tests/scanner/regress.h

   1 #ifndef __GITESTTYPES_H__
   2 #define __GITESTTYPES_H__
   3
   4 #include <cairo.h>
   5 #include <glib-object.h>
   6 #include <gio/gio.h>
   7 #include <time.h>
   8
   9 void regress_set_abort_on_error (gboolean abort_on_error);
  10
  11 /* basic types */
  12 gboolean regress_test_boolean (gboolean in);
  13 gboolean regress_test_boolean_true (gboolean in);
  14 gboolean regress_test_boolean_false (gboolean in);
  15 gint8 regress_test_int8 (gint8 in);
  16 guint8 regress_test_uint8 (guint8 in);
  17 gint16 regress_test_int16 (gint16 in);
  18 guint16 regress_test_uint16 (guint16 in);
  19 gint32 regress_test_int32 (gint32 in);
  20 guint32 regress_test_uint32 (guint32 in);
  21 gint64 regress_test_int64 (gint64 in);
  22 guint64 regress_test_uint64 (guint64 in);
  23 gshort regress_test_short (gshort in);
  24 gushort regress_test_ushort (gushort in);
  25 gint regress_test_int (gint in);
  26 guint regress_test_uint (guint in);
  27 glong regress_test_long (glong in);
  28 gulong regress_test_ulong (gulong in);
  29 gssize regress_test_ssize (gssize in);
  30 gsize regress_test_size (gsize in);
  31 gfloat regress_test_float (gfloat in);
  32 gdouble regress_test_double (gdouble in);
  33 gunichar regress_test_unichar (gunichar in);
  34 time_t regress_test_timet (time_t in);
  35 GType regress_test_gtype (GType in);
  36
  37 /* utf8 */
  38 const char *regress_test_utf8_const_return (void);
  39 char *regress_test_utf8_nonconst_return (void);
  40 void regress_test_utf8_const_in (const char *in);
  41 void regress_test_utf8_out (char **out);
  42 void regress_test_utf8_inout (char **inout);
  43 GSList *regress_test_filename_return (void);
  44 void regress_test_utf8_null_in (char *in);
  45 void regress_test_utf8_null_out (char **char_out);
  46
  47 /* in arguments after out arguments */
  48 void regress_test_int_out_utf8 (int *length, const char *in);
  49
  50 /* multiple output arguments */
  51 void regress_test_multi_double_args (gdouble in, gdouble *one, gdouble *two);
  52 void regress_test_utf8_out_out (char **out0, char **out1);
  53 char *regress_test_utf8_out_nonconst_return (char **out);
  54
  55 /* non-basic-types */
  56 /* array */
  57 gboolean regress_test_strv_in (char **arr);
  58 int regress_test_array_int_in (int n_ints, int *ints);
  59 void regress_test_array_int_out (int *n_ints, int **ints);
  60 void regress_test_array_int_inout (int *n_ints, int **ints);
  61 int regress_test_array_gint8_in (int n_ints, gint8 *ints);
  62 int regress_test_array_gint16_in (int n_ints, gint16 *ints);
  63 gint32 regress_test_array_gint32_in (int n_ints, gint32 *ints);
  64 gint64 regress_test_array_gint64_in (int n_ints, gint64 *ints);
  65 char *regress_test_array_gtype_in (int n_types, GType *types);
  66 char **regress_test_strv_out_container (void);
  67 char **regress_test_strv_out (void);
  68 const char * const * regress_test_strv_out_c (void);
  69 void   regress_test_strv_outarg (char ***retp);
  70 int regress_test_array_fixed_size_int_in (int *ints);
  71 void regress_test_array_fixed_size_int_out (int **ints);
  72 int *regress_test_array_fixed_size_int_return (void);
  73
  74 /* transfer tests */
  75 int *regress_test_array_int_full_out(int *len);
  76 int *regress_test_array_int_none_out(int *len);
  77 void regress_test_array_int_null_in (int *arr, int len);
  78 void regress_test_array_int_null_out (int **arr, int *len);
  79
  80 /* interface */
  81 /* GList */
  82 const GList *regress_test_glist_nothing_return (void);
  83 GList *regress_test_glist_nothing_return2 (void);
  84 GList *regress_test_glist_container_return (void);
  85 GList *regress_test_glist_everything_return (void);
  86 void regress_test_glist_nothing_in (const GList *in);
  87 void regress_test_glist_nothing_in2 (GList *in);
  88 void regress_test_glist_null_in(GSList *in);
  89 void regress_test_glist_null_out(GSList **out_list);
  90
  91 /* GSList */
  92 const GSList *regress_test_gslist_nothing_return (void);
  93 GSList *regress_test_gslist_nothing_return2 (void);
  94 GSList *regress_test_gslist_container_return (void);
  95 GSList *regress_test_gslist_everything_return (void);
  96 void regress_test_gslist_nothing_in (const GSList *in);
  97 void regress_test_gslist_nothing_in2 (GSList *in);
  98 void regress_test_gslist_null_in(GSList *in);
  99 void regress_test_gslist_null_out(GSList **out_list);
 100
 101 /* GHashTable */
 102 const GHashTable *regress_test_ghash_null_return (void);
 103 const GHashTable *regress_test_ghash_nothing_return (void);
 104 GHashTable *regress_test_ghash_nothing_return2 (void);
 105 GHashTable *regress_test_ghash_gvalue_return (void);
 106 void regress_test_ghash_gvalue_in (GHashTable *hash);
 107 GHashTable *regress_test_ghash_container_return (void);
 108 GHashTable *regress_test_ghash_everything_return (void);
 109 void regress_test_ghash_null_in (const GHashTable *in);
 110 void regress_test_ghash_null_out (const GHashTable **out);
 111 void regress_test_ghash_nothing_in (const GHashTable *in);
 112 void regress_test_ghash_nothing_in2 (GHashTable *in);
 113 GHashTable *regress_test_ghash_nested_everything_return (void);
 114 GHashTable *regress_test_ghash_nested_everything_return2 (void);
 115
 116 /* GPtrArray */
 117 GPtrArray *regress_test_garray_container_return (void);
 118 GPtrArray *regress_test_garray_full_return (void);
 119
 120 /* error? */
 121
 122 /* closure */
 123 int regress_test_closure (GClosure *closure);
 124 int regress_test_closure_one_arg (GClosure *closure, int arg);
 125 GVariant *regress_test_closure_variant (GClosure *closure, GVariant* arg);
 126
 127 /* value */
 128 int regress_test_int_value_arg(const GValue *v);
 129 const GValue *regress_test_value_return(int i);
 130
 131 /* foreign structs */
 132 cairo_t *regress_test_cairo_context_full_return (void);
 133 void regress_test_cairo_context_none_in (cairo_t *context);
 134
 135 cairo_surface_t *regress_test_cairo_surface_none_return (void);
 136 cairo_surface_t *regress_test_cairo_surface_full_return (void);
 137 void regress_test_cairo_surface_none_in (cairo_surface_t *surface);
 138 void regress_test_cairo_surface_full_out (cairo_surface_t **surface);
 139
 140 GVariant *regress_test_gvariant_i (void);
 141 GVariant *regress_test_gvariant_s (void);
 142 GVariant *regress_test_gvariant_asv (void);
 143 GVariant *regress_test_gvariant_v (void);
 144 GVariant *regress_test_gvariant_as (void);
 145
 146 /* enums / flags */
 147
 148 #define NUM_REGRESS_FOO
 149
 150 typedef enum
 151 {
 152   REGRESS_TEST_VALUE1,
 153   REGRESS_TEST_VALUE2,
 154   REGRESS_TEST_VALUE3 = -1,
 155   REGRESS_TEST_VALUE4 = '0'
 156 } RegressTestEnum;
 157
 158 typedef enum
 159 {
 160   REGRESS_TEST_UNSIGNED_VALUE1 = 1,
 161   REGRESS_TEST_UNSIGNED_VALUE2 = 0x80000000
 162 } RegressTestEnumUnsigned;
 163
 164 typedef enum
 165 {
 166   REGRESS_TEST_FLAG1 = 1 << 0,
 167   REGRESS_TEST_FLAG2 = 1 << 1,
 168   REGRESS_TEST_FLAG3 = 1 << 2,
 169 } RegressTestFlags;
 170
 171 GType regress_test_enum_get_type (void) G_GNUC_CONST;
 172 #define REGRESS_TEST_TYPE_ENUM (regress_test_enum_get_type ())
 173 GType regress_test_enum_unsigned_get_type (void) G_GNUC_CONST;
 174 #define REGRESS_TEST_TYPE_ENUM_UNSIGNED (regress_test_enum_unsigned_get_type ())
 175 GType regress_test_flags_get_type (void) G_GNUC_CONST;
 176 #define REGRESS_TEST_TYPE_FLAGS (regress_test_flags_get_type ())
 177
 178 /* this is not registered with GType */
 179 typedef enum
 180 {
 181   REGRESS_TEST_EVALUE1,
 182   REGRESS_TEST_EVALUE2 = 42,
 183   REGRESS_TEST_EVALUE3 = '0'
 184 } RegressTestEnumNoGEnum;
 185
 186 const gchar * regress_test_enum_param(RegressTestEnum e);
 187 const gchar * regress_test_unsigned_enum_param(RegressTestEnumUnsigned e);
 188
 189 void regress_global_get_flags_out (RegressTestFlags *v);
 190
 191 /* constants */
 192
 193 #define REGRESS_INT_CONSTANT 4422
 194 #define REGRESS_DOUBLE_CONSTANT 44.22
 195 #define REGRESS_STRING_CONSTANT "Some String"
 196 #define REGRESS_Mixed_Case_Constant 4423
 197
 198 /* structures */
 199 typedef struct _RegressTestStructA RegressTestStructA;
 200 typedef struct _RegressTestStructB RegressTestStructB;
 201 typedef struct _RegressTestStructC RegressTestStructC;
 202 typedef struct _RegressTestStructD RegressTestStructD;
 203
 204 struct _RegressTestStructA
 205 {
 206   gint some_int;
 207   gint8 some_int8;
 208   gdouble some_double;
 209   RegressTestEnum some_enum;
 210 };
 211
 212 void regress_test_struct_a_clone (RegressTestStructA *a,
 213                                   RegressTestStructA *a_out);
 214
 215 struct _RegressTestStructB
 216 {
 217   gint8 some_int8;
 218   RegressTestStructA nested_a;
 219 };
 220
 221 void regress_test_struct_b_clone (RegressTestStructB *b,
 222                           RegressTestStructB *b_out);
 223
 224 /* This one has a non-basic member */
 225 struct _RegressTestStructC
 226 {
 227   gint another_int;
 228   GObject *obj;
 229 };
 230
 231 /* This one has annotated fields */
 232 /**
 233  * RegressTestStructD:
 234  * @array1: (array zero-terminated=1):
 235  * @array2: (array zero-terminated=1) (element-type RegressTestObj):
 236  * @field: (type RegressTestObj):
 237  * @list: (element-type RegressTestObj):
 238  * @garray: (element-type RegressTestObj):
 239  */
 240 struct _RegressTestStructD
 241 {
 242   RegressTestStructA **array1;
 243   gpointer            *array2;
 244   gpointer             field;
 245   GList               *list;
 246   GPtrArray           *garray;
 247 };
 248
 249 /* This one has an array of anonymous unions, inspired by GValue */
 250 struct RegressTestStructE
 251 {
 252   GType some_type;
 253   union {
 254     gint        v_int;
 255     guint       v_uint;
 256     glong       v_long;
 257     gulong      v_ulong;
 258     gint64      v_int64;
 259     guint64     v_uint64;
 260     gfloat      v_float;
 261     gdouble     v_double;
 262     gpointer    v_pointer;
 263   } some_union[2];
 264 };
 265
 266 /* plain-old-data boxed types */
 267 typedef struct _RegressTestSimpleBoxedA RegressTestSimpleBoxedA;
 268 typedef struct _RegressTestSimpleBoxedB RegressTestSimpleBoxedB;
 269
 270 struct _RegressTestSimpleBoxedA
 271 {
 272   gint some_int;
 273   gint8 some_int8;
 274   gdouble some_double;
 275   RegressTestEnum some_enum;
 276 };
 277
 278 /* Intentionally uses _get_gtype */
 279 GType                   regress_test_simple_boxed_a_get_gtype     (void);
 280 RegressTestSimpleBoxedA *regress_test_simple_boxed_a_copy         (RegressTestSimpleBoxedA *a);
 281 gboolean                regress_test_simple_boxed_a_equals       (RegressTestSimpleBoxedA *a,
 282                                                           RegressTestSimpleBoxedA *other_a);
 283 const RegressTestSimpleBoxedA *regress_test_simple_boxed_a_const_return (void);
 284
 285
 286 struct _RegressTestSimpleBoxedB
 287 {
 288   gint8 some_int8;
 289   RegressTestSimpleBoxedA nested_a;
 290 };
 291
 292 GType             regress_test_simple_boxed_b_get_type (void);
 293 RegressTestSimpleBoxedB *regress_test_simple_boxed_b_copy     (RegressTestSimpleBoxedB *b);
 294
 295 /* opaque boxed */
 296 #define REGRESS_TEST_TYPE_BOXED (regress_test_boxed_get_type())
 297
 298 typedef struct _RegressTestBoxed RegressTestBoxed;
 299 typedef struct _RegressTestBoxedPrivate RegressTestBoxedPrivate;
 300
 301 struct _RegressTestBoxed
 302 {
 303   gint8 some_int8;
 304   RegressTestSimpleBoxedA nested_a;
 305
 306   RegressTestBoxedPrivate *priv;
 307 };
 308
 309 GType      regress_test_boxed_get_type (void);
 310 RegressTestBoxed *regress_test_boxed_new      (void);
 311 RegressTestBoxed *regress_test_boxed_new_alternative_constructor1  (int i);
 312 RegressTestBoxed *regress_test_boxed_new_alternative_constructor2  (int i, int j);
 313 RegressTestBoxed *regress_test_boxed_new_alternative_constructor3  (char *s);
 314
 315 RegressTestBoxed *regress_test_boxed_copy     (RegressTestBoxed *boxed);
 316 gboolean   regress_test_boxed_equals   (RegressTestBoxed *boxed,
 317                                         RegressTestBoxed *other);
 318
 319 typedef struct _RegressTestBoxedB RegressTestBoxedB;
 320
 321 struct _RegressTestBoxedB
 322 {
 323   gint8 some_int8;
 324   glong some_long;
 325 };
 326
 327 GType regress_test_boxed_b_get_type (void);
 328 RegressTestBoxedB *regress_test_boxed_b_new (gint8 some_int8, glong some_long);
 329 RegressTestBoxedB *regress_test_boxed_b_copy (RegressTestBoxedB *boxed);
 330
 331 /* gobject */
 332 #define REGRESS_TEST_TYPE_OBJ              (regress_test_obj_get_type ())
 333 #define REGRESS_TEST_OBJECT(object)        (G_TYPE_CHECK_INSTANCE_CAST ((object), REGRESS_TEST_TYPE_OBJ, RegressTestObj))
 334 #define REGRESS_TEST_IS_OBJECT(object)     (G_TYPE_CHECK_INSTANCE_TYPE ((object), REGRESS_TEST_TYPE_OBJ))
 335 #define REGRESS_TEST_OBJ_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), REGRESS_TEST_TYPE_OBJ, RegressTestObjClass))
 336
 337 typedef struct _RegressTestObj          RegressTestObj;
 338 typedef struct _RegressTestObjClass     RegressTestObjClass;
 339
 340 /**
 341  * RegressTestObj:
 342  * @bare: (allow-none):
 343  */
 344 struct _RegressTestObj
 345 {
 346   GObject parent_instance;
 347
 348   GObject *bare;
 349   RegressTestBoxed *boxed;
 350   GHashTable *hash_table;
 351   GList *list;
 352   gint8 some_int8;
 353   float some_float;
 354   double some_double;
 355   char* string;
 356   GType gtype;
 357 };
 358
 359 struct _RegressTestObjClass
 360 {
 361   GObjectClass parent_class;
 362
 363   int (*matrix) (RegressTestObj *obj, const char *somestr);
 364
 365   /**
 366    * RegressTestObjClass::allow_none_vfunc:
 367    * @two: (allow-none): Another object
 368    */
 369   void (*allow_none_vfunc) (RegressTestObj *obj, RegressTestObj *two);
 370
 371   guint test_signal;
 372   guint test_signal_with_static_scope_arg;
 373
 374   /* Should be replaced with simple "gpointer" and not be callback */
 375   void (*_regress_reserved1) (void);
 376   void (*_regress_reserved2) (void);
 377 };
 378
 379 GType      regress_test_obj_get_type (void);
 380 RegressTestObj*   regress_test_obj_new (RegressTestObj *obj);
 381 RegressTestObj*   regress_constructor (void);
 382 RegressTestObj*   regress_test_obj_new_from_file (const char *x, GError **error);
 383 void       regress_test_obj_set_bare (RegressTestObj *obj, GObject *bare);
 384 void       regress_test_obj_emit_sig_with_obj (RegressTestObj *obj);
 385 void       regress_test_obj_emit_sig_with_foreign_struct (RegressTestObj *obj);
 386 int        regress_test_obj_instance_method (RegressTestObj *obj);
 387 double     regress_test_obj_static_method (int x);
 388 void       regress_forced_method (RegressTestObj *obj);
 389
 390 void regress_test_array_fixed_out_objects (RegressTestObj ***objs);
 391
 392 void regress_test_obj_torture_signature_0 (RegressTestObj    *obj,
 393                                    int        x,
 394                                    double     *y,
 395                                    int        *z,
 396                                    const char *foo,
 397                                    int        *q,
 398                                    guint       m);
 399 gboolean regress_test_obj_torture_signature_1 (RegressTestObj    *obj,
 400                                        int        x,
 401                                        double     *y,
 402                                        int        *z,
 403                                        const char *foo,
 404                                        int        *q,
 405                                        guint       m,
 406                                        GError    **error);
 407
 408 gboolean regress_test_obj_skip_return_val (RegressTestObj *obj,
 409                                            gint            a,
 410                                            gint           *out_b,
 411                                            gdouble         c,
 412                                            gint           *inout_d,
 413                                            gint           *out_sum,
 414                                            gint            num1,
 415                                            gint            num2,
 416                                            GError        **error);
 417
 418 gboolean regress_test_obj_skip_return_val_no_out (RegressTestObj *obj,
 419                                                   gint            a,
 420                                                   GError        **error);
 421
 422 gboolean regress_test_obj_skip_param (RegressTestObj *obj,
 423                                       gint            a,
 424                                       gint           *out_b,
 425                                       gdouble         c,
 426                                       gint           *inout_d,
 427                                       gint           *out_sum,
 428                                       gint            num1,
 429                                       gint            num2,
 430                                       GError        **error);
 431
 432 gboolean regress_test_obj_skip_out_param (RegressTestObj *obj,
 433                                           gint            a,
 434                                           gint           *out_b,
 435                                           gdouble         c,
 436                                           gint           *inout_d,
 437                                           gint           *out_sum,
 438                                           gint            num1,
 439                                           gint            num2,
 440                                           GError        **error);
 441
 442 gboolean regress_test_obj_skip_inout_param (RegressTestObj *obj,
 443                                             gint            a,
 444                                             gint           *out_b,
 445                                             gdouble         c,
 446                                             gint           *inout_d,
 447                                             gint           *out_sum,
 448                                             gint            num1,
 449                                             gint            num2,
 450                                             GError        **error);
 451
 452 /* virtual */
 453 int        regress_test_obj_do_matrix (RegressTestObj *obj, const char *somestr);
 454
 455 void regress_func_obj_null_in (RegressTestObj *obj);
 456 void regress_test_obj_null_out (RegressTestObj **obj);
 457
 458 /* inheritance */
 459 #define REGRESS_TEST_TYPE_SUB_OBJ           (regress_test_sub_obj_get_type ())
 460 #define REGRESS_TEST_SUB_OBJECT(object)     (G_TYPE_CHECK_INSTANCE_CAST ((object), REGRESS_TEST_TYPE_SUB_OBJ, RegressTestSubObj))
 461 #define REGRESS_TEST_IS_SUB_OBJECT(object)  (G_TYPE_CHECK_INSTANCE_TYPE ((object), REGRESS_TEST_TYPE_SUB_OBJ))
 462 #define REGRESS_TEST_SUB_OBJ_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), REGRESS_TEST_TYPE_SUB_OBJ, RegressTestSubObjClass))
 463
 464 typedef struct _RegressTestSubObj         RegressTestSubObj;
 465 typedef struct _RegressTestSubObjClass    RegressTestSubObjClass;
 466
 467 struct _RegressTestSubObj
 468 {
 469   RegressTestObj parent_instance;
 470 };
 471
 472 struct _RegressTestSubObjClass
 473 {
 474   RegressTestObjClass parent_class;
 475 };
 476
 477 GType       regress_test_sub_obj_get_type (void);
 478 RegressTestObj* regress_test_sub_obj_new (void);
 479 void        regress_test_sub_obj_unset_bare (RegressTestSubObj *obj);
 480 int         regress_test_sub_obj_instance_method (RegressTestSubObj *obj);
 481
 482 /* fundamental object */
 483 #define REGRESS_TEST_TYPE_FUNDAMENTAL_OBJECT            (regress_test_fundamental_object_get_type())
 484 #define REGRESS_TEST_IS_FUNDAMENTAL_OBJECT(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), REGRESS_TEST_TYPE_FUNDAMENTAL_OBJECT))
 485 #define REGRESS_TEST_IS_FUNDAMENTAL_OBJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), REGRESS_TEST_TYPE_FUNDAMENTAL_OBJECT))
 486 #define REGRESS_TEST_FUNDAMENTAL_OBJECT_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), REGRESS_TEST_TYPE_FUNDAMENTAL_OBJECT, RegressTestFundamentalObjectClass))
 487 #define REGRESS_TEST_FUNDAMENTAL_OBJECT(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), REGRESS_TEST_TYPE_FUNDAMENTAL_OBJECT, RegressTestFundamentalObject))
 488 #define REGRESS_TEST_FUNDAMENTAL_OBJECT_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), REGRESS_TEST_TYPE_FUNDAMENTAL_OBJECT, RegressTestFundamentalObjectClass))
 489 #define REGRESS_TEST_FUNDAMENTAL_OBJECT_CAST(obj)       ((RegressTestFundamentalObject*)(obj))
 490
 491 typedef struct _RegressTestFundamentalObject RegressTestFundamentalObject;
 492 typedef struct _RegressTestFundamentalObjectClass RegressTestFundamentalObjectClass;
 493 /**
 494  * RegressTestFundamentalObjectCopyFunction:
 495  *
 496  * Returns: (transfer full):
 497  */
 498 typedef RegressTestFundamentalObject * (*RegressTestFundamentalObjectCopyFunction) (const RegressTestFundamentalObject *obj);
 499 typedef void (*RegressTestFundamentalObjectFinalizeFunction) (RegressTestFundamentalObject *obj);
 500
 501
 502 struct _RegressTestFundamentalObject {
 503   GTypeInstance instance;
 504   gint refcount;
 505   guint flags;
 506 };
 507
 508 struct _RegressTestFundamentalObjectClass {
 509   GTypeClass type_class;
 510
 511   RegressTestFundamentalObjectCopyFunction copy;
 512   RegressTestFundamentalObjectFinalizeFunction finalize;
 513 };
 514
 515 GType                  regress_test_fundamental_object_get_type (void);
 516 RegressTestFundamentalObject* regress_test_fundamental_object_ref      (RegressTestFundamentalObject *fundamental_object);
 517 void                   regress_test_fundamental_object_unref    (RegressTestFundamentalObject *fundamental_object);
 518
 519 #define REGRESS_TEST_VALUE_HOLDS_FUNDAMENTAL_OBJECT(value)  (G_VALUE_HOLDS(value, REGRESS_TEST_TYPE_FUNDAMENTAL_OBJECT))
 520
 521 void                   regress_test_value_set_fundamental_object (GValue *value, RegressTestFundamentalObject *fundamental_object);
 522 RegressTestFundamentalObject* regress_test_value_get_fundamental_object (const GValue *value);
 523
 524 typedef struct _RegressTestFundamentalSubObject RegressTestFundamentalSubObject;
 525 typedef struct _RegressTestFundamentalSubObjectClass RegressTestFundamentalSubObjectClass;
 526
 527 struct _RegressTestFundamentalSubObject
 528 {
 529   RegressTestFundamentalObject fundamental_object;
 530   char *data;
 531 };
 532
 533 struct _RegressTestFundamentalSubObjectClass {
 534   RegressTestFundamentalObjectClass fundamental_object_class;
 535 };
 536
 537 GType regress_test_fundamental_sub_object_get_type(void);
 538
 539 RegressTestFundamentalSubObject *
 540 regress_test_fundamental_sub_object_new (const char *data);
 541
 542 /* callback */
 543 typedef void (*RegressTestSimpleCallback) (void);
 544 typedef int (*RegressTestCallback) (void);
 545 typedef int (*RegressTestCallbackUserData) (gpointer user_data);
 546 /**
 547  * RegressTestCallbackHashtable:
 548  * @data: (element-type utf8 gint): a hash table; will be modified
 549  */
 550 typedef void (*RegressTestCallbackHashtable) (GHashTable *data);
 551 typedef void (*RegressTestCallbackGError) (const GError *error);
 552 /**
 553  * RegressTestCallbackOwnedGError:
 554  * @error: (transfer full): GError instance; must be freed by the callback
 555  */
 556 typedef void (*RegressTestCallbackOwnedGError) (GError *error);
 557 /**
 558  * RegressTestCallbackFull:
 559  * @foo: the investment rate
 560  * @bar: how much money
 561  * @path: (type filename): Path to file
 562  */
 563 typedef int (*RegressTestCallbackFull) (int foo, double bar, char *path);
 564 /**
 565  * RegressTestCallbackArray:
 566  * @one: (array length=one_length):
 567  * @one_length:
 568  * @two: (array length=two_length) (element-type utf8):
 569  * @two_length:
 570  */
 571 typedef int (*RegressTestCallbackArray) (int *one, gsize one_length, const char** two, int two_length);
 572
 573 void regress_test_simple_callback (RegressTestSimpleCallback callback);
 574 int regress_test_callback (RegressTestCallback callback);
 575 int regress_test_multi_callback (RegressTestCallback callback);
 576 int regress_test_array_callback (RegressTestCallbackArray callback);
 577 int regress_test_callback_user_data (RegressTestCallbackUserData callback,
 578                              gpointer user_data);
 579 int regress_test_callback_destroy_notify (RegressTestCallbackUserData callback,
 580                                   gpointer user_data,
 581                                   GDestroyNotify notify);
 582 int regress_test_callback_thaw_notifications (void);
 583
 584 void regress_test_callback_async (RegressTestCallbackUserData callback, gpointer user_data);
 585 int regress_test_callback_thaw_async (void);
 586
 587 void regress_test_async_ready_callback (GAsyncReadyCallback callback);
 588
 589 void regress_test_obj_instance_method_callback (RegressTestObj *obj, RegressTestCallback callback);
 590 void regress_test_obj_static_method_callback (RegressTestCallback callback);
 591 RegressTestObj *regress_test_obj_new_callback (RegressTestCallbackUserData callback,
 592                                 gpointer user_data,
 593                                 GDestroyNotify notify);
 594 void regress_test_hash_table_callback (GHashTable *data, RegressTestCallbackHashtable callback);
 595 void regress_test_gerror_callback (RegressTestCallbackGError callback);
 596 void regress_test_null_gerror_callback (RegressTestCallbackGError callback);
 597 void regress_test_owned_gerror_callback (RegressTestCallbackOwnedGError callback);
 598
 599 typedef struct _RegressTestInterface RegressTestInterface;
 600
 601 /* interface */
 602 #define REGRESS_TEST_TYPE_INTERFACE              (regress_test_interface_get_type ())
 603 #define REGRESS_TEST_INTERFACE(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), REGRESS_TEST_TYPE_INTERFACE, RegressTestInterface))
 604 #define REGRESS_TEST_IS_INTERFACE(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), REGRESS_TEST_TYPE_INTERFACE))
 605 #define REGRESS_TEST_INTERFACE_GET_IFACE(obj)    (G_TYPE_INSTANCE_GET_INTERFACE ((obj), REGRESS_TEST_TYPE_INTERFACE, RegressTestInterfaceIface))
 606
 607 typedef struct _RegressTestInterfaceIface RegressTestInterfaceIface;
 608
 609 struct _RegressTestInterfaceIface {
 610     GTypeInterface base_iface;
 611 };
 612
 613 GType regress_test_interface_get_type (void) G_GNUC_CONST;
 614
 615 /* gobject with non-standard prefix */
 616 #define REGRESS_TEST_TYPE_WI_802_1X              (regress_test_wi_802_1x_get_type ())
 617 #define REGRESS_TEST_WI_802_1X(object)        (G_TYPE_CHECK_INSTANCE_CAST ((object), REGRESS_TEST_TYPE_WI_802_1X, RegressTestWi8021x))
 618 #define REGRESS_TEST_IS_WI_802_1X(object)     (G_TYPE_CHECK_INSTANCE_TYPE ((object), REGRESS_TEST_TYPE_WI_802_1X))
 619 #define REGRESS_TEST_WI_802_1X_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), REGRESS_TEST_TYPE_WI_802_1X, RegressTestWi8021xClass))
 620
 621 typedef struct
 622 {
 623   GObject parent_instance;
 624
 625   gboolean testbool;
 626 } RegressTestWi8021x;
 627
 628 typedef struct
 629 {
 630   GObjectClass parent_class;
 631 } RegressTestWi8021xClass;
 632
 633 GType        regress_test_wi_802_1x_get_type (void);
 634 RegressTestWi8021x* regress_test_wi_802_1x_new (void);
 635 gboolean     regress_test_wi_802_1x_get_testbool (RegressTestWi8021x *obj);
 636 void         regress_test_wi_802_1x_set_testbool (RegressTestWi8021x *obj, gboolean v);
 637 int          regress_test_wi_802_1x_static_method (int x);
 638
 639 /* floating gobject */
 640 #define REGRESS_TEST_TYPE_FLOATING           (regress_test_floating_get_type ())
 641 #define REGRESS_TEST_FLOATING(object)        (G_TYPE_CHECK_INSTANCE_CAST ((object), REGRESS_TEST_TYPE_FLOATING, RegressTestFloating))
 642 #define REGRESS_TEST_IS_FLOATING(object)     (G_TYPE_CHECK_INSTANCE_TYPE ((object), REGRESS_TEST_TYPE_FLOATING))
 643 #define REGRESS_TEST_FLOATING_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), REGRESS_TEST_TYPE_FLOATING, RegressTestFloatingClass))
 644
 645 typedef struct
 646 {
 647   GInitiallyUnowned parent_instance;
 648 } RegressTestFloating;
 649
 650 typedef struct
 651 {
 652   GInitiallyUnownedClass parent_class;
 653 } RegressTestFloatingClass;
 654
 655 GType        regress_test_floating_get_type (void);
 656 RegressTestFloating* regress_test_floating_new (void);
 657
 658 /* Function signature torture tests */
 659 void regress_test_torture_signature_0 (int        x,
 660                                double     *y,
 661                                int        *z,
 662                                const char *foo,
 663                                int        *q,
 664                                guint       m);
 665 gboolean regress_test_torture_signature_1 (int        x,
 666                                    double     *y,
 667                                    int        *z,
 668                                    const char *foo,
 669                                    int        *q,
 670                                    guint       m,
 671                                    GError    **error);
 672 void regress_test_torture_signature_2 (int                  x,
 673                                        RegressTestCallbackUserData  callback,
 674                                        gpointer              user_data,
 675                                        GDestroyNotify        notify,
 676                                        double               *y,
 677                                        int                  *z,
 678                                        const char           *foo,
 679                                        int                  *q,
 680                                        guint                 m);
 681
 682 GValue *regress_test_date_in_gvalue (void);
 683 GValue *regress_test_strv_in_gvalue (void);
 684
 685 GObject * _regress_this_is_a_private_symbol (void);
 686
 687 void regress_test_multiline_doc_comments (void);
 688 void regress_test_nested_parameter (int a);
 689
 690 /**
 691  * RegressSkippedStructure: (skip)
 692  *
 693  * This should be skipped, and moreover, all function which
 694  * use it should be.
 695  */
 696 typedef struct
 697 {
 698   int x;
 699   double v;
 700 } RegressSkippedStructure;
 701
 702 void regress_random_function_with_skipped_structure (int x,
 703                                                      RegressSkippedStructure *foo,
 704                                                      double v);
 705
 706 /**
 707  * RegressIntset:
 708  *
 709  * Like telepathy-glib's TpIntset.
 710  *
 711  */
 712 typedef struct _RegressIntset RegressIntset;
 713
 714 /**
 715  * RegressIntSet: (skip)
 716  *
 717  * Compatibility typedef, like telepathy-glib's TpIntSet
 718  *
 719  */
 720 typedef RegressIntset RegressIntSet;
 721
 722 /**
 723  * RegressPtrArrayAlias:
 724  *
 725  * Typedef'd GPtrArray for some reason
 726  */
 727 typedef GPtrArray RegressPtrArrayAlias;
 728
 729 void regress_introspectable_via_alias (RegressPtrArrayAlias *data);
 730
 731 /**
 732  * RegressVaListAlias:
 733  *
 734  * Typedef'd va_list for additional reasons
 735  */
 736 typedef va_list RegressVaListAlias;
 737
 738 void regress_not_introspectable_via_alias (RegressVaListAlias ok);
 739
 740 /**
 741  * RegressAliasedTestBoxed:
 742  *
 743  * Typedef TestBoxed to test caller-allocates correctness
 744  */
 745 typedef RegressTestBoxed RegressAliasedTestBoxed;
 746
 747 void regress_aliased_caller_alloc (RegressAliasedTestBoxed *boxed);
 748
 749 /* private testing */
 750
 751 typedef struct {
 752   gint this_is_public_before;
 753   /* < private > */
 754   gint this_is_private;
 755   /* < public > */
 756   gint this_is_public_after;
 757 } RegressTestPrivateStruct;
 758
 759 typedef enum {
 760   REGRESS_TEST_PUBLIC_ENUM_BEFORE = 1 << 0,
 761   /* <private> */
 762   REGRESS_TEST_PRIVATE_ENUM       = 1 << 1,
 763   /* <public> */
 764   REGRESS_TEST_PUBLIC_ENUM_AFTER  = 1 << 2,
 765 } RegressTestPrivateEnum;
 766
 767 typedef struct {
 768   gint just_int;
 769   gint array[10];
 770 } RegressTestStructFixedArray;
 771
 772 void regress_test_struct_fixed_array_frob (RegressTestStructFixedArray *str);
 773
 774 #define REGRESS_UTF8_CONSTANT "const \xe2\x99\xa5 utf8"
 775
 776 #ifdef __GNUC__
 777 #define REGRESS_TEST_GNUC_EXTENSION_STMT(foo) (G_GNUC_EXTENSION ({ int x[10]; x[5] = 42; x[5]; }))
 778 #endif
 779
 780 /* https://bugzilla.gnome.org/show_bug.cgi?id=662888 */
 781 #define REGRESS_LONG_STRING_CONSTANT \
 782         "TYPE,VALUE,ENCODING,CHARSET,LANGUAGE,DOM,INTL,POSTAL,PARCEL," \
 783         "HOME,WORK,PREF,VOICE,FAX,MSG,CELL,PAGER,BBS,MODEM,CAR,ISDN,VIDEO," \
 784         "AOL,APPLELINK,ATTMAIL,CIS,EWORLD,INTERNET,IBMMAIL,MCIMAIL," \
 785         "POWERSHARE,PRODIGY,TLX,X400,GIF,CGM,WMF,BMP,MET,PMB,DIB,PICT,TIFF," \
 786         "PDF,PS,JPEG,QTIME,MPEG,MPEG2,AVI,WAVE,AIFF,PCM,X509,PGP"
 787
 788 void regress_has_parameter_named_attrs (int        foo,
 789                                         gpointer   attributes);
 790
 791 #endif /* __GITESTTYPES_H__ */