src/adg/tests/test-title-block.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_author(void)
  26 {
  27     AdgTitleBlock *title_block;
  28     const gchar *valid_text, *latin1_text;
  29     const gchar *author;
  30     gchar *author_dup;
  31
  32     title_block = adg_title_block_new();
  33     valid_text = "This is some text...";
  34     latin1_text = "This is some àèìòù Latin1 text...";
  35
  36     /* Using the public APIs */
  37     adg_title_block_set_author(title_block, valid_text);
  38     author = adg_title_block_get_author(title_block);
  39     g_assert_cmpstr(author, ==, valid_text);
  40
  41     adg_title_block_set_author(title_block, latin1_text);
  42     author = adg_title_block_get_author(title_block);
  43     g_assert_cmpstr(author, ==, latin1_text);
  44
  45     adg_title_block_set_author(title_block, NULL);
  46     author = adg_title_block_get_author(title_block);
  47     g_assert(author == NULL);
  48
  49     /* Using GObject property methods */
  50     g_object_set(title_block, "author", valid_text, NULL);
  51     g_object_get(title_block, "author", &author_dup, NULL);
  52     g_assert_cmpstr(author_dup, ==, valid_text);
  53     g_free(author_dup);
  54
  55     g_object_set(title_block, "author", latin1_text, NULL);
  56     g_object_get(title_block, "author", &author_dup, NULL);
  57     g_assert_cmpstr(author_dup, ==, latin1_text);
  58     g_free(author_dup);
  59
  60     g_object_set(title_block, "author", NULL, NULL);
  61     g_object_get(title_block, "author", &author_dup, NULL);
  62     g_assert(author_dup == NULL);
  63
  64     adg_entity_destroy(ADG_ENTITY(title_block));
  65 }
  66
  67 static void
  68 _adg_test_date(void)
  69 {
  70     AdgTitleBlock *title_block;
  71     const gchar *valid_text, *latin1_text;
  72     const gchar *date;
  73     gchar *date_dup;
  74
  75     title_block = adg_title_block_new();
  76     valid_text = "This is some text...";
  77     latin1_text = "This is some àèìòù Latin1 text...";
  78
  79     /* Using the public APIs */
  80     adg_title_block_set_date(title_block, valid_text);
  81     date = adg_title_block_get_date(title_block);
  82     g_assert_cmpstr(date, ==, valid_text);
  83
  84     adg_title_block_set_date(title_block, latin1_text);
  85     date = adg_title_block_get_date(title_block);
  86     g_assert_cmpstr(date, ==, latin1_text);
  87
  88     adg_title_block_set_date(title_block, NULL);
  89     date = adg_title_block_get_date(title_block);
  90     g_assert(date != NULL);
  91
  92     /* Using GObject property methods */
  93     g_object_set(title_block, "date", valid_text, NULL);
  94     g_object_get(title_block, "date", &date_dup, NULL);
  95     g_assert_cmpstr(date_dup, ==, valid_text);
  96     g_free(date_dup);
  97
  98     g_object_set(title_block, "date", latin1_text, NULL);
  99     g_object_get(title_block, "date", &date_dup, NULL);
 100     g_assert_cmpstr(date_dup, ==, latin1_text);
 101     g_free(date_dup);
 102
 103     g_object_set(title_block, "date", NULL, NULL);
 104     g_object_get(title_block, "date", &date_dup, NULL);
 105     g_assert(date_dup != NULL);
 106     g_free(date_dup);
 107
 108     adg_entity_destroy(ADG_ENTITY(title_block));
 109 }
 110
 111 static void
 112 _adg_test_drawing(void)
 113 {
 114     AdgTitleBlock *title_block;
 115     const gchar *valid_text, *latin1_text;
 116     const gchar *drawing;
 117     gchar *drawing_dup;
 118
 119     title_block = adg_title_block_new();
 120     valid_text = "This is some text...";
 121     latin1_text = "This is some àèìòù Latin1 text...";
 122
 123     /* Using the public APIs */
 124     adg_title_block_set_drawing(title_block, valid_text);
 125     drawing = adg_title_block_get_drawing(title_block);
 126     g_assert_cmpstr(drawing, ==, valid_text);
 127
 128     adg_title_block_set_drawing(title_block, latin1_text);
 129     drawing = adg_title_block_get_drawing(title_block);
 130     g_assert_cmpstr(drawing, ==, latin1_text);
 131
 132     adg_title_block_set_drawing(title_block, NULL);
 133     drawing = adg_title_block_get_drawing(title_block);
 134     g_assert(drawing == NULL);
 135
 136     /* Using GObject property methods */
 137     g_object_set(title_block, "drawing", valid_text, NULL);
 138     g_object_get(title_block, "drawing", &drawing_dup, NULL);
 139     g_assert_cmpstr(drawing_dup, ==, valid_text);
 140     g_free(drawing_dup);
 141
 142     g_object_set(title_block, "drawing", latin1_text, NULL);
 143     g_object_get(title_block, "drawing", &drawing_dup, NULL);
 144     g_assert_cmpstr(drawing_dup, ==, latin1_text);
 145     g_free(drawing_dup);
 146
 147     g_object_set(title_block, "drawing", NULL, NULL);
 148     g_object_get(title_block, "drawing", &drawing_dup, NULL);
 149     g_assert(drawing_dup == NULL);
 150
 151     adg_entity_destroy(ADG_ENTITY(title_block));
 152 }
 153
 154 static void
 155 _adg_test_logo(void)
 156 {
 157     AdgTitleBlock *title_block;
 158     AdgEntity *valid_entity, *invalid_entity, *logo;
 159
 160     title_block = adg_title_block_new();
 161     valid_entity = ADG_ENTITY(adg_hatch_new(NULL));
 162     invalid_entity = adg_test_invalid_pointer();
 163
 164     /* Prevent valid_entity from being destroyed
 165      * the first time AdgTitleBlock:logo is set to NULL */
 166     g_object_ref(valid_entity);
 167
 168     /* Using the public APIs */
 169     adg_title_block_set_logo(title_block, valid_entity);
 170     logo = adg_title_block_logo(title_block);
 171     g_assert(logo == valid_entity);
 172
 173     adg_title_block_set_logo(title_block, invalid_entity);
 174     logo = adg_title_block_logo(title_block);
 175     g_assert(logo == valid_entity);
 176
 177     adg_title_block_set_logo(title_block, valid_entity);
 178     logo = adg_title_block_logo(title_block);
 179     g_assert(logo == valid_entity);
 180
 181     adg_title_block_set_logo(title_block, NULL);
 182     logo = adg_title_block_logo(title_block);
 183     g_assert(logo == NULL);
 184
 185     /* Using GObject property methods */
 186     g_object_set(title_block, "logo", valid_entity, NULL);
 187     g_object_get(title_block, "logo", &logo, NULL);
 188     g_assert(logo == valid_entity);
 189     adg_entity_destroy(logo);
 190
 191     g_object_set(title_block, "logo", invalid_entity, NULL);
 192     g_object_get(title_block, "logo", &logo, NULL);
 193     g_assert(logo == valid_entity);
 194     adg_entity_destroy(logo);
 195
 196     g_object_set(title_block, "logo", valid_entity, NULL);
 197     g_object_get(title_block, "logo", &logo, NULL);
 198     g_assert(logo == valid_entity);
 199     adg_entity_destroy(logo);
 200
 201     g_object_set(title_block, "logo", NULL, NULL);
 202     g_object_get(title_block, "logo", &logo, NULL);
 203     g_assert(logo == NULL);
 204
 205     adg_entity_destroy(ADG_ENTITY(title_block));
 206     g_object_unref(valid_entity);
 207 }
 208
 209 static void
 210 _adg_test_projection(void)
 211 {
 212     AdgTitleBlock *title_block;
 213     AdgEntity *valid_entity, *invalid_entity, *projection;
 214
 215     title_block = adg_title_block_new();
 216     valid_entity = ADG_ENTITY(adg_hatch_new(NULL));
 217     invalid_entity = adg_test_invalid_pointer();
 218
 219     /* Prevent valid_entity from being destroyed
 220      * the first time AdgTitleBlock:projection is set to NULL */
 221     g_object_ref(valid_entity);
 222
 223     /* Using the public APIs */
 224     adg_title_block_set_projection(title_block, valid_entity);
 225     projection = adg_title_block_projection(title_block);
 226     g_assert(projection == valid_entity);
 227
 228     adg_title_block_set_projection(title_block, invalid_entity);
 229     projection = adg_title_block_projection(title_block);
 230     g_assert(projection == valid_entity);
 231
 232     adg_title_block_set_projection(title_block, NULL);
 233     projection = adg_title_block_projection(title_block);
 234     g_assert(projection == NULL);
 235
 236     /* Using GObject property methods */
 237     g_object_set(title_block, "projection", valid_entity, NULL);
 238     g_object_get(title_block, "projection", &projection, NULL);
 239     g_assert(projection == valid_entity);
 240     adg_entity_destroy(projection);
 241
 242     g_object_set(title_block, "projection", invalid_entity, NULL);
 243     g_object_get(title_block, "projection", &projection, NULL);
 244     g_assert(projection == valid_entity);
 245     adg_entity_destroy(projection);
 246
 247     g_object_set(title_block, "projection", NULL, NULL);
 248     g_object_get(title_block, "projection", &projection, NULL);
 249     g_assert(projection == NULL);
 250
 251     adg_entity_destroy(ADG_ENTITY(title_block));
 252     g_object_unref(valid_entity);
 253 }
 254
 255 static void
 256 _adg_test_scale(void)
 257 {
 258     AdgTitleBlock *title_block;
 259     const gchar *valid_text, *latin1_text;
 260     const gchar *scale;
 261     gchar *scale_dup;
 262
 263     title_block = adg_title_block_new();
 264     valid_text = "This is some text...";
 265     latin1_text = "This is some àèìòù Latin1 text...";
 266
 267     /* Using the public APIs */
 268     adg_title_block_set_scale(title_block, valid_text);
 269     scale = adg_title_block_get_scale(title_block);
 270     g_assert_cmpstr(scale, ==, valid_text);
 271
 272     adg_title_block_set_scale(title_block, latin1_text);
 273     scale = adg_title_block_get_scale(title_block);
 274     g_assert_cmpstr(scale, ==, latin1_text);
 275
 276     adg_title_block_set_scale(title_block, NULL);
 277     scale = adg_title_block_get_scale(title_block);
 278     g_assert(scale == NULL);
 279
 280     /* Using GObject property methods */
 281     g_object_set(title_block, "scale", valid_text, NULL);
 282     g_object_get(title_block, "scale", &scale_dup, NULL);
 283     g_assert_cmpstr(scale_dup, ==, valid_text);
 284     g_free(scale_dup);
 285
 286     g_object_set(title_block, "scale", latin1_text, NULL);
 287     g_object_get(title_block, "scale", &scale_dup, NULL);
 288     g_assert_cmpstr(scale_dup, ==, latin1_text);
 289     g_free(scale_dup);
 290
 291     g_object_set(title_block, "scale", NULL, NULL);
 292     g_object_get(title_block, "scale", &scale_dup, NULL);
 293     g_assert(scale_dup == NULL);
 294
 295     adg_entity_destroy(ADG_ENTITY(title_block));
 296 }
 297
 298 static void
 299 _adg_test_size(void)
 300 {
 301     AdgTitleBlock *title_block;
 302     const gchar *valid_text, *latin1_text;
 303     const gchar *size;
 304     gchar *size_dup;
 305
 306     title_block = adg_title_block_new();
 307     valid_text = "This is some text...";
 308     latin1_text = "This is some àèìòù Latin1 text...";
 309
 310     /* Using the public APIs */
 311     adg_title_block_set_size(title_block, valid_text);
 312     size = adg_title_block_get_size(title_block);
 313     g_assert_cmpstr(size, ==, valid_text);
 314
 315     adg_title_block_set_size(title_block, latin1_text);
 316     size = adg_title_block_get_size(title_block);
 317     g_assert_cmpstr(size, ==, latin1_text);
 318
 319     adg_title_block_set_size(title_block, NULL);
 320     size = adg_title_block_get_size(title_block);
 321     g_assert(size == NULL);
 322
 323     /* Using GObject property methods */
 324     g_object_set(title_block, "size", valid_text, NULL);
 325     g_object_get(title_block, "size", &size_dup, NULL);
 326     g_assert_cmpstr(size_dup, ==, valid_text);
 327     g_free(size_dup);
 328
 329     g_object_set(title_block, "size", latin1_text, NULL);
 330     g_object_get(title_block, "size", &size_dup, NULL);
 331     g_assert_cmpstr(size_dup, ==, latin1_text);
 332     g_free(size_dup);
 333
 334     g_object_set(title_block, "size", NULL, NULL);
 335     g_object_get(title_block, "size", &size_dup, NULL);
 336     g_assert(size_dup == NULL);
 337
 338     adg_entity_destroy(ADG_ENTITY(title_block));
 339 }
 340
 341 static void
 342 _adg_test_title(void)
 343 {
 344     AdgTitleBlock *title_block;
 345     const gchar *valid_text, *latin1_text;
 346     const gchar *title;
 347     gchar *title_dup;
 348
 349     title_block = adg_title_block_new();
 350     valid_text = "This is some text...";
 351     latin1_text = "This is some àèìòù Latin1 text...";
 352
 353     /* Using the public APIs */
 354     adg_title_block_set_title(title_block, valid_text);
 355     title = adg_title_block_get_title(title_block);
 356     g_assert_cmpstr(title, ==, valid_text);
 357
 358     adg_title_block_set_title(title_block, latin1_text);
 359     title = adg_title_block_get_title(title_block);
 360     g_assert_cmpstr(title, ==, latin1_text);
 361
 362     adg_title_block_set_title(title_block, NULL);
 363     title = adg_title_block_get_title(title_block);
 364     g_assert(title == NULL);
 365
 366     /* Using GObject property methods */
 367     g_object_set(title_block, "title", valid_text, NULL);
 368     g_object_get(title_block, "title", &title_dup, NULL);
 369     g_assert_cmpstr(title_dup, ==, valid_text);
 370     g_free(title_dup);
 371
 372     g_object_set(title_block, "title", latin1_text, NULL);
 373     g_object_get(title_block, "title", &title_dup, NULL);
 374     g_assert_cmpstr(title_dup, ==, latin1_text);
 375     g_free(title_dup);
 376
 377     g_object_set(title_block, "title", NULL, NULL);
 378     g_object_get(title_block, "title", &title_dup, NULL);
 379     g_assert(title_dup == NULL);
 380
 381     adg_entity_destroy(ADG_ENTITY(title_block));
 382 }
 383
 384
 385 int
 386 main(int argc, char *argv[])
 387 {
 388     adg_test_init(&argc, &argv);
 389
 390     adg_test_add_func("/adg/title-block/author", _adg_test_author);
 391     adg_test_add_func("/adg/title-block/date", _adg_test_date);
 392     adg_test_add_func("/adg/title-block/drawing", _adg_test_drawing);
 393     adg_test_add_func("/adg/title-block/logo", _adg_test_logo);
 394     adg_test_add_func("/adg/title-block/projection", _adg_test_projection);
 395     adg_test_add_func("/adg/title-block/scale", _adg_test_scale);
 396     adg_test_add_func("/adg/title-block/size", _adg_test_size);
 397     adg_test_add_func("/adg/title-block/title", _adg_test_title);
 398
 399     return g_test_run();
 400 }