Merge branch 'feature/drop_raw_g_assert' into 'master'json-glib-1-6

Drop usage of raw g_assert in reader test in favor of g_assert_*()

See merge request GNOME/json-glib!54

14 files changed, 164 insertions, 163 deletions

diff --git a/json-glib/tests/array.c b/json-glib/tests/array.c
index 426cd72..5406916 100644
--- a/json-glib/tests/array.c
+++ b/json-glib/tests/array.c
@@ -6,7 +6,7 @@ test_empty_array (void)
   JsonArray *array = json_array_new ();
 
   g_assert_cmpint (json_array_get_length (array), ==, 0);
-  g_assert (json_array_get_elements (array) == NULL);
+  g_assert_null (json_array_get_elements (array));
 
   json_array_unref (array);
 }
@@ -24,7 +24,7 @@ test_add_element (void)
 
   node = json_array_get_element (array, 0);
   g_assert_cmpint (JSON_NODE_TYPE (node), ==, JSON_NODE_NULL);
-  g_assert (json_array_get_null_element (array, 0));
+  g_assert_true (json_array_get_null_element (array, 0));
 
   json_array_add_int_element (array, 42);
   g_assert_cmpint (json_array_get_length (array), ==, 2);
@@ -36,7 +36,7 @@ test_add_element (void)
 
   json_array_add_boolean_element (array, TRUE);
   g_assert_cmpint (json_array_get_length (array), ==, 4);
-  g_assert (json_array_get_boolean_element (array, 3));
+  g_assert_true (json_array_get_boolean_element (array, 3));
 
   json_array_add_string_element (array, "Hello");
   g_assert_cmpint (json_array_get_length (array), ==, 5);
@@ -44,20 +44,20 @@ test_add_element (void)
 
   json_array_add_string_element (array, NULL);
   g_assert_cmpint (json_array_get_length (array), ==, 6);
-  g_assert (json_array_get_string_element (array, 5) == NULL);
-  g_assert (json_array_get_element (array, 5) != NULL);
-  g_assert (json_array_get_null_element (array, 5));
+  g_assert_null (json_array_get_string_element (array, 5));
+  g_assert_nonnull (json_array_get_element (array, 5));
+  g_assert_true (json_array_get_null_element (array, 5));
 
   json_array_add_array_element (array, NULL);
-  g_assert (json_array_get_array_element (array, 6) == NULL);
-  g_assert (json_array_get_null_element (array, 6));
+  g_assert_null (json_array_get_array_element (array, 6));
+  g_assert_true (json_array_get_null_element (array, 6));
 
   json_array_add_object_element (array, json_object_new ());
-  g_assert (json_array_get_object_element (array, 7) != NULL);
+  g_assert_nonnull (json_array_get_object_element (array, 7));
 
   json_array_add_object_element (array, NULL);
-  g_assert (json_array_get_object_element (array, 8) == NULL);
-  g_assert (json_array_get_null_element (array, 8));
+  g_assert_null (json_array_get_object_element (array, 8));
+  g_assert_true (json_array_get_null_element (array, 8));
 
   json_array_unref (array);
 }
@@ -101,9 +101,9 @@ verify_foreach (JsonArray *array,
 {
   TestForeachFixture *fixture = user_data;
 
-  g_assert (g_list_find (fixture->elements, element_node));
-  g_assert (json_node_get_node_type (element_node) == type_verify[index_].element_type);
-  g_assert (json_node_get_value_type (element_node) == type_verify[index_].element_gtype);
+  g_assert_nonnull (g_list_find (fixture->elements, element_node));
+  g_assert_true (json_node_get_node_type (element_node) == type_verify[index_].element_type);
+  g_assert_true (json_node_get_value_type (element_node) == type_verify[index_].element_gtype);
 
   fixture->iterations += 1;
 }
@@ -120,7 +120,7 @@ test_foreach_element (void)
   json_array_add_null_element (array);
 
   fixture.elements = json_array_get_elements (array);
-  g_assert (fixture.elements != NULL);
+  g_assert_nonnull (fixture.elements);
 
   fixture.n_elements = json_array_get_length (array);
   g_assert_cmpint (fixture.n_elements, ==, g_list_length (fixture.elements));
diff --git a/json-glib/tests/boxed.c b/json-glib/tests/boxed.c
index 6e52e2a..e9facff 100644
--- a/json-glib/tests/boxed.c
+++ b/json-glib/tests/boxed.c
@@ -243,9 +243,9 @@ test_deserialize_boxed (void)
   GObject *obj;
 
   obj = json_gobject_from_data (TEST_TYPE_OBJECT, serialize_data, -1, NULL);
-  g_assert (TEST_IS_OBJECT (obj));
+  g_assert_true (TEST_IS_OBJECT (obj));
   g_assert_cmpint (TEST_OBJECT (obj)->blah.foo, ==, 42);
-  g_assert (TEST_OBJECT (obj)->blah.bar);
+  g_assert_true (TEST_OBJECT (obj)->blah.bar);
 
   g_object_unref (obj);
 }
diff --git a/json-glib/tests/builder.c b/json-glib/tests/builder.c
index b3e07d6..42569d7 100644
--- a/json-glib/tests/builder.c
+++ b/json-glib/tests/builder.c
@@ -134,7 +134,7 @@ test_builder_reset (void)
   node = json_builder_get_root (builder);
   json_generator_set_root (generator, node);
   data = json_generator_to_data (generator, &length);
-  g_assert (strncmp (data, reset_object, length) == 0);
+  g_assert_true (strncmp (data, reset_object, length) == 0);
 
   g_free (data);
   json_node_free (node);
@@ -148,7 +148,7 @@ test_builder_reset (void)
   node = json_builder_get_root (builder);
   json_generator_set_root (generator, node);
   data = json_generator_to_data (generator, &length);
-  g_assert (strncmp (data, reset_array, length) == 0);
+  g_assert_true (strncmp (data, reset_array, length) == 0);
 
   g_free (data);
   json_node_free (node);
diff --git a/json-glib/tests/generator.c b/json-glib/tests/generator.c
index 84995f8..833d8fc 100644
--- a/json-glib/tests/generator.c
+++ b/json-glib/tests/generator.c
@@ -84,7 +84,7 @@ test_empty_array (void)
   g_assert_cmpint (len, ==, strlen (empty_array));
   g_assert_cmpstr (data, ==, empty_array);
 
-  g_assert (json_generator_get_pretty (gen) == FALSE);
+  g_assert_false (json_generator_get_pretty (gen));
   g_assert_cmpint (json_generator_get_indent (gen), ==, 0);
   g_assert_cmpint (json_generator_get_indent_char (gen), ==, ' ');
 
@@ -319,12 +319,12 @@ test_decimal_separator (void)
                  json_node_get_double (node),
                  str);
 
-      g_assert (str != NULL);
+      g_assert_nonnull (str);
       expected = strstr (str, decimal_separator[i].sep);
       if (decimal_separator[i].matches)
-        g_assert (expected != NULL);
+        g_assert_nonnull (expected);
       else
-        g_assert (expected == NULL);
+        g_assert_null (expected);
 
       g_free (str);
    }
@@ -373,10 +373,10 @@ test_pretty (void)
       char *data;
       gsize len;
 
-      g_assert (json_parser_load_from_data (parser, pretty_examples[i], -1, NULL));
+      g_assert_true (json_parser_load_from_data (parser, pretty_examples[i], -1, NULL));
 
       root = json_parser_get_root (parser);
-      g_assert (root != NULL);
+      g_assert_nonnull (root);
 
       json_generator_set_root (generator, root);
 
diff --git a/json-glib/tests/gvariant.c b/json-glib/tests/gvariant.c
index e88b1b9..3f2bc13 100644
--- a/json-glib/tests/gvariant.c
+++ b/json-glib/tests/gvariant.c
@@ -176,7 +176,7 @@ test_gvariant_to_json (gconstpointer test_data)
                              NULL);
 
   json_data = json_gvariant_serialize_data (variant, &len);
-  g_assert (json_data != NULL);
+  g_assert_nonnull (json_data);
 
   g_assert_cmpstr (test_case->json_data, ==, json_data);
 
diff --git a/json-glib/tests/invalid.c b/json-glib/tests/invalid.c
index cb5f818..5197e9f 100644
--- a/json-glib/tests/invalid.c
+++ b/json-glib/tests/invalid.c
@@ -16,14 +16,14 @@ test_invalid_bareword (gconstpointer user_data)
   gboolean res;
 
   parser = json_parser_new ();
-  g_assert (JSON_IS_PARSER (parser));
+  g_assert_true (JSON_IS_PARSER (parser));
 
   if (g_test_verbose ())
     g_print ("invalid data: '%s'...", json);
 
   res = json_parser_load_from_data (parser, json, -1, &error);
 
-  g_assert (!res);
+  g_assert_false (res);
   g_assert_error (error, JSON_PARSER_ERROR, JSON_PARSER_ERROR_INVALID_BAREWORD);
 
   if (g_test_verbose ())
@@ -43,15 +43,15 @@ test_invalid_assignment (gconstpointer user_data)
   gboolean res;
 
   parser = json_parser_new ();
-  g_assert (JSON_IS_PARSER (parser));
+  g_assert_true (JSON_IS_PARSER (parser));
 
   if (g_test_verbose ())
     g_print ("invalid data: '%s'...", json);
 
   res = json_parser_load_from_data (parser, json, -1, &error);
 
-  g_assert (!res);
-  g_assert (error != NULL);
+  g_assert_false (res);
+  g_assert_nonnull (error);
 
   if (g_test_verbose ())
     g_print ("expected error: %s\n", error->message);
@@ -70,15 +70,15 @@ test_invalid_value (gconstpointer user_data)
   gboolean res;
 
   parser = json_parser_new ();
-  g_assert (JSON_IS_PARSER (parser));
+  g_assert_true (JSON_IS_PARSER (parser));
 
   if (g_test_verbose ())
     g_print ("invalid data: '%s'...", json);
 
   res = json_parser_load_from_data (parser, json, -1, &error);
 
-  g_assert (!res);
-  g_assert (error != NULL);
+  g_assert_false (res);
+  g_assert_nonnull (error);
 
   if (g_test_verbose ())
     g_print ("expected error: %s\n", error->message);
@@ -97,15 +97,15 @@ test_invalid_array (gconstpointer user_data)
   gboolean res;
 
   parser = json_parser_new ();
-  g_assert (JSON_IS_PARSER (parser));
+  g_assert_true (JSON_IS_PARSER (parser));
 
   if (g_test_verbose ())
     g_print ("invalid data: '%s'...", json);
 
   res = json_parser_load_from_data (parser, json, -1, &error);
 
-  g_assert (!res);
-  g_assert (error != NULL);
+  g_assert_false (res);
+  g_assert_nonnull (error);
 
   if (g_test_verbose ())
     g_print ("expected error: %s\n", error->message);
@@ -124,15 +124,15 @@ test_invalid_object (gconstpointer user_data)
   gboolean res;
 
   parser = json_parser_new ();
-  g_assert (JSON_IS_PARSER (parser));
+  g_assert_true (JSON_IS_PARSER (parser));
 
   if (g_test_verbose ())
     g_print ("invalid data: '%s'...", json);
 
   res = json_parser_load_from_data (parser, json, -1, &error);
 
-  g_assert (!res);
-  g_assert (error != NULL);
+  g_assert_false (res);
+  g_assert_nonnull (error);
 
   if (g_test_verbose ())
     g_print ("expected error: %s\n", error->message);
@@ -151,14 +151,14 @@ test_missing_comma (gconstpointer user_data)
   gboolean res;
 
   parser = json_parser_new ();
-  g_assert (JSON_IS_PARSER (parser));
+  g_assert_true (JSON_IS_PARSER (parser));
 
   if (g_test_verbose ())
     g_print ("invalid data: '%s'...", json);
 
   res = json_parser_load_from_data (parser, json, -1, &error);
 
-  g_assert (!res);
+  g_assert_false (res);
   g_assert_error (error, JSON_PARSER_ERROR, JSON_PARSER_ERROR_MISSING_COMMA);
 
   if (g_test_verbose ())
@@ -178,14 +178,14 @@ test_trailing_comma (gconstpointer user_data)
   gboolean res;
 
   parser = json_parser_new ();
-  g_assert (JSON_IS_PARSER (parser));
+  g_assert_true (JSON_IS_PARSER (parser));
 
   if (g_test_verbose ())
     g_print ("invalid data: '%s'...", json);
 
   res = json_parser_load_from_data (parser, json, -1, &error);
 
-  g_assert (!res);
+  g_assert_false (res);
   g_assert_error (error, JSON_PARSER_ERROR, JSON_PARSER_ERROR_TRAILING_COMMA);
 
   if (g_test_verbose ())
diff --git a/json-glib/tests/node.c b/json-glib/tests/node.c
index 7d536f1..764ea36 100644
--- a/json-glib/tests/node.c
+++ b/json-glib/tests/node.c
@@ -28,7 +28,7 @@ test_init_boolean (void)
   JsonNode *node = json_node_new (JSON_NODE_VALUE);
 
   json_node_set_boolean (node, TRUE);
-  g_assert (json_node_get_boolean (node));
+  g_assert_true (json_node_get_boolean (node));
 
   json_node_free (node);
 }
@@ -107,7 +107,7 @@ test_copy_object (void)
   copy = json_node_copy (node);
 
   g_assert_cmpint (json_node_get_node_type (node), ==, json_node_get_node_type (copy));
-  g_assert (json_node_get_object (node) == json_node_get_object (copy));
+  g_assert_true (json_node_get_object (node) == json_node_get_object (copy));
 
   json_node_free (copy);
   json_node_free (node);
@@ -118,8 +118,8 @@ test_null (void)
 {
   JsonNode *node = json_node_new (JSON_NODE_NULL);
 
-  g_assert (JSON_NODE_HOLDS_NULL (node));
-  g_assert (json_node_is_null (node));
+  g_assert_true (JSON_NODE_HOLDS_NULL (node));
+  g_assert_true (json_node_is_null (node));
   g_assert_cmpint (json_node_get_value_type (node), ==, G_TYPE_INVALID);
   g_assert_cmpstr (json_node_type_name (node), ==, "NULL");
 
@@ -134,14 +134,14 @@ test_get_int (void)
   json_node_set_int (node, 0);
   g_assert_cmpint (json_node_get_int (node), ==, 0);
   json_assert_almost_equals (json_node_get_double (node), 0.0);
-  g_assert (!json_node_get_boolean (node));
-  g_assert (!json_node_is_null (node));
+  g_assert_false (json_node_get_boolean (node));
+  g_assert_false (json_node_is_null (node));
 
   json_node_set_int (node, 42);
   g_assert_cmpint (json_node_get_int (node), ==, 42);
   json_assert_almost_equals (json_node_get_double (node), 42.0);
-  g_assert (json_node_get_boolean (node));
-  g_assert (!json_node_is_null (node));
+  g_assert_true (json_node_get_boolean (node));
+  g_assert_false (json_node_is_null (node));
 
   json_node_free (node);
 }
@@ -154,7 +154,7 @@ test_get_double (void)
   json_node_set_double (node, 3.14);
   json_assert_fuzzy_equals (json_node_get_double (node), 3.14, 0.001);
   g_assert_cmpint (json_node_get_int (node), ==, 3);
-  g_assert (json_node_get_boolean (node));
+  g_assert_true (json_node_get_boolean (node));
 
   json_node_free (node);
 }
diff --git a/json-glib/tests/object.c b/json-glib/tests/object.c
index fa2efd2..b5cab1a 100644
--- a/json-glib/tests/object.c
+++ b/json-glib/tests/object.c
@@ -11,7 +11,7 @@ test_empty_object (void)
   JsonObject *object = json_object_new ();
 
   g_assert_cmpint (json_object_get_size (object), ==, 0);
-  g_assert (json_object_get_members (object) == NULL);
+  g_assert_null (json_object_get_members (object));
 
   json_object_unref (object);
 }
@@ -62,10 +62,10 @@ test_set_member (void)
   g_assert_cmpint (JSON_NODE_TYPE (json_object_get_member (object, "Array")), ==, JSON_NODE_NULL);
 
   json_object_set_object_member (object, "Object", NULL);
-  g_assert (json_object_get_null_member (object, "Object") == TRUE);
+  g_assert_true (json_object_get_null_member (object, "Object"));
 
   json_object_set_object_member (object, "", NULL);
-  g_assert (json_object_get_null_member (object, "") == TRUE);
+  g_assert_true (json_object_get_null_member (object, ""));
 
   json_object_unref (object);
 }
@@ -238,19 +238,19 @@ test_empty_member (void)
   JsonObject *object = json_object_new ();
 
   json_object_set_string_member (object, "string", "");
-  g_assert (json_object_has_member (object, "string"));
+  g_assert_true (json_object_has_member (object, "string"));
   g_assert_cmpstr (json_object_get_string_member (object, "string"), ==, "");
 
   json_object_set_string_member (object, "null", NULL);
-  g_assert (json_object_has_member (object, "null"));
-  g_assert (json_object_get_string_member (object, "null") == NULL);
+  g_assert_true (json_object_has_member (object, "null"));
+  g_assert_null (json_object_get_string_member (object, "null"));
 
   json_object_set_null_member (object, "array");
-  g_assert (json_object_get_array_member (object, "array") == NULL);
+  g_assert_null (json_object_get_array_member (object, "array"));
 
   json_object_set_object_member (object, "object", NULL);
-  g_assert (json_object_get_member (object, "object") != NULL);
-  g_assert (json_object_get_object_member (object, "object") == NULL);
+  g_assert_nonnull (json_object_get_member (object, "object"));
+  g_assert_null (json_object_get_object_member (object, "object"));
 
   json_object_unref (object);
 }
diff --git a/json-glib/tests/parser.c b/json-glib/tests/parser.c
index ddec577..c6ee421 100644
--- a/json-glib/tests/parser.c
+++ b/json-glib/tests/parser.c
@@ -164,7 +164,7 @@ test_empty_with_parser (JsonParser *parser)
       if (g_test_verbose ())
         g_print ("checking json_parser_get_root...\n");
 
-      g_assert (NULL == json_parser_get_root (parser));
+      g_assert_null (json_parser_get_root (parser));
     }
 }
 
@@ -176,12 +176,12 @@ test_empty (void)
   /* Check with and without immutability enabled, as there have been bugs with
    * NULL root nodes on immutable parsers. */
   parser = json_parser_new ();
-  g_assert (JSON_IS_PARSER (parser));
+  g_assert_true (JSON_IS_PARSER (parser));
   test_empty_with_parser (parser);
   g_object_unref (parser);
 
   parser = json_parser_new_immutable ();
-  g_assert (JSON_IS_PARSER (parser));
+  g_assert_true (JSON_IS_PARSER (parser));
   test_empty_with_parser (parser);
   g_object_unref (parser);
 }
@@ -193,7 +193,7 @@ test_base_value (void)
   JsonParser *parser;
 
   parser = json_parser_new ();
-  g_assert (JSON_IS_PARSER (parser));
+  g_assert_true (JSON_IS_PARSER (parser));
 
   if (g_test_verbose ())
     g_print ("checking json_parser_load_from_data with base-values...\n");
@@ -215,11 +215,11 @@ test_base_value (void)
         {
           JsonNode *root;
 
-          g_assert (NULL != json_parser_get_root (parser));
+          g_assert_nonnull (json_parser_get_root (parser));
 
           root = json_parser_get_root (parser);
-          g_assert (root != NULL);
-          g_assert (json_node_get_parent (root) == NULL);
+          g_assert_nonnull (root);
+          g_assert_null (json_node_get_parent (root));
 
           if (g_test_verbose ())
             g_print ("checking root node is of the desired type %s...\n",
@@ -243,7 +243,7 @@ test_empty_array (void)
   GError *error = NULL;
 
   parser = json_parser_new ();
-  g_assert (JSON_IS_PARSER (parser));
+  g_assert_true (JSON_IS_PARSER (parser));
 
   if (g_test_verbose ())
     g_print ("checking json_parser_load_from_data with empty array...\n");
@@ -261,16 +261,16 @@ test_empty_array (void)
       JsonNode *root;
       JsonArray *array;
 
-      g_assert (NULL != json_parser_get_root (parser));
+      g_assert_nonnull (json_parser_get_root (parser));
 
       if (g_test_verbose ())
         g_print ("checking root node is an array...\n");
       root = json_parser_get_root (parser);
       g_assert_cmpint (JSON_NODE_TYPE (root), ==, JSON_NODE_ARRAY);
-      g_assert (json_node_get_parent (root) == NULL);
+      g_assert_null (json_node_get_parent (root));
 
       array = json_node_get_array (root);
-      g_assert (array != NULL);
+      g_assert_nonnull (array);
 
       if (g_test_verbose ())
         g_print ("checking array is empty...\n");
@@ -287,7 +287,7 @@ test_simple_array (void)
   JsonParser *parser;
 
   parser = json_parser_new ();
-  g_assert (JSON_IS_PARSER (parser));
+  g_assert_true (JSON_IS_PARSER (parser));
 
   if (g_test_verbose ())
     g_print ("checking json_parser_load_from_data with simple arrays...\n");
@@ -313,16 +313,16 @@ test_simple_array (void)
           JsonNode *root, *node;
           JsonArray *array;
 
-          g_assert (NULL != json_parser_get_root (parser));
+          g_assert_nonnull (json_parser_get_root (parser));
 
           if (g_test_verbose ())
             g_print ("checking root node is an array...\n");
           root = json_parser_get_root (parser);
           g_assert_cmpint (JSON_NODE_TYPE (root), ==, JSON_NODE_ARRAY);
-          g_assert (json_node_get_parent (root) == NULL);
+          g_assert_null (json_node_get_parent (root));
 
           array = json_node_get_array (root);
-          g_assert (array != NULL);
+          g_assert_nonnull (array);
 
           if (g_test_verbose ())
             g_print ("checking array is of the desired length (%d)...\n",
@@ -334,8 +334,8 @@ test_simple_array (void)
                      test_simple_arrays[i].element,
                      g_type_name (test_simple_arrays[i].gtype));
           node = json_array_get_element (array, test_simple_arrays[i].element);
-          g_assert (node != NULL);
-          g_assert (json_node_get_parent (node) == root);
+          g_assert_nonnull (node);
+          g_assert_true (json_node_get_parent (node) == root);
           g_assert_cmpint (JSON_NODE_TYPE (node), ==, test_simple_arrays[i].type);
           g_assert_cmpint (json_node_get_value_type (node), ==, test_simple_arrays[i].gtype);
         }
@@ -351,7 +351,7 @@ test_nested_array (void)
   JsonParser *parser;
 
   parser = json_parser_new ();
-  g_assert (JSON_IS_PARSER (parser));
+  g_assert_true (JSON_IS_PARSER (parser));
 
   if (g_test_verbose ())
     g_print ("checking json_parser_load_from_data with nested arrays...\n");
@@ -374,16 +374,16 @@ test_nested_array (void)
           JsonNode *root;
           JsonArray *array;
 
-          g_assert (NULL != json_parser_get_root (parser));
+          g_assert_nonnull (json_parser_get_root (parser));
 
           if (g_test_verbose ())
             g_print ("checking root node is an array...\n");
           root = json_parser_get_root (parser);
           g_assert_cmpint (JSON_NODE_TYPE (root), ==, JSON_NODE_ARRAY);
-          g_assert (json_node_get_parent (root) == NULL);
+          g_assert_null (json_node_get_parent (root));
 
           array = json_node_get_array (root);
-          g_assert (array != NULL);
+          g_assert_nonnull (array);
 
           if (g_test_verbose ())
             g_print ("checking array is not empty...\n");
@@ -401,7 +401,7 @@ test_empty_object (void)
   GError *error = NULL;
 
   parser = json_parser_new ();
-  g_assert (JSON_IS_PARSER (parser));
+  g_assert_true (JSON_IS_PARSER (parser));
 
   if (g_test_verbose ())
     g_print ("checking json_parser_load_from_data with empty object...\n");
@@ -419,17 +419,17 @@ test_empty_object (void)
       JsonNode *root;
       JsonObject *object;
 
-      g_assert (NULL != json_parser_get_root (parser));
+      g_assert_nonnull (json_parser_get_root (parser));
 
       if (g_test_verbose ())
         g_print ("checking root node is an object...\n");
       root = json_parser_get_root (parser);
-      g_assert (json_node_get_parent (root) == NULL);
+      g_assert_null (json_node_get_parent (root));
       g_assert_cmpint (JSON_NODE_TYPE (root), ==, JSON_NODE_OBJECT);
-      g_assert (json_node_get_parent (root) == NULL);
+      g_assert_null (json_node_get_parent (root));
 
       object = json_node_get_object (root);
-      g_assert (object != NULL);
+      g_assert_nonnull (object);
 
       if (g_test_verbose ())
         g_print ("checking object is empty...\n");
@@ -446,7 +446,7 @@ test_simple_object (void)
   JsonParser *parser;
 
   parser = json_parser_new ();
-  g_assert (JSON_IS_PARSER (parser));
+  g_assert_true (JSON_IS_PARSER (parser));
 
   if (g_test_verbose ())
     g_print ("checking json_parser_load_from_data with simple objects...\n");
@@ -469,16 +469,16 @@ test_simple_object (void)
           JsonNode *root, *node;
           JsonObject *object;
 
-          g_assert (NULL != json_parser_get_root (parser));
+          g_assert_nonnull (json_parser_get_root (parser));
 
           if (g_test_verbose ())
             g_print ("checking root node is an object...\n");
           root = json_parser_get_root (parser);
           g_assert_cmpint (JSON_NODE_TYPE (root), ==, JSON_NODE_OBJECT);
-          g_assert (json_node_get_parent (root) == NULL);
+          g_assert_null (json_node_get_parent (root));
 
           object = json_node_get_object (root);
-          g_assert (object != NULL);
+          g_assert_nonnull (object);
 
           if (g_test_verbose ())
             g_print ("checking object is of the desired size (%d)...\n",
@@ -490,8 +490,8 @@ test_simple_object (void)
                      test_simple_objects[i].member,
                      g_type_name (test_simple_objects[i].gtype));
           node = json_object_get_member (object, test_simple_objects[i].member);
-          g_assert (node != NULL);
-          g_assert (json_node_get_parent (node) == root);
+          g_assert_nonnull (node);
+          g_assert_true (json_node_get_parent (node) == root);
           g_assert_cmpint (JSON_NODE_TYPE (node), ==, test_simple_objects[i].type);
           g_assert_cmpint (json_node_get_value_type (node), ==, test_simple_objects[i].gtype);
         }
@@ -507,7 +507,7 @@ test_nested_object (void)
   JsonParser *parser;
 
   parser = json_parser_new ();
-  g_assert (JSON_IS_PARSER (parser));
+  g_assert_true (JSON_IS_PARSER (parser));
 
   if (g_test_verbose ())
     g_print ("checking json_parser_load_from_data with nested objects...\n");
@@ -530,16 +530,16 @@ test_nested_object (void)
           JsonNode *root;
           JsonObject *object;
 
-          g_assert (NULL != json_parser_get_root (parser));
+          g_assert_nonnull (json_parser_get_root (parser));
 
           if (g_test_verbose ())
             g_print ("checking root node is an object...\n");
           root = json_parser_get_root (parser);
           g_assert_cmpint (JSON_NODE_TYPE (root), ==, JSON_NODE_OBJECT);
-          g_assert (json_node_get_parent (root) == NULL);
+          g_assert_null (json_node_get_parent (root));
 
           object = json_node_get_object (root);
-          g_assert (object != NULL);
+          g_assert_nonnull (object);
 
           if (g_test_verbose ())
             g_print ("checking object is not empty...\n");
@@ -557,7 +557,7 @@ test_assignment (void)
   JsonParser *parser;
 
   parser = json_parser_new ();
-  g_assert (JSON_IS_PARSER (parser));
+  g_assert_true (JSON_IS_PARSER (parser));
 
   if (g_test_verbose ())
     g_print ("checking json_parser_load_from_data with assignments...\n");
@@ -582,10 +582,10 @@ test_assignment (void)
           if (g_test_verbose ())
             g_print ("checking assignment...\n");
 
-          g_assert (json_parser_has_assignment (parser, &var) == TRUE);
-          g_assert (var != NULL);
+          g_assert_true (json_parser_has_assignment (parser, &var));
+          g_assert_nonnull (var);
           g_assert_cmpstr (var, ==, test_assignments[i].var);
-          g_assert (NULL != json_parser_get_root (parser));
+          g_assert_nonnull (json_parser_get_root (parser));
         }
     }
 
@@ -599,7 +599,7 @@ test_unicode_escape (void)
   JsonParser *parser;
 
   parser = json_parser_new ();
-  g_assert (JSON_IS_PARSER (parser));
+  g_assert_true (JSON_IS_PARSER (parser));
 
   if (g_test_verbose ())
     g_print ("checking json_parser_load_from_data with unicode escape...\n");
@@ -622,7 +622,7 @@ test_unicode_escape (void)
           JsonNode *root, *node;
           JsonObject *object;
 
-          g_assert (NULL != json_parser_get_root (parser));
+          g_assert_nonnull (json_parser_get_root (parser));
 
           if (g_test_verbose ())
             g_print ("checking root node is an object...\n");
@@ -630,7 +630,7 @@ test_unicode_escape (void)
           g_assert_cmpint (JSON_NODE_TYPE (root), ==, JSON_NODE_OBJECT);
 
           object = json_node_get_object (root);
-          g_assert (object != NULL);
+          g_assert_true (object);
 
           if (g_test_verbose ())
             g_print ("checking object is not empty...\n");
@@ -645,7 +645,7 @@ test_unicode_escape (void)
 
           if (g_test_verbose ())
             g_print ("checking for valid UTF-8...\n");
-          g_assert (g_utf8_validate (json_node_get_string (node), -1, NULL));
+          g_assert_true (g_utf8_validate (json_node_get_string (node), -1, NULL));
         }
     }
 
@@ -669,19 +669,19 @@ test_stream_sync (void)
   file = g_file_new_for_path (path);
   stream = g_file_read (file, NULL, &error);
   g_assert_no_error (error);
-  g_assert (stream != NULL);
+  g_assert_nonnull (stream);
 
   json_parser_load_from_stream (parser, G_INPUT_STREAM (stream), NULL, &error);
   g_assert_no_error (error);
 
   root = json_parser_get_root (parser);
-  g_assert (root != NULL);
-  g_assert (JSON_NODE_HOLDS_ARRAY (root));
+  g_assert_nonnull (root);
+  g_assert_true (JSON_NODE_HOLDS_ARRAY (root));
 
   array = json_node_get_array (root);
   g_assert_cmpint (json_array_get_length (array), ==, 1);
-  g_assert (JSON_NODE_HOLDS_OBJECT (json_array_get_element (array, 0)));
-  g_assert (json_object_has_member (json_array_get_object_element (array, 0), "hello"));
+  g_assert_true (JSON_NODE_HOLDS_OBJECT (json_array_get_element (array, 0)));
+  g_assert_true (json_object_has_member (json_array_get_object_element (array, 0), "hello"));
 
   g_object_unref (stream);
   g_object_unref (file);
@@ -697,13 +697,13 @@ assert_stream_load_json_correct (JsonParser *parser)
   JsonArray *array;
 
   root = json_parser_get_root (parser);
-  g_assert (root != NULL);
-  g_assert (JSON_NODE_HOLDS_ARRAY (root));
+  g_assert_nonnull (root);
+  g_assert_true (JSON_NODE_HOLDS_ARRAY (root));
 
   array = json_node_get_array (root);
   g_assert_cmpint (json_array_get_length (array), ==, 1);
-  g_assert (JSON_NODE_HOLDS_OBJECT (json_array_get_element (array, 0)));
-  g_assert (json_object_has_member (json_array_get_object_element (array, 0), "hello"));
+  g_assert_true (JSON_NODE_HOLDS_OBJECT (json_array_get_element (array, 0)));
+  g_assert_true (json_object_has_member (json_array_get_object_element (array, 0), "hello"));
 }
 
 static void
@@ -736,8 +736,8 @@ test_stream_async (void)
   path = g_test_build_filename (G_TEST_DIST, "stream-load.json", NULL);
   file = g_file_new_for_path (path);
   stream = g_file_read (file, NULL, &error);
-  g_assert (error == NULL);
-  g_assert (stream != NULL);
+  g_assert_null (error);
+  g_assert_nonnull (stream);
 
   main_loop = g_main_loop_new (NULL, FALSE);
 
diff --git a/json-glib/tests/path.c b/json-glib/tests/path.c
index e6d82c2..d674da3 100644
--- a/json-glib/tests/path.c
+++ b/json-glib/tests/path.c
@@ -190,7 +190,7 @@ path_expressions_valid (gconstpointer data)
   if (g_test_verbose ())
     g_print ("* %s ('%s')\n", desc, expr);
 
-  g_assert (json_path_compile (path, expr, &error));
+  g_assert_true (json_path_compile (path, expr, &error));
   g_assert_no_error (error);
 
   g_object_unref (path);
@@ -211,7 +211,7 @@ path_expressions_invalid (gconstpointer data)
     g_print ("* %s ('%s')\n", desc, expr);
 
 
-  g_assert (!json_path_compile (path, expr, &error));
+  g_assert_false (json_path_compile (path, expr, &error));
   g_assert_error (error, JSON_PATH_ERROR, code);
 
   g_object_unref (path);
@@ -236,10 +236,10 @@ path_match (gconstpointer data)
   json_parser_load_from_data (parser, test_json, -1, NULL);
   root = json_parser_get_root (parser);
 
-  g_assert (json_path_compile (path, expr, NULL));
+  g_assert_true (json_path_compile (path, expr, NULL));
 
   matches = json_path_match (path, root);
-  g_assert (JSON_NODE_HOLDS_ARRAY (matches));
+  g_assert_true (JSON_NODE_HOLDS_ARRAY (matches));
 
   json_generator_set_root (gen, matches);
   str = json_generator_to_data (gen, NULL);
diff --git a/json-glib/tests/reader.c b/json-glib/tests/reader.c
index 67a81c3..947fbc9 100644
--- a/json-glib/tests/reader.c
+++ b/json-glib/tests/reader.c
@@ -30,15 +30,15 @@ test_base_object (void)
   gsize n_members, i;
 
   json_parser_load_from_data (parser, test_base_object_data, -1, &error);
-  g_assert (error == NULL);
+  g_assert_no_error (error);
 
   json_reader_set_root (reader, json_parser_get_root (parser));
 
-  g_assert (json_reader_is_object (reader));
+  g_assert_true (json_reader_is_object (reader));
   g_assert_cmpint (json_reader_count_members (reader), ==, 4);
 
   members = json_reader_list_members (reader);
-  g_assert (members != NULL);
+  g_assert_nonnull (members);
 
   n_members = g_strv_length (members);
   g_assert_cmpint (n_members, ==, json_reader_count_members (reader));
@@ -48,29 +48,29 @@ test_base_object (void)
 
   g_strfreev (members);
 
-  g_assert (json_reader_read_member (reader, "text"));
-  g_assert (json_reader_is_value (reader));
+  g_assert_true (json_reader_read_member (reader, "text"));
+  g_assert_true (json_reader_is_value (reader));
   g_assert_cmpstr (json_reader_get_string_value (reader), ==, "hello, world!");
   json_reader_end_member (reader);
 
-  g_assert (json_reader_read_member (reader, "foo"));
-  g_assert (json_reader_get_null_value (reader));
+  g_assert_true (json_reader_read_member (reader, "foo"));
+  g_assert_true (json_reader_get_null_value (reader));
   json_reader_end_member (reader);
 
-  g_assert (!json_reader_read_member (reader, "bar"));
-  g_assert (json_reader_get_error (reader) != NULL);
+  g_assert_false (json_reader_read_member (reader, "bar"));
+  g_assert_nonnull (json_reader_get_error (reader));
   g_assert_error ((GError *) json_reader_get_error (reader),
                   JSON_READER_ERROR,
                   JSON_READER_ERROR_INVALID_MEMBER);
   json_reader_end_member (reader);
-  g_assert (json_reader_get_error (reader) == NULL);
+  g_assert_no_error (json_reader_get_error (reader));
 
-  g_assert (json_reader_read_element (reader, 2));
+  g_assert_true (json_reader_read_element (reader, 2));
   g_assert_cmpstr (json_reader_get_member_name (reader), ==, "blah");
-  g_assert (json_reader_is_value (reader));
+  g_assert_true (json_reader_is_value (reader));
   g_assert_cmpint (json_reader_get_int_value (reader), ==, 47);
   json_reader_end_element (reader);
-  g_assert (json_reader_get_error (reader) == NULL);
+  g_assert_no_error (json_reader_get_error (reader));
 
   json_reader_read_member (reader, "double");
   json_assert_fuzzy_equals (json_reader_get_double_value (reader), 42.47, 0.01);
@@ -88,49 +88,50 @@ test_base_array (void)
   GError *error = NULL;
 
   json_parser_load_from_data (parser, test_base_array_data, -1, &error);
-  g_assert (error == NULL);
+  g_assert_no_error (error);
 
   json_reader_set_root (reader, json_parser_get_root (parser));
 
-  g_assert (json_reader_is_array (reader));
+  g_assert_true (json_reader_is_array (reader));
   g_assert_cmpint (json_reader_count_elements (reader), ==, 7);
 
   json_reader_read_element (reader, 0);
-  g_assert (json_reader_is_value (reader));
+  g_assert_true (json_reader_is_value (reader));
   g_assert_cmpint (json_reader_get_int_value (reader), ==, 0);
   json_reader_end_element (reader);
 
   json_reader_read_element (reader, 1);
-  g_assert (json_reader_is_value (reader));
-  g_assert (json_reader_get_boolean_value (reader));
+  g_assert_true (json_reader_is_value (reader));
+  g_assert_true (json_reader_get_boolean_value (reader));
   json_reader_end_element (reader);
 
   json_reader_read_element (reader, 3);
-  g_assert (json_reader_is_value (reader));
+  g_assert_true (json_reader_is_value (reader));
   g_assert_cmpstr (json_reader_get_string_value (reader), ==, "foo");
   json_reader_end_element (reader);
 
   json_reader_read_element (reader, 5);
-  g_assert (!json_reader_is_value (reader));
-  g_assert (json_reader_is_array (reader));
+  g_assert_false (json_reader_is_value (reader));
+  g_assert_true (json_reader_is_array (reader));
   json_reader_end_element (reader);
 
   json_reader_read_element (reader, 6);
-  g_assert (json_reader_is_object (reader));
+  g_assert_true (json_reader_is_object (reader));
 
   json_reader_read_member (reader, "bar");
-  g_assert (json_reader_is_value (reader));
+  g_assert_true (json_reader_is_value (reader));
   g_assert_cmpint (json_reader_get_int_value (reader), ==, 42);
   json_reader_end_member (reader);
 
   json_reader_end_element (reader);
 
-  g_assert (!json_reader_read_element (reader, 7));
+  g_assert_false (json_reader_read_element (reader, 7));
+  g_assert_nonnull (json_reader_get_error (reader));
   g_assert_error ((GError *) json_reader_get_error (reader),
                   JSON_READER_ERROR,
                   JSON_READER_ERROR_INVALID_INDEX);
   json_reader_end_element (reader);
-  g_assert (json_reader_get_error (reader) == NULL);
+  g_assert_no_error (json_reader_get_error (reader));
 
   g_object_unref (reader);
   g_object_unref (parser);
@@ -146,31 +147,31 @@ test_reader_level (void)
   char **members;
 
   json_parser_load_from_data (parser, test_reader_level_data, -1, &error);
-  g_assert (error == NULL);
+  g_assert_no_error (error);
 
   json_reader_set_root (reader, json_parser_get_root (parser));
 
-  g_assert (json_reader_count_members (reader) > 0);
+  g_assert_cmpint (json_reader_count_members (reader), >, 0);
 
   /* Grab the list */
-  g_assert (json_reader_read_member (reader, "list"));
+  g_assert_true (json_reader_read_member (reader, "list"));
   g_assert_cmpstr (json_reader_get_member_name (reader), ==, "list");
 
   members = json_reader_list_members (reader);
-  g_assert (members != NULL);
+  g_assert_nonnull (members);
   g_strfreev (members);
 
-  g_assert (json_reader_read_member (reader, "181195771"));
+  g_assert_true (json_reader_read_member (reader, "181195771"));
   g_assert_cmpstr (json_reader_get_member_name (reader), ==, "181195771");
 
-  g_assert (!json_reader_read_member (reader, "resolved_url"));
+  g_assert_false (json_reader_read_member (reader, "resolved_url"));
   g_assert_cmpstr (json_reader_get_member_name (reader), ==, NULL);
-  g_assert (json_reader_get_error (reader) != NULL);
+  g_assert_nonnull (json_reader_get_error (reader));
   json_reader_end_member (reader);
 
   g_assert_cmpstr (json_reader_get_member_name (reader), ==, "181195771");
 
-  g_assert (json_reader_read_member (reader, "given_url"));
+  g_assert_true (json_reader_read_member (reader, "given_url"));
   g_assert_cmpstr (json_reader_get_member_name (reader), ==, "given_url");
   g_assert_cmpstr (json_reader_get_string_value (reader), ==, "http://www.gnome.org/json-glib-test");
   json_reader_end_member (reader);
diff --git a/json-glib/tests/serialize-complex.c b/json-glib/tests/serialize-complex.c
index 226e722..b43c143 100644
--- a/json-glib/tests/serialize-complex.c
+++ b/json-glib/tests/serialize-complex.c
@@ -278,19 +278,19 @@ test_serialize (void)
 
   parser = json_parser_new ();
   json_parser_load_from_data (parser, data, -1, &error);
-  g_assert (error == NULL);
+  g_assert_null (error);
 
   node = json_parser_get_root (parser);
-  g_assert (json_node_get_node_type (node) == JSON_NODE_OBJECT);
+  g_assert_true (json_node_get_node_type (node) == JSON_NODE_OBJECT);
 
   object = json_node_get_object (node);
   g_assert_cmpint (json_object_get_int_member (object, "foo"), ==, 47);
-  g_assert (!json_object_get_boolean_member (object, "bar"));
+  g_assert_false (json_object_get_boolean_member (object, "bar"));
   g_assert_cmpstr (json_object_get_string_member (object, "baz"), ==, "Hello, World!");
   g_assert_cmpfloat (json_object_get_double_member (object, "meh"), ==, 0.5);
 
   /* blah is read-only */
-  g_assert (json_object_has_member (object, "blah"));
+  g_assert_true (json_object_has_member (object, "blah"));
 
   g_free (data);
   g_object_unref (parser);
diff --git a/json-glib/tests/serialize-full.c b/json-glib/tests/serialize-full.c
index dd5da7a..42f189d 100644
--- a/json-glib/tests/serialize-full.c
+++ b/json-glib/tests/serialize-full.c
@@ -421,20 +421,20 @@ test_deserialize (void)
              TEST_OBJECT (object)->m_enum == TEST_ENUM_BAZ ? "<true>" : "<false>");
 
   g_assert_cmpint (TEST_OBJECT (object)->m_int, ==, 42);
-  g_assert (TEST_OBJECT (object)->m_bool);
+  g_assert_true (TEST_OBJECT (object)->m_bool);
   g_assert_cmpstr (TEST_OBJECT (object)->m_str, ==, "hello");
   g_assert_cmpint (TEST_OBJECT (object)->m_enum, ==, TEST_ENUM_BAZ);
 
-  g_assert (TEST_OBJECT (object)->m_strv != NULL);
+  g_assert_nonnull (TEST_OBJECT (object)->m_strv);
   g_assert_cmpint (g_strv_length (TEST_OBJECT (object)->m_strv), ==, 4);
 
   str = g_strjoinv (NULL, TEST_OBJECT (object)->m_strv);
   g_assert_cmpstr (str, ==, "hello, world!");
   g_free (str);
 
-  g_assert (TEST_IS_OBJECT (TEST_OBJECT (object)->m_obj));
+  g_assert_true (TEST_IS_OBJECT (TEST_OBJECT (object)->m_obj));
   test = TEST_OBJECT (TEST_OBJECT (object)->m_obj);
-  g_assert (test->m_bool);
+  g_assert_true (test->m_bool);
   g_assert_cmpstr (test->m_str, ==, "world");
   g_assert_cmpint (test->m_enum, ==, TEST_ENUM_FOO);
   g_assert_cmpint (test->m_flags, ==, TEST_FLAGS_FOO | TEST_FLAGS_BAR);
diff --git a/json-glib/tests/serialize-simple.c b/json-glib/tests/serialize-simple.c
index e2e7be2..6d456af 100644
--- a/json-glib/tests/serialize-simple.c
+++ b/json-glib/tests/serialize-simple.c
@@ -142,7 +142,7 @@ test_serialize (void)
 
   data = json_gobject_to_data (G_OBJECT (obj), &len);
 
-  g_assert (data != NULL);
+  g_assert_nonnull (data);
   g_assert_cmpint (len, >, 0);
   g_assert_cmpint (len, ==, strlen (data));