summaryrefslogtreecommitdiffstats
path: root/src/jaegertracing/thrift/lib/c_glib/test/testdebugproto.c
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--src/jaegertracing/thrift/lib/c_glib/test/testdebugproto.c941
1 files changed, 941 insertions, 0 deletions
diff --git a/src/jaegertracing/thrift/lib/c_glib/test/testdebugproto.c b/src/jaegertracing/thrift/lib/c_glib/test/testdebugproto.c
new file mode 100644
index 000000000..109a48b50
--- /dev/null
+++ b/src/jaegertracing/thrift/lib/c_glib/test/testdebugproto.c
@@ -0,0 +1,941 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#include <math.h>
+#include <string.h>
+#include <glib-object.h>
+
+#ifndef M_PI
+#define M_PI 3.1415926535897932385
+#endif
+
+#include <thrift/c_glib/protocol/thrift_protocol.h>
+#include <thrift/c_glib/protocol/thrift_binary_protocol.h>
+
+#include "gen-c_glib/t_test_debug_proto_test_types.h"
+#include "gen-c_glib/t_test_srv.h"
+#include "gen-c_glib/t_test_inherited.h"
+
+static void
+test_structs_doubles_create_and_destroy (void)
+{
+ GObject *object = NULL;
+
+ /* A Doubles structure can be created... */
+ object = g_object_new (T_TEST_TYPE_DOUBLES, NULL);
+
+ g_assert (object != NULL);
+ g_assert (T_TEST_IS_DOUBLES (object));
+
+ /* ...and destroyed */
+ g_object_unref (object);
+}
+
+static void
+test_structs_doubles_initialize (void)
+{
+ TTestDoubles *doubles = NULL;
+ gdouble nan;
+ gdouble inf;
+ gdouble neginf;
+ gdouble repeating;
+ gdouble big;
+ gdouble tiny;
+ gdouble zero;
+ gdouble negzero;
+
+ /* Note there seems to be no way to get not-a-number ("NAN") values past
+ GObject's range-checking, so that portion of the test has been commented
+ out below. */
+
+ /* A Doubles structure's members are available as GObject properties
+ that can be initialized at construction... */
+ doubles = g_object_new (T_TEST_TYPE_DOUBLES,
+ /* "nan", 0 * INFINITY, */
+ "inf", INFINITY,
+ "neginf", -INFINITY,
+ "repeating", 1.0 / 3,
+ "big", G_MAXDOUBLE,
+ "tiny", 10E-101,
+ "zero", 1.0 * 0,
+ "negzero", -1.0 * 0,
+ NULL);
+
+ g_assert (doubles != NULL);
+
+ /* ...and later retrieved */
+ g_object_get (doubles,
+ "nan", &nan,
+ "inf", &inf,
+ "neginf", &neginf,
+ "repeating", &repeating,
+ "big", &big,
+ "tiny", &tiny,
+ "zero", &zero,
+ "negzero", &negzero,
+ NULL);
+
+ /* g_assert_cmpint (isnan (nan), !=, 0); */
+ g_assert_cmpint (isinf (inf), ==, 1);
+ g_assert_cmpint (isinf (neginf), ==, -1);
+
+ g_assert_cmpfloat (repeating, ==, 1.0 / 3);
+ g_assert_cmpfloat (big, ==, G_MAXDOUBLE);
+ g_assert_cmpfloat (tiny, ==, 10E-101);
+ g_assert_cmpfloat (zero, ==, 1.0 * 0);
+ g_assert_cmpfloat (negzero, ==, -1.0 * 0);
+
+ g_object_unref (doubles);
+}
+
+static void
+test_structs_one_of_each_create_and_destroy (void)
+{
+ GObject *object = NULL;
+
+ /* A OneOfEach structure can be created... */
+ object = g_object_new (T_TEST_TYPE_ONE_OF_EACH, NULL);
+
+ g_assert (object != NULL);
+ g_assert (T_TEST_IS_ONE_OF_EACH (object));
+
+ /* ...and destroyed */
+ g_object_unref (object);
+}
+
+static void
+test_structs_one_of_each_initialize_default_values (void)
+{
+ TTestOneOfEach *one_of_each = NULL;
+ gint a_bite;
+ gint integer16;
+ gint64 integer64;
+ GArray *byte_list;
+ GArray *i16_list;
+ GArray *i64_list;
+
+ /* A OneOfEach structure created with no explicit property values
+ will hold the default values specified in the .thrift file */
+ one_of_each = g_object_new (T_TEST_TYPE_ONE_OF_EACH, NULL);
+
+ g_object_get (one_of_each,
+ "a_bite", &a_bite,
+ "integer16", &integer16,
+ "integer64", &integer64,
+ "byte_list", &byte_list,
+ "i16_list", &i16_list,
+ "i64_list", &i64_list,
+ NULL);
+
+ g_assert_cmpint (a_bite, ==, 0x7f);
+ g_assert_cmpint (integer16, ==, 0x7fff);
+ g_assert_cmpint (integer64, ==, G_GINT64_CONSTANT (10000000000));
+
+ g_assert (byte_list != NULL);
+ g_assert_cmpint (byte_list->len, ==, 3);
+ g_assert_cmpint (g_array_index (byte_list, gint8, 0), ==, 1);
+ g_assert_cmpint (g_array_index (byte_list, gint8, 1), ==, 2);
+ g_assert_cmpint (g_array_index (byte_list, gint8, 2), ==, 3);
+
+ g_assert (i16_list != NULL);
+ g_assert_cmpint (i16_list->len, ==, 3);
+ g_assert_cmpint (g_array_index (i16_list, gint16, 0), ==, 1);
+ g_assert_cmpint (g_array_index (i16_list, gint16, 1), ==, 2);
+ g_assert_cmpint (g_array_index (i16_list, gint16, 2), ==, 3);
+
+ g_assert (i64_list != NULL);
+ g_assert_cmpint (i64_list->len, ==, 3);
+ g_assert_cmpint (g_array_index (i64_list, gint64, 0), ==, 1);
+ g_assert_cmpint (g_array_index (i64_list, gint64, 1), ==, 2);
+ g_assert_cmpint (g_array_index (i64_list, gint64, 2), ==, 3);
+
+ g_array_unref (i64_list);
+ g_array_unref (i16_list);
+ g_array_unref (byte_list);
+ g_object_unref (one_of_each);
+}
+
+static void
+test_structs_one_of_each_initialize_specified_values (void)
+{
+ static const gint8 initial_byte_list[5] = { 13, 21, 34, 55, 89 };
+ static const gint16 initial_i16_list[5] = { 4181, 6765, 10946, 17711, 28657 };
+ static const gint64 initial_i64_list[5] =
+ {
+ G_GINT64_CONSTANT (1100087778366101931),
+ G_GINT64_CONSTANT (1779979416004714189),
+ G_GINT64_CONSTANT (2880067194370816120),
+ G_GINT64_CONSTANT (4660046610375530309),
+ G_GINT64_CONSTANT (7540113804746346429)
+ };
+ static const guint8 initial_base64[8] =
+ {
+ 0x56, 0x47, 0x68, 0x79, 0x61, 0x57, 0x5a, 0x30
+ };
+
+ TTestOneOfEach *one_of_each;
+ gboolean im_true;
+ gboolean im_false;
+ gint a_bite;
+ gint integer16;
+ gint integer32;
+ gint64 integer64;
+ double double_precision;
+ gchar *some_characters;
+ gchar *zomg_unicode;
+ gboolean what_who;
+ GByteArray *base64;
+ GArray *byte_list;
+ GArray *i16_list;
+ GArray *i64_list;
+
+ base64 = g_byte_array_new ();
+ g_byte_array_append (base64, initial_base64, 8);
+
+ byte_list = g_array_new (FALSE, FALSE, sizeof (gint8));
+ g_array_append_vals (byte_list, initial_byte_list, 5);
+
+ i16_list = g_array_new (FALSE, FALSE, sizeof (gint16));
+ g_array_append_vals (i16_list, initial_i16_list, 5);
+
+ i64_list = g_array_new (FALSE, FALSE, sizeof (gint64));
+ g_array_append_vals (i64_list, initial_i64_list, 5);
+
+ /* All of OneOfEach's properties can be set at construction... */
+ one_of_each =
+ g_object_new (T_TEST_TYPE_ONE_OF_EACH,
+ "im_true", TRUE,
+ "im_false", FALSE,
+ "a_bite", 0x50,
+ "integer16", 0x7e57,
+ "integer32", 0xdeadbeef,
+ "integer64", G_GINT64_CONSTANT (0xfa15efacade15bad),
+ "double_precision", M_PI,
+ "some_characters", "Debug THIS!",
+ "zomg_unicode", "\xd7\n\a\t",
+ "what_who", TRUE,
+ "base64", base64,
+ "byte_list", byte_list,
+ "i16_list", i16_list,
+ "i64_list", i64_list,
+ NULL);
+ g_assert (one_of_each != NULL);
+
+ g_array_unref (i64_list);
+ i64_list = NULL;
+ g_array_unref (i16_list);
+ i16_list = NULL;
+ g_array_unref (byte_list);
+ byte_list = NULL;
+ g_byte_array_unref (base64);
+ base64 = NULL;
+
+ /* ...and later retrieved */
+ g_object_get (one_of_each,
+ "im_true", &im_true,
+ "im_false", &im_false,
+ "a_bite", &a_bite,
+ "integer16", &integer16,
+ "integer32", &integer32,
+ "integer64", &integer64,
+ "double_precision", &double_precision,
+ "some_characters", &some_characters,
+ "zomg_unicode", &zomg_unicode,
+ "what_who", &what_who,
+ "base64", &base64,
+ "byte_list", &byte_list,
+ "i16_list", &i16_list,
+ "i64_list", &i64_list,
+ NULL);
+
+ g_assert (im_true == TRUE);
+ g_assert (im_false == FALSE);
+
+ g_assert_cmphex (a_bite, ==, 0x50);
+ g_assert_cmphex (integer16, ==, 0x7e57);
+ g_assert_cmphex (integer32, ==, (gint32)0xdeadbeef);
+ g_assert_cmphex (integer64, ==, G_GINT64_CONSTANT (0xfa15efacade15bad));
+
+ g_assert_cmpfloat (double_precision, ==, M_PI);
+
+ g_assert_cmpstr (some_characters, ==, "Debug THIS!");
+ g_assert_cmpstr (zomg_unicode, ==, "\xd7\n\a\t");
+
+ g_assert (what_who == TRUE);
+
+ g_assert_cmpint (base64->len, ==, 8);
+ g_assert_cmpint (memcmp (base64->data,
+ initial_base64,
+ 8 * sizeof (guint8)), ==, 0);
+
+ g_assert_cmpint (byte_list->len, ==, 5);
+ g_assert_cmpint (memcmp (byte_list->data,
+ initial_byte_list,
+ 5 * sizeof (gint8)), ==, 0);
+
+ g_assert_cmpint (i16_list->len, ==, 5);
+ g_assert_cmpint (memcmp (i16_list->data,
+ initial_i16_list,
+ 5 * sizeof (gint16)), ==, 0);
+
+ g_assert_cmpint (i64_list->len, ==, 5);
+ g_assert_cmpint (memcmp (i64_list->data,
+ initial_i64_list,
+ 5 * sizeof (gint64)), ==, 0);
+
+ g_array_unref (i64_list);
+ g_array_unref (i16_list);
+ g_array_unref (byte_list);
+ g_byte_array_unref (base64);
+
+ g_object_unref (one_of_each);
+}
+
+static void
+test_structs_one_of_each_properties_byte_list (void)
+{
+ TTestOneOfEach *one_of_each;
+ GArray *byte_list = NULL;
+
+ one_of_each = g_object_new (T_TEST_TYPE_ONE_OF_EACH, NULL);
+
+ /* OneOfEach's "byte_list" member is a list that holds eight-bit-wide integer
+ values */
+ g_object_get (one_of_each, "byte_list", &byte_list, NULL);
+
+ g_assert (byte_list != NULL);
+ g_assert_cmpint (g_array_get_element_size (byte_list), ==, sizeof (gint8));
+
+ g_array_unref (byte_list);
+ g_object_unref (one_of_each);
+}
+
+static void
+test_structs_one_of_each_properties_i16_list (void)
+{
+ TTestOneOfEach *one_of_each;
+ GArray *i16_list = NULL;
+
+ one_of_each = g_object_new (T_TEST_TYPE_ONE_OF_EACH, NULL);
+
+ /* OneOfEach's "i16_list" member is a list that holds sixteen-bit-wide integer
+ values */
+ g_object_get (one_of_each, "i16_list", &i16_list, NULL);
+
+ g_assert (i16_list != NULL);
+ g_assert_cmpint (g_array_get_element_size (i16_list), ==, sizeof (gint16));
+
+ g_array_unref (i16_list);
+ g_object_unref (one_of_each);
+}
+
+static void
+test_structs_one_of_each_properties_i64_list (void)
+{
+ TTestOneOfEach *one_of_each;
+ GArray *i64_list = NULL;
+
+ one_of_each = g_object_new (T_TEST_TYPE_ONE_OF_EACH, NULL);
+
+ /* OneOfEach's "i64_list" member is a list that holds sixty-four-bit-wide
+ integer values */
+ g_object_get (one_of_each, "i64_list", &i64_list, NULL);
+
+ g_assert (i64_list != NULL);
+ g_assert_cmpint (g_array_get_element_size (i64_list), ==, sizeof (gint64));
+
+ g_array_unref (i64_list);
+ g_object_unref (one_of_each);
+}
+
+static void
+test_structs_nesting_create_and_destroy (void)
+{
+ GObject *object = NULL;
+
+ /* A Nesting structure can be created... */
+ object = g_object_new (T_TEST_TYPE_NESTING, NULL);
+
+ g_assert (object != NULL);
+ g_assert (T_TEST_IS_NESTING (object));
+
+ /* ...and destroyed */
+ g_object_unref (object);
+}
+
+static void
+test_structs_nesting_properties_my_bonk (void)
+{
+ TTestNesting *nesting;
+ TTestBonk *bonk = NULL;
+ gint type;
+ gchar *message;
+
+ nesting = g_object_new (T_TEST_TYPE_NESTING, NULL);
+
+ /* Nesting's "my_bonk" member is initialized with a new, default Bonk object
+ during construction */
+ g_object_get (nesting, "my_bonk", &bonk, NULL);
+
+ g_assert (bonk != NULL);
+ g_assert (T_TEST_IS_BONK (bonk));
+
+ g_object_get (bonk,
+ "type", &type,
+ "message", &message,
+ NULL);
+
+ g_assert_cmpint (type, ==, 0);
+ g_assert (message == NULL);
+
+ g_object_unref (bonk);
+ bonk = NULL;
+
+ /* It can be replaced... */
+ bonk = g_object_new (T_TEST_TYPE_BONK,
+ "type", 100,
+ "message", "Replacement Bonk",
+ NULL);
+ g_object_set (nesting, "my_bonk", bonk, NULL);
+ g_object_unref (bonk);
+ bonk = NULL;
+
+ g_object_get (nesting, "my_bonk", &bonk, NULL);
+
+ g_assert (bonk != NULL);
+ g_assert (T_TEST_IS_BONK (bonk));
+
+ g_object_get (bonk,
+ "type", &type,
+ "message", &message,
+ NULL);
+
+ g_assert_cmpint (type, ==, 100);
+ g_assert_cmpstr (message, ==, "Replacement Bonk");
+
+ g_free (message);
+ g_object_unref (bonk);
+ bonk = NULL;
+
+ /* ...or set to null */
+ g_object_set (nesting, "my_bonk", NULL, NULL);
+ g_object_get (nesting, "my_bonk", &bonk, NULL);
+
+ g_assert (bonk == NULL);
+
+ g_object_unref (nesting);
+}
+
+static void
+test_structs_nesting_properties_my_ooe (void)
+{
+ TTestNesting *nesting;
+ TTestOneOfEach *one_of_each = NULL;
+ gint a_bite;
+ gint integer16;
+
+ nesting = g_object_new (T_TEST_TYPE_NESTING, NULL);
+
+ /* Nesting's "my_ooe" member is initialized with a new, default OneOfEach
+ object during construction */
+ g_object_get (nesting, "my_ooe", &one_of_each, NULL);
+
+ g_assert (one_of_each != NULL);
+ g_assert (T_TEST_IS_ONE_OF_EACH (one_of_each));
+
+ g_object_get (one_of_each,
+ "a_bite", &a_bite,
+ "integer16", &integer16,
+ NULL);
+
+ g_assert_cmphex (a_bite, ==, 0x7f);
+ g_assert_cmphex (integer16, ==, 0x7fff);
+
+ g_object_unref (one_of_each);
+ one_of_each = NULL;
+
+ /* It can be replaced... */
+ one_of_each = g_object_new (T_TEST_TYPE_ONE_OF_EACH,
+ "a_bite", 0x50,
+ "integer16", 0x5050,
+ NULL);
+ g_object_set (nesting, "my_ooe", one_of_each, NULL);
+ g_object_unref (one_of_each);
+ one_of_each = NULL;
+
+ g_object_get (nesting, "my_ooe", &one_of_each, NULL);
+
+ g_assert (one_of_each != NULL);
+ g_assert (T_TEST_IS_ONE_OF_EACH (one_of_each));
+
+ g_object_get (one_of_each,
+ "a_bite", &a_bite,
+ "integer16", &integer16,
+ NULL);
+
+ g_assert_cmphex (a_bite, ==, 0x50);
+ g_assert_cmphex (integer16, ==, 0x5050);
+
+ g_object_unref (one_of_each);
+ one_of_each = NULL;
+
+ /* ...or set to null */
+ g_object_set (nesting, "my_ooe", NULL, NULL);
+ g_object_get (nesting, "my_ooe", &one_of_each, NULL);
+
+ g_assert (one_of_each == NULL);
+
+ g_object_unref (nesting);
+}
+
+static void
+test_structs_holy_moley_create_and_destroy (void)
+{
+ GObject *object = NULL;
+
+ /* A HolyMoley structure can be created... */
+ object = g_object_new (T_TEST_TYPE_HOLY_MOLEY, NULL);
+
+ g_assert (object != NULL);
+ g_assert (T_TEST_IS_HOLY_MOLEY (object));
+
+ /* ...and destroyed */
+ g_object_unref (object);
+}
+
+static void
+test_structs_holy_moley_properties_big (void)
+{
+ TTestHolyMoley *holy_moley;
+ GPtrArray *big = NULL;
+ gint a_bite = 0;
+ gint integer16 = 0;
+
+ holy_moley = g_object_new (T_TEST_TYPE_HOLY_MOLEY, NULL);
+
+ /* A HolyMoley's "big" member is is initialized on construction */
+ g_object_get (holy_moley, "big", &big, NULL);
+
+ g_assert (big != NULL);
+ g_assert_cmpint (big->len, ==, 0);
+
+ /* It can be modified... */
+ g_ptr_array_add (big,
+ g_object_new (T_TEST_TYPE_ONE_OF_EACH,
+ "a_bite", 0x50,
+ "integer16", 0x5050,
+ NULL));
+
+ g_ptr_array_unref (big);
+ big = NULL;
+
+ g_object_get (holy_moley, "big", &big, NULL);
+
+ g_assert_cmpint (big->len, ==, 1);
+ g_object_get (g_ptr_array_index (big, 0),
+ "a_bite", &a_bite,
+ "integer16", &integer16,
+ NULL);
+
+ g_assert_cmphex (a_bite, ==, 0x50);
+ g_assert_cmphex (integer16, ==, 0x5050);
+
+ g_ptr_array_unref (big);
+ big = NULL;
+
+ /* ...replaced... */
+ big = g_ptr_array_new_with_free_func (g_object_unref);
+ g_ptr_array_add (big,
+ g_object_new (T_TEST_TYPE_ONE_OF_EACH,
+ "a_bite", 0x64,
+ "integer16", 0x1541,
+ NULL));
+
+ g_object_set (holy_moley, "big", big, NULL);
+
+ g_ptr_array_unref (big);
+ big = NULL;
+
+ g_object_get (holy_moley, "big", &big, NULL);
+
+ g_assert_cmpint (big->len, ==, 1);
+ g_object_get (g_ptr_array_index (big, 0),
+ "a_bite", &a_bite,
+ "integer16", &integer16,
+ NULL);
+
+ g_assert_cmphex (a_bite, ==, 0x64);
+ g_assert_cmphex (integer16, ==, 0x1541);
+
+ g_ptr_array_unref (big);
+ big = NULL;
+
+ /* ...or set to NULL */
+ g_object_set (holy_moley, "big", NULL, NULL);
+ g_object_get (holy_moley, "big", &big, NULL);
+
+ g_assert (big == NULL);
+
+ g_object_unref (holy_moley);
+}
+
+static void
+test_structs_holy_moley_properties_contain (void)
+{
+ static gchar *strings[2] = { "Apache", "Thrift" };
+
+ TTestHolyMoley *holy_moley;
+ GHashTable *contain = NULL;
+ GPtrArray *string_list;
+ GList *key_list;
+
+ holy_moley = g_object_new (T_TEST_TYPE_HOLY_MOLEY, NULL);
+
+ /* A HolyMoley's "contain" member is initialized on construction */
+ g_object_get (holy_moley, "contain", &contain, NULL);
+
+ g_assert (contain != NULL);
+ g_assert_cmpint (g_hash_table_size (contain), ==, 0);
+
+ /* It can be modified... */
+ string_list = g_ptr_array_new ();
+ g_ptr_array_add (string_list, strings[0]);
+ g_ptr_array_add (string_list, strings[1]);
+
+ g_hash_table_insert (contain, string_list, NULL);
+ string_list = NULL;
+
+ g_hash_table_unref (contain);
+ contain = NULL;
+
+ g_object_get (holy_moley, "contain", &contain, NULL);
+
+ g_assert_cmpint (g_hash_table_size (contain), ==, 1);
+
+ key_list = g_hash_table_get_keys (contain);
+ string_list = g_list_nth_data (key_list, 0);
+
+ g_assert_cmpint (string_list->len, ==, 2);
+ g_assert_cmpstr (g_ptr_array_index (string_list, 0), ==, "Apache");
+ g_assert_cmpstr (g_ptr_array_index (string_list, 1), ==, "Thrift");
+
+ g_list_free (key_list);
+ g_hash_table_unref (contain);
+ contain = NULL;
+
+ /* ...replaced... */
+ contain = g_hash_table_new_full (g_direct_hash,
+ g_direct_equal,
+ (GDestroyNotify) g_ptr_array_unref,
+ NULL);
+ g_object_set (holy_moley, "contain", contain, NULL);
+ g_hash_table_unref (contain);
+ contain = NULL;
+
+ g_object_get (holy_moley, "contain", &contain, NULL);
+
+ g_assert_cmpint (g_hash_table_size (contain), ==, 0);
+
+ g_hash_table_unref (contain);
+ contain = NULL;
+
+ /* ...or set to NULL */
+ g_object_set (holy_moley, "contain", NULL, NULL);
+ g_object_get (holy_moley, "contain", &contain, NULL);
+
+ g_assert (contain == NULL);
+
+ g_object_unref (holy_moley);
+}
+
+static void
+test_structs_holy_moley_properties_bonks (void)
+{
+ TTestHolyMoley *holy_moley;
+ GHashTable *bonks = NULL;
+ GPtrArray *bonk_list = NULL;
+ TTestBonk *bonk = NULL;
+ gint type;
+ gchar *message;
+ GList *key_list;
+
+ holy_moley = g_object_new (T_TEST_TYPE_HOLY_MOLEY, NULL);
+
+ /* A HolyMoley's "bonks" member is initialized on construction */
+ g_object_get (holy_moley, "bonks", &bonks, NULL);
+
+ g_assert (bonks != NULL);
+ g_assert_cmpint (g_hash_table_size (bonks), ==, 0);
+
+ /* It can be modified... */
+ bonk = g_object_new (T_TEST_TYPE_BONK,
+ "type", 100,
+ "message", "Sample Bonk",
+ NULL);
+ bonk_list = g_ptr_array_new_with_free_func (g_object_unref);
+ g_ptr_array_add (bonk_list, bonk);
+ bonk = NULL;
+
+ g_hash_table_insert (bonks, g_strdup ("Sample Bonks"), bonk_list);
+ bonk_list = NULL;
+
+ g_hash_table_unref (bonks);
+ bonks = NULL;
+
+ g_object_get (holy_moley, "bonks", &bonks, NULL);
+
+ g_assert_cmpint (g_hash_table_size (bonks), ==, 1);
+
+ key_list = g_hash_table_get_keys (bonks);
+ bonk_list = g_hash_table_lookup (bonks, g_list_nth_data (key_list, 0));
+
+ g_assert_cmpint (bonk_list->len, ==, 1);
+
+ bonk = (g_ptr_array_index (bonk_list, 0));
+ g_object_get (bonk,
+ "type", &type,
+ "message", &message,
+ NULL);
+
+ g_assert_cmpint (type, ==, 100);
+ g_assert_cmpstr (message, ==, "Sample Bonk");
+
+ bonk = NULL;
+ g_free (message);
+ g_list_free (key_list);
+ g_hash_table_unref (bonks);
+ bonks = NULL;
+
+ /* ...replaced... */
+ bonks = g_hash_table_new_full (g_str_hash,
+ g_str_equal,
+ g_free,
+ (GDestroyNotify) g_ptr_array_unref);
+ g_object_set (holy_moley, "bonks", bonks, NULL);
+ g_hash_table_unref (bonks);
+ bonks = NULL;
+
+ g_object_get (holy_moley, "bonks", &bonks, NULL);
+
+ g_assert_cmpint (g_hash_table_size (bonks), ==, 0);
+
+ g_hash_table_unref (bonks);
+ bonks = NULL;
+
+ /* ...or set to NULL */
+ g_object_set (holy_moley, "bonks", NULL, NULL);
+ g_object_get (holy_moley, "bonks", &bonks, NULL);
+
+ g_assert (bonks == NULL);
+
+ g_object_unref (holy_moley);
+}
+
+static void
+test_structs_empty (void)
+{
+ GObject *object = NULL;
+ GParamSpec **properties;
+ guint property_count;
+
+ /* An Empty structure can be created */
+ object = g_object_new (T_TEST_TYPE_EMPTY, NULL);
+
+ g_assert (object != NULL);
+ g_assert (T_TEST_IS_EMPTY (object));
+
+ /* An Empty structure has no members and thus no properties */
+ properties = g_object_class_list_properties (G_OBJECT_GET_CLASS (object),
+ &property_count);
+ g_assert_cmpint (property_count, ==, 0);
+ g_free (properties);
+
+ /* An Empty structure can be destroyed */
+ g_object_unref (object);
+}
+
+static void
+test_structs_wrapper_create_and_destroy (void)
+{
+ GObject *object = NULL;
+
+ /* A Wrapper structure can be created... */
+ object = g_object_new (T_TEST_TYPE_EMPTY, NULL);
+
+ g_assert (object != NULL);
+ g_assert (T_TEST_IS_EMPTY (object));
+
+ /* ...and destroyed */
+ g_object_unref (object);
+}
+
+static void
+test_structs_wrapper_properties_foo (void) {
+ TTestWrapper *wrapper;
+ TTestEmpty *foo;
+
+ wrapper = g_object_new (T_TEST_TYPE_WRAPPER, NULL);
+
+ /* A Wrapper structure has one member, "foo", which is an Empty
+ structure initialized during construction */
+ g_object_get (wrapper, "foo", &foo, NULL);
+
+ g_assert (foo != NULL);
+ g_assert (T_TEST_IS_EMPTY (foo));
+
+ g_object_unref (foo);
+ foo = NULL;
+
+ /* A Wrapper's foo property can be replaced... */
+ foo = g_object_new (T_TEST_TYPE_EMPTY, NULL);
+ g_object_set (wrapper, "foo", foo, NULL);
+
+ g_object_unref (foo);
+ foo = NULL;
+
+ g_object_get (wrapper, "foo", &foo, NULL);
+ g_assert (foo != NULL);
+ g_assert (T_TEST_IS_EMPTY (foo));
+
+ g_object_unref (foo);
+ foo = NULL;
+
+ /* ...or set to NULL */
+ g_object_set (wrapper, "foo", NULL, NULL);
+ g_object_get (wrapper, "foo", &foo, NULL);
+
+ g_assert (foo == NULL);
+
+ g_object_unref (wrapper);
+}
+
+static void
+test_services_inherited (void)
+{
+ ThriftProtocol *protocol;
+ TTestInheritedClient *inherited_client;
+ GObject *input_protocol, *output_protocol;
+
+ protocol = g_object_new (THRIFT_TYPE_BINARY_PROTOCOL, NULL);
+ inherited_client = g_object_new (T_TEST_TYPE_INHERITED_CLIENT,
+ NULL);
+
+ /* TTestInheritedClient inherits from TTestSrvClient */
+ g_assert (g_type_is_a (T_TEST_TYPE_INHERITED_CLIENT,
+ T_TEST_TYPE_SRV_CLIENT));
+
+ /* TTestInheritedClient implements TTestSrvClient's interface */
+ g_assert (g_type_is_a (T_TEST_TYPE_INHERITED_CLIENT,
+ T_TEST_TYPE_SRV_IF));
+
+ /* TTestInheritedClient's inherited properties can be set and retrieved */
+ g_object_set (inherited_client,
+ "input_protocol", protocol,
+ "output_protocol", protocol,
+ NULL);
+
+ g_object_get (inherited_client,
+ "input_protocol", &input_protocol,
+ "output_protocol", &output_protocol,
+ NULL);
+
+ g_assert (input_protocol == G_OBJECT(protocol));
+ g_assert (output_protocol == G_OBJECT(protocol));
+
+ g_object_unref (output_protocol);
+ g_object_unref (input_protocol);
+ g_object_unref (inherited_client);
+ g_object_unref (protocol);
+}
+
+int
+main(int argc, char *argv[])
+{
+#if (!GLIB_CHECK_VERSION (2, 36, 0))
+ g_type_init ();
+#endif
+
+ g_test_init (&argc, &argv, NULL);
+
+ g_test_add_func
+ ("/testdebugproto/DebugProto/Structs/Doubles/CreateAndDestroy",
+ test_structs_doubles_create_and_destroy);
+ g_test_add_func
+ ("/testdebugproto/DebugProto/Structs/Doubles/Initialize",
+ test_structs_doubles_initialize);
+
+ g_test_add_func
+ ("/testdebugproto/DebugProto/Structs/OneOfEach/CreateAndDestroy",
+ test_structs_one_of_each_create_and_destroy);
+ g_test_add_func
+ ("/testdebugproto/DebugProto/Structs/OneOfEach/Initialize/DefaultValues",
+ test_structs_one_of_each_initialize_default_values);
+ g_test_add_func
+ ("/testdebugproto/DebugProto/Structs/OneOfEach/Initialize/SpecifiedValues",
+ test_structs_one_of_each_initialize_specified_values);
+ g_test_add_func
+ ("/testdebugproto/DebugProto/Structs/OneOfEach/Properties/byte_list",
+ test_structs_one_of_each_properties_byte_list);
+ g_test_add_func
+ ("/testdebugproto/DebugProto/Structs/OneOfEach/Properties/i16_list",
+ test_structs_one_of_each_properties_i16_list);
+ g_test_add_func
+ ("/testdebugproto/DebugProto/Structs/OneOfEach/Properties/i64_list",
+ test_structs_one_of_each_properties_i64_list);
+
+ g_test_add_func
+ ("/testdebugproto/DebugProto/Structs/Nesting/CreateAndDestroy",
+ test_structs_nesting_create_and_destroy);
+ g_test_add_func
+ ("/testdebugproto/DebugProto/Structs/Nesting/Properties/my_bonk",
+ test_structs_nesting_properties_my_bonk);
+ g_test_add_func
+ ("/testdebugproto/DebugProto/Structs/Nesting/Properties/my_ooe",
+ test_structs_nesting_properties_my_ooe);
+
+ g_test_add_func
+ ("/testdebugproto/DebugProto/Structs/HolyMoley/CreateAndDestroy",
+ test_structs_holy_moley_create_and_destroy);
+ g_test_add_func
+ ("/testdebugproto/DebugProto/Structs/HolyMoley/Properties/big",
+ test_structs_holy_moley_properties_big);
+ g_test_add_func
+ ("/testdebugproto/DebugProto/Structs/HolyMoley/Properties/contain",
+ test_structs_holy_moley_properties_contain);
+ g_test_add_func
+ ("/testdebugproto/DebugProto/Structs/HolyMoley/Properties/bonks",
+ test_structs_holy_moley_properties_bonks);
+
+ g_test_add_func
+ ("/testdebugproto/DebugProto/Structs/Empty",
+ test_structs_empty);
+
+ g_test_add_func
+ ("/testdebugproto/DebugProto/Structs/Wrapper/CreateAndDestroy",
+ test_structs_wrapper_create_and_destroy);
+ g_test_add_func
+ ("/testdebugproto/DebugProto/Structs/Wrapper/Properties/foo",
+ test_structs_wrapper_properties_foo);
+
+ g_test_add_func
+ ("/testdebugproto/DebugProto/Services/Inherited",
+ test_services_inherited);
+
+ return g_test_run ();
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-07-16 10:18:58 +0000