summaryrefslogtreecommitdiffstats
path: root/src/jaegertracing/thrift/test/c_glib/src/thrift_test_handler.c
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--src/jaegertracing/thrift/test/c_glib/src/thrift_test_handler.c837
1 files changed, 837 insertions, 0 deletions
diff --git a/src/jaegertracing/thrift/test/c_glib/src/thrift_test_handler.c b/src/jaegertracing/thrift/test/c_glib/src/thrift_test_handler.c
new file mode 100644
index 000000000..f6c759e1a
--- /dev/null
+++ b/src/jaegertracing/thrift/test/c_glib/src/thrift_test_handler.c
@@ -0,0 +1,837 @@
+/*
+ * 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 <inttypes.h>
+#include <string.h>
+#include <unistd.h>
+
+#include <thrift/c_glib/thrift.h>
+#include <thrift/c_glib/thrift_application_exception.h>
+
+#include "thrift_test_handler.h"
+
+/* A handler that implements the TTestThriftTestIf interface */
+
+G_DEFINE_TYPE (ThriftTestHandler,
+ thrift_test_handler,
+ T_TEST_TYPE_THRIFT_TEST_HANDLER)
+
+gboolean
+thrift_test_handler_test_void (TTestThriftTestIf *iface,
+ GError **error)
+{
+ THRIFT_UNUSED_VAR (iface);
+ THRIFT_UNUSED_VAR (error);
+
+ printf ("testVoid()\n");
+
+ return TRUE;
+}
+
+gboolean
+thrift_test_handler_test_string (TTestThriftTestIf *iface,
+ gchar **_return,
+ const gchar *thing,
+ GError **error)
+{
+ THRIFT_UNUSED_VAR (iface);
+ THRIFT_UNUSED_VAR (error);
+
+ printf ("testString(\"%s\")\n", thing);
+ *_return = g_strdup (thing);
+
+ return TRUE;
+}
+
+gboolean
+thrift_test_handler_test_bool (TTestThriftTestIf *iface,
+ gboolean *_return,
+ const gboolean thing,
+ GError **error)
+{
+ THRIFT_UNUSED_VAR (iface);
+ THRIFT_UNUSED_VAR (error);
+
+ printf ("testBool(%s)\n", thing ? "true" : "false");
+ *_return = thing;
+
+ return TRUE;
+}
+
+gboolean
+thrift_test_handler_test_byte (TTestThriftTestIf *iface,
+ gint8 *_return,
+ const gint8 thing,
+ GError **error)
+{
+ THRIFT_UNUSED_VAR (iface);
+ THRIFT_UNUSED_VAR (error);
+
+ printf ("testByte(%d)\n", (gint)thing);
+ *_return = thing;
+
+ return TRUE;
+}
+
+gboolean
+thrift_test_handler_test_i32 (TTestThriftTestIf *iface,
+ gint32 *_return,
+ const gint32 thing,
+ GError **error)
+{
+ THRIFT_UNUSED_VAR (iface);
+ THRIFT_UNUSED_VAR (error);
+
+ printf ("testI32(%d)\n", thing);
+ *_return = thing;
+
+ return TRUE;
+}
+
+gboolean
+thrift_test_handler_test_i64 (TTestThriftTestIf *iface,
+ gint64 *_return,
+ const gint64 thing,
+ GError **error)
+{
+ THRIFT_UNUSED_VAR (iface);
+ THRIFT_UNUSED_VAR (error);
+
+ printf ("testI64(%" PRId64 ")\n", thing);
+ *_return = thing;
+
+ return TRUE;
+}
+
+gboolean
+thrift_test_handler_test_double (TTestThriftTestIf *iface,
+ gdouble *_return,
+ const gdouble thing,
+ GError **error)
+{
+ THRIFT_UNUSED_VAR (iface);
+ THRIFT_UNUSED_VAR (error);
+
+ printf ("testDouble(%f)\n", thing);
+ *_return = thing;
+
+ return TRUE;
+}
+
+gboolean
+thrift_test_handler_test_binary (TTestThriftTestIf *iface,
+ GByteArray ** _return,
+ const GByteArray * thing,
+ GError **error)
+{
+ THRIFT_UNUSED_VAR (iface);
+ THRIFT_UNUSED_VAR (error);
+
+ printf ("testBinary()\n"); // TODO: hex output
+ g_byte_array_ref((GByteArray *)thing);
+ *_return = (GByteArray *)thing;
+
+ return TRUE;
+}
+
+gboolean
+thrift_test_handler_test_struct (TTestThriftTestIf *iface,
+ TTestXtruct **_return,
+ const TTestXtruct *thing,
+ GError **error)
+{
+ gchar *string_thing = NULL;
+ gint byte_thing;
+ gint i32_thing;
+ gint64 i64_thing;
+
+ THRIFT_UNUSED_VAR (iface);
+ THRIFT_UNUSED_VAR (error);
+
+ g_object_get ((TTestXtruct *)thing,
+ "string_thing", &string_thing,
+ "byte_thing", &byte_thing,
+ "i32_thing", &i32_thing,
+ "i64_thing", &i64_thing,
+ NULL);
+
+ printf ("testStruct({\"%s\", %d, %d, %" PRId64 "})\n",
+ string_thing,
+ (gint)byte_thing,
+ i32_thing,
+ i64_thing);
+
+ g_object_set (*_return,
+ "string_thing", string_thing,
+ "byte_thing", byte_thing,
+ "i32_thing", i32_thing,
+ "i64_thing", i64_thing,
+ NULL);
+
+ if (string_thing != NULL)
+ g_free (string_thing);
+
+ return TRUE;
+}
+
+gboolean
+thrift_test_handler_test_nest (TTestThriftTestIf *iface,
+ TTestXtruct2 **_return,
+ const TTestXtruct2 *thing,
+ GError **error)
+{
+ gchar *inner_string_thing = NULL;
+ gint byte_thing, inner_byte_thing;
+ gint i32_thing, inner_i32_thing;
+ gint64 inner_i64_thing;
+ TTestXtruct *struct_thing;
+
+ THRIFT_UNUSED_VAR (iface);
+ THRIFT_UNUSED_VAR (error);
+
+ g_object_get ((TTestXtruct2 *)thing,
+ "byte_thing", &byte_thing,
+ "struct_thing", &struct_thing,
+ "i32_thing", &i32_thing,
+ NULL);
+ g_object_get (struct_thing,
+ "string_thing", &inner_string_thing,
+ "byte_thing", &inner_byte_thing,
+ "i32_thing", &inner_i32_thing,
+ "i64_thing", &inner_i64_thing,
+ NULL);
+
+ printf ("testNest({%d, {\"%s\", %d, %d, %" PRId64 "}, %d})\n",
+ byte_thing,
+ inner_string_thing,
+ inner_byte_thing,
+ inner_i32_thing,
+ inner_i64_thing,
+ i32_thing);
+
+ g_object_set (*_return,
+ "byte_thing", byte_thing,
+ "struct_thing", struct_thing,
+ "i32_thing", i32_thing,
+ NULL);
+
+ if (inner_string_thing != NULL)
+ g_free (inner_string_thing);
+ g_object_unref (struct_thing);
+
+ return TRUE;
+}
+
+gboolean
+thrift_test_handler_test_map (TTestThriftTestIf *iface,
+ GHashTable **_return,
+ const GHashTable *thing,
+ GError **error)
+{
+ GHashTableIter hash_table_iter;
+ gpointer key;
+ gpointer value;
+ gboolean first = TRUE;
+
+ THRIFT_UNUSED_VAR (iface);
+ THRIFT_UNUSED_VAR (error);
+
+ printf ("testMap({");
+ g_hash_table_iter_init (&hash_table_iter, (GHashTable *)thing);
+ while (g_hash_table_iter_next (&hash_table_iter,
+ &key,
+ &value)) {
+ gint32 *new_key;
+ gint32 *new_value;
+
+ if (first)
+ first = FALSE;
+ else
+ printf (", ");
+
+ printf ("%d => %d", *(gint32 *)key, *(gint32 *)value);
+
+ new_key = g_malloc (sizeof *new_key);
+ *new_key = *(gint32 *)key;
+ new_value = g_malloc (sizeof *new_value);
+ *new_value = *(gint32 *)value;
+ g_hash_table_insert (*_return, new_key, new_value);
+ }
+ printf ("})\n");
+
+ return TRUE;
+}
+
+gboolean
+thrift_test_handler_test_string_map (TTestThriftTestIf *iface,
+ GHashTable **_return,
+ const GHashTable *thing,
+ GError **error)
+{
+ GHashTableIter hash_table_iter;
+ gpointer key;
+ gpointer value;
+ gboolean first = TRUE;
+
+ THRIFT_UNUSED_VAR (iface);
+ THRIFT_UNUSED_VAR (error);
+
+ printf ("testStringMap({");
+ g_hash_table_iter_init (&hash_table_iter, (GHashTable *)thing);
+ while (g_hash_table_iter_next (&hash_table_iter,
+ &key,
+ &value)) {
+ gchar *new_key;
+ gchar *new_value;
+
+ if (first)
+ first = FALSE;
+ else
+ printf (", ");
+
+ printf ("%s => %s", (gchar *)key, (gchar *)value);
+
+ new_key = g_strdup ((gchar *)key);
+ new_value = g_strdup ((gchar *)value);
+ g_hash_table_insert (*_return, new_key, new_value);
+ }
+ printf ("})\n");
+
+ return TRUE;
+}
+
+gboolean
+thrift_test_handler_test_set (TTestThriftTestIf *iface,
+ GHashTable **_return,
+ const GHashTable *thing,
+ GError **error)
+{
+ GHashTableIter hash_table_iter;
+ gpointer key;
+ gboolean first = TRUE;
+
+ THRIFT_UNUSED_VAR (iface);
+ THRIFT_UNUSED_VAR (error);
+
+ printf ("testSet({");
+ g_hash_table_iter_init (&hash_table_iter, (GHashTable *)thing);
+ while (g_hash_table_iter_next (&hash_table_iter,
+ &key,
+ NULL)) {
+ gint32 *new_key;
+
+ if (first)
+ first = FALSE;
+ else
+ printf (", ");
+
+ printf ("%d", *(gint32 *)key);
+
+ new_key = g_malloc (sizeof *new_key);
+ *new_key = *(gint32 *)key;
+ g_hash_table_insert (*_return, new_key, NULL);
+ }
+ printf ("})\n");
+
+ return TRUE;
+}
+
+gboolean
+thrift_test_handler_test_list (TTestThriftTestIf *iface,
+ GArray **_return,
+ const GArray *thing,
+ GError **error)
+{
+ guint i;
+ gboolean first = TRUE;
+
+ THRIFT_UNUSED_VAR (iface);
+ THRIFT_UNUSED_VAR (error);
+
+ printf ("testList({");
+ for (i = 0; i < thing->len; i += 1) {
+ gint32 value;
+ gint32 *new_value;
+
+ if (first)
+ first = FALSE;
+ else
+ printf (", ");
+
+ value = g_array_index (thing, gint32, i);
+ printf ("%d", value);
+
+ new_value = g_malloc (sizeof *new_value);
+ *new_value = value;
+ g_array_append_val (*_return, *new_value);
+ }
+ printf ("})\n");
+
+ return TRUE;
+}
+
+gboolean
+thrift_test_handler_test_enum (TTestThriftTestIf *iface,
+ TTestNumberz *_return,
+ const TTestNumberz thing,
+ GError **error)
+{
+ THRIFT_UNUSED_VAR (iface);
+ THRIFT_UNUSED_VAR (error);
+
+ printf ("testEnum(%d)\n", thing);
+ *_return = thing;
+
+ return TRUE;
+}
+
+gboolean
+thrift_test_handler_test_typedef (TTestThriftTestIf *iface,
+ TTestUserId *_return,
+ const TTestUserId thing,
+ GError **error)
+{
+ THRIFT_UNUSED_VAR (iface);
+ THRIFT_UNUSED_VAR (error);
+
+ printf ("testTypedef(%" PRId64 ")\n", thing);
+ *_return = thing;
+
+ return TRUE;
+}
+
+gboolean
+thrift_test_handler_test_map_map (TTestThriftTestIf *iface,
+ GHashTable **_return,
+ const gint32 hello,
+ GError **error)
+{
+ GHashTable *positive;
+ GHashTable *negative;
+ gint32 *key;
+ gint32 *value;
+ guint i;
+
+ THRIFT_UNUSED_VAR (iface);
+ THRIFT_UNUSED_VAR (error);
+
+ printf ("testMapMap(%d)\n", hello);
+
+ positive = g_hash_table_new_full (g_int_hash,
+ g_int_equal,
+ g_free,
+ g_free);
+ negative = g_hash_table_new_full (g_int_hash,
+ g_int_equal,
+ g_free,
+ g_free);
+
+ for (i = 1; i < 5; i += 1) {
+ key = g_malloc (sizeof *key);
+ value = g_malloc (sizeof *value);
+ *key = i;
+ *value = i;
+ g_hash_table_insert (positive, key, value);
+
+ key = g_malloc (sizeof *key);
+ value = g_malloc (sizeof *value);
+ *key = -i;
+ *value = -i;
+ g_hash_table_insert (negative, key, value);
+ }
+
+ key = g_malloc (sizeof *key);
+ *key = 4;
+ g_hash_table_insert (*_return, key, positive);
+
+ key = g_malloc (sizeof *key);
+ *key = -4;
+ g_hash_table_insert (*_return, key, negative);
+
+ return TRUE;
+}
+
+gboolean
+thrift_test_handler_test_insanity (TTestThriftTestIf *iface,
+ GHashTable **_return,
+ const TTestInsanity *argument,
+ GError **error)
+{
+ TTestXtruct *xtruct_in;
+
+ gchar *string_thing = NULL;
+ gint byte_thing;
+ gint i32_thing;
+ gint64 i64_thing;
+
+ GPtrArray *xtructs;
+
+ TTestInsanity *looney;
+
+ GHashTable *user_map;
+ GHashTable *first_map;
+ GHashTable *second_map;
+
+ GHashTableIter hash_table_iter;
+ GHashTableIter inner_hash_table_iter;
+ GHashTableIter user_map_iter;
+
+ gpointer key;
+ gpointer value;
+
+ TTestUserId *user_id;
+
+ guint i;
+
+ THRIFT_UNUSED_VAR (iface);
+ THRIFT_UNUSED_VAR (error);
+
+ printf ("testInsanity()\n");
+
+ first_map = g_hash_table_new_full (g_direct_hash,
+ g_direct_equal,
+ NULL,
+ g_object_unref);
+ second_map = g_hash_table_new_full (g_direct_hash,
+ g_direct_equal,
+ NULL,
+ g_object_unref);
+
+ g_hash_table_insert (first_map,
+ GINT_TO_POINTER (T_TEST_NUMBERZ_TWO),
+ (gpointer)argument);
+ g_hash_table_insert (first_map,
+ GINT_TO_POINTER (T_TEST_NUMBERZ_THREE),
+ (gpointer)argument);
+
+ /* Increment argument's ref count by two because first_map now holds
+ two references to it and the caller is not aware we have made any
+ additional references to argument. (That is, caller owns argument
+ and will unref it explicitly in addition to unref-ing *_return.)
+
+ We do this instead of creating a copy of argument in order to mimic
+ the C++ implementation (and since, frankly, the world needs less
+ argument, not more). */
+ g_object_ref ((gpointer)argument);
+ g_object_ref ((gpointer)argument);
+
+ looney = g_object_new (T_TEST_TYPE_INSANITY, NULL);
+ g_hash_table_insert (second_map,
+ GINT_TO_POINTER (T_TEST_NUMBERZ_SIX),
+ looney);
+
+ user_id = g_malloc (sizeof *user_id);
+ *user_id = 1;
+ g_hash_table_insert (*_return, user_id, first_map);
+
+ user_id = g_malloc (sizeof *user_id);
+ *user_id = 2;
+ g_hash_table_insert (*_return, user_id, second_map);
+
+ printf ("return");
+ printf (" = {");
+ g_hash_table_iter_init (&hash_table_iter, *_return);
+ while (g_hash_table_iter_next (&hash_table_iter,
+ &key,
+ &value)) {
+ printf ("%" PRId64 " => {", *(TTestUserId *)key);
+
+ g_hash_table_iter_init (&inner_hash_table_iter,
+ (GHashTable *)value);
+ while (g_hash_table_iter_next (&inner_hash_table_iter,
+ &key,
+ &value)) {
+ printf ("%d => {", (TTestNumberz)key);
+
+ g_object_get ((TTestInsanity *)value,
+ "userMap", &user_map,
+ "xtructs", &xtructs,
+ NULL);
+
+ printf ("{");
+ g_hash_table_iter_init (&user_map_iter, user_map);
+ while (g_hash_table_iter_next (&user_map_iter,
+ &key,
+ &value)) {
+ printf ("%d => %" PRId64 ", ",
+ (TTestNumberz)key,
+ *(TTestUserId *)value);
+ }
+ printf ("}, ");
+ g_hash_table_unref (user_map);
+
+ printf ("{");
+ for (i = 0; i < xtructs->len; ++i) {
+ xtruct_in = g_ptr_array_index (xtructs, i);
+ g_object_get (xtruct_in,
+ "string_thing", &string_thing,
+ "byte_thing", &byte_thing,
+ "i32_thing", &i32_thing,
+ "i64_thing", &i64_thing,
+ NULL);
+
+ printf ("{\"%s\", %d, %d, %" PRId64 "}, ",
+ string_thing,
+ byte_thing,
+ i32_thing,
+ i64_thing);
+ }
+ printf ("}");
+ g_ptr_array_unref (xtructs);
+
+ printf ("}, ");
+ }
+ printf ("}, ");
+ }
+ printf ("}\n");
+
+ return TRUE;
+}
+
+gboolean
+thrift_test_handler_test_multi (TTestThriftTestIf *iface,
+ TTestXtruct **_return,
+ const gint8 arg0,
+ const gint32 arg1,
+ const gint64 arg2,
+ const GHashTable *arg3,
+ const TTestNumberz arg4,
+ const TTestUserId arg5,
+ GError **error)
+{
+ THRIFT_UNUSED_VAR (iface);
+ THRIFT_UNUSED_VAR (error);
+ THRIFT_UNUSED_VAR (arg3);
+ THRIFT_UNUSED_VAR (arg4);
+ THRIFT_UNUSED_VAR (arg5);
+
+ printf ("testMulti()\n");
+
+ g_object_set (*_return,
+ "string_thing", g_strdup ("Hello2"),
+ "byte_thing", arg0,
+ "i32_thing", arg1,
+ "i64_thing", arg2,
+ NULL);
+
+ return TRUE;
+}
+
+gboolean
+thrift_test_handler_test_exception (TTestThriftTestIf *iface,
+ const gchar *arg,
+ TTestXception **err1,
+ GError **error)
+{
+ THRIFT_UNUSED_VAR (iface);
+
+ TTestXtruct *xtruct;
+ gboolean result;
+
+ printf ("testException(%s)\n", arg);
+
+ /* Unlike argument objects, exception objects are not pre-created */
+ g_assert (*err1 == NULL);
+
+ if (strncmp (arg, "Xception", 9) == 0) {
+ /* "Throw" a custom exception: Set the corresponding exception
+ argument, set *error to NULL and return FALSE */
+ *err1 = g_object_new (T_TEST_TYPE_XCEPTION,
+ "errorCode", 1001,
+ "message", g_strdup (arg),
+ NULL);
+ *error = NULL;
+ result = FALSE;
+ }
+ else if (strncmp (arg, "TException", 11) == 0) {
+ /* "Throw" a generic TException (ThriftApplicationException): Set
+ all exception arguments to NULL, set *error and return FALSE */
+ *err1 = NULL;
+ g_set_error (error,
+ thrift_application_exception_error_quark (),
+ THRIFT_APPLICATION_EXCEPTION_ERROR_UNKNOWN,
+ "Default TException.");
+ result = FALSE;
+ }
+ else {
+ *err1 = NULL;
+ *error = NULL;
+
+ /* This code is duplicated from the C++ test suite, though it
+ appears to serve no purpose */
+ xtruct = g_object_new (T_TEST_TYPE_XTRUCT,
+ "string_thing", g_strdup (arg),
+ NULL);
+ g_object_unref (xtruct);
+
+ result = TRUE;
+ }
+
+ return result;
+}
+
+gboolean
+thrift_test_handler_test_multi_exception (TTestThriftTestIf *iface,
+ TTestXtruct **_return,
+ const gchar *arg0,
+ const gchar *arg1,
+ TTestXception **err1,
+ TTestXception2 **err2,
+ GError **error)
+{
+ THRIFT_UNUSED_VAR (iface);
+ THRIFT_UNUSED_VAR (error);
+
+ TTestXtruct *struct_thing;
+ gboolean result;
+
+ printf ("testMultiException(%s, %s)\n", arg0, arg1);
+
+ g_assert (*err1 == NULL);
+ g_assert (*err2 == NULL);
+
+ if (strncmp (arg0, "Xception", 8) == 0 && strlen(arg0) == 8) {
+ *err1 = g_object_new (T_TEST_TYPE_XCEPTION,
+ "errorCode", 1001,
+ "message", g_strdup ("This is an Xception"),
+ NULL);
+ result = FALSE;
+ }
+ else if (strncmp (arg0, "Xception2", 9) == 0) {
+ *err2 = g_object_new (T_TEST_TYPE_XCEPTION2,
+ "errorCode", 2002,
+ NULL);
+
+ g_object_get (*err2,
+ "struct_thing", &struct_thing,
+ NULL);
+ g_object_set (struct_thing,
+ "string_thing", g_strdup ("This is an Xception2"),
+ NULL);
+ g_object_set (*err2,
+ "struct_thing", struct_thing,
+ NULL);
+ g_object_unref (struct_thing);
+
+ result = FALSE;
+ }
+ else {
+ g_object_set (*_return,
+ "string_thing", g_strdup (arg1),
+ NULL);
+ result = TRUE;
+ }
+
+ return result;
+}
+
+gboolean
+thrift_test_handler_test_oneway (TTestThriftTestIf *iface,
+ const gint32 secondsToSleep,
+ GError **error)
+{
+ THRIFT_UNUSED_VAR (iface);
+ THRIFT_UNUSED_VAR (error);
+
+ printf ("testOneway(%d): Sleeping...\n", secondsToSleep);
+ sleep (secondsToSleep);
+ printf ("testOneway(%d): done sleeping!\n", secondsToSleep);
+
+ return TRUE;
+}
+
+static void
+thrift_test_handler_init (ThriftTestHandler *self)
+{
+ THRIFT_UNUSED_VAR (self);
+}
+
+static void
+thrift_test_handler_class_init (ThriftTestHandlerClass *klass)
+{
+ TTestThriftTestHandlerClass *base_class =
+ T_TEST_THRIFT_TEST_HANDLER_CLASS (klass);
+
+ base_class->test_void =
+ klass->test_void =
+ thrift_test_handler_test_void;
+ base_class->test_string =
+ klass->test_string =
+ thrift_test_handler_test_string;
+ base_class->test_bool =
+ klass->test_bool =
+ thrift_test_handler_test_bool;
+ base_class->test_byte =
+ klass->test_byte =
+ thrift_test_handler_test_byte;
+ base_class->test_i32 =
+ klass->test_i32 =
+ thrift_test_handler_test_i32;
+ base_class->test_i64 =
+ klass->test_i64 =
+ thrift_test_handler_test_i64;
+ base_class->test_double =
+ klass->test_double =
+ thrift_test_handler_test_double;
+ base_class->test_binary =
+ klass->test_binary =
+ thrift_test_handler_test_binary;
+ base_class->test_struct =
+ klass->test_struct =
+ thrift_test_handler_test_struct;
+ base_class->test_nest =
+ klass->test_nest =
+ thrift_test_handler_test_nest;
+ base_class->test_map =
+ klass->test_map =
+ thrift_test_handler_test_map;
+ base_class->test_string_map =
+ klass->test_string_map =
+ thrift_test_handler_test_string_map;
+ base_class->test_set =
+ klass->test_set =
+ thrift_test_handler_test_set;
+ base_class->test_list =
+ klass->test_list =
+ thrift_test_handler_test_list;
+ base_class->test_enum =
+ klass->test_enum =
+ thrift_test_handler_test_enum;
+ base_class->test_typedef =
+ klass->test_typedef =
+ thrift_test_handler_test_typedef;
+ base_class->test_map_map =
+ klass->test_map_map =
+ thrift_test_handler_test_map_map;
+ base_class->test_insanity =
+ klass->test_insanity =
+ thrift_test_handler_test_insanity;
+ base_class->test_multi =
+ klass->test_multi =
+ thrift_test_handler_test_multi;
+ base_class->test_exception =
+ klass->test_exception =
+ thrift_test_handler_test_exception;
+ base_class->test_multi_exception =
+ klass->test_multi_exception =
+ thrift_test_handler_test_multi_exception;
+ base_class->test_oneway =
+ klass->test_oneway =
+ thrift_test_handler_test_oneway;
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-07-16 18:50:35 +0000