src/adg/tests/test-canvas.c

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