diff options
Diffstat (limited to 'src/tests')
-rw-r--r-- | src/tests/sbus_codegen_tests.c | 490 | ||||
-rwxr-xr-x | src/tests/sbus_codegen_tests.xml | 26 | ||||
-rw-r--r-- | src/tests/sbus_codegen_tests_generated.c | 522 | ||||
-rw-r--r-- | src/tests/sbus_codegen_tests_generated.h | 44 |
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 */ |