[gtksourceview] testsuite: use g_assert_* macros instead of g_assert()



commit a244dbaa2d21b6bff5dd00cf29a0fa1be741f1ec
Author: Christian Hergert <chergert redhat com>
Date:   Thu Sep 12 11:13:28 2019 -0700

    testsuite: use g_assert_* macros instead of g_assert()
    
    Fixes #43

 testsuite/test-buffer-input-stream.c  |   2 +-
 testsuite/test-buffer-output-stream.c |  10 ++--
 testsuite/test-buffer.c               |   8 +--
 testsuite/test-completion-model.c     |  84 +++++++++++++--------------
 testsuite/test-completion-words.c     |   8 +--
 testsuite/test-encoding.c             |   8 +--
 testsuite/test-iter.c                 |  24 ++++----
 testsuite/test-language.c             |   2 +-
 testsuite/test-languagemanager.c      |  18 +++---
 testsuite/test-mark.c                 |  32 +++++------
 testsuite/test-printcompositor.c      |   8 +--
 testsuite/test-regex.c                |   2 +-
 testsuite/test-region.c               |  24 ++++----
 testsuite/test-search-context.c       |  58 +++++++++----------
 testsuite/test-space-drawer.c         |   4 +-
 testsuite/test-stylescheme.c          |  10 ++--
 testsuite/test-styleschememanager.c   |   2 +-
 testsuite/test-undo-manager.c         | 104 +++++++++++++++++-----------------
 testsuite/test-view.c                 |  20 +++----
 19 files changed, 214 insertions(+), 214 deletions(-)
---
diff --git a/testsuite/test-buffer-input-stream.c b/testsuite/test-buffer-input-stream.c
index 4250df1c..f812b522 100644
--- a/testsuite/test-buffer-input-stream.c
+++ b/testsuite/test-buffer-input-stream.c
@@ -63,7 +63,7 @@ test_consecutive_read (const gchar          *inbuf,
        g_assert_cmpstr (b, ==, outbuf);
 
        close = g_input_stream_close (G_INPUT_STREAM (in), NULL, &err);
-       g_assert (close);
+       g_assert_true (close);
        g_assert_no_error (err);
 
        g_object_unref (buf);
diff --git a/testsuite/test-buffer-output-stream.c b/testsuite/test-buffer-output-stream.c
index fecba844..c844093d 100644
--- a/testsuite/test-buffer-output-stream.c
+++ b/testsuite/test-buffer-output-stream.c
@@ -62,7 +62,7 @@ test_consecutive_write (const gchar          *inbuf,
        g_assert_no_error (err);
 
        type = gtk_source_buffer_output_stream_detect_newline_type (out);
-       g_assert (type == newline_type);
+       g_assert_cmpint (type, ==, newline_type);
 
        g_output_stream_close (G_OUTPUT_STREAM (out), NULL, &err);
        g_assert_no_error (err);
@@ -72,7 +72,7 @@ test_consecutive_write (const gchar          *inbuf,
        g_assert_cmpstr (outbuf, ==, b);
        g_free (b);
 
-       g_assert (gtk_text_buffer_get_modified (GTK_TEXT_BUFFER (source_buffer)) == FALSE);
+       g_assert_false (gtk_text_buffer_get_modified (GTK_TEXT_BUFFER (source_buffer)));
 
        g_object_unref (source_buffer);
        g_object_unref (out);
@@ -337,7 +337,7 @@ test_empty_conversion (void)
        g_assert_cmpstr (out, ==, "");
        g_free (out);
 
-       g_assert (guessed == gtk_source_encoding_get_utf8 ());
+       g_assert_true (guessed == gtk_source_encoding_get_utf8 ());
 }
 
 static void
@@ -360,7 +360,7 @@ test_guessed (void)
                                 &fail_len,
                                 FALSE);
 
-       g_assert (fail == NULL);
+       g_assert_null (fail);
 
        /* ISO-8859-15 should fail */
        encs = g_slist_append (encs, (gpointer)gtk_source_encoding_get_from_charset ("ISO-8859-15"));
@@ -370,7 +370,7 @@ test_guessed (void)
        g_free (aux);
        g_free (aux2);
 
-       g_assert (guessed == gtk_source_encoding_get_from_charset ("UTF-16"));
+       g_assert_true (guessed == gtk_source_encoding_get_from_charset ("UTF-16"));
 }
 
 static void
diff --git a/testsuite/test-buffer.c b/testsuite/test-buffer.c
index d27c933a..618077ad 100644
--- a/testsuite/test-buffer.c
+++ b/testsuite/test-buffer.c
@@ -71,8 +71,8 @@ test_get_buffer (void)
 
        buffer = GTK_SOURCE_BUFFER (gtk_text_view_get_buffer (GTK_TEXT_VIEW (view)));
 
-       g_assert (buffer != NULL);
-       g_assert (GTK_SOURCE_IS_BUFFER (buffer));
+       g_assert_nonnull (buffer);
+       g_assert_true (GTK_SOURCE_IS_BUFFER (buffer));
 
        if (g_object_is_floating (view))
        {
@@ -111,7 +111,7 @@ test_get_context_classes (void)
        /* test C */
        lm = gtk_source_language_manager_get_default ();
        lang = gtk_source_language_manager_get_language (lm, "c");
-       g_assert (GTK_SOURCE_IS_LANGUAGE (lang));
+       g_assert_true (GTK_SOURCE_IS_LANGUAGE (lang));
        buffer = gtk_source_buffer_new_with_language (lang);
        gtk_text_buffer_set_text (GTK_TEXT_BUFFER (buffer), c_snippet, -1);
        gtk_text_buffer_get_bounds (GTK_TEXT_BUFFER (buffer), &start, &end);
@@ -347,7 +347,7 @@ test_bracket_matching (void)
 
        language_manager = gtk_source_language_manager_get_default ();
        c_language = gtk_source_language_manager_get_language (language_manager, "c");
-       g_assert (c_language != NULL);
+       g_assert_nonnull (c_language);
        gtk_source_buffer_set_language (buffer, c_language);
 
        /* Basics */
diff --git a/testsuite/test-completion-model.c b/testsuite/test-completion-model.c
index ddad6b59..9e99dbd7 100644
--- a/testsuite/test-completion-model.c
+++ b/testsuite/test-completion-model.c
@@ -189,16 +189,16 @@ check_provider (GtkSourceCompletionModel    *model,
 
        if (is_header_visible)
        {
-               g_assert (gtk_source_completion_model_iter_is_header (model, iter));
+               g_assert_true (gtk_source_completion_model_iter_is_header (model, iter));
 
                gtk_tree_model_get (GTK_TREE_MODEL (model), iter,
                                    GTK_SOURCE_COMPLETION_MODEL_COLUMN_PROPOSAL, &proposal_get,
                                    GTK_SOURCE_COMPLETION_MODEL_COLUMN_PROVIDER, &provider_get,
                                    -1);
 
-               g_assert (proposal_get == NULL);
-               g_assert (provider_get == provider);
-               g_assert (gtk_tree_model_iter_next (GTK_TREE_MODEL (model), iter));
+               g_assert_null (proposal_get);
+               g_assert_true (provider_get == provider);
+               g_assert_true (gtk_tree_model_iter_next (GTK_TREE_MODEL (model), iter));
        }
 
        /* Check the proposals */
@@ -211,8 +211,8 @@ check_provider (GtkSourceCompletionModel    *model,
                                    GTK_SOURCE_COMPLETION_MODEL_COLUMN_PROVIDER, &provider_get,
                                    -1);
 
-               g_assert (proposal_get == cur_proposal->data);
-               g_assert (provider_get == provider);
+               g_assert_true (proposal_get == cur_proposal->data);
+               g_assert_true (provider_get == provider);
 
                cur_proposal = g_list_next (cur_proposal);
 
@@ -221,7 +221,7 @@ check_provider (GtkSourceCompletionModel    *model,
                        break;
                }
 
-               g_assert (gtk_tree_model_iter_next (GTK_TREE_MODEL (model), iter));
+               g_assert_true (gtk_tree_model_iter_next (GTK_TREE_MODEL (model), iter));
        }
 }
 
@@ -236,7 +236,7 @@ check_all_providers (GtkSourceCompletionModel *model,
        GList *cur_provider = NULL;
        GList *cur_list_proposals = NULL;
 
-       g_assert (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (model), &iter));
+       g_assert_true (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (model), &iter));
 
        cur_provider = all_providers;
        cur_list_proposals = all_list_proposals;
@@ -253,14 +253,14 @@ check_all_providers (GtkSourceCompletionModel *model,
 
                if (cur_provider == NULL)
                {
-                       g_assert (cur_list_proposals == NULL);
+                       g_assert_null (cur_list_proposals);
                        break;
                }
 
-               g_assert (gtk_tree_model_iter_next (GTK_TREE_MODEL (model), &iter));
+               g_assert_true (gtk_tree_model_iter_next (GTK_TREE_MODEL (model), &iter));
        }
 
-       g_assert (!gtk_tree_model_iter_next (GTK_TREE_MODEL (model), &iter));
+       g_assert_true (!gtk_tree_model_iter_next (GTK_TREE_MODEL (model), &iter));
 }
 
 static void
@@ -314,8 +314,8 @@ test_is_empty (void)
        /* Completely empty */
        model = gtk_source_completion_model_new ();
 
-       g_assert (gtk_source_completion_model_is_empty (model, FALSE));
-       g_assert (gtk_source_completion_model_is_empty (model, TRUE));
+       g_assert_true (gtk_source_completion_model_is_empty (model, FALSE));
+       g_assert_true (gtk_source_completion_model_is_empty (model, TRUE));
 
        /* One visible provider */
        provider = test_provider_new ();
@@ -326,15 +326,15 @@ test_is_empty (void)
                                                   GTK_SOURCE_COMPLETION_PROVIDER (provider),
                                                   list_proposals);
 
-       g_assert (!gtk_source_completion_model_is_empty (model, FALSE));
-       g_assert (!gtk_source_completion_model_is_empty (model, TRUE));
+       g_assert_false (gtk_source_completion_model_is_empty (model, FALSE));
+       g_assert_false (gtk_source_completion_model_is_empty (model, TRUE));
 
        /* One invisible provider */
        visible_providers = g_list_append (visible_providers, test_provider_new ());
        gtk_source_completion_model_set_visible_providers (model, visible_providers);
 
-       g_assert (!gtk_source_completion_model_is_empty (model, FALSE));
-       g_assert (gtk_source_completion_model_is_empty (model, TRUE));
+       g_assert_false (gtk_source_completion_model_is_empty (model, FALSE));
+       g_assert_true (gtk_source_completion_model_is_empty (model, TRUE));
 
        g_object_unref (model);
        g_list_free_full (list_providers, g_object_unref);
@@ -351,7 +351,7 @@ test_get_visible_providers (void)
        GList *visible_providers = NULL;
 
        model = gtk_source_completion_model_new ();
-       g_assert (gtk_source_completion_model_get_visible_providers (model) == NULL);
+       g_assert_null (gtk_source_completion_model_get_visible_providers (model));
 
        provider = test_provider_new ();
        list_providers = g_list_append (list_providers, provider);
@@ -359,7 +359,7 @@ test_get_visible_providers (void)
        gtk_source_completion_model_set_visible_providers (model, list_providers);
        visible_providers = gtk_source_completion_model_get_visible_providers (model);
 
-       g_assert (visible_providers->data == provider);
+       g_assert_true (visible_providers->data == provider);
 
        g_object_unref (model);
        g_list_free_full (list_providers, g_object_unref);
@@ -428,7 +428,7 @@ test_set_visible_providers (void)
        other_provider = test_provider_new ();
        subset_providers->data = other_provider;
        gtk_source_completion_model_set_visible_providers (model, subset_providers);
-       g_assert (gtk_source_completion_model_is_empty (model, TRUE));
+       g_assert_true (gtk_source_completion_model_is_empty (model, TRUE));
 
        /* The two providers are visible again */
        gtk_source_completion_model_set_visible_providers (model, NULL);
@@ -457,9 +457,9 @@ test_populate_several_batches (void)
        /* First batch */
        gtk_source_completion_model_add_proposals (model, provider, first_proposals);
 
-       g_assert (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (model), &iter));
+       g_assert_true (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (model), &iter));
        check_provider (model, provider, first_proposals, TRUE, &iter);
-       g_assert (!gtk_tree_model_iter_next (GTK_TREE_MODEL (model), &iter));
+       g_assert_false (gtk_tree_model_iter_next (GTK_TREE_MODEL (model), &iter));
 
        /* Second batch */
        gtk_source_completion_model_add_proposals (model, provider, second_proposals);
@@ -467,9 +467,9 @@ test_populate_several_batches (void)
        all_proposals = g_list_copy (first_proposals);
        all_proposals = g_list_concat (all_proposals, g_list_copy (second_proposals));
 
-       g_assert (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (model), &iter));
+       g_assert_true (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (model), &iter));
        check_provider (model, provider, all_proposals, TRUE, &iter);
-       g_assert (!gtk_tree_model_iter_next (GTK_TREE_MODEL (model), &iter));
+       g_assert_false (gtk_tree_model_iter_next (GTK_TREE_MODEL (model), &iter));
 
        g_object_unref (model);
        g_object_unref (provider);
@@ -488,14 +488,14 @@ test_get_providers (void)
        GList *providers_get = NULL;
 
        /* Empty */
-       g_assert (gtk_source_completion_model_get_providers (model) == NULL);
+       g_assert_null (gtk_source_completion_model_get_providers (model));
 
        /* Non-empty */
        create_providers (&all_providers, &all_list_proposals);
        populate_model (model, all_providers, all_list_proposals);
 
        providers_get = gtk_source_completion_model_get_providers (model);
-       g_assert (same_list_contents (all_providers, providers_get));
+       g_assert_true (same_list_contents (all_providers, providers_get));
 
        g_object_unref (model);
        free_providers (all_providers, all_list_proposals);
@@ -516,46 +516,46 @@ test_iters_impl (gboolean show_headers)
        gint *indices;
 
        /* Test last_proposal() */
-       g_assert (!gtk_source_completion_model_last_proposal (model, &last_iter));
+       g_assert_false (gtk_source_completion_model_last_proposal (model, &last_iter));
 
        create_providers (&all_providers, &all_list_proposals);
        populate_model (model, all_providers, all_list_proposals);
 
        gtk_source_completion_model_set_show_headers (model, show_headers);
 
-       g_assert (gtk_source_completion_model_last_proposal (model, &last_iter));
+       g_assert_true (gtk_source_completion_model_last_proposal (model, &last_iter));
 
        /* Get the last proposal by another means, and compare it */
        nb_items = gtk_tree_model_iter_n_children (GTK_TREE_MODEL (model), NULL);
 
-       g_assert (gtk_tree_model_iter_nth_child (GTK_TREE_MODEL (model),
-                                                &other_iter,
-                                                NULL,
-                                                nb_items - 1));
+       g_assert_true (gtk_tree_model_iter_nth_child (GTK_TREE_MODEL (model),
+                                                     &other_iter,
+                                                     NULL,
+                                                     nb_items - 1));
 
-       g_assert (gtk_source_completion_model_iter_equal (model, &last_iter, &other_iter));
+       g_assert_true (gtk_source_completion_model_iter_equal (model, &last_iter, &other_iter));
 
        /* Test get_path() */
        path = gtk_tree_model_get_path (GTK_TREE_MODEL (model), &last_iter);
        indices = gtk_tree_path_get_indices (path);
-       g_assert (indices[0] == nb_items - 1);
+       g_assert_cmpint (indices[0], ==, nb_items - 1);
 
        /* Test iter_previous() */
        while (gtk_source_completion_model_iter_previous (model, &other_iter));
 
-       g_assert (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (model), &first_iter));
-       g_assert (gtk_source_completion_model_iter_equal (model, &first_iter, &other_iter));
+       g_assert_true (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (model), &first_iter));
+       g_assert_true (gtk_source_completion_model_iter_equal (model, &first_iter, &other_iter));
 
        /* Test iter_children() */
-       g_assert (gtk_tree_model_iter_children (GTK_TREE_MODEL (model), &other_iter, NULL));
-       g_assert (gtk_source_completion_model_iter_equal (model, &first_iter, &other_iter));
-       g_assert (!gtk_tree_model_iter_children (GTK_TREE_MODEL (model), &other_iter, &first_iter));
+       g_assert_true (gtk_tree_model_iter_children (GTK_TREE_MODEL (model), &other_iter, NULL));
+       g_assert_true (gtk_source_completion_model_iter_equal (model, &first_iter, &other_iter));
+       g_assert_false (gtk_tree_model_iter_children (GTK_TREE_MODEL (model), &other_iter, &first_iter));
 
        /* Test iter_has_child() */
-       g_assert (!gtk_tree_model_iter_has_child (GTK_TREE_MODEL (model), &first_iter));
+       g_assert_false (gtk_tree_model_iter_has_child (GTK_TREE_MODEL (model), &first_iter));
 
        /* Test iter_parent() */
-       g_assert (!gtk_tree_model_iter_parent (GTK_TREE_MODEL (model), &other_iter, &first_iter));
+       g_assert_false (gtk_tree_model_iter_parent (GTK_TREE_MODEL (model), &other_iter, &first_iter));
 
        g_object_unref (model);
        free_providers (all_providers, all_list_proposals);
@@ -582,7 +582,7 @@ on_row_changed (GtkTreeModel                *model,
                            -1);
 
        /* Make sure that the signal was emitted for the good row. */
-       g_assert (proposal == row_proposal);
+       g_assert_true (proposal == row_proposal);
 }
 
 static void
diff --git a/testsuite/test-completion-words.c b/testsuite/test-completion-words.c
index 4e736eb4..6dbafa11 100644
--- a/testsuite/test-completion-words.c
+++ b/testsuite/test-completion-words.c
@@ -43,20 +43,20 @@ test_library_find (void)
        library_add_words (library);
 
        iter = gtk_source_completion_words_library_find_first (library, "a", -1);
-       g_assert (iter == NULL);
+       g_assert_null (iter);
 
        iter = gtk_source_completion_words_library_find_first (library, "bba", -1);
-       g_assert (iter == NULL);
+       g_assert_null (iter);
 
        iter = gtk_source_completion_words_library_find_first (library, "b", -1);
-       g_assert (iter != NULL);
+       g_assert_nonnull (iter);
 
        proposal = gtk_source_completion_words_library_get_proposal (iter);
        word = gtk_source_completion_words_proposal_get_word (proposal);
        g_assert_cmpstr (word, ==, "bb");
 
        iter = gtk_source_completion_words_library_find_first (library, "dd", -1);
-       g_assert (iter != NULL);
+       g_assert_nonnull (iter);
 
        proposal = gtk_source_completion_words_library_get_proposal (iter);
        word = gtk_source_completion_words_proposal_get_word (proposal);
diff --git a/testsuite/test-encoding.c b/testsuite/test-encoding.c
index d2bf29c7..0fdc7950 100644
--- a/testsuite/test-encoding.c
+++ b/testsuite/test-encoding.c
@@ -40,8 +40,8 @@ test_remove_duplicates (void)
        list = _gtk_source_encoding_remove_duplicates (list, GTK_SOURCE_ENCODING_DUPLICATES_KEEP_FIRST);
 
        g_assert_cmpint (2, ==, g_slist_length (list));
-       g_assert (list->data == utf8);
-       g_assert (list->next->data == iso);
+       g_assert_true (list->data == utf8);
+       g_assert_true (list->next->data == iso);
 
        /* Before: [UTF-8, ISO-8859-15, UTF-8] */
        list = g_slist_append (list, (gpointer) utf8);
@@ -50,8 +50,8 @@ test_remove_duplicates (void)
        list = _gtk_source_encoding_remove_duplicates (list, GTK_SOURCE_ENCODING_DUPLICATES_KEEP_LAST);
 
        g_assert_cmpint (2, ==, g_slist_length (list));
-       g_assert (list->data == iso);
-       g_assert (list->next->data == utf8);
+       g_assert_true (list->data == iso);
+       g_assert_true (list->next->data == utf8);
 
        g_slist_free (list);
 }
diff --git a/testsuite/test-iter.c b/testsuite/test-iter.c
index 6491f6ec..ff6cd305 100644
--- a/testsuite/test-iter.c
+++ b/testsuite/test-iter.c
@@ -80,23 +80,23 @@ test_starts_full_word (void)
        gtk_text_buffer_set_text (buffer, "foo--- ---bar", -1);
 
        gtk_text_buffer_get_iter_at_offset (buffer, &iter, 0);
-       g_assert (_gtk_source_iter_starts_full_word (&iter));
+       g_assert_true (_gtk_source_iter_starts_full_word (&iter));
 
        gtk_text_buffer_get_iter_at_offset (buffer, &iter, 1);
-       g_assert (!_gtk_source_iter_starts_full_word (&iter));
+       g_assert_false (_gtk_source_iter_starts_full_word (&iter));
 
        gtk_text_buffer_get_iter_at_offset (buffer, &iter, 7);
-       g_assert (_gtk_source_iter_starts_full_word (&iter));
+       g_assert_true (_gtk_source_iter_starts_full_word (&iter));
 
        gtk_text_buffer_get_iter_at_offset (buffer, &iter, 10);
-       g_assert (!_gtk_source_iter_starts_full_word (&iter));
+       g_assert_false (_gtk_source_iter_starts_full_word (&iter));
 
        gtk_text_buffer_set_text (buffer, " ab ", -1);
        gtk_text_buffer_get_iter_at_offset (buffer, &iter, 0);
-       g_assert (!_gtk_source_iter_starts_full_word (&iter));
+       g_assert_false (_gtk_source_iter_starts_full_word (&iter));
 
        gtk_text_buffer_get_iter_at_offset (buffer, &iter, 4);
-       g_assert (!_gtk_source_iter_starts_full_word (&iter));
+       g_assert_false (_gtk_source_iter_starts_full_word (&iter));
 
        g_object_unref (buffer);
 }
@@ -111,22 +111,22 @@ test_ends_full_word (void)
        gtk_text_buffer_set_text (buffer, "foo--- ---bar ", -1);
 
        gtk_text_buffer_get_iter_at_offset (buffer, &iter, 14);
-       g_assert (!_gtk_source_iter_ends_full_word (&iter));
+       g_assert_false (_gtk_source_iter_ends_full_word (&iter));
 
        gtk_text_buffer_get_iter_at_offset (buffer, &iter, 13);
-       g_assert (_gtk_source_iter_ends_full_word (&iter));
+       g_assert_true (_gtk_source_iter_ends_full_word (&iter));
 
        gtk_text_buffer_get_iter_at_offset (buffer, &iter, 12);
-       g_assert (!_gtk_source_iter_ends_full_word (&iter));
+       g_assert_false (_gtk_source_iter_ends_full_word (&iter));
 
        gtk_text_buffer_get_iter_at_offset (buffer, &iter, 6);
-       g_assert (_gtk_source_iter_ends_full_word (&iter));
+       g_assert_true (_gtk_source_iter_ends_full_word (&iter));
 
        gtk_text_buffer_get_iter_at_offset (buffer, &iter, 3);
-       g_assert (!_gtk_source_iter_ends_full_word (&iter));
+       g_assert_false (_gtk_source_iter_ends_full_word (&iter));
 
        gtk_text_buffer_get_iter_at_offset (buffer, &iter, 0);
-       g_assert (!_gtk_source_iter_ends_full_word (&iter));
+       g_assert_false (_gtk_source_iter_ends_full_word (&iter));
 
        g_object_unref (buffer);
 }
diff --git a/testsuite/test-language.c b/testsuite/test-language.c
index 43b142aa..3bfba724 100644
--- a/testsuite/test-language.c
+++ b/testsuite/test-language.c
@@ -120,7 +120,7 @@ check_language (GtkSourceLanguage  *language,
        g_assert_cmpstr (gtk_source_language_get_id (language), ==, id);
        g_assert_cmpstr (gtk_source_language_get_name (language), ==, expected_name);
        g_assert_cmpstr (gtk_source_language_get_section (language), ==, expected_section);
-       g_assert (gtk_source_language_get_hidden (language) == expected_hidden);
+       g_assert_cmpint (gtk_source_language_get_hidden (language), ==, expected_hidden);
        g_assert_cmpstr (gtk_source_language_get_metadata (language, "extra-meta"), ==, expected_extra_meta);
 
        mime = gtk_source_language_get_mime_types (language);
diff --git a/testsuite/test-languagemanager.c b/testsuite/test-languagemanager.c
index 6298a59c..6ac6b6ae 100644
--- a/testsuite/test-languagemanager.c
+++ b/testsuite/test-languagemanager.c
@@ -60,7 +60,7 @@ test_get_default (void)
 
        lm1 = gtk_source_language_manager_get_default ();
        lm2 = gtk_source_language_manager_get_default ();
-       g_assert (lm1 == lm2);
+       g_assert_true (lm1 == lm2);
 }
 
 static void
@@ -71,20 +71,20 @@ test_get_language (void)
 
        lm = gtk_source_language_manager_get_default ();
        ids = gtk_source_language_manager_get_language_ids (lm);
-       g_assert (ids != NULL);
+       g_assert_nonnull (ids);
 
        while (*ids != NULL)
        {
                GtkSourceLanguage *lang1, *lang2;
 
                lang1 = gtk_source_language_manager_get_language (lm, *ids);
-               g_assert (lang1 != NULL);
-               g_assert (GTK_SOURCE_IS_LANGUAGE (lang1));
+               g_assert_nonnull (lang1);
+               g_assert_true (GTK_SOURCE_IS_LANGUAGE (lang1));
                g_assert_cmpstr (*ids, == , gtk_source_language_get_id (lang1));
 
                /* langs are owned by the manager */
                lang2 = gtk_source_language_manager_get_language (lm, *ids);
-               g_assert (lang1 == lang2);
+               g_assert_true (lang1 == lang2);
 
                ++ids;
        }
@@ -143,16 +143,16 @@ test_guess_language (void)
        g_test_trap_assert_failed ();
 
        l = gtk_source_language_manager_guess_language (lm, "foo.abcdef", NULL);
-       g_assert (l == NULL);
+       g_assert_null (l);
 
        l = gtk_source_language_manager_guess_language (lm, "foo.abcdef", "");
-       g_assert (l == NULL);
+       g_assert_null (l);
 
        l = gtk_source_language_manager_guess_language (lm, NULL, "image/png");
-       g_assert (l == NULL);
+       g_assert_null (l);
 
        l = gtk_source_language_manager_guess_language (lm, "", "image/png");
-       g_assert (l == NULL);
+       g_assert_null (l);
 
        l = gtk_source_language_manager_guess_language (lm, "foo.c", NULL);
        g_assert_cmpstr (gtk_source_language_get_id (l), ==, "c");
diff --git a/testsuite/test-mark.c b/testsuite/test-mark.c
index 859821cb..4d118195 100644
--- a/testsuite/test-mark.c
+++ b/testsuite/test-mark.c
@@ -30,9 +30,9 @@ test_create (void)
        m = gtk_source_mark_new ("Mark 1", "test");
        g_assert_cmpstr ("Mark 1", ==, gtk_text_mark_get_name (GTK_TEXT_MARK (m)));
        g_assert_cmpstr ("test", ==, gtk_source_mark_get_category (m));
-       g_assert (NULL == gtk_text_mark_get_buffer (GTK_TEXT_MARK (m)));
-       g_assert (NULL == gtk_source_mark_next (m, NULL));
-       g_assert (NULL == gtk_source_mark_prev (m, NULL));
+       g_assert_null (gtk_text_mark_get_buffer (GTK_TEXT_MARK (m)));
+       g_assert_null (gtk_source_mark_next (m, NULL));
+       g_assert_null (gtk_source_mark_prev (m, NULL));
        g_object_unref (m);
 }
 
@@ -55,15 +55,15 @@ test_prev_next (void)
        gtk_text_iter_forward_char (&iter);
        mark3 = gtk_source_buffer_create_source_mark (source_buffer, NULL, "cat1", &iter);
 
-       g_assert (mark2 == gtk_source_mark_next (mark1, NULL));
-       g_assert (mark3 == gtk_source_mark_next (mark1, "cat1"));
-       g_assert (NULL == gtk_source_mark_next (mark2, "cat2"));
-       g_assert (NULL == gtk_source_mark_next (mark3, NULL));
+       g_assert_true (mark2 == gtk_source_mark_next (mark1, NULL));
+       g_assert_true (mark3 == gtk_source_mark_next (mark1, "cat1"));
+       g_assert_null (gtk_source_mark_next (mark2, "cat2"));
+       g_assert_null (gtk_source_mark_next (mark3, NULL));
 
-       g_assert (mark1 == gtk_source_mark_prev (mark2, NULL));
-       g_assert (mark1 == gtk_source_mark_prev (mark3, "cat1"));
-       g_assert (NULL == gtk_source_mark_prev (mark2, "cat2"));
-       g_assert (NULL == gtk_source_mark_prev (mark1, NULL));
+       g_assert_true (mark1 == gtk_source_mark_prev (mark2, NULL));
+       g_assert_true (mark1 == gtk_source_mark_prev (mark3, "cat1"));
+       g_assert_null (gtk_source_mark_prev (mark2, "cat2"));
+       g_assert_null (gtk_source_mark_prev (mark1, NULL));
 
        g_object_unref (source_buffer);
 }
@@ -123,15 +123,15 @@ test_get_source_marks_at_iter (void)
 
        list = gtk_source_buffer_get_source_marks_at_iter (source_buffer, &iter, "cat1");
        g_assert_cmpint (2, ==, g_slist_length (list));
-       g_assert (g_slist_find (list, mark1) != NULL);
-       g_assert (g_slist_find (list, mark3) != NULL);
+       g_assert_nonnull (g_slist_find (list, mark1));
+       g_assert_nonnull (g_slist_find (list, mark3));
        g_slist_free (list);
 
        list = gtk_source_buffer_get_source_marks_at_iter (source_buffer, &iter, NULL);
        g_assert_cmpint (3, ==, g_slist_length (list));
-       g_assert (g_slist_find (list, mark1) != NULL);
-       g_assert (g_slist_find (list, mark2) != NULL);
-       g_assert (g_slist_find (list, mark3) != NULL);
+       g_assert_nonnull (g_slist_find (list, mark1));
+       g_assert_nonnull (g_slist_find (list, mark2));
+       g_assert_nonnull (g_slist_find (list, mark3));
 
        g_object_unref (source_buffer);
 }
diff --git a/testsuite/test-printcompositor.c b/testsuite/test-printcompositor.c
index ba88b212..99897bd6 100644
--- a/testsuite/test-printcompositor.c
+++ b/testsuite/test-printcompositor.c
@@ -32,11 +32,11 @@ test_buffer_ref (void)
 
        compositor = gtk_source_print_compositor_new (buffer_original);
        buffer = gtk_source_print_compositor_get_buffer (compositor);
-       g_assert (GTK_SOURCE_IS_BUFFER (buffer));
+       g_assert_true (GTK_SOURCE_IS_BUFFER (buffer));
 
        g_object_unref (G_OBJECT (buffer_original));
        buffer = gtk_source_print_compositor_get_buffer (compositor);
-       g_assert (GTK_SOURCE_IS_BUFFER (buffer));
+       g_assert_true (GTK_SOURCE_IS_BUFFER (buffer));
 }
 
 static void
@@ -49,11 +49,11 @@ test_buffer_view_ref (void)
        view = gtk_source_view_new ();
        compositor = gtk_source_print_compositor_new_from_view (GTK_SOURCE_VIEW (view));
        buffer = gtk_source_print_compositor_get_buffer (compositor);
-       g_assert (GTK_SOURCE_IS_BUFFER (buffer));
+       g_assert_true (GTK_SOURCE_IS_BUFFER (buffer));
 
        gtk_widget_destroy (view);
        buffer = gtk_source_print_compositor_get_buffer (compositor);
-       g_assert (GTK_SOURCE_IS_BUFFER (buffer));
+       g_assert_true (GTK_SOURCE_IS_BUFFER (buffer));
 
        g_object_unref (G_OBJECT (compositor));
 }
diff --git a/testsuite/test-regex.c b/testsuite/test-regex.c
index c8a1cf52..6e173b58 100644
--- a/testsuite/test-regex.c
+++ b/testsuite/test-regex.c
@@ -30,7 +30,7 @@ test_slash_c_pattern (void)
 
        regex = _gtk_source_regex_new ("\\C", 0, &error);
        g_assert_error (error, G_REGEX_ERROR, G_REGEX_ERROR_COMPILE);
-       g_assert (regex == NULL);
+       g_assert_null (regex);
 }
 
 int
diff --git a/testsuite/test-region.c b/testsuite/test-region.c
index c64e0f1b..38eb31fc 100644
--- a/testsuite/test-region.c
+++ b/testsuite/test-region.c
@@ -38,15 +38,15 @@ test_weak_ref (void)
        gtk_text_buffer_get_bounds (buffer, &start, &end);
        gtk_source_region_add_subregion (region, &start, &end);
 
-       g_assert (!gtk_source_region_is_empty (region));
+       g_assert_false (gtk_source_region_is_empty (region));
 
        g_object_unref (buffer);
 
-       g_assert (gtk_source_region_is_empty (region));
-       g_assert (!gtk_source_region_get_bounds (region, &start, &end));
+       g_assert_true (gtk_source_region_is_empty (region));
+       g_assert_false (gtk_source_region_get_bounds (region, &start, &end));
 
        gtk_source_region_get_start_region_iter (region, &region_iter);
-       g_assert (!gtk_source_region_iter_get_subregion (&region_iter, &start, &end));
+       g_assert_false (gtk_source_region_iter_get_subregion (&region_iter, &start, &end));
 
        g_object_unref (region);
 }
@@ -92,11 +92,11 @@ check_result (GtkSourceRegion *region,
 
        if (expected_result == NULL)
        {
-               g_assert (gtk_source_region_is_empty (region));
+               g_assert_true (gtk_source_region_is_empty (region));
                return;
        }
 
-       g_assert (!gtk_source_region_is_empty (region));
+       g_assert_false (gtk_source_region_is_empty (region));
 
        expected_region_str = g_strconcat ("Subregions: ", expected_result, NULL);
        region_str = gtk_source_region_to_string (region);
@@ -117,13 +117,13 @@ test_add_subtract_subregion (void)
 
        gtk_text_buffer_set_text (buffer, "This is a test of GtkSourceRegion", -1);
 
-       g_assert (gtk_source_region_is_empty (region));
+       g_assert_true (gtk_source_region_is_empty (region));
 
        /* Add/remove 0-length subregions */
        add_subregion (region, 5, 5);
-       g_assert (gtk_source_region_is_empty (region));
+       g_assert_true (gtk_source_region_is_empty (region));
        subtract_subregion (region, 5, 5);
-       g_assert (gtk_source_region_is_empty (region));
+       g_assert_true (gtk_source_region_is_empty (region));
 
        /* Add subregion */
        add_subregion (region, 5, 10);
@@ -138,7 +138,7 @@ test_add_subtract_subregion (void)
 
        /* Remove all */
        subtract_subregion (region, 1, 15);
-       g_assert (gtk_source_region_is_empty (region));
+       g_assert_true (gtk_source_region_is_empty (region));
 
        /* Add two separate subregions */
        add_subregion (region, 5, 10);
@@ -238,7 +238,7 @@ test_intersect_subregion (void)
 
        gtk_text_buffer_set_text (buffer, "This is a test of GtkSourceRegion", -1);
 
-       g_assert (gtk_source_region_is_empty (region));
+       g_assert_true (gtk_source_region_is_empty (region));
 
        add_subregion (region, 0, 2);
        add_subregion (region, 10, 15);
@@ -269,7 +269,7 @@ test_add_subtract_intersect_region (void)
 
        gtk_text_buffer_set_text (buffer, "This is a test of GtkSourceRegion", -1);
 
-       g_assert (gtk_source_region_is_empty (main_region));
+       g_assert_true (gtk_source_region_is_empty (main_region));
 
        /* Basic tests */
 
diff --git a/testsuite/test-search-context.c b/testsuite/test-search-context.c
index cde881fe..488691f4 100644
--- a/testsuite/test-search-context.c
+++ b/testsuite/test-search-context.c
@@ -339,7 +339,7 @@ test_case_sensitivity (void)
 
        gtk_source_search_settings_set_case_sensitive (settings, TRUE);
        case_sensitive = gtk_source_search_settings_get_case_sensitive (settings);
-       g_assert (case_sensitive);
+       g_assert_true (case_sensitive);
 
        flush_queue ();
        occurrences_count = gtk_source_search_context_get_occurrences_count (context);
@@ -347,7 +347,7 @@ test_case_sensitivity (void)
 
        gtk_source_search_settings_set_case_sensitive (settings, FALSE);
        case_sensitive = gtk_source_search_settings_get_case_sensitive (settings);
-       g_assert (!case_sensitive);
+       g_assert_false (case_sensitive);
 
        flush_queue ();
        occurrences_count = gtk_source_search_context_get_occurrences_count (context);
@@ -374,7 +374,7 @@ test_search_at_word_boundaries (void)
 
        gtk_source_search_settings_set_at_word_boundaries (settings, TRUE);
        at_word_boundaries = gtk_source_search_settings_get_at_word_boundaries (settings);
-       g_assert (at_word_boundaries);
+       g_assert_true (at_word_boundaries);
 
        flush_queue ();
        occurrences_count = gtk_source_search_context_get_occurrences_count (context);
@@ -396,7 +396,7 @@ test_search_at_word_boundaries (void)
 
        gtk_source_search_settings_set_at_word_boundaries (settings, FALSE);
        at_word_boundaries = gtk_source_search_settings_get_at_word_boundaries (settings);
-       g_assert (!at_word_boundaries);
+       g_assert_false (at_word_boundaries);
 
        flush_queue ();
        occurrences_count = gtk_source_search_context_get_occurrences_count (context);
@@ -603,7 +603,7 @@ test_forward_search (void)
 
        gtk_source_search_settings_set_wrap_around (settings, TRUE);
        wrap_around = gtk_source_search_settings_get_wrap_around (settings);
-       g_assert (wrap_around);
+       g_assert_true (wrap_around);
 
        check_search_results (source_buffer, context, results1, TRUE);
 
@@ -621,7 +621,7 @@ test_forward_search (void)
 
        gtk_source_search_settings_set_wrap_around (settings, FALSE);
        wrap_around = gtk_source_search_settings_get_wrap_around (settings);
-       g_assert (!wrap_around);
+       g_assert_false (wrap_around);
 
        check_search_results (source_buffer, context, results2, TRUE);
 
@@ -828,11 +828,11 @@ test_highlight (void)
 
        gtk_source_search_context_set_highlight (context1, TRUE);
        highlight = gtk_source_search_context_get_highlight (context1);
-       g_assert (highlight);
+       g_assert_true (highlight);
 
        gtk_source_search_context_set_highlight (context2, FALSE);
        highlight = gtk_source_search_context_get_highlight (context2);
-       g_assert (!highlight);
+       g_assert_false (highlight);
 
        g_object_unref (source_buffer);
        g_object_unref (context1);
@@ -846,11 +846,11 @@ test_get_search_text (void)
        const gchar *search_text;
 
        search_text = gtk_source_search_settings_get_search_text (settings);
-       g_assert (search_text == NULL);
+       g_assert_null (search_text);
 
        gtk_source_search_settings_set_search_text (settings, "");
        search_text = gtk_source_search_settings_get_search_text (settings);
-       g_assert (search_text == NULL);
+       g_assert_null (search_text);
 
        gtk_source_search_settings_set_search_text (settings, "search-text");
        search_text = gtk_source_search_settings_get_search_text (settings);
@@ -917,13 +917,13 @@ test_replace (void)
        gtk_text_buffer_get_iter_at_offset (text_buffer, &end, 3);
 
        replaced = gtk_source_search_context_replace (context, &start, &end, "bbb", -1, NULL);
-       g_assert (!replaced);
+       g_assert_false (replaced);
 
        gtk_text_buffer_get_iter_at_offset (text_buffer, &start, 2);
        gtk_text_buffer_get_iter_at_offset (text_buffer, &end, 4);
 
        replaced = gtk_source_search_context_replace (context, &start, &end, "bbb", -1, NULL);
-       g_assert (replaced);
+       g_assert_true (replaced);
        offset = gtk_text_iter_get_offset (&start);
        g_assert_cmpint (offset, ==, 2);
        offset = gtk_text_iter_get_offset (&end);
@@ -980,7 +980,7 @@ test_regex_basics (void)
        gtk_text_buffer_set_text (text_buffer, "hello\nworld\n", -1);
        gtk_source_search_settings_set_regex_enabled (settings, TRUE);
        regex_enabled = gtk_source_search_settings_get_regex_enabled (settings);
-       g_assert (regex_enabled);
+       g_assert_true (regex_enabled);
 
        /* Simple regex */
 
@@ -1005,8 +1005,8 @@ test_regex_basics (void)
        gtk_text_buffer_get_start_iter (text_buffer, &start);
        gtk_text_buffer_get_end_iter (text_buffer, &end);
        gtk_source_search_context_replace (context, &start, &end, "\\2#\\1", -1, NULL);
-       g_assert (gtk_text_iter_is_start (&start));
-       g_assert (gtk_text_iter_is_end (&end));
+       g_assert_true (gtk_text_iter_is_start (&start));
+       g_assert_true (gtk_text_iter_is_end (&end));
 
        contents = get_buffer_contents (text_buffer);
        g_assert_cmpstr (contents, ==, "bb#aa");
@@ -1054,8 +1054,8 @@ test_regex_at_word_boundaries (void)
                                                   &match_start,
                                                   &match_end,
                                                   &has_wrapped_around);
-       g_assert (found);
-       g_assert (!has_wrapped_around);
+       g_assert_true (found);
+       g_assert_false (has_wrapped_around);
 
        offset = gtk_text_iter_get_offset (&match_start);
        g_assert_cmpint (offset, ==, 0);
@@ -1068,8 +1068,8 @@ test_regex_at_word_boundaries (void)
                                                   &match_start,
                                                   &match_end,
                                                   &has_wrapped_around);
-       g_assert (found);
-       g_assert (!has_wrapped_around);
+       g_assert_true (found);
+       g_assert_false (has_wrapped_around);
 
        offset = gtk_text_iter_get_offset (&match_start);
        g_assert_cmpint (offset, ==, 11);
@@ -1087,7 +1087,7 @@ test_regex_at_word_boundaries (void)
        gtk_source_search_context_replace (context, &match_start, &match_end, "bbb", -1, NULL);
        offset = gtk_text_iter_get_offset (&match_start);
        g_assert_cmpint (offset, ==, 1);
-       g_assert (gtk_text_iter_is_end (&match_end));
+       g_assert_true (gtk_text_iter_is_end (&match_end));
 
        content = get_buffer_contents (text_buffer);
        g_assert_cmpstr (content, ==, "&bbb");
@@ -1104,7 +1104,7 @@ test_regex_at_word_boundaries (void)
        gtk_source_search_context_replace (context, &match_start, &match_end, "bbb", -1, NULL);
        offset = gtk_text_iter_get_offset (&match_start);
        g_assert_cmpint (offset, ==, 1);
-       g_assert (gtk_text_iter_is_end (&match_end));
+       g_assert_true (gtk_text_iter_is_end (&match_end));
 
        content = get_buffer_contents (text_buffer);
        g_assert_cmpstr (content, ==, "–bbb");
@@ -1150,8 +1150,8 @@ test_regex_look_behind (void)
                                                   &match_start,
                                                   &match_end,
                                                   &has_wrapped_around);
-       g_assert (found);
-       g_assert (!has_wrapped_around);
+       g_assert_true (found);
+       g_assert_false (has_wrapped_around);
 
        offset = gtk_text_iter_get_offset (&match_start);
        g_assert_cmpint (offset, ==, 7);
@@ -1165,8 +1165,8 @@ test_regex_look_behind (void)
                                                    &match_start,
                                                    &match_end,
                                                    &has_wrapped_around);
-       g_assert (found);
-       g_assert (!has_wrapped_around);
+       g_assert_true (found);
+       g_assert_false (has_wrapped_around);
 
        offset = gtk_text_iter_get_offset (&match_start);
        g_assert_cmpint (offset, ==, 7);
@@ -1236,8 +1236,8 @@ test_regex_look_ahead (void)
                                                   &match_start,
                                                   &match_end,
                                                   &has_wrapped_around);
-       g_assert (found);
-       g_assert (!has_wrapped_around);
+       g_assert_true (found);
+       g_assert_false (has_wrapped_around);
 
        offset = gtk_text_iter_get_offset (&match_start);
        g_assert_cmpint (offset, ==, 6);
@@ -1251,8 +1251,8 @@ test_regex_look_ahead (void)
                                                    &match_start,
                                                    &match_end,
                                                    &has_wrapped_around);
-       g_assert (found);
-       g_assert (!has_wrapped_around);
+       g_assert_true (found);
+       g_assert_false (has_wrapped_around);
 
        offset = gtk_text_iter_get_offset (&match_start);
        g_assert_cmpint (offset, ==, 6);
diff --git a/testsuite/test-space-drawer.c b/testsuite/test-space-drawer.c
index a673b86a..d5f5033d 100644
--- a/testsuite/test-space-drawer.c
+++ b/testsuite/test-space-drawer.c
@@ -86,7 +86,7 @@ check_equal_matrix (GtkSourceSpaceDrawer    *drawer,
        /* Check variants */
        my_variant = create_variant_from_matrix (matrix);
        drawer_variant = gtk_source_space_drawer_get_matrix (drawer);
-       g_assert (g_variant_equal (my_variant, drawer_variant));
+       g_assert_true (g_variant_equal (my_variant, drawer_variant));
 
        gtk_source_space_drawer_set_types_for_locations (drawer,
                                                         GTK_SOURCE_SPACE_LOCATION_ALL,
@@ -97,7 +97,7 @@ check_equal_matrix (GtkSourceSpaceDrawer    *drawer,
 
        my_variant = create_variant_from_matrix (matrix);
        drawer_variant = gtk_source_space_drawer_get_matrix (drawer);
-       g_assert (g_variant_equal (my_variant, drawer_variant));
+       g_assert_true (g_variant_equal (my_variant, drawer_variant));
        g_variant_ref_sink (my_variant);
        g_variant_unref (my_variant);
        g_variant_ref_sink (drawer_variant);
diff --git a/testsuite/test-stylescheme.c b/testsuite/test-stylescheme.c
index a6246fb3..38365711 100644
--- a/testsuite/test-stylescheme.c
+++ b/testsuite/test-stylescheme.c
@@ -94,7 +94,7 @@ compare_strv (const gchar **strv,
        }
        else
        {
-               g_assert (strv == NULL);
+               g_assert_null (strv);
        }
 }
 
@@ -114,7 +114,7 @@ check_scheme (GtkSourceStyleScheme  *scheme,
        compare_strv ((const gchar **)gtk_source_style_scheme_get_authors (scheme), expected_authors);
 
        style = gtk_source_style_scheme_get_style (scheme, style_id);
-       g_assert (GTK_SOURCE_IS_STYLE (style));
+       g_assert_true (GTK_SOURCE_IS_STYLE (style));
 }
 
 static void
@@ -140,12 +140,12 @@ test_named_color_alpha (TestFixture   *fixture,
 
        /* Use these two semi private methods to compare a named color and a normal one */
        res = _gtk_source_style_scheme_get_current_line_color (scheme, &color1);
-       g_assert (res);
+       g_assert_true (res);
 
        res = _gtk_source_style_scheme_get_background_pattern_color (scheme, &color2);
-       g_assert (res);
+       g_assert_true (res);
 
-       g_assert (gdk_rgba_equal (&color1, &color2));
+       g_assert_true (gdk_rgba_equal (&color1, &color2));
 }
 
 int
diff --git a/testsuite/test-styleschememanager.c b/testsuite/test-styleschememanager.c
index 16b72729..92e82a91 100644
--- a/testsuite/test-styleschememanager.c
+++ b/testsuite/test-styleschememanager.c
@@ -28,7 +28,7 @@ test_get_default (void)
 
        sm1 = gtk_source_style_scheme_manager_get_default ();
        sm2 = gtk_source_style_scheme_manager_get_default ();
-       g_assert (sm1 == sm2);
+       g_assert_true (sm1 == sm2);
 }
 
 static void
diff --git a/testsuite/test-undo-manager.c b/testsuite/test-undo-manager.c
index 91d402c5..baecfa06 100644
--- a/testsuite/test-undo-manager.c
+++ b/testsuite/test-undo-manager.c
@@ -175,20 +175,20 @@ test_single_action (void)
        GtkSourceBuffer *buffer = gtk_source_buffer_new (NULL);
        gtk_source_buffer_set_max_undo_levels (buffer, -1);
 
-       g_assert (!gtk_source_buffer_can_undo (buffer));
-       g_assert (!gtk_source_buffer_can_redo (buffer));
+       g_assert_false (gtk_source_buffer_can_undo (buffer));
+       g_assert_false (gtk_source_buffer_can_redo (buffer));
 
        insert_text (buffer, "foo");
-       g_assert (gtk_source_buffer_can_undo (buffer));
-       g_assert (!gtk_source_buffer_can_redo (buffer));
+       g_assert_true (gtk_source_buffer_can_undo (buffer));
+       g_assert_false (gtk_source_buffer_can_redo (buffer));
 
        gtk_source_buffer_undo (buffer);
-       g_assert (!gtk_source_buffer_can_undo (buffer));
-       g_assert (gtk_source_buffer_can_redo (buffer));
+       g_assert_false (gtk_source_buffer_can_undo (buffer));
+       g_assert_true (gtk_source_buffer_can_redo (buffer));
 
        gtk_source_buffer_redo (buffer);
-       g_assert (gtk_source_buffer_can_undo (buffer));
-       g_assert (!gtk_source_buffer_can_redo (buffer));
+       g_assert_true (gtk_source_buffer_can_undo (buffer));
+       g_assert_false (gtk_source_buffer_can_redo (buffer));
 
        g_object_unref (buffer);
 }
@@ -201,16 +201,16 @@ test_lose_redo_actions (void)
 
        insert_text (buffer, "foo\n");
        insert_text (buffer, "bar\n");
-       g_assert (gtk_source_buffer_can_undo (buffer));
-       g_assert (!gtk_source_buffer_can_redo (buffer));
+       g_assert_true (gtk_source_buffer_can_undo (buffer));
+       g_assert_false (gtk_source_buffer_can_redo (buffer));
 
        gtk_source_buffer_undo (buffer);
-       g_assert (gtk_source_buffer_can_undo (buffer));
-       g_assert (gtk_source_buffer_can_redo (buffer));
+       g_assert_true (gtk_source_buffer_can_undo (buffer));
+       g_assert_true (gtk_source_buffer_can_redo (buffer));
 
        insert_text (buffer, "baz\n");
-       g_assert (gtk_source_buffer_can_undo (buffer));
-       g_assert (!gtk_source_buffer_can_redo (buffer));
+       g_assert_true (gtk_source_buffer_can_undo (buffer));
+       g_assert_false (gtk_source_buffer_can_redo (buffer));
 
        g_object_unref (buffer);
 }
@@ -251,10 +251,10 @@ test_max_undo_levels (void)
        }
 
        gtk_source_buffer_undo (buffer);
-       g_assert (gtk_source_buffer_can_redo (buffer));
+       g_assert_true (gtk_source_buffer_can_redo (buffer));
 
        gtk_source_buffer_set_max_undo_levels (buffer, 2);
-       g_assert (!gtk_source_buffer_can_redo (buffer));
+       g_assert_false (gtk_source_buffer_can_redo (buffer));
 
        g_object_unref (buffer);
 }
@@ -270,8 +270,8 @@ test_not_undoable_action (void)
        gtk_text_buffer_set_text (GTK_TEXT_BUFFER (buffer), "foo\n", -1);
        gtk_source_buffer_end_not_undoable_action (buffer);
 
-       g_assert (!gtk_source_buffer_can_undo (buffer));
-       g_assert (!gtk_source_buffer_can_redo (buffer));
+       g_assert_false (gtk_source_buffer_can_undo (buffer));
+       g_assert_false (gtk_source_buffer_can_redo (buffer));
 
        /* begin_user_action inside */
        gtk_source_buffer_begin_not_undoable_action (buffer);
@@ -280,38 +280,38 @@ test_not_undoable_action (void)
        gtk_text_buffer_end_user_action (GTK_TEXT_BUFFER (buffer));
        gtk_source_buffer_end_not_undoable_action (buffer);
 
-       g_assert (!gtk_source_buffer_can_undo (buffer));
-       g_assert (!gtk_source_buffer_can_redo (buffer));
+       g_assert_false (gtk_source_buffer_can_undo (buffer));
+       g_assert_false (gtk_source_buffer_can_redo (buffer));
 
        /* In the middle of an action history */
        insert_text (buffer, "foo\n");
        insert_text (buffer, "bar\n");
-       g_assert (gtk_source_buffer_can_undo (buffer));
-       g_assert (!gtk_source_buffer_can_redo (buffer));
+       g_assert_true (gtk_source_buffer_can_undo (buffer));
+       g_assert_false (gtk_source_buffer_can_redo (buffer));
 
        gtk_source_buffer_undo (buffer);
-       g_assert (gtk_source_buffer_can_undo (buffer));
-       g_assert (gtk_source_buffer_can_redo (buffer));
+       g_assert_true (gtk_source_buffer_can_undo (buffer));
+       g_assert_true (gtk_source_buffer_can_redo (buffer));
 
        gtk_source_buffer_begin_not_undoable_action (buffer);
        gtk_text_buffer_set_text (GTK_TEXT_BUFFER (buffer), "new text\n", -1);
        gtk_source_buffer_end_not_undoable_action (buffer);
 
-       g_assert (!gtk_source_buffer_can_undo (buffer));
-       g_assert (!gtk_source_buffer_can_redo (buffer));
+       g_assert_false (gtk_source_buffer_can_undo (buffer));
+       g_assert_false (gtk_source_buffer_can_redo (buffer));
 
        /* Empty undoable action */
        insert_text (buffer, "foo\n");
        insert_text (buffer, "bar\n");
        gtk_source_buffer_undo (buffer);
-       g_assert (gtk_source_buffer_can_undo (buffer));
-       g_assert (gtk_source_buffer_can_redo (buffer));
+       g_assert_true (gtk_source_buffer_can_undo (buffer));
+       g_assert_true (gtk_source_buffer_can_redo (buffer));
 
        gtk_source_buffer_begin_not_undoable_action (buffer);
        gtk_source_buffer_end_not_undoable_action (buffer);
 
-       g_assert (!gtk_source_buffer_can_undo (buffer));
-       g_assert (!gtk_source_buffer_can_redo (buffer));
+       g_assert_false (gtk_source_buffer_can_undo (buffer));
+       g_assert_false (gtk_source_buffer_can_redo (buffer));
 
        /* Behavior _during_ a not undoable action */
 
@@ -327,18 +327,18 @@ test_not_undoable_action (void)
        gtk_source_buffer_undo (buffer);
 
        gtk_source_buffer_begin_not_undoable_action (buffer);
-       g_assert (gtk_source_buffer_can_undo (buffer));
-       g_assert (gtk_source_buffer_can_redo (buffer));
+       g_assert_true (gtk_source_buffer_can_undo (buffer));
+       g_assert_true (gtk_source_buffer_can_redo (buffer));
 
        gtk_source_buffer_redo (buffer);
-       g_assert (gtk_source_buffer_can_undo (buffer));
-       g_assert (!gtk_source_buffer_can_redo (buffer));
+       g_assert_true (gtk_source_buffer_can_undo (buffer));
+       g_assert_false (gtk_source_buffer_can_redo (buffer));
 
        gtk_text_buffer_set_text (GTK_TEXT_BUFFER (buffer), "new text\n", -1);
 
        gtk_source_buffer_end_not_undoable_action (buffer);
-       g_assert (!gtk_source_buffer_can_undo (buffer));
-       g_assert (!gtk_source_buffer_can_redo (buffer));
+       g_assert_false (gtk_source_buffer_can_undo (buffer));
+       g_assert_false (gtk_source_buffer_can_redo (buffer));
 
        /* Nested */
        insert_text (buffer, "foo\n");
@@ -355,12 +355,12 @@ test_not_undoable_action (void)
        insert_text (buffer, "blah\n");
 
        gtk_source_buffer_end_not_undoable_action (buffer);
-       g_assert (!gtk_source_buffer_can_undo (buffer));
-       g_assert (!gtk_source_buffer_can_redo (buffer));
+       g_assert_false (gtk_source_buffer_can_undo (buffer));
+       g_assert_false (gtk_source_buffer_can_redo (buffer));
 
        insert_text (buffer, "blah\n");
-       g_assert (gtk_source_buffer_can_undo (buffer));
-       g_assert (!gtk_source_buffer_can_redo (buffer));
+       g_assert_true (gtk_source_buffer_can_undo (buffer));
+       g_assert_false (gtk_source_buffer_can_redo (buffer));
 
        g_object_unref (buffer);
 }
@@ -390,7 +390,7 @@ check_contents_history (GtkSourceBuffer *buffer,
                }
                else
                {
-                       g_assert (l->prev == NULL);
+                       g_assert_null (l->prev);
                }
        }
 
@@ -407,7 +407,7 @@ check_contents_history (GtkSourceBuffer *buffer,
                }
                else
                {
-                       g_assert (l->next == NULL);
+                       g_assert_null (l->next);
                }
        }
 }
@@ -593,24 +593,24 @@ test_modified (void)
        gtk_text_buffer_set_modified (text_buffer, FALSE);
        insert_text (source_buffer, "foo\n");
 
-       g_assert (gtk_text_buffer_get_modified (text_buffer));
+       g_assert_true (gtk_text_buffer_get_modified (text_buffer));
        gtk_source_buffer_undo (source_buffer);
-       g_assert (!gtk_text_buffer_get_modified (text_buffer));
+       g_assert_false (gtk_text_buffer_get_modified (text_buffer));
        gtk_source_buffer_redo (source_buffer);
-       g_assert (gtk_text_buffer_get_modified (text_buffer));
+       g_assert_true (gtk_text_buffer_get_modified (text_buffer));
 
        gtk_text_buffer_set_modified (text_buffer, FALSE);
        gtk_source_buffer_undo (source_buffer);
-       g_assert (gtk_text_buffer_get_modified (text_buffer));
+       g_assert_true (gtk_text_buffer_get_modified (text_buffer));
        gtk_source_buffer_redo (source_buffer);
-       g_assert (!gtk_text_buffer_get_modified (text_buffer));
+       g_assert_false (gtk_text_buffer_get_modified (text_buffer));
 
        gtk_source_buffer_undo (source_buffer);
-       g_assert (gtk_text_buffer_get_modified (text_buffer));
+       g_assert_true (gtk_text_buffer_get_modified (text_buffer));
        insert_text (source_buffer, "bar\n");
-       g_assert (gtk_text_buffer_get_modified (text_buffer));
+       g_assert_true (gtk_text_buffer_get_modified (text_buffer));
        gtk_source_buffer_undo (source_buffer);
-       g_assert (gtk_text_buffer_get_modified (text_buffer));
+       g_assert_true (gtk_text_buffer_get_modified (text_buffer));
 
        g_object_unref (source_buffer);
 
@@ -627,10 +627,10 @@ test_modified (void)
        gtk_source_buffer_end_not_undoable_action (source_buffer);
 
        insert_text (source_buffer, "b\n");
-       g_assert (gtk_text_buffer_get_modified (text_buffer));
+       g_assert_true (gtk_text_buffer_get_modified (text_buffer));
 
        gtk_source_buffer_undo (source_buffer);
-       g_assert (!gtk_text_buffer_get_modified (text_buffer));
+       g_assert_false (gtk_text_buffer_get_modified (text_buffer));
 
        g_object_unref (source_buffer);
 }
diff --git a/testsuite/test-view.c b/testsuite/test-view.c
index 24955023..349ee47a 100644
--- a/testsuite/test-view.c
+++ b/testsuite/test-view.c
@@ -141,7 +141,7 @@ test_move_lines__move_single_line (void)
                g_free (text);
 
                gtk_text_buffer_get_selection_bounds (buffer, &start, &end);
-               g_assert (gtk_text_iter_is_start (&start));
+               g_assert_true (gtk_text_iter_is_start (&start));
                g_assert_cmpint (gtk_text_iter_get_offset (&end), ==, 6);
        }
 
@@ -166,7 +166,7 @@ test_move_lines__move_single_line (void)
 
                gtk_text_buffer_get_selection_bounds (buffer, &start, &end);
                g_assert_cmpint (gtk_text_iter_get_offset (&start), ==, 12);
-               g_assert (gtk_text_iter_is_end (&end));
+               g_assert_true (gtk_text_iter_is_end (&end));
        }
 
        /* Move down second line, with final newline */
@@ -190,7 +190,7 @@ test_move_lines__move_single_line (void)
 
                gtk_text_buffer_get_selection_bounds (buffer, &start, &end);
                g_assert_cmpint (gtk_text_iter_get_offset (&start), ==, 12);
-               g_assert (gtk_text_iter_is_end (&end));
+               g_assert_true (gtk_text_iter_is_end (&end));
        }
 
        /* Move up third line, without final newline */
@@ -260,8 +260,8 @@ test_move_lines__move_single_line (void)
        g_free (text);
 
        gtk_text_buffer_get_selection_bounds (buffer, &start, &end);
-       g_assert (gtk_text_iter_is_end (&start));
-       g_assert (gtk_text_iter_is_end (&end));
+       g_assert_true (gtk_text_iter_is_end (&start));
+       g_assert_true (gtk_text_iter_is_end (&end));
 
        /* Move up first line */
        gtk_text_buffer_set_text (buffer,
@@ -282,8 +282,8 @@ test_move_lines__move_single_line (void)
        g_free (text);
 
        gtk_text_buffer_get_selection_bounds (buffer, &start, &end);
-       g_assert (gtk_text_iter_is_start (&start));
-       g_assert (gtk_text_iter_is_start (&end));
+       g_assert_true (gtk_text_iter_is_start (&start));
+       g_assert_true (gtk_text_iter_is_start (&end));
 
        g_object_unref (view);
 }
@@ -388,7 +388,7 @@ test_move_lines__move_several_lines (void)
                g_free (text);
 
                gtk_text_buffer_get_selection_bounds (buffer, &start, &end);
-               g_assert (gtk_text_iter_is_start (&start));
+               g_assert_true (gtk_text_iter_is_start (&start));
                g_assert_cmpint (gtk_text_iter_get_offset (&end), ==, 12);
        }
 
@@ -415,7 +415,7 @@ test_move_lines__move_several_lines (void)
 
                gtk_text_buffer_get_selection_bounds (buffer, &start, &end);
                g_assert_cmpint (gtk_text_iter_get_offset (&start), ==, 12);
-               g_assert (gtk_text_iter_is_end (&end));
+               g_assert_true (gtk_text_iter_is_end (&end));
        }
 
        /* Move down second and third lines, with final newline */
@@ -441,7 +441,7 @@ test_move_lines__move_several_lines (void)
 
                gtk_text_buffer_get_selection_bounds (buffer, &start, &end);
                g_assert_cmpint (gtk_text_iter_get_offset (&start), ==, 12);
-               g_assert (gtk_text_iter_is_end (&end));
+               g_assert_true (gtk_text_iter_is_end (&end));
        }
 
        /* Move up third and fourth lines, without final newline */


[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]