[glib: 3/19] tests: Use g_assert_*() in param tests rather than g_assert()

[Emmanuele Bassi <ebassi src gnome org>]

commit c0e5c6c62c0ab7c569c2de9df16a13587f419aad
Author: Philip Withnall <withnall endlessm com>
Date:   Tue Nov 12 18:34:50 2019 +0000

    tests: Use g_assert_*() in param tests rather than g_assert()
    
    It provides more useful output on failure, and isn’t compiled out when
    building with `G_DISABLE_ASSERT`.
    
    Signed-off-by: Philip Withnall <withnall endlessm com>

 gobject/tests/param.c | 70 +++++++++++++++++++++++++--------------------------
 1 file changed, 35 insertions(+), 35 deletions(-)
---
diff --git a/gobject/tests/param.c b/gobject/tests/param.c
index 466e7bfe9..d7b5c5b92 100644
--- a/gobject/tests/param.c
+++ b/gobject/tests/param.c
@@ -10,19 +10,19 @@ test_param_value (void)
   GValue value = G_VALUE_INIT;
 
   g_value_init (&value, G_TYPE_PARAM);
-  g_assert (G_VALUE_HOLDS_PARAM (&value));
+  g_assert_true (G_VALUE_HOLDS_PARAM (&value));
 
   p = g_param_spec_int ("my-int", "My Int", "Blurb", 0, 20, 10, G_PARAM_READWRITE);
 
   g_value_take_param (&value, p);
   p2 = g_value_get_param (&value);
-  g_assert (p2 == p);
+  g_assert_true (p2 == p);
 
   pp = g_param_spec_uint ("my-uint", "My UInt", "Blurb", 0, 10, 5, G_PARAM_READWRITE);
   g_value_set_param (&value, pp);
 
   p2 = g_value_dup_param (&value);
-  g_assert (p2 == pp); /* param specs use ref/unref for copy/free */
+  g_assert_true (p2 == pp); /* param specs use ref/unref for copy/free */
   g_param_spec_unref (p2);
 
   g_value_unset (&value);
@@ -57,7 +57,7 @@ test_param_qdata (void)
   g_assert_cmpint (destroy_count, ==, 1);
   g_assert_cmpstr (g_param_spec_steal_qdata (p, q), ==, "blabla");
   g_assert_cmpint (destroy_count, ==, 1);
-  g_assert (g_param_spec_get_qdata (p, q) == NULL);
+  g_assert_null (g_param_spec_get_qdata (p, q));
 
   g_param_spec_ref_sink (p);
 
@@ -74,12 +74,12 @@ test_param_validate (void)
 
   g_value_init (&value, G_TYPE_INT);
   g_value_set_int (&value, 100);
-  g_assert (!g_param_value_defaults (p, &value));
-  g_assert (g_param_value_validate (p, &value));
+  g_assert_false (g_param_value_defaults (p, &value));
+  g_assert_true (g_param_value_validate (p, &value));
   g_assert_cmpint (g_value_get_int (&value), ==, 20);
 
   g_param_value_set_default (p, &value);
-  g_assert (g_param_value_defaults (p, &value));
+  g_assert_true (g_param_value_defaults (p, &value));
   g_assert_cmpint (g_value_get_int (&value), ==, 10);
 
   g_param_spec_unref (p);
@@ -104,7 +104,7 @@ test_param_strings (void)
 
   g_assert_cmpstr (g_param_spec_get_name (p), ==, "my-int");
   g_assert_cmpstr (g_param_spec_get_nick (p), ==, "my-int");
-  g_assert (g_param_spec_get_blurb (p) == NULL);
+  g_assert_null (g_param_spec_get_blurb (p));
 
   g_param_spec_unref (p);
 }
@@ -123,10 +123,10 @@ test_param_convert (void)
   g_value_init (&v2, G_TYPE_INT);
   g_value_set_int (&v2, -4);
 
-  g_assert (!g_param_value_convert (p, &v1, &v2, TRUE));
+  g_assert_false (g_param_value_convert (p, &v1, &v2, TRUE));
   g_assert_cmpint (g_value_get_int (&v2), ==, -4);
 
-  g_assert (g_param_value_convert (p, &v1, &v2, FALSE));
+  g_assert_true (g_param_value_convert (p, &v1, &v2, FALSE));
   g_assert_cmpint (g_value_get_int (&v2), ==, 20);
 
   g_param_spec_unref (p);
@@ -139,11 +139,11 @@ test_value_transform (void)
   GValue dest = G_VALUE_INIT;
 
 #define CHECK_INT_CONVERSION(type, getter, value)                       \
-  g_assert (g_value_type_transformable (G_TYPE_INT, type));             \
+  g_assert_true (g_value_type_transformable (G_TYPE_INT, type));        \
   g_value_init (&src, G_TYPE_INT);                                      \
   g_value_init (&dest, type);                                           \
   g_value_set_int (&src, value);                                        \
-  g_assert (g_value_transform (&src, &dest));                           \
+  g_assert_true (g_value_transform (&src, &dest));                      \
   g_assert_cmpint (g_value_get_##getter (&dest), ==, value);            \
   g_value_unset (&src);                                                 \
   g_value_unset (&dest);
@@ -171,11 +171,11 @@ test_value_transform (void)
   CHECK_INT_CONVERSION(G_TYPE_DOUBLE, double, 12345678)
 
 #define CHECK_UINT_CONVERSION(type, getter, value)                      \
-  g_assert (g_value_type_transformable (G_TYPE_UINT, type));            \
+  g_assert_true (g_value_type_transformable (G_TYPE_UINT, type));       \
   g_value_init (&src, G_TYPE_UINT);                                     \
   g_value_init (&dest, type);                                           \
   g_value_set_uint (&src, value);                                       \
-  g_assert (g_value_transform (&src, &dest));                           \
+  g_assert_true (g_value_transform (&src, &dest));                      \
   g_assert_cmpuint (g_value_get_##getter (&dest), ==, value);           \
   g_value_unset (&src);                                                 \
   g_value_unset (&dest);
@@ -196,11 +196,11 @@ test_value_transform (void)
   CHECK_UINT_CONVERSION(G_TYPE_DOUBLE, double, 12345678)
 
 #define CHECK_LONG_CONVERSION(type, getter, value)                      \
-  g_assert (g_value_type_transformable (G_TYPE_LONG, type));            \
+  g_assert_true (g_value_type_transformable (G_TYPE_LONG, type));       \
   g_value_init (&src, G_TYPE_LONG);                                     \
   g_value_init (&dest, type);                                           \
   g_value_set_long (&src, value);                                       \
-  g_assert (g_value_transform (&src, &dest));                           \
+  g_assert_true (g_value_transform (&src, &dest));                      \
   g_assert_cmpint (g_value_get_##getter (&dest), ==, value);            \
   g_value_unset (&src);                                                 \
   g_value_unset (&dest);
@@ -221,11 +221,11 @@ test_value_transform (void)
   CHECK_LONG_CONVERSION(G_TYPE_DOUBLE, double, 12345678)
 
 #define CHECK_ULONG_CONVERSION(type, getter, value)                     \
-  g_assert (g_value_type_transformable (G_TYPE_ULONG, type));           \
+  g_assert_true (g_value_type_transformable (G_TYPE_ULONG, type));      \
   g_value_init (&src, G_TYPE_ULONG);                                    \
   g_value_init (&dest, type);                                           \
   g_value_set_ulong (&src, value);                                      \
-  g_assert (g_value_transform (&src, &dest));                           \
+  g_assert_true (g_value_transform (&src, &dest));                      \
   g_assert_cmpuint (g_value_get_##getter (&dest), ==, value);           \
   g_value_unset (&src);                                                 \
   g_value_unset (&dest);
@@ -246,11 +246,11 @@ test_value_transform (void)
   CHECK_ULONG_CONVERSION(G_TYPE_DOUBLE, double, 12345678)
 
 #define CHECK_INT64_CONVERSION(type, getter, value)                     \
-  g_assert (g_value_type_transformable (G_TYPE_INT64, type));           \
+  g_assert_true (g_value_type_transformable (G_TYPE_INT64, type));      \
   g_value_init (&src, G_TYPE_INT64);                                    \
   g_value_init (&dest, type);                                           \
   g_value_set_int64 (&src, value);                                      \
-  g_assert (g_value_transform (&src, &dest));                           \
+  g_assert_true (g_value_transform (&src, &dest));                      \
   g_assert_cmpint (g_value_get_##getter (&dest), ==, value);            \
   g_value_unset (&src);                                                 \
   g_value_unset (&dest);
@@ -271,11 +271,11 @@ test_value_transform (void)
   CHECK_INT64_CONVERSION(G_TYPE_DOUBLE, double, 12345678)
 
 #define CHECK_UINT64_CONVERSION(type, getter, value)                    \
-  g_assert (g_value_type_transformable (G_TYPE_UINT64, type));          \
+  g_assert_true (g_value_type_transformable (G_TYPE_UINT64, type));     \
   g_value_init (&src, G_TYPE_UINT64);                                   \
   g_value_init (&dest, type);                                           \
   g_value_set_uint64 (&src, value);                                     \
-  g_assert (g_value_transform (&src, &dest));                           \
+  g_assert_true (g_value_transform (&src, &dest));                      \
   g_assert_cmpuint (g_value_get_##getter (&dest), ==, value);           \
   g_value_unset (&src);                                                 \
   g_value_unset (&dest);
@@ -296,11 +296,11 @@ test_value_transform (void)
   CHECK_UINT64_CONVERSION(G_TYPE_DOUBLE, double, 12345678)
 
 #define CHECK_FLOAT_CONVERSION(type, getter, value)                    \
-  g_assert (g_value_type_transformable (G_TYPE_FLOAT, type));          \
+  g_assert_true (g_value_type_transformable (G_TYPE_FLOAT, type));     \
   g_value_init (&src, G_TYPE_FLOAT);                                   \
   g_value_init (&dest, type);                                          \
   g_value_set_float (&src, value);                                     \
-  g_assert (g_value_transform (&src, &dest));                          \
+  g_assert_true (g_value_transform (&src, &dest));                     \
   g_assert_cmpfloat (g_value_get_##getter (&dest), ==, value);         \
   g_value_unset (&src);                                                \
   g_value_unset (&dest);
@@ -321,11 +321,11 @@ test_value_transform (void)
   CHECK_FLOAT_CONVERSION(G_TYPE_DOUBLE, double, 12345678)
 
 #define CHECK_DOUBLE_CONVERSION(type, getter, value)                    \
-  g_assert (g_value_type_transformable (G_TYPE_DOUBLE, type));          \
+  g_assert_true (g_value_type_transformable (G_TYPE_DOUBLE, type));     \
   g_value_init (&src, G_TYPE_DOUBLE);                                   \
   g_value_init (&dest, type);                                           \
   g_value_set_double (&src, value);                                     \
-  g_assert (g_value_transform (&src, &dest));                           \
+  g_assert_true (g_value_transform (&src, &dest));                      \
   g_assert_cmpfloat (g_value_get_##getter (&dest), ==, value);          \
   g_value_unset (&src);                                                 \
   g_value_unset (&dest);
@@ -346,14 +346,14 @@ test_value_transform (void)
   CHECK_DOUBLE_CONVERSION(G_TYPE_DOUBLE, double, 12345678)
 
 #define CHECK_BOOLEAN_CONVERSION(type, setter, value)                   \
-  g_assert (g_value_type_transformable (type, G_TYPE_BOOLEAN));         \
+  g_assert_true (g_value_type_transformable (type, G_TYPE_BOOLEAN));    \
   g_value_init (&src, type);                                            \
   g_value_init (&dest, G_TYPE_BOOLEAN);                                 \
   g_value_set_##setter (&src, value);                                   \
-  g_assert (g_value_transform (&src, &dest));                           \
+  g_assert_true (g_value_transform (&src, &dest));                      \
   g_assert_cmpint (g_value_get_boolean (&dest), ==, TRUE);              \
   g_value_set_##setter (&src, 0);                                       \
-  g_assert (g_value_transform (&src, &dest));                           \
+  g_assert_true (g_value_transform (&src, &dest));                      \
   g_assert_cmpint (g_value_get_boolean (&dest), ==, FALSE);             \
   g_value_unset (&src);                                                 \
   g_value_unset (&dest);
@@ -366,11 +366,11 @@ test_value_transform (void)
   CHECK_BOOLEAN_CONVERSION(G_TYPE_UINT64, uint64, 12345678)
 
 #define CHECK_STRING_CONVERSION(int_type, setter, int_value)            \
-  g_assert (g_value_type_transformable (int_type, G_TYPE_STRING));      \
+  g_assert_true (g_value_type_transformable (int_type, G_TYPE_STRING)); \
   g_value_init (&src, int_type);                                        \
   g_value_init (&dest, G_TYPE_STRING);                                  \
   g_value_set_##setter (&src, int_value);                               \
-  g_assert (g_value_transform (&src, &dest));                           \
+  g_assert_true (g_value_transform (&src, &dest));                      \
   g_assert_cmpstr (g_value_get_string (&dest), ==, #int_value);         \
   g_value_unset (&src);                                                 \
   g_value_unset (&dest);
@@ -384,12 +384,12 @@ test_value_transform (void)
   CHECK_STRING_CONVERSION(G_TYPE_FLOAT, float, 0.500000)
   CHECK_STRING_CONVERSION(G_TYPE_DOUBLE, double, -1.234567)
 
-  g_assert (!g_value_type_transformable (G_TYPE_STRING, G_TYPE_CHAR));
+  g_assert_false (g_value_type_transformable (G_TYPE_STRING, G_TYPE_CHAR));
   g_value_init (&src, G_TYPE_STRING);
   g_value_init (&dest, G_TYPE_CHAR);
   g_value_set_static_string (&src, "bla");
   g_value_set_schar (&dest, 'c');
-  g_assert (!g_value_transform (&src, &dest));
+  g_assert_false (g_value_transform (&src, &dest));
   g_assert_cmpint (g_value_get_schar (&dest), ==, 'c');
   g_value_unset (&src);
   g_value_unset (&dest);
@@ -757,7 +757,7 @@ test_param_implement (void)
               {
               case 0:
                 /* make sure the other table agrees */
-                g_assert (valid_impl_types[change_this_type * 16 + change_this_flag][use_this_type] == 0);
+                g_assert_cmpint (valid_impl_types[change_this_type * 16 + change_this_flag][use_this_type], 
==, 0);
                 g_test_trap_assert_failed ();
                 g_test_trap_assert_stderr ("*Interface property does not exist*");
                 continue;
@@ -820,7 +820,7 @@ test_param_default (void)
   param = g_param_spec_int ("my-int", "My Int", "Blurb", 0, 20, 10, G_PARAM_READWRITE);
   def = g_param_spec_get_default_value (param);
 
-  g_assert (G_VALUE_HOLDS (def, G_TYPE_INT));
+  g_assert_true (G_VALUE_HOLDS (def, G_TYPE_INT));
   g_assert_cmpint (g_value_get_int (def), ==, 10);
 
   g_param_spec_unref (param);