src/adg/tests/test-utils.c

   1 /* ADG - Automatic Drawing Generation
   2  * Copyright (C) 2007-2019  Nicola Fontana <ntd at entidi.it>
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  17  * Boston, MA  02110-1301, USA.
  18  */
  19
  20
  21 #include <adg-test.h>
  22 #include <adg.h>
  23
  24
  25 static void
  26 _adg_method_strcmp0(void)
  27 {
  28     g_assert_cmpint(g_strcmp0(NULL, NULL), ==, 0);
  29     g_assert_cmpint(g_strcmp0("", ""), ==, 0);
  30     g_assert_cmpint(g_strcmp0(NULL, "test"), <, 0);
  31     g_assert_cmpint(g_strcmp0("test", NULL), >, 0);
  32     g_assert_cmpint(g_strcmp0("test", "test"), ==, 0);
  33 }
  34
  35 static void
  36 _adg_method_is_string_empty(void)
  37 {
  38     g_assert_true(adg_is_string_empty(""));
  39     g_assert_true(adg_is_string_empty(NULL));
  40     g_assert_false(adg_is_string_empty("test"));
  41 }
  42
  43 static void
  44 _adg_method_is_enum_value(void)
  45 {
  46     g_assert_true(adg_is_enum_value(ADG_THREE_STATE_ON, ADG_TYPE_THREE_STATE));
  47     g_assert_false(adg_is_enum_value(-1, ADG_TYPE_THREE_STATE));
  48     g_assert_false(adg_is_enum_value(485, ADG_TYPE_THREE_STATE));
  49 }
  50
  51 static void
  52 _adg_method_is_boolean_value(void)
  53 {
  54     g_assert_true(adg_is_boolean_value(TRUE));
  55     g_assert_true(adg_is_boolean_value(FALSE));
  56     g_assert_false(adg_is_boolean_value(177));
  57 }
  58
  59 static void
  60 _adg_method_string_replace(void)
  61 {
  62     gchar *result;
  63
  64     g_assert_null(adg_string_replace(NULL, "first", "second"));
  65     g_assert_null(adg_string_replace("original", NULL, "second"));
  66     g_assert_null(adg_string_replace("original", NULL, "second"));
  67
  68     result = adg_string_replace("The first arg", "first", "second");
  69     g_assert_cmpstr(result, ==, "The second arg");
  70     g_free(result);
  71
  72     result = adg_string_replace("The first arg", "first", NULL);
  73     g_assert_cmpstr(result, ==, "The  arg");
  74     g_free(result);
  75 }
  76
  77 static void
  78 _adg_method_find_file(void)
  79 {
  80     gchar *result;
  81
  82     g_assert_null(adg_find_file(NULL));
  83     g_assert_null(adg_find_file("test-utils.c", NULL));
  84
  85     result = adg_find_file("test-utils.c", SRCDIR, NULL);
  86     g_assert_nonnull(result);
  87     g_free(result);
  88
  89     result = adg_find_file("test-utils.c", "unexistentdirectory", SRCDIR, NULL);
  90     g_assert_nonnull(result);
  91     g_free(result);
  92 }
  93
  94 static void
  95 _adg_method_scale_factor(void)
  96 {
  97     adg_assert_isapprox(adg_scale_factor(""), 0);
  98     adg_assert_isapprox(adg_scale_factor(NULL), 0);
  99     adg_assert_isapprox(adg_scale_factor("3"), 3);
 100     adg_assert_isapprox(adg_scale_factor("3:3"), 1);
 101     adg_assert_isapprox(adg_scale_factor("+010 garbage"), 10);
 102
 103     /* No idea if sign+space is invalid on every atof implementation */
 104     adg_assert_isapprox(adg_scale_factor("+ 3"), 0);
 105
 106     adg_assert_isapprox(adg_scale_factor("-1:1"), -1);
 107     adg_assert_isapprox(adg_scale_factor("1:-1"), -1);
 108     adg_assert_isapprox(adg_scale_factor(" +5 : 05 garbage"), 1);
 109     adg_assert_isapprox(adg_scale_factor("1:0"), 0);
 110     adg_assert_isapprox(adg_scale_factor("1:"), 0);
 111
 112     adg_assert_isapprox(adg_scale_factor("3:2"), 1.5);
 113     adg_assert_isapprox(adg_scale_factor("3.2:3.20"), 1);
 114     adg_assert_isapprox(adg_scale_factor("3.25:1"), 3.25);
 115     adg_assert_isapprox(adg_scale_factor("1:0.33333333333"), 3);
 116 }
 117
 118 static void
 119 _adg_method_type_from_filename(void)
 120 {
 121     g_assert_cmpint(adg_type_from_filename("noextension"), ==, CAIRO_SURFACE_TYPE_XLIB);
 122     g_assert_cmpint(adg_type_from_filename("a.png"), ==, CAIRO_SURFACE_TYPE_IMAGE);
 123     g_assert_cmpint(adg_type_from_filename("a.PNG"), ==, CAIRO_SURFACE_TYPE_IMAGE);
 124     g_assert_cmpint(adg_type_from_filename("a.svg"), ==, CAIRO_SURFACE_TYPE_SVG);
 125     g_assert_cmpint(adg_type_from_filename("a.pdf"), ==, CAIRO_SURFACE_TYPE_PDF);
 126     g_assert_cmpint(adg_type_from_filename("a.ps"), ==, CAIRO_SURFACE_TYPE_PS);
 127     g_assert_cmpint(adg_type_from_filename("a.unknown"), ==, CAIRO_SURFACE_TYPE_XLIB);
 128 }
 129
 130 static void
 131 _adg_method_clone(void)
 132 {
 133     AdgCanvas *canvas, *clone;
 134     AdgTitleBlock *title_block;
 135
 136     /* Sanity check */
 137     g_assert_null(adg_object_clone(NULL));
 138
 139     canvas = adg_canvas_new();
 140     title_block = adg_title_block_new();
 141
 142     adg_canvas_set_background_dress(canvas, ADG_DRESS_COLOR_ANNOTATION);
 143     adg_canvas_set_title_block(canvas, title_block);
 144     g_object_unref(title_block);
 145     adg_canvas_set_margins(canvas, 1, 2, 3, 4);
 146     adg_canvas_switch_frame(canvas, FALSE);
 147
 148     /* Check that the original canvas matches the expected states */
 149     g_assert_cmpint(adg_canvas_get_background_dress(canvas), ==, ADG_DRESS_COLOR_ANNOTATION);
 150     g_assert_true(adg_canvas_get_title_block(canvas) == title_block);
 151     adg_assert_isapprox(adg_canvas_get_top_margin(canvas), 1);
 152     adg_assert_isapprox(adg_canvas_get_right_margin(canvas), 2);
 153     adg_assert_isapprox(adg_canvas_get_bottom_margin(canvas), 3);
 154     adg_assert_isapprox(adg_canvas_get_left_margin(canvas), 4);
 155     g_assert_false(adg_canvas_has_frame(canvas));
 156
 157     clone = ADG_CANVAS(adg_object_clone(G_OBJECT(canvas)));
 158     g_object_unref(canvas);
 159
 160     /* Check the states on the clone are the same */
 161     g_assert_cmpint(adg_canvas_get_background_dress(clone), ==, ADG_DRESS_COLOR_ANNOTATION);
 162     g_assert_true(adg_canvas_get_title_block(clone) == title_block);
 163     adg_assert_isapprox(adg_canvas_get_top_margin(clone), 1);
 164     adg_assert_isapprox(adg_canvas_get_right_margin(clone), 2);
 165     adg_assert_isapprox(adg_canvas_get_bottom_margin(clone), 3);
 166     adg_assert_isapprox(adg_canvas_get_left_margin(clone), 4);
 167     g_assert_false(adg_canvas_has_frame(clone));
 168
 169     g_object_unref(clone);
 170 }
 171
 172 static void
 173 _adg_method_nop(void)
 174 {
 175     /* Just check for this function existence */
 176     adg_nop();
 177 }
 178
 179 static void
 180 _adg_method_round(void)
 181 {
 182     adg_assert_isapprox(adg_round(0, 12), 0);
 183     adg_assert_isapprox(adg_round(3.2222222, 1), 3.2);
 184     adg_assert_isapprox(adg_round(3.2222222, 2), 3.22);
 185     adg_assert_isapprox(adg_round(-1234.56, 0), -1235);
 186 }
 187
 188 static void
 189 _adg_method_unescaped_strchr(void)
 190 {
 191     const gchar *result;
 192
 193     /* Sanity check */
 194     g_assert_null(adg_unescaped_strchr(NULL, '\0'));
 195
 196     result = adg_unescaped_strchr("\\a\\b\\abab", 'a');
 197     g_assert_cmpstr(result, ==, "ab");
 198
 199     result = adg_unescaped_strchr("\\a\\b\\abab", 'b');
 200     g_assert_cmpstr(result, ==, "bab");
 201
 202     result = adg_unescaped_strchr("1\\22", '1');
 203     g_assert_cmpstr(result, ==, "1\\22");
 204
 205     result = adg_unescaped_strchr("1\\22", '2');
 206     g_assert_cmpstr(result, ==, "2");
 207
 208     result = adg_unescaped_strchr("122", '3');
 209     g_assert_null(result);
 210 }
 211
 212
 213 int
 214 main(int argc, char *argv[])
 215 {
 216     adg_test_init(&argc, &argv);
 217
 218     g_test_add_func("/adg/method/strcpm0", _adg_method_strcmp0);
 219     g_test_add_func("/adg/method/is-string-empty", _adg_method_is_string_empty);
 220     g_test_add_func("/adg/method/is-enum-value", _adg_method_is_enum_value);
 221     g_test_add_func("/adg/method/is-boolean-value", _adg_method_is_boolean_value);
 222     g_test_add_func("/adg/method/string-replace", _adg_method_string_replace);
 223     g_test_add_func("/adg/method/find-file", _adg_method_find_file);
 224     g_test_add_func("/adg/method/scale-factor", _adg_method_scale_factor);
 225     g_test_add_func("/adg/method/type-from-filename", _adg_method_type_from_filename);
 226     g_test_add_func("/adg/method/clone", _adg_method_clone);
 227     g_test_add_func("/adg/method/nop", _adg_method_nop);
 228     g_test_add_func("/adg/method/round", _adg_method_round);
 229     g_test_add_func("/adg/method/unescaped-strchr", _adg_method_unescaped_strchr);
 230
 231     return g_test_run();
 232 }