src/adg/tests/test-canvas.c

   1 /* ADG - Automatic Drawing Generation
   2  * Copyright (C) 2007,2008,2009,2010,2011,2012,2013  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     adg_entity_destroy(ADG_ENTITY(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     adg_entity_destroy(ADG_ENTITY(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     adg_entity_destroy(ADG_ENTITY(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     adg_entity_destroy(ADG_ENTITY(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     adg_entity_destroy(ADG_ENTITY(canvas));
 155     adg_entity_destroy(ADG_ENTITY(valid_title_block));
 156 }
 157
 158 static void
 159 _adg_test_size(void)
 160 {
 161     AdgCanvas *canvas;
 162     CpmlPair null_size, sample_size;
 163     const CpmlPair *size;
 164     CpmlPair *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(cpml_pair_equal(size, &sample_size));
 176
 177     adg_canvas_set_size(canvas, NULL);
 178     size = adg_canvas_get_size(canvas);
 179     g_assert(cpml_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(cpml_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(cpml_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(cpml_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(cpml_pair_equal(size_dup, &null_size));
 199     g_free(size_dup);
 200
 201     adg_entity_destroy(ADG_ENTITY(canvas));
 202 }
 203
 204 static void
 205 _adg_test_scales(void)
 206 {
 207     AdgCanvas *canvas;
 208     gchar **scales;
 209     gchar *scales_array[] = { "a", "b", "c", NULL };
 210
 211     /* By default, AdgCanvas:scales is prefilled with some default scales */
 212     canvas = adg_canvas_new();
 213     scales = adg_canvas_get_scales(canvas);
 214     g_assert(scales != NULL);
 215     adg_entity_destroy(ADG_ENTITY(canvas));
 216
 217     /* AdgCanvas:scales must be prefilled also when using g_object_new() */
 218     canvas = g_object_new(ADG_TYPE_CANVAS, NULL);
 219     scales = adg_canvas_get_scales(canvas);
 220     g_assert(scales != NULL);
 221
 222     /* Using the public APIs */
 223     adg_canvas_set_scales(canvas, NULL);
 224     scales = adg_canvas_get_scales(canvas);
 225     g_assert(scales == NULL);
 226
 227     adg_canvas_set_scales(canvas, "0", "1", NULL);
 228     scales = adg_canvas_get_scales(canvas);
 229     g_assert(scales != NULL);
 230     g_assert_cmpstr(scales[0], ==, "0");
 231     g_assert_cmpstr(scales[1], ==, "1");
 232     g_assert(scales[2] == NULL);
 233
 234     adg_canvas_set_scales_array(canvas, NULL);
 235     scales = adg_canvas_get_scales(canvas);
 236     g_assert(scales == NULL);
 237
 238     adg_canvas_set_scales_array(canvas, scales_array);
 239     scales = adg_canvas_get_scales(canvas);
 240     g_assert(scales != NULL);
 241     g_assert_cmpstr(scales[0], ==, "a");
 242     g_assert_cmpstr(scales[1], ==, "b");
 243     g_assert_cmpstr(scales[2], ==, "c");
 244     g_assert(scales[3] == NULL);
 245
 246     /* Using GObject property methods */
 247     g_object_set(canvas, "scales", NULL, NULL);
 248     g_object_get(canvas, "scales", &scales, NULL);
 249     g_assert(scales == NULL);
 250
 251     g_object_set(canvas, "scales", scales_array, NULL);
 252     g_object_get(canvas, "scales", &scales, NULL);
 253     g_assert(scales != NULL);
 254     g_assert_cmpstr(scales[0], ==, "a");
 255     g_assert_cmpstr(scales[1], ==, "b");
 256     g_assert_cmpstr(scales[2], ==, "c");
 257     g_assert(scales[3] == NULL);
 258     g_strfreev(scales);
 259
 260     /* Check autoscale does not crash on no scales */
 261     g_object_set(canvas, "scales", NULL, NULL);
 262     adg_canvas_autoscale(canvas);
 263
 264     adg_entity_destroy(ADG_ENTITY(canvas));
 265 }
 266
 267 static void
 268 _adg_test_top_margin(void)
 269 {
 270     AdgCanvas *canvas;
 271     gdouble valid_value_1, valid_value_2;
 272     gdouble top_margin;
 273
 274     canvas = ADG_CANVAS(adg_canvas_new());
 275     valid_value_1 = 4321;
 276     valid_value_2 = -1;
 277
 278     /* Using the public APIs */
 279     adg_canvas_set_top_margin(canvas, valid_value_1);
 280     top_margin = adg_canvas_get_top_margin(canvas);
 281     g_assert_cmpfloat(top_margin, ==, valid_value_1);
 282
 283     adg_canvas_set_margins(canvas, valid_value_2, 0, 0, 0);
 284     top_margin = adg_canvas_get_top_margin(canvas);
 285     g_assert_cmpfloat(top_margin, ==, valid_value_2);
 286
 287     /* Using GObject property methods */
 288     g_object_set(canvas, "top-margin", valid_value_1, NULL);
 289     g_object_get(canvas, "top-margin", &top_margin, NULL);
 290     g_assert_cmpfloat(top_margin, ==, valid_value_1);
 291
 292     g_object_set(canvas, "top-margin", valid_value_2, NULL);
 293     g_object_get(canvas, "top-margin", &top_margin, NULL);
 294     g_assert_cmpfloat(top_margin, ==, valid_value_2);
 295
 296     adg_entity_destroy(ADG_ENTITY(canvas));
 297 }
 298
 299 static void
 300 _adg_test_right_margin(void)
 301 {
 302     AdgCanvas *canvas;
 303     gdouble valid_value_1, valid_value_2;
 304     gdouble right_margin;
 305
 306     canvas = ADG_CANVAS(adg_canvas_new());
 307     valid_value_1 = 4321;
 308     valid_value_2 = 0;
 309
 310     /* Using the public APIs */
 311     adg_canvas_set_right_margin(canvas, valid_value_1);
 312     right_margin = adg_canvas_get_right_margin(canvas);
 313     g_assert_cmpfloat(right_margin, ==, valid_value_1);
 314
 315     adg_canvas_set_margins(canvas, 0, valid_value_2, 0, 0);
 316     right_margin = adg_canvas_get_right_margin(canvas);
 317     g_assert_cmpfloat(right_margin, ==, valid_value_2);
 318
 319     /* Using GObject property methods */
 320     g_object_set(canvas, "right-margin", valid_value_1, NULL);
 321     g_object_get(canvas, "right-margin", &right_margin, NULL);
 322     g_assert_cmpfloat(right_margin, ==, valid_value_1);
 323
 324     g_object_set(canvas, "right-margin", valid_value_2, NULL);
 325     g_object_get(canvas, "right-margin", &right_margin, NULL);
 326     g_assert_cmpfloat(right_margin, ==, valid_value_2);
 327
 328     adg_entity_destroy(ADG_ENTITY(canvas));
 329 }
 330
 331 static void
 332 _adg_test_bottom_margin(void)
 333 {
 334     AdgCanvas *canvas;
 335     gdouble valid_value_1, valid_value_2;
 336     gdouble bottom_margin;
 337
 338     canvas = ADG_CANVAS(adg_canvas_new());
 339     valid_value_1 = 4321;
 340     valid_value_2 = -1234;
 341
 342     /* Using the public APIs */
 343     adg_canvas_set_bottom_margin(canvas, valid_value_1);
 344     bottom_margin = adg_canvas_get_bottom_margin(canvas);
 345     g_assert_cmpfloat(bottom_margin, ==, valid_value_1);
 346
 347     adg_canvas_set_margins(canvas, 0, 0, valid_value_2, 0);
 348     bottom_margin = adg_canvas_get_bottom_margin(canvas);
 349     g_assert_cmpfloat(bottom_margin, ==, valid_value_2);
 350
 351     /* Using GObject property methods */
 352     g_object_set(canvas, "bottom-margin", valid_value_1, NULL);
 353     g_object_get(canvas, "bottom-margin", &bottom_margin, NULL);
 354     g_assert_cmpfloat(bottom_margin, ==, valid_value_1);
 355
 356     g_object_set(canvas, "bottom-margin", valid_value_2, NULL);
 357     g_object_get(canvas, "bottom-margin", &bottom_margin, NULL);
 358     g_assert_cmpfloat(bottom_margin, ==, valid_value_2);
 359
 360     adg_entity_destroy(ADG_ENTITY(canvas));
 361 }
 362
 363 static void
 364 _adg_test_left_margin(void)
 365 {
 366     AdgCanvas *canvas;
 367     gdouble valid_value_1, valid_value_2;
 368     gdouble left_margin;
 369
 370     canvas = ADG_CANVAS(adg_canvas_new());
 371     valid_value_1 = 4321;
 372     valid_value_2 = -4321;
 373
 374     /* Using the public APIs */
 375     adg_canvas_set_left_margin(canvas, valid_value_1);
 376     left_margin = adg_canvas_get_left_margin(canvas);
 377     g_assert_cmpfloat(left_margin, ==, valid_value_1);
 378
 379     adg_canvas_set_margins(canvas, 0, 0, 0, valid_value_2);
 380     left_margin = adg_canvas_get_left_margin(canvas);
 381     g_assert_cmpfloat(left_margin, ==, valid_value_2);
 382
 383     /* Using GObject property methods */
 384     g_object_set(canvas, "left-margin", valid_value_1, NULL);
 385     g_object_get(canvas, "left-margin", &left_margin, NULL);
 386     g_assert_cmpfloat(left_margin, ==, valid_value_1);
 387
 388     g_object_set(canvas, "left-margin", valid_value_2, NULL);
 389     g_object_get(canvas, "left-margin", &left_margin, NULL);
 390     g_assert_cmpfloat(left_margin, ==, valid_value_2);
 391
 392     adg_entity_destroy(ADG_ENTITY(canvas));
 393 }
 394
 395 static void
 396 _adg_test_has_frame(void)
 397 {
 398     AdgCanvas *canvas;
 399     gboolean invalid_boolean;
 400     gboolean has_frame;
 401
 402     canvas = ADG_CANVAS(adg_canvas_new());
 403     invalid_boolean = (gboolean) 1234;
 404
 405     /* Using the public APIs */
 406     adg_canvas_switch_frame(canvas, FALSE);
 407     has_frame = adg_canvas_has_frame(canvas);
 408     g_assert(!has_frame);
 409
 410     adg_canvas_switch_frame(canvas, invalid_boolean);
 411     has_frame = adg_canvas_has_frame(canvas);
 412     g_assert(!has_frame);
 413
 414     adg_canvas_switch_frame(canvas, TRUE);
 415     has_frame = adg_canvas_has_frame(canvas);
 416     g_assert(has_frame);
 417
 418     /* Using GObject property methods */
 419     g_object_set(canvas, "has-frame", FALSE, NULL);
 420     g_object_get(canvas, "has-frame", &has_frame, NULL);
 421     g_assert(!has_frame);
 422
 423     g_object_set(canvas, "has-frame", invalid_boolean, NULL);
 424     g_object_get(canvas, "has-frame", &has_frame, NULL);
 425     g_assert(!has_frame);
 426
 427     g_object_set(canvas, "has-frame", TRUE, NULL);
 428     g_object_get(canvas, "has-frame", &has_frame, NULL);
 429     g_assert(has_frame);
 430
 431     adg_entity_destroy(ADG_ENTITY(canvas));
 432 }
 433
 434 static void
 435 _adg_test_top_padding(void)
 436 {
 437     AdgCanvas *canvas;
 438     gdouble valid_value_1, valid_value_2;
 439     gdouble top_padding;
 440
 441     canvas = ADG_CANVAS(adg_canvas_new());
 442     valid_value_1 = 4321;
 443     valid_value_2 = 0;
 444
 445     /* Using the public APIs */
 446     adg_canvas_set_top_padding(canvas, valid_value_1);
 447     top_padding = adg_canvas_get_top_padding(canvas);
 448     g_assert_cmpfloat(top_padding, ==, valid_value_1);
 449
 450     adg_canvas_set_paddings(canvas, valid_value_2, 0, 0, 0);
 451     top_padding = adg_canvas_get_top_padding(canvas);
 452     g_assert_cmpfloat(top_padding, ==, valid_value_2);
 453
 454     /* Using GObject property methods */
 455     g_object_set(canvas, "top-padding", valid_value_1, NULL);
 456     g_object_get(canvas, "top-padding", &top_padding, NULL);
 457     g_assert_cmpfloat(top_padding, ==, valid_value_1);
 458
 459     g_object_set(canvas, "top-padding", valid_value_2, NULL);
 460     g_object_get(canvas, "top-padding", &top_padding, NULL);
 461     g_assert_cmpfloat(top_padding, ==, valid_value_2);
 462
 463     adg_entity_destroy(ADG_ENTITY(canvas));
 464 }
 465
 466 static void
 467 _adg_test_right_padding(void)
 468 {
 469     AdgCanvas *canvas;
 470     gdouble valid_value_1, valid_value_2;
 471     gdouble right_padding;
 472
 473     canvas = ADG_CANVAS(adg_canvas_new());
 474     valid_value_1 = 4321;
 475     valid_value_2 = -1;
 476
 477     /* Using the public APIs */
 478     adg_canvas_set_right_padding(canvas, valid_value_1);
 479     right_padding = adg_canvas_get_right_padding(canvas);
 480     g_assert_cmpfloat(right_padding, ==, valid_value_1);
 481
 482     adg_canvas_set_paddings(canvas, 0, valid_value_2, 0, 0);
 483     right_padding = adg_canvas_get_right_padding(canvas);
 484     g_assert_cmpfloat(right_padding, ==, valid_value_2);
 485
 486     /* Using GObject property methods */
 487     g_object_set(canvas, "right-padding", valid_value_1, NULL);
 488     g_object_get(canvas, "right-padding", &right_padding, NULL);
 489     g_assert_cmpfloat(right_padding, ==, valid_value_1);
 490
 491     g_object_set(canvas, "right-padding", valid_value_2, NULL);
 492     g_object_get(canvas, "right-padding", &right_padding, NULL);
 493     g_assert_cmpfloat(right_padding, ==, valid_value_2);
 494
 495     adg_entity_destroy(ADG_ENTITY(canvas));
 496 }
 497
 498 static void
 499 _adg_test_bottom_padding(void)
 500 {
 501     AdgCanvas *canvas;
 502     gdouble valid_value_1, valid_value_2;
 503     gdouble bottom_padding;
 504
 505     canvas = ADG_CANVAS(adg_canvas_new());
 506     valid_value_1 = 4321;
 507     valid_value_2 = -4321;
 508
 509     /* Using the public APIs */
 510     adg_canvas_set_bottom_padding(canvas, valid_value_1);
 511     bottom_padding = adg_canvas_get_bottom_padding(canvas);
 512     g_assert_cmpfloat(bottom_padding, ==, valid_value_1);
 513
 514     adg_canvas_set_paddings(canvas, 0, 0, valid_value_2, 0);
 515     bottom_padding = adg_canvas_get_bottom_padding(canvas);
 516     g_assert_cmpfloat(bottom_padding, ==, valid_value_2);
 517
 518     /* Using GObject property methods */
 519     g_object_set(canvas, "bottom-padding", valid_value_1, NULL);
 520     g_object_get(canvas, "bottom-padding", &bottom_padding, NULL);
 521     g_assert_cmpfloat(bottom_padding, ==, valid_value_1);
 522
 523     g_object_set(canvas, "bottom-padding", valid_value_2, NULL);
 524     g_object_get(canvas, "bottom-padding", &bottom_padding, NULL);
 525     g_assert_cmpfloat(bottom_padding, ==, valid_value_2);
 526
 527     adg_entity_destroy(ADG_ENTITY(canvas));
 528 }
 529
 530 static void
 531 _adg_test_left_padding(void)
 532 {
 533     AdgCanvas *canvas;
 534     gdouble valid_value_1, valid_value_2;
 535     gdouble left_padding;
 536
 537     canvas = ADG_CANVAS(adg_canvas_new());
 538     valid_value_1 = 4321;
 539     valid_value_2 = -1111;
 540
 541     /* Using the public APIs */
 542     adg_canvas_set_left_padding(canvas, valid_value_1);
 543     left_padding = adg_canvas_get_left_padding(canvas);
 544     g_assert_cmpfloat(left_padding, ==, valid_value_1);
 545
 546     adg_canvas_set_paddings(canvas, 0, 0, 0, valid_value_2);
 547     left_padding = adg_canvas_get_left_padding(canvas);
 548     g_assert_cmpfloat(left_padding, ==, valid_value_2);
 549
 550     /* Using GObject property methods */
 551     g_object_set(canvas, "left-padding", valid_value_1, NULL);
 552     g_object_get(canvas, "left-padding", &left_padding, NULL);
 553     g_assert_cmpfloat(left_padding, ==, valid_value_1);
 554
 555     g_object_set(canvas, "left-padding", valid_value_2, NULL);
 556     g_object_get(canvas, "left-padding", &left_padding, NULL);
 557     g_assert_cmpfloat(left_padding, ==, valid_value_2);
 558
 559     adg_entity_destroy(ADG_ENTITY(canvas));
 560 }
 561
 562
 563 int
 564 main(int argc, char *argv[])
 565 {
 566     adg_test_init(&argc, &argv);
 567
 568     adg_test_add_func("/adg/canvas/property/background-dress",
 569                       _adg_test_background_dress);
 570     adg_test_add_func("/adg/canvas/property/frame-dress",
 571                       _adg_test_frame_dress);
 572     adg_test_add_func("/adg/canvas/property/title-block",
 573                       _adg_test_title_block);
 574     adg_test_add_func("/adg/canvas/property/size",
 575                       _adg_test_size);
 576     adg_test_add_func("/adg/canvas/property/scales",
 577                       _adg_test_scales);
 578     adg_test_add_func("/adg/canvas/property/top-margin",
 579                       _adg_test_top_margin);
 580     adg_test_add_func("/adg/canvas/property/right-margin",
 581                       _adg_test_right_margin);
 582     adg_test_add_func("/adg/canvas/property/bottom-margin",
 583                       _adg_test_bottom_margin);
 584     adg_test_add_func("/adg/canvas/property/left-margin",
 585                       _adg_test_left_margin);
 586     adg_test_add_func("/adg/canvas/property/has-frame",
 587                       _adg_test_has_frame);
 588     adg_test_add_func("/adg/canvas/property/top-padding",
 589                       _adg_test_top_padding);
 590     adg_test_add_func("/adg/canvas/property/right-padding",
 591                       _adg_test_right_padding);
 592     adg_test_add_func("/adg/canvas/property/bottom-padding",
 593                       _adg_test_bottom_padding);
 594     adg_test_add_func("/adg/canvas/property/left-padding",
 595                       _adg_test_left_padding);
 596
 597     return g_test_run();
 598 }