src/adg/tests/test-canvas.c

   1 /* ADG - Automatic Drawing Generation
   2  * Copyright (C) 2007-2021  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 <config.h>
  22 #include <adg-test.h>
  23 #include <adg.h>
  24
  25 #ifdef G_OS_WIN32
  26
  27 #define NULL_FILE "NUL"
  28
  29 #else
  30
  31 #define NULL_FILE "/dev/null"
  32
  33 #endif
  34
  35
  36 static void
  37 _adg_behavior_entity(void)
  38 {
  39     AdgCanvas *canvas;
  40     const CpmlExtents *extents;
  41     AdgTitleBlock *title_block;
  42
  43     canvas = ADG_CANVAS(adg_test_canvas());
  44
  45     adg_entity_arrange(ADG_ENTITY(canvas));
  46     extents = adg_entity_get_extents(ADG_ENTITY(canvas));
  47     g_assert_true(extents->is_defined);
  48     adg_assert_isapprox(extents->size.x, 1);
  49     adg_assert_isapprox(extents->size.y, 1);
  50
  51     adg_entity_invalidate(ADG_ENTITY(canvas));
  52     extents = adg_entity_get_extents(ADG_ENTITY(canvas));
  53     g_assert_false(extents->is_defined);
  54
  55     title_block = adg_title_block_new();
  56     adg_canvas_set_title_block(canvas, title_block);
  57     adg_entity_arrange(ADG_ENTITY(canvas));
  58     extents = adg_entity_get_extents(ADG_ENTITY(canvas));
  59     g_assert_true(extents->is_defined);
  60     g_assert_cmpfloat(extents->size.x, >, 1);
  61     g_assert_cmpfloat(extents->size.y, >, 1);
  62     g_assert_cmpfloat(extents->size.x, <, 5000);
  63     g_assert_cmpfloat(extents->size.y, <, 5000);
  64
  65     adg_canvas_set_size_explicit(canvas, 5000, 5000);
  66     adg_entity_arrange(ADG_ENTITY(canvas));
  67     extents = adg_entity_get_extents(ADG_ENTITY(canvas));
  68     g_assert_true(extents->is_defined);
  69     adg_assert_isapprox(extents->size.x, 5000);
  70     adg_assert_isapprox(extents->size.y, 5000);
  71
  72     adg_entity_destroy(ADG_ENTITY(canvas));
  73 }
  74
  75 static void
  76 _adg_behavior_misc(void)
  77 {
  78     g_assert_cmpuint(ADG_CANVAS_ERROR, !=, 0);
  79 }
  80
  81 static void
  82 _adg_property_background_dress(void)
  83 {
  84     AdgCanvas *canvas;
  85     AdgDress valid_dress_1, valid_dress_2, incompatible_dress;
  86     AdgDress background_dress;
  87
  88     canvas = adg_canvas_new();
  89     valid_dress_1 = ADG_DRESS_COLOR_DIMENSION;
  90     valid_dress_2 = ADG_DRESS_COLOR_FILL;
  91     incompatible_dress = ADG_DRESS_FONT_QUOTE_ANNOTATION;
  92
  93     /* Using the public APIs */
  94     adg_canvas_set_background_dress(canvas, valid_dress_1);
  95     background_dress = adg_canvas_get_background_dress(canvas);
  96     g_assert_cmpint(background_dress, ==, valid_dress_1);
  97
  98     adg_canvas_set_background_dress(canvas, incompatible_dress);
  99     background_dress = adg_canvas_get_background_dress(canvas);
 100     g_assert_cmpint(background_dress, ==, valid_dress_1);
 101
 102     adg_canvas_set_background_dress(canvas, valid_dress_2);
 103     background_dress = adg_canvas_get_background_dress(canvas);
 104     g_assert_cmpint(background_dress, ==, valid_dress_2);
 105
 106     /* Using GObject property methods */
 107     g_object_set(canvas, "background-dress", valid_dress_1, NULL);
 108     g_object_get(canvas, "background-dress", &background_dress, NULL);
 109     g_assert_cmpint(background_dress, ==, valid_dress_1);
 110
 111     g_object_set(canvas, "background-dress", incompatible_dress, NULL);
 112     g_object_get(canvas, "background-dress", &background_dress, NULL);
 113     g_assert_cmpint(background_dress, ==, valid_dress_1);
 114
 115     g_object_set(canvas, "background-dress", valid_dress_2, NULL);
 116     g_object_get(canvas, "background-dress", &background_dress, NULL);
 117     g_assert_cmpint(background_dress, ==, valid_dress_2);
 118
 119     adg_entity_destroy(ADG_ENTITY(canvas));
 120 }
 121
 122 static void
 123 _adg_property_frame_dress(void)
 124 {
 125     AdgCanvas *canvas;
 126     AdgDress valid_dress_1, valid_dress_2, incompatible_dress;
 127     AdgDress frame_dress;
 128
 129     canvas = adg_canvas_new();
 130     valid_dress_1 = ADG_DRESS_LINE_DIMENSION;
 131     valid_dress_2 = ADG_DRESS_LINE_FILL;
 132     incompatible_dress = ADG_DRESS_FONT;
 133
 134     /* Using the public APIs */
 135     adg_canvas_set_frame_dress(canvas, valid_dress_1);
 136     frame_dress = adg_canvas_get_frame_dress(canvas);
 137     g_assert_cmpint(frame_dress, ==, valid_dress_1);
 138
 139     adg_canvas_set_frame_dress(canvas, incompatible_dress);
 140     frame_dress = adg_canvas_get_frame_dress(canvas);
 141     g_assert_cmpint(frame_dress, ==, valid_dress_1);
 142
 143     adg_canvas_set_frame_dress(canvas, valid_dress_2);
 144     frame_dress = adg_canvas_get_frame_dress(canvas);
 145     g_assert_cmpint(frame_dress, ==, valid_dress_2);
 146
 147     /* Using GObject property methods */
 148     g_object_set(canvas, "frame-dress", valid_dress_1, NULL);
 149     g_object_get(canvas, "frame-dress", &frame_dress, NULL);
 150     g_assert_cmpint(frame_dress, ==, valid_dress_1);
 151
 152     g_object_set(canvas, "frame-dress", incompatible_dress, NULL);
 153     g_object_get(canvas, "frame-dress", &frame_dress, NULL);
 154     g_assert_cmpint(frame_dress, ==, valid_dress_1);
 155
 156     g_object_set(canvas, "frame-dress", valid_dress_2, NULL);
 157     g_object_get(canvas, "frame-dress", &frame_dress, NULL);
 158     g_assert_cmpint(frame_dress, ==, valid_dress_2);
 159
 160     adg_entity_destroy(ADG_ENTITY(canvas));
 161 }
 162
 163 static void
 164 _adg_property_title_block(void)
 165 {
 166     AdgCanvas *canvas;
 167     AdgTitleBlock *valid_title_block, *invalid_title_block, *title_block;
 168
 169     canvas = adg_canvas_new();
 170     valid_title_block = ADG_TITLE_BLOCK(adg_title_block_new());
 171     invalid_title_block = adg_test_invalid_pointer();
 172
 173     g_object_ref(valid_title_block);
 174
 175     /* Using the public APIs */
 176     adg_canvas_set_title_block(canvas, NULL);
 177     title_block = adg_canvas_get_title_block(canvas);
 178     g_assert_null(title_block);
 179
 180     adg_canvas_set_title_block(canvas, valid_title_block);
 181     title_block = adg_canvas_get_title_block(canvas);
 182     g_assert_true(title_block == valid_title_block);
 183
 184     adg_canvas_set_title_block(canvas, invalid_title_block);
 185     title_block = adg_canvas_get_title_block(canvas);
 186     g_assert_true(title_block == valid_title_block);
 187
 188     adg_canvas_set_title_block(canvas, NULL);
 189     title_block = adg_canvas_get_title_block(canvas);
 190     g_assert_null(title_block);
 191
 192     /* Using GObject property methods */
 193     g_object_set(canvas, "title-block", NULL, NULL);
 194     g_object_get(canvas, "title-block", &title_block, NULL);
 195     g_assert_null(title_block);
 196
 197     g_object_set(canvas, "title-block", valid_title_block, NULL);
 198     g_object_get(canvas, "title-block", &title_block, NULL);
 199     g_assert_true(title_block == valid_title_block);
 200     g_object_unref(title_block);
 201
 202     g_object_set(canvas, "title-block", invalid_title_block, NULL);
 203     g_object_get(canvas, "title-block", &title_block, NULL);
 204     g_assert_true(title_block == valid_title_block);
 205     g_object_unref(title_block);
 206
 207     g_object_set(canvas, "title-block", NULL, NULL);
 208     g_object_get(canvas, "title-block", &title_block, NULL);
 209     g_assert_null(title_block);
 210
 211     adg_entity_destroy(ADG_ENTITY(canvas));
 212 }
 213
 214 static void
 215 _adg_property_size(void)
 216 {
 217     AdgCanvas *canvas;
 218     CpmlPair null_size, sample_size;
 219     const CpmlPair *size;
 220     CpmlPair *size_dup;
 221
 222     canvas = adg_canvas_new();
 223     null_size.x = 0;
 224     null_size.y = 0;
 225     sample_size.x = 123;
 226     sample_size.y = 321;
 227
 228     /* Using the public APIs */
 229     size = adg_canvas_get_size(canvas);
 230
 231     /* The default size is 0, 0 (anamorphic canvas) */
 232     g_assert_true(cpml_pair_equal(size, &null_size));
 233
 234     adg_canvas_set_size(canvas, &sample_size);
 235     size = adg_canvas_get_size(canvas);
 236     g_assert_true(cpml_pair_equal(size, &sample_size));
 237
 238     adg_canvas_set_size(canvas, NULL);
 239     size = adg_canvas_get_size(canvas);
 240     g_assert_true(cpml_pair_equal(size, &sample_size));
 241
 242     adg_canvas_set_size_explicit(canvas, 0, 0);
 243     size = adg_canvas_get_size(canvas);
 244     g_assert_true(cpml_pair_equal(size, &null_size));
 245
 246     /* Using GObject property methods */
 247     g_object_set(canvas, "size", &sample_size, NULL);
 248     g_object_get(canvas, "size", &size_dup, NULL);
 249     g_assert_true(cpml_pair_equal(size_dup, &sample_size));
 250     g_free(size_dup);
 251
 252     g_object_set(canvas, "size", NULL, NULL);
 253     g_object_get(canvas, "size", &size_dup, NULL);
 254     g_assert_true(cpml_pair_equal(size_dup, &sample_size));
 255     g_free(size_dup);
 256
 257     g_object_set(canvas, "size", &null_size, NULL);
 258     g_object_get(canvas, "size", &size_dup, NULL);
 259     g_assert_true(cpml_pair_equal(size_dup, &null_size));
 260     g_free(size_dup);
 261
 262     adg_entity_destroy(ADG_ENTITY(canvas));
 263 }
 264
 265 static void
 266 _adg_property_factor(void)
 267 {
 268     AdgCanvas *canvas;
 269     gdouble factor;
 270
 271     canvas = ADG_CANVAS(adg_canvas_new());
 272
 273     /* Using the public APIs */
 274     factor = adg_canvas_get_factor(canvas);
 275     adg_assert_isapprox(factor, 1);
 276
 277     adg_canvas_set_factor(canvas, 123);
 278     factor = adg_canvas_get_factor(canvas);
 279     adg_assert_isapprox(factor, 123);
 280
 281     adg_canvas_set_factor(canvas, -123);
 282     factor = adg_canvas_get_factor(canvas);
 283     adg_assert_isapprox(factor, 123);
 284
 285     adg_canvas_set_factor(canvas, 0);
 286     factor = adg_canvas_get_factor(canvas);
 287     adg_assert_isapprox(factor, 123);
 288
 289     /* Using GObject property methods */
 290     g_object_set(canvas, "factor", 321., NULL);
 291     g_object_get(canvas, "factor", &factor, NULL);
 292     adg_assert_isapprox(factor, 321);
 293
 294     g_object_set(canvas, "factor", -321., NULL);
 295     g_object_get(canvas, "factor", &factor, NULL);
 296     adg_assert_isapprox(factor, 321);
 297
 298     g_object_set(canvas, "factor", 0., NULL);
 299     g_object_get(canvas, "factor", &factor, NULL);
 300     adg_assert_isapprox(factor, 321);
 301
 302     adg_entity_destroy(ADG_ENTITY(canvas));
 303 }
 304
 305 static void
 306 _adg_property_scales(void)
 307 {
 308     AdgCanvas *canvas;
 309     gchar **scales;
 310     gchar *scales_array[] = { "a", "b", "c", NULL };
 311
 312     /* By default, AdgCanvas:scales is prefilled with some default scales */
 313     canvas = adg_canvas_new();
 314     scales = adg_canvas_get_scales(canvas);
 315     g_assert_nonnull(scales);
 316     adg_entity_destroy(ADG_ENTITY(canvas));
 317
 318     /* AdgCanvas:scales must be prefilled also when using g_object_new() */
 319     canvas = g_object_new(ADG_TYPE_CANVAS, NULL);
 320     scales = adg_canvas_get_scales(canvas);
 321     g_assert_nonnull(scales);
 322
 323     /* Using the public APIs */
 324     adg_canvas_set_scales(canvas, NULL);
 325     scales = adg_canvas_get_scales(canvas);
 326     g_assert_null(scales);
 327
 328     adg_canvas_set_scales(canvas, "0", "1", NULL);
 329     scales = adg_canvas_get_scales(canvas);
 330     g_assert_nonnull(scales);
 331     g_assert_cmpstr(scales[0], ==, "0");
 332     g_assert_cmpstr(scales[1], ==, "1");
 333     g_assert_null(scales[2]);
 334
 335     adg_canvas_set_scales_array(canvas, NULL);
 336     scales = adg_canvas_get_scales(canvas);
 337     g_assert_null(scales);
 338
 339     adg_canvas_set_scales_array(canvas, scales_array);
 340     scales = adg_canvas_get_scales(canvas);
 341     g_assert_nonnull(scales);
 342     g_assert_cmpstr(scales[0], ==, "a");
 343     g_assert_cmpstr(scales[1], ==, "b");
 344     g_assert_cmpstr(scales[2], ==, "c");
 345     g_assert_null(scales[3]);
 346
 347     /* Using GObject property methods */
 348     g_object_set(canvas, "scales", NULL, NULL);
 349     g_object_get(canvas, "scales", &scales, NULL);
 350     g_assert_null(scales);
 351
 352     g_object_set(canvas, "scales", scales_array, NULL);
 353     g_object_get(canvas, "scales", &scales, NULL);
 354     g_assert_nonnull(scales);
 355     g_assert_cmpstr(scales[0], ==, "a");
 356     g_assert_cmpstr(scales[1], ==, "b");
 357     g_assert_cmpstr(scales[2], ==, "c");
 358     g_assert_null(scales[3]);
 359     g_strfreev(scales);
 360
 361     adg_entity_destroy(ADG_ENTITY(canvas));
 362 }
 363
 364 static void
 365 _adg_property_top_margin(void)
 366 {
 367     AdgCanvas *canvas;
 368     gdouble valid_value_1, valid_value_2;
 369     gdouble top_margin;
 370
 371     canvas = ADG_CANVAS(adg_canvas_new());
 372     valid_value_1 = 4321;
 373     valid_value_2 = -1;
 374
 375     /* Using the public APIs */
 376     adg_canvas_set_top_margin(canvas, valid_value_1);
 377     top_margin = adg_canvas_get_top_margin(canvas);
 378     adg_assert_isapprox(top_margin, valid_value_1);
 379
 380     adg_canvas_set_margins(canvas, valid_value_2, 0, 0, 0);
 381     top_margin = adg_canvas_get_top_margin(canvas);
 382     adg_assert_isapprox(top_margin, valid_value_2);
 383
 384     /* Using GObject property methods */
 385     g_object_set(canvas, "top-margin", valid_value_1, NULL);
 386     g_object_get(canvas, "top-margin", &top_margin, NULL);
 387     adg_assert_isapprox(top_margin, valid_value_1);
 388
 389     g_object_set(canvas, "top-margin", valid_value_2, NULL);
 390     g_object_get(canvas, "top-margin", &top_margin, NULL);
 391     adg_assert_isapprox(top_margin, valid_value_2);
 392
 393     adg_entity_destroy(ADG_ENTITY(canvas));
 394 }
 395
 396 static void
 397 _adg_property_right_margin(void)
 398 {
 399     AdgCanvas *canvas;
 400     gdouble valid_value_1, valid_value_2;
 401     gdouble right_margin;
 402
 403     canvas = ADG_CANVAS(adg_canvas_new());
 404     valid_value_1 = 4321;
 405     valid_value_2 = 0;
 406
 407     /* Using the public APIs */
 408     adg_canvas_set_right_margin(canvas, valid_value_1);
 409     right_margin = adg_canvas_get_right_margin(canvas);
 410     adg_assert_isapprox(right_margin, valid_value_1);
 411
 412     adg_canvas_set_margins(canvas, 0, valid_value_2, 0, 0);
 413     right_margin = adg_canvas_get_right_margin(canvas);
 414     adg_assert_isapprox(right_margin, valid_value_2);
 415
 416     /* Using GObject property methods */
 417     g_object_set(canvas, "right-margin", valid_value_1, NULL);
 418     g_object_get(canvas, "right-margin", &right_margin, NULL);
 419     adg_assert_isapprox(right_margin, valid_value_1);
 420
 421     g_object_set(canvas, "right-margin", valid_value_2, NULL);
 422     g_object_get(canvas, "right-margin", &right_margin, NULL);
 423     adg_assert_isapprox(right_margin, valid_value_2);
 424
 425     adg_entity_destroy(ADG_ENTITY(canvas));
 426 }
 427
 428 static void
 429 _adg_property_bottom_margin(void)
 430 {
 431     AdgCanvas *canvas;
 432     gdouble valid_value_1, valid_value_2;
 433     gdouble bottom_margin;
 434
 435     canvas = ADG_CANVAS(adg_canvas_new());
 436     valid_value_1 = 4321;
 437     valid_value_2 = -1234;
 438
 439     /* Using the public APIs */
 440     adg_canvas_set_bottom_margin(canvas, valid_value_1);
 441     bottom_margin = adg_canvas_get_bottom_margin(canvas);
 442     adg_assert_isapprox(bottom_margin, valid_value_1);
 443
 444     adg_canvas_set_margins(canvas, 0, 0, valid_value_2, 0);
 445     bottom_margin = adg_canvas_get_bottom_margin(canvas);
 446     adg_assert_isapprox(bottom_margin, valid_value_2);
 447
 448     /* Using GObject property methods */
 449     g_object_set(canvas, "bottom-margin", valid_value_1, NULL);
 450     g_object_get(canvas, "bottom-margin", &bottom_margin, NULL);
 451     adg_assert_isapprox(bottom_margin, valid_value_1);
 452
 453     g_object_set(canvas, "bottom-margin", valid_value_2, NULL);
 454     g_object_get(canvas, "bottom-margin", &bottom_margin, NULL);
 455     adg_assert_isapprox(bottom_margin, valid_value_2);
 456
 457     adg_entity_destroy(ADG_ENTITY(canvas));
 458 }
 459
 460 static void
 461 _adg_property_left_margin(void)
 462 {
 463     AdgCanvas *canvas;
 464     gdouble valid_value_1, valid_value_2;
 465     gdouble left_margin;
 466
 467     canvas = ADG_CANVAS(adg_canvas_new());
 468     valid_value_1 = 4321;
 469     valid_value_2 = -4321;
 470
 471     /* Using the public APIs */
 472     adg_canvas_set_left_margin(canvas, valid_value_1);
 473     left_margin = adg_canvas_get_left_margin(canvas);
 474     adg_assert_isapprox(left_margin, valid_value_1);
 475
 476     adg_canvas_set_margins(canvas, 0, 0, 0, valid_value_2);
 477     left_margin = adg_canvas_get_left_margin(canvas);
 478     adg_assert_isapprox(left_margin, valid_value_2);
 479
 480     /* Using GObject property methods */
 481     g_object_set(canvas, "left-margin", valid_value_1, NULL);
 482     g_object_get(canvas, "left-margin", &left_margin, NULL);
 483     adg_assert_isapprox(left_margin, valid_value_1);
 484
 485     g_object_set(canvas, "left-margin", valid_value_2, NULL);
 486     g_object_get(canvas, "left-margin", &left_margin, NULL);
 487     adg_assert_isapprox(left_margin, valid_value_2);
 488
 489     adg_entity_destroy(ADG_ENTITY(canvas));
 490 }
 491
 492 static void
 493 _adg_property_has_frame(void)
 494 {
 495     AdgCanvas *canvas;
 496     gboolean invalid_boolean;
 497     gboolean has_frame;
 498
 499     canvas = ADG_CANVAS(adg_canvas_new());
 500     invalid_boolean = (gboolean) 1234;
 501
 502     /* Using the public APIs */
 503     adg_canvas_switch_frame(canvas, FALSE);
 504     has_frame = adg_canvas_has_frame(canvas);
 505     g_assert_false(has_frame);
 506
 507     adg_canvas_switch_frame(canvas, invalid_boolean);
 508     has_frame = adg_canvas_has_frame(canvas);
 509     g_assert_false(has_frame);
 510
 511     adg_canvas_switch_frame(canvas, TRUE);
 512     has_frame = adg_canvas_has_frame(canvas);
 513     g_assert_true(has_frame);
 514
 515     /* Using GObject property methods */
 516     g_object_set(canvas, "has-frame", FALSE, NULL);
 517     g_object_get(canvas, "has-frame", &has_frame, NULL);
 518     g_assert_false(has_frame);
 519
 520     g_object_set(canvas, "has-frame", invalid_boolean, NULL);
 521     g_object_get(canvas, "has-frame", &has_frame, NULL);
 522     g_assert_false(has_frame);
 523
 524     g_object_set(canvas, "has-frame", TRUE, NULL);
 525     g_object_get(canvas, "has-frame", &has_frame, NULL);
 526     g_assert_true(has_frame);
 527
 528     adg_entity_destroy(ADG_ENTITY(canvas));
 529 }
 530
 531 static void
 532 _adg_property_top_padding(void)
 533 {
 534     AdgCanvas *canvas;
 535     gdouble valid_value_1, valid_value_2;
 536     gdouble top_padding;
 537
 538     canvas = ADG_CANVAS(adg_canvas_new());
 539     valid_value_1 = 4321;
 540     valid_value_2 = 0;
 541
 542     /* Using the public APIs */
 543     adg_canvas_set_top_padding(canvas, valid_value_1);
 544     top_padding = adg_canvas_get_top_padding(canvas);
 545     adg_assert_isapprox(top_padding, valid_value_1);
 546
 547     adg_canvas_set_paddings(canvas, valid_value_2, 0, 0, 0);
 548     top_padding = adg_canvas_get_top_padding(canvas);
 549     adg_assert_isapprox(top_padding, valid_value_2);
 550
 551     /* Using GObject property methods */
 552     g_object_set(canvas, "top-padding", valid_value_1, NULL);
 553     g_object_get(canvas, "top-padding", &top_padding, NULL);
 554     adg_assert_isapprox(top_padding, valid_value_1);
 555
 556     g_object_set(canvas, "top-padding", valid_value_2, NULL);
 557     g_object_get(canvas, "top-padding", &top_padding, NULL);
 558     adg_assert_isapprox(top_padding, valid_value_2);
 559
 560     adg_entity_destroy(ADG_ENTITY(canvas));
 561 }
 562
 563 static void
 564 _adg_property_right_padding(void)
 565 {
 566     AdgCanvas *canvas;
 567     gdouble valid_value_1, valid_value_2;
 568     gdouble right_padding;
 569
 570     canvas = ADG_CANVAS(adg_canvas_new());
 571     valid_value_1 = 4321;
 572     valid_value_2 = -1;
 573
 574     /* Using the public APIs */
 575     adg_canvas_set_right_padding(canvas, valid_value_1);
 576     right_padding = adg_canvas_get_right_padding(canvas);
 577     adg_assert_isapprox(right_padding, valid_value_1);
 578
 579     adg_canvas_set_paddings(canvas, 0, valid_value_2, 0, 0);
 580     right_padding = adg_canvas_get_right_padding(canvas);
 581     adg_assert_isapprox(right_padding, valid_value_2);
 582
 583     /* Using GObject property methods */
 584     g_object_set(canvas, "right-padding", valid_value_1, NULL);
 585     g_object_get(canvas, "right-padding", &right_padding, NULL);
 586     adg_assert_isapprox(right_padding, valid_value_1);
 587
 588     g_object_set(canvas, "right-padding", valid_value_2, NULL);
 589     g_object_get(canvas, "right-padding", &right_padding, NULL);
 590     adg_assert_isapprox(right_padding, valid_value_2);
 591
 592     adg_entity_destroy(ADG_ENTITY(canvas));
 593 }
 594
 595 static void
 596 _adg_property_bottom_padding(void)
 597 {
 598     AdgCanvas *canvas;
 599     gdouble valid_value_1, valid_value_2;
 600     gdouble bottom_padding;
 601
 602     canvas = ADG_CANVAS(adg_canvas_new());
 603     valid_value_1 = 4321;
 604     valid_value_2 = -4321;
 605
 606     /* Using the public APIs */
 607     adg_canvas_set_bottom_padding(canvas, valid_value_1);
 608     bottom_padding = adg_canvas_get_bottom_padding(canvas);
 609     adg_assert_isapprox(bottom_padding, valid_value_1);
 610
 611     adg_canvas_set_paddings(canvas, 0, 0, valid_value_2, 0);
 612     bottom_padding = adg_canvas_get_bottom_padding(canvas);
 613     adg_assert_isapprox(bottom_padding, valid_value_2);
 614
 615     /* Using GObject property methods */
 616     g_object_set(canvas, "bottom-padding", valid_value_1, NULL);
 617     g_object_get(canvas, "bottom-padding", &bottom_padding, NULL);
 618     adg_assert_isapprox(bottom_padding, valid_value_1);
 619
 620     g_object_set(canvas, "bottom-padding", valid_value_2, NULL);
 621     g_object_get(canvas, "bottom-padding", &bottom_padding, NULL);
 622     adg_assert_isapprox(bottom_padding, valid_value_2);
 623
 624     adg_entity_destroy(ADG_ENTITY(canvas));
 625 }
 626
 627 static void
 628 _adg_property_left_padding(void)
 629 {
 630     AdgCanvas *canvas;
 631     gdouble valid_value_1, valid_value_2;
 632     gdouble left_padding;
 633
 634     canvas = ADG_CANVAS(adg_canvas_new());
 635     valid_value_1 = 4321;
 636     valid_value_2 = -1111;
 637
 638     /* Using the public APIs */
 639     adg_canvas_set_left_padding(canvas, valid_value_1);
 640     left_padding = adg_canvas_get_left_padding(canvas);
 641     adg_assert_isapprox(left_padding, valid_value_1);
 642
 643     adg_canvas_set_paddings(canvas, 0, 0, 0, valid_value_2);
 644     left_padding = adg_canvas_get_left_padding(canvas);
 645     adg_assert_isapprox(left_padding, valid_value_2);
 646
 647     /* Using GObject property methods */
 648     g_object_set(canvas, "left-padding", valid_value_1, NULL);
 649     g_object_get(canvas, "left-padding", &left_padding, NULL);
 650     adg_assert_isapprox(left_padding, valid_value_1);
 651
 652     g_object_set(canvas, "left-padding", valid_value_2, NULL);
 653     g_object_get(canvas, "left-padding", &left_padding, NULL);
 654     adg_assert_isapprox(left_padding, valid_value_2);
 655
 656     adg_entity_destroy(ADG_ENTITY(canvas));
 657 }
 658
 659 static void
 660 _adg_method_autoscale(void)
 661 {
 662     AdgCanvas *canvas;
 663     AdgTitleBlock *title_block;
 664     AdgPath *path;
 665     AdgStroke *stroke;
 666     const cairo_matrix_t *matrix;
 667
 668     canvas = adg_canvas_new();
 669
 670     /* Check autoscale does not crash on no scales */
 671     adg_canvas_set_scales(canvas, NULL);
 672     adg_canvas_autoscale(canvas);
 673
 674     /* Set an arbitrary size on canvas: the first three scales
 675      * are invalids and should be ignored*/
 676     adg_canvas_set_scales(canvas, "0", "-1:1", "1:0", "10:1", "1 a 1", "1:2", "1:10 ", NULL);
 677     adg_canvas_set_size_explicit(canvas, 100, 100);
 678
 679     /* Check the scale will be reported on the title block */
 680     title_block = adg_title_block_new();
 681     adg_canvas_set_title_block(canvas, title_block);
 682     g_object_unref(title_block);
 683
 684     path = adg_path_new();
 685     adg_path_move_to_explicit(path, 0, 0);
 686     adg_path_line_to_explicit(path, 5, 5);
 687     stroke = adg_stroke_new(ADG_TRAIL(path));
 688     g_object_unref(path);
 689
 690     adg_container_add(ADG_CONTAINER(canvas), ADG_ENTITY(stroke));
 691
 692     adg_canvas_autoscale(canvas);
 693     matrix = adg_entity_get_local_matrix(ADG_ENTITY(canvas));
 694     adg_assert_isapprox(matrix->xx, 10);
 695     g_assert_cmpstr(adg_title_block_get_scale(title_block), ==, "10:1");
 696
 697     adg_path_line_to_explicit(path, 50, 50);
 698
 699     adg_canvas_autoscale(canvas);
 700     matrix = adg_entity_get_local_matrix(ADG_ENTITY(canvas));
 701     adg_assert_isapprox(matrix->xx, 1);
 702     g_assert_cmpstr(adg_title_block_get_scale(title_block), ==, "1 a 1");
 703
 704     adg_path_line_to_explicit(path, 0, 100);
 705
 706     adg_canvas_autoscale(canvas);
 707     matrix = adg_entity_get_local_matrix(ADG_ENTITY(canvas));
 708     adg_assert_isapprox(matrix->xx, 0.5);
 709     g_assert_cmpstr(adg_title_block_get_scale(title_block), ==, "1:2");
 710
 711     adg_path_line_to_explicit(path, 800, 0);
 712
 713     adg_canvas_autoscale(canvas);
 714     matrix = adg_entity_get_local_matrix(ADG_ENTITY(canvas));
 715     adg_assert_isapprox(matrix->xx, 0.1);
 716     g_assert_cmpstr(adg_title_block_get_scale(title_block), ==, "1:10 ");
 717
 718     adg_entity_destroy(ADG_ENTITY(canvas));
 719 }
 720
 721 static void
 722 _adg_method_set_margins(void)
 723 {
 724     AdgCanvas *canvas = ADG_CANVAS(adg_canvas_new());
 725
 726     adg_canvas_set_margins(canvas, 0, 2, 4, 6);
 727
 728     g_assert_cmpfloat(adg_canvas_get_top_margin(canvas),    ==, 0);
 729     g_assert_cmpfloat(adg_canvas_get_right_margin(canvas),  ==, 2);
 730     adg_assert_isapprox(adg_canvas_get_bottom_margin(canvas), 4);
 731     g_assert_cmpfloat(adg_canvas_get_left_margin(canvas),   ==, 6);
 732
 733     adg_canvas_set_margins(canvas, 1, 3, 5, 7);
 734
 735     g_assert_cmpfloat(adg_canvas_get_top_margin(canvas),    ==, 1);
 736     g_assert_cmpfloat(adg_canvas_get_right_margin(canvas),  ==, 3);
 737     adg_assert_isapprox(adg_canvas_get_bottom_margin(canvas), 5);
 738     g_assert_cmpfloat(adg_canvas_get_left_margin(canvas),   ==, 7);
 739
 740     adg_entity_destroy(ADG_ENTITY(canvas));
 741 }
 742
 743 static void
 744 _adg_method_get_margins(void)
 745 {
 746     AdgCanvas *canvas = ADG_CANVAS(adg_canvas_new());
 747     gdouble top, right, bottom, left;
 748
 749     adg_canvas_set_margins(canvas, 1, 2, 3, 4);
 750
 751     /* Check that passing NULL does not crash the process */
 752     adg_canvas_get_margins(canvas, NULL, NULL, NULL, NULL);
 753
 754     adg_canvas_get_margins(canvas, &top, &right, &bottom, &left);
 755     adg_assert_isapprox(top, 1);
 756     adg_assert_isapprox(right, 2);
 757     adg_assert_isapprox(bottom, 3);
 758     adg_assert_isapprox(left, 4);
 759
 760     adg_entity_destroy(ADG_ENTITY(canvas));
 761 }
 762
 763 static void
 764 _adg_method_get_paddings(void)
 765 {
 766     AdgCanvas *canvas = ADG_CANVAS(adg_canvas_new());
 767     gdouble top, right, bottom, left;
 768
 769     adg_canvas_set_paddings(canvas, 1, 2, 3, 4);
 770
 771     /* Check that passing NULL does not crash the process */
 772     adg_canvas_get_paddings(canvas, NULL, NULL, NULL, NULL);
 773
 774     adg_canvas_get_paddings(canvas, &top, &right, &bottom, &left);
 775     adg_assert_isapprox(top, 1);
 776     adg_assert_isapprox(right, 2);
 777     adg_assert_isapprox(bottom, 3);
 778     adg_assert_isapprox(left, 4);
 779
 780     adg_entity_destroy(ADG_ENTITY(canvas));
 781 }
 782
 783 static void
 784 _adg_method_apply_margins(void)
 785 {
 786     AdgCanvas *canvas = ADG_CANVAS(adg_canvas_new());
 787     CpmlExtents extents = {
 788         .is_defined = 1,
 789         .org = { 0, 0 },
 790         .size = { 10, 10 }
 791     };
 792
 793     /* Sanity checks */
 794     adg_canvas_apply_margins(canvas, NULL);
 795     //adg_canvas_apply_margins(NULL, &extents);
 796
 797     adg_canvas_set_margins(canvas, 1, 2, 3, 4);
 798
 799     adg_canvas_apply_margins(canvas, &extents);
 800
 801     g_assert_cmpfloat(extents.org.x,  ==, -4);
 802     g_assert_cmpfloat(extents.org.y,  ==, -1);
 803     adg_assert_isapprox(extents.size.x, 16);
 804     adg_assert_isapprox(extents.size.y, 14);
 805
 806     adg_canvas_apply_margins(canvas, &extents);
 807
 808     g_assert_cmpfloat(extents.org.x,  ==, -8);
 809     g_assert_cmpfloat(extents.org.y,  ==, -2);
 810     adg_assert_isapprox(extents.size.x, 22);
 811     adg_assert_isapprox(extents.size.y, 18);
 812
 813     extents.is_defined = 0;
 814     adg_canvas_apply_margins(canvas, &extents);
 815
 816     g_assert_cmpfloat(extents.org.x,  ==, -8);
 817     g_assert_cmpfloat(extents.org.y,  ==, -2);
 818     adg_assert_isapprox(extents.size.x, 22);
 819     adg_assert_isapprox(extents.size.y, 18);
 820
 821     adg_entity_destroy(ADG_ENTITY(canvas));
 822 }
 823
 824 static void
 825 _adg_method_set_paddings(void)
 826 {
 827     AdgCanvas *canvas = ADG_CANVAS(adg_canvas_new());
 828
 829     adg_canvas_set_paddings(canvas, 0, 2, 4, 6);
 830
 831     g_assert_cmpfloat(adg_canvas_get_top_padding(canvas),    ==, 0);
 832     g_assert_cmpfloat(adg_canvas_get_right_padding(canvas),  ==, 2);
 833     adg_assert_isapprox(adg_canvas_get_bottom_padding(canvas), 4);
 834     g_assert_cmpfloat(adg_canvas_get_left_padding(canvas),   ==, 6);
 835
 836     adg_canvas_set_paddings(canvas, 1, 3, 5, 7);
 837
 838     g_assert_cmpfloat(adg_canvas_get_top_padding(canvas),    ==, 1);
 839     g_assert_cmpfloat(adg_canvas_get_right_padding(canvas),  ==, 3);
 840     adg_assert_isapprox(adg_canvas_get_bottom_padding(canvas), 5);
 841     g_assert_cmpfloat(adg_canvas_get_left_padding(canvas),   ==, 7);
 842
 843     adg_entity_destroy(ADG_ENTITY(canvas));
 844 }
 845
 846 static void
 847 _adg_method_export(void)
 848 {
 849     AdgCanvas *canvas = adg_test_canvas();
 850
 851     /* Sanity check */
 852     g_assert_false(adg_canvas_export(NULL, CAIRO_SURFACE_TYPE_IMAGE, NULL_FILE, NULL));
 853     g_assert_false(adg_canvas_export(canvas, CAIRO_SURFACE_TYPE_IMAGE, NULL, NULL));
 854
 855     /* Supported surface types return TRUE while unsupported ones return FALSE */
 856     g_assert_true(adg_canvas_export(canvas, CAIRO_SURFACE_TYPE_IMAGE, NULL_FILE, NULL));
 857     g_assert_true(adg_canvas_export(canvas, CAIRO_SURFACE_TYPE_PDF, NULL_FILE, NULL));
 858     g_assert_true(adg_canvas_export(canvas, CAIRO_SURFACE_TYPE_PS, NULL_FILE, NULL));
 859     g_assert_false(adg_canvas_export(canvas, CAIRO_SURFACE_TYPE_XLIB, NULL_FILE, NULL));
 860     g_assert_false(adg_canvas_export(canvas, CAIRO_SURFACE_TYPE_XCB, NULL_FILE, NULL));
 861     g_assert_false(adg_canvas_export(canvas, CAIRO_SURFACE_TYPE_GLITZ, NULL_FILE, NULL));
 862     g_assert_false(adg_canvas_export(canvas, CAIRO_SURFACE_TYPE_QUARTZ, NULL_FILE, NULL));
 863     g_assert_false(adg_canvas_export(canvas, CAIRO_SURFACE_TYPE_WIN32, NULL_FILE, NULL));
 864     g_assert_false(adg_canvas_export(canvas, CAIRO_SURFACE_TYPE_BEOS, NULL_FILE, NULL));
 865     g_assert_false(adg_canvas_export(canvas, CAIRO_SURFACE_TYPE_DIRECTFB, NULL_FILE, NULL));
 866     g_assert_true(adg_canvas_export(canvas, CAIRO_SURFACE_TYPE_SVG, NULL_FILE, NULL));
 867     g_assert_false(adg_canvas_export(canvas, CAIRO_SURFACE_TYPE_OS2, NULL_FILE, NULL));
 868     g_assert_false(adg_canvas_export(canvas, CAIRO_SURFACE_TYPE_WIN32_PRINTING, NULL_FILE, NULL));
 869     g_assert_false(adg_canvas_export(canvas, CAIRO_SURFACE_TYPE_QUARTZ_IMAGE, NULL_FILE, NULL));
 870
 871     /* An empty canvas can fail depending on the surface type (e.g., the image
 872      * surface fails while the PDF surface does not) so skipping that tests */
 873
 874     adg_entity_destroy(ADG_ENTITY(canvas));
 875 }
 876
 877 #if GTK3_ENABLED || GTK2_ENABLED
 878
 879 static void
 880 _adg_method_set_paper(void)
 881 {
 882     AdgCanvas *canvas;
 883     const CpmlPair *size;
 884     gdouble width, height;
 885
 886     canvas = ADG_CANVAS(adg_canvas_new());
 887
 888     size = adg_canvas_get_size(canvas);
 889     adg_assert_isapprox(size->x, 0);
 890     adg_assert_isapprox(size->y, 0);
 891
 892     adg_canvas_set_margins(canvas, 0, 0, 0, 0);
 893     adg_canvas_set_paper(canvas, GTK_PAPER_NAME_A4,
 894                          GTK_PAGE_ORIENTATION_LANDSCAPE);
 895
 896     g_assert_cmpfloat(adg_canvas_get_top_margin(canvas),    !=, 0);
 897     g_assert_cmpfloat(adg_canvas_get_right_margin(canvas),  !=, 0);
 898     g_assert_cmpfloat(adg_canvas_get_bottom_margin(canvas), !=, 0);
 899     g_assert_cmpfloat(adg_canvas_get_left_margin(canvas),   !=, 0);
 900
 901     size = adg_canvas_get_size(canvas);
 902     width = size->x;
 903     height = size->y;
 904     g_assert_cmpfloat(width, !=, 0);
 905     g_assert_cmpfloat(height, !=, 0);
 906
 907     adg_canvas_set_left_margin(canvas, 0);
 908     adg_canvas_set_top_margin(canvas, 0);
 909
 910     size = adg_canvas_get_size(canvas);
 911     g_assert_cmpfloat(width,  !=, size->x);
 912     g_assert_cmpfloat(height, !=, size->y);
 913     width = size->x;
 914     height = size->y;
 915
 916     /* Ensure the page size is decreased when margins are increased */
 917     adg_canvas_set_left_margin(canvas, adg_canvas_get_left_margin(canvas) + 1);
 918     adg_canvas_set_top_margin(canvas, adg_canvas_get_top_margin(canvas) + 2);
 919     size = adg_canvas_get_size(canvas);
 920     adg_assert_isapprox(size->x, width - 1);
 921     adg_assert_isapprox(size->y, height - 2);
 922
 923     adg_entity_destroy(ADG_ENTITY(canvas));
 924 }
 925
 926 static void
 927 _adg_method_get_page_setup(void)
 928 {
 929     AdgCanvas *canvas;
 930     GtkPageSetup *page_setup;
 931
 932     /* Sanity checks */
 933     g_assert_null(adg_canvas_get_page_setup(NULL));
 934
 935     canvas = ADG_CANVAS(adg_canvas_new());
 936     page_setup = gtk_page_setup_new();
 937
 938     g_assert_null(adg_canvas_get_page_setup(canvas));
 939
 940     adg_canvas_set_page_setup(canvas, page_setup);
 941     g_assert_true(adg_canvas_get_page_setup(canvas) == page_setup);
 942
 943     /* canvas should still internally owns a reference to page_setup */
 944     g_object_unref(page_setup);
 945     g_assert_true(GTK_IS_PAGE_SETUP(adg_canvas_get_page_setup(canvas)));
 946
 947     adg_canvas_set_page_setup(canvas, NULL);
 948     g_assert_null(adg_canvas_get_page_setup(canvas));
 949
 950     adg_entity_destroy(ADG_ENTITY(canvas));
 951 }
 952
 953 static void
 954 _adg_method_set_page_setup(void)
 955 {
 956     AdgCanvas *canvas;
 957     GtkPageSetup *page_setup;
 958     const CpmlPair *size;
 959     gdouble width, height;
 960
 961     canvas = ADG_CANVAS(adg_canvas_new());
 962     page_setup = gtk_page_setup_new();
 963
 964     /* Sanity checks */
 965     adg_canvas_set_page_setup(NULL, page_setup);
 966
 967     gtk_page_setup_set_top_margin(page_setup,    1, GTK_UNIT_POINTS);
 968     gtk_page_setup_set_right_margin(page_setup,  2, GTK_UNIT_POINTS);
 969     gtk_page_setup_set_left_margin(page_setup,   3, GTK_UNIT_POINTS);
 970     gtk_page_setup_set_bottom_margin(page_setup, 4, GTK_UNIT_POINTS);
 971
 972     adg_canvas_set_page_setup(canvas, page_setup);
 973     g_object_unref(page_setup);
 974
 975     /* For some unknown reason the margins are rounded, so using
 976      * adg_assert_isapprox() instead of g_assert_cmpfloat() */
 977     adg_assert_isapprox(adg_canvas_get_top_margin(canvas),    1);
 978     adg_assert_isapprox(adg_canvas_get_right_margin(canvas),  2);
 979     adg_assert_isapprox(adg_canvas_get_left_margin(canvas),   3);
 980     adg_assert_isapprox(adg_canvas_get_bottom_margin(canvas), 4);
 981
 982     adg_canvas_set_page_setup(canvas, NULL);
 983
 984     adg_assert_isapprox(adg_canvas_get_top_margin(canvas),    1);
 985     adg_assert_isapprox(adg_canvas_get_right_margin(canvas),  2);
 986     adg_assert_isapprox(adg_canvas_get_left_margin(canvas),   3);
 987     adg_assert_isapprox(adg_canvas_get_bottom_margin(canvas), 4);
 988
 989     size = adg_canvas_get_size(canvas);
 990     width = size->x;
 991     height = size->y;
 992     g_assert_cmpfloat(adg_canvas_get_top_margin(canvas),    ==, 1);
 993
 994     /* When no page setup is bound to canvas, changing the margins
 995      * should not change the page size */
 996     adg_canvas_set_margins(canvas, 10, 20, 30, 40);
 997     size = adg_canvas_get_size(canvas);
 998     adg_assert_isapprox(size->x, width);
 999     adg_assert_isapprox(size->y, height);
1000
1001     adg_entity_destroy(ADG_ENTITY(canvas));
1002 }
1003
1004 #endif
1005
1006
1007 int
1008 main(int argc, char *argv[])
1009 {
1010     adg_test_init(&argc, &argv);
1011
1012     adg_test_add_object_checks("/adg/canvas/type/object", ADG_TYPE_CANVAS);
1013     adg_test_add_entity_checks("/adg/canvas/type/entity", ADG_TYPE_CANVAS);
1014     adg_test_add_container_checks("/adg/canvas/type/container", ADG_TYPE_CANVAS);
1015
1016     g_test_add_func("/adg/canvas/behavior/entity", _adg_behavior_entity);
1017     g_test_add_func("/adg/canvas/behavior/misc", _adg_behavior_misc);
1018     adg_test_add_global_space_checks("/adg/canvas/behavior/global-space", adg_test_canvas());
1019     adg_test_add_local_space_checks("/adg/canvas/behavior/local-space", adg_test_canvas());
1020
1021     g_test_add_func("/adg/canvas/property/background-dress", _adg_property_background_dress);
1022     g_test_add_func("/adg/canvas/property/frame-dress", _adg_property_frame_dress);
1023     g_test_add_func("/adg/canvas/property/title-block", _adg_property_title_block);
1024     g_test_add_func("/adg/canvas/property/size", _adg_property_size);
1025     g_test_add_func("/adg/canvas/property/factor", _adg_property_factor);
1026     g_test_add_func("/adg/canvas/property/scales", _adg_property_scales);
1027     g_test_add_func("/adg/canvas/property/top-margin", _adg_property_top_margin);
1028     g_test_add_func("/adg/canvas/property/right-margin", _adg_property_right_margin);
1029     g_test_add_func("/adg/canvas/property/bottom-margin", _adg_property_bottom_margin);
1030     g_test_add_func("/adg/canvas/property/left-margin", _adg_property_left_margin);
1031     g_test_add_func("/adg/canvas/property/has-frame", _adg_property_has_frame);
1032     g_test_add_func("/adg/canvas/property/top-padding", _adg_property_top_padding);
1033     g_test_add_func("/adg/canvas/property/right-padding", _adg_property_right_padding);
1034     g_test_add_func("/adg/canvas/property/bottom-padding", _adg_property_bottom_padding);
1035     g_test_add_func("/adg/canvas/property/left-padding", _adg_property_left_padding);
1036
1037     g_test_add_func("/adg/canvas/method/autoscale", _adg_method_autoscale);
1038     g_test_add_func("/adg/canvas/method/set-margins", _adg_method_set_margins);
1039     g_test_add_func("/adg/canvas/method/get-margins", _adg_method_get_margins);
1040     g_test_add_func("/adg/canvas/method/apply-margins", _adg_method_apply_margins);
1041     g_test_add_func("/adg/canvas/method/set-paddings", _adg_method_set_paddings);
1042     g_test_add_func("/adg/canvas/method/get-paddings", _adg_method_get_paddings);
1043     g_test_add_func("/adg/canvas/method/export", _adg_method_export);
1044 #if GTK3_ENABLED || GTK2_ENABLED
1045     g_test_add_func("/adg/canvas/method/set-paper", _adg_method_set_paper);
1046     g_test_add_func("/adg/canvas/method/get-page-setup", _adg_method_get_page_setup);
1047     g_test_add_func("/adg/canvas/method/set-page-setup", _adg_method_set_page_setup);
1048 #endif
1049
1050     return g_test_run();
1051 }