src/adg/tests/test-canvas.c

   1 /* ADG - Automatic Drawing Generation
   2  * Copyright (C) 2010  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 "test-internal.h"
  22
  23
  24 static void
  25 _adg_test_background_dress(void)
  26 {
  27     AdgCanvas *canvas;
  28     AdgDress valid_dress_1, valid_dress_2, incompatible_dress;
  29     AdgDress background_dress;
  30
  31     canvas = adg_canvas_new();
  32     valid_dress_1 = ADG_DRESS_COLOR_DIMENSION;
  33     valid_dress_2 = ADG_DRESS_COLOR_FILL;
  34     incompatible_dress = ADG_DRESS_FONT_QUOTE_ANNOTATION;
  35
  36     /* Using the public APIs */
  37     adg_canvas_set_background_dress(canvas, valid_dress_1);
  38     background_dress = adg_canvas_get_background_dress(canvas);
  39     g_assert_cmpint(background_dress, ==, valid_dress_1);
  40
  41     adg_canvas_set_background_dress(canvas, incompatible_dress);
  42     background_dress = adg_canvas_get_background_dress(canvas);
  43     g_assert_cmpint(background_dress, ==, valid_dress_1);
  44
  45     adg_canvas_set_background_dress(canvas, valid_dress_2);
  46     background_dress = adg_canvas_get_background_dress(canvas);
  47     g_assert_cmpint(background_dress, ==, valid_dress_2);
  48
  49     /* Using GObject property methods */
  50     g_object_set(canvas, "background-dress", valid_dress_1, NULL);
  51     g_object_get(canvas, "background-dress", &background_dress, NULL);
  52     g_assert_cmpint(background_dress, ==, valid_dress_1);
  53
  54     g_object_set(canvas, "background-dress", incompatible_dress, NULL);
  55     g_object_get(canvas, "background-dress", &background_dress, NULL);
  56     g_assert_cmpint(background_dress, ==, valid_dress_1);
  57
  58     g_object_set(canvas, "background-dress", valid_dress_2, NULL);
  59     g_object_get(canvas, "background-dress", &background_dress, NULL);
  60     g_assert_cmpint(background_dress, ==, valid_dress_2);
  61
  62     g_object_unref(canvas);
  63 }
  64
  65 static void
  66 _adg_test_frame_dress(void)
  67 {
  68     AdgCanvas *canvas;
  69     AdgDress valid_dress_1, valid_dress_2, incompatible_dress;
  70     AdgDress frame_dress;
  71
  72     canvas = adg_canvas_new();
  73     valid_dress_1 = ADG_DRESS_LINE_DIMENSION;
  74     valid_dress_2 = ADG_DRESS_LINE_FILL;
  75     incompatible_dress = ADG_DRESS_FONT;
  76
  77     /* Using the public APIs */
  78     adg_canvas_set_frame_dress(canvas, valid_dress_1);
  79     frame_dress = adg_canvas_get_frame_dress(canvas);
  80     g_assert_cmpint(frame_dress, ==, valid_dress_1);
  81
  82     adg_canvas_set_frame_dress(canvas, incompatible_dress);
  83     frame_dress = adg_canvas_get_frame_dress(canvas);
  84     g_assert_cmpint(frame_dress, ==, valid_dress_1);
  85
  86     adg_canvas_set_frame_dress(canvas, valid_dress_2);
  87     frame_dress = adg_canvas_get_frame_dress(canvas);
  88     g_assert_cmpint(frame_dress, ==, valid_dress_2);
  89
  90     /* Using GObject property methods */
  91     g_object_set(canvas, "frame-dress", valid_dress_1, NULL);
  92     g_object_get(canvas, "frame-dress", &frame_dress, NULL);
  93     g_assert_cmpint(frame_dress, ==, valid_dress_1);
  94
  95     g_object_set(canvas, "frame-dress", incompatible_dress, NULL);
  96     g_object_get(canvas, "frame-dress", &frame_dress, NULL);
  97     g_assert_cmpint(frame_dress, ==, valid_dress_1);
  98
  99     g_object_set(canvas, "frame-dress", valid_dress_2, NULL);
 100     g_object_get(canvas, "frame-dress", &frame_dress, NULL);
 101     g_assert_cmpint(frame_dress, ==, valid_dress_2);
 102
 103     g_object_unref(canvas);
 104 }
 105
 106 static void
 107 _adg_test_title_block(void)
 108 {
 109     AdgCanvas *canvas;
 110     AdgTitleBlock *valid_title_block, *invalid_title_block, *title_block;
 111
 112     canvas = adg_canvas_new();
 113     valid_title_block = ADG_TITLE_BLOCK(adg_title_block_new());
 114     invalid_title_block = adg_test_invalid_pointer();
 115
 116     g_object_ref(valid_title_block);
 117
 118     /* Using the public APIs */
 119     adg_canvas_set_title_block(canvas, NULL);
 120     title_block = adg_canvas_get_title_block(canvas);
 121     g_assert(title_block == NULL);
 122
 123     adg_canvas_set_title_block(canvas, valid_title_block);
 124     title_block = adg_canvas_get_title_block(canvas);
 125     g_assert(title_block == valid_title_block);
 126
 127     adg_canvas_set_title_block(canvas, invalid_title_block);
 128     title_block = adg_canvas_get_title_block(canvas);
 129     g_assert(title_block == valid_title_block);
 130
 131     adg_canvas_set_title_block(canvas, NULL);
 132     title_block = adg_canvas_get_title_block(canvas);
 133     g_assert(title_block == NULL);
 134
 135     /* Using GObject property methods */
 136     g_object_set(canvas, "title-block", NULL, NULL);
 137     g_object_get(canvas, "title-block", &title_block, NULL);
 138     g_assert(title_block == NULL);
 139
 140     g_object_set(canvas, "title-block", valid_title_block, NULL);
 141     g_object_get(canvas, "title-block", &title_block, NULL);
 142     g_assert(title_block == valid_title_block);
 143     g_object_unref(title_block);
 144
 145     g_object_set(canvas, "title-block", invalid_title_block, NULL);
 146     g_object_get(canvas, "title-block", &title_block, NULL);
 147     g_assert(title_block == valid_title_block);
 148     g_object_unref(title_block);
 149
 150     g_object_set(canvas, "title-block", NULL, NULL);
 151     g_object_get(canvas, "title-block", &title_block, NULL);
 152     g_assert(title_block == NULL);
 153
 154     g_object_unref(canvas);
 155     g_object_unref(valid_title_block);
 156 }
 157
 158 static void
 159 _adg_test_size(void)
 160 {
 161     AdgCanvas *canvas;
 162     AdgPair null_size, sample_size;
 163     const AdgPair *size;
 164     AdgPair *size_dup;
 165
 166     canvas = adg_canvas_new();
 167     null_size.x = 0;
 168     null_size.y = 0;
 169     sample_size.x = 123;
 170     sample_size.y = 321;
 171
 172     /* Using the public APIs */
 173     adg_canvas_set_size(canvas, &sample_size);
 174     size = adg_canvas_get_size(canvas);
 175     g_assert(adg_pair_equal(size, &sample_size));
 176
 177     adg_canvas_set_size(canvas, NULL);
 178     size = adg_canvas_get_size(canvas);
 179     g_assert(adg_pair_equal(size, &sample_size));
 180
 181     adg_canvas_set_size_explicit(canvas, 0, 0);
 182     size = adg_canvas_get_size(canvas);
 183     g_assert(adg_pair_equal(size, &null_size));
 184
 185     /* Using GObject property methods */
 186     g_object_set(canvas, "size", &sample_size, NULL);
 187     g_object_get(canvas, "size", &size_dup, NULL);
 188     g_assert(adg_pair_equal(size_dup, &sample_size));
 189     g_free(size_dup);
 190
 191     g_object_set(canvas, "size", NULL, NULL);
 192     g_object_get(canvas, "size", &size_dup, NULL);
 193     g_assert(adg_pair_equal(size_dup, &sample_size));
 194     g_free(size_dup);
 195
 196     g_object_set(canvas, "size", &null_size, NULL);
 197     g_object_get(canvas, "size", &size_dup, NULL);
 198     g_assert(adg_pair_equal(size_dup, &null_size));
 199     g_free(size_dup);
 200
 201     g_object_unref(canvas);
 202 }
 203
 204 static void
 205 _adg_test_top_margin(void)
 206 {
 207     AdgCanvas *canvas;
 208     gdouble valid_value_1, valid_value_2;
 209     gdouble top_margin;
 210
 211     canvas = ADG_CANVAS(adg_canvas_new());
 212     valid_value_1 = 4321;
 213     valid_value_2 = 1234;
 214
 215     /* Using the public APIs */
 216     adg_canvas_set_top_margin(canvas, valid_value_1);
 217     top_margin = adg_canvas_get_top_margin(canvas);
 218     g_assert_cmpfloat(top_margin, ==, valid_value_1);
 219
 220     adg_canvas_set_margins(canvas, valid_value_2, 0, 0, 0);
 221     top_margin = adg_canvas_get_top_margin(canvas);
 222     g_assert_cmpfloat(top_margin, ==, valid_value_2);
 223
 224     /* Using GObject property methods */
 225     g_object_set(canvas, "top-margin", valid_value_1, NULL);
 226     g_object_get(canvas, "top-margin", &top_margin, NULL);
 227     g_assert_cmpfloat(top_margin, ==, valid_value_1);
 228
 229     g_object_set(canvas, "top-margin", valid_value_2, NULL);
 230     g_object_get(canvas, "top-margin", &top_margin, NULL);
 231     g_assert_cmpfloat(top_margin, ==, valid_value_2);
 232
 233     g_object_unref(canvas);
 234 }
 235
 236 static void
 237 _adg_test_right_margin(void)
 238 {
 239     AdgCanvas *canvas;
 240     gdouble valid_value_1, valid_value_2;
 241     gdouble right_margin;
 242
 243     canvas = ADG_CANVAS(adg_canvas_new());
 244     valid_value_1 = 4321;
 245     valid_value_2 = 1234;
 246
 247     /* Using the public APIs */
 248     adg_canvas_set_right_margin(canvas, valid_value_1);
 249     right_margin = adg_canvas_get_right_margin(canvas);
 250     g_assert_cmpfloat(right_margin, ==, valid_value_1);
 251
 252     adg_canvas_set_margins(canvas, 0, valid_value_2, 0, 0);
 253     right_margin = adg_canvas_get_right_margin(canvas);
 254     g_assert_cmpfloat(right_margin, ==, valid_value_2);
 255
 256     /* Using GObject property methods */
 257     g_object_set(canvas, "right-margin", valid_value_1, NULL);
 258     g_object_get(canvas, "right-margin", &right_margin, NULL);
 259     g_assert_cmpfloat(right_margin, ==, valid_value_1);
 260
 261     g_object_set(canvas, "right-margin", valid_value_2, NULL);
 262     g_object_get(canvas, "right-margin", &right_margin, NULL);
 263     g_assert_cmpfloat(right_margin, ==, valid_value_2);
 264
 265     g_object_unref(canvas);
 266 }
 267
 268 static void
 269 _adg_test_bottom_margin(void)
 270 {
 271     AdgCanvas *canvas;
 272     gdouble valid_value_1, valid_value_2;
 273     gdouble bottom_margin;
 274
 275     canvas = ADG_CANVAS(adg_canvas_new());
 276     valid_value_1 = 4321;
 277     valid_value_2 = 1234;
 278
 279     /* Using the public APIs */
 280     adg_canvas_set_bottom_margin(canvas, valid_value_1);
 281     bottom_margin = adg_canvas_get_bottom_margin(canvas);
 282     g_assert_cmpfloat(bottom_margin, ==, valid_value_1);
 283
 284     adg_canvas_set_margins(canvas, 0, 0, valid_value_2, 0);
 285     bottom_margin = adg_canvas_get_bottom_margin(canvas);
 286     g_assert_cmpfloat(bottom_margin, ==, valid_value_2);
 287
 288     /* Using GObject property methods */
 289     g_object_set(canvas, "bottom-margin", valid_value_1, NULL);
 290     g_object_get(canvas, "bottom-margin", &bottom_margin, NULL);
 291     g_assert_cmpfloat(bottom_margin, ==, valid_value_1);
 292
 293     g_object_set(canvas, "bottom-margin", valid_value_2, NULL);
 294     g_object_get(canvas, "bottom-margin", &bottom_margin, NULL);
 295     g_assert_cmpfloat(bottom_margin, ==, valid_value_2);
 296
 297     g_object_unref(canvas);
 298 }
 299
 300 static void
 301 _adg_test_left_margin(void)
 302 {
 303     AdgCanvas *canvas;
 304     gdouble valid_value_1, valid_value_2;
 305     gdouble left_margin;
 306
 307     canvas = ADG_CANVAS(adg_canvas_new());
 308     valid_value_1 = 4321;
 309     valid_value_2 = 1234;
 310
 311     /* Using the public APIs */
 312     adg_canvas_set_left_margin(canvas, valid_value_1);
 313     left_margin = adg_canvas_get_left_margin(canvas);
 314     g_assert_cmpfloat(left_margin, ==, valid_value_1);
 315
 316     adg_canvas_set_margins(canvas, 0, 0, 0, valid_value_2);
 317     left_margin = adg_canvas_get_left_margin(canvas);
 318     g_assert_cmpfloat(left_margin, ==, valid_value_2);
 319
 320     /* Using GObject property methods */
 321     g_object_set(canvas, "left-margin", valid_value_1, NULL);
 322     g_object_get(canvas, "left-margin", &left_margin, NULL);
 323     g_assert_cmpfloat(left_margin, ==, valid_value_1);
 324
 325     g_object_set(canvas, "left-margin", valid_value_2, NULL);
 326     g_object_get(canvas, "left-margin", &left_margin, NULL);
 327     g_assert_cmpfloat(left_margin, ==, valid_value_2);
 328
 329     g_object_unref(canvas);
 330 }
 331
 332 static void
 333 _adg_test_has_frame(void)
 334 {
 335     AdgCanvas *canvas;
 336     gboolean invalid_boolean;
 337     gboolean has_frame;
 338
 339     canvas = ADG_CANVAS(adg_canvas_new());
 340     invalid_boolean = (gboolean) 1234;
 341
 342     /* Using the public APIs */
 343     adg_canvas_switch_frame(canvas, FALSE);
 344     has_frame = adg_canvas_has_frame(canvas);
 345     g_assert(!has_frame);
 346
 347     adg_canvas_switch_frame(canvas, invalid_boolean);
 348     has_frame = adg_canvas_has_frame(canvas);
 349     g_assert(!has_frame);
 350
 351     adg_canvas_switch_frame(canvas, TRUE);
 352     has_frame = adg_canvas_has_frame(canvas);
 353     g_assert(has_frame);
 354
 355     /* Using GObject property methods */
 356     g_object_set(canvas, "has-frame", FALSE, NULL);
 357     g_object_get(canvas, "has-frame", &has_frame, NULL);
 358     g_assert(!has_frame);
 359
 360     g_object_set(canvas, "has-frame", invalid_boolean, NULL);
 361     g_object_get(canvas, "has-frame", &has_frame, NULL);
 362     g_assert(!has_frame);
 363
 364     g_object_set(canvas, "has-frame", TRUE, NULL);
 365     g_object_get(canvas, "has-frame", &has_frame, NULL);
 366     g_assert(has_frame);
 367
 368     g_object_unref(canvas);
 369 }
 370
 371 static void
 372 _adg_test_top_padding(void)
 373 {
 374     AdgCanvas *canvas;
 375     gdouble valid_value_1, valid_value_2;
 376     gdouble top_padding;
 377
 378     canvas = ADG_CANVAS(adg_canvas_new());
 379     valid_value_1 = 4321;
 380     valid_value_2 = 1234;
 381
 382     /* Using the public APIs */
 383     adg_canvas_set_top_padding(canvas, valid_value_1);
 384     top_padding = adg_canvas_get_top_padding(canvas);
 385     g_assert_cmpfloat(top_padding, ==, valid_value_1);
 386
 387     adg_canvas_set_paddings(canvas, valid_value_2, 0, 0, 0);
 388     top_padding = adg_canvas_get_top_padding(canvas);
 389     g_assert_cmpfloat(top_padding, ==, valid_value_2);
 390
 391     /* Using GObject property methods */
 392     g_object_set(canvas, "top-padding", valid_value_1, NULL);
 393     g_object_get(canvas, "top-padding", &top_padding, NULL);
 394     g_assert_cmpfloat(top_padding, ==, valid_value_1);
 395
 396     g_object_set(canvas, "top-padding", valid_value_2, NULL);
 397     g_object_get(canvas, "top-padding", &top_padding, NULL);
 398     g_assert_cmpfloat(top_padding, ==, valid_value_2);
 399
 400     g_object_unref(canvas);
 401 }
 402
 403 static void
 404 _adg_test_right_padding(void)
 405 {
 406     AdgCanvas *canvas;
 407     gdouble valid_value_1, valid_value_2;
 408     gdouble right_padding;
 409
 410     canvas = ADG_CANVAS(adg_canvas_new());
 411     valid_value_1 = 4321;
 412     valid_value_2 = 1234;
 413
 414     /* Using the public APIs */
 415     adg_canvas_set_right_padding(canvas, valid_value_1);
 416     right_padding = adg_canvas_get_right_padding(canvas);
 417     g_assert_cmpfloat(right_padding, ==, valid_value_1);
 418
 419     adg_canvas_set_paddings(canvas, 0, valid_value_2, 0, 0);
 420     right_padding = adg_canvas_get_right_padding(canvas);
 421     g_assert_cmpfloat(right_padding, ==, valid_value_2);
 422
 423     /* Using GObject property methods */
 424     g_object_set(canvas, "right-padding", valid_value_1, NULL);
 425     g_object_get(canvas, "right-padding", &right_padding, NULL);
 426     g_assert_cmpfloat(right_padding, ==, valid_value_1);
 427
 428     g_object_set(canvas, "right-padding", valid_value_2, NULL);
 429     g_object_get(canvas, "right-padding", &right_padding, NULL);
 430     g_assert_cmpfloat(right_padding, ==, valid_value_2);
 431
 432     g_object_unref(canvas);
 433 }
 434
 435 static void
 436 _adg_test_bottom_padding(void)
 437 {
 438     AdgCanvas *canvas;
 439     gdouble valid_value_1, valid_value_2;
 440     gdouble bottom_padding;
 441
 442     canvas = ADG_CANVAS(adg_canvas_new());
 443     valid_value_1 = 4321;
 444     valid_value_2 = 1234;
 445
 446     /* Using the public APIs */
 447     adg_canvas_set_bottom_padding(canvas, valid_value_1);
 448     bottom_padding = adg_canvas_get_bottom_padding(canvas);
 449     g_assert_cmpfloat(bottom_padding, ==, valid_value_1);
 450
 451     adg_canvas_set_paddings(canvas, 0, 0, valid_value_2, 0);
 452     bottom_padding = adg_canvas_get_bottom_padding(canvas);
 453     g_assert_cmpfloat(bottom_padding, ==, valid_value_2);
 454
 455     /* Using GObject property methods */
 456     g_object_set(canvas, "bottom-padding", valid_value_1, NULL);
 457     g_object_get(canvas, "bottom-padding", &bottom_padding, NULL);
 458     g_assert_cmpfloat(bottom_padding, ==, valid_value_1);
 459
 460     g_object_set(canvas, "bottom-padding", valid_value_2, NULL);
 461     g_object_get(canvas, "bottom-padding", &bottom_padding, NULL);
 462     g_assert_cmpfloat(bottom_padding, ==, valid_value_2);
 463
 464     g_object_unref(canvas);
 465 }
 466
 467 static void
 468 _adg_test_left_padding(void)
 469 {
 470     AdgCanvas *canvas;
 471     gdouble valid_value_1, valid_value_2;
 472     gdouble left_padding;
 473
 474     canvas = ADG_CANVAS(adg_canvas_new());
 475     valid_value_1 = 4321;
 476     valid_value_2 = 1234;
 477
 478     /* Using the public APIs */
 479     adg_canvas_set_left_padding(canvas, valid_value_1);
 480     left_padding = adg_canvas_get_left_padding(canvas);
 481     g_assert_cmpfloat(left_padding, ==, valid_value_1);
 482
 483     adg_canvas_set_paddings(canvas, 0, 0, 0, valid_value_2);
 484     left_padding = adg_canvas_get_left_padding(canvas);
 485     g_assert_cmpfloat(left_padding, ==, valid_value_2);
 486
 487     /* Using GObject property methods */
 488     g_object_set(canvas, "left-padding", valid_value_1, NULL);
 489     g_object_get(canvas, "left-padding", &left_padding, NULL);
 490     g_assert_cmpfloat(left_padding, ==, valid_value_1);
 491
 492     g_object_set(canvas, "left-padding", valid_value_2, NULL);
 493     g_object_get(canvas, "left-padding", &left_padding, NULL);
 494     g_assert_cmpfloat(left_padding, ==, valid_value_2);
 495
 496     g_object_unref(canvas);
 497 }
 498
 499
 500 int
 501 main(int argc, char *argv[])
 502 {
 503     adg_test_init(&argc, &argv);
 504
 505     adg_test_add_func("/adg/canvas/property/background-dress",
 506                       _adg_test_background_dress);
 507     adg_test_add_func("/adg/canvas/property/frame-dress",
 508                       _adg_test_frame_dress);
 509     adg_test_add_func("/adg/canvas/property/title-block",
 510                       _adg_test_title_block);
 511     adg_test_add_func("/adg/canvas/property/size",
 512                       _adg_test_size);
 513     adg_test_add_func("/adg/canvas/property/top-margin",
 514                       _adg_test_top_margin);
 515     adg_test_add_func("/adg/canvas/property/right-margin",
 516                       _adg_test_right_margin);
 517     adg_test_add_func("/adg/canvas/property/bottom-margin",
 518                       _adg_test_bottom_margin);
 519     adg_test_add_func("/adg/canvas/property/left-margin",
 520                       _adg_test_left_margin);
 521     adg_test_add_func("/adg/canvas/property/has-frame",
 522                       _adg_test_has_frame);
 523     adg_test_add_func("/adg/canvas/property/top-padding",
 524                       _adg_test_top_padding);
 525     adg_test_add_func("/adg/canvas/property/right-padding",
 526                       _adg_test_right_padding);
 527     adg_test_add_func("/adg/canvas/property/bottom-padding",
 528                       _adg_test_bottom_padding);
 529     adg_test_add_func("/adg/canvas/property/left-padding",
 530                       _adg_test_left_padding);
 531
 532     return g_test_run();
 533 }