summaryrefslogtreecommitdiffstats
path: root/src/tests
diff options
context:
space:
mode:
Diffstat (limited to 'src/tests')
-rw-r--r--src/tests/sbus_codegen_tests.c490
-rwxr-xr-xsrc/tests/sbus_codegen_tests.xml26
-rw-r--r--src/tests/sbus_codegen_tests_generated.c522
-rw-r--r--src/tests/sbus_codegen_tests_generated.h44
4 files changed, 1078 insertions, 4 deletions
diff --git a/src/tests/sbus_codegen_tests.c b/src/tests/sbus_codegen_tests.c
index a88bbac38..fa31ad64d 100644
--- a/src/tests/sbus_codegen_tests.c
+++ b/src/tests/sbus_codegen_tests.c
@@ -33,6 +33,9 @@
#include "tests/sbus_codegen_tests_generated.h"
#include "util/util_errors.h"
+#define N_ELEMENTS(arr) \
+ (sizeof(arr) / sizeof(arr[0]))
+
/* The following 2 macros were taken from check's project source files (0.9.10)
* http://check.sourceforge.net/
*/
@@ -329,12 +332,225 @@ static int eject_handler(struct sbus_request *req, void *instance_data,
arg_object_path_array, len_object_path_array);
}
-#define N_ELEMENTS(arr) \
- (sizeof(arr) / sizeof(arr[0]))
+#define getter_body(in, out) do { \
+ ck_assert(dbus_req != NULL); \
+ ck_assert(out != NULL); \
+ *out = in; \
+} while(0);
+
+static const bool pilot_bool = true;
+void pilot_get_boolean_handler(struct sbus_request *dbus_req,
+ void *instance_data,
+ bool *val)
+{
+ getter_body(pilot_bool, val);
+}
+
+static const char *pilot_full_name = "Turanga Leela";
+void pilot_get_full_name_handler(struct sbus_request *dbus_req,
+ void *instance_data,
+ const char **name)
+{
+ getter_body(pilot_full_name, name);
+}
+
+static const uint8_t pilot_byte = 42;
+void pilot_get_byte_handler(struct sbus_request *dbus_req,
+ void *instance_data,
+ uint8_t *byte)
+{
+ getter_body(pilot_byte, byte);
+}
+
+static const int16_t pilot_int16 = -123;
+void pilot_get_int16_handler(struct sbus_request *dbus_req,
+ void *instance_data,
+ int16_t *int16)
+{
+ getter_body(pilot_int16, int16);
+}
+
+static const uint16_t pilot_uint16 = 123;
+void pilot_get_uint16_handler(struct sbus_request *dbus_req,
+ void *instance_data,
+ uint16_t *uint16)
+{
+ getter_body(pilot_uint16, uint16);
+}
+
+static const int32_t pilot_int32 = -456;
+void pilot_get_int32_handler(struct sbus_request *dbus_req,
+ void *instance_data,
+ int32_t *int32)
+{
+ getter_body(pilot_int32, int32);
+}
+
+static const uint32_t pilot_uint32 = 456;
+void pilot_get_uint32_handler(struct sbus_request *dbus_req,
+ void *instance_data,
+ uint32_t *uint32)
+{
+ getter_body(pilot_uint32, uint32);
+}
+
+static const int64_t pilot_int64 = -456;
+void pilot_get_int64_handler(struct sbus_request *dbus_req,
+ void *instance_data,
+ int64_t *int64)
+{
+ getter_body(pilot_int64, int64);
+}
+
+static const uint64_t pilot_uint64 = 456;
+void pilot_get_uint64_handler(struct sbus_request *dbus_req,
+ void *instance_data,
+ uint64_t *uint64)
+{
+ getter_body(pilot_uint64, uint64);
+}
+
+static const double pilot_double = 3.14;
+void pilot_get_double_handler(struct sbus_request *dbus_req,
+ void *instance_data,
+ double *double_val)
+{
+ getter_body(pilot_double, double_val);
+}
+
+static const char *pilot_string = "leela";
+void pilot_get_string_handler(struct sbus_request *dbus_req,
+ void *instance_data,
+ const char **string_val)
+{
+ *string_val = pilot_string;
+}
+
+static const char *pilot_path = "/path/leela";
+void pilot_get_objpath_handler(struct sbus_request *dbus_req,
+ void *instance_data,
+ const char **path_val)
+{
+ *path_val = pilot_path;
+}
+
+#define array_getter_body(in, out, outlen) do { \
+ ck_assert(dbus_req != NULL); \
+ ck_assert(out != NULL); \
+ ck_assert(outlen != NULL); \
+ *out = in; \
+ *outlen = N_ELEMENTS(in); \
+} while(0);
+
+static uint8_t pilot_byte_array[] = { 42, 0 };
+void pilot_get_byte_array_handler(struct sbus_request *dbus_req,
+ void *instance_data,
+ uint8_t **arr_out, int *arr_len)
+{
+ array_getter_body(pilot_byte_array, arr_out, arr_len);
+}
+
+static int16_t pilot_int16_array[] = { -123, 0 };
+void pilot_get_int16_array_handler(struct sbus_request *dbus_req,
+ void *instance_data,
+ int16_t **arr_out, int *arr_len)
+{
+ array_getter_body(pilot_int16_array, arr_out, arr_len);
+}
+
+static uint16_t pilot_uint16_array[] = { 123, 0 };
+void pilot_get_uint16_array_handler(struct sbus_request *dbus_req,
+ void *instance_data,
+ uint16_t **arr_out, int *arr_len)
+{
+ array_getter_body(pilot_uint16_array, arr_out, arr_len);
+}
+
+static int32_t pilot_int32_array[] = { -456, 0 };
+void pilot_get_int32_array_handler(struct sbus_request *dbus_req,
+ void *instance_data,
+ int32_t **arr_out, int *arr_len)
+{
+ array_getter_body(pilot_int32_array, arr_out, arr_len);
+}
+
+static uint32_t pilot_uint32_array[] = { 456, 0 };
+void pilot_get_uint32_array_handler(struct sbus_request *dbus_req,
+ void *instance_data,
+ uint32_t **arr_out, int *arr_len)
+{
+ array_getter_body(pilot_uint32_array, arr_out, arr_len);
+}
+
+static int64_t pilot_int64_array[] = { -789, 0 };
+void pilot_get_int64_array_handler(struct sbus_request *dbus_req,
+ void *instance_data,
+ int64_t **arr_out, int *arr_len)
+{
+ array_getter_body(pilot_int64_array, arr_out, arr_len);
+}
+
+static uint64_t pilot_uint64_array[] = { 789, 0 };
+void pilot_get_uint64_array_handler(struct sbus_request *dbus_req,
+ void *instance_data,
+ uint64_t **arr_out, int *arr_len)
+{
+ array_getter_body(pilot_uint64_array, arr_out, arr_len);
+}
+
+static double pilot_double_array[] = { 3.14, 0 };
+void pilot_get_double_array_handler(struct sbus_request *dbus_req,
+ void *instance_data,
+ double **arr_out, int *arr_len)
+{
+ array_getter_body(pilot_double_array, arr_out, arr_len);
+}
+
+static const char *pilot_string_array[] = { "Turanga", "Leela" };
+void pilot_get_string_array_handler(struct sbus_request *dbus_req,
+ void *data,
+ const char ***arr_out,
+ int *arr_len)
+{
+ array_getter_body(pilot_string_array, arr_out, arr_len);
+}
-struct test_pilot pilot_methods = {
+static const char *pilot_path_array[] = { "/some/path", "/another/path" };
+void pilot_get_path_array_handler(struct sbus_request *dbus_req,
+ void *data,
+ const char ***arr_out,
+ int *arr_len)
+{
+ array_getter_body(pilot_path_array, arr_out, arr_len);
+}
+
+struct test_pilot pilot_iface = {
{ &test_pilot_meta, 0 },
.Eject = eject_handler,
+
+ .test_pilot_get_FullName = pilot_get_full_name_handler,
+ .test_pilot_get_byte = pilot_get_byte_handler,
+ .test_pilot_get_boolean = pilot_get_boolean_handler,
+ .test_pilot_get_int16 = pilot_get_int16_handler,
+ .test_pilot_get_uint16 = pilot_get_uint16_handler,
+ .test_pilot_get_int32 = pilot_get_int32_handler,
+ .test_pilot_get_uint32 = pilot_get_uint32_handler,
+ .test_pilot_get_int64 = pilot_get_int64_handler,
+ .test_pilot_get_uint64 = pilot_get_uint64_handler,
+ .test_pilot_get_double = pilot_get_double_handler,
+ .test_pilot_get_string = pilot_get_string_handler,
+ .test_pilot_get_object_path = pilot_get_objpath_handler,
+
+ .test_pilot_get_byte_array = pilot_get_byte_array_handler,
+ .test_pilot_get_int16_array = pilot_get_int16_array_handler,
+ .test_pilot_get_uint16_array = pilot_get_uint16_array_handler,
+ .test_pilot_get_int32_array = pilot_get_int32_array_handler,
+ .test_pilot_get_uint32_array = pilot_get_uint32_array_handler,
+ .test_pilot_get_int64_array = pilot_get_int64_array_handler,
+ .test_pilot_get_uint64_array = pilot_get_uint64_array_handler,
+ .test_pilot_get_double_array = pilot_get_double_array_handler,
+ .test_pilot_get_string_array = pilot_get_string_array_handler,
+ .test_pilot_get_object_path_array = pilot_get_path_array_handler,
};
static int pilot_test_server_init(struct sbus_connection *server, void *unused)
@@ -343,7 +559,7 @@ static int pilot_test_server_init(struct sbus_connection *server, void *unused)
ret = sbus_conn_add_interface(server,
sbus_new_interface(server, "/test/leela",
- &pilot_methods.vtable,
+ &pilot_iface.vtable,
"Crash into the billboard"));
ck_assert_int_eq(ret, EOK);
@@ -526,11 +742,277 @@ START_TEST(test_marshal_basic_types)
}
END_TEST
+static void parse_get_reply(DBusMessage *reply, const int type, void *val)
+{
+ DBusMessageIter iter;
+ DBusMessageIter variter;
+ dbus_bool_t dbret;
+
+ dbret = dbus_message_iter_init(reply, &iter);
+ ck_assert(dbret == TRUE);
+ ck_assert_int_eq(dbus_message_iter_get_arg_type(&iter), DBUS_TYPE_VARIANT);
+ dbus_message_iter_recurse(&iter, &variter);
+ ck_assert_int_eq(dbus_message_iter_get_arg_type(&variter), type);
+ dbus_message_iter_get_basic(&variter, val);
+}
+
+static void call_get(DBusConnection *client,
+ const char *object_path,
+ const char *iface,
+ const char *prop,
+ int type,
+ void *val)
+{
+ DBusMessage *reply;
+ DBusError error = DBUS_ERROR_INIT;
+
+ reply = test_dbus_call_sync(client,
+ object_path,
+ DBUS_PROPERTIES_INTERFACE,
+ "Get",
+ &error,
+ DBUS_TYPE_STRING, &iface,
+ DBUS_TYPE_STRING, &prop,
+ DBUS_TYPE_INVALID);
+ ck_assert(reply != NULL);
+ parse_get_reply(reply, type, val);
+}
+
+START_TEST(test_get_basic_types)
+{
+ TALLOC_CTX *ctx;
+ DBusConnection *client;
+ dbus_bool_t bool_val;
+ const char *string_val;
+ const char *path_val;
+ uint8_t byte_val;
+ int16_t int16_val;
+ uint16_t uint16_val;
+ int32_t int32_val;
+ uint32_t uint32_val;
+ int64_t int64_val;
+ uint64_t uint64_val;
+ double double_val;
+
+ ctx = talloc_new(NULL);
+ client = test_dbus_setup_mock(ctx, NULL, pilot_test_server_init, NULL);
+
+ call_get(client, "/test/leela", test_pilot_meta.name, "boolean",
+ DBUS_TYPE_BOOLEAN, &bool_val);
+ ck_assert(bool_val == pilot_bool);
+
+ call_get(client, "/test/leela", test_pilot_meta.name, "FullName",
+ DBUS_TYPE_STRING, &string_val);
+ ck_assert_str_eq(string_val, pilot_full_name);
+
+ call_get(client, "/test/leela", test_pilot_meta.name, "byte",
+ DBUS_TYPE_BYTE, &byte_val);
+ ck_assert_int_eq(byte_val, pilot_byte);
+
+ call_get(client, "/test/leela", test_pilot_meta.name, "int16",
+ DBUS_TYPE_INT16, &int16_val);
+ ck_assert_int_eq(int16_val, pilot_int16);
+
+ call_get(client, "/test/leela", test_pilot_meta.name, "uint16",
+ DBUS_TYPE_UINT16, &uint16_val);
+ ck_assert_int_eq(uint16_val, pilot_uint16);
+
+ call_get(client, "/test/leela", test_pilot_meta.name, "int32",
+ DBUS_TYPE_INT32, &int32_val);
+ ck_assert_int_eq(int32_val, pilot_int32);
+
+ call_get(client, "/test/leela", test_pilot_meta.name, "uint32",
+ DBUS_TYPE_UINT32, &uint32_val);
+ ck_assert_int_eq(uint32_val, pilot_uint32);
+
+ call_get(client, "/test/leela", test_pilot_meta.name, "int64",
+ DBUS_TYPE_INT64, &int64_val);
+ ck_assert_int_eq(int64_val, pilot_int64);
+
+ call_get(client, "/test/leela", test_pilot_meta.name, "uint64",
+ DBUS_TYPE_UINT64, &uint64_val);
+ ck_assert_int_eq(uint64_val, pilot_uint64);
+
+ call_get(client, "/test/leela", test_pilot_meta.name, "double",
+ DBUS_TYPE_DOUBLE, &double_val);
+ ck_assert_int_eq(double_val, pilot_double);
+
+ call_get(client, "/test/leela", test_pilot_meta.name, "string",
+ DBUS_TYPE_STRING, &string_val);
+ ck_assert_str_eq(string_val, pilot_string);
+
+ call_get(client, "/test/leela", test_pilot_meta.name, "object_path",
+ DBUS_TYPE_OBJECT_PATH, &path_val);
+ ck_assert_str_eq(path_val, pilot_path);
+}
+END_TEST
+
+static void parse_get_array_reply(DBusMessage *reply, const int type,
+ void **values, int *nels)
+{
+ DBusMessageIter iter;
+ DBusMessageIter variter;
+ DBusMessageIter arriter;
+ dbus_bool_t dbret;
+
+ dbret = dbus_message_iter_init(reply, &iter);
+ ck_assert(dbret == TRUE);
+ ck_assert_int_eq(dbus_message_iter_get_arg_type(&iter), DBUS_TYPE_VARIANT);
+ dbus_message_iter_recurse(&iter, &variter);
+ ck_assert_int_eq(dbus_message_iter_get_arg_type(&variter), DBUS_TYPE_ARRAY);
+ ck_assert_int_eq(dbus_message_iter_get_element_type(&variter), type);
+ dbus_message_iter_recurse(&variter, &arriter);
+ if (type == DBUS_TYPE_STRING || type == DBUS_TYPE_OBJECT_PATH) {
+ int n = 0, i = 0;;
+ const char **strings;
+ const char *s;
+
+ do {
+ n++;
+ } while (dbus_message_iter_next(&arriter));
+
+ /* Allocating on NULL is bad, but this is unit test */
+ strings = talloc_array(NULL, const char *, n);
+ ck_assert(strings != NULL);
+
+ dbus_message_iter_recurse(&variter, &arriter);
+ do {
+ dbus_message_iter_get_basic(&arriter, &s);
+ strings[i] = talloc_strdup(strings, s);
+ ck_assert(strings[i] != NULL);
+ i++;
+ } while (dbus_message_iter_next(&arriter));
+
+ *nels = n;
+ *values = strings;
+ } else {
+ /* Fixed types are easy */
+ dbus_message_iter_get_fixed_array(&arriter, values, nels);
+ }
+}
+
+static void call_get_array(DBusConnection *client,
+ const char *object_path,
+ const char *iface,
+ const char *prop,
+ int type,
+ void **values,
+ int *nels)
+{
+ DBusMessage *reply;
+ DBusError error = DBUS_ERROR_INIT;
+
+ reply = test_dbus_call_sync(client,
+ object_path,
+ DBUS_PROPERTIES_INTERFACE,
+ "Get",
+ &error,
+ DBUS_TYPE_STRING, &iface,
+ DBUS_TYPE_STRING, &prop,
+ DBUS_TYPE_INVALID);
+ ck_assert(reply != NULL);
+ parse_get_array_reply(reply, type, values, nels);
+}
+
+#define _check_array(reply, len, known, fn) do { \
+ fn(len, 2); \
+ fn(reply[0], known[0]); \
+ fn(reply[1], known[1]); \
+} while(0); \
+
+#define check_int_array(reply, len, known) \
+ _check_array(reply, len, known, ck_assert_int_eq)
+#define check_uint_array(reply, len, known) \
+ _check_array(reply, len, known, ck_assert_uint_eq)
+
+START_TEST(test_get_basic_array_types)
+{
+ TALLOC_CTX *ctx;
+ DBusConnection *client;
+ const char **string_arr_val;
+ int string_arr_len;
+ const char **path_arr_val;
+ int path_arr_len;
+ uint8_t *byte_arr_val;
+ int byte_arr_len;
+ int16_t *int16_arr_val;
+ int int16_arr_len;
+ uint16_t *uint16_arr_val;
+ int uint16_arr_len;
+ int32_t *int32_arr_val;
+ int int32_arr_len;
+ uint32_t *uint32_arr_val;
+ int uint32_arr_len;
+ int64_t *int64_arr_val;
+ int int64_arr_len;
+ uint64_t *uint64_arr_val;
+ int uint64_arr_len;
+ double *double_arr_val;
+ int double_arr_len;
+
+ ctx = talloc_new(NULL);
+ client = test_dbus_setup_mock(ctx, NULL, pilot_test_server_init, NULL);
+
+ call_get_array(client, "/test/leela", test_pilot_meta.name, "byte_array",
+ DBUS_TYPE_BYTE, (void **) &byte_arr_val, &byte_arr_len);
+ check_uint_array(byte_arr_val, byte_arr_len, pilot_byte_array);
+
+ call_get_array(client, "/test/leela", test_pilot_meta.name, "int16_array",
+ DBUS_TYPE_INT16, (void **) &int16_arr_val, &int16_arr_len);
+ check_int_array(int16_arr_val, int16_arr_len, pilot_int16_array);
+
+ call_get_array(client, "/test/leela", test_pilot_meta.name, "uint16_array",
+ DBUS_TYPE_UINT16, (void **) &uint16_arr_val, &uint16_arr_len);
+ check_uint_array(uint16_arr_val, uint16_arr_len, pilot_uint16_array);
+
+ call_get_array(client, "/test/leela", test_pilot_meta.name, "int32_array",
+ DBUS_TYPE_INT32, (void **) &int32_arr_val, &int32_arr_len);
+ check_int_array(int32_arr_val, int32_arr_len, pilot_int32_array);
+
+ call_get_array(client, "/test/leela", test_pilot_meta.name, "uint32_array",
+ DBUS_TYPE_UINT32, (void **) &uint32_arr_val, &uint32_arr_len);
+ check_uint_array(uint32_arr_val, uint32_arr_len, pilot_uint32_array);
+
+ call_get_array(client, "/test/leela", test_pilot_meta.name, "int64_array",
+ DBUS_TYPE_INT64, (void **) &int64_arr_val, &int64_arr_len);
+ check_int_array(int64_arr_val, int64_arr_len, pilot_int64_array);
+
+ call_get_array(client, "/test/leela", test_pilot_meta.name, "uint64_array",
+ DBUS_TYPE_UINT64, (void **) &uint64_arr_val, &uint64_arr_len);
+ check_uint_array(uint64_arr_val, uint64_arr_len, pilot_uint64_array);
+
+ call_get_array(client, "/test/leela", test_pilot_meta.name, "double_array",
+ DBUS_TYPE_DOUBLE, (void **) &double_arr_val, &double_arr_len);
+ check_int_array(double_arr_val, double_arr_len, pilot_double_array);
+
+ call_get_array(client, "/test/leela", test_pilot_meta.name, "string_array",
+ DBUS_TYPE_STRING, (void **) &string_arr_val, &string_arr_len);
+ ck_assert_int_eq(string_arr_len, 2);
+ ck_assert_str_eq(string_arr_val[0], pilot_string_array[0]);
+ ck_assert_str_eq(string_arr_val[1], pilot_string_array[1]);
+
+ call_get_array(client, "/test/leela", test_pilot_meta.name, "string_array",
+ DBUS_TYPE_STRING, (void **) &string_arr_val, &string_arr_len);
+ ck_assert_int_eq(string_arr_len, 2);
+ ck_assert_str_eq(string_arr_val[0], pilot_string_array[0]);
+ ck_assert_str_eq(string_arr_val[1], pilot_string_array[1]);
+
+ call_get_array(client, "/test/leela", test_pilot_meta.name, "object_path_array",
+ DBUS_TYPE_OBJECT_PATH, (void **) &path_arr_val, &path_arr_len);
+ ck_assert_int_eq(path_arr_len, 2);
+ ck_assert_str_eq(path_arr_val[0], pilot_path_array[0]);
+ ck_assert_str_eq(path_arr_val[1], pilot_path_array[1]);
+
+}
+END_TEST
+
TCase *create_handler_tests(void)
{
TCase *tc = tcase_create("handler");
tcase_add_test(tc, test_marshal_basic_types);
+ tcase_add_test(tc, test_get_basic_types);
+ tcase_add_test(tc, test_get_basic_array_types);
return tc;
}
diff --git a/src/tests/sbus_codegen_tests.xml b/src/tests/sbus_codegen_tests.xml
index 83807b9c2..74037cc40 100755
--- a/src/tests/sbus_codegen_tests.xml
+++ b/src/tests/sbus_codegen_tests.xml
@@ -107,6 +107,32 @@
<arg name="object_path_array" type="ao" direction="out"/>
</method>
+ <!-- Properties with every type of basic argument, so far read only -->
+ <property name="byte" type="y" access="read"/>
+ <property name="boolean" type="b" access="read"/>
+ <property name="int16" type="n" access="read"/>
+ <property name="uint16" type="q" access="read"/>
+ <property name="int32" type="i" access="read"/>
+ <property name="uint32" type="u" access="read"/>
+ <property name="int64" type="x" access="read"/>
+ <property name="uint64" type="t" access="read"/>
+ <property name="double" type="d" access="read"/>
+ <property name="string" type="s" access="read"/>
+ <property name="object_path" type="o" access="read"/>
+
+ <!-- Property arrays with every type of basic argument except boolean
+ which we can't do (yet) -->
+ <property name="byte_array" type="ay" access="read"/>
+ <property name="int16_array" type="an" access="read"/>
+ <property name="uint16_array" type="aq" access="read"/>
+ <property name="int32_array" type="ai" access="read"/>
+ <property name="uint32_array" type="au" access="read"/>
+ <property name="int64_array" type="ax" access="read"/>
+ <property name="uint64_array" type="at" access="read"/>
+ <property name="double_array" type="ad" access="read"/>
+ <property name="string_array" type="as" access="read"/>
+ <property name="object_path_array" type="ao" access="read"/>
+
</interface>
</node>
diff --git a/src/tests/sbus_codegen_tests_generated.c b/src/tests/sbus_codegen_tests_generated.c
index 40d40cdc4..4ace03650 100644
--- a/src/tests/sbus_codegen_tests_generated.c
+++ b/src/tests/sbus_codegen_tests_generated.c
@@ -16,6 +16,27 @@ static int invoke_u_method(struct sbus_request *dbus_req, void *function_ptr);
/* invokes a handler with a 'ybnqiuxtdsoayanaqaiauaxatadasao' DBus signature */
static int invoke_ybnqiuxtdsoayanaqaiauaxatadasao_method(struct sbus_request *dbus_req, void *function_ptr);
+static int invoke_get_s(struct sbus_request *dbus_req, void *function_ptr);
+static int invoke_get_y(struct sbus_request *dbus_req, void *function_ptr);
+static int invoke_get_b(struct sbus_request *dbus_req, void *function_ptr);
+static int invoke_get_n(struct sbus_request *dbus_req, void *function_ptr);
+static int invoke_get_q(struct sbus_request *dbus_req, void *function_ptr);
+static int invoke_get_i(struct sbus_request *dbus_req, void *function_ptr);
+static int invoke_get_u(struct sbus_request *dbus_req, void *function_ptr);
+static int invoke_get_x(struct sbus_request *dbus_req, void *function_ptr);
+static int invoke_get_t(struct sbus_request *dbus_req, void *function_ptr);
+static int invoke_get_d(struct sbus_request *dbus_req, void *function_ptr);
+static int invoke_get_o(struct sbus_request *dbus_req, void *function_ptr);
+static int invoke_get_ay(struct sbus_request *dbus_req, void *function_ptr);
+static int invoke_get_an(struct sbus_request *dbus_req, void *function_ptr);
+static int invoke_get_aq(struct sbus_request *dbus_req, void *function_ptr);
+static int invoke_get_ai(struct sbus_request *dbus_req, void *function_ptr);
+static int invoke_get_au(struct sbus_request *dbus_req, void *function_ptr);
+static int invoke_get_ax(struct sbus_request *dbus_req, void *function_ptr);
+static int invoke_get_at(struct sbus_request *dbus_req, void *function_ptr);
+static int invoke_get_ad(struct sbus_request *dbus_req, void *function_ptr);
+static int invoke_get_as(struct sbus_request *dbus_req, void *function_ptr);
+static int invoke_get_ao(struct sbus_request *dbus_req, void *function_ptr);
/* arguments for com.planetexpress.Ship.MoveUniverse */
const struct sbus_arg_meta com_planetexpress_Ship_MoveUniverse__in[] = {
@@ -96,6 +117,10 @@ const struct sbus_property_meta com_planetexpress_Ship__properties[] = {
"Color", /* name */
"s", /* type */
SBUS_PROPERTY_READABLE,
+ offsetof(struct com_planetexpress_Ship, com_planetexpress_Ship_get_Color),
+ invoke_get_s,
+ 0, /* not writable */
+ NULL, /* no invoker */
},
{ NULL, }
};
@@ -233,6 +258,199 @@ const struct sbus_property_meta test_pilot__properties[] = {
"FullName", /* name */
"s", /* type */
SBUS_PROPERTY_READABLE | SBUS_PROPERTY_WRITABLE,
+ offsetof(struct test_pilot, test_pilot_get_FullName),
+ invoke_get_s,
+ 0, /* not writable */
+ NULL, /* no invoker */
+ },
+ {
+ "byte", /* name */
+ "y", /* type */
+ SBUS_PROPERTY_READABLE,
+ offsetof(struct test_pilot, test_pilot_get_byte),
+ invoke_get_y,
+ 0, /* not writable */
+ NULL, /* no invoker */
+ },
+ {
+ "boolean", /* name */
+ "b", /* type */
+ SBUS_PROPERTY_READABLE,
+ offsetof(struct test_pilot, test_pilot_get_boolean),
+ invoke_get_b,
+ 0, /* not writable */
+ NULL, /* no invoker */
+ },
+ {
+ "int16", /* name */
+ "n", /* type */
+ SBUS_PROPERTY_READABLE,
+ offsetof(struct test_pilot, test_pilot_get_int16),
+ invoke_get_n,
+ 0, /* not writable */
+ NULL, /* no invoker */
+ },
+ {
+ "uint16", /* name */
+ "q", /* type */
+ SBUS_PROPERTY_READABLE,
+ offsetof(struct test_pilot, test_pilot_get_uint16),
+ invoke_get_q,
+ 0, /* not writable */
+ NULL, /* no invoker */
+ },
+ {
+ "int32", /* name */
+ "i", /* type */
+ SBUS_PROPERTY_READABLE,
+ offsetof(struct test_pilot, test_pilot_get_int32),
+ invoke_get_i,
+ 0, /* not writable */
+ NULL, /* no invoker */
+ },
+ {
+ "uint32", /* name */
+ "u", /* type */
+ SBUS_PROPERTY_READABLE,
+ offsetof(struct test_pilot, test_pilot_get_uint32),
+ invoke_get_u,
+ 0, /* not writable */
+ NULL, /* no invoker */
+ },
+ {
+ "int64", /* name */
+ "x", /* type */
+ SBUS_PROPERTY_READABLE,
+ offsetof(struct test_pilot, test_pilot_get_int64),
+ invoke_get_x,
+ 0, /* not writable */
+ NULL, /* no invoker */
+ },
+ {
+ "uint64", /* name */
+ "t", /* type */
+ SBUS_PROPERTY_READABLE,
+ offsetof(struct test_pilot, test_pilot_get_uint64),
+ invoke_get_t,
+ 0, /* not writable */
+ NULL, /* no invoker */
+ },
+ {
+ "double", /* name */
+ "d", /* type */
+ SBUS_PROPERTY_READABLE,
+ offsetof(struct test_pilot, test_pilot_get_double),
+ invoke_get_d,
+ 0, /* not writable */
+ NULL, /* no invoker */
+ },
+ {
+ "string", /* name */
+ "s", /* type */
+ SBUS_PROPERTY_READABLE,
+ offsetof(struct test_pilot, test_pilot_get_string),
+ invoke_get_s,
+ 0, /* not writable */
+ NULL, /* no invoker */
+ },
+ {
+ "object_path", /* name */
+ "o", /* type */
+ SBUS_PROPERTY_READABLE,
+ offsetof(struct test_pilot, test_pilot_get_object_path),
+ invoke_get_o,
+ 0, /* not writable */
+ NULL, /* no invoker */
+ },
+ {
+ "byte_array", /* name */
+ "ay", /* type */
+ SBUS_PROPERTY_READABLE,
+ offsetof(struct test_pilot, test_pilot_get_byte_array),
+ invoke_get_ay,
+ 0, /* not writable */
+ NULL, /* no invoker */
+ },
+ {
+ "int16_array", /* name */
+ "an", /* type */
+ SBUS_PROPERTY_READABLE,
+ offsetof(struct test_pilot, test_pilot_get_int16_array),
+ invoke_get_an,
+ 0, /* not writable */
+ NULL, /* no invoker */
+ },
+ {
+ "uint16_array", /* name */
+ "aq", /* type */
+ SBUS_PROPERTY_READABLE,
+ offsetof(struct test_pilot, test_pilot_get_uint16_array),
+ invoke_get_aq,
+ 0, /* not writable */
+ NULL, /* no invoker */
+ },
+ {
+ "int32_array", /* name */
+ "ai", /* type */
+ SBUS_PROPERTY_READABLE,
+ offsetof(struct test_pilot, test_pilot_get_int32_array),
+ invoke_get_ai,
+ 0, /* not writable */
+ NULL, /* no invoker */
+ },
+ {
+ "uint32_array", /* name */
+ "au", /* type */
+ SBUS_PROPERTY_READABLE,
+ offsetof(struct test_pilot, test_pilot_get_uint32_array),
+ invoke_get_au,
+ 0, /* not writable */
+ NULL, /* no invoker */
+ },
+ {
+ "int64_array", /* name */
+ "ax", /* type */
+ SBUS_PROPERTY_READABLE,
+ offsetof(struct test_pilot, test_pilot_get_int64_array),
+ invoke_get_ax,
+ 0, /* not writable */
+ NULL, /* no invoker */
+ },
+ {
+ "uint64_array", /* name */
+ "at", /* type */
+ SBUS_PROPERTY_READABLE,
+ offsetof(struct test_pilot, test_pilot_get_uint64_array),
+ invoke_get_at,
+ 0, /* not writable */
+ NULL, /* no invoker */
+ },
+ {
+ "double_array", /* name */
+ "ad", /* type */
+ SBUS_PROPERTY_READABLE,
+ offsetof(struct test_pilot, test_pilot_get_double_array),
+ invoke_get_ad,
+ 0, /* not writable */
+ NULL, /* no invoker */
+ },
+ {
+ "string_array", /* name */
+ "as", /* type */
+ SBUS_PROPERTY_READABLE,
+ offsetof(struct test_pilot, test_pilot_get_string_array),
+ invoke_get_as,
+ 0, /* not writable */
+ NULL, /* no invoker */
+ },
+ {
+ "object_path_array", /* name */
+ "ao", /* type */
+ SBUS_PROPERTY_READABLE,
+ offsetof(struct test_pilot, test_pilot_get_object_path_array),
+ invoke_get_ao,
+ 0, /* not writable */
+ NULL, /* no invoker */
},
{ NULL, }
};
@@ -391,3 +609,307 @@ static int invoke_ybnqiuxtdsoayanaqaiauaxatadasao_method(struct sbus_request *db
arg_20,
len_20);
}
+
+/* invokes a getter with an array of 'uint16_t' DBus type */
+static int invoke_get_aq(struct sbus_request *dbus_req, void *function_ptr)
+{
+ uint16_t *prop_val;
+ int prop_len;
+ uint16_t *out_val;
+
+ void (*handler)(struct sbus_request *, void *data, uint16_t * *, int *) = function_ptr;
+
+ (handler)(dbus_req, dbus_req->intf->instance_data, &prop_val, &prop_len);
+
+ out_val = prop_val;
+ return sbus_request_return_array_as_variant(dbus_req, DBUS_TYPE_UINT16, (uint8_t*)out_val, prop_len, sizeof(uint16_t));
+}
+
+/* invokes a getter with a 'dbus_bool_t' DBus type */
+static int invoke_get_b(struct sbus_request *dbus_req, void *function_ptr)
+{
+ bool prop_val;
+ dbus_bool_t out_val;
+
+ void (*handler)(struct sbus_request *, void *data, bool *) = function_ptr;
+
+ (handler)(dbus_req, dbus_req->intf->instance_data, &prop_val);
+
+ out_val = prop_val;
+ return sbus_request_return_as_variant(dbus_req, DBUS_TYPE_BOOLEAN, &out_val);
+}
+
+/* invokes a getter with a 'double' DBus type */
+static int invoke_get_d(struct sbus_request *dbus_req, void *function_ptr)
+{
+ double prop_val;
+ double out_val;
+
+ void (*handler)(struct sbus_request *, void *data, double *) = function_ptr;
+
+ (handler)(dbus_req, dbus_req->intf->instance_data, &prop_val);
+
+ out_val = prop_val;
+ return sbus_request_return_as_variant(dbus_req, DBUS_TYPE_DOUBLE, &out_val);
+}
+
+/* invokes a getter with an array of 'const char *' DBus type */
+static int invoke_get_ao(struct sbus_request *dbus_req, void *function_ptr)
+{
+ const char * *prop_val;
+ int prop_len;
+ const char * *out_val;
+
+ void (*handler)(struct sbus_request *, void *data, const char * * *, int *) = function_ptr;
+
+ (handler)(dbus_req, dbus_req->intf->instance_data, &prop_val, &prop_len);
+
+ out_val = prop_val;
+ return sbus_request_return_array_as_variant(dbus_req, DBUS_TYPE_OBJECT_PATH, (uint8_t*)out_val, prop_len, sizeof(const char *));
+}
+
+/* invokes a getter with a 'int32_t' DBus type */
+static int invoke_get_i(struct sbus_request *dbus_req, void *function_ptr)
+{
+ int32_t prop_val;
+ int32_t out_val;
+
+ void (*handler)(struct sbus_request *, void *data, int32_t *) = function_ptr;
+
+ (handler)(dbus_req, dbus_req->intf->instance_data, &prop_val);
+
+ out_val = prop_val;
+ return sbus_request_return_as_variant(dbus_req, DBUS_TYPE_INT32, &out_val);
+}
+
+/* invokes a getter with an array of 'const char *' DBus type */
+static int invoke_get_as(struct sbus_request *dbus_req, void *function_ptr)
+{
+ const char * *prop_val;
+ int prop_len;
+ const char * *out_val;
+
+ void (*handler)(struct sbus_request *, void *data, const char * * *, int *) = function_ptr;
+
+ (handler)(dbus_req, dbus_req->intf->instance_data, &prop_val, &prop_len);
+
+ out_val = prop_val;
+ return sbus_request_return_array_as_variant(dbus_req, DBUS_TYPE_STRING, (uint8_t*)out_val, prop_len, sizeof(const char *));
+}
+
+/* invokes a getter with a 'const char *' DBus type */
+static int invoke_get_o(struct sbus_request *dbus_req, void *function_ptr)
+{
+ const char * prop_val;
+ const char * out_val;
+
+ void (*handler)(struct sbus_request *, void *data, const char * *) = function_ptr;
+
+ (handler)(dbus_req, dbus_req->intf->instance_data, &prop_val);
+
+ out_val = prop_val;
+ return sbus_request_return_as_variant(dbus_req, DBUS_TYPE_OBJECT_PATH, &out_val);
+}
+
+/* invokes a getter with a 'int16_t' DBus type */
+static int invoke_get_n(struct sbus_request *dbus_req, void *function_ptr)
+{
+ int16_t prop_val;
+ int16_t out_val;
+
+ void (*handler)(struct sbus_request *, void *data, int16_t *) = function_ptr;
+
+ (handler)(dbus_req, dbus_req->intf->instance_data, &prop_val);
+
+ out_val = prop_val;
+ return sbus_request_return_as_variant(dbus_req, DBUS_TYPE_INT16, &out_val);
+}
+
+/* invokes a getter with a 'uint16_t' DBus type */
+static int invoke_get_q(struct sbus_request *dbus_req, void *function_ptr)
+{
+ uint16_t prop_val;
+ uint16_t out_val;
+
+ void (*handler)(struct sbus_request *, void *data, uint16_t *) = function_ptr;
+
+ (handler)(dbus_req, dbus_req->intf->instance_data, &prop_val);
+
+ out_val = prop_val;
+ return sbus_request_return_as_variant(dbus_req, DBUS_TYPE_UINT16, &out_val);
+}
+
+/* invokes a getter with an array of 'uint8_t' DBus type */
+static int invoke_get_ay(struct sbus_request *dbus_req, void *function_ptr)
+{
+ uint8_t *prop_val;
+ int prop_len;
+ uint8_t *out_val;
+
+ void (*handler)(struct sbus_request *, void *data, uint8_t * *, int *) = function_ptr;
+
+ (handler)(dbus_req, dbus_req->intf->instance_data, &prop_val, &prop_len);
+
+ out_val = prop_val;
+ return sbus_request_return_array_as_variant(dbus_req, DBUS_TYPE_BYTE, (uint8_t*)out_val, prop_len, sizeof(uint8_t));
+}
+
+/* invokes a getter with a 'const char *' DBus type */
+static int invoke_get_s(struct sbus_request *dbus_req, void *function_ptr)
+{
+ const char * prop_val;
+ const char * out_val;
+
+ void (*handler)(struct sbus_request *, void *data, const char * *) = function_ptr;
+
+ (handler)(dbus_req, dbus_req->intf->instance_data, &prop_val);
+
+ out_val = prop_val;
+ return sbus_request_return_as_variant(dbus_req, DBUS_TYPE_STRING, &out_val);
+}
+
+/* invokes a getter with a 'uint32_t' DBus type */
+static int invoke_get_u(struct sbus_request *dbus_req, void *function_ptr)
+{
+ uint32_t prop_val;
+ uint32_t out_val;
+
+ void (*handler)(struct sbus_request *, void *data, uint32_t *) = function_ptr;
+
+ (handler)(dbus_req, dbus_req->intf->instance_data, &prop_val);
+
+ out_val = prop_val;
+ return sbus_request_return_as_variant(dbus_req, DBUS_TYPE_UINT32, &out_val);
+}
+
+/* invokes a getter with a 'uint64_t' DBus type */
+static int invoke_get_t(struct sbus_request *dbus_req, void *function_ptr)
+{
+ uint64_t prop_val;
+ uint64_t out_val;
+
+ void (*handler)(struct sbus_request *, void *data, uint64_t *) = function_ptr;
+
+ (handler)(dbus_req, dbus_req->intf->instance_data, &prop_val);
+
+ out_val = prop_val;
+ return sbus_request_return_as_variant(dbus_req, DBUS_TYPE_UINT64, &out_val);
+}
+
+/* invokes a getter with an array of 'int64_t' DBus type */
+static int invoke_get_ax(struct sbus_request *dbus_req, void *function_ptr)
+{
+ int64_t *prop_val;
+ int prop_len;
+ int64_t *out_val;
+
+ void (*handler)(struct sbus_request *, void *data, int64_t * *, int *) = function_ptr;
+
+ (handler)(dbus_req, dbus_req->intf->instance_data, &prop_val, &prop_len);
+
+ out_val = prop_val;
+ return sbus_request_return_array_as_variant(dbus_req, DBUS_TYPE_INT64, (uint8_t*)out_val, prop_len, sizeof(int64_t));
+}
+
+/* invokes a getter with a 'uint8_t' DBus type */
+static int invoke_get_y(struct sbus_request *dbus_req, void *function_ptr)
+{
+ uint8_t prop_val;
+ uint8_t out_val;
+
+ void (*handler)(struct sbus_request *, void *data, uint8_t *) = function_ptr;
+
+ (handler)(dbus_req, dbus_req->intf->instance_data, &prop_val);
+
+ out_val = prop_val;
+ return sbus_request_return_as_variant(dbus_req, DBUS_TYPE_BYTE, &out_val);
+}
+
+/* invokes a getter with a 'int64_t' DBus type */
+static int invoke_get_x(struct sbus_request *dbus_req, void *function_ptr)
+{
+ int64_t prop_val;
+ int64_t out_val;
+
+ void (*handler)(struct sbus_request *, void *data, int64_t *) = function_ptr;
+
+ (handler)(dbus_req, dbus_req->intf->instance_data, &prop_val);
+
+ out_val = prop_val;
+ return sbus_request_return_as_variant(dbus_req, DBUS_TYPE_INT64, &out_val);
+}
+
+/* invokes a getter with an array of 'uint32_t' DBus type */
+static int invoke_get_au(struct sbus_request *dbus_req, void *function_ptr)
+{
+ uint32_t *prop_val;
+ int prop_len;
+ uint32_t *out_val;
+
+ void (*handler)(struct sbus_request *, void *data, uint32_t * *, int *) = function_ptr;
+
+ (handler)(dbus_req, dbus_req->intf->instance_data, &prop_val, &prop_len);
+
+ out_val = prop_val;
+ return sbus_request_return_array_as_variant(dbus_req, DBUS_TYPE_UINT32, (uint8_t*)out_val, prop_len, sizeof(uint32_t));
+}
+
+/* invokes a getter with an array of 'int16_t' DBus type */
+static int invoke_get_an(struct sbus_request *dbus_req, void *function_ptr)
+{
+ int16_t *prop_val;
+ int prop_len;
+ int16_t *out_val;
+
+ void (*handler)(struct sbus_request *, void *data, int16_t * *, int *) = function_ptr;
+
+ (handler)(dbus_req, dbus_req->intf->instance_data, &prop_val, &prop_len);
+
+ out_val = prop_val;
+ return sbus_request_return_array_as_variant(dbus_req, DBUS_TYPE_INT16, (uint8_t*)out_val, prop_len, sizeof(int16_t));
+}
+
+/* invokes a getter with an array of 'double' DBus type */
+static int invoke_get_ad(struct sbus_request *dbus_req, void *function_ptr)
+{
+ double *prop_val;
+ int prop_len;
+ double *out_val;
+
+ void (*handler)(struct sbus_request *, void *data, double * *, int *) = function_ptr;
+
+ (handler)(dbus_req, dbus_req->intf->instance_data, &prop_val, &prop_len);
+
+ out_val = prop_val;
+ return sbus_request_return_array_as_variant(dbus_req, DBUS_TYPE_DOUBLE, (uint8_t*)out_val, prop_len, sizeof(double));
+}
+
+/* invokes a getter with an array of 'int32_t' DBus type */
+static int invoke_get_ai(struct sbus_request *dbus_req, void *function_ptr)
+{
+ int32_t *prop_val;
+ int prop_len;
+ int32_t *out_val;
+
+ void (*handler)(struct sbus_request *, void *data, int32_t * *, int *) = function_ptr;
+
+ (handler)(dbus_req, dbus_req->intf->instance_data, &prop_val, &prop_len);
+
+ out_val = prop_val;
+ return sbus_request_return_array_as_variant(dbus_req, DBUS_TYPE_INT32, (uint8_t*)out_val, prop_len, sizeof(int32_t));
+}
+
+/* invokes a getter with an array of 'uint64_t' DBus type */
+static int invoke_get_at(struct sbus_request *dbus_req, void *function_ptr)
+{
+ uint64_t *prop_val;
+ int prop_len;
+ uint64_t *out_val;
+
+ void (*handler)(struct sbus_request *, void *data, uint64_t * *, int *) = function_ptr;
+
+ (handler)(dbus_req, dbus_req->intf->instance_data, &prop_val, &prop_len);
+
+ out_val = prop_val;
+ return sbus_request_return_array_as_variant(dbus_req, DBUS_TYPE_UINT64, (uint8_t*)out_val, prop_len, sizeof(uint64_t));
+}
diff --git a/src/tests/sbus_codegen_tests_generated.h b/src/tests/sbus_codegen_tests_generated.h
index 137dab8a0..9599091dd 100644
--- a/src/tests/sbus_codegen_tests_generated.h
+++ b/src/tests/sbus_codegen_tests_generated.h
@@ -24,6 +24,27 @@
#define TEST_PILOT_BLINK "Blink"
#define TEST_PILOT_EJECT "Eject"
#define TEST_PILOT_FULLNAME "FullName"
+#define TEST_PILOT_BYTE "byte"
+#define TEST_PILOT_BOOLEAN "boolean"
+#define TEST_PILOT_INT16 "int16"
+#define TEST_PILOT_UINT16 "uint16"
+#define TEST_PILOT_INT32 "int32"
+#define TEST_PILOT_UINT32 "uint32"
+#define TEST_PILOT_INT64 "int64"
+#define TEST_PILOT_UINT64 "uint64"
+#define TEST_PILOT_DOUBLE "double"
+#define TEST_PILOT_STRING "string"
+#define TEST_PILOT_OBJECT_PATH "object_path"
+#define TEST_PILOT_BYTE_ARRAY "byte_array"
+#define TEST_PILOT_INT16_ARRAY "int16_array"
+#define TEST_PILOT_UINT16_ARRAY "uint16_array"
+#define TEST_PILOT_INT32_ARRAY "int32_array"
+#define TEST_PILOT_UINT32_ARRAY "uint32_array"
+#define TEST_PILOT_INT64_ARRAY "int64_array"
+#define TEST_PILOT_UINT64_ARRAY "uint64_array"
+#define TEST_PILOT_DOUBLE_ARRAY "double_array"
+#define TEST_PILOT_STRING_ARRAY "string_array"
+#define TEST_PILOT_OBJECT_PATH_ARRAY "object_path_array"
/* ------------------------------------------------------------------------
* DBus handlers
@@ -49,6 +70,7 @@ struct com_planetexpress_Ship {
int (*MoveUniverse)(struct sbus_request *req, void *data, bool arg_smoothly, uint32_t arg_speed_factor);
int (*crash_now)(struct sbus_request *req, void *data, const char *arg_where);
sbus_msg_handler_fn Land;
+ void (*com_planetexpress_Ship_get_Color)(struct sbus_request *, void *data, const char * *);
};
/* finish function for MoveUniverse */
@@ -62,6 +84,28 @@ struct test_pilot {
struct sbus_vtable vtable; /* derive from sbus_vtable */
int (*Blink)(struct sbus_request *req, void *data, uint32_t arg_duration);
int (*Eject)(struct sbus_request *req, void *data, uint8_t arg_byte, bool arg_boolean, int16_t arg_int16, uint16_t arg_uint16, int32_t arg_int32, uint32_t arg_uint32, int64_t arg_int64, uint64_t arg_uint64, double arg_double, const char *arg_string, const char *arg_object_path, uint8_t arg_byte_array[], int len_byte_array, int16_t arg_int16_array[], int len_int16_array, uint16_t arg_uint16_array[], int len_uint16_array, int32_t arg_int32_array[], int len_int32_array, uint32_t arg_uint32_array[], int len_uint32_array, int64_t arg_int64_array[], int len_int64_array, uint64_t arg_uint64_array[], int len_uint64_array, double arg_double_array[], int len_double_array, const char *arg_string_array[], int len_string_array, const char *arg_object_path_array[], int len_object_path_array);
+ void (*test_pilot_get_FullName)(struct sbus_request *, void *data, const char * *);
+ void (*test_pilot_get_byte)(struct sbus_request *, void *data, uint8_t *);
+ void (*test_pilot_get_boolean)(struct sbus_request *, void *data, bool *);
+ void (*test_pilot_get_int16)(struct sbus_request *, void *data, int16_t *);
+ void (*test_pilot_get_uint16)(struct sbus_request *, void *data, uint16_t *);
+ void (*test_pilot_get_int32)(struct sbus_request *, void *data, int32_t *);
+ void (*test_pilot_get_uint32)(struct sbus_request *, void *data, uint32_t *);
+ void (*test_pilot_get_int64)(struct sbus_request *, void *data, int64_t *);
+ void (*test_pilot_get_uint64)(struct sbus_request *, void *data, uint64_t *);
+ void (*test_pilot_get_double)(struct sbus_request *, void *data, double *);
+ void (*test_pilot_get_string)(struct sbus_request *, void *data, const char * *);
+ void (*test_pilot_get_object_path)(struct sbus_request *, void *data, const char * *);
+ void (*test_pilot_get_byte_array)(struct sbus_request *, void *data, uint8_t * *, int *);
+ void (*test_pilot_get_int16_array)(struct sbus_request *, void *data, int16_t * *, int *);
+ void (*test_pilot_get_uint16_array)(struct sbus_request *, void *data, uint16_t * *, int *);
+ void (*test_pilot_get_int32_array)(struct sbus_request *, void *data, int32_t * *, int *);
+ void (*test_pilot_get_uint32_array)(struct sbus_request *, void *data, uint32_t * *, int *);
+ void (*test_pilot_get_int64_array)(struct sbus_request *, void *data, int64_t * *, int *);
+ void (*test_pilot_get_uint64_array)(struct sbus_request *, void *data, uint64_t * *, int *);
+ void (*test_pilot_get_double_array)(struct sbus_request *, void *data, double * *, int *);
+ void (*test_pilot_get_string_array)(struct sbus_request *, void *data, const char * * *, int *);
+ void (*test_pilot_get_object_path_array)(struct sbus_request *, void *data, const char * * *, int *);
};
/* finish function for Blink */