http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/d709f67d/depends/thirdparty/thrift/lib/c_glib/test/testdebugproto.c ---------------------------------------------------------------------- diff --git a/depends/thirdparty/thrift/lib/c_glib/test/testdebugproto.c b/depends/thirdparty/thrift/lib/c_glib/test/testdebugproto.c new file mode 100644 index 0000000..703dff0 --- /dev/null +++ b/depends/thirdparty/thrift/lib/c_glib/test/testdebugproto.c @@ -0,0 +1,938 @@ +/* + * 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 <assert.h> +#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, ==, 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] = + { + 1100087778366101931, 1779979416004714189, 2880067194370816120, + 4660046610375530309, 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", 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, ==, 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 */ + assert (g_type_is_a (T_TEST_TYPE_INHERITED_CLIENT, + T_TEST_TYPE_SRV_CLIENT)); + + /* TTestInheritedClient implements TTestSrvClient's interface */ + 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); + + assert (input_protocol == G_OBJECT(protocol)); + 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 (); +}
http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/d709f67d/depends/thirdparty/thrift/lib/c_glib/test/testframedtransport.c ---------------------------------------------------------------------- diff --git a/depends/thirdparty/thrift/lib/c_glib/test/testframedtransport.c b/depends/thirdparty/thrift/lib/c_glib/test/testframedtransport.c new file mode 100755 index 0000000..d50ff23 --- /dev/null +++ b/depends/thirdparty/thrift/lib/c_glib/test/testframedtransport.c @@ -0,0 +1,284 @@ +/* + * 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 <assert.h> +#include <netdb.h> +#include <sys/wait.h> + +#include <thrift/c_glib/transport/thrift_transport.h> +#include <thrift/c_glib/transport/thrift_socket.h> +#include <thrift/c_glib/transport/thrift_server_transport.h> +#include <thrift/c_glib/transport/thrift_server_socket.h> + +#define TEST_DATA { 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j' } + +#include "../src/thrift/c_glib/transport/thrift_framed_transport.c" + +static void thrift_server (const int port); + +/* test object creation and destruction */ +static void +test_create_and_destroy(void) +{ + ThriftTransport *transport = NULL; + guint r_buf_size = 0; + guint w_buf_size = 0; + + GObject *object = NULL; + object = g_object_new (THRIFT_TYPE_FRAMED_TRANSPORT, NULL); + assert (object != NULL); + g_object_get (G_OBJECT (object), "transport", &transport, + "r_buf_size", &r_buf_size, + "w_buf_size", &w_buf_size, NULL); + g_object_unref (object); +} + +static void +test_open_and_close(void) +{ + ThriftSocket *tsocket = NULL; + ThriftTransport *transport = NULL; + GError *err = NULL; + + /* create a ThriftSocket */ + tsocket = g_object_new (THRIFT_TYPE_SOCKET, "hostname", "localhost", + "port", 51188, NULL); + + /* create a BufferedTransport wrapper of the Socket */ + transport = g_object_new (THRIFT_TYPE_FRAMED_TRANSPORT, + "transport", THRIFT_TRANSPORT (tsocket), NULL); + + /* this shouldn't work */ + assert (thrift_framed_transport_open (transport, NULL) == FALSE); + assert (thrift_framed_transport_is_open (transport) == TRUE); + assert (thrift_framed_transport_close (transport, NULL) == TRUE); + g_object_unref (transport); + g_object_unref (tsocket); + + /* try and underlying socket failure */ + tsocket = g_object_new (THRIFT_TYPE_SOCKET, "hostname", "localhost.broken", + NULL); + + /* create a BufferedTransport wrapper of the Socket */ + transport = g_object_new (THRIFT_TYPE_FRAMED_TRANSPORT, + "transport", THRIFT_TRANSPORT (tsocket), NULL); + + assert (thrift_framed_transport_open (transport, &err) == FALSE); + g_object_unref (transport); + g_object_unref (tsocket); + g_error_free (err); + err = NULL; +} + +static void +test_read_and_write(void) +{ + int status; + pid_t pid; + ThriftSocket *tsocket = NULL; + ThriftTransport *transport = NULL; + int port = 51199; + guchar buf[10] = TEST_DATA; /* a buffer */ + + pid = fork (); + assert ( pid >= 0 ); + + if ( pid == 0 ) + { + /* child listens */ + thrift_server (port); + exit (0); + } else { + /* parent connects, wait a bit for the socket to be created */ + sleep (1); + + tsocket = g_object_new (THRIFT_TYPE_SOCKET, "hostname", "localhost", + "port", port, NULL); + transport = g_object_new (THRIFT_TYPE_FRAMED_TRANSPORT, + "transport", THRIFT_TRANSPORT (tsocket), + "w_buf_size", 4, NULL); + + assert (thrift_framed_transport_open (transport, NULL) == TRUE); + assert (thrift_framed_transport_is_open (transport)); + + /* write 10 bytes */ + thrift_framed_transport_write (transport, buf, 10, NULL); + thrift_framed_transport_flush (transport, NULL); + + thrift_framed_transport_write (transport, buf, 1, NULL); + thrift_framed_transport_flush (transport, NULL); + + thrift_framed_transport_write (transport, buf, 10, NULL); + thrift_framed_transport_flush (transport, NULL); + + thrift_framed_transport_write (transport, buf, 10, NULL); + thrift_framed_transport_flush (transport, NULL); + + thrift_framed_transport_write_end (transport, NULL); + thrift_framed_transport_flush (transport, NULL); + thrift_framed_transport_close (transport, NULL); + + g_object_unref (transport); + g_object_unref (tsocket); + + assert ( wait (&status) == pid ); + assert ( status == 0 ); + } +} + +/* test reading from the transport after the peer has unexpectedly + closed the connection */ +static void +test_read_after_peer_close(void) +{ + int status; + pid_t pid; + int port = 51199; + GError *err = NULL; + + pid = fork (); + g_assert (pid >= 0); + + if (pid == 0) + { + ThriftServerTransport *server_transport = NULL; + ThriftTransport *client_transport = NULL; + + /* child listens */ + server_transport = g_object_new (THRIFT_TYPE_SERVER_SOCKET, + "port", port, + NULL); + g_assert (server_transport != NULL); + + thrift_server_transport_listen (server_transport, &err); + g_assert (err == NULL); + + /* wrap the client transport in a ThriftFramedTransport */ + client_transport = g_object_new + (THRIFT_TYPE_FRAMED_TRANSPORT, + "transport", thrift_server_transport_accept (server_transport, &err), + "r_buf_size", 0, + NULL); + g_assert (err == NULL); + g_assert (client_transport != NULL); + + /* close the connection immediately after the client connects */ + thrift_transport_close (client_transport, NULL); + + g_object_unref (client_transport); + g_object_unref (server_transport); + + exit (0); + } else { + ThriftSocket *tsocket = NULL; + ThriftTransport *transport = NULL; + guchar buf[10]; /* a buffer */ + + /* parent connects, wait a bit for the socket to be created */ + sleep (1); + + tsocket = g_object_new (THRIFT_TYPE_SOCKET, + "hostname", "localhost", + "port", port, + NULL); + transport = g_object_new (THRIFT_TYPE_FRAMED_TRANSPORT, + "transport", THRIFT_TRANSPORT (tsocket), + "w_buf_size", 0, + NULL); + + g_assert (thrift_transport_open (transport, NULL) == TRUE); + g_assert (thrift_transport_is_open (transport)); + + /* attempting to read from the transport after the peer has closed + the connection fails gracefully without generating a critical + warning or segmentation fault */ + thrift_transport_read (transport, buf, 10, &err); + g_assert (err != NULL); + + g_error_free (err); + err = NULL; + + thrift_transport_read_end (transport, &err); + g_assert (err == NULL); + + thrift_transport_close (transport, &err); + g_assert (err == NULL); + + g_object_unref (transport); + g_object_unref (tsocket); + + g_assert (wait (&status) == pid); + g_assert (status == 0); + } +} + +static void +thrift_server (const int port) +{ + int bytes = 0; + ThriftServerTransport *transport = NULL; + ThriftTransport *client = NULL; + guchar buf[12]; /* a buffer */ + guchar match[10] = TEST_DATA; + + ThriftServerSocket *tsocket = g_object_new (THRIFT_TYPE_SERVER_SOCKET, + "port", port, NULL); + + transport = THRIFT_SERVER_TRANSPORT (tsocket); + thrift_server_transport_listen (transport, NULL); + + /* wrap the client in a BufferedTransport */ + client = g_object_new (THRIFT_TYPE_FRAMED_TRANSPORT, "transport", + thrift_server_transport_accept (transport, NULL), + "r_buf_size", 5, NULL); + assert (client != NULL); + + /* read 10 bytes */ + bytes = thrift_framed_transport_read (client, buf, 10, NULL); + assert (bytes == 10); /* make sure we've read 10 bytes */ + assert ( memcmp (buf, match, 10) == 0 ); /* make sure what we got matches */ + + bytes = thrift_framed_transport_read (client, buf, 6, NULL); + bytes = thrift_framed_transport_read (client, buf, 5, NULL); + bytes = thrift_framed_transport_read (client, buf, 1, NULL); + + bytes = thrift_framed_transport_read (client, buf, 12, NULL); + + thrift_framed_transport_read_end (client, NULL); + thrift_framed_transport_close (client, NULL); + g_object_unref (client); + g_object_unref (tsocket); +} + +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 ("/testframedtransport/CreateAndDestroy", test_create_and_destroy); + g_test_add_func ("/testframedtransport/OpenAndClose", test_open_and_close); + g_test_add_func ("/testframedtransport/ReadAndWrite", test_read_and_write); + g_test_add_func ("/testframedtransport/ReadAfterPeerClose", test_read_after_peer_close); + + return g_test_run (); +} http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/d709f67d/depends/thirdparty/thrift/lib/c_glib/test/testmemorybuffer.c ---------------------------------------------------------------------- diff --git a/depends/thirdparty/thrift/lib/c_glib/test/testmemorybuffer.c b/depends/thirdparty/thrift/lib/c_glib/test/testmemorybuffer.c new file mode 100755 index 0000000..5c75273 --- /dev/null +++ b/depends/thirdparty/thrift/lib/c_glib/test/testmemorybuffer.c @@ -0,0 +1,98 @@ +/* + * 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 <assert.h> +#include <netdb.h> + +#include <thrift/c_glib/transport/thrift_transport.h> +#include <thrift/c_glib/transport/thrift_socket.h> +#include <thrift/c_glib/transport/thrift_server_transport.h> +#include <thrift/c_glib/transport/thrift_server_socket.h> + +#define TEST_DATA { 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j' } + +#include "../src/thrift/c_glib/transport/thrift_memory_buffer.c" + +/* test object creation and destruction */ +static void +test_create_and_destroy(void) +{ + GObject *object = NULL; + object = g_object_new (THRIFT_TYPE_MEMORY_BUFFER, NULL); + assert (object != NULL); + g_object_unref (object); +} + +static void +test_open_and_close(void) +{ + ThriftMemoryBuffer *tbuffer = NULL; + + /* create a ThriftMemoryBuffer */ + tbuffer = g_object_new (THRIFT_TYPE_MEMORY_BUFFER, NULL); + + /* this shouldn't work */ + assert (thrift_memory_buffer_open (THRIFT_TRANSPORT (tbuffer), NULL) == TRUE); + assert (thrift_memory_buffer_is_open (THRIFT_TRANSPORT (tbuffer)) == TRUE); + assert (thrift_memory_buffer_close (THRIFT_TRANSPORT (tbuffer), NULL) == TRUE); + g_object_unref (tbuffer); +} + +static void +test_read_and_write(void) +{ + ThriftMemoryBuffer *tbuffer = NULL; + guchar buf[10] = TEST_DATA; + guchar read[10]; + GError *error = NULL; + + tbuffer = g_object_new (THRIFT_TYPE_MEMORY_BUFFER, "buf_size", 5, NULL); + assert (thrift_memory_buffer_write (THRIFT_TRANSPORT (tbuffer), + (gpointer) buf, + 10, &error) == FALSE); + assert (error != NULL); + g_error_free (error); + error = NULL; + g_object_unref (tbuffer); + + tbuffer = g_object_new (THRIFT_TYPE_MEMORY_BUFFER, "buf_size", 15, NULL); + assert (thrift_memory_buffer_write (THRIFT_TRANSPORT (tbuffer), + (gpointer) buf, 10, &error) == TRUE); + assert (error == NULL); + + assert (thrift_memory_buffer_read (THRIFT_TRANSPORT (tbuffer), + &read, 10, &error) > 0); + assert (error == NULL); +} + +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 ("/testmemorybuffer/CreateAndDestroy", test_create_and_destroy); + g_test_add_func ("/testmemorybuffer/OpenAndClose", test_open_and_close); + g_test_add_func ("/testmemorybuffer/ReadAndWrite", test_read_and_write); + + return g_test_run (); +} http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/d709f67d/depends/thirdparty/thrift/lib/c_glib/test/testoptionalrequired.c ---------------------------------------------------------------------- diff --git a/depends/thirdparty/thrift/lib/c_glib/test/testoptionalrequired.c b/depends/thirdparty/thrift/lib/c_glib/test/testoptionalrequired.c new file mode 100755 index 0000000..ae0c3d2 --- /dev/null +++ b/depends/thirdparty/thrift/lib/c_glib/test/testoptionalrequired.c @@ -0,0 +1,207 @@ +/* + * 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 <assert.h> +#include <glib.h> + +#include <thrift/c_glib/thrift_struct.h> +#include <thrift/c_glib/protocol/thrift_protocol.h> +#include <thrift/c_glib/protocol/thrift_binary_protocol.h> +#include <thrift/c_glib/transport/thrift_memory_buffer.h> +#include "gen-c_glib/t_test_optional_required_test_types.h" + +#include "gen-c_glib/t_test_optional_required_test_types.c" + +static void +write_to_read (ThriftStruct *w, ThriftStruct *r, GError **write_error, + GError **read_error) +{ + ThriftMemoryBuffer *tbuffer = NULL; + ThriftProtocol *protocol = NULL; + + tbuffer = g_object_new (THRIFT_TYPE_MEMORY_BUFFER, NULL); + protocol = g_object_new (THRIFT_TYPE_BINARY_PROTOCOL, "transport", + tbuffer, NULL); + + thrift_struct_write (w, protocol, write_error); + thrift_struct_read (r, protocol, read_error); + + g_object_unref (protocol); + g_object_unref (tbuffer); +} + +static void +test_old_school1 (void) +{ + TTestOldSchool *o = NULL; + + o = g_object_new (T_TEST_TYPE_OLD_SCHOOL, NULL); + o->im_int = 10; + o->im_str = g_strdup ("test"); + o->im_big = g_ptr_array_new (); + g_ptr_array_free (o->im_big, TRUE); + o->im_big = NULL; + g_free (o->im_str); + o->im_str = NULL; + g_object_unref (o); +} + +/** + * Write to read with optional fields + */ +static void +test_simple (void) +{ + TTestSimple *s1 = NULL, *s2 = NULL, *s3 = NULL; + + s1 = g_object_new (T_TEST_TYPE_SIMPLE, NULL); + s2 = g_object_new (T_TEST_TYPE_SIMPLE, NULL); + s3 = g_object_new (T_TEST_TYPE_SIMPLE, NULL); + + /* write-to-read with optional fields */ + s1->im_optional = 10; + assert (s1->__isset_im_default == FALSE); + assert (s1->__isset_im_optional == FALSE); + write_to_read (THRIFT_STRUCT (s1), THRIFT_STRUCT (s2), NULL, NULL); + assert (s2->__isset_im_default = TRUE); + assert (s2->__isset_im_optional == FALSE); + assert (s2->im_optional == 0); + + s1->__isset_im_optional = TRUE; + write_to_read (THRIFT_STRUCT (s1), THRIFT_STRUCT (s3), NULL, NULL); + assert (s3->__isset_im_default == TRUE); + assert (s3->__isset_im_optional == TRUE); + assert (s3->im_optional == 10); + + g_object_unref (s1); + g_object_unref (s2); +} + +/** + * Writing between optional and default + */ +static void +test_tricky1 (void) +{ + TTestTricky1 *t1 = NULL; + TTestTricky2 *t2 = NULL; + + t1 = g_object_new (T_TEST_TYPE_TRICKY1, NULL); + t2 = g_object_new (T_TEST_TYPE_TRICKY2, NULL); + + t2->im_optional = 10; + write_to_read (THRIFT_STRUCT (t2), THRIFT_STRUCT (t1), NULL, NULL); + write_to_read (THRIFT_STRUCT (t1), THRIFT_STRUCT (t2), NULL, NULL); + + assert (t1->__isset_im_default == FALSE); + assert (t2->__isset_im_optional == TRUE); + assert (t1->im_default == t2->im_optional); + assert (t1->im_default == 0); + + g_object_unref (t1); + g_object_unref (t2); +} + +/** + * Writing between default and required. + */ +static void +test_tricky2 (void) +{ + TTestTricky1 *t1 = NULL; + TTestTricky3 *t3 = NULL; + + t1 = g_object_new (T_TEST_TYPE_TRICKY1, NULL); + t3 = g_object_new (T_TEST_TYPE_TRICKY3, NULL); + + write_to_read (THRIFT_STRUCT (t1), THRIFT_STRUCT (t3), NULL, NULL); + write_to_read (THRIFT_STRUCT (t3), THRIFT_STRUCT (t1), NULL, NULL); + + assert (t1->__isset_im_default == TRUE); + + g_object_unref (t1); + g_object_unref (t3); +} + +/** + * Writing between optional and required. + */ +static void +test_tricky3 (void) +{ + TTestTricky2 *t2 = NULL; + TTestTricky3 *t3 = NULL; + + t2 = g_object_new (T_TEST_TYPE_TRICKY2, NULL); + t3 = g_object_new (T_TEST_TYPE_TRICKY3, NULL); + + t2->__isset_im_optional = TRUE; + + write_to_read (THRIFT_STRUCT (t2), THRIFT_STRUCT (t3), NULL, NULL); + write_to_read (THRIFT_STRUCT (t3), THRIFT_STRUCT (t2), NULL, NULL); + + g_object_unref (t2); + g_object_unref (t3); +} + +/** + * Catch an optional not set exception. To quote the + * C++ test, "Mu-hu-ha-ha-ha!" + */ +static void +test_tricky4 (void) +{ + TTestTricky2 *t2 = NULL; + TTestTricky3 *t3 = NULL; + GError *read_error = NULL; + + t2 = g_object_new (T_TEST_TYPE_TRICKY2, NULL); + t3 = g_object_new (T_TEST_TYPE_TRICKY3, NULL); + + /* throws protocol exception */ + write_to_read (THRIFT_STRUCT (t2), THRIFT_STRUCT (t3), NULL, &read_error); + assert (read_error != NULL); + g_error_free (read_error); + + write_to_read (THRIFT_STRUCT (t3), THRIFT_STRUCT (t2), NULL, NULL); + + assert (t2->__isset_im_optional); + + g_object_unref (t2); + g_object_unref (t3); +} + +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 ("/testoptionalrequired/OldSchool", test_old_school1); + g_test_add_func ("/testoptionalrequired/Simple", test_simple); + g_test_add_func ("/testoptionalrequired/Tricky1", test_tricky1); + g_test_add_func ("/testoptionalrequired/Tricky2", test_tricky2); + g_test_add_func ("/testoptionalrequired/Tricky3", test_tricky3); + g_test_add_func ("/testoptionalrequired/Tricky4", test_tricky4); + + return g_test_run (); +} http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/d709f67d/depends/thirdparty/thrift/lib/c_glib/test/testsimpleserver.c ---------------------------------------------------------------------- diff --git a/depends/thirdparty/thrift/lib/c_glib/test/testsimpleserver.c b/depends/thirdparty/thrift/lib/c_glib/test/testsimpleserver.c new file mode 100755 index 0000000..3af2eeb --- /dev/null +++ b/depends/thirdparty/thrift/lib/c_glib/test/testsimpleserver.c @@ -0,0 +1,123 @@ +/* + * 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 <assert.h> +#include <glib.h> +#include <stdlib.h> +#include <unistd.h> +#include <sys/types.h> +#include <sys/wait.h> + +#include <thrift/c_glib/thrift.h> +#include <thrift/c_glib/processor/thrift_processor.h> +#include <thrift/c_glib/transport/thrift_server_socket.h> + +#define TEST_PORT 51199 + +#include <thrift/c_glib/server/thrift_simple_server.c> + +/* create a rudimentary processor */ +#define TEST_PROCESSOR_TYPE (test_processor_get_type ()) + +struct _TestProcessor +{ + ThriftProcessor parent; +}; +typedef struct _TestProcessor TestProcessor; + +struct _TestProcessorClass +{ + ThriftProcessorClass parent; +}; +typedef struct _TestProcessorClass TestProcessorClass; + +G_DEFINE_TYPE(TestProcessor, test_processor, THRIFT_TYPE_PROCESSOR) + +gboolean +test_processor_process (ThriftProcessor *processor, ThriftProtocol *in, + ThriftProtocol *out, GError **error) +{ + THRIFT_UNUSED_VAR (processor); + THRIFT_UNUSED_VAR (in); + THRIFT_UNUSED_VAR (out); + THRIFT_UNUSED_VAR (error); + + return FALSE; +} + +static void +test_processor_init (TestProcessor *p) +{ + THRIFT_UNUSED_VAR (p); +} + +static void +test_processor_class_init (TestProcessorClass *proc) +{ + (THRIFT_PROCESSOR_CLASS(proc))->process = test_processor_process; +} + +static void +test_server (void) +{ + int status; + pid_t pid; + TestProcessor *p = NULL; + ThriftServerSocket *tss = NULL; + ThriftSimpleServer *ss = NULL; + + p = g_object_new (TEST_PROCESSOR_TYPE, NULL); + tss = g_object_new (THRIFT_TYPE_SERVER_SOCKET, "port", TEST_PORT, NULL); + ss = g_object_new (THRIFT_TYPE_SIMPLE_SERVER, "processor", p, + "server_transport", THRIFT_SERVER_TRANSPORT (tss), NULL); + + /* run the server in a child process */ + pid = fork (); + assert (pid >= 0); + + if (pid == 0) + { + THRIFT_SERVER_GET_CLASS (THRIFT_SERVER (ss))->serve (THRIFT_SERVER (ss), + NULL); + exit (0); + } else { + sleep (5); + kill (pid, SIGINT); + + g_object_unref (ss); + g_object_unref (tss); + g_object_unref (p); + assert (wait (&status) == pid); + assert (status == SIGINT); + } +} + +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 ("/testsimpleserver/SimpleServer", test_server); + + return g_test_run (); +} http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/d709f67d/depends/thirdparty/thrift/lib/c_glib/test/teststruct.c ---------------------------------------------------------------------- diff --git a/depends/thirdparty/thrift/lib/c_glib/test/teststruct.c b/depends/thirdparty/thrift/lib/c_glib/test/teststruct.c new file mode 100755 index 0000000..5d4baf3 --- /dev/null +++ b/depends/thirdparty/thrift/lib/c_glib/test/teststruct.c @@ -0,0 +1,112 @@ +/* + * 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 <assert.h> +#include <glib-object.h> + +#include "../src/thrift/c_glib/thrift_struct.c" + +/* tests to ensure we can extend a ThriftStruct */ + +struct _ThriftTestStruct +{ + ThriftStruct parent; +}; +typedef struct _ThriftTestStruct ThriftTestStruct; + +struct _ThriftTestStructClass +{ + ThriftStructClass parent; +}; +typedef struct _ThriftTestStructClass ThriftTestStructClass; + +GType thrift_test_struct_get_type (void); + +#define THRIFT_TYPE_TEST_STRUCT (thrift_test_struct_get_type ()) +#define THRIFT_TEST_STRUCT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), THRIFT_TYPE_TEST_STRUCT, ThriftTestStruct)) +#define THRIFT_TEST_STRUCT_CLASS(c) (G_TYPE_CHECK_CLASS_CAST ((c), THRIFT_TYPE_TEST_STRUCT, ThriftTestStructClass)) +#define THRIFT_IS_TEST_STRUCT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), THRIFT_TYPE_TEST_STRUCT)) +#define THRIFT_IS_TEST_STRUCT_CLASS(c) (G_TYPE_CHECK_CLASS_TYPE ((c), THRIFT_TYPE_TEST_STRUCT)) +#define THRIFT_TEST_STRUCT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), THRIFT_TYPE_TEST_STRUCT, ThriftTestStructClass)) + +G_DEFINE_TYPE(ThriftTestStruct, thrift_test_struct, THRIFT_TYPE_STRUCT) + +gint32 +thrift_test_struct_read (ThriftStruct *object, ThriftProtocol *protocol, + GError **error) +{ + THRIFT_UNUSED_VAR (object); + THRIFT_UNUSED_VAR (protocol); + THRIFT_UNUSED_VAR (error); + + return 0; +} + +gint32 +thrift_test_struct_write (ThriftStruct *object, ThriftProtocol *protocol, + GError **error) +{ + THRIFT_UNUSED_VAR (object); + THRIFT_UNUSED_VAR (protocol); + THRIFT_UNUSED_VAR (error); + + return 0; +} + +static void +thrift_test_struct_class_init (ThriftTestStructClass *cls) +{ + ThriftStructClass *ts_cls = THRIFT_STRUCT_CLASS (cls); + ts_cls->read = thrift_test_struct_read; + ts_cls->write = thrift_test_struct_write; +} + +static void +thrift_test_struct_init (ThriftTestStruct *s) +{ + THRIFT_UNUSED_VAR (s); +} + +static void +test_initialize_object (void) +{ + ThriftTestStruct *t = NULL; + + t = g_object_new (THRIFT_TYPE_TEST_STRUCT, NULL); + assert ( THRIFT_IS_STRUCT (t)); + thrift_struct_read (THRIFT_STRUCT (t), NULL, NULL); + thrift_struct_write (THRIFT_STRUCT (t), NULL, NULL); + thrift_test_struct_read (THRIFT_STRUCT (t), NULL, NULL); + thrift_test_struct_write (THRIFT_STRUCT (t), NULL, NULL); + g_object_unref (t); +} + +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 ("/teststruct/InitializeObject", test_initialize_object); + + return g_test_run (); +} http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/d709f67d/depends/thirdparty/thrift/lib/c_glib/test/testthrifttest.c ---------------------------------------------------------------------- diff --git a/depends/thirdparty/thrift/lib/c_glib/test/testthrifttest.c b/depends/thirdparty/thrift/lib/c_glib/test/testthrifttest.c new file mode 100755 index 0000000..5f0f6e3 --- /dev/null +++ b/depends/thirdparty/thrift/lib/c_glib/test/testthrifttest.c @@ -0,0 +1,31 @@ +#include <assert.h> +#include <netdb.h> + +#include <thrift/c_glib/transport/thrift_server_transport.h> +#include <thrift/c_glib/transport/thrift_server_socket.h> + +static const char TEST_ADDRESS[] = "localhost"; +static const int TEST_PORT = 64444; + +static void +test_thrift_server (void) +{ + ThriftServerSocket *tsocket = g_object_new (THRIFT_TYPE_SERVER_SOCKET, + "port", TEST_PORT, NULL); + + g_object_unref (tsocket); +} + +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 ("/testthrift/Server", test_thrift_server); + + return g_test_run (); +} http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/d709f67d/depends/thirdparty/thrift/lib/c_glib/test/testthrifttestclient.cpp ---------------------------------------------------------------------- diff --git a/depends/thirdparty/thrift/lib/c_glib/test/testthrifttestclient.cpp b/depends/thirdparty/thrift/lib/c_glib/test/testthrifttestclient.cpp new file mode 100755 index 0000000..e618fe9 --- /dev/null +++ b/depends/thirdparty/thrift/lib/c_glib/test/testthrifttestclient.cpp @@ -0,0 +1,627 @@ +/* + * 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. + */ + +/* test a C client with a C++ server */ + +#include <signal.h> +#include <sys/types.h> +#include <sys/wait.h> +#include <thrift/protocol/TBinaryProtocol.h> +#include <thrift/protocol/TDebugProtocol.h> +#include <thrift/server/TSimpleServer.h> +#include <thrift/transport/TServerSocket.h> +#include "ThriftTest.h" +#include "ThriftTest_types.h" + +#include <iostream> + +using namespace std; +using namespace boost; + +using namespace apache::thrift; +using namespace apache::thrift::concurrency; +using namespace apache::thrift::protocol; +using namespace apache::thrift::transport; +using namespace apache::thrift::server; + +using namespace thrift::test; + +#define TEST_PORT 9980 + +// Extra functions required for ThriftTest_types to work +namespace thrift { namespace test { + +bool Insanity::operator<(thrift::test::Insanity const& other) const { + using apache::thrift::ThriftDebugString; + return ThriftDebugString(*this) < ThriftDebugString(other); +} + +}} + +class TestHandler : public ThriftTestIf { + public: + TestHandler() {} + + void testVoid() { + printf("[C -> C++] testVoid()\n"); + } + + void testString(string& out, const string &thing) { + printf("[C -> C++] testString(\"%s\")\n", thing.c_str()); + out = thing; + } + + bool testBool(const bool thing) { + printf("[C -> C++] testBool(%s)\n", thing ? "true" : "false"); + return thing; + } + int8_t testByte(const int8_t thing) { + printf("[C -> C++] testByte(%d)\n", (int)thing); + return thing; + } + int32_t testI32(const int32_t thing) { + printf("[C -> C++] testI32(%d)\n", thing); + return thing; + } + + int64_t testI64(const int64_t thing) { + printf("[C -> C++] testI64(%ld)\n", thing); + return thing; + } + + double testDouble(const double thing) { + printf("[C -> C++] testDouble(%lf)\n", thing); + return thing; + } + + void testBinary(string& out, const string &thing) { + printf("[C -> C++] testBinary(\"%s\")\n", thing.c_str()); + out = thing; + } + + void testStruct(Xtruct& out, const Xtruct &thing) { + printf("[C -> C++] testStruct({\"%s\", %d, %d, %ld})\n", thing.string_thing.c_str(), (int)thing.byte_thing, thing.i32_thing, thing.i64_thing); + out = thing; + } + + void testNest(Xtruct2& out, const Xtruct2& nest) { + const Xtruct &thing = nest.struct_thing; + printf("[C -> C++] testNest({%d, {\"%s\", %d, %d, %ld}, %d})\n", (int)nest.byte_thing, thing.string_thing.c_str(), (int)thing.byte_thing, thing.i32_thing, thing.i64_thing, nest.i32_thing); + out = nest; + } + + void testMap(map<int32_t, int32_t> &out, const map<int32_t, int32_t> &thing) { + printf("[C -> C++] testMap({"); + map<int32_t, int32_t>::const_iterator m_iter; + bool first = true; + for (m_iter = thing.begin(); m_iter != thing.end(); ++m_iter) { + if (first) { + first = false; + } else { + printf(", "); + } + printf("%d => %d", m_iter->first, m_iter->second); + } + printf("})\n"); + out = thing; + } + + void testStringMap(map<std::string, std::string> &out, const map<std::string, std::string> &thing) { + printf("[C -> C++] testStringMap({"); + map<std::string, std::string>::const_iterator m_iter; + bool first = true; + for (m_iter = thing.begin(); m_iter != thing.end(); ++m_iter) { + if (first) { + first = false; + } else { + printf(", "); + } + printf("\"%s\" => \"%s\"", (m_iter->first).c_str(), (m_iter->second).c_str()); + } + printf("})\n"); + out = thing; + } + + + void testSet(set<int32_t> &out, const set<int32_t> &thing) { + printf("[C -> C++] testSet({"); + set<int32_t>::const_iterator s_iter; + bool first = true; + for (s_iter = thing.begin(); s_iter != thing.end(); ++s_iter) { + if (first) { + first = false; + } else { + printf(", "); + } + printf("%d", *s_iter); + } + printf("})\n"); + out = thing; + } + + void testList(vector<int32_t> &out, const vector<int32_t> &thing) { + printf("[C -> C++] testList({"); + vector<int32_t>::const_iterator l_iter; + bool first = true; + for (l_iter = thing.begin(); l_iter != thing.end(); ++l_iter) { + if (first) { + first = false; + } else { printf(", "); + } + printf("%d", *l_iter); + } + printf("})\n"); + out = thing; + } + + Numberz::type testEnum(const Numberz::type thing) { + printf("[C -> C++] testEnum(%d)\n", thing); + return thing; + } + + UserId testTypedef(const UserId thing) { + printf("[C -> C++] testTypedef(%ld)\n", thing); + return thing; } + + void testMapMap(map<int32_t, map<int32_t,int32_t> > &mapmap, const int32_t hello) { + printf("[C -> C++] testMapMap(%d)\n", hello); + + map<int32_t,int32_t> pos; + map<int32_t,int32_t> neg; + for (int i = 1; i < 5; i++) { + pos.insert(make_pair(i,i)); + neg.insert(make_pair(-i,-i)); + } + + mapmap.insert(make_pair(4, pos)); + mapmap.insert(make_pair(-4, neg)); + + } + + void testInsanity(map<UserId, map<Numberz::type,Insanity> > &insane, const Insanity &argument) { + THRIFT_UNUSED_VARIABLE (argument); + + printf("[C -> C++] testInsanity()\n"); + + Xtruct hello; + hello.string_thing = "Hello2"; + hello.byte_thing = 2; + hello.i32_thing = 2; + hello.i64_thing = 2; + + Xtruct goodbye; + goodbye.string_thing = "Goodbye4"; + goodbye.byte_thing = 4; + goodbye.i32_thing = 4; + goodbye.i64_thing = 4; + + Insanity crazy; + crazy.userMap.insert(make_pair(Numberz::EIGHT, 8)); + crazy.xtructs.push_back(goodbye); + + Insanity looney; + crazy.userMap.insert(make_pair(Numberz::FIVE, 5)); + crazy.xtructs.push_back(hello); + + map<Numberz::type, Insanity> first_map; + map<Numberz::type, Insanity> second_map; + + first_map.insert(make_pair(Numberz::TWO, crazy)); + first_map.insert(make_pair(Numberz::THREE, crazy)); + + second_map.insert(make_pair(Numberz::SIX, looney)); + + insane.insert(make_pair(1, first_map)); + insane.insert(make_pair(2, second_map)); + + printf("return"); + printf(" = {"); + map<UserId, map<Numberz::type,Insanity> >::const_iterator i_iter; + for (i_iter = insane.begin(); i_iter != insane.end(); ++i_iter) { + printf("%ld => {", i_iter->first); + map<Numberz::type,Insanity>::const_iterator i2_iter; + for (i2_iter = i_iter->second.begin(); + i2_iter != i_iter->second.end(); + ++i2_iter) { + printf("%d => {", i2_iter->first); + map<Numberz::type, UserId> userMap = i2_iter->second.userMap; + map<Numberz::type, UserId>::const_iterator um; + printf("{"); + for (um = userMap.begin(); um != userMap.end(); ++um) { + printf("%d => %ld, ", um->first, um->second); + } + printf("}, "); + + vector<Xtruct> xtructs = i2_iter->second.xtructs; + vector<Xtruct>::const_iterator x; + printf("{"); + for (x = xtructs.begin(); x != xtructs.end(); ++x) { + printf("{\"%s\", %d, %d, %ld}, ", x->string_thing.c_str(), (int)x->byte_thing, x->i32_thing, x->i64_thing); + } + printf("}"); + + printf("}, "); + } + printf("}, "); + } + printf("}\n"); + + + } + + void testMulti(Xtruct &hello, const int8_t arg0, const int32_t arg1, const int64_t arg2, const std::map<int16_t, std::string> &arg3, const Numberz::type arg4, const UserId arg5) { + THRIFT_UNUSED_VARIABLE (arg3); + THRIFT_UNUSED_VARIABLE (arg4); + THRIFT_UNUSED_VARIABLE (arg5); + + printf("[C -> C++] testMulti()\n"); + + hello.string_thing = "Hello2"; + hello.byte_thing = arg0; + hello.i32_thing = arg1; + hello.i64_thing = (int64_t)arg2; + } + + void testException(const std::string &arg) + throw(Xception, apache::thrift::TException) + { + printf("[C -> C++] testException(%s)\n", arg.c_str()); + if (arg.compare("Xception") == 0) { + Xception e; + e.errorCode = 1001; + e.message = arg; + throw e; + } else if (arg.compare("ApplicationException") == 0) { + apache::thrift::TException e; + throw e; + } else { + Xtruct result; + result.string_thing = arg; + return; + } + } + + void testMultiException(Xtruct &result, const std::string &arg0, const std::string &arg1) throw(Xception, Xception2) { + + printf("[C -> C++] testMultiException(%s, %s)\n", arg0.c_str(), arg1.c_str()); + + if (arg0.compare("Xception") == 0) { + Xception e; + e.errorCode = 1001; + e.message = "This is an Xception"; + throw e; + } else if (arg0.compare("Xception2") == 0) { + Xception2 e; + e.errorCode = 2002; + e.struct_thing.string_thing = "This is an Xception2"; + throw e; + } else { + result.string_thing = arg1; + return; + } + } + + void testOneway(int sleepFor) { + printf("testOneway(%d): Sleeping...\n", sleepFor); + sleep(sleepFor); + printf("testOneway(%d): done sleeping!\n", sleepFor); + } +}; + +// C CLIENT +extern "C" { + +#undef THRIFT_SOCKET /* from lib/cpp */ + +#include "t_test_thrift_test.h" +#include "t_test_thrift_test_types.h" +#include <thrift/c_glib/transport/thrift_socket.h> +#include <thrift/c_glib/protocol/thrift_protocol.h> +#include <thrift/c_glib/protocol/thrift_binary_protocol.h> + +static void +test_thrift_client (void) +{ + ThriftSocket *tsocket = NULL; + ThriftBinaryProtocol *protocol = NULL; + TTestThriftTestClient *client = NULL; + TTestThriftTestIf *iface = NULL; + GError *error = NULL; + gchar *string = NULL; + gint8 byte = 0; + gint16 i16 = 0; + gint32 i32 = 0, another_i32 = 56789; + gint64 i64 = 0; + double dbl = 0.0; + TTestXtruct *xtruct_in, *xtruct_out; + TTestXtruct2 *xtruct2_in, *xtruct2_out; + GHashTable *map_in = NULL, *map_out = NULL; + GHashTable *set_in = NULL, *set_out = NULL; + GArray *list_in = NULL, *list_out = NULL; + TTestNumberz enum_in, enum_out; + TTestUserId user_id_in, user_id_out; + GHashTable *insanity_in = NULL; + TTestXtruct *xtruct1, *xtruct2; + TTestInsanity *insanity_out = NULL; + TTestXtruct *multi_in = NULL; + GHashTable *multi_map_out = NULL; + TTestXception *xception = NULL; + TTestXception2 *xception2 = NULL; + +#if (!GLIB_CHECK_VERSION (2, 36, 0)) + // initialize gobject + g_type_init (); +#endif + + // create a C client + tsocket = (ThriftSocket *) g_object_new (THRIFT_TYPE_SOCKET, + "hostname", "localhost", + "port", TEST_PORT, NULL); + protocol = (ThriftBinaryProtocol *) g_object_new (THRIFT_TYPE_BINARY_PROTOCOL, + "transport", + tsocket, NULL); + client = (TTestThriftTestClient *) g_object_new (T_TEST_TYPE_THRIFT_TEST_CLIENT, "input_protocol", protocol, "output_protocol", protocol, NULL); + iface = T_TEST_THRIFT_TEST_IF (client); + + // open and send + thrift_transport_open (THRIFT_TRANSPORT(tsocket), NULL); + + assert (t_test_thrift_test_client_test_void (iface, &error) == TRUE); + assert (error == NULL); + + assert (t_test_thrift_test_client_test_string (iface, &string, "test123", &error) == TRUE); + assert (strcmp (string, "test123") == 0); + g_free (string); + assert (error == NULL); + + assert (t_test_thrift_test_client_test_byte (iface, &byte, (gint8) 5, &error) == TRUE); + assert (byte == 5); + assert (error == NULL); + + assert (t_test_thrift_test_client_test_i32 (iface, &i32, 123, &error) == TRUE); + assert (i32 == 123); + assert (error == NULL); + + assert (t_test_thrift_test_client_test_i64 (iface, &i64, 12345, &error) == TRUE); + assert (i64 == 12345); + assert (error == NULL); + + assert (t_test_thrift_test_client_test_double (iface, &dbl, 5.6, &error) == TRUE); + assert (dbl == 5.6); + assert (error == NULL); + + xtruct_out = (TTestXtruct *) g_object_new (T_TEST_TYPE_XTRUCT, NULL); + xtruct_out->byte_thing = 1; + xtruct_out->__isset_byte_thing = TRUE; + xtruct_out->i32_thing = 15; + xtruct_out->__isset_i32_thing = TRUE; + xtruct_out->i64_thing = 151; + xtruct_out->__isset_i64_thing = TRUE; + xtruct_out->string_thing = g_strdup ("abc123"); + xtruct_out->__isset_string_thing = TRUE; + xtruct_in = (TTestXtruct *) g_object_new(T_TEST_TYPE_XTRUCT, NULL); + assert (t_test_thrift_test_client_test_struct (iface, &xtruct_in, xtruct_out, &error) == TRUE); + assert (error == NULL); + + xtruct2_out = (TTestXtruct2 *) g_object_new (T_TEST_TYPE_XTRUCT2, NULL); + xtruct2_out->byte_thing = 1; + xtruct2_out->__isset_byte_thing = TRUE; + if (xtruct2_out->struct_thing != NULL) + g_object_unref(xtruct2_out->struct_thing); + xtruct2_out->struct_thing = xtruct_out; + xtruct2_out->__isset_struct_thing = TRUE; + xtruct2_out->i32_thing = 123; + xtruct2_out->__isset_i32_thing = TRUE; + xtruct2_in = (TTestXtruct2 *) g_object_new (T_TEST_TYPE_XTRUCT2, NULL); + assert (t_test_thrift_test_client_test_nest (iface, &xtruct2_in, xtruct2_out, &error) == TRUE); + assert (error == NULL); + + g_object_unref (xtruct2_out); + g_object_unref (xtruct2_in); + g_object_unref (xtruct_in); + + map_out = g_hash_table_new (NULL, NULL); + map_in = g_hash_table_new (NULL, NULL); g_hash_table_insert (map_out, &i32, &i32); + assert (t_test_thrift_test_client_test_map (iface, &map_in, map_out, &error) == TRUE); + assert (error == NULL); + g_hash_table_destroy (map_out); + g_hash_table_destroy (map_in); + + map_out = g_hash_table_new (NULL, NULL); + map_in = g_hash_table_new (NULL, NULL); + g_hash_table_insert (map_out, g_strdup ("a"), g_strdup ("123")); + g_hash_table_insert (map_out, g_strdup ("a b"), g_strdup ("with spaces ")); + g_hash_table_insert (map_out, g_strdup ("same"), g_strdup ("same")); + g_hash_table_insert (map_out, g_strdup ("0"), g_strdup ("numeric key")); + assert (t_test_thrift_test_client_test_string_map (iface, &map_in, map_out, &error) == TRUE); + assert (error == NULL); + g_hash_table_destroy (map_out); + g_hash_table_destroy (map_in); + + set_out = g_hash_table_new (NULL, NULL); + set_in = g_hash_table_new (NULL, NULL); + g_hash_table_insert (set_out, &i32, &i32); + assert (t_test_thrift_test_client_test_set (iface, &set_in, set_out, &error) == TRUE); + assert (error == NULL); + g_hash_table_destroy (set_out); + g_hash_table_destroy (set_in); + + list_out = g_array_new(TRUE, TRUE, sizeof(gint32)); + list_in = g_array_new(TRUE, TRUE, sizeof(gint32)); + another_i32 = 456; + g_array_append_val (list_out, i32); + g_array_append_val (list_out, another_i32); + assert (t_test_thrift_test_client_test_list (iface, &list_in, list_out, &error) == TRUE); + assert (error == NULL); + g_array_free (list_out, TRUE); + g_array_free (list_in, TRUE); + + enum_out = T_TEST_NUMBERZ_ONE; + assert (t_test_thrift_test_client_test_enum (iface, &enum_in, enum_out, &error) == TRUE); + assert (enum_in == enum_out); + assert (error == NULL); + + user_id_out = 12345; + assert (t_test_thrift_test_client_test_typedef (iface, &user_id_in, user_id_out, &error) == TRUE); + assert (user_id_in == user_id_out); + assert (error == NULL); + + map_in = g_hash_table_new (NULL, NULL); + assert (t_test_thrift_test_client_test_map_map (iface, &map_in, i32, &error) == TRUE); + assert (error == NULL); + g_hash_table_destroy (map_in); + + // insanity + insanity_out = (TTestInsanity *) g_object_new (T_TEST_TYPE_INSANITY, NULL); + insanity_out->userMap = g_hash_table_new (NULL, NULL); + g_hash_table_insert (insanity_out->userMap, GINT_TO_POINTER (enum_out), &user_id_out); + + xtruct1 = (TTestXtruct *) g_object_new (T_TEST_TYPE_XTRUCT, NULL); + xtruct1->byte_thing = 1; + xtruct1->__isset_byte_thing = TRUE; + xtruct1->i32_thing = 15; + xtruct1->__isset_i32_thing = TRUE; + xtruct1->i64_thing = 151; + xtruct1->__isset_i64_thing = TRUE; + xtruct1->string_thing = g_strdup ("abc123"); + xtruct1->__isset_string_thing = TRUE; + xtruct2 = (TTestXtruct *) g_object_new (T_TEST_TYPE_XTRUCT, NULL); + xtruct2->byte_thing = 1; + xtruct2->__isset_byte_thing = TRUE; + xtruct2->i32_thing = 15; + xtruct2->__isset_i32_thing = TRUE; + xtruct2->i64_thing = 151; + xtruct2->__isset_i64_thing = TRUE; + xtruct2->string_thing = g_strdup ("abc123"); + xtruct2->__isset_string_thing = TRUE; + + insanity_in = g_hash_table_new (NULL, NULL); + g_ptr_array_add (insanity_out->xtructs, xtruct1); + g_ptr_array_add (insanity_out->xtructs, xtruct2); + assert (t_test_thrift_test_client_test_insanity (iface, &insanity_in, insanity_out, &error) == TRUE); + + g_hash_table_unref (insanity_in); + g_ptr_array_free (insanity_out->xtructs, TRUE); + + multi_map_out = g_hash_table_new (NULL, NULL); + string = g_strdup ("abc123"); + g_hash_table_insert (multi_map_out, &i16, string); + multi_in = (TTestXtruct *) g_object_new (T_TEST_TYPE_XTRUCT, NULL); + assert (t_test_thrift_test_client_test_multi (iface, &multi_in, byte, i32, i64, multi_map_out, enum_out, user_id_out, &error) == TRUE); + assert (multi_in->i32_thing == i32); + assert (multi_in->i64_thing == i64); + g_object_unref (multi_in); + g_hash_table_unref (multi_map_out); + g_free (string); + + assert (t_test_thrift_test_client_test_exception (iface, "Xception", &xception, &error) == FALSE); + assert (xception->errorCode == 1001); + g_error_free (error); + error = NULL; + g_object_unref (xception); + xception = NULL; + + assert (t_test_thrift_test_client_test_exception (iface, "ApplicationException", &xception, &error) == FALSE); + g_error_free (error); + error = NULL; + assert (xception == NULL); + + assert (t_test_thrift_test_client_test_exception (iface, "Test", &xception, &error) == TRUE); + assert (error == NULL); + + multi_in = (TTestXtruct*) g_object_new (T_TEST_TYPE_XTRUCT, NULL); + assert (t_test_thrift_test_client_test_multi_exception (iface, &multi_in, "Xception", NULL, &xception, &xception2, &error) == FALSE); + assert (xception->errorCode == 1001); + assert (xception2 == NULL); + g_error_free (error); + error = NULL; + g_object_unref (xception); + g_object_unref (multi_in); + xception = NULL; + multi_in = NULL; + + multi_in = (TTestXtruct*) g_object_new (T_TEST_TYPE_XTRUCT, NULL); + assert (t_test_thrift_test_client_test_multi_exception (iface, &multi_in, "Xception2", NULL, &xception, &xception2, &error) == FALSE); + assert (xception2->errorCode == 2002); + assert (xception == NULL); + g_error_free (error); + error = NULL; + g_object_unref (xception2); + g_object_unref (multi_in); + xception2 = NULL; + multi_in = NULL; + + multi_in = (TTestXtruct*) g_object_new (T_TEST_TYPE_XTRUCT, NULL); + assert (t_test_thrift_test_client_test_multi_exception (iface, &multi_in, NULL , NULL, &xception, &xception2, &error) == TRUE); + assert (error == NULL); + g_object_unref(multi_in); + multi_in = NULL; + + assert (t_test_thrift_test_client_test_oneway (iface, 1, &error) == TRUE); + assert (error == NULL); + + /* sleep to let the oneway call go through */ + sleep (5); + + thrift_transport_close (THRIFT_TRANSPORT(tsocket), NULL); + g_object_unref (client); + g_object_unref (protocol); + g_object_unref (tsocket); +} + + +} /* extern "C" */ + + +static void +bailout (int signum) +{ + THRIFT_UNUSED_VARIABLE (signum); + + exit (1); +} + +int +main (void) +{ + int status; + int pid = fork (); + assert (pid >= 0); + + if (pid == 0) /* child */ + { + boost::shared_ptr<TProtocolFactory> protocolFactory(new TBinaryProtocolFactory()); + boost::shared_ptr<TestHandler> testHandler(new TestHandler()); + boost::shared_ptr<ThriftTestProcessor> testProcessor(new ThriftTestProcessor(testHandler)); + boost::shared_ptr<TServerSocket> serverSocket(new TServerSocket(TEST_PORT)); + boost::shared_ptr<TTransportFactory> transportFactory(new TBufferedTransportFactory()); + TSimpleServer simpleServer(testProcessor, serverSocket, transportFactory, protocolFactory); + signal (SIGALRM, bailout); + alarm (60); + simpleServer.serve(); + } else { + sleep (1); + test_thrift_client (); + kill (pid, SIGINT); + assert (wait (&status) == pid); + } + + return 0; +} + http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/d709f67d/depends/thirdparty/thrift/lib/c_glib/test/testtransportsocket.c ---------------------------------------------------------------------- diff --git a/depends/thirdparty/thrift/lib/c_glib/test/testtransportsocket.c b/depends/thirdparty/thrift/lib/c_glib/test/testtransportsocket.c new file mode 100755 index 0000000..d91507f --- /dev/null +++ b/depends/thirdparty/thrift/lib/c_glib/test/testtransportsocket.c @@ -0,0 +1,323 @@ +/* + * 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 <assert.h> +#include <netdb.h> +#include <sys/wait.h> + +#include <thrift/c_glib/transport/thrift_transport.h> +#include <thrift/c_glib/transport/thrift_buffered_transport.h> +#include <thrift/c_glib/transport/thrift_server_transport.h> +#include <thrift/c_glib/transport/thrift_server_socket.h> + +#define TEST_DATA { 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j' } + +/* substituted functions to test failures of system and library calls */ +static int socket_error = 0; +int +my_socket(int domain, int type, int protocol) +{ + if (socket_error == 0) + { + return socket (domain, type, protocol); + } + return -1; +} + +static int recv_error = 0; +ssize_t +my_recv(int socket, void *buffer, size_t length, int flags) +{ + if (recv_error == 0) + { + return recv (socket, buffer, length, flags); + } + return -1; +} + +static int send_error = 0; +ssize_t +my_send(int socket, const void *buffer, size_t length, int flags) +{ + if (send_error == 0) + { + return send (socket, buffer, length, flags); + } + return -1; +} + +#define socket my_socket +#define recv my_recv +#define send my_send +#include "../src/thrift/c_glib/transport/thrift_socket.c" +#undef socket +#undef recv +#undef send + +static void thrift_socket_server (const int port); + +/* test object creation and destruction */ +static void +test_create_and_destroy(void) +{ + gchar *hostname = NULL; + guint port = 0; + + GObject *object = NULL; + object = g_object_new (THRIFT_TYPE_SOCKET, NULL); + assert (object != NULL); + g_object_get (G_OBJECT(object), "hostname", &hostname, "port", &port, NULL); + g_free (hostname); + + g_object_unref (object); +} + +static void +test_open_and_close(void) +{ + ThriftSocket *tsocket = NULL; + ThriftTransport *transport = NULL; + GError *err = NULL; + + /* open a connection and close it */ + tsocket = g_object_new (THRIFT_TYPE_SOCKET, "hostname", "localhost", + "port", 51188, NULL); + transport = THRIFT_TRANSPORT (tsocket); + thrift_socket_open (transport, NULL); + assert (thrift_socket_is_open (transport) == TRUE); + thrift_socket_close (transport, NULL); + assert (thrift_socket_is_open (transport) == FALSE); + + /* test close failure */ + tsocket->sd = -1; + thrift_socket_close (transport, NULL); + g_object_unref (tsocket); + + /* try a hostname lookup failure */ + tsocket = g_object_new (THRIFT_TYPE_SOCKET, "hostname", "localhost.broken", + NULL); + transport = THRIFT_TRANSPORT (tsocket); + assert (thrift_socket_open (transport, &err) == FALSE); + g_object_unref (tsocket); + g_error_free (err); + err = NULL; + + /* try an error call to socket() */ + tsocket = g_object_new (THRIFT_TYPE_SOCKET, "hostname", "localhost", NULL); + transport = THRIFT_TRANSPORT (tsocket); + socket_error = 1; + assert (thrift_socket_open (transport, &err) == FALSE); + socket_error = 0; + g_object_unref (tsocket); + g_error_free (err); +} + +static void +test_read_and_write(void) +{ + int status; + pid_t pid; + ThriftSocket *tsocket = NULL; + ThriftTransport *transport = NULL; + int port = 51199; + guchar buf[10] = TEST_DATA; /* a buffer */ + + pid = fork (); + assert ( pid >= 0 ); + + if ( pid == 0 ) + { + /* child listens */ + thrift_socket_server (port); + exit (0); + } else { + /* parent connects, wait a bit for the socket to be created */ + sleep (1); + + tsocket = g_object_new (THRIFT_TYPE_SOCKET, "hostname", "localhost", + "port", port, NULL); + transport = THRIFT_TRANSPORT (tsocket); + assert (thrift_socket_open (transport, NULL) == TRUE); + assert (thrift_socket_is_open (transport)); + thrift_socket_write (transport, buf, 10, NULL); + + /* write fail */ + send_error = 1; + thrift_socket_write (transport, buf, 1, NULL); + send_error = 0; + + thrift_socket_write_end (transport, NULL); + thrift_socket_flush (transport, NULL); + thrift_socket_close (transport, NULL); + g_object_unref (tsocket); + + assert ( wait (&status) == pid ); + assert ( status == 0 ); + } +} + +/* test ThriftSocket's peek() implementation */ +static void +test_peek(void) +{ + gint status; + pid_t pid; + guint port = 51199; + gchar data = 'A'; + ThriftTransport *client_transport; + GError *error = NULL; + + client_transport = g_object_new (THRIFT_TYPE_SOCKET, + "hostname", "localhost", + "port", port, + NULL); + + /* thrift_transport_peek returns FALSE when the socket is closed */ + g_assert (thrift_transport_is_open (client_transport) == FALSE); + g_assert (thrift_transport_peek (client_transport, &error) == FALSE); + g_assert (error == NULL); + + pid = fork (); + g_assert (pid >= 0); + + if (pid == 0) + { + ThriftServerTransport *server_transport = NULL; + + g_object_unref (client_transport); + + /* child listens */ + server_transport = g_object_new (THRIFT_TYPE_SERVER_SOCKET, + "port", port, + NULL); + g_assert (server_transport != NULL); + + thrift_server_transport_listen (server_transport, &error); + g_assert (error == NULL); + + client_transport = g_object_new + (THRIFT_TYPE_BUFFERED_TRANSPORT, + "transport", thrift_server_transport_accept (server_transport, &error), + "r_buf_size", 0, + "w_buf_size", sizeof data, + NULL); + g_assert (error == NULL); + g_assert (client_transport != NULL); + + /* write exactly one character to the client */ + g_assert (thrift_transport_write (client_transport, + &data, + sizeof data, + &error) == TRUE); + + thrift_transport_flush (client_transport, &error); + thrift_transport_write_end (client_transport, &error); + thrift_transport_close (client_transport, &error); + + g_object_unref (client_transport); + g_object_unref (server_transport); + + exit (0); + } + else { + /* parent connects, wait a bit for the socket to be created */ + sleep (1); + + /* connect to the child */ + thrift_transport_open (client_transport, &error); + g_assert (error == NULL); + g_assert (thrift_transport_is_open (client_transport) == TRUE); + + /* thrift_transport_peek returns TRUE when the socket is open and there is + data available to be read */ + g_assert (thrift_transport_peek (client_transport, &error) == TRUE); + g_assert (error == NULL); + + /* read exactly one character from the server */ + g_assert_cmpint (thrift_transport_read (client_transport, + &data, + sizeof data, + &error), ==, sizeof data); + + /* thrift_transport_peek returns FALSE when the socket is open but there is + no (more) data available to be read */ + g_assert (thrift_transport_is_open (client_transport) == TRUE); + g_assert (thrift_transport_peek (client_transport, &error) == FALSE); + g_assert (error == NULL); + + thrift_transport_read_end (client_transport, &error); + thrift_transport_close (client_transport, &error); + + g_object_unref (client_transport); + + g_assert (wait (&status) == pid); + g_assert (status == 0); + } +} + +static void +thrift_socket_server (const int port) +{ + int bytes = 0; + ThriftServerTransport *transport = NULL; + ThriftTransport *client = NULL; + guchar buf[10]; /* a buffer */ + guchar match[10] = TEST_DATA; + + ThriftServerSocket *tsocket = g_object_new (THRIFT_TYPE_SERVER_SOCKET, + "port", port, NULL); + + transport = THRIFT_SERVER_TRANSPORT (tsocket); + thrift_server_transport_listen (transport, NULL); + client = thrift_server_transport_accept (transport, NULL); + assert (client != NULL); + + /* read 10 bytes */ + bytes = thrift_socket_read (client, buf, 10, NULL); + assert (bytes == 10); /* make sure we've read 10 bytes */ + assert ( memcmp(buf, match, 10) == 0 ); /* make sure what we got matches */ + + /* failed read */ + recv_error = 1; + thrift_socket_read (client, buf, 1, NULL); + recv_error = 0; + + thrift_socket_read_end (client, NULL); + thrift_socket_close (client, NULL); + g_object_unref (tsocket); + g_object_unref (client); +} + +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 ("/testtransportsocket/CreateAndDestroy", test_create_and_destroy); + g_test_add_func ("/testtransportsocket/OpenAndClose", test_open_and_close); + g_test_add_func ("/testtransportsocket/ReadAndWrite", test_read_and_write); + g_test_add_func ("/testtransportsocket/Peek", test_peek); + + return g_test_run (); +} +
