src/tests/eo_suite/eo_test_class_errors.c

   1 #ifdef HAVE_CONFIG_H
   2 # include <config.h>
   3 #endif
   4
   5 #include <stdio.h>
   6
   7 #include "Eo.h"
   8 #include "eo_suite.h"
   9 #include "class_simple.h"
  10
  11 START_TEST(eo_incomplete_desc)
  12 {
  13    eo_init();
  14
  15    const Eo_Class *klass;
  16    static Eo_Op TMP_BASE_ID = EO_NOOP;
  17
  18    enum {
  19         TEST_SUB_ID_FOO,
  20         TEST_SUB_ID_FOO2,
  21         TEST_SUB_ID_LAST
  22    };
  23
  24    static const Eo_Op_Description op_desc[] = {
  25         EO_OP_DESCRIPTION(TEST_SUB_ID_FOO, "Foo"),
  26         EO_OP_DESCRIPTION(TEST_SUB_ID_FOO2, "Foo2"),
  27         EO_OP_DESCRIPTION_SENTINEL
  28    };
  29
  30    static const Eo_Op_Description op_desc_wrong[] = {
  31         EO_OP_DESCRIPTION(TEST_SUB_ID_FOO2, "Foo2"),
  32         EO_OP_DESCRIPTION(TEST_SUB_ID_FOO, "Foo"),
  33         EO_OP_DESCRIPTION_SENTINEL
  34    };
  35
  36    /* XXX: In real life this should be const, this is just for testing. */
  37    static Eo_Class_Description class_desc = {
  38         EO_VERSION,
  39         "Simple",
  40         EO_CLASS_TYPE_REGULAR,
  41         EO_CLASS_DESCRIPTION_OPS(NULL, op_desc, 1),
  42         NULL,
  43         0,
  44         NULL,
  45         NULL
  46    };
  47
  48    klass = eo_class_new(&class_desc, NULL, NULL);
  49    fail_if(klass);
  50
  51    class_desc.ops.base_op_id = &TMP_BASE_ID;
  52    class_desc.ops.descs = NULL;
  53
  54    klass = eo_class_new(&class_desc, NULL, NULL);
  55    fail_if(klass);
  56
  57    class_desc.ops.descs = op_desc;
  58    class_desc.ops.count = TEST_SUB_ID_LAST + 1;
  59
  60    klass = eo_class_new(&class_desc, NULL, NULL);
  61    fail_if(klass);
  62
  63    class_desc.ops.count = 0;
  64
  65    klass = eo_class_new(&class_desc, NULL, NULL);
  66    fail_if(klass);
  67
  68    class_desc.ops.count = TEST_SUB_ID_LAST;
  69    class_desc.ops.descs = op_desc_wrong;
  70
  71    klass = eo_class_new(&class_desc, NULL, NULL);
  72    fail_if(klass);
  73
  74    class_desc.ops.descs = op_desc;
  75    class_desc.name = NULL;
  76
  77    klass = eo_class_new(&class_desc, NULL, NULL);
  78    fail_if(klass);
  79
  80    class_desc.name = "Simple";
  81
  82
  83    klass = eo_class_new(NULL, NULL, NULL);
  84    fail_if(klass);
  85
  86    /* Should create a class. */
  87    klass = eo_class_new(&class_desc, EO_BASE_CLASS, NULL);
  88    fail_if(!klass);
  89
  90    (void) klass;
  91
  92    eo_shutdown();
  93 }
  94 END_TEST
  95
  96 START_TEST(eo_inherit_errors)
  97 {
  98    eo_init();
  99
 100    const Eo_Class *klass;
 101    const Eo_Class *klass_mixin;
 102    const Eo_Class *klass_simple;
 103
 104    static const Eo_Class_Description class_desc_simple = {
 105         EO_VERSION,
 106         "Simple",
 107         EO_CLASS_TYPE_REGULAR,
 108         EO_CLASS_DESCRIPTION_OPS(NULL, NULL, 0),
 109         NULL,
 110         0,
 111         NULL,
 112         NULL
 113    };
 114
 115    static const Eo_Class_Description class_desc_mixin = {
 116         EO_VERSION,
 117         "Mixin",
 118         EO_CLASS_TYPE_MIXIN,
 119         EO_CLASS_DESCRIPTION_OPS(NULL, NULL, 0),
 120         NULL,
 121         0,
 122         NULL,
 123         NULL
 124    };
 125
 126    static Eo_Class_Description class_desc = {
 127         EO_VERSION,
 128         "General",
 129         EO_CLASS_TYPE_MIXIN,
 130         EO_CLASS_DESCRIPTION_OPS(NULL, NULL, 0),
 131         NULL,
 132         0,
 133         NULL,
 134         NULL
 135    };
 136
 137    klass_mixin = eo_class_new(&class_desc_mixin, NULL, NULL);
 138    fail_if(!klass_mixin);
 139
 140    klass_simple = eo_class_new(&class_desc_simple, EO_BASE_CLASS, NULL);
 141    fail_if(!klass_simple);
 142
 143    klass = eo_class_new(&class_desc, klass_simple, NULL);
 144    fail_if(klass);
 145
 146    class_desc.type = EO_CLASS_TYPE_REGULAR;
 147
 148    klass = eo_class_new(&class_desc, klass_mixin, NULL);
 149    fail_if(klass);
 150
 151    (void) klass;
 152
 153    eo_shutdown();
 154 }
 155 END_TEST
 156
 157 START_TEST(eo_inconsistent_mro)
 158 {
 159    eo_init();
 160
 161    const Eo_Class *klass;
 162    const Eo_Class *klass_mixin;
 163    const Eo_Class *klass_mixin2;
 164    const Eo_Class *klass_mixin3;
 165
 166    static const Eo_Class_Description class_desc_simple = {
 167         EO_VERSION,
 168         "Simple",
 169         EO_CLASS_TYPE_REGULAR,
 170         EO_CLASS_DESCRIPTION_OPS(NULL, NULL, 0),
 171         NULL,
 172         0,
 173         NULL,
 174         NULL
 175    };
 176
 177    static const Eo_Class_Description class_desc_mixin = {
 178         EO_VERSION,
 179         "Mixin",
 180         EO_CLASS_TYPE_MIXIN,
 181         EO_CLASS_DESCRIPTION_OPS(NULL, NULL, 0),
 182         NULL,
 183         0,
 184         NULL,
 185         NULL
 186    };
 187
 188    static const Eo_Class_Description class_desc_mixin2 = {
 189         EO_VERSION,
 190         "Mixin2",
 191         EO_CLASS_TYPE_MIXIN,
 192         EO_CLASS_DESCRIPTION_OPS(NULL, NULL, 0),
 193         NULL,
 194         0,
 195         NULL,
 196         NULL
 197    };
 198
 199    static const Eo_Class_Description class_desc_mixin3 = {
 200         EO_VERSION,
 201         "Mixin3",
 202         EO_CLASS_TYPE_MIXIN,
 203         EO_CLASS_DESCRIPTION_OPS(NULL, NULL, 0),
 204         NULL,
 205         0,
 206         NULL,
 207         NULL
 208    };
 209
 210    klass_mixin = eo_class_new(&class_desc_mixin, NULL, NULL);
 211    fail_if(!klass_mixin);
 212
 213    klass_mixin2 = eo_class_new(&class_desc_mixin2, klass_mixin, NULL);
 214    fail_if(!klass_mixin2);
 215
 216    klass_mixin3 = eo_class_new(&class_desc_mixin3, klass_mixin, NULL);
 217    fail_if(!klass_mixin3);
 218
 219    klass = eo_class_new(&class_desc_simple, EO_BASE_CLASS, klass_mixin, klass_mixin2, NULL);
 220    fail_if(klass);
 221
 222    klass = eo_class_new(&class_desc_simple, EO_BASE_CLASS, klass_mixin2, klass_mixin, NULL);
 223    fail_if(!klass);
 224
 225    klass = eo_class_new(&class_desc_simple, EO_BASE_CLASS, klass_mixin2, klass_mixin3, NULL);
 226    fail_if(!klass);
 227
 228    eo_shutdown();
 229 }
 230 END_TEST
 231
 232 static void _stub_class_constructor(Eo_Class *klass EINA_UNUSED) {}
 233
 234 START_TEST(eo_bad_interface)
 235 {
 236    eo_init();
 237
 238    const Eo_Class *klass;
 239
 240    static Eo_Class_Description class_desc = {
 241         EO_VERSION,
 242         "Interface",
 243         EO_CLASS_TYPE_INTERFACE,
 244         EO_CLASS_DESCRIPTION_OPS(NULL, NULL, 0),
 245         NULL,
 246         10,
 247         NULL,
 248         NULL
 249    };
 250
 251    klass = eo_class_new(&class_desc, NULL, NULL);
 252    fail_if(klass);
 253
 254    class_desc.data_size = 0;
 255    class_desc.class_constructor = _stub_class_constructor;
 256
 257    klass = eo_class_new(&class_desc, NULL, NULL);
 258    fail_if(!klass);
 259
 260    class_desc.class_constructor = NULL;
 261    class_desc.class_destructor = _stub_class_constructor;
 262
 263    klass = eo_class_new(&class_desc, NULL, NULL);
 264    fail_if(!klass);
 265
 266    class_desc.class_destructor = NULL;
 267
 268    klass = eo_class_new(&class_desc, NULL, NULL);
 269    fail_if(!klass);
 270
 271    eo_shutdown();
 272 }
 273 END_TEST
 274
 275 static int _const_ops_counter = 0;
 276
 277 static void
 278 _const_ops_a_set(Eo *obj EINA_UNUSED, void *class_data EINA_UNUSED, va_list *list)
 279 {
 280    int a = va_arg(*list, int);
 281    (void) a;
 282    _const_ops_counter++;
 283 }
 284
 285 static void
 286 _const_ops_a_print(Eo *obj EINA_UNUSED, void *class_data EINA_UNUSED, va_list *list EINA_UNUSED)
 287 {
 288    _const_ops_counter++;
 289 }
 290
 291 static void
 292 _const_ops_class_hi_print(Eo *obj EINA_UNUSED, void *class_data EINA_UNUSED, va_list *list EINA_UNUSED)
 293 {
 294    _const_ops_counter++;
 295 }
 296
 297 static void
 298 _const_ops_class_constructor(Eo_Class *klass)
 299 {
 300    const Eo_Op_Func_Description func_desc[] = {
 301         EO_OP_FUNC(SIMPLE_ID(SIMPLE_SUB_ID_A_SET), (eo_op_func_type) _const_ops_a_set),
 302         EO_OP_FUNC(SIMPLE_ID(SIMPLE_SUB_ID_A_PRINT), (eo_op_func_type) _const_ops_a_print),
 303         EO_OP_FUNC_CLASS(SIMPLE_ID(SIMPLE_SUB_ID_A_SET), (eo_op_func_type_class) _const_ops_a_set),
 304         EO_OP_FUNC_CLASS(SIMPLE_ID(SIMPLE_SUB_ID_A_PRINT), (eo_op_func_type_class) _const_ops_a_print),
 305         EO_OP_FUNC(SIMPLE_ID(SIMPLE_SUB_ID_CLASS_HI_PRINT), (eo_op_func_type) _const_ops_class_hi_print),
 306         EO_OP_FUNC(SIMPLE_ID(SIMPLE_SUB_ID_CLASS_HI_PRINT), (eo_op_func_type) _const_ops_class_hi_print),
 307         EO_OP_FUNC_SENTINEL
 308    };
 309
 310    eo_class_funcs_set(klass, func_desc);
 311 }
 312
 313 START_TEST(eo_op_types)
 314 {
 315    eo_init();
 316
 317    const Eo_Class *klass;
 318
 319    static Eo_Class_Description class_desc = {
 320         EO_VERSION,
 321         "Simple",
 322         EO_CLASS_TYPE_REGULAR,
 323         EO_CLASS_DESCRIPTION_OPS(NULL, NULL, 0),
 324         NULL,
 325         0,
 326         _const_ops_class_constructor,
 327         NULL
 328    };
 329
 330    klass = eo_class_new(&class_desc, SIMPLE_CLASS, NULL);
 331    fail_if(!klass);
 332
 333    /* Add class checks here... */
 334    Eo *obj = eo_add(klass, NULL);
 335    eo_do(obj, simple_a_set(7), simple_a_print(), simple_class_hi_print());
 336
 337    eo_unref(obj);
 338
 339    eo_shutdown();
 340 }
 341 END_TEST
 342
 343 void eo_test_class_errors(TCase *tc)
 344 {
 345    tcase_add_test(tc, eo_incomplete_desc);
 346    tcase_add_test(tc, eo_inherit_errors);
 347    tcase_add_test(tc, eo_inconsistent_mro);
 348    tcase_add_test(tc, eo_bad_interface);
 349    tcase_add_test(tc, eo_op_types);
 350 }