src/adg/tests/test-dim.c

   1 /* ADG - Automatic Drawing Generation
   2  * Copyright (C) 2007-2017  Nicola Fontana <ntd at entidi.it>
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  17  * Boston, MA  02110-1301, USA.
  18  */
  19
  20
  21 #include <adg-test.h>
  22 #include <adg.h>
  23
  24
  25 static void
  26 _adg_property_detached(void)
  27 {
  28     AdgDim *dim;
  29     AdgThreeState valid_three_state_1, valid_three_state_2, invalid_three_state;
  30     AdgThreeState detached;
  31
  32     dim = ADG_DIM(adg_ldim_new());
  33     valid_three_state_1 = ADG_THREE_STATE_UNKNOWN;
  34     valid_three_state_2 = ADG_THREE_STATE_OFF;
  35     invalid_three_state = 1234;
  36
  37     /* Using the public APIs */
  38     adg_dim_set_detached(dim, valid_three_state_1);
  39     detached = adg_dim_get_detached(dim);
  40     g_assert_cmpint(detached, ==, valid_three_state_1);
  41
  42     adg_dim_set_detached(dim, invalid_three_state);
  43     detached = adg_dim_get_detached(dim);
  44     g_assert_cmpint(detached, ==, valid_three_state_1);
  45
  46     adg_dim_set_detached(dim, valid_three_state_2);
  47     detached = adg_dim_get_detached(dim);
  48     g_assert_cmpint(detached, ==, valid_three_state_2);
  49
  50     /* Using GObject property methods */
  51     g_object_set(dim, "detached", valid_three_state_1, NULL);
  52     g_object_get(dim, "detached", &detached, NULL);
  53     g_assert_cmpint(detached, ==, valid_three_state_1);
  54
  55     g_object_set(dim, "detached", invalid_three_state, NULL);
  56     g_object_get(dim, "detached", &detached, NULL);
  57     g_assert_cmpint(detached, ==, valid_three_state_1);
  58
  59     g_object_set(dim, "detached", valid_three_state_2, NULL);
  60     g_object_get(dim, "detached", &detached, NULL);
  61     g_assert_cmpint(detached, ==, valid_three_state_2);
  62
  63     adg_entity_destroy(ADG_ENTITY(dim));
  64 }
  65
  66 static void
  67 _adg_property_dim_dress(void)
  68 {
  69     AdgDim *dim;
  70     AdgDress valid_dress, incompatible_dress;
  71     AdgDress dim_dress;
  72
  73     dim = ADG_DIM(adg_ldim_new());
  74     valid_dress = ADG_DRESS_DIMENSION;
  75     incompatible_dress = ADG_DRESS_LINE;
  76
  77     /* Using the public APIs */
  78     adg_dim_set_dim_dress(dim, valid_dress);
  79     dim_dress = adg_dim_get_dim_dress(dim);
  80     g_assert_cmpint(dim_dress, ==, valid_dress);
  81
  82     adg_dim_set_dim_dress(dim, incompatible_dress);
  83     dim_dress = adg_dim_get_dim_dress(dim);
  84     g_assert_cmpint(dim_dress, ==, valid_dress);
  85
  86     /* Using GObject property methods */
  87     g_object_set(dim, "dim-dress", valid_dress, NULL);
  88     g_object_get(dim, "dim-dress", &dim_dress, NULL);
  89     g_assert_cmpint(dim_dress, ==, valid_dress);
  90
  91     g_object_set(dim, "dim-dress", incompatible_dress, NULL);
  92     g_object_get(dim, "dim-dress", &dim_dress, NULL);
  93     g_assert_cmpint(dim_dress, ==, valid_dress);
  94
  95     adg_entity_destroy(ADG_ENTITY(dim));
  96 }
  97
  98 static void
  99 _adg_property_level(void)
 100 {
 101     AdgDim *dim;
 102     gdouble valid_value_1, valid_value_2;
 103     gdouble level;
 104
 105     dim = ADG_DIM(adg_ldim_new());
 106     valid_value_1 = 4321;
 107     valid_value_2 = 1234;
 108
 109     /* Using the public APIs */
 110     adg_dim_set_level(dim, valid_value_1);
 111     level = adg_dim_get_level(dim);
 112     adg_assert_isapprox(level, valid_value_1);
 113
 114     adg_dim_set_level(dim, valid_value_2);
 115     level = adg_dim_get_level(dim);
 116     adg_assert_isapprox(level, valid_value_2);
 117
 118     /* Using GObject property methods */
 119     g_object_set(dim, "level", valid_value_1, NULL);
 120     g_object_get(dim, "level", &level, NULL);
 121     adg_assert_isapprox(level, valid_value_1);
 122
 123     g_object_set(dim, "level", valid_value_2, NULL);
 124     g_object_get(dim, "level", &level, NULL);
 125     adg_assert_isapprox(level, valid_value_2);
 126
 127     adg_entity_destroy(ADG_ENTITY(dim));
 128 }
 129
 130 static void
 131 _adg_property_max(void)
 132 {
 133     AdgDim *dim;
 134     const gchar *valid_text, *latin1_text;
 135     const gchar *max;
 136     gchar *max_dup;
 137
 138     dim = ADG_DIM(adg_ldim_new());
 139     valid_text = "This is some text...";
 140     latin1_text = "This is some àèìòù Latin1 text...";
 141
 142     /* Using the public APIs */
 143     adg_dim_set_max(dim, valid_text);
 144     max = adg_dim_get_max(dim);
 145     g_assert_cmpstr(max, ==, valid_text);
 146
 147     adg_dim_set_max(dim, latin1_text);
 148     max = adg_dim_get_max(dim);
 149     g_assert_cmpstr(max, ==, latin1_text);
 150
 151     adg_dim_set_max(dim, NULL);
 152     max = adg_dim_get_max(dim);
 153     g_assert_null(max);
 154
 155     /* Using GObject property methods */
 156     g_object_set(dim, "max", valid_text, NULL);
 157     g_object_get(dim, "max", &max_dup, NULL);
 158     g_assert_cmpstr(max_dup, ==, valid_text);
 159     g_free(max_dup);
 160
 161     g_object_set(dim, "max", latin1_text, NULL);
 162     g_object_get(dim, "max", &max_dup, NULL);
 163     g_assert_cmpstr(max_dup, ==, latin1_text);
 164     g_free(max_dup);
 165
 166     g_object_set(dim, "max", NULL, NULL);
 167     g_object_get(dim, "max", &max_dup, NULL);
 168     g_assert_null(max_dup);
 169
 170     adg_entity_destroy(ADG_ENTITY(dim));
 171 }
 172
 173 static void
 174 _adg_property_min(void)
 175 {
 176     AdgDim *dim;
 177     const gchar *valid_text, *latin1_text;
 178     const gchar *min;
 179     gchar *min_dup;
 180
 181     dim = ADG_DIM(adg_ldim_new());
 182     valid_text = "This is some text...";
 183     latin1_text = "This is some àèìòù Latin1 text...";
 184
 185     /* Using the public APIs */
 186     adg_dim_set_min(dim, valid_text);
 187     min = adg_dim_get_min(dim);
 188     g_assert_cmpstr(min, ==, valid_text);
 189
 190     adg_dim_set_min(dim, latin1_text);
 191     min = adg_dim_get_min(dim);
 192     g_assert_cmpstr(min, ==, latin1_text);
 193
 194     adg_dim_set_min(dim, NULL);
 195     min = adg_dim_get_min(dim);
 196     g_assert_null(min);
 197
 198     /* Using GObject property methods */
 199     g_object_set(dim, "min", valid_text, NULL);
 200     g_object_get(dim, "min", &min_dup, NULL);
 201     g_assert_cmpstr(min_dup, ==, valid_text);
 202     g_free(min_dup);
 203
 204     g_object_set(dim, "min", latin1_text, NULL);
 205     g_object_get(dim, "min", &min_dup, NULL);
 206     g_assert_cmpstr(min_dup, ==, latin1_text);
 207     g_free(min_dup);
 208
 209     g_object_set(dim, "min", NULL, NULL);
 210     g_object_get(dim, "min", &min_dup, NULL);
 211     g_assert_null(min_dup);
 212
 213     adg_entity_destroy(ADG_ENTITY(dim));
 214 }
 215
 216 static void
 217 _adg_property_outside(void)
 218 {
 219     AdgDim *dim;
 220     AdgThreeState valid_three_state_1, valid_three_state_2, invalid_three_state;
 221     AdgThreeState outside;
 222
 223     dim = ADG_DIM(adg_rdim_new());
 224     valid_three_state_1 = ADG_THREE_STATE_UNKNOWN;
 225     valid_three_state_2 = ADG_THREE_STATE_OFF;
 226     invalid_three_state = 1234;
 227
 228     /* Using the public APIs */
 229     adg_dim_set_outside(dim, valid_three_state_1);
 230     outside = adg_dim_get_outside(dim);
 231     g_assert_cmpint(outside, ==, valid_three_state_1);
 232
 233     adg_dim_set_outside(dim, invalid_three_state);
 234     outside = adg_dim_get_outside(dim);
 235     g_assert_cmpint(outside, ==, valid_three_state_1);
 236
 237     adg_dim_set_outside(dim, valid_three_state_2);
 238     outside = adg_dim_get_outside(dim);
 239     g_assert_cmpint(outside, ==, valid_three_state_2);
 240
 241     /* Using GObject property methods */
 242     g_object_set(dim, "outside", valid_three_state_1, NULL);
 243     g_object_get(dim, "outside", &outside, NULL);
 244     g_assert_cmpint(outside, ==, valid_three_state_1);
 245
 246     g_object_set(dim, "outside", invalid_three_state, NULL);
 247     g_object_get(dim, "outside", &outside, NULL);
 248     g_assert_cmpint(outside, ==, valid_three_state_1);
 249
 250     g_object_set(dim, "outside", valid_three_state_2, NULL);
 251     g_object_get(dim, "outside", &outside, NULL);
 252     g_assert_cmpint(outside, ==, valid_three_state_2);
 253
 254     adg_entity_destroy(ADG_ENTITY(dim));
 255 }
 256
 257 static void
 258 _adg_property_pos(void)
 259 {
 260     AdgDim *dim;
 261     AdgModel *model;
 262     AdgPoint *origin, *explicit_point, *model_point;
 263     AdgPoint *pos;
 264
 265     dim = ADG_DIM(adg_rdim_new());
 266     model = ADG_MODEL(adg_path_new());
 267     origin = adg_point_new();
 268     explicit_point = adg_point_new();
 269     model_point = adg_point_new();
 270
 271     adg_point_set_pair_explicit(origin, 0, 0);
 272     adg_point_set_pair_explicit(explicit_point, 123, 321);
 273     adg_model_set_named_pair(model, "named-pair", (CpmlPair *) explicit_point);
 274     adg_point_set_pair_from_model(model_point, model, "named-pair");
 275
 276     /* Ensure ADG does not consider an explicit point equals to
 277      * a point bound to a named pair with the same coordinates */
 278     g_assert_false(adg_point_equal(explicit_point, model_point));
 279
 280     pos = adg_dim_get_pos(dim);
 281     g_assert_null(pos);
 282
 283     /* Using the public APIs */
 284     adg_dim_set_pos_explicit(dim, 0, 0);
 285     pos = adg_dim_get_pos(dim);
 286     g_assert_true(adg_point_equal(pos, origin));
 287
 288     adg_dim_set_pos(dim, NULL);
 289     pos = adg_dim_get_pos(dim);
 290     g_assert_null(pos);
 291
 292     adg_dim_set_pos(dim, explicit_point);
 293     pos = adg_dim_get_pos(dim);
 294     g_assert_true(adg_point_equal(pos, explicit_point));
 295
 296     adg_dim_set_pos_from_model(dim, model, "dummy");
 297     pos = adg_dim_get_pos(dim);
 298     g_assert_nonnull(pos);
 299
 300     adg_dim_set_pos_from_model(dim, model, "named-pair");
 301     pos = adg_dim_get_pos(dim);
 302     g_assert_true(adg_point_equal(pos, model_point));
 303
 304     /* Using GObject property methods */
 305     g_object_set(dim, "pos", origin, NULL);
 306     g_object_get(dim, "pos", &pos, NULL);
 307     g_assert_true(adg_point_equal(pos, origin));
 308     adg_point_destroy(pos);
 309
 310     g_object_set(dim, "pos", NULL, NULL);
 311     g_object_get(dim, "pos", &pos, NULL);
 312     g_assert_null(pos);
 313
 314     g_object_set(dim, "pos", explicit_point, NULL);
 315     g_object_get(dim, "pos", &pos, NULL);
 316     g_assert_true(adg_point_equal(pos, explicit_point));
 317     adg_point_destroy(pos);
 318
 319     adg_dim_set_pos_from_model(dim, model, "dummy");
 320     g_object_get(dim, "pos", &pos, NULL);
 321     g_assert_nonnull(pos);
 322     adg_point_destroy(pos);
 323
 324     g_object_set(dim, "pos", model_point, NULL);
 325     g_object_get(dim, "pos", &pos, NULL);
 326     g_assert_true(adg_point_equal(pos, model_point));
 327     adg_point_destroy(pos);
 328
 329     adg_point_destroy(origin);
 330     adg_point_destroy(explicit_point);
 331     adg_point_destroy(model_point);
 332     adg_entity_destroy(ADG_ENTITY(dim));
 333     g_object_unref(model);
 334 }
 335
 336 static void
 337 _adg_property_ref1(void)
 338 {
 339     AdgDim *dim;
 340     AdgModel *model;
 341     AdgPoint *origin, *explicit_point, *model_point;
 342     AdgPoint *ref1;
 343
 344     dim = ADG_DIM(adg_rdim_new());
 345     model = ADG_MODEL(adg_path_new());
 346     origin = adg_point_new();
 347     explicit_point = adg_point_new();
 348     model_point = adg_point_new();
 349
 350     adg_point_set_pair_explicit(origin, 0, 0);
 351     adg_point_set_pair_explicit(explicit_point, 123, 321);
 352     adg_model_set_named_pair(model, "named-pair", (CpmlPair *) explicit_point);
 353     adg_point_set_pair_from_model(model_point, model, "named-pair");
 354
 355     /* Ensure ADG does not consider an explicit point equals to
 356      * a point bound to a named pair with the same coordinates */
 357     g_assert_false(adg_point_equal(explicit_point, model_point));
 358
 359     ref1 = adg_dim_get_ref1(dim);
 360     g_assert_null(ref1);
 361
 362     /* Using the public APIs */
 363     adg_dim_set_ref1_explicit(dim, 0, 0);
 364     ref1 = adg_dim_get_ref1(dim);
 365     g_assert_true(adg_point_equal(ref1, origin));
 366
 367     adg_dim_set_ref1(dim, NULL);
 368     ref1 = adg_dim_get_ref1(dim);
 369     g_assert_null(ref1);
 370
 371     adg_dim_set_ref1(dim, explicit_point);
 372     ref1 = adg_dim_get_ref1(dim);
 373     g_assert_true(adg_point_equal(ref1, explicit_point));
 374
 375     adg_dim_set_ref1_from_model(dim, model, "dummy");
 376     ref1 = adg_dim_get_ref1(dim);
 377     g_assert_nonnull(ref1);
 378
 379     adg_dim_set_ref1_from_model(dim, model, "named-pair");
 380     ref1 = adg_dim_get_ref1(dim);
 381     g_assert_true(adg_point_equal(ref1, model_point));
 382
 383     /* Using GObject property methods */
 384     g_object_set(dim, "ref1", origin, NULL);
 385     g_object_get(dim, "ref1", &ref1, NULL);
 386     g_assert_true(adg_point_equal(ref1, origin));
 387     adg_point_destroy(ref1);
 388
 389     g_object_set(dim, "ref1", NULL, NULL);
 390     g_object_get(dim, "ref1", &ref1, NULL);
 391     g_assert_null(ref1);
 392
 393     g_object_set(dim, "ref1", explicit_point, NULL);
 394     g_object_get(dim, "ref1", &ref1, NULL);
 395     g_assert_true(adg_point_equal(ref1, explicit_point));
 396     adg_point_destroy(ref1);
 397
 398     adg_dim_set_ref1_from_model(dim, model, "dummy");
 399     g_object_get(dim, "ref1", &ref1, NULL);
 400     g_assert_nonnull(ref1);
 401     adg_point_destroy(ref1);
 402
 403     g_object_set(dim, "ref1", model_point, NULL);
 404     g_object_get(dim, "ref1", &ref1, NULL);
 405     g_assert_true(adg_point_equal(ref1, model_point));
 406     adg_point_destroy(ref1);
 407
 408     adg_point_destroy(origin);
 409     adg_point_destroy(explicit_point);
 410     adg_point_destroy(model_point);
 411     adg_entity_destroy(ADG_ENTITY(dim));
 412     g_object_unref(model);
 413 }
 414
 415 static void
 416 _adg_property_ref2(void)
 417 {
 418     AdgDim *dim;
 419     AdgModel *model;
 420     AdgPoint *origin, *explicit_point, *model_point;
 421     AdgPoint *ref2;
 422
 423     dim = ADG_DIM(adg_rdim_new());
 424     model = ADG_MODEL(adg_path_new());
 425     origin = adg_point_new();
 426     explicit_point = adg_point_new();
 427     model_point = adg_point_new();
 428
 429     adg_point_set_pair_explicit(origin, 0, 0);
 430     adg_point_set_pair_explicit(explicit_point, 123, 321);
 431     adg_model_set_named_pair(model, "named-pair", (CpmlPair *) explicit_point);
 432     adg_point_set_pair_from_model(model_point, model, "named-pair");
 433
 434     /* Ensure ADG does not consider an explicit point equals to
 435      * a point bound to a named pair with the same coordinates */
 436     g_assert_false(adg_point_equal(explicit_point, model_point));
 437
 438     ref2 = adg_dim_get_ref2(dim);
 439     g_assert_null(ref2);
 440
 441     /* Using the public APIs */
 442     adg_dim_set_ref2_explicit(dim, 0, 0);
 443     ref2 = adg_dim_get_ref2(dim);
 444     g_assert_true(adg_point_equal(ref2, origin));
 445
 446     adg_dim_set_ref2(dim, NULL);
 447     ref2 = adg_dim_get_ref2(dim);
 448     g_assert_null(ref2);
 449
 450     adg_dim_set_ref2(dim, explicit_point);
 451     ref2 = adg_dim_get_ref2(dim);
 452     g_assert_true(adg_point_equal(ref2, explicit_point));
 453
 454     adg_dim_set_ref2_from_model(dim, model, "dummy");
 455     ref2 = adg_dim_get_ref2(dim);
 456     g_assert_nonnull(ref2);
 457
 458     adg_dim_set_ref2_from_model(dim, model, "named-pair");
 459     ref2 = adg_dim_get_ref2(dim);
 460     g_assert_true(adg_point_equal(ref2, model_point));
 461
 462     /* Using GObject property methods */
 463     g_object_set(dim, "ref2", origin, NULL);
 464     g_object_get(dim, "ref2", &ref2, NULL);
 465     g_assert_true(adg_point_equal(ref2, origin));
 466     adg_point_destroy(ref2);
 467
 468     g_object_set(dim, "ref2", NULL, NULL);
 469     g_object_get(dim, "ref2", &ref2, NULL);
 470     g_assert_null(ref2);
 471
 472     g_object_set(dim, "ref2", explicit_point, NULL);
 473     g_object_get(dim, "ref2", &ref2, NULL);
 474     g_assert_true(adg_point_equal(ref2, explicit_point));
 475     adg_point_destroy(ref2);
 476
 477     adg_dim_set_ref2_from_model(dim, model, "dummy");
 478     g_object_get(dim, "ref2", &ref2, NULL);
 479     g_assert_nonnull(ref2);
 480     adg_point_destroy(ref2);
 481
 482     g_object_set(dim, "ref2", model_point, NULL);
 483     g_object_get(dim, "ref2", &ref2, NULL);
 484     g_assert_true(adg_point_equal(ref2, model_point));
 485     adg_point_destroy(ref2);
 486
 487     adg_point_destroy(origin);
 488     adg_point_destroy(explicit_point);
 489     adg_point_destroy(model_point);
 490     adg_entity_destroy(ADG_ENTITY(dim));
 491     g_object_unref(model);
 492 }
 493
 494 static void
 495 _adg_property_value(void)
 496 {
 497     AdgDim *dim;
 498     const gchar *valid_text, *latin1_text;
 499     const gchar *value;
 500     gchar *value_dup;
 501
 502     dim = ADG_DIM(adg_ldim_new());
 503     valid_text = "This is some text...";
 504     latin1_text = "This is some àèìòù Latin1 text...";
 505
 506     /* Using the public APIs */
 507     adg_dim_set_value(dim, valid_text);
 508     value = adg_dim_get_value(dim);
 509     g_assert_cmpstr(value, ==, valid_text);
 510
 511     adg_dim_set_value(dim, latin1_text);
 512     value = adg_dim_get_value(dim);
 513     g_assert_cmpstr(value, ==, latin1_text);
 514
 515     adg_dim_set_value(dim, NULL);
 516     value = adg_dim_get_value(dim);
 517     g_assert_null(value);
 518
 519     /* Using GObject property methods */
 520     g_object_set(dim, "value", valid_text, NULL);
 521     g_object_get(dim, "value", &value_dup, NULL);
 522     g_assert_cmpstr(value_dup, ==, valid_text);
 523     g_free(value_dup);
 524
 525     g_object_set(dim, "value", latin1_text, NULL);
 526     g_object_get(dim, "value", &value_dup, NULL);
 527     g_assert_cmpstr(value_dup, ==, latin1_text);
 528     g_free(value_dup);
 529
 530     g_object_set(dim, "value", NULL, NULL);
 531     g_object_get(dim, "value", &value_dup, NULL);
 532     g_assert_null(value_dup);
 533
 534     adg_entity_destroy(ADG_ENTITY(dim));
 535 }
 536
 537 static void
 538 _adg_method_get_text(void)
 539 {
 540     AdgDim *dim;
 541     AdgDimStyle *dim_style;
 542     gchar *text;
 543
 544     dim = ADG_DIM(adg_ldim_new());
 545     dim_style = ADG_DIM_STYLE(adg_entity_style(ADG_ENTITY(dim), ADG_DRESS_DIMENSION));
 546
 547     /* Checking predefined dresses */
 548
 549     /* Default dress: ADG_DRESS_DIMENSION */
 550     text = adg_dim_get_text(dim, 7.891);
 551     g_assert_cmpstr(text, ==, "7.89");
 552     g_free(text);
 553
 554     adg_dim_set_dim_dress(dim, ADG_DRESS_DIMENSION_ANGULAR);
 555     text = adg_dim_get_text(dim, 7.891);
 556     g_assert_cmpstr(text, ==, "7°53'");
 557     g_free(text);
 558
 559     adg_dim_set_dim_dress(dim, ADG_DRESS_DIMENSION_RADIUS);
 560     text = adg_dim_get_text(dim, 7.891);
 561     g_assert_cmpstr(text, ==, "R7.89");
 562     g_free(text);
 563
 564     adg_dim_set_dim_dress(dim, ADG_DRESS_DIMENSION_DIAMETER);
 565     text = adg_dim_get_text(dim, 7.891);
 566     g_assert_cmpstr(text, ==, ADG_UTF8_DIAMETER "7.89");
 567     g_free(text);
 568
 569     /* Restore the default dress */
 570     adg_dim_set_dim_dress(dim, ADG_DRESS_DIMENSION);
 571     text = adg_dim_get_text(dim, 3.456);
 572     g_assert_cmpstr(text, ==, "3.46");
 573     g_free(text);
 574
 575     /* Decrease the decimals */
 576     adg_dim_style_set_decimals(dim_style, 1);
 577     text = adg_dim_get_text(dim, 7.891);
 578     g_assert_cmpstr(text, ==, "7.9");
 579     g_free(text);
 580
 581     /* Change the argument type */
 582     adg_dim_style_set_number_arguments(dim_style, "a");
 583     text = adg_dim_get_text(dim, 7.891);
 584     g_assert_cmpstr(text, ==, "7.891");
 585     g_free(text);
 586
 587     adg_dim_style_set_number_arguments(dim_style, "D");
 588     text = adg_dim_get_text(dim, 7.891);
 589     g_assert_cmpstr(text, ==, "7");
 590     g_free(text);
 591
 592     adg_dim_style_set_number_arguments(dim_style, "d");
 593     text = adg_dim_get_text(dim, 7.891);
 594     g_assert_cmpstr(text, ==, "7.9");
 595     g_free(text);
 596
 597     /* Change the number format */
 598     adg_dim_style_set_number_format(dim_style, "%.3f");
 599     text = adg_dim_get_text(dim, 7.891);
 600     g_assert_cmpstr(text, ==, "7.900");
 601     g_free(text);
 602
 603     /* Trying a complex formatting with multiple fields */
 604     adg_dim_style_set_decimals(dim_style, 2);
 605     adg_dim_style_set_number_arguments(dim_style, "aieDMSdms");
 606     adg_dim_style_set_number_format(dim_style, "%%Raw: \\(%g, %g, %g\\); Truncated: \\(%g, %g, %g\\); Rounded: \\(%g, %g, %g\\)");
 607     text = adg_dim_get_text(dim, 7.891);
 608     g_assert_cmpstr(text, ==, "%Raw: (7.891, 53.46, 27.6); Truncated: (7, 53, 27); Rounded: (7.89, 53.46, 27.6)");
 609     g_free(text);
 610
 611     text = adg_dim_get_text(dim, 5.432);
 612     g_assert_cmpstr(text, ==, "%Raw: (5.432, 25.92, 55.2); Truncated: (5, 25, 55); Rounded: (5.43, 25.92, 55.2)");
 613     g_free(text);
 614
 615     /* Testing simple disappearing of unvalorized values */
 616     adg_dim_style_set_number_arguments(dim_style, "a");
 617     adg_dim_style_set_number_format(dim_style, "(%g)");
 618
 619     text = adg_dim_get_text(dim, 123);
 620     g_assert_cmpstr(text, ==, "123");
 621     g_free(text);
 622
 623     text = adg_dim_get_text(dim, 0);
 624     g_assert_cmpstr(text, ==, "");
 625     g_free(text);
 626
 627     adg_dim_style_set_number_arguments(dim_style, "aD");
 628     adg_dim_style_set_number_format(dim_style, ">(%g)--(%g)<");
 629
 630     text = adg_dim_get_text(dim, 0);
 631     g_assert_cmpstr(text, ==, ">--<");
 632     g_free(text);
 633
 634     text = adg_dim_get_text(dim, 0.42);
 635     g_assert_cmpstr(text, ==, ">0.42--<");
 636     g_free(text);
 637
 638     text = adg_dim_get_text(dim, 2.34);
 639     g_assert_cmpstr(text, ==, ">2.34--2<");
 640     g_free(text);
 641
 642     /* Testing nested parenthesis */
 643     adg_dim_style_set_number_arguments(dim_style, "DMs");
 644     adg_dim_style_set_number_format(dim_style, "%g°(%g'(%g\"))");
 645
 646     text = adg_dim_get_text(dim, 0);
 647     g_assert_cmpstr(text, ==, "0°");
 648     g_free(text);
 649
 650     text = adg_dim_get_text(dim, 1.5);
 651     g_assert_cmpstr(text, ==, "1°30'");
 652     g_free(text);
 653
 654     text = adg_dim_get_text(dim, 2.002777);
 655     g_assert_cmpstr(text, ==, "2°0'10\"");
 656     g_free(text);
 657
 658     /* Test errors on unmatched parenthesis */
 659     adg_dim_style_set_number_format(dim_style, "%g°(%g'(%g\")");
 660     g_assert_null(adg_dim_get_text(dim, 0));
 661
 662     adg_dim_style_set_number_format(dim_style, "%g°%g'(%g\"))");
 663     g_assert_null(adg_dim_get_text(dim, 0));
 664
 665     adg_entity_destroy(ADG_ENTITY(dim));
 666 }
 667
 668 static void
 669 _adg_method_set_limits(void)
 670 {
 671     AdgDim *dim;
 672
 673     dim = ADG_DIM(adg_ldim_new());
 674
 675     /* Sanity checks */
 676     adg_dim_set_limits(NULL, "", "");
 677     adg_dim_set_limits(dim, NULL, "");
 678     adg_dim_set_limits(dim, "", NULL);
 679
 680     adg_dim_set_limits(dim, "min", "max");
 681     g_assert_cmpstr(adg_dim_get_min(dim), ==, "min");
 682     g_assert_cmpstr(adg_dim_get_max(dim), ==, "max");
 683
 684     adg_entity_destroy(ADG_ENTITY(dim));
 685 }
 686
 687
 688 int
 689 main(int argc, char *argv[])
 690 {
 691     adg_test_init(&argc, &argv);
 692
 693     adg_test_add_object_checks("/adg/dim/type/object", ADG_TYPE_DIM);
 694     adg_test_add_entity_checks("/adg/dim/type/entity", ADG_TYPE_DIM);
 695
 696     g_test_add_func("/adg/dim/property/detached", _adg_property_detached);
 697     g_test_add_func("/adg/dim/property/dim-dress", _adg_property_dim_dress);
 698     g_test_add_func("/adg/dim/property/level", _adg_property_level);
 699     g_test_add_func("/adg/dim/property/max", _adg_property_max);
 700     g_test_add_func("/adg/dim/property/min", _adg_property_min);
 701     g_test_add_func("/adg/dim/property/outside", _adg_property_outside);
 702     g_test_add_func("/adg/dim/property/pos", _adg_property_pos);
 703     g_test_add_func("/adg/dim/property/ref1", _adg_property_ref1);
 704     g_test_add_func("/adg/dim/property/ref2", _adg_property_ref2);
 705     g_test_add_func("/adg/dim/property/value", _adg_property_value);
 706
 707     g_test_add_func("/adg/dim/method/get_text", _adg_method_get_text);
 708     g_test_add_func("/adg/dim/method/set_limits", _adg_method_set_limits);
 709
 710     return g_test_run();
 711 }