d6badc27cd6e8d3398877b6766cb0aaeef3a7800Timo Sirainen

d6badc27cd6e8d3398877b6766cb0aaeef3a7800Timo Sirainen#include <stdlib.h>

d6badc27cd6e8d3398877b6766cb0aaeef3a7800Timo Sirainen#include <check.h>

46c31f64b9f0949f00b7819f45b22f2d64b2ea27Timo Sirainen#include <talloc.h>

46c31f64b9f0949f00b7819f45b22f2d64b2ea27Timo Sirainen#include <tevent.h>

46c31f64b9f0949f00b7819f45b22f2d64b2ea27Timo Sirainen#include <popt.h>

46c31f64b9f0949f00b7819f45b22f2d64b2ea27Timo Sirainen

0cb2e8eb55e70f8ebe1e8349bdf49e4cbe5d8834Timo Sirainen#include "sbus/sssd_dbus_meta.h"

09c3a491f4f6ccebe290c7709bdc0d79a187610bTimo Sirainen#include "tests/common.h"

d6badc27cd6e8d3398877b6766cb0aaeef3a7800Timo Sirainen#include "tests/sbus_codegen_tests_generated.h"

db87d16551d1081ada01f787ea21aa3ed1402c31Timo Sirainen#include "util/util_errors.h"

d6badc27cd6e8d3398877b6766cb0aaeef3a7800Timo Sirainen

ae8817f05005f57bba32479a610b52d083e2b6ebTimo Sirainen#ifndef _ck_assert_uint

8d80659e504ffb34bb0c6a633184fece35751b18Timo Sirainen#define _ck_assert_uint(X, OP, Y) do { \

31ddc75584c5cde53d2e78a737587f2e7fdcb0d2Timo Sirainen uintmax_t _ck_x = (X); \

cf93189100a9136f2fd508c26e1573410bc8c1aaTimo Sirainen uintmax_t _ck_y = (Y); \

48270badadd82279bfe50ae3d187aea8b0b2b30eTimo Sirainen ck_assert_msg(_ck_x OP _ck_y, "Assertion '"#X#OP#Y"' failed: "#X"==%ju, "#Y"==%ju", _ck_x, _ck_y); \

48270badadd82279bfe50ae3d187aea8b0b2b30eTimo Sirainen} while (0)

0cb2e8eb55e70f8ebe1e8349bdf49e4cbe5d8834Timo Sirainen#endif /* _ck_assert_uint */

8d80659e504ffb34bb0c6a633184fece35751b18Timo Sirainen

8d80659e504ffb34bb0c6a633184fece35751b18Timo Sirainen#ifndef ck_assert_uint_eq

c251a38df327599a62d341bf5c2282f31352faa5Timo Sirainen#define ck_assert_uint_eq(X, Y) _ck_assert_uint(X, ==, Y)

0cb2e8eb55e70f8ebe1e8349bdf49e4cbe5d8834Timo Sirainen#endif /* ck_assert_uint_eq */

aa38d1a0945f0bc13a225d043f53fad2eec666b1Timo Sirainen

aa38d1a0945f0bc13a225d043f53fad2eec666b1Timo Sirainenstatic const struct sbus_arg_meta *

aa38d1a0945f0bc13a225d043f53fad2eec666b1Timo Sirainenfind_arg(const struct sbus_arg_meta *args,

aa38d1a0945f0bc13a225d043f53fad2eec666b1Timo Sirainen const char *name)

e06c0b65c16ccce69bbee009ead14d7d3d17a256Timo Sirainen{

beb6125ee872e7fed57745ab33e6de99639180f3Timo Sirainen const struct sbus_arg_meta *arg;

81a5d8714c566ce50c4a2409f59e82e716d576d2Timo Sirainen for (arg = args; arg->name != NULL; arg++) {

c5794838af9995f50bfecb06a3cd4f9a0ac77858Timo Sirainen if (strcmp (arg->name, name) == 0)

c5794838af9995f50bfecb06a3cd4f9a0ac77858Timo Sirainen return arg;

8d80659e504ffb34bb0c6a633184fece35751b18Timo Sirainen }

6e07b4251bf6a3cf34019c351a32a65c08392e58Timo Sirainen

893e5bbd5184ec5c21f47c67c8ea6efbea41f7d0Timo Sirainen return NULL;

6e07b4251bf6a3cf34019c351a32a65c08392e58Timo Sirainen}

faed8babca9914257f34fb2e603d74016d563b2dTimo Sirainen

8d80659e504ffb34bb0c6a633184fece35751b18Timo SirainenSTART_TEST(test_interfaces)

8d80659e504ffb34bb0c6a633184fece35751b18Timo Sirainen{

8d80659e504ffb34bb0c6a633184fece35751b18Timo Sirainen ck_assert_str_eq(com_planetexpress_Ship_meta.name, "com.planetexpress.Ship");

1175f27441385a7011629f295f42708f9a3a4ffcTimo Sirainen ck_assert(com_planetexpress_Ship_meta.methods != NULL);

48270badadd82279bfe50ae3d187aea8b0b2b30eTimo Sirainen ck_assert(com_planetexpress_Ship_meta.signals != NULL);

48270badadd82279bfe50ae3d187aea8b0b2b30eTimo Sirainen ck_assert(com_planetexpress_Ship_meta.properties != NULL);

48270badadd82279bfe50ae3d187aea8b0b2b30eTimo Sirainen

72cbf33ae81fde08384d30c779ff540752d9256cTimo Sirainen /* Explicit C Symbol */

72cbf33ae81fde08384d30c779ff540752d9256cTimo Sirainen ck_assert_str_eq(test_pilot_meta.name, "com.planetexpress.Pilot");

46c31f64b9f0949f00b7819f45b22f2d64b2ea27Timo Sirainen ck_assert(test_pilot_meta.methods != NULL);

46c31f64b9f0949f00b7819f45b22f2d64b2ea27Timo Sirainen ck_assert(test_pilot_meta.signals == NULL); /* no signals */

46c31f64b9f0949f00b7819f45b22f2d64b2ea27Timo Sirainen ck_assert(test_pilot_meta.properties != NULL);

d6badc27cd6e8d3398877b6766cb0aaeef3a7800Timo Sirainen

1b3bb8d39686ed24730cbc31cc9a33dc62c8c6c3Timo Sirainen}

f153a2cec0319f549388d28f8cfd4d50229d1132Timo Sirainen

ae8817f05005f57bba32479a610b52d083e2b6ebTimo SirainenSTART_TEST(test_methods)

aa38d1a0945f0bc13a225d043f53fad2eec666b1Timo Sirainen{

aa38d1a0945f0bc13a225d043f53fad2eec666b1Timo Sirainen const struct sbus_method_meta *method;

ae8817f05005f57bba32479a610b52d083e2b6ebTimo Sirainen const struct sbus_arg_meta *arg;

a022088674a5ae72ed29ae001834cbad62a4f19fTimo Sirainen

a022088674a5ae72ed29ae001834cbad62a4f19fTimo Sirainen method = sbus_meta_find_method(&com_planetexpress_Ship_meta, "MoveUniverse");

a022088674a5ae72ed29ae001834cbad62a4f19fTimo Sirainen ck_assert(method != NULL);

73e7998716853b5b7621c06aea0022dccda70ad1Timo Sirainen ck_assert_str_eq(method->name, "MoveUniverse");

a2cbf1d392ee983520451bc9b849a490f28ac298Timo Sirainen ck_assert(method->in_args != NULL);

a2cbf1d392ee983520451bc9b849a490f28ac298Timo Sirainen ck_assert(method->out_args != NULL);

0cb2e8eb55e70f8ebe1e8349bdf49e4cbe5d8834Timo Sirainen

0cb2e8eb55e70f8ebe1e8349bdf49e4cbe5d8834Timo Sirainen arg = find_arg(method->in_args, "smoothly");

1279090ba03f9c176976a69ab7718f0ed77b19afTimo Sirainen ck_assert(arg != NULL);

1279090ba03f9c176976a69ab7718f0ed77b19afTimo Sirainen ck_assert_str_eq(arg->name, "smoothly");

1279090ba03f9c176976a69ab7718f0ed77b19afTimo Sirainen ck_assert_str_eq(arg->type, "b");

1279090ba03f9c176976a69ab7718f0ed77b19afTimo Sirainen

d6badc27cd6e8d3398877b6766cb0aaeef3a7800Timo Sirainen arg = find_arg(method->out_args, "where_we_crashed");

d6badc27cd6e8d3398877b6766cb0aaeef3a7800Timo Sirainen ck_assert(arg != NULL);

d6badc27cd6e8d3398877b6766cb0aaeef3a7800Timo Sirainen ck_assert_str_eq(arg->name, "where_we_crashed");

24fc71a693331ffe77e2b6d81c70aca6fa055e47Timo Sirainen ck_assert_str_eq(arg->type, "s");

24fc71a693331ffe77e2b6d81c70aca6fa055e47Timo Sirainen}

09c3a491f4f6ccebe290c7709bdc0d79a187610bTimo Sirainen

d5cebe7f98e63d4e2822863ef2faa4971e8b3a5dTimo SirainenSTART_TEST(test_properties)

09c3a491f4f6ccebe290c7709bdc0d79a187610bTimo Sirainen{

985fa802913c96ce6f2e25bbc788ee39c416a7e0Timo Sirainen const struct sbus_property_meta *prop;

1d3f7c1278168d5b1cbfa9a2cc9929a0909056b4Timo Sirainen

1279090ba03f9c176976a69ab7718f0ed77b19afTimo Sirainen prop = sbus_meta_find_property(&com_planetexpress_Ship_meta, "Color");

985fa802913c96ce6f2e25bbc788ee39c416a7e0Timo Sirainen ck_assert(prop != NULL);

3fe9483b2b412a14493e3120751b0e99ecfe9388Timo Sirainen ck_assert_str_eq(prop->name, "Color");

3fe9483b2b412a14493e3120751b0e99ecfe9388Timo Sirainen ck_assert_str_eq(prop->type, "s");

3fe9483b2b412a14493e3120751b0e99ecfe9388Timo Sirainen ck_assert_int_eq(prop->flags, SBUS_PROPERTY_READABLE);

3fe9483b2b412a14493e3120751b0e99ecfe9388Timo Sirainen}

3fe9483b2b412a14493e3120751b0e99ecfe9388Timo Sirainen

8d80659e504ffb34bb0c6a633184fece35751b18Timo SirainenSTART_TEST(test_signals)

8d80659e504ffb34bb0c6a633184fece35751b18Timo Sirainen{

1279090ba03f9c176976a69ab7718f0ed77b19afTimo Sirainen const struct sbus_signal_meta *signal;

1279090ba03f9c176976a69ab7718f0ed77b19afTimo Sirainen const struct sbus_arg_meta *arg;

1279090ba03f9c176976a69ab7718f0ed77b19afTimo Sirainen

1279090ba03f9c176976a69ab7718f0ed77b19afTimo Sirainen signal = sbus_meta_find_signal(&com_planetexpress_Ship_meta, "BecameSentient");

1279090ba03f9c176976a69ab7718f0ed77b19afTimo Sirainen ck_assert(signal != NULL);

1279090ba03f9c176976a69ab7718f0ed77b19afTimo Sirainen ck_assert_str_eq(signal->name, "BecameSentient");

1279090ba03f9c176976a69ab7718f0ed77b19afTimo Sirainen ck_assert(signal->args != NULL);

5a07b37a9df398b5189c14872a600384208ab74bTimo Sirainen

0cb2e8eb55e70f8ebe1e8349bdf49e4cbe5d8834Timo Sirainen arg = find_arg(signal->args, "gender");

ck_assert(arg != NULL);

ck_assert_str_eq(arg->name, "gender");

ck_assert_str_eq(arg->type, "s");

}

static int

mock_move_universe(struct sbus_request *dbus_req, void *data,

bool arg_smoothly, uint32_t arg_speed_factor)

{

/*

ck_assert(FALSE);

return com_planetexpress_Ship_MoveUniverse_finish(dbus_req, "here");

}

static int

mock_crash_now(struct sbus_request *dbus_req, void *data,

const char *where)

{

/*

ck_assert(FALSE);

return com_planetexpress_Ship_crash_now_finish(dbus_req);

}

static int

mock_land(struct sbus_request *req, void *data)

{

/*

ck_assert(FALSE);

return 0;

}

START_TEST(test_vtable)

{

struct com_planetexpress_Ship vtable = {

{ &com_planetexpress_Ship_meta, 0 },

mock_move_universe,

mock_crash_now,

mock_land,

};

/*

ck_assert(vtable.crash_now == mock_crash_now);

ck_assert(vtable.MoveUniverse == mock_move_universe);

ck_assert(vtable.Land == mock_land);

}

START_TEST(test_constants)

{

ck_assert_str_eq(COM_PLANETEXPRESS_SHIP, "com.planetexpress.Ship");

ck_assert_str_eq(COM_PLANETEXPRESS_SHIP_MOVEUNIVERSE, "MoveUniverse");

ck_assert_str_eq(COM_PLANETEXPRESS_SHIP_CRASH_NOW, "Crash");

ck_assert_str_eq(COM_PLANETEXPRESS_SHIP_BECAMESENTIENT, "BecameSentient");

ck_assert_str_eq(COM_PLANETEXPRESS_SHIP_COLOR, "Color");

/* constants for com.planetexpress.Pilot */

ck_assert_str_eq(TEST_PILOT, "com.planetexpress.Pilot");

ck_assert_str_eq(TEST_PILOT_FULLNAME, "FullName");

}

TCase *create_defs_tests(void)

{

TCase *tc = tcase_create("defs");

/* Do some testing */

tcase_add_test(tc, test_interfaces);

tcase_add_test(tc, test_methods);

tcase_add_test(tc, test_properties);

tcase_add_test(tc, test_signals);

tcase_add_test(tc, test_vtable);

tcase_add_test(tc, test_constants);

return tc;

}

static int eject_handler(struct sbus_request *req, void *instance_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)

{

int i;

/* Only called for leela, so double check here */

ck_assert_str_eq(instance_data, "Crash into the billboard");

/* Murge the various values for test case */

ck_assert_uint_eq(arg_byte, 11);

arg_byte++;

ck_assert(arg_boolean == TRUE);

arg_boolean = !arg_boolean;

ck_assert_int_eq(arg_int16, -2222);

arg_int16++;

ck_assert_uint_eq(arg_uint16, 3333);

arg_uint16++;

ck_assert_int_eq(arg_int32, -44444444);

arg_int32++;

ck_assert_uint_eq(arg_uint32, 55555555);

arg_uint32++;

ck_assert(arg_int64 == -6666666666666666);

arg_int64++;

ck_assert(arg_uint64 == 7777777777777777);

arg_uint64++;

ck_assert(arg_double == 1.1);

arg_double++;

ck_assert_str_eq(arg_string, "hello");

arg_string = "bears, beets, battlestar galactica";

ck_assert_str_eq(arg_object_path, "/original/object/path");

arg_object_path = "/another/object/path";

arg_byte_array = talloc_memdup(req, arg_byte_array, sizeof(uint8_t) * len_byte_array);

for (i = 0; i < len_byte_array; i++)

arg_byte_array[i]++;

arg_int16_array = talloc_memdup(req, arg_int16_array, sizeof(int16_t) * len_int16_array);

for (i = 0; i < len_int16_array; i++)

arg_int16_array[i]++;

len_int16_array--;

arg_uint16_array = talloc_memdup(req, arg_uint16_array, sizeof(uint16_t) * len_uint16_array);

for (i = 0; i < len_uint16_array; i++)

arg_uint16_array[i]++;

arg_int32_array = talloc_memdup(req, arg_int32_array, sizeof(int32_t) * len_int32_array);

for (i = 0; i < len_int32_array; i++)

arg_int32_array[i]++;

len_int32_array--;

arg_uint32_array = talloc_memdup(req, arg_uint32_array, sizeof(uint32_t) * len_uint32_array);

for (i = 0; i < len_uint32_array; i++)

arg_uint32_array[i]++;

arg_int64_array = talloc_memdup(req, arg_int64_array, sizeof(int64_t) * len_int64_array);

for (i = 0; i < len_int64_array; i++)

arg_int64_array[i]++;

arg_uint64_array = talloc_memdup(req, arg_uint64_array, sizeof(uint64_t) * len_uint64_array);

for (i = 0; i < len_uint64_array; i++)

arg_uint64_array[i]++;

arg_double_array = talloc_memdup(req, arg_double_array, sizeof(double) * len_double_array);

for (i = 0; i < len_double_array; i++)

arg_double_array[i]++;

arg_string_array = talloc_memdup(req, arg_string_array, sizeof(char *) * len_string_array);

for (i = 0; i < len_double_array; i++) {

ck_assert_str_eq(arg_string_array[i], "bears");

arg_string_array[i] = "beets";

}

len_string_array--;

arg_object_path_array = talloc_memdup(req, arg_object_path_array, sizeof(char *) * len_object_path_array);

for (i = 0; i < len_object_path_array; i++) {

ck_assert_str_eq(arg_object_path_array[i], "/original");

arg_object_path_array[i] = "/changed";

}

/* And reply with those values */

return test_pilot_Eject_finish(req, arg_byte, arg_boolean, arg_int16,

arg_uint16, arg_int32, arg_uint32,

arg_int64, arg_uint64, arg_double,

arg_string, arg_object_path,

arg_byte_array, len_byte_array,

arg_int16_array, len_int16_array,

arg_uint16_array, len_uint16_array,

arg_int32_array, len_int32_array,

arg_uint32_array, len_uint32_array,

arg_int64_array, len_int64_array,

arg_uint64_array, len_uint64_array,

arg_double_array, len_double_array,

arg_string_array, len_string_array,

arg_object_path_array, len_object_path_array);

}

#define N_ELEMENTS(arr) \

(sizeof(arr) / sizeof(arr[0]))

struct test_pilot pilot_methods = {

{ &test_pilot_meta, 0 },

.Eject = eject_handler,

};

static int pilot_test_server_init(struct sbus_connection *server, void *unused)

{

int ret;

ret = sbus_conn_add_interface(server,

sbus_new_interface(server, "/test/leela",

&pilot_methods.vtable,

"Crash into the billboard"));

ck_assert_int_eq(ret, EOK);

return EOK;

}

START_TEST(test_marshal_basic_types)

{

unsigned char arg_byte = 11;

dbus_bool_t arg_boolean = TRUE;

dbus_int16_t arg_int16 = -2222;

dbus_uint16_t arg_uint16 = 3333;

dbus_int32_t arg_int32 = -44444444;

dbus_uint32_t arg_uint32 = 55555555;

dbus_int64_t arg_int64 = -6666666666666666;

dbus_uint64_t arg_uint64 = 7777777777777777;

double arg_double = 1.1;

const char *arg_string = "hello";

const char *arg_object_path = "/original/object/path";

unsigned char v_byte[] = { 11, 12 };

dbus_int16_t v_int16[] = { 1, -22, 333, -4444 };

dbus_uint16_t v_uint16[] = { 1, 2, 3, 4, 5 };

dbus_int32_t v_int32[] = { -1, -23, 34, -56, -90000000, 78 };

dbus_uint32_t v_uint32[] = { 11111111, 22222222, 33333333 };

dbus_int64_t v_int64[] = { -6666666666666666, 7777777777777777 };

dbus_uint64_t v_uint64[] = { 7777777777777777, 888888888888888888 };

double v_double[] = { 1.1, 2.2, 3.3 };

char *v_string[] = { "bears", "bears", "bears" };

char *v_object_path[] = { "/original", "/original" };

unsigned char *arr_byte = v_byte;

dbus_int16_t *arr_int16 = v_int16;

dbus_uint16_t *arr_uint16 = v_uint16;

dbus_int32_t *arr_int32 = v_int32;

dbus_uint32_t *arr_uint32 = v_uint32;

dbus_int64_t *arr_int64 = v_int64;

dbus_uint64_t *arr_uint64 = v_uint64;

double *arr_double = v_double;

char **arr_string = v_string;

char **arr_object_path = v_object_path;

int len_byte = N_ELEMENTS(v_byte);

int len_int16 = N_ELEMENTS(v_int16);

int len_uint16 = N_ELEMENTS(v_uint16);

int len_int32 = N_ELEMENTS(v_int32);

int len_uint32 = N_ELEMENTS(v_uint32);

int len_int64 = N_ELEMENTS(v_int64);

int len_uint64 = N_ELEMENTS(v_uint64);

int len_double = N_ELEMENTS(v_double);

int len_string = N_ELEMENTS(v_string);

int len_object_path = N_ELEMENTS(v_object_path);

TALLOC_CTX *ctx;

DBusConnection *client;

DBusError error = DBUS_ERROR_INIT;

DBusMessage *reply;

ctx = talloc_new(NULL);

client = test_dbus_setup_mock(ctx, NULL, pilot_test_server_init, NULL);

reply = test_dbus_call_sync(client,

"/test/leela",

TEST_PILOT,

TEST_PILOT_EJECT,

&error,

DBUS_TYPE_BYTE, &arg_byte,

DBUS_TYPE_BOOLEAN, &arg_boolean,

DBUS_TYPE_INT16, &arg_int16,

DBUS_TYPE_UINT16, &arg_uint16,

DBUS_TYPE_INT32, &arg_int32,

DBUS_TYPE_UINT32, &arg_uint32,

DBUS_TYPE_INT64, &arg_int64,

DBUS_TYPE_UINT64, &arg_uint64,

DBUS_TYPE_DOUBLE, &arg_double,

DBUS_TYPE_STRING, &arg_string,

DBUS_TYPE_OBJECT_PATH, &arg_object_path,

DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE, &arr_byte, len_byte,

DBUS_TYPE_ARRAY, DBUS_TYPE_INT16, &arr_int16, len_int16,

DBUS_TYPE_ARRAY, DBUS_TYPE_UINT16, &arr_uint16, len_uint16,

DBUS_TYPE_ARRAY, DBUS_TYPE_INT32, &arr_int32, len_int32,

DBUS_TYPE_ARRAY, DBUS_TYPE_UINT32, &arr_uint32, len_uint32,

DBUS_TYPE_ARRAY, DBUS_TYPE_INT64, &arr_int64, len_int64,

DBUS_TYPE_ARRAY, DBUS_TYPE_UINT64, &arr_uint64, len_uint64,

DBUS_TYPE_ARRAY, DBUS_TYPE_DOUBLE, &arr_double, len_double,

DBUS_TYPE_ARRAY, DBUS_TYPE_STRING, &arr_string, len_string,

DBUS_TYPE_ARRAY, DBUS_TYPE_OBJECT_PATH, &arr_object_path, len_object_path,

DBUS_TYPE_INVALID);

ck_assert(reply != NULL);

ck_assert(!dbus_error_is_set(&error));

ck_assert(dbus_message_get_args(reply, NULL,

DBUS_TYPE_BYTE, &arg_byte,

DBUS_TYPE_BOOLEAN, &arg_boolean,

DBUS_TYPE_INT16, &arg_int16,

DBUS_TYPE_UINT16, &arg_uint16,

DBUS_TYPE_INT32, &arg_int32,

DBUS_TYPE_UINT32, &arg_uint32,

DBUS_TYPE_INT64, &arg_int64,

DBUS_TYPE_UINT64, &arg_uint64,

DBUS_TYPE_DOUBLE, &arg_double,

DBUS_TYPE_STRING, &arg_string,

DBUS_TYPE_OBJECT_PATH, &arg_object_path,

DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE, &arr_byte, &len_byte,

DBUS_TYPE_ARRAY, DBUS_TYPE_INT16, &arr_int16, &len_int16,

DBUS_TYPE_ARRAY, DBUS_TYPE_UINT16, &arr_uint16, &len_uint16,

DBUS_TYPE_ARRAY, DBUS_TYPE_INT32, &arr_int32, &len_int32,

DBUS_TYPE_ARRAY, DBUS_TYPE_UINT32, &arr_uint32, &len_uint32,

DBUS_TYPE_ARRAY, DBUS_TYPE_INT64, &arr_int64, &len_int64,

DBUS_TYPE_ARRAY, DBUS_TYPE_UINT64, &arr_uint64, &len_uint64,

DBUS_TYPE_ARRAY, DBUS_TYPE_DOUBLE, &arr_double, &len_double,

DBUS_TYPE_ARRAY, DBUS_TYPE_STRING, &arr_string, &len_string,

DBUS_TYPE_ARRAY, DBUS_TYPE_OBJECT_PATH, &arr_object_path, &len_object_path,

DBUS_TYPE_INVALID));

ck_assert_uint_eq(arg_byte, 12);

ck_assert(arg_boolean == FALSE);

ck_assert_int_eq(arg_int16, -2221);

ck_assert_uint_eq(arg_uint16, 3334);

ck_assert_int_eq(arg_int32, -44444443);

ck_assert_uint_eq(arg_uint32, 55555556);

ck_assert(arg_int64 ==-6666666666666665);

ck_assert(arg_uint64 == 7777777777777778);

ck_assert(arg_double == 2.1);

ck_assert_str_eq(arg_string, "bears, beets, battlestar galactica");

ck_assert_str_eq(arg_object_path, "/another/object/path");

ck_assert_int_eq(len_byte, 2);

ck_assert_int_eq(arr_byte[0], 12);

ck_assert_int_eq(arr_byte[1], 13);

ck_assert_int_eq(len_int16, 3);

ck_assert_int_eq(arr_int16[0], 2);

ck_assert_int_eq(arr_int16[1], -21);

ck_assert_int_eq(arr_int16[2], 334);

ck_assert_int_eq(len_uint16, 5);

ck_assert_uint_eq(arr_uint16[0], 2);

ck_assert_uint_eq(arr_uint16[1], 3);

ck_assert_uint_eq(arr_uint16[2], 4);

ck_assert_uint_eq(arr_uint16[3], 5);

ck_assert_uint_eq(arr_uint16[4], 6);

ck_assert_int_eq(len_int32, 5);

ck_assert_int_eq(arr_int32[0], 0);

ck_assert_int_eq(arr_int32[1], -22);

ck_assert_int_eq(arr_int32[2], 35);

ck_assert_int_eq(arr_int32[3], -55);

ck_assert_int_eq(arr_int32[4], -89999999);

ck_assert_int_eq(len_uint32, 3);

ck_assert_uint_eq(arr_uint32[0], 11111112);

ck_assert_uint_eq(arr_uint32[1], 22222223);

ck_assert_uint_eq(arr_uint32[2], 33333334);

ck_assert_int_eq(len_int64, 2);

ck_assert(arr_int64[0] == -6666666666666665);

ck_assert(arr_int64[1] == 7777777777777778);

ck_assert_int_eq(len_uint64, 2);

ck_assert(arr_uint64[0] == 7777777777777778);

ck_assert(arr_uint64[1] == 888888888888888889);

ck_assert_int_eq(len_double, 3);

ck_assert(arr_double[0] == 2.1);

ck_assert(arr_double[1] == 3.2);

ck_assert(arr_double[2] == 4.3);

ck_assert_int_eq(len_string, 2);

ck_assert_str_eq(arr_string[0], "beets");

ck_assert_str_eq(arr_string[1], "beets");

dbus_free_string_array(arr_string);

ck_assert_int_eq(len_object_path, 2);

ck_assert_str_eq(arr_object_path[0], "/changed");

ck_assert_str_eq(arr_object_path[1], "/changed");

dbus_free_string_array(arr_object_path);

dbus_message_unref (reply);

talloc_free(ctx);

}

TCase *create_handler_tests(void)

{

TCase *tc = tcase_create("handler");

tcase_add_test(tc, test_marshal_basic_types);

return tc;

}

Suite *create_suite(void)

{

Suite *s = suite_create("sbus_codegen");

suite_add_tcase(s, create_defs_tests ());

suite_add_tcase(s, create_handler_tests ());

return s;

}

int main(int argc, const char *argv[])

{

int opt;

poptContext pc;

int failure_count;

Suite *suite;

SRunner *sr;

struct poptOption long_options[] = {

POPT_AUTOHELP

POPT_TABLEEND

};

pc = poptGetContext(argv[0], argc, argv, long_options, 0);

while ((opt = poptGetNextOpt(pc)) != -1) {

switch (opt) {

default:

fprintf(stderr, "\nInvalid option %s: %s\n\n",

poptBadOption(pc, 0), poptStrerror(opt));

poptPrintUsage(pc, stderr, 0);

return 1;

}

}

poptFreeContext(pc);

suite = create_suite();

sr = srunner_create(suite);

/* If CK_VERBOSITY is set, use that, otherwise it defaults to CK_NORMAL */

srunner_run_all(sr, CK_ENV);

failure_count = srunner_ntests_failed(sr);

srunner_free(sr);

return (failure_count == 0 ? EXIT_SUCCESS : EXIT_FAILURE);

}