[gtksourceview] test-region: write real tests instead of just printing the results



commit f0f86a2fa72b7d5b42b28994b6370a09cc8ca2bb
Author: Sébastien Wilmet <swilmet gnome org>
Date:   Thu Aug 11 10:37:14 2016 +0200

    test-region: write real tests instead of just printing the results
    
    I thought GtkSourceRegion was well tested… It just tested that there was
    no crash or warnings, but it didn't actually check the results!

 testsuite/test-region.c |  337 ++++++++++++++++++++++++++++++-----------------
 1 files changed, 217 insertions(+), 120 deletions(-)
---
diff --git a/testsuite/test-region.c b/testsuite/test-region.c
index 2e0cee2..d0b6884 100644
--- a/testsuite/test-region.c
+++ b/testsuite/test-region.c
@@ -4,7 +4,7 @@
  *
  * Copyright (C) 2003 - Gustavo Giráldez
  * Copyright (C) 2006, 2013 - Paolo Borelli
- * Copyright (C) 2013 - Sébastien Wilmet
+ * Copyright (C) 2013, 2016 - Sébastien Wilmet
  *
  * GtkSourceView is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -24,149 +24,246 @@
 #include <gtksourceview/gtksource.h>
 
 static void
-test_region (void)
+test_weak_ref (void)
 {
        GtkTextBuffer *buffer;
-       GtkSourceRegion *region, *intersection;
-       GtkSourceRegionIter reg_iter;
-       GtkTextIter iter1, iter2;
-       guint i;
-       gchar *region_str = NULL;
-
-#define NUM_OPS 23
-
-       gint ops [NUM_OPS][3] = {
-               /* add/remove a 0-length region */
-               {  1,  5,  5 },
-               { -1,  5,  5 },
-               /* add a region */
-               {  1,  5, 10 },
-               /* add two adjacent regions */
-               {  1,  3,  5 },
-               {  1, 10, 12 },
-               /* remove all */
-               { -1,  1, 15 },
-               /* add two separate regions */
-               {  1,  5, 10 },
-               {  1, 15, 20 },
-               /* join them */
-               {  1,  7, 17 },
-               /* remove from the middle */
-               { -1, 10, 15 },
-               /* exactly remove a subregion */
-               { -1, 15, 20 },
-               /* try to remove an adjacent region */
-               { -1, 10, 20 },
-               /* try to remove an adjacent region */
-               { -1,  0,  5 },
-               /* add another separate */
-               {  1, 15, 20 },
-               /* join with excess */
-               {  1,  0, 25 },
-               /* do two holes */
-               { -1,  5, 10 },
-               { -1, 15, 20 },
-               /* remove the middle subregion */
-               { -1,  8, 22 },
-               /* add the subregion we just removed */
-               {  1, 10, 15 },
-               /* remove the middle subregion */
-               { -1,  3, 17 },
-               /* add the subregion we just removed */
-               {  1, 10, 15 },
-               /* remove the middle subregion */
-               { -1,  2, 23 },
-               /* add the subregion we just removed */
-               {  1, 10, 15 },
-       };
-
-#define NUM_INTERSECTS 5
-
-       gint inter [NUM_INTERSECTS][2] = {
-               {  0, 25 },
-               { 10, 15 },
-               {  8, 17 },
-               {  1, 24 },
-               {  3,  7 }
-       };
+       GtkSourceRegion *region;
+       GtkSourceRegionIter region_iter;
+       GtkTextIter start;
+       GtkTextIter end;
 
        buffer = gtk_text_buffer_new (NULL);
        region = gtk_source_region_new (buffer);
 
-       gtk_text_buffer_get_start_iter (buffer, &iter1);
-       gtk_text_buffer_insert (buffer, &iter1, "This is a test of GtkSourceRegion", -1);
+       gtk_text_buffer_set_text (buffer, "test_weak_ref", -1);
+       gtk_text_buffer_get_bounds (buffer, &start, &end);
+       gtk_source_region_add_subregion (region, &start, &end);
 
-       gtk_source_region_get_start_region_iter (region, &reg_iter);
-       if (!gtk_source_region_iter_is_end (&reg_iter)) {
-               g_print ("problem fetching iterator for an empty region\n");
-               g_assert_not_reached ();
-       }
+       g_assert (!gtk_source_region_is_empty (region));
 
-       for (i = 0; i < NUM_OPS; i++) {
-               const gchar *op_name;
-
-               gtk_text_buffer_get_iter_at_offset (buffer, &iter1, ops [i][1]);
-               gtk_text_buffer_get_iter_at_offset (buffer, &iter2, ops [i][2]);
-
-               if (ops [i][0] > 0) {
-                       op_name = "added";
-                       gtk_source_region_add_subregion (region, &iter1, &iter2);
-               } else {
-                       op_name = "deleted";
-                       gtk_source_region_subtract_subregion (region, &iter1, &iter2);
-               }
-               g_print ("%s %d-%d\n", op_name, ops [i][1], ops [i][2]);
-
-               region_str = gtk_source_region_to_string (region);
-               g_print ("%s\n", region_str);
-               g_free (region_str);
-               region_str = NULL;
-       }
+       g_object_unref (buffer);
 
-       for (i = 0; i < NUM_INTERSECTS; i++) {
-               gtk_text_buffer_get_iter_at_offset (buffer, &iter1, inter [i][0]);
-               gtk_text_buffer_get_iter_at_offset (buffer, &iter2, inter [i][1]);
-
-               g_print ("intersect %d-%d\n", inter [i][0], inter [i][1]);
-               intersection = gtk_source_region_intersect_subregion (region, &iter1, &iter2);
-               if (intersection) {
-                       region_str = gtk_source_region_to_string (region);
-                       g_print ("%s\n", region_str);
-                       g_free (region_str);
-                       region_str = NULL;
-
-                       g_clear_object (&intersection);
-               } else {
-                       g_print ("no intersection\n");
-               }
-       }
+       g_assert (gtk_source_region_is_empty (region));
+       g_assert (!gtk_source_region_get_bounds (region, &start, &end));
 
-       i = 0;
-       gtk_source_region_get_start_region_iter (region, &reg_iter);
+       gtk_source_region_get_start_region_iter (region, &region_iter);
+       g_assert (!gtk_source_region_iter_get_subregion (&region_iter, &start, &end));
 
-       while (!gtk_source_region_iter_is_end (&reg_iter))
-       {
-               GtkTextIter s, e;
+       g_object_unref (region);
+}
+
+static void
+add_subregion (GtkSourceRegion *region,
+              gint             start_offset,
+              gint             end_offset)
+{
+       GtkTextBuffer *buffer;
+       GtkTextIter start_iter;
+       GtkTextIter end_iter;
+
+       buffer = gtk_source_region_get_buffer (region);
+       gtk_text_buffer_get_iter_at_offset (buffer, &start_iter, start_offset);
+       gtk_text_buffer_get_iter_at_offset (buffer, &end_iter, end_offset);
+
+       gtk_source_region_add_subregion (region, &start_iter, &end_iter);
+}
+
+static void
+subtract_subregion (GtkSourceRegion *region,
+                   gint             start_offset,
+                   gint             end_offset)
+{
+       GtkTextBuffer *buffer;
+       GtkTextIter start_iter;
+       GtkTextIter end_iter;
+
+       buffer = gtk_source_region_get_buffer (region);
+       gtk_text_buffer_get_iter_at_offset (buffer, &start_iter, start_offset);
+       gtk_text_buffer_get_iter_at_offset (buffer, &end_iter, end_offset);
+
+       gtk_source_region_subtract_subregion (region, &start_iter, &end_iter);
+}
 
-               gtk_source_region_iter_get_subregion (&reg_iter,
-                                                     &s, &e);
+static void
+check_result (GtkSourceRegion *region,
+             const gchar     *expected_result)
+{
+       gchar *expected_region_str;
+       gchar *region_str;
 
-               i++;
-               gtk_source_region_iter_next (&reg_iter);
+       if (expected_result == NULL)
+       {
+               g_assert (gtk_source_region_is_empty (region));
+               return;
        }
 
-       g_print ("iterated %u subregions\n", i);
+       g_assert (!gtk_source_region_is_empty (region));
+
+       expected_region_str = g_strconcat ("Subregions: ", expected_result, NULL);
+       region_str = gtk_source_region_to_string (region);
+       g_assert_cmpstr (region_str, ==, expected_region_str);
+
+       g_free (expected_region_str);
+       g_free (region_str);
+}
+
+static void
+test_add_subtract_subregion (void)
+{
+       GtkTextBuffer *buffer;
+       GtkSourceRegion *region;
+
+       buffer = gtk_text_buffer_new (NULL);
+       region = gtk_source_region_new (buffer);
+
+       gtk_text_buffer_set_text (buffer, "This is a test of GtkSourceRegion", -1);
+
+       g_assert (gtk_source_region_is_empty (region));
+
+       /* Add/remove 0-length subregions */
+       add_subregion (region, 5, 5);
+       g_assert (gtk_source_region_is_empty (region));
+       subtract_subregion (region, 5, 5);
+       g_assert (gtk_source_region_is_empty (region));
+
+       /* Add subregion */
+       add_subregion (region, 5, 10);
+       check_result (region, "5-10");
+
+       /* Add two adjacent subregions */
+       add_subregion (region, 3, 5);
+       check_result (region, "3-10");
+
+       add_subregion (region, 10, 12);
+       check_result (region, "3-12");
 
+       /* Remove all */
+       subtract_subregion (region, 1, 15);
+       g_assert (gtk_source_region_is_empty (region));
+
+       /* Add two separate subregions */
+       add_subregion (region, 5, 10);
+       add_subregion (region, 15, 20);
+       check_result (region, "5-10 15-20");
+
+       /* Join them */
+       add_subregion (region, 7, 17);
+       check_result (region, "5-20");
+
+       /* Remove from the middle */
+       subtract_subregion (region, 10, 15);
+       check_result (region, "5-10 15-20");
+
+       /* Exactly remove a subregion */
+       subtract_subregion (region, 15, 20);
+       check_result (region, "5-10");
+
+       /* Try to remove an adjacent subregion */
+       subtract_subregion (region, 10, 20);
+       check_result (region, "5-10");
+
+       subtract_subregion (region, 0, 5);
+       check_result (region, "5-10");
+
+       /* Add another separate subregion */
+       add_subregion (region, 15, 20);
+       check_result (region, "5-10 15-20");
+
+       /* Join with excess */
+       add_subregion (region, 0, 25);
+       check_result (region, "0-25");
+
+       /* Do two holes */
+       subtract_subregion (region, 5, 10);
+       check_result (region, "0-5 10-25");
+
+       subtract_subregion (region, 15, 20);
+       check_result (region, "0-5 10-15 20-25");
+
+       /* Remove the middle subregion */
+       subtract_subregion (region, 8, 22);
+       check_result (region, "0-5 22-25");
+
+       /* Add the subregion we just removed */
+       add_subregion (region, 10, 15);
+       check_result (region, "0-5 10-15 22-25");
+
+       /* Remove the middle subregion */
+       subtract_subregion (region, 3, 17);
+       check_result (region, "0-3 22-25");
+
+       /* Add the subregion we just removed */
+       add_subregion (region, 10, 15);
+       check_result (region, "0-3 10-15 22-25");
+
+       /* Remove the middle subregion */
+       subtract_subregion (region, 2, 23);
+       check_result (region, "0-2 23-25");
+
+       /* Add the subregion we just removed */
+       add_subregion (region, 10, 15);
+       check_result (region, "0-2 10-15 23-25");
+
+       g_object_unref (buffer);
        g_object_unref (region);
+}
+
+static void
+do_intersection_subregion (GtkSourceRegion *region,
+                          gint             start_offset,
+                          gint             end_offset,
+                          const gchar     *expected_result)
+{
+       GtkTextBuffer *buffer;
+       GtkTextIter start_iter;
+       GtkTextIter end_iter;
+       GtkSourceRegion *intersection;
+
+       buffer = gtk_source_region_get_buffer (region);
+       gtk_text_buffer_get_iter_at_offset (buffer, &start_iter, start_offset);
+       gtk_text_buffer_get_iter_at_offset (buffer, &end_iter, end_offset);
+
+       intersection = gtk_source_region_intersect_subregion (region, &start_iter, &end_iter);
+       check_result (intersection, expected_result);
+       g_clear_object (&intersection);
+}
+
+static void
+test_intersect_subregion (void)
+{
+       GtkTextBuffer *buffer;
+       GtkSourceRegion *region;
+
+       buffer = gtk_text_buffer_new (NULL);
+       region = gtk_source_region_new (buffer);
+
+       gtk_text_buffer_set_text (buffer, "This is a test of GtkSourceRegion", -1);
+
+       g_assert (gtk_source_region_is_empty (region));
+
+       add_subregion (region, 0, 2);
+       add_subregion (region, 10, 15);
+       add_subregion (region, 23, 25);
+       check_result (region, "0-2 10-15 23-25");
+
+       do_intersection_subregion (region, 0, 25, "0-2 10-15 23-25");
+       do_intersection_subregion (region, 10, 15, "10-15");
+       do_intersection_subregion (region, 8, 17, "10-15");
+       do_intersection_subregion (region, 1, 24, "1-2 10-15 23-24");
+       do_intersection_subregion (region, 3, 7, NULL);
+
        g_object_unref (buffer);
+       g_object_unref (region);
 }
 
 int
-main (int argc, char** argv)
+main (int argc, char **argv)
 {
        gtk_test_init (&argc, &argv);
 
-       g_test_add_func ("/Region/region", test_region);
+       g_test_add_func ("/Region/weak-ref", test_weak_ref);
+       g_test_add_func ("/Region/add-subtract-subregion", test_add_subtract_subregion);
+       g_test_add_func ("/Region/intersect-subregion", test_intersect_subregion);
 
        return g_test_run();
 }


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