src/adg/tests/test-canvas.c

   1 /* ADG - Automatic Drawing Generation
   2  * Copyright (C) 2007-2015  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_test_background_dress(void)
  27 {
  28     AdgCanvas *canvas;
  29     AdgDress valid_dress_1, valid_dress_2, incompatible_dress;
  30     AdgDress background_dress;
  31
  32     canvas = adg_canvas_new();
  33     valid_dress_1 = ADG_DRESS_COLOR_DIMENSION;
  34     valid_dress_2 = ADG_DRESS_COLOR_FILL;
  35     incompatible_dress = ADG_DRESS_FONT_QUOTE_ANNOTATION;
  36
  37     /* Using the public APIs */
  38     adg_canvas_set_background_dress(canvas, valid_dress_1);
  39     background_dress = adg_canvas_get_background_dress(canvas);
  40     g_assert_cmpint(background_dress, ==, valid_dress_1);
  41
  42     adg_canvas_set_background_dress(canvas, incompatible_dress);
  43     background_dress = adg_canvas_get_background_dress(canvas);
  44     g_assert_cmpint(background_dress, ==, valid_dress_1);
  45
  46     adg_canvas_set_background_dress(canvas, valid_dress_2);
  47     background_dress = adg_canvas_get_background_dress(canvas);
  48     g_assert_cmpint(background_dress, ==, valid_dress_2);
  49
  50     /* Using GObject property methods */
  51     g_object_set(canvas, "background-dress", valid_dress_1, NULL);
  52     g_object_get(canvas, "background-dress", &background_dress, NULL);
  53     g_assert_cmpint(background_dress, ==, valid_dress_1);
  54
  55     g_object_set(canvas, "background-dress", incompatible_dress, NULL);
  56     g_object_get(canvas, "background-dress", &background_dress, NULL);
  57     g_assert_cmpint(background_dress, ==, valid_dress_1);
  58
  59     g_object_set(canvas, "background-dress", valid_dress_2, NULL);
  60     g_object_get(canvas, "background-dress", &background_dress, NULL);
  61     g_assert_cmpint(background_dress, ==, valid_dress_2);
  62
  63     adg_entity_destroy(ADG_ENTITY(canvas));
  64 }
  65
  66 static void
  67 _adg_test_frame_dress(void)
  68 {
  69     AdgCanvas *canvas;
  70     AdgDress valid_dress_1, valid_dress_2, incompatible_dress;
  71     AdgDress frame_dress;
  72
  73     canvas = adg_canvas_new();
  74     valid_dress_1 = ADG_DRESS_LINE_DIMENSION;
  75     valid_dress_2 = ADG_DRESS_LINE_FILL;
  76     incompatible_dress = ADG_DRESS_FONT;
  77
  78     /* Using the public APIs */
  79     adg_canvas_set_frame_dress(canvas, valid_dress_1);
  80     frame_dress = adg_canvas_get_frame_dress(canvas);
  81     g_assert_cmpint(frame_dress, ==, valid_dress_1);
  82
  83     adg_canvas_set_frame_dress(canvas, incompatible_dress);
  84     frame_dress = adg_canvas_get_frame_dress(canvas);
  85     g_assert_cmpint(frame_dress, ==, valid_dress_1);
  86
  87     adg_canvas_set_frame_dress(canvas, valid_dress_2);
  88     frame_dress = adg_canvas_get_frame_dress(canvas);
  89     g_assert_cmpint(frame_dress, ==, valid_dress_2);
  90
  91     /* Using GObject property methods */
  92     g_object_set(canvas, "frame-dress", valid_dress_1, NULL);
  93     g_object_get(canvas, "frame-dress", &frame_dress, NULL);
  94     g_assert_cmpint(frame_dress, ==, valid_dress_1);
  95
  96     g_object_set(canvas, "frame-dress", incompatible_dress, NULL);
  97     g_object_get(canvas, "frame-dress", &frame_dress, NULL);
  98     g_assert_cmpint(frame_dress, ==, valid_dress_1);
  99
 100     g_object_set(canvas, "frame-dress", valid_dress_2, NULL);
 101     g_object_get(canvas, "frame-dress", &frame_dress, NULL);
 102     g_assert_cmpint(frame_dress, ==, valid_dress_2);
 103
 104     adg_entity_destroy(ADG_ENTITY(canvas));
 105 }
 106
 107 static void
 108 _adg_test_title_block(void)
 109 {
 110     AdgCanvas *canvas;
 111     AdgTitleBlock *valid_title_block, *invalid_title_block, *title_block;
 112
 113     canvas = adg_canvas_new();
 114     valid_title_block = ADG_TITLE_BLOCK(adg_title_block_new());
 115     invalid_title_block = adg_test_invalid_pointer();
 116
 117     g_object_ref(valid_title_block);
 118
 119     /* Using the public APIs */
 120     adg_canvas_set_title_block(canvas, NULL);
 121     title_block = adg_canvas_get_title_block(canvas);
 122     g_assert_null(title_block);
 123
 124     adg_canvas_set_title_block(canvas, valid_title_block);
 125     title_block = adg_canvas_get_title_block(canvas);
 126     g_assert_true(title_block == valid_title_block);
 127
 128     adg_canvas_set_title_block(canvas, invalid_title_block);
 129     title_block = adg_canvas_get_title_block(canvas);
 130     g_assert_true(title_block == valid_title_block);
 131
 132     adg_canvas_set_title_block(canvas, NULL);
 133     title_block = adg_canvas_get_title_block(canvas);
 134     g_assert_null(title_block);
 135
 136     /* Using GObject property methods */
 137     g_object_set(canvas, "title-block", NULL, NULL);
 138     g_object_get(canvas, "title-block", &title_block, NULL);
 139     g_assert_null(title_block);
 140
 141     g_object_set(canvas, "title-block", valid_title_block, NULL);
 142     g_object_get(canvas, "title-block", &title_block, NULL);
 143     g_assert_true(title_block == valid_title_block);
 144     adg_entity_destroy(ADG_ENTITY(title_block));
 145
 146     g_object_set(canvas, "title-block", invalid_title_block, NULL);
 147     g_object_get(canvas, "title-block", &title_block, NULL);
 148     g_assert_true(title_block == valid_title_block);
 149     adg_entity_destroy(ADG_ENTITY(title_block));
 150
 151     g_object_set(canvas, "title-block", NULL, NULL);
 152     g_object_get(canvas, "title-block", &title_block, NULL);
 153     g_assert_null(title_block);
 154
 155     adg_entity_destroy(ADG_ENTITY(canvas));
 156     adg_entity_destroy(ADG_ENTITY(valid_title_block));
 157 }
 158
 159 static void
 160 _adg_test_size(void)
 161 {
 162     AdgCanvas *canvas;
 163     CpmlPair null_size, sample_size;
 164     const CpmlPair *size;
 165     CpmlPair *size_dup;
 166
 167     canvas = adg_canvas_new();
 168     null_size.x = 0;
 169     null_size.y = 0;
 170     sample_size.x = 123;
 171     sample_size.y = 321;
 172
 173     /* Using the public APIs */
 174     size = adg_canvas_get_size(canvas);
 175
 176     /* The default size is 0, 0 (anamorphic canvas) */
 177     g_assert_true(cpml_pair_equal(size, &null_size));
 178
 179     adg_canvas_set_size(canvas, &sample_size);
 180     size = adg_canvas_get_size(canvas);
 181     g_assert_true(cpml_pair_equal(size, &sample_size));
 182
 183     adg_canvas_set_size(canvas, NULL);
 184     size = adg_canvas_get_size(canvas);
 185     g_assert_true(cpml_pair_equal(size, &sample_size));
 186
 187     adg_canvas_set_size_explicit(canvas, 0, 0);
 188     size = adg_canvas_get_size(canvas);
 189     g_assert_true(cpml_pair_equal(size, &null_size));
 190
 191     /* Using GObject property methods */
 192     g_object_set(canvas, "size", &sample_size, NULL);
 193     g_object_get(canvas, "size", &size_dup, NULL);
 194     g_assert_true(cpml_pair_equal(size_dup, &sample_size));
 195     g_free(size_dup);
 196
 197     g_object_set(canvas, "size", NULL, NULL);
 198     g_object_get(canvas, "size", &size_dup, NULL);
 199     g_assert_true(cpml_pair_equal(size_dup, &sample_size));
 200     g_free(size_dup);
 201
 202     g_object_set(canvas, "size", &null_size, NULL);
 203     g_object_get(canvas, "size", &size_dup, NULL);
 204     g_assert_true(cpml_pair_equal(size_dup, &null_size));
 205     g_free(size_dup);
 206
 207     adg_entity_destroy(ADG_ENTITY(canvas));
 208 }
 209
 210 static void
 211 _adg_test_scales(void)
 212 {
 213     AdgCanvas *canvas;
 214     gchar **scales;
 215     gchar *scales_array[] = { "a", "b", "c", NULL };
 216
 217     /* By default, AdgCanvas:scales is prefilled with some default scales */
 218     canvas = adg_canvas_new();
 219     scales = adg_canvas_get_scales(canvas);
 220     g_assert_nonnull(scales);
 221     adg_entity_destroy(ADG_ENTITY(canvas));
 222
 223     /* AdgCanvas:scales must be prefilled also when using g_object_new() */
 224     canvas = g_object_new(ADG_TYPE_CANVAS, NULL);
 225     scales = adg_canvas_get_scales(canvas);
 226     g_assert_nonnull(scales);
 227
 228     /* Using the public APIs */
 229     adg_canvas_set_scales(canvas, NULL);
 230     scales = adg_canvas_get_scales(canvas);
 231     g_assert_null(scales);
 232
 233     adg_canvas_set_scales(canvas, "0", "1", NULL);
 234     scales = adg_canvas_get_scales(canvas);
 235     g_assert_nonnull(scales);
 236     g_assert_cmpstr(scales[0], ==, "0");
 237     g_assert_cmpstr(scales[1], ==, "1");
 238     g_assert_null(scales[2]);
 239
 240     adg_canvas_set_scales_array(canvas, NULL);
 241     scales = adg_canvas_get_scales(canvas);
 242     g_assert_null(scales);
 243
 244     adg_canvas_set_scales_array(canvas, scales_array);
 245     scales = adg_canvas_get_scales(canvas);
 246     g_assert_nonnull(scales);
 247     g_assert_cmpstr(scales[0], ==, "a");
 248     g_assert_cmpstr(scales[1], ==, "b");
 249     g_assert_cmpstr(scales[2], ==, "c");
 250     g_assert_null(scales[3]);
 251
 252     /* Using GObject property methods */
 253     g_object_set(canvas, "scales", NULL, NULL);
 254     g_object_get(canvas, "scales", &scales, NULL);
 255     g_assert_null(scales);
 256
 257     g_object_set(canvas, "scales", scales_array, NULL);
 258     g_object_get(canvas, "scales", &scales, NULL);
 259     g_assert_nonnull(scales);
 260     g_assert_cmpstr(scales[0], ==, "a");
 261     g_assert_cmpstr(scales[1], ==, "b");
 262     g_assert_cmpstr(scales[2], ==, "c");
 263     g_assert_null(scales[3]);
 264     g_strfreev(scales);
 265
 266     /* Check autoscale does not crash on no scales */
 267     g_object_set(canvas, "scales", NULL, NULL);
 268     adg_canvas_autoscale(canvas);
 269
 270     adg_entity_destroy(ADG_ENTITY(canvas));
 271 }
 272
 273 static void
 274 _adg_test_top_margin(void)
 275 {
 276     AdgCanvas *canvas;
 277     gdouble valid_value_1, valid_value_2;
 278     gdouble top_margin;
 279
 280     canvas = ADG_CANVAS(adg_canvas_new());
 281     valid_value_1 = 4321;
 282     valid_value_2 = -1;
 283
 284     /* Using the public APIs */
 285     adg_canvas_set_top_margin(canvas, valid_value_1);
 286     top_margin = adg_canvas_get_top_margin(canvas);
 287     g_assert_cmpfloat(top_margin, ==, valid_value_1);
 288
 289     adg_canvas_set_margins(canvas, valid_value_2, 0, 0, 0);
 290     top_margin = adg_canvas_get_top_margin(canvas);
 291     g_assert_cmpfloat(top_margin, ==, valid_value_2);
 292
 293     /* Using GObject property methods */
 294     g_object_set(canvas, "top-margin", valid_value_1, NULL);
 295     g_object_get(canvas, "top-margin", &top_margin, NULL);
 296     g_assert_cmpfloat(top_margin, ==, valid_value_1);
 297
 298     g_object_set(canvas, "top-margin", valid_value_2, NULL);
 299     g_object_get(canvas, "top-margin", &top_margin, NULL);
 300     g_assert_cmpfloat(top_margin, ==, valid_value_2);
 301
 302     adg_entity_destroy(ADG_ENTITY(canvas));
 303 }
 304
 305 static void
 306 _adg_test_right_margin(void)
 307 {
 308     AdgCanvas *canvas;
 309     gdouble valid_value_1, valid_value_2;
 310     gdouble right_margin;
 311
 312     canvas = ADG_CANVAS(adg_canvas_new());
 313     valid_value_1 = 4321;
 314     valid_value_2 = 0;
 315
 316     /* Using the public APIs */
 317     adg_canvas_set_right_margin(canvas, valid_value_1);
 318     right_margin = adg_canvas_get_right_margin(canvas);
 319     g_assert_cmpfloat(right_margin, ==, valid_value_1);
 320
 321     adg_canvas_set_margins(canvas, 0, valid_value_2, 0, 0);
 322     right_margin = adg_canvas_get_right_margin(canvas);
 323     g_assert_cmpfloat(right_margin, ==, valid_value_2);
 324
 325     /* Using GObject property methods */
 326     g_object_set(canvas, "right-margin", valid_value_1, NULL);
 327     g_object_get(canvas, "right-margin", &right_margin, NULL);
 328     g_assert_cmpfloat(right_margin, ==, valid_value_1);
 329
 330     g_object_set(canvas, "right-margin", valid_value_2, NULL);
 331     g_object_get(canvas, "right-margin", &right_margin, NULL);
 332     g_assert_cmpfloat(right_margin, ==, valid_value_2);
 333
 334     adg_entity_destroy(ADG_ENTITY(canvas));
 335 }
 336
 337 static void
 338 _adg_test_bottom_margin(void)
 339 {
 340     AdgCanvas *canvas;
 341     gdouble valid_value_1, valid_value_2;
 342     gdouble bottom_margin;
 343
 344     canvas = ADG_CANVAS(adg_canvas_new());
 345     valid_value_1 = 4321;
 346     valid_value_2 = -1234;
 347
 348     /* Using the public APIs */
 349     adg_canvas_set_bottom_margin(canvas, valid_value_1);
 350     bottom_margin = adg_canvas_get_bottom_margin(canvas);
 351     g_assert_cmpfloat(bottom_margin, ==, valid_value_1);
 352
 353     adg_canvas_set_margins(canvas, 0, 0, valid_value_2, 0);
 354     bottom_margin = adg_canvas_get_bottom_margin(canvas);
 355     g_assert_cmpfloat(bottom_margin, ==, valid_value_2);
 356
 357     /* Using GObject property methods */
 358     g_object_set(canvas, "bottom-margin", valid_value_1, NULL);
 359     g_object_get(canvas, "bottom-margin", &bottom_margin, NULL);
 360     g_assert_cmpfloat(bottom_margin, ==, valid_value_1);
 361
 362     g_object_set(canvas, "bottom-margin", valid_value_2, NULL);
 363     g_object_get(canvas, "bottom-margin", &bottom_margin, NULL);
 364     g_assert_cmpfloat(bottom_margin, ==, valid_value_2);
 365
 366     adg_entity_destroy(ADG_ENTITY(canvas));
 367 }
 368
 369 static void
 370 _adg_test_left_margin(void)
 371 {
 372     AdgCanvas *canvas;
 373     gdouble valid_value_1, valid_value_2;
 374     gdouble left_margin;
 375
 376     canvas = ADG_CANVAS(adg_canvas_new());
 377     valid_value_1 = 4321;
 378     valid_value_2 = -4321;
 379
 380     /* Using the public APIs */
 381     adg_canvas_set_left_margin(canvas, valid_value_1);
 382     left_margin = adg_canvas_get_left_margin(canvas);
 383     g_assert_cmpfloat(left_margin, ==, valid_value_1);
 384
 385     adg_canvas_set_margins(canvas, 0, 0, 0, valid_value_2);
 386     left_margin = adg_canvas_get_left_margin(canvas);
 387     g_assert_cmpfloat(left_margin, ==, valid_value_2);
 388
 389     /* Using GObject property methods */
 390     g_object_set(canvas, "left-margin", valid_value_1, NULL);
 391     g_object_get(canvas, "left-margin", &left_margin, NULL);
 392     g_assert_cmpfloat(left_margin, ==, valid_value_1);
 393
 394     g_object_set(canvas, "left-margin", valid_value_2, NULL);
 395     g_object_get(canvas, "left-margin", &left_margin, NULL);
 396     g_assert_cmpfloat(left_margin, ==, valid_value_2);
 397
 398     adg_entity_destroy(ADG_ENTITY(canvas));
 399 }
 400
 401 static void
 402 _adg_test_has_frame(void)
 403 {
 404     AdgCanvas *canvas;
 405     gboolean invalid_boolean;
 406     gboolean has_frame;
 407
 408     canvas = ADG_CANVAS(adg_canvas_new());
 409     invalid_boolean = (gboolean) 1234;
 410
 411     /* Using the public APIs */
 412     adg_canvas_switch_frame(canvas, FALSE);
 413     has_frame = adg_canvas_has_frame(canvas);
 414     g_assert_false(has_frame);
 415
 416     adg_canvas_switch_frame(canvas, invalid_boolean);
 417     has_frame = adg_canvas_has_frame(canvas);
 418     g_assert_false(has_frame);
 419
 420     adg_canvas_switch_frame(canvas, TRUE);
 421     has_frame = adg_canvas_has_frame(canvas);
 422     g_assert_true(has_frame);
 423
 424     /* Using GObject property methods */
 425     g_object_set(canvas, "has-frame", FALSE, NULL);
 426     g_object_get(canvas, "has-frame", &has_frame, NULL);
 427     g_assert_false(has_frame);
 428
 429     g_object_set(canvas, "has-frame", invalid_boolean, NULL);
 430     g_object_get(canvas, "has-frame", &has_frame, NULL);
 431     g_assert_false(has_frame);
 432
 433     g_object_set(canvas, "has-frame", TRUE, NULL);
 434     g_object_get(canvas, "has-frame", &has_frame, NULL);
 435     g_assert_true(has_frame);
 436
 437     adg_entity_destroy(ADG_ENTITY(canvas));
 438 }
 439
 440 static void
 441 _adg_test_top_padding(void)
 442 {
 443     AdgCanvas *canvas;
 444     gdouble valid_value_1, valid_value_2;
 445     gdouble top_padding;
 446
 447     canvas = ADG_CANVAS(adg_canvas_new());
 448     valid_value_1 = 4321;
 449     valid_value_2 = 0;
 450
 451     /* Using the public APIs */
 452     adg_canvas_set_top_padding(canvas, valid_value_1);
 453     top_padding = adg_canvas_get_top_padding(canvas);
 454     g_assert_cmpfloat(top_padding, ==, valid_value_1);
 455
 456     adg_canvas_set_paddings(canvas, valid_value_2, 0, 0, 0);
 457     top_padding = adg_canvas_get_top_padding(canvas);
 458     g_assert_cmpfloat(top_padding, ==, valid_value_2);
 459
 460     /* Using GObject property methods */
 461     g_object_set(canvas, "top-padding", valid_value_1, NULL);
 462     g_object_get(canvas, "top-padding", &top_padding, NULL);
 463     g_assert_cmpfloat(top_padding, ==, valid_value_1);
 464
 465     g_object_set(canvas, "top-padding", valid_value_2, NULL);
 466     g_object_get(canvas, "top-padding", &top_padding, NULL);
 467     g_assert_cmpfloat(top_padding, ==, valid_value_2);
 468
 469     adg_entity_destroy(ADG_ENTITY(canvas));
 470 }
 471
 472 static void
 473 _adg_test_right_padding(void)
 474 {
 475     AdgCanvas *canvas;
 476     gdouble valid_value_1, valid_value_2;
 477     gdouble right_padding;
 478
 479     canvas = ADG_CANVAS(adg_canvas_new());
 480     valid_value_1 = 4321;
 481     valid_value_2 = -1;
 482
 483     /* Using the public APIs */
 484     adg_canvas_set_right_padding(canvas, valid_value_1);
 485     right_padding = adg_canvas_get_right_padding(canvas);
 486     g_assert_cmpfloat(right_padding, ==, valid_value_1);
 487
 488     adg_canvas_set_paddings(canvas, 0, valid_value_2, 0, 0);
 489     right_padding = adg_canvas_get_right_padding(canvas);
 490     g_assert_cmpfloat(right_padding, ==, valid_value_2);
 491
 492     /* Using GObject property methods */
 493     g_object_set(canvas, "right-padding", valid_value_1, NULL);
 494     g_object_get(canvas, "right-padding", &right_padding, NULL);
 495     g_assert_cmpfloat(right_padding, ==, valid_value_1);
 496
 497     g_object_set(canvas, "right-padding", valid_value_2, NULL);
 498     g_object_get(canvas, "right-padding", &right_padding, NULL);
 499     g_assert_cmpfloat(right_padding, ==, valid_value_2);
 500
 501     adg_entity_destroy(ADG_ENTITY(canvas));
 502 }
 503
 504 static void
 505 _adg_test_bottom_padding(void)
 506 {
 507     AdgCanvas *canvas;
 508     gdouble valid_value_1, valid_value_2;
 509     gdouble bottom_padding;
 510
 511     canvas = ADG_CANVAS(adg_canvas_new());
 512     valid_value_1 = 4321;
 513     valid_value_2 = -4321;
 514
 515     /* Using the public APIs */
 516     adg_canvas_set_bottom_padding(canvas, valid_value_1);
 517     bottom_padding = adg_canvas_get_bottom_padding(canvas);
 518     g_assert_cmpfloat(bottom_padding, ==, valid_value_1);
 519
 520     adg_canvas_set_paddings(canvas, 0, 0, valid_value_2, 0);
 521     bottom_padding = adg_canvas_get_bottom_padding(canvas);
 522     g_assert_cmpfloat(bottom_padding, ==, valid_value_2);
 523
 524     /* Using GObject property methods */
 525     g_object_set(canvas, "bottom-padding", valid_value_1, NULL);
 526     g_object_get(canvas, "bottom-padding", &bottom_padding, NULL);
 527     g_assert_cmpfloat(bottom_padding, ==, valid_value_1);
 528
 529     g_object_set(canvas, "bottom-padding", valid_value_2, NULL);
 530     g_object_get(canvas, "bottom-padding", &bottom_padding, NULL);
 531     g_assert_cmpfloat(bottom_padding, ==, valid_value_2);
 532
 533     adg_entity_destroy(ADG_ENTITY(canvas));
 534 }
 535
 536 static void
 537 _adg_test_left_padding(void)
 538 {
 539     AdgCanvas *canvas;
 540     gdouble valid_value_1, valid_value_2;
 541     gdouble left_padding;
 542
 543     canvas = ADG_CANVAS(adg_canvas_new());
 544     valid_value_1 = 4321;
 545     valid_value_2 = -1111;
 546
 547     /* Using the public APIs */
 548     adg_canvas_set_left_padding(canvas, valid_value_1);
 549     left_padding = adg_canvas_get_left_padding(canvas);
 550     g_assert_cmpfloat(left_padding, ==, valid_value_1);
 551
 552     adg_canvas_set_paddings(canvas, 0, 0, 0, valid_value_2);
 553     left_padding = adg_canvas_get_left_padding(canvas);
 554     g_assert_cmpfloat(left_padding, ==, valid_value_2);
 555
 556     /* Using GObject property methods */
 557     g_object_set(canvas, "left-padding", valid_value_1, NULL);
 558     g_object_get(canvas, "left-padding", &left_padding, NULL);
 559     g_assert_cmpfloat(left_padding, ==, valid_value_1);
 560
 561     g_object_set(canvas, "left-padding", valid_value_2, NULL);
 562     g_object_get(canvas, "left-padding", &left_padding, NULL);
 563     g_assert_cmpfloat(left_padding, ==, valid_value_2);
 564
 565     adg_entity_destroy(ADG_ENTITY(canvas));
 566 }
 567
 568 static void
 569 _adg_method_set_margins(void)
 570 {
 571     AdgCanvas *canvas = ADG_CANVAS(adg_canvas_new());
 572
 573     adg_canvas_set_margins(canvas, 0, 2, 4, 6);
 574
 575     g_assert_cmpfloat(adg_canvas_get_top_margin(canvas),    ==, 0);
 576     g_assert_cmpfloat(adg_canvas_get_right_margin(canvas),  ==, 2);
 577     g_assert_cmpfloat(adg_canvas_get_bottom_margin(canvas), ==, 4);
 578     g_assert_cmpfloat(adg_canvas_get_left_margin(canvas),   ==, 6);
 579
 580     adg_canvas_set_margins(canvas, 1, 3, 5, 7);
 581
 582     g_assert_cmpfloat(adg_canvas_get_top_margin(canvas),    ==, 1);
 583     g_assert_cmpfloat(adg_canvas_get_right_margin(canvas),  ==, 3);
 584     g_assert_cmpfloat(adg_canvas_get_bottom_margin(canvas), ==, 5);
 585     g_assert_cmpfloat(adg_canvas_get_left_margin(canvas),   ==, 7);
 586
 587     adg_entity_destroy(ADG_ENTITY(canvas));
 588 }
 589
 590 static void
 591 _adg_method_set_paddings(void)
 592 {
 593     AdgCanvas *canvas = ADG_CANVAS(adg_canvas_new());
 594
 595     adg_canvas_set_paddings(canvas, 0, 2, 4, 6);
 596
 597     g_assert_cmpfloat(adg_canvas_get_top_padding(canvas),    ==, 0);
 598     g_assert_cmpfloat(adg_canvas_get_right_padding(canvas),  ==, 2);
 599     g_assert_cmpfloat(adg_canvas_get_bottom_padding(canvas), ==, 4);
 600     g_assert_cmpfloat(adg_canvas_get_left_padding(canvas),   ==, 6);
 601
 602     adg_canvas_set_paddings(canvas, 1, 3, 5, 7);
 603
 604     g_assert_cmpfloat(adg_canvas_get_top_padding(canvas),    ==, 1);
 605     g_assert_cmpfloat(adg_canvas_get_right_padding(canvas),  ==, 3);
 606     g_assert_cmpfloat(adg_canvas_get_bottom_padding(canvas), ==, 5);
 607     g_assert_cmpfloat(adg_canvas_get_left_padding(canvas),   ==, 7);
 608
 609     adg_entity_destroy(ADG_ENTITY(canvas));
 610 }
 611
 612 #if GTK3_ENABLED || GTK2_ENABLED
 613 static void
 614 _adg_method_set_paper(void)
 615 {
 616     AdgCanvas *canvas;
 617     const CpmlPair *size;
 618     gdouble width, height;
 619
 620     canvas = ADG_CANVAS(adg_canvas_new());
 621
 622     size = adg_canvas_get_size(canvas);
 623     g_assert_cmpfloat(size->x, ==, 0);
 624     g_assert_cmpfloat(size->y, ==, 0);
 625
 626     adg_canvas_set_margins(canvas, 0, 0, 0, 0);
 627     adg_canvas_set_paper(canvas, GTK_PAPER_NAME_A4,
 628                          GTK_PAGE_ORIENTATION_LANDSCAPE);
 629
 630     g_assert_cmpfloat(adg_canvas_get_top_margin(canvas),    !=, 0);
 631     g_assert_cmpfloat(adg_canvas_get_right_margin(canvas),  !=, 0);
 632     g_assert_cmpfloat(adg_canvas_get_bottom_margin(canvas), !=, 0);
 633     g_assert_cmpfloat(adg_canvas_get_left_margin(canvas),   !=, 0);
 634
 635     size = adg_canvas_get_size(canvas);
 636     width = size->x;
 637     height = size->y;
 638     g_assert_cmpfloat(width, !=, 0);
 639     g_assert_cmpfloat(height, !=, 0);
 640
 641     adg_canvas_set_left_margin(canvas, 0);
 642     adg_canvas_set_top_margin(canvas, 0);
 643
 644     size = adg_canvas_get_size(canvas);
 645     g_assert_cmpfloat(width,  !=, size->x);
 646     g_assert_cmpfloat(height, !=, size->y);
 647     width = size->x;
 648     height = size->y;
 649
 650     /* Ensure the page size is decreased when margins are increased */
 651     adg_canvas_set_left_margin(canvas, adg_canvas_get_left_margin(canvas) + 1);
 652     adg_canvas_set_top_margin(canvas, adg_canvas_get_top_margin(canvas) + 2);
 653     size = adg_canvas_get_size(canvas);
 654     g_assert_cmpfloat(size->x, ==, width - 1);
 655     g_assert_cmpfloat(size->y, ==, height - 2);
 656
 657     adg_entity_destroy(ADG_ENTITY(canvas));
 658 }
 659
 660 static void
 661 _adg_method_get_page_setup(void)
 662 {
 663     AdgCanvas *canvas;
 664     GtkPageSetup *page_setup;
 665
 666     canvas = ADG_CANVAS(adg_canvas_new());
 667     page_setup = gtk_page_setup_new();
 668
 669     g_assert_null(adg_canvas_get_page_setup(canvas));
 670
 671     adg_canvas_set_page_setup(canvas, page_setup);
 672     g_assert_true(adg_canvas_get_page_setup(canvas) == page_setup);
 673
 674     /* canvas should still internally owns a reference to page_setup */
 675     g_object_unref(page_setup);
 676     g_assert_true(GTK_IS_PAGE_SETUP(adg_canvas_get_page_setup(canvas)));
 677
 678     adg_canvas_set_page_setup(canvas, NULL);
 679     g_assert_null(adg_canvas_get_page_setup(canvas));
 680
 681     adg_entity_destroy(ADG_ENTITY(canvas));
 682 }
 683
 684 static void
 685 _adg_method_set_page_setup(void)
 686 {
 687     AdgCanvas *canvas;
 688     GtkPageSetup *page_setup;
 689     const CpmlPair *size;
 690     gdouble width, height;
 691
 692     canvas = ADG_CANVAS(adg_canvas_new());
 693     page_setup = gtk_page_setup_new();
 694
 695     gtk_page_setup_set_top_margin(page_setup,    1, GTK_UNIT_POINTS);
 696     gtk_page_setup_set_right_margin(page_setup,  2, GTK_UNIT_POINTS);
 697     gtk_page_setup_set_left_margin(page_setup,   3, GTK_UNIT_POINTS);
 698     gtk_page_setup_set_bottom_margin(page_setup, 4, GTK_UNIT_POINTS);
 699
 700     adg_canvas_set_page_setup(canvas, page_setup);
 701     g_object_unref(page_setup);
 702
 703     g_assert_cmpfloat(adg_canvas_get_top_margin(canvas),    ==, 1);
 704     g_assert_cmpfloat(adg_canvas_get_right_margin(canvas),  ==, 2);
 705     g_assert_cmpfloat(adg_canvas_get_left_margin(canvas),   ==, 3);
 706     g_assert_cmpfloat(adg_canvas_get_bottom_margin(canvas), ==, 4);
 707
 708     adg_canvas_set_page_setup(canvas, NULL);
 709
 710     g_assert_cmpfloat(adg_canvas_get_top_margin(canvas),    ==, 1);
 711     g_assert_cmpfloat(adg_canvas_get_right_margin(canvas),  ==, 2);
 712     g_assert_cmpfloat(adg_canvas_get_left_margin(canvas),   ==, 3);
 713     g_assert_cmpfloat(adg_canvas_get_bottom_margin(canvas), ==, 4);
 714
 715     size = adg_canvas_get_size(canvas);
 716     width = size->x;
 717     height = size->y;
 718     g_assert_cmpfloat(adg_canvas_get_top_margin(canvas),    ==, 1);
 719
 720     /* When no page setup is bound to canvas, changing the margins
 721      * should not change the page size */
 722     adg_canvas_set_margins(canvas, 10, 20, 30, 40);
 723     size = adg_canvas_get_size(canvas);
 724     g_assert_cmpfloat(size->x, ==, width);
 725     g_assert_cmpfloat(size->y, ==, height);
 726
 727     adg_entity_destroy(ADG_ENTITY(canvas));
 728 }
 729 #endif
 730
 731 int
 732 main(int argc, char *argv[])
 733 {
 734     adg_test_init(&argc, &argv);
 735
 736     adg_test_add_object_checks("/adg/canvas/type/object", ADG_TYPE_CANVAS);
 737     adg_test_add_entity_checks("/adg/canvas/type/entity", ADG_TYPE_CANVAS);
 738     adg_test_add_container_checks("/adg/canvas/type/container", ADG_TYPE_CANVAS);
 739
 740     g_test_add_func("/adg/canvas/property/background-dress", _adg_test_background_dress);
 741     g_test_add_func("/adg/canvas/property/frame-dress", _adg_test_frame_dress);
 742     g_test_add_func("/adg/canvas/property/title-block", _adg_test_title_block);
 743     g_test_add_func("/adg/canvas/property/size", _adg_test_size);
 744     g_test_add_func("/adg/canvas/property/scales", _adg_test_scales);
 745     g_test_add_func("/adg/canvas/property/top-margin", _adg_test_top_margin);
 746     g_test_add_func("/adg/canvas/property/right-margin", _adg_test_right_margin);
 747     g_test_add_func("/adg/canvas/property/bottom-margin", _adg_test_bottom_margin);
 748     g_test_add_func("/adg/canvas/property/left-margin", _adg_test_left_margin);
 749     g_test_add_func("/adg/canvas/property/has-frame", _adg_test_has_frame);
 750     g_test_add_func("/adg/canvas/property/top-padding", _adg_test_top_padding);
 751     g_test_add_func("/adg/canvas/property/right-padding", _adg_test_right_padding);
 752     g_test_add_func("/adg/canvas/property/bottom-padding", _adg_test_bottom_padding);
 753     g_test_add_func("/adg/canvas/property/left-padding", _adg_test_left_padding);
 754
 755     g_test_add_func("/adg/canvas/method/set_margins", _adg_method_set_margins);
 756     g_test_add_func("/adg/canvas/method/set_paddings", _adg_method_set_paddings);
 757 #if GTK3_ENABLED || GTK2_ENABLED
 758     g_test_add_func("/adg/canvas/method/set_paper", _adg_method_set_paper);
 759     g_test_add_func("/adg/canvas/method/get_page_setup", _adg_method_get_page_setup);
 760     g_test_add_func("/adg/canvas/method/set_page_setup", _adg_method_set_page_setup);
 761 #endif
 762
 763     return g_test_run();
 764 }