src/adg/tests/test-adim.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 <adg-test.h>
  22 #include <adg.h>
  23
  24
  25 static void
  26 _adg_property_dim_dress(void)
  27 {
  28     AdgADim *adim;
  29
  30     /* Check that the dimension dress for AdgADim instances is
  31      * ADG_DRESS_DIMENSION by default */
  32     adim = adg_adim_new();
  33     g_assert_cmpint(adg_dim_get_dim_dress(ADG_DIM(adim)), ==, ADG_DRESS_DIMENSION);
  34
  35     adg_entity_destroy(ADG_ENTITY(adim));
  36 }
  37
  38 static void
  39 _adg_property_org1(void)
  40 {
  41     AdgADim *adim;
  42     AdgModel *model;
  43     AdgPoint *origin, *explicit_point, *model_point;
  44     AdgPoint *org1;
  45
  46     adim = adg_adim_new();
  47     model = ADG_MODEL(adg_path_new());
  48     origin = adg_point_new();
  49     explicit_point = adg_point_new();
  50     model_point = adg_point_new();
  51
  52     adg_point_set_pair_explicit(origin, 0, 0);
  53     adg_point_set_pair_explicit(explicit_point, 123, 321);
  54     adg_model_set_named_pair(model, "named-pair", (CpmlPair *) explicit_point);
  55     adg_point_set_pair_from_model(model_point, model, "named-pair");
  56
  57     /* Ensure ADG does not consider an explicit point equals to
  58      * a point bound to a named pair with the same coordinates */
  59     g_assert_false(adg_point_equal(explicit_point, model_point));
  60
  61     org1 = adg_adim_get_org1(adim);
  62     g_assert_null(org1);
  63
  64     /* Using the public APIs */
  65     adg_adim_set_org1_explicit(adim, 0, 0);
  66     org1 = adg_adim_get_org1(adim);
  67     g_assert_true(adg_point_equal(org1, origin));
  68
  69     adg_adim_set_org1(adim, NULL);
  70     org1 = adg_adim_get_org1(adim);
  71     g_assert_null(org1);
  72
  73     adg_adim_set_org1(adim, explicit_point);
  74     org1 = adg_adim_get_org1(adim);
  75     g_assert_true(adg_point_equal(org1, explicit_point));
  76
  77     adg_adim_set_org1_from_model(adim, model, "dummy");
  78     org1 = adg_adim_get_org1(adim);
  79     g_assert_nonnull(org1);
  80
  81     adg_adim_set_org1_from_model(adim, model, "named-pair");
  82     org1 = adg_adim_get_org1(adim);
  83     g_assert_true(adg_point_equal(org1, model_point));
  84
  85     /* Using GObject property methods */
  86     g_object_set(adim, "org1", origin, NULL);
  87     g_object_get(adim, "org1", &org1, NULL);
  88     g_assert_true(adg_point_equal(org1, origin));
  89     adg_point_destroy(org1);
  90
  91     g_object_set(adim, "org1", NULL, NULL);
  92     g_object_get(adim, "org1", &org1, NULL);
  93     g_assert_null(org1);
  94
  95     g_object_set(adim, "org1", explicit_point, NULL);
  96     g_object_get(adim, "org1", &org1, NULL);
  97     g_assert_true(adg_point_equal(org1, explicit_point));
  98     adg_point_destroy(org1);
  99
 100     adg_adim_set_org1_from_model(adim, model, "dummy");
 101     g_object_get(adim, "org1", &org1, NULL);
 102     g_assert_nonnull(org1);
 103     adg_point_destroy(org1);
 104
 105     g_object_set(adim, "org1", model_point, NULL);
 106     g_object_get(adim, "org1", &org1, NULL);
 107     g_assert_true(adg_point_equal(org1, model_point));
 108     adg_point_destroy(org1);
 109
 110     adg_point_destroy(origin);
 111     adg_point_destroy(explicit_point);
 112     adg_point_destroy(model_point);
 113     adg_entity_destroy(ADG_ENTITY(adim));
 114     g_object_unref(model);
 115 }
 116
 117 static void
 118 _adg_property_org2(void)
 119 {
 120     AdgADim *adim;
 121     AdgModel *model;
 122     AdgPoint *origin, *explicit_point, *model_point;
 123     AdgPoint *org2;
 124
 125     adim = adg_adim_new();
 126     model = ADG_MODEL(adg_path_new());
 127     origin = adg_point_new();
 128     explicit_point = adg_point_new();
 129     model_point = adg_point_new();
 130
 131     adg_point_set_pair_explicit(origin, 0, 0);
 132     adg_point_set_pair_explicit(explicit_point, 123, 321);
 133     adg_model_set_named_pair(model, "named-pair", (CpmlPair *) explicit_point);
 134     adg_point_set_pair_from_model(model_point, model, "named-pair");
 135
 136     /* Ensure ADG does not consider an explicit point equals to
 137      * a point bound to a named pair with the same coordinates */
 138     g_assert_false(adg_point_equal(explicit_point, model_point));
 139
 140     org2 = adg_adim_get_org2(adim);
 141     g_assert_null(org2);
 142
 143     /* Using the public APIs */
 144     adg_adim_set_org2_explicit(adim, 0, 0);
 145     org2 = adg_adim_get_org2(adim);
 146     g_assert_true(adg_point_equal(org2, origin));
 147
 148     adg_adim_set_org2(adim, NULL);
 149     org2 = adg_adim_get_org2(adim);
 150     g_assert_null(org2);
 151
 152     adg_adim_set_org2(adim, explicit_point);
 153     org2 = adg_adim_get_org2(adim);
 154     g_assert_true(adg_point_equal(org2, explicit_point));
 155
 156     adg_adim_set_org2_from_model(adim, model, "dummy");
 157     org2 = adg_adim_get_org2(adim);
 158     g_assert_nonnull(org2);
 159
 160     adg_adim_set_org2_from_model(adim, model, "named-pair");
 161     org2 = adg_adim_get_org2(adim);
 162     g_assert_true(adg_point_equal(org2, model_point));
 163
 164     /* Using GObject property methods */
 165     g_object_set(adim, "org2", origin, NULL);
 166     g_object_get(adim, "org2", &org2, NULL);
 167     g_assert_true(adg_point_equal(org2, origin));
 168     adg_point_destroy(org2);
 169
 170     g_object_set(adim, "org2", NULL, NULL);
 171     g_object_get(adim, "org2", &org2, NULL);
 172     g_assert_null(org2);
 173
 174     g_object_set(adim, "org2", explicit_point, NULL);
 175     g_object_get(adim, "org2", &org2, NULL);
 176     g_assert_true(adg_point_equal(org2, explicit_point));
 177     adg_point_destroy(org2);
 178
 179     adg_adim_set_org2_from_model(adim, model, "dummy");
 180     g_object_get(adim, "org2", &org2, NULL);
 181     g_assert_nonnull(org2);
 182     adg_point_destroy(org2);
 183
 184     g_object_set(adim, "org2", model_point, NULL);
 185     g_object_get(adim, "org2", &org2, NULL);
 186     g_assert_true(adg_point_equal(org2, model_point));
 187     adg_point_destroy(org2);
 188
 189     adg_point_destroy(origin);
 190     adg_point_destroy(explicit_point);
 191     adg_point_destroy(model_point);
 192     adg_entity_destroy(ADG_ENTITY(adim));
 193     g_object_unref(model);
 194 }
 195
 196 static void
 197 _adg_property_has_extension1(void)
 198 {
 199     AdgADim *adim;
 200     gboolean invalid_boolean;
 201     gboolean has_extension1;
 202
 203     adim = adg_adim_new();
 204     invalid_boolean = (gboolean) 1234;
 205
 206     /* Using the public APIs */
 207     adg_adim_switch_extension1(adim, FALSE);
 208     has_extension1 = adg_adim_has_extension1(adim);
 209     g_assert_false(has_extension1);
 210
 211     adg_adim_switch_extension1(adim, invalid_boolean);
 212     has_extension1 = adg_adim_has_extension1(adim);
 213     g_assert_false(has_extension1);
 214
 215     adg_adim_switch_extension1(adim, TRUE);
 216     has_extension1 = adg_adim_has_extension1(adim);
 217     g_assert_true(has_extension1);
 218
 219     /* Using GObject property methods */
 220     g_object_set(adim, "has-extension1", FALSE, NULL);
 221     g_object_get(adim, "has-extension1", &has_extension1, NULL);
 222     g_assert_false(has_extension1);
 223
 224     g_object_set(adim, "has-extension1", invalid_boolean, NULL);
 225     g_object_get(adim, "has-extension1", &has_extension1, NULL);
 226     g_assert_false(has_extension1);
 227
 228     g_object_set(adim, "has-extension1", TRUE, NULL);
 229     g_object_get(adim, "has-extension1", &has_extension1, NULL);
 230     g_assert_true(has_extension1);
 231
 232     adg_entity_destroy(ADG_ENTITY(adim));
 233 }
 234
 235 static void
 236 _adg_property_has_extension2(void)
 237 {
 238     AdgADim *adim;
 239     gboolean invalid_boolean;
 240     gboolean has_extension2;
 241
 242     adim = adg_adim_new();
 243     invalid_boolean = (gboolean) 1234;
 244
 245     /* Using the public APIs */
 246     adg_adim_switch_extension2(adim, FALSE);
 247     has_extension2 = adg_adim_has_extension2(adim);
 248     g_assert_false(has_extension2);
 249
 250     adg_adim_switch_extension2(adim, invalid_boolean);
 251     has_extension2 = adg_adim_has_extension2(adim);
 252     g_assert_false(has_extension2);
 253
 254     adg_adim_switch_extension2(adim, TRUE);
 255     has_extension2 = adg_adim_has_extension2(adim);
 256     g_assert_true(has_extension2);
 257
 258     /* Using GObject property methods */
 259     g_object_set(adim, "has-extension2", FALSE, NULL);
 260     g_object_get(adim, "has-extension2", &has_extension2, NULL);
 261     g_assert_false(has_extension2);
 262
 263     g_object_set(adim, "has-extension2", invalid_boolean, NULL);
 264     g_object_get(adim, "has-extension2", &has_extension2, NULL);
 265     g_assert_false(has_extension2);
 266
 267     g_object_set(adim, "has-extension2", TRUE, NULL);
 268     g_object_get(adim, "has-extension2", &has_extension2, NULL);
 269     g_assert_true(has_extension2);
 270
 271     adg_entity_destroy(ADG_ENTITY(adim));
 272 }
 273
 274
 275 int
 276 main(int argc, char *argv[])
 277 {
 278     adg_test_init(&argc, &argv);
 279
 280     adg_test_add_object_checks("/adg/adim/type/object", ADG_TYPE_ADIM);
 281     adg_test_add_entity_checks("/adg/adim/type/entity", ADG_TYPE_ADIM);
 282
 283     adg_test_add_global_space_checks("/adg/adim/behavior/global-space",
 284                                      adg_adim_new_full_explicit(1, 2, 3, 4,
 285                                                                 9, 6, 7, 8,
 286                                                                 9, 10));
 287     adg_test_add_local_space_checks("/adg/adim/behavior/local-space",
 288                                     adg_adim_new_full_explicit(4, 3, 2, 1,
 289                                                                8, 7, 6, 9,
 290                                                                10, 9));
 291
 292     g_test_add_func("/adg/adim/property/dim-dress", _adg_property_dim_dress);
 293     g_test_add_func("/adg/adim/property/org1", _adg_property_org1);
 294     g_test_add_func("/adg/adim/property/org2", _adg_property_org2);
 295     g_test_add_func("/adg/adim/property/has-extension1", _adg_property_has_extension1);
 296     g_test_add_func("/adg/adim/property/has-extension2", _adg_property_has_extension2);
 297
 298     return g_test_run();
 299 }