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