src/adg/tests/test-adim.c

   1 /* ADG - Automatic Drawing Generation
   2  * Copyright (C) 2007,2008,2009,2010,2011,2012,2013  Nicola Fontana <ntd at entidi.it>
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  17  * Boston, MA  02110-1301, USA.
  18  */
  19
  20
  21 #include "test-internal.h"
  22
  23
  24 static void
  25 _adg_test_org1(void)
  26 {
  27     AdgADim *adim;
  28     AdgModel *model;
  29     AdgPoint *origin, *explicit_point, *model_point;
  30     AdgPoint *org1;
  31
  32     adim = adg_adim_new();
  33     model = ADG_MODEL(adg_path_new());
  34     origin = adg_point_new();
  35     explicit_point = adg_point_new();
  36     model_point = adg_point_new();
  37
  38     adg_point_set_pair_explicit(origin, 0, 0);
  39     adg_point_set_pair_explicit(explicit_point, 123, 321);
  40     adg_model_set_named_pair(model, "named-pair", (CpmlPair *) explicit_point);
  41     adg_point_set_pair_from_model(model_point, model, "named-pair");
  42
  43     /* Ensure ADG does not consider an explicit point equals to
  44      * a point bound to a named pair with the same coordinates */
  45     g_assert(!adg_point_equal(explicit_point, model_point));
  46
  47     org1 = adg_adim_get_org1(adim);
  48     g_assert(org1 == NULL);
  49
  50     /* Using the public APIs */
  51     adg_adim_set_org1_explicit(adim, 0, 0);
  52     org1 = adg_adim_get_org1(adim);
  53     g_assert(adg_point_equal(org1, origin));
  54
  55     adg_adim_set_org1(adim, NULL);
  56     org1 = adg_adim_get_org1(adim);
  57     g_assert(org1 == NULL);
  58
  59     adg_adim_set_org1(adim, explicit_point);
  60     org1 = adg_adim_get_org1(adim);
  61     g_assert(adg_point_equal(org1, explicit_point));
  62
  63     adg_adim_set_org1_from_model(adim, model, "dummy");
  64     org1 = adg_adim_get_org1(adim);
  65     g_assert(org1 != NULL);
  66
  67     adg_adim_set_org1_from_model(adim, model, "named-pair");
  68     org1 = adg_adim_get_org1(adim);
  69     g_assert(adg_point_equal(org1, model_point));
  70
  71     /* Using GObject property methods */
  72     g_object_set(adim, "org1", origin, NULL);
  73     g_object_get(adim, "org1", &org1, NULL);
  74     g_assert(adg_point_equal(org1, origin));
  75     adg_point_destroy(org1);
  76
  77     g_object_set(adim, "org1", NULL, NULL);
  78     g_object_get(adim, "org1", &org1, NULL);
  79     g_assert(org1 == NULL);
  80
  81     g_object_set(adim, "org1", explicit_point, NULL);
  82     g_object_get(adim, "org1", &org1, NULL);
  83     g_assert(adg_point_equal(org1, explicit_point));
  84     adg_point_destroy(org1);
  85
  86     adg_adim_set_org1_from_model(adim, model, "dummy");
  87     g_object_get(adim, "org1", &org1, NULL);
  88     g_assert(org1 != NULL);
  89     adg_point_destroy(org1);
  90
  91     g_object_set(adim, "org1", model_point, NULL);
  92     g_object_get(adim, "org1", &org1, NULL);
  93     g_assert(adg_point_equal(org1, model_point));
  94     adg_point_destroy(org1);
  95
  96     adg_point_destroy(origin);
  97     adg_point_destroy(explicit_point);
  98     adg_point_destroy(model_point);
  99     adg_entity_destroy(ADG_ENTITY(adim));
 100     g_object_unref(model);
 101 }
 102
 103 static void
 104 _adg_test_org2(void)
 105 {
 106     AdgADim *adim;
 107     AdgModel *model;
 108     AdgPoint *origin, *explicit_point, *model_point;
 109     AdgPoint *org2;
 110
 111     adim = adg_adim_new();
 112     model = ADG_MODEL(adg_path_new());
 113     origin = adg_point_new();
 114     explicit_point = adg_point_new();
 115     model_point = adg_point_new();
 116
 117     adg_point_set_pair_explicit(origin, 0, 0);
 118     adg_point_set_pair_explicit(explicit_point, 123, 321);
 119     adg_model_set_named_pair(model, "named-pair", (CpmlPair *) explicit_point);
 120     adg_point_set_pair_from_model(model_point, model, "named-pair");
 121
 122     /* Ensure ADG does not consider an explicit point equals to
 123      * a point bound to a named pair with the same coordinates */
 124     g_assert(!adg_point_equal(explicit_point, model_point));
 125
 126     org2 = adg_adim_get_org2(adim);
 127     g_assert(org2 == NULL);
 128
 129     /* Using the public APIs */
 130     adg_adim_set_org2_explicit(adim, 0, 0);
 131     org2 = adg_adim_get_org2(adim);
 132     g_assert(adg_point_equal(org2, origin));
 133
 134     adg_adim_set_org2(adim, NULL);
 135     org2 = adg_adim_get_org2(adim);
 136     g_assert(org2 == NULL);
 137
 138     adg_adim_set_org2(adim, explicit_point);
 139     org2 = adg_adim_get_org2(adim);
 140     g_assert(adg_point_equal(org2, explicit_point));
 141
 142     adg_adim_set_org2_from_model(adim, model, "dummy");
 143     org2 = adg_adim_get_org2(adim);
 144     g_assert(org2 != NULL);
 145
 146     adg_adim_set_org2_from_model(adim, model, "named-pair");
 147     org2 = adg_adim_get_org2(adim);
 148     g_assert(adg_point_equal(org2, model_point));
 149
 150     /* Using GObject property methods */
 151     g_object_set(adim, "org2", origin, NULL);
 152     g_object_get(adim, "org2", &org2, NULL);
 153     g_assert(adg_point_equal(org2, origin));
 154     adg_point_destroy(org2);
 155
 156     g_object_set(adim, "org2", NULL, NULL);
 157     g_object_get(adim, "org2", &org2, NULL);
 158     g_assert(org2 == NULL);
 159
 160     g_object_set(adim, "org2", explicit_point, NULL);
 161     g_object_get(adim, "org2", &org2, NULL);
 162     g_assert(adg_point_equal(org2, explicit_point));
 163     adg_point_destroy(org2);
 164
 165     adg_adim_set_org2_from_model(adim, model, "dummy");
 166     g_object_get(adim, "org2", &org2, NULL);
 167     g_assert(org2 != NULL);
 168     adg_point_destroy(org2);
 169
 170     g_object_set(adim, "org2", model_point, NULL);
 171     g_object_get(adim, "org2", &org2, NULL);
 172     g_assert(adg_point_equal(org2, model_point));
 173     adg_point_destroy(org2);
 174
 175     adg_point_destroy(origin);
 176     adg_point_destroy(explicit_point);
 177     adg_point_destroy(model_point);
 178     adg_entity_destroy(ADG_ENTITY(adim));
 179     g_object_unref(model);
 180 }
 181
 182 static void
 183 _adg_test_has_extension1(void)
 184 {
 185     AdgADim *adim;
 186     gboolean invalid_boolean;
 187     gboolean has_extension1;
 188
 189     adim = adg_adim_new();
 190     invalid_boolean = (gboolean) 1234;
 191
 192     /* Using the public APIs */
 193     adg_adim_switch_extension1(adim, FALSE);
 194     has_extension1 = adg_adim_has_extension1(adim);
 195     g_assert(!has_extension1);
 196
 197     adg_adim_switch_extension1(adim, invalid_boolean);
 198     has_extension1 = adg_adim_has_extension1(adim);
 199     g_assert(!has_extension1);
 200
 201     adg_adim_switch_extension1(adim, TRUE);
 202     has_extension1 = adg_adim_has_extension1(adim);
 203     g_assert(has_extension1);
 204
 205     /* Using GObject property methods */
 206     g_object_set(adim, "has-extension1", FALSE, NULL);
 207     g_object_get(adim, "has-extension1", &has_extension1, NULL);
 208     g_assert(!has_extension1);
 209
 210     g_object_set(adim, "has-extension1", invalid_boolean, NULL);
 211     g_object_get(adim, "has-extension1", &has_extension1, NULL);
 212     g_assert(!has_extension1);
 213
 214     g_object_set(adim, "has-extension1", TRUE, NULL);
 215     g_object_get(adim, "has-extension1", &has_extension1, NULL);
 216     g_assert(has_extension1);
 217
 218     adg_entity_destroy(ADG_ENTITY(adim));
 219 }
 220
 221 static void
 222 _adg_test_has_extension2(void)
 223 {
 224     AdgADim *adim;
 225     gboolean invalid_boolean;
 226     gboolean has_extension2;
 227
 228     adim = adg_adim_new();
 229     invalid_boolean = (gboolean) 1234;
 230
 231     /* Using the public APIs */
 232     adg_adim_switch_extension2(adim, FALSE);
 233     has_extension2 = adg_adim_has_extension2(adim);
 234     g_assert(!has_extension2);
 235
 236     adg_adim_switch_extension2(adim, invalid_boolean);
 237     has_extension2 = adg_adim_has_extension2(adim);
 238     g_assert(!has_extension2);
 239
 240     adg_adim_switch_extension2(adim, TRUE);
 241     has_extension2 = adg_adim_has_extension2(adim);
 242     g_assert(has_extension2);
 243
 244     /* Using GObject property methods */
 245     g_object_set(adim, "has-extension2", FALSE, NULL);
 246     g_object_get(adim, "has-extension2", &has_extension2, NULL);
 247     g_assert(!has_extension2);
 248
 249     g_object_set(adim, "has-extension2", invalid_boolean, NULL);
 250     g_object_get(adim, "has-extension2", &has_extension2, NULL);
 251     g_assert(!has_extension2);
 252
 253     g_object_set(adim, "has-extension2", TRUE, NULL);
 254     g_object_get(adim, "has-extension2", &has_extension2, NULL);
 255     g_assert(has_extension2);
 256
 257     adg_entity_destroy(ADG_ENTITY(adim));
 258 }
 259
 260
 261 int
 262 main(int argc, char *argv[])
 263 {
 264     adg_test_init(&argc, &argv);
 265
 266     adg_test_add_func("/adg/adim/property/org1", _adg_test_org1);
 267     adg_test_add_func("/adg/adim/property/org2", _adg_test_org2);
 268     adg_test_add_func("/adg/adim/property/has-extension1", _adg_test_has_extension1);
 269     adg_test_add_func("/adg/adim/property/has-extension2", _adg_test_has_extension2);
 270
 271     return g_test_run();
 272 }