Replace g_return_if_fail() and g_return_val_if_fail() by ASSERT_TRUE and EXPECT_TRUE

libgnucash/engine/mocks/gmock-Account.cpp

@@ -26,37 +26,46 @@ gnc_mock_account_class_init(MockAccountClass *klass)
 void
 xaccAccountBeginEdit (Account *account)
 {
-    g_return_if_fail(GNC_IS_MOCK_ACCOUNT(account));
+    ASSERT_TRUE(GNC_IS_MOCK_ACCOUNT(account));
     ((MockAccount*)account)->beginEdit();
 }
 
 void
 xaccAccountCommitEdit (Account *account)
 {
-    g_return_if_fail(GNC_IS_MOCK_ACCOUNT(account));
+    ASSERT_TRUE(GNC_IS_MOCK_ACCOUNT(account));
     ((MockAccount*)account)->commitEdit();
 }
 
 QofBook *
 gnc_account_get_book(const Account *account)
 {
-    g_return_val_if_fail(GNC_IS_MOCK_ACCOUNT(account), NULL);
-    return ((MockAccount*)account)->getBook();
+    EXPECT_TRUE(GNC_IS_MOCK_ACCOUNT(account));
+    if (GNC_IS_MOCK_ACCOUNT(account))
+        return ((MockAccount*)account)->getBook();
+    else
+        return nullptr;
 }
 
 gint
 xaccAccountForEachTransaction(const Account *acc, TransactionCallback proc,
                               void *data)
 {
-    g_return_val_if_fail(GNC_IS_MOCK_ACCOUNT(acc), 0);
-    return ((MockAccount*)acc)->forEachTransaction(proc, data);
+    EXPECT_TRUE(GNC_IS_MOCK_ACCOUNT(acc));
+    if (GNC_IS_MOCK_ACCOUNT(acc))
+        return ((MockAccount*)acc)->forEachTransaction(proc, data);
+    else
+        return 0;
 }
 
 GncImportMatchMap *
 gnc_account_imap_create_imap (Account *acc)
 {
-    g_return_val_if_fail(GNC_IS_MOCK_ACCOUNT(acc), NULL);
-    return ((MockAccount*)acc)->imapCreateImap();
+    EXPECT_TRUE(GNC_IS_MOCK_ACCOUNT(acc));
+    if (GNC_IS_MOCK_ACCOUNT(acc))
+        return ((MockAccount*)acc)->imapCreateImap();
+    else
+        return nullptr;
 }
 
 Account*

libgnucash/engine/mocks/gmock-Split.cpp

@@ -30,113 +30,143 @@ gnc_mock_split_class_init (MockSplitClass *klass)
 Split *
 xaccMallocSplit (QofBook *book)
 {
-    g_return_val_if_fail(QOF_IS_MOCK_BOOK(book), NULL);
-    return ((QofMockBook*)book)->mallocSplit();
+    EXPECT_TRUE(QOF_IS_MOCK_BOOK(book));
+    if (QOF_IS_MOCK_BOOK(book))
+        return ((QofMockBook*)book)->mallocSplit();
+    else
+        return nullptr;
 }
 
 QofBook *
 xaccSplitGetBook (const Split *split)
 {
-    g_return_val_if_fail(GNC_IS_MOCK_SPLIT(split), NULL);
-    return ((MockSplit*)split)->getBook();
+    EXPECT_TRUE(GNC_IS_MOCK_SPLIT(split));
+    if (GNC_IS_MOCK_SPLIT(split))
+        return ((MockSplit*)split)->getBook();
+    else
+        return nullptr;
 }
 
 Account *
 xaccSplitGetAccount (const Split *split)
 {
-    g_return_val_if_fail(GNC_IS_MOCK_SPLIT(split), NULL);
-    return ((MockSplit*)split)->getAccount();
+    EXPECT_TRUE(GNC_IS_MOCK_SPLIT(split));
+    if (GNC_IS_MOCK_SPLIT(split))
+        return ((MockSplit*)split)->getAccount();
+    else
+        return nullptr;
 }
 
 void
 xaccSplitSetAccount (Split *split, Account *acc)
 {
-    g_return_if_fail(GNC_IS_MOCK_SPLIT(split));
-    g_return_if_fail(GNC_IS_MOCK_ACCOUNT(acc));
+    ASSERT_TRUE(GNC_IS_MOCK_SPLIT(split));
+    ASSERT_TRUE(GNC_IS_MOCK_ACCOUNT(acc));
     ((MockSplit*)split)->setAccount(acc);
 }
 
 gnc_numeric
 xaccSplitGetAmount (const Split *split)
 {
-    g_return_val_if_fail(GNC_IS_MOCK_SPLIT(split), gnc_numeric_zero());
-    return ((MockSplit*)split)->getAmount();
+    EXPECT_TRUE(GNC_IS_MOCK_SPLIT(split));
+    if (GNC_IS_MOCK_SPLIT(split))
+        return ((MockSplit*)split)->getAmount();
+    else
+        return gnc_numeric_zero();
 }
 
 void
 xaccSplitSetAmount (Split *split, gnc_numeric amt)
 {
-    g_return_if_fail(GNC_IS_MOCK_SPLIT(split));
+    ASSERT_TRUE(GNC_IS_MOCK_SPLIT(split));
     ((MockSplit*)split)->setAmount(amt);
 }
 
 gnc_numeric
 xaccSplitGetValue (const Split *split)
 {
-    g_return_val_if_fail(GNC_IS_MOCK_SPLIT(split), gnc_numeric_zero());
-    return ((MockSplit*)split)->getValue();
+    EXPECT_TRUE(GNC_IS_MOCK_SPLIT(split));
+    if (GNC_IS_MOCK_SPLIT(split))
+        return ((MockSplit*)split)->getValue();
+    else
+        return gnc_numeric_zero();
 }
 
 void
 xaccSplitSetValue (Split *split, gnc_numeric val)
 {
-    g_return_if_fail(GNC_IS_MOCK_SPLIT(split));
+    ASSERT_TRUE(GNC_IS_MOCK_SPLIT(split));
     ((MockSplit*)split)->setValue(val);
 }
 
 const char *
 xaccSplitGetMemo (const Split *split)
 {
-    g_return_val_if_fail(GNC_IS_MOCK_SPLIT(split), NULL);
-    return ((MockSplit*)split)->getMemo();
+    EXPECT_TRUE(GNC_IS_MOCK_SPLIT(split));
+    if (GNC_IS_MOCK_SPLIT(split))
+        return ((MockSplit*)split)->getMemo();
+    else
+        return nullptr;
 }
 
 char
 xaccSplitGetReconcile (const Split *split)
 {
-    g_return_val_if_fail(GNC_IS_MOCK_SPLIT(split), VREC);
-    return ((MockSplit*)split)->getReconcile();
+    EXPECT_TRUE(GNC_IS_MOCK_SPLIT(split));
+    if (GNC_IS_MOCK_SPLIT(split))
+        return ((MockSplit*)split)->getReconcile();
+    else
+        return VREC;
 }
 
 void
 xaccSplitSetReconcile (Split *split, char recn)
 {
-    g_return_if_fail(GNC_IS_MOCK_SPLIT(split));
+    ASSERT_TRUE(GNC_IS_MOCK_SPLIT(split));
     ((MockSplit*)split)->setReconcile(recn);
 }
 
 void
 xaccSplitSetDateReconciledSecs (Split *split, time64 secs)
 {
-    g_return_if_fail(GNC_IS_MOCK_SPLIT(split));
+    ASSERT_TRUE(GNC_IS_MOCK_SPLIT(split));
     ((MockSplit*)split)->setDateReconciledSecs(secs);
 }
 
 const char *
 xaccSplitGetAction (const Split *split)
 {
-    g_return_val_if_fail(GNC_IS_MOCK_SPLIT(split), NULL);
-    return ((MockSplit*)split)->getAction();
+    EXPECT_TRUE(GNC_IS_MOCK_SPLIT(split));
+    if (GNC_IS_MOCK_SPLIT(split))
+        return ((MockSplit*)split)->getAction();
+    else
+        return nullptr;
 }
 
 Split *
 xaccSplitGetOtherSplit (const Split *split)
 {
-    g_return_val_if_fail(GNC_IS_MOCK_SPLIT(split), NULL);
-    return ((MockSplit*)split)->getOtherSplit();
+    EXPECT_TRUE(GNC_IS_MOCK_SPLIT(split));
+    if (GNC_IS_MOCK_SPLIT(split))
+        return ((MockSplit*)split)->getOtherSplit();
+    else
+        return nullptr;
 }
 
 Transaction *
 xaccSplitGetParent (const Split *split)
 {
-    g_return_val_if_fail(GNC_IS_MOCK_SPLIT(split), NULL);
-    return ((MockSplit*)split)->getParent();
+    EXPECT_TRUE(GNC_IS_MOCK_SPLIT(split));
+    if (GNC_IS_MOCK_SPLIT(split))
+        return ((MockSplit*)split)->getParent();
+    else
+        return nullptr;
 }
 
 void
 xaccSplitSetParent(Split *split, Transaction *trans)
 {
-    g_return_if_fail(GNC_IS_MOCK_SPLIT(split));
-    g_return_if_fail(GNC_IS_MOCK_TRANSACTION(trans));
+    ASSERT_TRUE(GNC_IS_MOCK_SPLIT(split));
+    ASSERT_TRUE(GNC_IS_MOCK_TRANSACTION(trans));
     ((MockSplit*)split)->setParent(trans);
 }

libgnucash/engine/mocks/gmock-Transaction.cpp

@@ -28,98 +28,122 @@ gnc_mock_transaction_class_init(MockTransactionClass *klass)
 void
 xaccTransBeginEdit (Transaction *trans)
 {
-    g_return_if_fail(GNC_IS_MOCK_TRANSACTION(trans));
+    ASSERT_TRUE(GNC_IS_MOCK_TRANSACTION(trans));
     ((MockTransaction*)trans)->beginEdit();
 }
 
 void
 xaccTransCommitEdit (Transaction *trans)
 {
-    g_return_if_fail(GNC_IS_MOCK_TRANSACTION(trans));
+    ASSERT_TRUE(GNC_IS_MOCK_TRANSACTION(trans));
     ((MockTransaction*)trans)->commitEdit();
 }
 
 Split *
 xaccTransGetSplit (const Transaction *trans, int i)
 {
-    g_return_val_if_fail(GNC_IS_MOCK_TRANSACTION(trans), NULL);
-    return ((MockTransaction*)trans)->getSplit(i);
+    EXPECT_TRUE(GNC_IS_MOCK_TRANSACTION(trans));
+    if (GNC_IS_MOCK_TRANSACTION(trans))
+        return ((MockTransaction*)trans)->getSplit(i);
+    else
+        return nullptr;
 }
 
 Split *
 xaccTransFindSplitByAccount(const Transaction *trans, const Account *acc)
 {
-    g_return_val_if_fail(GNC_IS_MOCK_TRANSACTION(trans), NULL);
-    g_return_val_if_fail(GNC_IS_MOCK_ACCOUNT(acc), NULL);
-    return ((MockTransaction*)trans)->findSplitByAccount(acc);
+    EXPECT_TRUE(GNC_IS_MOCK_TRANSACTION(trans));
+    EXPECT_TRUE(GNC_IS_MOCK_ACCOUNT(acc));
+    if (GNC_IS_MOCK_TRANSACTION(trans))
+        return ((MockTransaction*)trans)->findSplitByAccount(acc);
+    else
+        return nullptr;
 }
 
 time64
 xaccTransGetDate (const Transaction *trans)
 {
-    g_return_val_if_fail(GNC_IS_MOCK_TRANSACTION(trans), 0);
-    return ((MockTransaction*)trans)->getDate();
+    EXPECT_TRUE(GNC_IS_MOCK_TRANSACTION(trans));
+    if (GNC_IS_MOCK_TRANSACTION(trans))
+        return ((MockTransaction*)trans)->getDate();
+    else
+        return 0;
 }
 
 void
 xaccTransSetDatePostedSecsNormalized (Transaction *trans, time64 time)
 {
-    g_return_if_fail(GNC_IS_MOCK_TRANSACTION(trans));
+    ASSERT_TRUE(GNC_IS_MOCK_TRANSACTION(trans));
     ((MockTransaction*)trans)->setDatePostedSecsNormalized(time);
 }
 
 const char *
 xaccTransGetDescription (const Transaction *trans)
 {
-    g_return_val_if_fail(GNC_IS_MOCK_TRANSACTION(trans), NULL);
-    return ((MockTransaction*)trans)->getDescription();
+    EXPECT_TRUE(GNC_IS_MOCK_TRANSACTION(trans));
+    if (GNC_IS_MOCK_TRANSACTION(trans))
+        return ((MockTransaction*)trans)->getDescription();
+    else
+        return nullptr;
 }
 
 void
 xaccTransSetDescription (Transaction *trans, const char *desc)
 {
-    g_return_if_fail(GNC_IS_MOCK_TRANSACTION(trans));
+    ASSERT_TRUE(GNC_IS_MOCK_TRANSACTION(trans));
     ((MockTransaction*)trans)->setDescription(desc);
 }
 
 const char *
 xaccTransGetNotes (const Transaction *trans)
 {
-    g_return_val_if_fail(GNC_IS_MOCK_TRANSACTION(trans), NULL);
-    return ((MockTransaction*)trans)->getNotes();
+    EXPECT_TRUE(GNC_IS_MOCK_TRANSACTION(trans));
+    if (GNC_IS_MOCK_TRANSACTION(trans))
+        return ((MockTransaction*)trans)->getNotes();
+    else
+        return nullptr;
 }
 
 void
 xaccTransSetNotes (Transaction *trans, const char *notes)
 {
-    g_return_if_fail(GNC_IS_MOCK_TRANSACTION(trans));
+    ASSERT_TRUE(GNC_IS_MOCK_TRANSACTION(trans));
     ((MockTransaction*)trans)->setDescription(notes);
 }
 
 gnc_numeric
 xaccTransGetImbalanceValue (const Transaction * trans)
 {
-    g_return_val_if_fail(GNC_IS_MOCK_TRANSACTION(trans), gnc_numeric_zero());
-    return ((MockTransaction*)trans)->getImbalanceValue();
+    EXPECT_TRUE(GNC_IS_MOCK_TRANSACTION(trans));
+    if (GNC_IS_MOCK_TRANSACTION(trans))
+        return ((MockTransaction*)trans)->getImbalanceValue();
+    else
+        return gnc_numeric_zero();
 }
 
 const char *
 xaccTransGetNum (const Transaction *trans)
 {
-    g_return_val_if_fail(GNC_IS_MOCK_TRANSACTION(trans), NULL);
-    return ((MockTransaction*)trans)->getNum();
+    EXPECT_TRUE(GNC_IS_MOCK_TRANSACTION(trans));
+    if (GNC_IS_MOCK_TRANSACTION(trans))
+        return ((MockTransaction*)trans)->getNum();
+    else
+        return nullptr;
 }
 
 gboolean
 xaccTransIsOpen (const Transaction *trans)
 {
-    g_return_val_if_fail(GNC_IS_MOCK_TRANSACTION(trans), FALSE);
-    return ((MockTransaction*)trans)->isOpen();
+    EXPECT_TRUE(GNC_IS_MOCK_TRANSACTION(trans));
+    if (GNC_IS_MOCK_TRANSACTION(trans))
+        return ((MockTransaction*)trans)->isOpen();
+    else
+        return FALSE;
 }
 
 void
 xaccTransDestroy (Transaction *trans)
 {
-    g_return_if_fail(GNC_IS_MOCK_TRANSACTION(trans));
+    ASSERT_TRUE(GNC_IS_MOCK_TRANSACTION(trans));
     ((MockTransaction*)trans)->destroy();
 }

libgnucash/engine/mocks/gmock-qofinstance.cpp

@@ -1,5 +1,7 @@
 #include <glib.h>
 
+#include <gmock/gmock.h>
+
 extern "C"
 {
 #include <qofinstance.h>
@@ -26,7 +28,7 @@ void
 qof_instance_get (const QofInstance *inst, const gchar *first_prop, ...)
 {
     va_list ap;
-    g_return_if_fail (QOF_IS_INSTANCE (inst));
+    ASSERT_TRUE (QOF_IS_INSTANCE (inst));
 
     va_start (ap, first_prop);
     g_object_get_valist (G_OBJECT (inst), first_prop, ap);
@@ -39,7 +41,7 @@ void
 qof_instance_set (QofInstance *inst, const gchar *first_prop, ...)
 {
     va_list ap;
-    g_return_if_fail (QOF_IS_INSTANCE (inst));
+    ASSERT_TRUE (QOF_IS_INSTANCE (inst));
 
     va_start (ap, first_prop);
     g_object_set_valist (G_OBJECT (inst), first_prop, ap);

libgnucash/engine/mocks/gmock-qofquery.cpp

@@ -23,7 +23,7 @@ qof_query_create_for (QofIdTypeConst obj_type)
 void
 qof_query_set_book (QofQuery *query, QofBook *book)
 {
-    g_return_if_fail(QOF_IS_MOCK_BOOK(book));
+    ASSERT_TRUE(QOF_IS_MOCK_BOOK(book));
     ((QofMockQuery*)query)->setBook(book);
 }