From 49f3d5842e5806ac23111a0b3819f33a5d714eac Mon Sep 17 00:00:00 2001 From: Peter Hutterer Date: Tue, 27 Jul 2021 09:59:41 +1000 Subject: [PATCH] test: replace all spa_assert() macros with spa_assert_se() These are tests, we never want those to be optimized away. --- spa/plugins/audioconvert/test-audioadapter.c | 26 +- spa/plugins/audioconvert/test-audioconvert.c | 42 +- spa/plugins/audioconvert/test-channelmix.c | 2 +- spa/plugins/audioconvert/test-fmt-ops.c | 2 +- spa/plugins/audioconvert/test-resample.c | 4 +- .../module-protocol-native/test-connection.c | 56 +- src/tests/test-client.c | 6 +- src/tests/test-endpoint.c | 80 +- src/tests/test-interfaces.c | 74 +- src/tests/test-stream.c | 86 +- src/tests/test-utils.c | 36 +- test/pwtest.c | 34 +- test/test-spa-node.c | 8 +- test/test-spa-pod.c | 1506 ++++++++--------- 14 files changed, 981 insertions(+), 981 deletions(-) diff --git a/spa/plugins/audioconvert/test-audioadapter.c b/spa/plugins/audioconvert/test-audioadapter.c index 300410b66..d1500618a 100644 --- a/spa/plugins/audioconvert/test-audioadapter.c +++ b/spa/plugins/audioconvert/test-audioadapter.c @@ -80,27 +80,27 @@ static int setup_context(struct context *ctx) factory = &test_source_factory; size = spa_handle_factory_get_size(factory, NULL); ctx->follower_handle = calloc(1, size); - spa_assert(ctx->follower_handle != NULL); + spa_assert_se(ctx->follower_handle != NULL); res = spa_handle_factory_init(factory, ctx->follower_handle, NULL, support, 1); - spa_assert(res >= 0); + spa_assert_se(res >= 0); res = spa_handle_get_interface(ctx->follower_handle, SPA_TYPE_INTERFACE_Node, &iface); - spa_assert(res >= 0); + spa_assert_se(res >= 0); ctx->follower_node = iface; /* make adapter */ factory = find_factory(SPA_NAME_AUDIO_ADAPT); - spa_assert(factory != NULL); + spa_assert_se(factory != NULL); size = spa_handle_factory_get_size(factory, NULL); ctx->adapter_handle = calloc(1, size); - spa_assert(ctx->adapter_handle != NULL); + spa_assert_se(ctx->adapter_handle != NULL); snprintf(value, sizeof(value), "pointer:%p", ctx->follower_node); items[0] = SPA_DICT_ITEM_INIT("audio.adapt.follower", value); @@ -109,11 +109,11 @@ static int setup_context(struct context *ctx) ctx->adapter_handle, &SPA_DICT_INIT(items, 1), support, 1); - spa_assert(res >= 0); + spa_assert_se(res >= 0); res = spa_handle_get_interface(ctx->adapter_handle, SPA_TYPE_INTERFACE_Node, &iface); - spa_assert(res >= 0); + spa_assert_se(res >= 0); ctx->adapter_node = iface; return 0; @@ -134,8 +134,8 @@ static void node_info(void *data, const struct spa_node_info *info) info->max_input_ports, info->max_output_ports); - spa_assert(info->max_input_ports == 0); - spa_assert(info->max_output_ports > 0); + spa_assert_se(info->max_input_ports == 0); + spa_assert_se(info->max_output_ports > 0); } static void port_info_none(void *data, @@ -167,8 +167,8 @@ static void port_info_5_1(void *data, enum spa_direction direction, uint32_t port, const struct spa_port_info *info) { - spa_assert(direction == SPA_DIRECTION_OUTPUT); - spa_assert(port < 6); + spa_assert_se(direction == SPA_DIRECTION_OUTPUT); + spa_assert_se(port < 6); } static int test_split_setup(struct context *ctx) @@ -207,7 +207,7 @@ static int test_split_setup(struct context *ctx) SPA_PARAM_PORT_CONFIG_format, SPA_POD_Pod(param)); res = spa_node_set_param(ctx->adapter_node, SPA_PARAM_PortConfig, 0, param); - spa_assert(res == 0); + spa_assert_se(res == 0); spa_zero(listener); spa_node_add_listener(ctx->adapter_node, @@ -228,7 +228,7 @@ static int test_split_setup(struct context *ctx) spa_log_debug(&logger.log, "set format %d@%d", info.channels, info.rate); res = spa_node_set_param(ctx->adapter_node, SPA_PARAM_Format, 0, param); spa_log_debug(&logger.log, "result %d", res); - spa_assert(res >= 0); + spa_assert_se(res >= 0); return 0; } diff --git a/spa/plugins/audioconvert/test-audioconvert.c b/spa/plugins/audioconvert/test-audioconvert.c index b99923f50..72ae39d1f 100644 --- a/spa/plugins/audioconvert/test-audioconvert.c +++ b/spa/plugins/audioconvert/test-audioconvert.c @@ -79,22 +79,22 @@ static int setup_context(struct context *ctx) /* make convert */ factory = find_factory(SPA_NAME_AUDIO_CONVERT); - spa_assert(factory != NULL); + spa_assert_se(factory != NULL); size = spa_handle_factory_get_size(factory, NULL); ctx->convert_handle = calloc(1, size); - spa_assert(ctx->convert_handle != NULL); + spa_assert_se(ctx->convert_handle != NULL); res = spa_handle_factory_init(factory, ctx->convert_handle, NULL, support, 1); - spa_assert(res >= 0); + spa_assert_se(res >= 0); res = spa_handle_get_interface(ctx->convert_handle, SPA_TYPE_INTERFACE_Node, &iface); - spa_assert(res >= 0); + spa_assert_se(res >= 0); ctx->convert_node = iface; return 0; @@ -115,8 +115,8 @@ static void node_info_check(void *data, const struct spa_node_info *info) info->max_input_ports, info->max_output_ports); - spa_assert(info->max_input_ports == MAX_PORTS); - spa_assert(info->max_output_ports == MAX_PORTS); + spa_assert_se(info->max_input_ports == MAX_PORTS); + spa_assert_se(info->max_output_ports == MAX_PORTS); ctx->got_node_info = true; } @@ -151,11 +151,11 @@ static int test_init_state(struct context *ctx) &listener, &init_events, ctx); spa_hook_remove(&listener); - spa_assert(ctx->got_node_info); - spa_assert(ctx->n_port_info[0] == 1); - spa_assert(ctx->n_port_info[1] == 1); - spa_assert(ctx->got_port_info[0][0] == true); - spa_assert(ctx->got_port_info[1][0] == true); + spa_assert_se(ctx->got_node_info); + spa_assert_se(ctx->n_port_info[0] == 1); + spa_assert_se(ctx->n_port_info[1] == 1); + spa_assert_se(ctx->got_port_info[0][0] == true); + spa_assert_se(ctx->got_port_info[1][0] == true); return 0; } @@ -181,7 +181,7 @@ static int test_set_in_format(struct context *ctx) res = spa_node_port_set_param(ctx->convert_node, SPA_DIRECTION_INPUT, 0, SPA_PARAM_Format, 0, param); - spa_assert(res == 0); + spa_assert_se(res == 0); return 0; } @@ -225,7 +225,7 @@ static int test_split_setup1(struct context *ctx) SPA_PARAM_PORT_CONFIG_format, SPA_POD_Pod(param)); res = spa_node_set_param(ctx->convert_node, SPA_PARAM_PortConfig, 0, param); - spa_assert(res == 0); + spa_assert_se(res == 0); spa_hook_remove(&listener); @@ -269,7 +269,7 @@ static int test_split_setup2(struct context *ctx) SPA_PARAM_PORT_CONFIG_format, SPA_POD_Pod(param)); res = spa_node_set_param(ctx->convert_node, SPA_PARAM_PortConfig, 0, param); - spa_assert(res == 0); + spa_assert_se(res == 0); spa_hook_remove(&listener); @@ -300,7 +300,7 @@ static int test_convert_setup1(struct context *ctx) SPA_PARAM_PORT_CONFIG_mode, SPA_POD_Id(SPA_PARAM_PORT_CONFIG_MODE_convert)); res = spa_node_set_param(ctx->convert_node, SPA_PARAM_PortConfig, 0, param); - spa_assert(res == 0); + spa_assert_se(res == 0); spa_hook_remove(&listener); @@ -331,7 +331,7 @@ static int test_set_out_format(struct context *ctx) res = spa_node_port_set_param(ctx->convert_node, SPA_DIRECTION_OUTPUT, 0, SPA_PARAM_Format, 0, param); - spa_assert(res == 0); + spa_assert_se(res == 0); return 0; } @@ -375,7 +375,7 @@ static int test_merge_setup1(struct context *ctx) SPA_PARAM_PORT_CONFIG_format, SPA_POD_Pod(param)); res = spa_node_set_param(ctx->convert_node, SPA_PARAM_PortConfig, 0, param); - spa_assert(res == 0); + spa_assert_se(res == 0); spa_hook_remove(&listener); @@ -403,7 +403,7 @@ static int test_set_out_format2(struct context *ctx) res = spa_node_port_set_param(ctx->convert_node, SPA_DIRECTION_OUTPUT, 0, SPA_PARAM_Format, 0, param); - spa_assert(res == 0); + spa_assert_se(res == 0); return 0; } @@ -445,7 +445,7 @@ static int test_merge_setup2(struct context *ctx) SPA_PARAM_PORT_CONFIG_format, SPA_POD_Pod(param)); res = spa_node_set_param(ctx->convert_node, SPA_PARAM_PortConfig, 0, param); - spa_assert(res == 0); + spa_assert_se(res == 0); spa_hook_remove(&listener); @@ -476,7 +476,7 @@ static int test_convert_setup2(struct context *ctx) SPA_PARAM_PORT_CONFIG_mode, SPA_POD_Id(SPA_PARAM_PORT_CONFIG_MODE_convert)); res = spa_node_set_param(ctx->convert_node, SPA_PARAM_PortConfig, 0, param); - spa_assert(res == 0); + spa_assert_se(res == 0); spa_hook_remove(&listener); @@ -505,7 +505,7 @@ static int test_set_in_format2(struct context *ctx) res = spa_node_port_set_param(ctx->convert_node, SPA_DIRECTION_INPUT, 0, SPA_PARAM_Format, 0, param); - spa_assert(res == 0); + spa_assert_se(res == 0); return 0; } diff --git a/spa/plugins/audioconvert/test-channelmix.c b/spa/plugins/audioconvert/test-channelmix.c index fa279cd1d..d55a75db1 100644 --- a/spa/plugins/audioconvert/test-channelmix.c +++ b/spa/plugins/audioconvert/test-channelmix.c @@ -45,7 +45,7 @@ static void dump_matrix(struct channelmix *mix, float *coeff) for (j = 0; j < mix->src_chan; j++) { float v = mix->matrix_orig[i][j]; spa_log_debug(mix->log, "%d %d: %f <-> %f", i, j, v, *coeff); - spa_assert(fabs(v - *coeff) < 0.000001); + spa_assert_se(fabs(v - *coeff) < 0.000001); coeff++; } } diff --git a/spa/plugins/audioconvert/test-fmt-ops.c b/spa/plugins/audioconvert/test-fmt-ops.c index c234d0b23..7ad73bfa6 100644 --- a/spa/plugins/audioconvert/test-fmt-ops.c +++ b/spa/plugins/audioconvert/test-fmt-ops.c @@ -54,7 +54,7 @@ static void compare_mem(int i, int j, const void *m1, const void *m2, size_t siz spa_debug_mem(0, m1, size); spa_debug_mem(0, m2, size); } -// spa_assert(res == 0); +// spa_assert_se(res == 0); } static void run_test(const char *name, diff --git a/spa/plugins/audioconvert/test-resample.c b/spa/plugins/audioconvert/test-resample.c index 5f2526a90..4f11f53f9 100644 --- a/spa/plugins/audioconvert/test-resample.c +++ b/spa/plugins/audioconvert/test-resample.c @@ -112,8 +112,8 @@ static void pull_blocks(struct resample *r, uint32_t first, uint32_t size) in_len, pin_len, out_len, pout_len, resample_in_len(r, size)); - spa_assert(in_len == pin_len); - spa_assert(out_len == pout_len); + spa_assert_se(in_len == pin_len); + spa_assert_se(out_len == pout_len); } } diff --git a/src/modules/module-protocol-native/test-connection.c b/src/modules/module-protocol-native/test-connection.c index 16c432cf8..666f0c942 100644 --- a/src/modules/module-protocol-native/test-connection.c +++ b/src/modules/module-protocol-native/test-connection.c @@ -38,16 +38,16 @@ static void test_create(struct pw_protocol_native_connection *conn) int res; res = pw_protocol_native_connection_get_next(conn, &msg); - spa_assert(res != 1); + spa_assert_se(res != 1); res = pw_protocol_native_connection_get_fd(conn, 0); - spa_assert(res == -ENOENT); + spa_assert_se(res == -ENOENT); res = pw_protocol_native_connection_flush(conn); - spa_assert(res == 0); + spa_assert_se(res == 0); res = pw_protocol_native_connection_clear(conn); - spa_assert(res == 0); + spa_assert_se(res == 0); } static void write_message(struct pw_protocol_native_connection *conn, int fd) @@ -57,8 +57,8 @@ static void write_message(struct pw_protocol_native_connection *conn, int fd) int seq = -1, res; b = pw_protocol_native_connection_begin(conn, 1, 5, &msg); - spa_assert(b != NULL); - spa_assert(msg->seq != -1); + spa_assert_se(b != NULL); + spa_assert_se(msg->seq != -1); seq = SPA_RESULT_RETURN_ASYNC(msg->seq); @@ -68,7 +68,7 @@ static void write_message(struct pw_protocol_native_connection *conn, int fd) SPA_POD_Int(pw_protocol_native_connection_add_fd(conn, fd))); res = pw_protocol_native_connection_end(conn, b); - spa_assert(seq == res); + spa_assert_se(seq == res); } static int read_message(struct pw_protocol_native_connection *conn, @@ -88,10 +88,10 @@ static int read_message(struct pw_protocol_native_connection *conn, if (pmsg) *pmsg = msg; - spa_assert(msg->opcode == 5); - spa_assert(msg->id == 1); - spa_assert(msg->data != NULL); - spa_assert(msg->size > 0); + spa_assert_se(msg->opcode == 5); + spa_assert_se(msg->id == 1); + spa_assert_se(msg->data != NULL); + spa_assert_se(msg->size > 0); spa_pod_parser_init(&prs, msg->data, msg->size); if (spa_pod_parser_get_struct(&prs, @@ -101,7 +101,7 @@ static int read_message(struct pw_protocol_native_connection *conn, spa_assert_not_reached(); fd = pw_protocol_native_connection_get_fd(conn, fdidx); - spa_assert(fd != -ENOENT); + spa_assert_se(fd != -ENOENT); pw_log_debug("got fd %d %d", fdidx, fd); return 0; } @@ -113,16 +113,16 @@ static void test_read_write(struct pw_protocol_native_connection *in, pw_protocol_native_connection_flush(out); write_message(out, 2); pw_protocol_native_connection_flush(out); - spa_assert(read_message(in, NULL) == 0); - spa_assert(read_message(in, NULL) == 0); - spa_assert(read_message(in, NULL) == -1); + spa_assert_se(read_message(in, NULL) == 0); + spa_assert_se(read_message(in, NULL) == 0); + spa_assert_se(read_message(in, NULL) == -1); write_message(out, 1); write_message(out, 2); pw_protocol_native_connection_flush(out); - spa_assert(read_message(in, NULL) == 0); - spa_assert(read_message(in, NULL) == 0); - spa_assert(read_message(in, NULL) == -1); + spa_assert_se(read_message(in, NULL) == 0); + spa_assert_se(read_message(in, NULL) == 0); + spa_assert_se(read_message(in, NULL) == -1); } static void test_reentering(struct pw_protocol_native_connection *in, @@ -132,16 +132,16 @@ static void test_reentering(struct pw_protocol_native_connection *in, int i; #define READ_MSG(idx) \ - spa_assert(read_message(in, &msg ## idx) == 0); \ - spa_assert((msg ## idx)->n_fds == 1); \ - spa_assert((msg ## idx)->size < sizeof(buf ## idx)); \ + spa_assert_se(read_message(in, &msg ## idx) == 0); \ + spa_assert_se((msg ## idx)->n_fds == 1); \ + spa_assert_se((msg ## idx)->size < sizeof(buf ## idx)); \ fd ## idx = (msg ## idx)->fds[0]; \ memcpy(buf ## idx, (msg ## idx)->data, (msg ## idx)->size); \ size ## idx = (msg ## idx)->size #define CHECK_MSG(idx) \ - spa_assert((msg ## idx)->fds[0] == fd ## idx); \ - spa_assert(memcmp((msg ## idx)->data, buf ## idx, size ## idx) == 0) + spa_assert_se((msg ## idx)->fds[0] == fd ## idx); \ + spa_assert_se(memcmp((msg ## idx)->data, buf ## idx, size ## idx) == 0) for (i = 0; i < 50; ++i) { int fd1, fd2; @@ -165,16 +165,16 @@ static void test_reentering(struct pw_protocol_native_connection *in, CHECK_MSG(2); pw_protocol_native_connection_enter(in); /* 2 */ pw_protocol_native_connection_enter(in); /* 3 */ - spa_assert(read_message(in, NULL) == 0); + spa_assert_se(read_message(in, NULL) == 0); CHECK_MSG(1); CHECK_MSG(2); pw_protocol_native_connection_leave(in); /* 3 */ - spa_assert(read_message(in, NULL) == 0); + spa_assert_se(read_message(in, NULL) == 0); CHECK_MSG(1); CHECK_MSG(2); pw_protocol_native_connection_leave(in); /* 2 */ CHECK_MSG(2); - spa_assert(read_message(in, NULL) == 0); + spa_assert_se(read_message(in, NULL) == 0); CHECK_MSG(1); pw_protocol_native_connection_leave(in); /* 1 */ CHECK_MSG(1); @@ -199,9 +199,9 @@ int main(int argc, char *argv[]) } in = pw_protocol_native_connection_new(context, fds[0]); - spa_assert(in != NULL); + spa_assert_se(in != NULL); out = pw_protocol_native_connection_new(context, fds[1]); - spa_assert(out != NULL); + spa_assert_se(out != NULL); test_create(in); test_create(out); diff --git a/src/tests/test-client.c b/src/tests/test-client.c index 5dc22ea82..3be03deff 100644 --- a/src/tests/test-client.c +++ b/src/tests/test-client.c @@ -28,7 +28,7 @@ #define TEST_FUNC(a,b,func) \ do { \ a.func = b.func; \ - spa_assert(SPA_PTRDIFF(&a.func, &a) == SPA_PTRDIFF(&b.func, &b)); \ + spa_assert_se(SPA_PTRDIFF(&a.func, &a) == SPA_PTRDIFF(&b.func, &b)); \ } while(0) static void test_abi(void) @@ -54,8 +54,8 @@ static void test_abi(void) TEST_FUNC(ev, test, resource_removed); TEST_FUNC(ev, test, busy_changed); - spa_assert(PW_VERSION_IMPL_CLIENT_EVENTS == 0); - spa_assert(sizeof(ev) == sizeof(test)); + spa_assert_se(PW_VERSION_IMPL_CLIENT_EVENTS == 0); + spa_assert_se(sizeof(ev) == sizeof(test)); } int main(int argc, char *argv[]) diff --git a/src/tests/test-endpoint.c b/src/tests/test-endpoint.c index 5dc3874ac..d575e0b30 100644 --- a/src/tests/test-endpoint.c +++ b/src/tests/test-endpoint.c @@ -272,27 +272,27 @@ endpoint_event_info(void *object, const struct pw_endpoint_info *info) struct test_endpoint_data *d = object; const char *val; - spa_assert(info); - spa_assert(info->version == PW_VERSION_ENDPOINT_INFO); - spa_assert(info->id == pw_proxy_get_bound_id(d->bound_proxy)); - spa_assert(info->id == pw_proxy_get_bound_id(d->export_proxy)); - spa_assert(info->change_mask == PW_ENDPOINT_CHANGE_MASK_ALL); - spa_assert(spa_streq(info->name, "test-endpoint")); - spa_assert(spa_streq(info->media_class, "Audio/Sink")); - spa_assert(info->direction == PW_DIRECTION_OUTPUT); - spa_assert(info->n_streams == 0); - spa_assert(info->session_id == SPA_ID_INVALID); - spa_assert(info->n_params == SPA_N_ELEMENTS (param_info)); - spa_assert(info->n_params == 2); - spa_assert(info->params[0].id == param_info[0].id); - spa_assert(info->params[0].flags == param_info[0].flags); - spa_assert(info->params[1].id == param_info[1].id); - spa_assert(info->params[1].flags == param_info[1].flags); - spa_assert(info->props != NULL); + spa_assert_se(info); + spa_assert_se(info->version == PW_VERSION_ENDPOINT_INFO); + spa_assert_se(info->id == pw_proxy_get_bound_id(d->bound_proxy)); + spa_assert_se(info->id == pw_proxy_get_bound_id(d->export_proxy)); + spa_assert_se(info->change_mask == PW_ENDPOINT_CHANGE_MASK_ALL); + spa_assert_se(spa_streq(info->name, "test-endpoint")); + spa_assert_se(spa_streq(info->media_class, "Audio/Sink")); + spa_assert_se(info->direction == PW_DIRECTION_OUTPUT); + spa_assert_se(info->n_streams == 0); + spa_assert_se(info->session_id == SPA_ID_INVALID); + spa_assert_se(info->n_params == SPA_N_ELEMENTS (param_info)); + spa_assert_se(info->n_params == 2); + spa_assert_se(info->params[0].id == param_info[0].id); + spa_assert_se(info->params[0].flags == param_info[0].flags); + spa_assert_se(info->params[1].id == param_info[1].id); + spa_assert_se(info->params[1].flags == param_info[1].flags); + spa_assert_se(info->props != NULL); val = spa_dict_lookup(info->props, PW_KEY_ENDPOINT_NAME); - spa_assert(val && spa_streq(val, "test-endpoint")); + spa_assert_se(val && spa_streq(val, "test-endpoint")); val = spa_dict_lookup(info->props, PW_KEY_MEDIA_CLASS); - spa_assert(val && spa_streq(val, "Audio/Sink")); + spa_assert_se(val && spa_streq(val, "Audio/Sink")); d->info_received = true; pw_main_loop_quit(d->loop); @@ -307,12 +307,12 @@ endpoint_event_param(void *object, int seq, if (id == SPA_PARAM_Props) { struct props *p = &d->props; - spa_assert(param); + spa_assert_se(param); spa_pod_parse_object(param, SPA_TYPE_OBJECT_Props, &id, SPA_PROP_volume, SPA_POD_OPT_Float(&p->volume), SPA_PROP_mute, SPA_POD_OPT_Bool(&p->mute)); - spa_assert(id == SPA_PARAM_Props); + spa_assert_se(id == SPA_PARAM_Props); } d->params_received++; @@ -351,13 +351,13 @@ test_endpoint_global(void *object, uint32_t id, d->bound_proxy = pw_registry_bind(d->registry, id, type, PW_VERSION_ENDPOINT, 0); - spa_assert(d->bound_proxy != NULL); + spa_assert_se(d->bound_proxy != NULL); - spa_assert(props != NULL); + spa_assert_se(props != NULL); val = spa_dict_lookup(props, PW_KEY_ENDPOINT_NAME); - spa_assert(val && spa_streq(val, "test-endpoint")); + spa_assert_se(val && spa_streq(val, "test-endpoint")); val = spa_dict_lookup(props, PW_KEY_MEDIA_CLASS); - spa_assert(val && spa_streq(val, "Audio/Sink")); + spa_assert_se(val && spa_streq(val, "Audio/Sink")); pw_endpoint_add_listener(d->bound_proxy, &d->object_listener, &endpoint_events, d); @@ -388,10 +388,10 @@ static void test_endpoint(void) d.loop = pw_main_loop_new(NULL); d.context = pw_context_new(pw_main_loop_get_loop(d.loop), NULL, 0); - spa_assert(d.context != NULL); + spa_assert_se(d.context != NULL); d.core = pw_context_connect_self(d.context, NULL, 0); - spa_assert(d.core != NULL); + spa_assert_se(d.core != NULL); d.registry = pw_core_get_registry(d.core, PW_VERSION_REGISTRY, 0); pw_registry_add_listener(d.registry, @@ -403,10 +403,10 @@ static void test_endpoint(void) endpoint_init(&d.endpoint); d.export_proxy = pw_core_export(d.core, PW_TYPE_INTERFACE_Endpoint, d.endpoint.info.props, &d.endpoint.iface, 0); - spa_assert(d.export_proxy != NULL); + spa_assert_se(d.export_proxy != NULL); pw_main_loop_run(d.loop); - spa_assert(d.bound_proxy); - spa_assert(d.info_received == true); + spa_assert_se(d.bound_proxy); + spa_assert_se(d.info_received == true); /* request params */ d.params_received = 0; @@ -414,9 +414,9 @@ static void test_endpoint(void) d.props.mute = true; pw_endpoint_subscribe_params(d.bound_proxy, ids, SPA_N_ELEMENTS(ids)); pw_main_loop_run(d.loop); - spa_assert(d.params_received == 1); - spa_assert(d.props.volume > 0.89 && d.props.volume < 0.91); - spa_assert(d.props.mute == false); + spa_assert_se(d.params_received == 1); + spa_assert_se(d.props.volume > 0.89 && d.props.volume < 0.91); + spa_assert_se(d.props.mute == false); /* set param from the client */ d.params_received = 0; @@ -425,9 +425,9 @@ static void test_endpoint(void) SPA_TYPE_OBJECT_Props, SPA_PARAM_Props, SPA_PROP_volume, SPA_POD_Float(0.5))); pw_main_loop_run(d.loop); - spa_assert(d.params_received == 1); - spa_assert(d.props.volume > 0.49 && d.props.volume < 0.51); - spa_assert(d.props.mute == false); + spa_assert_se(d.params_received == 1); + spa_assert_se(d.props.volume > 0.49 && d.props.volume < 0.51); + spa_assert_se(d.props.mute == false); /* set param from the impl */ d.params_received = 0; @@ -437,14 +437,14 @@ static void test_endpoint(void) SPA_PROP_volume, SPA_POD_Float(0.2), SPA_PROP_mute, SPA_POD_Bool(true))); pw_main_loop_run(d.loop); - spa_assert(d.params_received == 1); - spa_assert(d.props.volume > 0.19 && d.props.volume < 0.21); - spa_assert(d.props.mute == true); + spa_assert_se(d.params_received == 1); + spa_assert_se(d.props.volume > 0.19 && d.props.volume < 0.21); + spa_assert_se(d.props.mute == true); /* stop exporting and expect to see that reflected on the registry */ pw_proxy_destroy(d.export_proxy); pw_main_loop_run(d.loop); - spa_assert(!d.bound_proxy); + spa_assert_se(!d.bound_proxy); endpoint_clear(&d.endpoint); pw_proxy_destroy((struct pw_proxy*)d.registry); diff --git a/src/tests/test-interfaces.c b/src/tests/test-interfaces.c index 10b541f8f..e298f7ad6 100644 --- a/src/tests/test-interfaces.c +++ b/src/tests/test-interfaces.c @@ -27,7 +27,7 @@ #define TEST_FUNC(a,b,func) \ do { \ a.func = b.func; \ - spa_assert(SPA_PTRDIFF(&a.func, &a) == SPA_PTRDIFF(&b.func, &b)); \ + spa_assert_se(SPA_PTRDIFF(&a.func, &a) == SPA_PTRDIFF(&b.func, &b)); \ } while(0) static void test_core_abi(void) @@ -76,8 +76,8 @@ static void test_core_abi(void) TEST_FUNC(m, methods, get_registry); TEST_FUNC(m, methods, create_object); TEST_FUNC(m, methods, destroy); - spa_assert(PW_VERSION_CORE_METHODS == 0); - spa_assert(sizeof(m) == sizeof(methods)); + spa_assert_se(PW_VERSION_CORE_METHODS == 0); + spa_assert_se(sizeof(m) == sizeof(methods)); TEST_FUNC(e, events, version); TEST_FUNC(e, events, info); @@ -88,8 +88,8 @@ static void test_core_abi(void) TEST_FUNC(e, events, bound_id); TEST_FUNC(e, events, add_mem); TEST_FUNC(e, events, remove_mem); - spa_assert(PW_VERSION_CORE_EVENTS == 0); - spa_assert(sizeof(e) == sizeof(events)); + spa_assert_se(PW_VERSION_CORE_EVENTS == 0); + spa_assert_se(sizeof(e) == sizeof(events)); } static void test_registry_abi(void) @@ -118,14 +118,14 @@ static void test_registry_abi(void) TEST_FUNC(m, methods, add_listener); TEST_FUNC(m, methods, bind); TEST_FUNC(m, methods, destroy); - spa_assert(PW_VERSION_REGISTRY_METHODS == 0); - spa_assert(sizeof(m) == sizeof(methods)); + spa_assert_se(PW_VERSION_REGISTRY_METHODS == 0); + spa_assert_se(sizeof(m) == sizeof(methods)); TEST_FUNC(e, events, version); TEST_FUNC(e, events, global); TEST_FUNC(e, events, global_remove); - spa_assert(PW_VERSION_REGISTRY_EVENTS == 0); - spa_assert(sizeof(e) == sizeof(events)); + spa_assert_se(PW_VERSION_REGISTRY_EVENTS == 0); + spa_assert_se(sizeof(e) == sizeof(events)); } static void test_module_abi(void) @@ -146,13 +146,13 @@ static void test_module_abi(void) TEST_FUNC(m, methods, version); TEST_FUNC(m, methods, add_listener); - spa_assert(PW_VERSION_MODULE_METHODS == 0); - spa_assert(sizeof(m) == sizeof(methods)); + spa_assert_se(PW_VERSION_MODULE_METHODS == 0); + spa_assert_se(sizeof(m) == sizeof(methods)); TEST_FUNC(e, events, version); TEST_FUNC(e, events, info); - spa_assert(PW_VERSION_MODULE_EVENTS == 0); - spa_assert(sizeof(e) == sizeof(events)); + spa_assert_se(PW_VERSION_MODULE_EVENTS == 0); + spa_assert_se(sizeof(e) == sizeof(events)); } static void test_device_abi(void) @@ -185,14 +185,14 @@ static void test_device_abi(void) TEST_FUNC(m, methods, subscribe_params); TEST_FUNC(m, methods, enum_params); TEST_FUNC(m, methods, set_param); - spa_assert(PW_VERSION_DEVICE_METHODS == 0); - spa_assert(sizeof(m) == sizeof(methods)); + spa_assert_se(PW_VERSION_DEVICE_METHODS == 0); + spa_assert_se(sizeof(m) == sizeof(methods)); TEST_FUNC(e, events, version); TEST_FUNC(e, events, info); TEST_FUNC(e, events, param); - spa_assert(PW_VERSION_DEVICE_EVENTS == 0); - spa_assert(sizeof(e) == sizeof(events)); + spa_assert_se(PW_VERSION_DEVICE_EVENTS == 0); + spa_assert_se(sizeof(e) == sizeof(events)); } static void test_node_abi(void) @@ -226,14 +226,14 @@ static void test_node_abi(void) TEST_FUNC(m, methods, enum_params); TEST_FUNC(m, methods, set_param); TEST_FUNC(m, methods, send_command); - spa_assert(PW_VERSION_NODE_METHODS == 0); - spa_assert(sizeof(m) == sizeof(methods)); + spa_assert_se(PW_VERSION_NODE_METHODS == 0); + spa_assert_se(sizeof(m) == sizeof(methods)); TEST_FUNC(e, events, version); TEST_FUNC(e, events, info); TEST_FUNC(e, events, param); - spa_assert(PW_VERSION_NODE_EVENTS == 0); - spa_assert(sizeof(e) == sizeof(events)); + spa_assert_se(PW_VERSION_NODE_EVENTS == 0); + spa_assert_se(sizeof(e) == sizeof(events)); } static void test_port_abi(void) @@ -261,14 +261,14 @@ static void test_port_abi(void) TEST_FUNC(m, methods, version); TEST_FUNC(m, methods, add_listener); TEST_FUNC(m, methods, enum_params); - spa_assert(PW_VERSION_PORT_METHODS == 0); - spa_assert(sizeof(m) == sizeof(methods)); + spa_assert_se(PW_VERSION_PORT_METHODS == 0); + spa_assert_se(sizeof(m) == sizeof(methods)); TEST_FUNC(e, events, version); TEST_FUNC(e, events, info); TEST_FUNC(e, events, param); - spa_assert(PW_VERSION_PORT_EVENTS == 0); - spa_assert(sizeof(e) == sizeof(events)); + spa_assert_se(PW_VERSION_PORT_EVENTS == 0); + spa_assert_se(sizeof(e) == sizeof(events)); } static void test_factory_abi(void) @@ -289,13 +289,13 @@ static void test_factory_abi(void) TEST_FUNC(m, methods, version); TEST_FUNC(m, methods, add_listener); - spa_assert(PW_VERSION_FACTORY_METHODS == 0); - spa_assert(sizeof(m) == sizeof(methods)); + spa_assert_se(PW_VERSION_FACTORY_METHODS == 0); + spa_assert_se(sizeof(m) == sizeof(methods)); TEST_FUNC(e, events, version); TEST_FUNC(e, events, info); - spa_assert(PW_VERSION_FACTORY_EVENTS == 0); - spa_assert(sizeof(e) == sizeof(events)); + spa_assert_se(PW_VERSION_FACTORY_EVENTS == 0); + spa_assert_se(sizeof(e) == sizeof(events)); } static void test_client_abi(void) @@ -327,14 +327,14 @@ static void test_client_abi(void) TEST_FUNC(m, methods, update_properties); TEST_FUNC(m, methods, get_permissions); TEST_FUNC(m, methods, update_permissions); - spa_assert(PW_VERSION_CLIENT_METHODS == 0); - spa_assert(sizeof(m) == sizeof(methods)); + spa_assert_se(PW_VERSION_CLIENT_METHODS == 0); + spa_assert_se(sizeof(m) == sizeof(methods)); TEST_FUNC(e, events, version); TEST_FUNC(e, events, info); TEST_FUNC(e, events, permissions); - spa_assert(PW_VERSION_CLIENT_EVENTS == 0); - spa_assert(sizeof(e) == sizeof(events)); + spa_assert_se(PW_VERSION_CLIENT_EVENTS == 0); + spa_assert_se(sizeof(e) == sizeof(events)); } static void test_link_abi(void) @@ -355,13 +355,13 @@ static void test_link_abi(void) TEST_FUNC(m, methods, version); TEST_FUNC(m, methods, add_listener); - spa_assert(PW_VERSION_LINK_METHODS == 0); - spa_assert(sizeof(m) == sizeof(methods)); + spa_assert_se(PW_VERSION_LINK_METHODS == 0); + spa_assert_se(sizeof(m) == sizeof(methods)); TEST_FUNC(e, events, version); TEST_FUNC(e, events, info); - spa_assert(PW_VERSION_LINK_EVENTS == 0); - spa_assert(sizeof(e) == sizeof(events)); + spa_assert_se(PW_VERSION_LINK_EVENTS == 0); + spa_assert_se(sizeof(e) == sizeof(events)); } int main(int argc, char *argv[]) diff --git a/src/tests/test-stream.c b/src/tests/test-stream.c index e9d6d21bc..20968cde4 100644 --- a/src/tests/test-stream.c +++ b/src/tests/test-stream.c @@ -31,7 +31,7 @@ #define TEST_FUNC(a,b,func) \ do { \ a.func = b.func; \ - spa_assert(SPA_PTRDIFF(&a.func, &a) == SPA_PTRDIFF(&b.func, &b)); \ + spa_assert_se(SPA_PTRDIFF(&a.func, &a) == SPA_PTRDIFF(&b.func, &b)); \ } while(0) static void test_abi(void) @@ -63,27 +63,27 @@ static void test_abi(void) TEST_FUNC(ev, test, drained); #if defined(__x86_64__) && defined(__LP64__) - spa_assert(sizeof(struct pw_buffer) == 24); - spa_assert(sizeof(struct pw_time) == 40); + spa_assert_se(sizeof(struct pw_buffer) == 24); + spa_assert_se(sizeof(struct pw_time) == 40); #else fprintf(stderr, "%zd\n", sizeof(struct pw_buffer)); fprintf(stderr, "%zd\n", sizeof(struct pw_time)); #endif - spa_assert(PW_VERSION_STREAM_EVENTS == 0); - spa_assert(sizeof(ev) == sizeof(test)); + spa_assert_se(PW_VERSION_STREAM_EVENTS == 0); + spa_assert_se(sizeof(ev) == sizeof(test)); - spa_assert(PW_STREAM_STATE_ERROR == -1); - spa_assert(PW_STREAM_STATE_UNCONNECTED == 0); - spa_assert(PW_STREAM_STATE_CONNECTING == 1); - spa_assert(PW_STREAM_STATE_PAUSED == 2); - spa_assert(PW_STREAM_STATE_STREAMING == 3); + spa_assert_se(PW_STREAM_STATE_ERROR == -1); + spa_assert_se(PW_STREAM_STATE_UNCONNECTED == 0); + spa_assert_se(PW_STREAM_STATE_CONNECTING == 1); + spa_assert_se(PW_STREAM_STATE_PAUSED == 2); + spa_assert_se(PW_STREAM_STATE_STREAMING == 3); - spa_assert(pw_stream_state_as_string(PW_STREAM_STATE_ERROR) != NULL); - spa_assert(pw_stream_state_as_string(PW_STREAM_STATE_UNCONNECTED) != NULL); - spa_assert(pw_stream_state_as_string(PW_STREAM_STATE_CONNECTING) != NULL); - spa_assert(pw_stream_state_as_string(PW_STREAM_STATE_PAUSED) != NULL); - spa_assert(pw_stream_state_as_string(PW_STREAM_STATE_STREAMING) != NULL); + spa_assert_se(pw_stream_state_as_string(PW_STREAM_STATE_ERROR) != NULL); + spa_assert_se(pw_stream_state_as_string(PW_STREAM_STATE_UNCONNECTED) != NULL); + spa_assert_se(pw_stream_state_as_string(PW_STREAM_STATE_CONNECTING) != NULL); + spa_assert_se(pw_stream_state_as_string(PW_STREAM_STATE_PAUSED) != NULL); + spa_assert_se(pw_stream_state_as_string(PW_STREAM_STATE_STREAMING) != NULL); } static void stream_destroy_error(void *data) @@ -151,37 +151,37 @@ static void test_create(void) loop = pw_main_loop_new(NULL); context = pw_context_new(pw_main_loop_get_loop(loop), NULL, 12); - spa_assert(context != NULL); + spa_assert_se(context != NULL); core = pw_context_connect_self(context, NULL, 0); - spa_assert(core != NULL); + spa_assert_se(core != NULL); stream = pw_stream_new(core, "test", NULL); - spa_assert(stream != NULL); + spa_assert_se(stream != NULL); pw_stream_add_listener(stream, &listener, &stream_events, stream); /* check state */ - spa_assert(pw_stream_get_state(stream, &error) == PW_STREAM_STATE_UNCONNECTED); - spa_assert(error == NULL); + spa_assert_se(pw_stream_get_state(stream, &error) == PW_STREAM_STATE_UNCONNECTED); + spa_assert_se(error == NULL); /* check name */ - spa_assert(spa_streq(pw_stream_get_name(stream), "test")); + spa_assert_se(spa_streq(pw_stream_get_name(stream), "test")); /* check id, only when connected */ - spa_assert(pw_stream_get_node_id(stream) == SPA_ID_INVALID); + spa_assert_se(pw_stream_get_node_id(stream) == SPA_ID_INVALID); - spa_assert(pw_stream_get_time(stream, &tm) == 0); - spa_assert(tm.now == 0); - spa_assert(tm.rate.num == 0); - spa_assert(tm.rate.denom == 0); - spa_assert(tm.ticks == 0); - spa_assert(tm.delay == 0); - spa_assert(tm.queued == 0); + spa_assert_se(pw_stream_get_time(stream, &tm) == 0); + spa_assert_se(tm.now == 0); + spa_assert_se(tm.rate.num == 0); + spa_assert_se(tm.rate.denom == 0); + spa_assert_se(tm.ticks == 0); + spa_assert_se(tm.delay == 0); + spa_assert_se(tm.queued == 0); - spa_assert(pw_stream_dequeue_buffer(stream) == NULL); + spa_assert_se(pw_stream_dequeue_buffer(stream) == NULL); /* check destroy */ destroy_count = 0; stream_events.destroy = stream_destroy_count; pw_stream_destroy(stream); - spa_assert(destroy_count == 1); + spa_assert_se(destroy_count == 1); pw_context_destroy(context); pw_main_loop_destroy(loop); @@ -200,21 +200,21 @@ static void test_properties(void) loop = pw_main_loop_new(NULL); context = pw_context_new(pw_main_loop_get_loop(loop), NULL, 12); - spa_assert(context != NULL); + spa_assert_se(context != NULL); core = pw_context_connect_self(context, NULL, 0); - spa_assert(core != NULL); + spa_assert_se(core != NULL); stream = pw_stream_new(core, "test", pw_properties_new("foo", "bar", "biz", "fuzz", NULL)); - spa_assert(stream != NULL); + spa_assert_se(stream != NULL); pw_stream_add_listener(stream, &listener, &stream_events, stream); props = pw_stream_get_properties(stream); - spa_assert(props != NULL); - spa_assert(spa_streq(pw_properties_get(props, "foo"), "bar")); - spa_assert(spa_streq(pw_properties_get(props, "biz"), "fuzz")); - spa_assert(pw_properties_get(props, "buzz") == NULL); + spa_assert_se(props != NULL); + spa_assert_se(spa_streq(pw_properties_get(props, "foo"), "bar")); + spa_assert_se(spa_streq(pw_properties_get(props, "biz"), "fuzz")); + spa_assert_se(pw_properties_get(props, "buzz") == NULL); /* remove foo */ items[0] = SPA_DICT_ITEM_INIT("foo", NULL); @@ -224,16 +224,16 @@ static void test_properties(void) items[2] = SPA_DICT_ITEM_INIT("buzz", "frizz"); pw_stream_update_properties(stream, &SPA_DICT_INIT(items, 3)); - spa_assert(props == pw_stream_get_properties(stream)); - spa_assert(pw_properties_get(props, "foo") == NULL); - spa_assert(spa_streq(pw_properties_get(props, "biz"), "buzz")); - spa_assert(spa_streq(pw_properties_get(props, "buzz"), "frizz")); + spa_assert_se(props == pw_stream_get_properties(stream)); + spa_assert_se(pw_properties_get(props, "foo") == NULL); + spa_assert_se(spa_streq(pw_properties_get(props, "biz"), "buzz")); + spa_assert_se(spa_streq(pw_properties_get(props, "buzz"), "frizz")); /* check destroy */ destroy_count = 0; stream_events.destroy = stream_destroy_count; pw_context_destroy(context); - spa_assert(destroy_count == 1); + spa_assert_se(destroy_count == 1); pw_main_loop_destroy(loop); } diff --git a/src/tests/test-utils.c b/src/tests/test-utils.c index 4ff8689d4..5268e27e2 100644 --- a/src/tests/test-utils.c +++ b/src/tests/test-utils.c @@ -37,7 +37,7 @@ static void test_abi(void) { pw_destroy_t f; f = test_destroy; - spa_assert(f == test_destroy); + spa_assert_se(f == test_destroy); } static void test__pw_split_walk(void) @@ -177,13 +177,13 @@ static void test__pw_split_walk(void) size_t j = 0, len; while ((s = pw_split_walk(str, tc->delim, &len, &state)) != NULL && tc->expected[j] != NULL) { - spa_assert(strlen(tc->expected[j]) == len); - spa_assert(strncmp(s, tc->expected[j], len) == 0); + spa_assert_se(strlen(tc->expected[j]) == len); + spa_assert_se(strncmp(s, tc->expected[j], len) == 0); j += 1; } - spa_assert(s == NULL && tc->expected[j] == NULL); + spa_assert_se(s == NULL && tc->expected[j] == NULL); } } @@ -195,20 +195,20 @@ static void test__pw_split_strv(void) char **res; res = pw_split_strv(test1, del, INT_MAX, &n_tokens); - spa_assert(res != NULL); - spa_assert(n_tokens == 3); - spa_assert(spa_streq(res[0], "a")); - spa_assert(spa_streq(res[1], "test")); - spa_assert(spa_streq(res[2], "string")); - spa_assert(res[3] == NULL); + spa_assert_se(res != NULL); + spa_assert_se(n_tokens == 3); + spa_assert_se(spa_streq(res[0], "a")); + spa_assert_se(spa_streq(res[1], "test")); + spa_assert_se(spa_streq(res[2], "string")); + spa_assert_se(res[3] == NULL); pw_free_strv(res); res = pw_split_strv(test1, del, 2, &n_tokens); - spa_assert(res != NULL); - spa_assert(n_tokens == 2); - spa_assert(spa_streq(res[0], "a")); - spa_assert(spa_streq(res[1], "test string \n \r ")); - spa_assert(res[2] == NULL); + spa_assert_se(res != NULL); + spa_assert_se(n_tokens == 2); + spa_assert_se(spa_streq(res[0], "a")); + spa_assert_se(spa_streq(res[1], "test string \n \r ")); + spa_assert_se(res[2] == NULL); pw_free_strv(res); } @@ -223,9 +223,9 @@ static void test_strip(void) char test1[] = " \n\r \n a test string \n \r "; char test2[] = " \n\r \n \n \r "; char test3[] = "a test string"; - spa_assert(spa_streq(pw_strip(test1, "\n\r "), "a test string")); - spa_assert(spa_streq(pw_strip(test2, "\n\r "), "")); - spa_assert(spa_streq(pw_strip(test3, "\n\r "), "a test string")); + spa_assert_se(spa_streq(pw_strip(test1, "\n\r "), "a test string")); + spa_assert_se(spa_streq(pw_strip(test2, "\n\r "), "")); + spa_assert_se(spa_streq(pw_strip(test3, "\n\r "), "a test string")); } int main(int argc, char *argv[]) diff --git a/test/pwtest.c b/test/pwtest.c index 70969f56c..f005d63d1 100644 --- a/test/pwtest.c +++ b/test/pwtest.c @@ -331,7 +331,7 @@ pwtest_spa_plugin_try_load_interface(struct pwtest_spa_plugin *plugin, bool found = false; struct spa_handle *handle; - spa_assert(libdir != NULL); + spa_assert_se(libdir != NULL); spa_scnprintf(path, sizeof(path), "%s/%s.so", libdir, libname); hnd = dlopen(path, RTLD_NOW); @@ -516,7 +516,7 @@ static void add_tests(struct pwtest_context *ctx) spa_list_for_each(c, &ctx->suites, link) { c->result = c->decl->setup(ctx, c); - spa_assert(c->result >= PWTEST_PASS && c->result <= PWTEST_SYSTEM_ERROR); + spa_assert_se(c->result >= PWTEST_PASS && c->result <= PWTEST_SYSTEM_ERROR); } } @@ -526,7 +526,7 @@ static int remove_file(const char *fpath, const struct stat *sb, int typeflag, s int r; /* Safety check: bail out if somehow we left TMPDIR */ - spa_assert(spa_strneq(fpath, tmpdir, strlen(tmpdir))); + spa_assert_se(spa_strneq(fpath, tmpdir, strlen(tmpdir))); r = remove(fpath); if (r) @@ -546,9 +546,9 @@ static void remove_xdg_runtime_dir(const char *xdg_dir) /* Safety checks, we really don't want to recursively remove a * random directory due to a bug */ - spa_assert(spa_strneq(xdg_dir, tmpdir, strlen(tmpdir))); + spa_assert_se(spa_strneq(xdg_dir, tmpdir, strlen(tmpdir))); r = spa_scnprintf(path, sizeof(path), "%s/pwtest.dir", xdg_dir); - spa_assert((size_t)r == strlen(xdg_dir) + 11); + spa_assert_se((size_t)r == strlen(xdg_dir) + 11); if (access(path, F_OK) != 0) { fprintf(stderr, "XDG_RUNTIME_DIR changed, cannot clean up\n"); return; @@ -588,7 +588,7 @@ static inline void log_append(struct pw_array *buffer, int fd) while (true) { r = pw_array_ensure_size(buffer, sz); - spa_assert(r == 0); + spa_assert_se(r == 0); r = read(fd, pw_array_end(buffer), sz); if (r <= 0) break; @@ -617,7 +617,7 @@ static bool collect_child(struct pwtest_test *t, pid_t pid) case PWTEST_SYSTEM_ERROR: break; default: - spa_assert(!"Invalid test result"); + spa_assert_se(!"Invalid test result"); break; } return true; @@ -677,11 +677,11 @@ static void make_xdg_runtime_test_dir(char dir[PATH_MAX], const char *prefix) int r; r = spa_scnprintf(dir, PATH_MAX, "%s/%zd", prefix, counter++); - spa_assert(r >= (int)(strlen(prefix) + 2)); + spa_assert_se(r >= (int)(strlen(prefix) + 2)); r = mkdir(dir, 0777); if (r == -1) { fprintf(stderr, "Failed to make XDG_RUNTIME_DIR %s (%m)\n", dir); - spa_assert(r != -1); + spa_assert_se(r != -1); } } @@ -787,10 +787,10 @@ static int start_test_forked(struct pwtest_test *t, int read_fds[_FD_LAST], int sigaction(SIGALRM, &act, NULL); r = dup2(write_fds[FD_STDERR], STDERR_FILENO); - spa_assert(r != -1); + spa_assert_se(r != -1); setlinebuf(stderr); r = dup2(write_fds[FD_STDOUT], STDOUT_FILENO); - spa_assert(r != -1); + spa_assert_se(r != -1); setlinebuf(stdout); /* For convenience in the tests, let this be a global variable. */ @@ -1019,8 +1019,8 @@ static void log_test_result(struct pwtest_test *t) { "ERROR", SPA_ANSI_BOLD_MAGENTA }, }; - spa_assert(t->result >= PWTEST_PASS); - spa_assert(t->result <= PWTEST_SYSTEM_ERROR); + spa_assert_se(t->result >= PWTEST_PASS); + spa_assert_se(t->result <= PWTEST_SYSTEM_ERROR); s = &statuses[t->result - PWTEST_PASS]; fprintf(stderr, " status: %s%s%s\n", @@ -1075,14 +1075,14 @@ static char* make_xdg_runtime_dir(void) tmpdir = "/tmp"; int r = asprintf(&dir, "%s/pwtest-%02d:%02d-XXXXXX", tmpdir, tm->tm_hour, tm->tm_min); - spa_assert((size_t)r == strlen(tmpdir) + 20); /* rough estimate */ - spa_assert(mkdtemp(dir) != NULL); + spa_assert_se((size_t)r == strlen(tmpdir) + 20); /* rough estimate */ + spa_assert_se(mkdtemp(dir) != NULL); /* Marker file to avoid removing a random directory during cleanup */ r = spa_scnprintf(path, sizeof(path), "%s/pwtest.dir", dir); - spa_assert((size_t)r == strlen(dir) + 11); + spa_assert_se((size_t)r == strlen(dir) + 11); fp = fopen(path, "w"); - spa_assert(fp); + spa_assert_se(fp); fprintf(fp, "pwtest\n"); fclose(fp); diff --git a/test/test-spa-node.c b/test/test-spa-node.c index aaa30315d..196bd031c 100644 --- a/test/test-spa-node.c +++ b/test/test-spa-node.c @@ -46,11 +46,11 @@ PWTEST(node_io_abi_sizes) pwtest_int_eq(sizeof(struct spa_io_position), 1688U); pwtest_int_eq(sizeof(struct spa_io_rate_match), 48U); - spa_assert(sizeof(struct spa_node_info) == 48); - spa_assert(sizeof(struct spa_port_info) == 48); + spa_assert_se(sizeof(struct spa_node_info) == 48); + spa_assert_se(sizeof(struct spa_port_info) == 48); - spa_assert(sizeof(struct spa_result_node_error) == 8); - spa_assert(sizeof(struct spa_result_node_params) == 24); + spa_assert_se(sizeof(struct spa_result_node_error) == 8); + spa_assert_se(sizeof(struct spa_result_node_params) == 24); return PWTEST_PASS; #else diff --git a/test/test-spa-pod.c b/test/test-spa-pod.c index 298082343..e14d18815 100644 --- a/test/test-spa-pod.c +++ b/test/test-spa-pod.c @@ -38,50 +38,50 @@ PWTEST(pod_abi_sizes) { #if defined(__x86_64__) && defined(__LP64__) - spa_assert(sizeof(struct spa_pod) == 8); - spa_assert(sizeof(struct spa_pod_bool) == 16); - spa_assert(sizeof(struct spa_pod_id) == 16); - spa_assert(sizeof(struct spa_pod_int) == 16); - spa_assert(sizeof(struct spa_pod_long) == 16); - spa_assert(sizeof(struct spa_pod_float) == 16); - spa_assert(sizeof(struct spa_pod_double) == 16); - spa_assert(sizeof(struct spa_pod_string) == 8); - spa_assert(sizeof(struct spa_pod_bytes) == 8); - spa_assert(sizeof(struct spa_pod_rectangle) == 16); - spa_assert(sizeof(struct spa_pod_fraction) == 16); - spa_assert(sizeof(struct spa_pod_bitmap) == 8); - spa_assert(sizeof(struct spa_pod_array_body) == 8); - spa_assert(sizeof(struct spa_pod_array) == 16); + spa_assert_se(sizeof(struct spa_pod) == 8); + spa_assert_se(sizeof(struct spa_pod_bool) == 16); + spa_assert_se(sizeof(struct spa_pod_id) == 16); + spa_assert_se(sizeof(struct spa_pod_int) == 16); + spa_assert_se(sizeof(struct spa_pod_long) == 16); + spa_assert_se(sizeof(struct spa_pod_float) == 16); + spa_assert_se(sizeof(struct spa_pod_double) == 16); + spa_assert_se(sizeof(struct spa_pod_string) == 8); + spa_assert_se(sizeof(struct spa_pod_bytes) == 8); + spa_assert_se(sizeof(struct spa_pod_rectangle) == 16); + spa_assert_se(sizeof(struct spa_pod_fraction) == 16); + spa_assert_se(sizeof(struct spa_pod_bitmap) == 8); + spa_assert_se(sizeof(struct spa_pod_array_body) == 8); + spa_assert_se(sizeof(struct spa_pod_array) == 16); - spa_assert(sizeof(struct spa_pod_choice_body) == 16); - spa_assert(sizeof(struct spa_pod_choice) == 24); - spa_assert(sizeof(struct spa_pod_struct) == 8); - spa_assert(sizeof(struct spa_pod_object_body) == 8); - spa_assert(sizeof(struct spa_pod_object) == 16); - spa_assert(sizeof(struct spa_pod_pointer_body) == 16); - spa_assert(sizeof(struct spa_pod_pointer) == 24); - spa_assert(sizeof(struct spa_pod_fd) == 16); - spa_assert(sizeof(struct spa_pod_prop) == 16); - spa_assert(sizeof(struct spa_pod_control) == 16); - spa_assert(sizeof(struct spa_pod_sequence_body) == 8); - spa_assert(sizeof(struct spa_pod_sequence) == 16); + spa_assert_se(sizeof(struct spa_pod_choice_body) == 16); + spa_assert_se(sizeof(struct spa_pod_choice) == 24); + spa_assert_se(sizeof(struct spa_pod_struct) == 8); + spa_assert_se(sizeof(struct spa_pod_object_body) == 8); + spa_assert_se(sizeof(struct spa_pod_object) == 16); + spa_assert_se(sizeof(struct spa_pod_pointer_body) == 16); + spa_assert_se(sizeof(struct spa_pod_pointer) == 24); + spa_assert_se(sizeof(struct spa_pod_fd) == 16); + spa_assert_se(sizeof(struct spa_pod_prop) == 16); + spa_assert_se(sizeof(struct spa_pod_control) == 16); + spa_assert_se(sizeof(struct spa_pod_sequence_body) == 8); + spa_assert_se(sizeof(struct spa_pod_sequence) == 16); /* builder */ - spa_assert(sizeof(struct spa_pod_frame) == 24); - spa_assert(sizeof(struct spa_pod_builder_state) == 16); - spa_assert(sizeof(struct spa_pod_builder) == 48); + spa_assert_se(sizeof(struct spa_pod_frame) == 24); + spa_assert_se(sizeof(struct spa_pod_builder_state) == 16); + spa_assert_se(sizeof(struct spa_pod_builder) == 48); /* command */ - spa_assert(sizeof(struct spa_command_body) == 8); - spa_assert(sizeof(struct spa_command) == 16); + spa_assert_se(sizeof(struct spa_command_body) == 8); + spa_assert_se(sizeof(struct spa_command) == 16); /* event */ - spa_assert(sizeof(struct spa_event_body) == 8); - spa_assert(sizeof(struct spa_event) == 16); + spa_assert_se(sizeof(struct spa_event_body) == 8); + spa_assert_se(sizeof(struct spa_event) == 16); /* parser */ - spa_assert(sizeof(struct spa_pod_parser_state) == 16); - spa_assert(sizeof(struct spa_pod_parser) == 32); + spa_assert_se(sizeof(struct spa_pod_parser_state) == 16); + spa_assert_se(sizeof(struct spa_pod_parser) == 32); return PWTEST_PASS; #endif @@ -90,11 +90,11 @@ PWTEST(pod_abi_sizes) PWTEST(pod_abi) { - spa_assert(SPA_CHOICE_None == 0); - spa_assert(SPA_CHOICE_Range == 1); - spa_assert(SPA_CHOICE_Step == 2); - spa_assert(SPA_CHOICE_Enum == 3); - spa_assert(SPA_CHOICE_Flags == 4); + spa_assert_se(SPA_CHOICE_None == 0); + spa_assert_se(SPA_CHOICE_Range == 1); + spa_assert_se(SPA_CHOICE_Step == 2); + spa_assert_se(SPA_CHOICE_Enum == 3); + spa_assert_se(SPA_CHOICE_Flags == 4); return PWTEST_PASS; } @@ -105,182 +105,182 @@ PWTEST(pod_init) struct spa_pod pod = SPA_POD_INIT(sizeof(int64_t), SPA_TYPE_Long); int32_t val; - spa_assert(SPA_POD_SIZE(&pod) == sizeof(int64_t) + 8); - spa_assert(SPA_POD_TYPE(&pod) == SPA_TYPE_Long); - spa_assert(SPA_POD_BODY_SIZE(&pod) == sizeof(int64_t)); - spa_assert(SPA_POD_CONTENTS_SIZE(struct spa_pod, &pod) == sizeof(int64_t)); - spa_assert(spa_pod_is_long(&pod)); + spa_assert_se(SPA_POD_SIZE(&pod) == sizeof(int64_t) + 8); + spa_assert_se(SPA_POD_TYPE(&pod) == SPA_TYPE_Long); + spa_assert_se(SPA_POD_BODY_SIZE(&pod) == sizeof(int64_t)); + spa_assert_se(SPA_POD_CONTENTS_SIZE(struct spa_pod, &pod) == sizeof(int64_t)); + spa_assert_se(spa_pod_is_long(&pod)); pod = SPA_POD_INIT(sizeof(int32_t), SPA_TYPE_Int); - spa_assert(SPA_POD_SIZE(&pod) == sizeof(int32_t) + 8); - spa_assert(SPA_POD_TYPE(&pod) == SPA_TYPE_Int); - spa_assert(SPA_POD_BODY_SIZE(&pod) == sizeof(int32_t)); - spa_assert(SPA_POD_CONTENTS_SIZE(struct spa_pod, &pod) == sizeof(int32_t)); - spa_assert(spa_pod_is_int(&pod)); + spa_assert_se(SPA_POD_SIZE(&pod) == sizeof(int32_t) + 8); + spa_assert_se(SPA_POD_TYPE(&pod) == SPA_TYPE_Int); + spa_assert_se(SPA_POD_BODY_SIZE(&pod) == sizeof(int32_t)); + spa_assert_se(SPA_POD_CONTENTS_SIZE(struct spa_pod, &pod) == sizeof(int32_t)); + spa_assert_se(spa_pod_is_int(&pod)); /** too small */ pod = SPA_POD_INIT(0, SPA_TYPE_Int); - spa_assert(!spa_pod_is_int(&pod)); - spa_assert(spa_pod_get_int(&pod, &val) < 0); + spa_assert_se(!spa_pod_is_int(&pod)); + spa_assert_se(spa_pod_get_int(&pod, &val) < 0); } { struct spa_pod pod = SPA_POD_INIT_None(); - spa_assert(SPA_POD_SIZE(&pod) == 8); - spa_assert(SPA_POD_TYPE(&pod) == SPA_TYPE_None); - spa_assert(SPA_POD_BODY_SIZE(&pod) == 0); - spa_assert(SPA_POD_CONTENTS_SIZE(struct spa_pod, &pod) == 0); - spa_assert(spa_pod_is_none(&pod)); + spa_assert_se(SPA_POD_SIZE(&pod) == 8); + spa_assert_se(SPA_POD_TYPE(&pod) == SPA_TYPE_None); + spa_assert_se(SPA_POD_BODY_SIZE(&pod) == 0); + spa_assert_se(SPA_POD_CONTENTS_SIZE(struct spa_pod, &pod) == 0); + spa_assert_se(spa_pod_is_none(&pod)); } { struct spa_pod_bool pod = SPA_POD_INIT_Bool(true); bool val; - spa_assert(SPA_POD_SIZE(&pod) == 12); - spa_assert(SPA_POD_TYPE(&pod) == SPA_TYPE_Bool); - spa_assert(SPA_POD_BODY_SIZE(&pod) == 4); - spa_assert(SPA_POD_VALUE(struct spa_pod_bool, &pod) == true); - spa_assert(spa_pod_is_bool(&pod.pod)); - spa_assert(spa_pod_get_bool(&pod.pod, &val) == 0); - spa_assert(val == true); + spa_assert_se(SPA_POD_SIZE(&pod) == 12); + spa_assert_se(SPA_POD_TYPE(&pod) == SPA_TYPE_Bool); + spa_assert_se(SPA_POD_BODY_SIZE(&pod) == 4); + spa_assert_se(SPA_POD_VALUE(struct spa_pod_bool, &pod) == true); + spa_assert_se(spa_pod_is_bool(&pod.pod)); + spa_assert_se(spa_pod_get_bool(&pod.pod, &val) == 0); + spa_assert_se(val == true); pod = SPA_POD_INIT_Bool(false); - spa_assert(SPA_POD_SIZE(&pod) == 12); - spa_assert(SPA_POD_TYPE(&pod) == SPA_TYPE_Bool); - spa_assert(SPA_POD_BODY_SIZE(&pod) == 4); - spa_assert(SPA_POD_VALUE(struct spa_pod_bool, &pod) == false); - spa_assert(spa_pod_is_bool(&pod.pod)); - spa_assert(spa_pod_get_bool(&pod.pod, &val) == 0); - spa_assert(val == false); + spa_assert_se(SPA_POD_SIZE(&pod) == 12); + spa_assert_se(SPA_POD_TYPE(&pod) == SPA_TYPE_Bool); + spa_assert_se(SPA_POD_BODY_SIZE(&pod) == 4); + spa_assert_se(SPA_POD_VALUE(struct spa_pod_bool, &pod) == false); + spa_assert_se(spa_pod_is_bool(&pod.pod)); + spa_assert_se(spa_pod_get_bool(&pod.pod, &val) == 0); + spa_assert_se(val == false); pod.pod = SPA_POD_INIT(0, SPA_TYPE_Bool); - spa_assert(!spa_pod_is_bool(&pod.pod)); - spa_assert(spa_pod_get_bool(&pod.pod, &val) < 0); + spa_assert_se(!spa_pod_is_bool(&pod.pod)); + spa_assert_se(spa_pod_get_bool(&pod.pod, &val) < 0); } { struct spa_pod_id pod = SPA_POD_INIT_Id(SPA_TYPE_Int); uint32_t val; - spa_assert(SPA_POD_SIZE(&pod) == 12); - spa_assert(SPA_POD_TYPE(&pod) == SPA_TYPE_Id); - spa_assert(SPA_POD_BODY_SIZE(&pod) == 4); - spa_assert(SPA_POD_VALUE(struct spa_pod_id, &pod) == SPA_TYPE_Int); - spa_assert(spa_pod_is_id(&pod.pod)); - spa_assert(spa_pod_get_id(&pod.pod, &val) == 0); - spa_assert(val == SPA_TYPE_Int); + spa_assert_se(SPA_POD_SIZE(&pod) == 12); + spa_assert_se(SPA_POD_TYPE(&pod) == SPA_TYPE_Id); + spa_assert_se(SPA_POD_BODY_SIZE(&pod) == 4); + spa_assert_se(SPA_POD_VALUE(struct spa_pod_id, &pod) == SPA_TYPE_Int); + spa_assert_se(spa_pod_is_id(&pod.pod)); + spa_assert_se(spa_pod_get_id(&pod.pod, &val) == 0); + spa_assert_se(val == SPA_TYPE_Int); pod = SPA_POD_INIT_Id(SPA_TYPE_Long); - spa_assert(SPA_POD_SIZE(&pod) == 12); - spa_assert(SPA_POD_TYPE(&pod) == SPA_TYPE_Id); - spa_assert(SPA_POD_BODY_SIZE(&pod) == 4); - spa_assert(SPA_POD_VALUE(struct spa_pod_id, &pod) == SPA_TYPE_Long); - spa_assert(spa_pod_is_id(&pod.pod)); - spa_assert(spa_pod_get_id(&pod.pod, &val) == 0); - spa_assert(val == SPA_TYPE_Long); + spa_assert_se(SPA_POD_SIZE(&pod) == 12); + spa_assert_se(SPA_POD_TYPE(&pod) == SPA_TYPE_Id); + spa_assert_se(SPA_POD_BODY_SIZE(&pod) == 4); + spa_assert_se(SPA_POD_VALUE(struct spa_pod_id, &pod) == SPA_TYPE_Long); + spa_assert_se(spa_pod_is_id(&pod.pod)); + spa_assert_se(spa_pod_get_id(&pod.pod, &val) == 0); + spa_assert_se(val == SPA_TYPE_Long); pod.pod = SPA_POD_INIT(0, SPA_TYPE_Id); - spa_assert(!spa_pod_is_id(&pod.pod)); - spa_assert(spa_pod_get_id(&pod.pod, &val) < 0); + spa_assert_se(!spa_pod_is_id(&pod.pod)); + spa_assert_se(spa_pod_get_id(&pod.pod, &val) < 0); } { struct spa_pod_int pod = SPA_POD_INIT_Int(23); int32_t val; - spa_assert(SPA_POD_SIZE(&pod) == 12); - spa_assert(SPA_POD_TYPE(&pod) == SPA_TYPE_Int); - spa_assert(SPA_POD_BODY_SIZE(&pod) == 4); - spa_assert(SPA_POD_VALUE(struct spa_pod_int, &pod) == 23); - spa_assert(spa_pod_is_int(&pod.pod)); - spa_assert(spa_pod_get_int(&pod.pod, &val) == 0); - spa_assert(val == 23); + spa_assert_se(SPA_POD_SIZE(&pod) == 12); + spa_assert_se(SPA_POD_TYPE(&pod) == SPA_TYPE_Int); + spa_assert_se(SPA_POD_BODY_SIZE(&pod) == 4); + spa_assert_se(SPA_POD_VALUE(struct spa_pod_int, &pod) == 23); + spa_assert_se(spa_pod_is_int(&pod.pod)); + spa_assert_se(spa_pod_get_int(&pod.pod, &val) == 0); + spa_assert_se(val == 23); pod = SPA_POD_INIT_Int(-123); - spa_assert(SPA_POD_SIZE(&pod) == 12); - spa_assert(SPA_POD_TYPE(&pod) == SPA_TYPE_Int); - spa_assert(SPA_POD_BODY_SIZE(&pod) == 4); - spa_assert(SPA_POD_VALUE(struct spa_pod_int, &pod) == -123); - spa_assert(spa_pod_is_int(&pod.pod)); - spa_assert(spa_pod_get_int(&pod.pod, &val) == 0); - spa_assert(val == -123); + spa_assert_se(SPA_POD_SIZE(&pod) == 12); + spa_assert_se(SPA_POD_TYPE(&pod) == SPA_TYPE_Int); + spa_assert_se(SPA_POD_BODY_SIZE(&pod) == 4); + spa_assert_se(SPA_POD_VALUE(struct spa_pod_int, &pod) == -123); + spa_assert_se(spa_pod_is_int(&pod.pod)); + spa_assert_se(spa_pod_get_int(&pod.pod, &val) == 0); + spa_assert_se(val == -123); pod.pod = SPA_POD_INIT(0, SPA_TYPE_Int); - spa_assert(!spa_pod_is_int(&pod.pod)); - spa_assert(spa_pod_get_int(&pod.pod, &val) < 0); + spa_assert_se(!spa_pod_is_int(&pod.pod)); + spa_assert_se(spa_pod_get_int(&pod.pod, &val) < 0); } { struct spa_pod_long pod = SPA_POD_INIT_Long(-23); int64_t val; - spa_assert(SPA_POD_SIZE(&pod) == 16); - spa_assert(SPA_POD_TYPE(&pod) == SPA_TYPE_Long); - spa_assert(SPA_POD_BODY_SIZE(&pod) == 8); - spa_assert(SPA_POD_VALUE(struct spa_pod_long, &pod) == -23); - spa_assert(spa_pod_is_long(&pod.pod)); - spa_assert(spa_pod_get_long(&pod.pod, &val) == 0); - spa_assert(val == -23); + spa_assert_se(SPA_POD_SIZE(&pod) == 16); + spa_assert_se(SPA_POD_TYPE(&pod) == SPA_TYPE_Long); + spa_assert_se(SPA_POD_BODY_SIZE(&pod) == 8); + spa_assert_se(SPA_POD_VALUE(struct spa_pod_long, &pod) == -23); + spa_assert_se(spa_pod_is_long(&pod.pod)); + spa_assert_se(spa_pod_get_long(&pod.pod, &val) == 0); + spa_assert_se(val == -23); pod = SPA_POD_INIT_Long(123); - spa_assert(SPA_POD_SIZE(&pod) == 16); - spa_assert(SPA_POD_TYPE(&pod) == SPA_TYPE_Long); - spa_assert(SPA_POD_BODY_SIZE(&pod) == 8); - spa_assert(SPA_POD_VALUE(struct spa_pod_long, &pod) == 123); - spa_assert(spa_pod_is_long(&pod.pod)); - spa_assert(spa_pod_get_long(&pod.pod, &val) == 0); - spa_assert(val == 123); + spa_assert_se(SPA_POD_SIZE(&pod) == 16); + spa_assert_se(SPA_POD_TYPE(&pod) == SPA_TYPE_Long); + spa_assert_se(SPA_POD_BODY_SIZE(&pod) == 8); + spa_assert_se(SPA_POD_VALUE(struct spa_pod_long, &pod) == 123); + spa_assert_se(spa_pod_is_long(&pod.pod)); + spa_assert_se(spa_pod_get_long(&pod.pod, &val) == 0); + spa_assert_se(val == 123); pod.pod = SPA_POD_INIT(0, SPA_TYPE_Long); - spa_assert(!spa_pod_is_long(&pod.pod)); - spa_assert(spa_pod_get_long(&pod.pod, &val) < 0); + spa_assert_se(!spa_pod_is_long(&pod.pod)); + spa_assert_se(spa_pod_get_long(&pod.pod, &val) < 0); } { struct spa_pod_float pod = SPA_POD_INIT_Float(0.67f); float val; - spa_assert(SPA_POD_SIZE(&pod) == 12); - spa_assert(SPA_POD_TYPE(&pod) == SPA_TYPE_Float); - spa_assert(SPA_POD_BODY_SIZE(&pod) == 4); - spa_assert(SPA_POD_VALUE(struct spa_pod_float, &pod) == 0.67f); - spa_assert(spa_pod_is_float(&pod.pod)); - spa_assert(spa_pod_get_float(&pod.pod, &val) == 0); - spa_assert(val == 0.67f); + spa_assert_se(SPA_POD_SIZE(&pod) == 12); + spa_assert_se(SPA_POD_TYPE(&pod) == SPA_TYPE_Float); + spa_assert_se(SPA_POD_BODY_SIZE(&pod) == 4); + spa_assert_se(SPA_POD_VALUE(struct spa_pod_float, &pod) == 0.67f); + spa_assert_se(spa_pod_is_float(&pod.pod)); + spa_assert_se(spa_pod_get_float(&pod.pod, &val) == 0); + spa_assert_se(val == 0.67f); pod = SPA_POD_INIT_Float(-134.8f); - spa_assert(SPA_POD_SIZE(&pod) == 12); - spa_assert(SPA_POD_TYPE(&pod) == SPA_TYPE_Float); - spa_assert(SPA_POD_BODY_SIZE(&pod) == 4); - spa_assert(SPA_POD_VALUE(struct spa_pod_float, &pod) == -134.8f); - spa_assert(spa_pod_is_float(&pod.pod)); - spa_assert(spa_pod_get_float(&pod.pod, &val) == 0); - spa_assert(val == -134.8f); + spa_assert_se(SPA_POD_SIZE(&pod) == 12); + spa_assert_se(SPA_POD_TYPE(&pod) == SPA_TYPE_Float); + spa_assert_se(SPA_POD_BODY_SIZE(&pod) == 4); + spa_assert_se(SPA_POD_VALUE(struct spa_pod_float, &pod) == -134.8f); + spa_assert_se(spa_pod_is_float(&pod.pod)); + spa_assert_se(spa_pod_get_float(&pod.pod, &val) == 0); + spa_assert_se(val == -134.8f); pod.pod = SPA_POD_INIT(0, SPA_TYPE_Float); - spa_assert(!spa_pod_is_float(&pod.pod)); - spa_assert(spa_pod_get_float(&pod.pod, &val) < 0); + spa_assert_se(!spa_pod_is_float(&pod.pod)); + spa_assert_se(spa_pod_get_float(&pod.pod, &val) < 0); } { struct spa_pod_double pod = SPA_POD_INIT_Double(0.67); double val; - spa_assert(SPA_POD_SIZE(&pod) == 16); - spa_assert(SPA_POD_TYPE(&pod) == SPA_TYPE_Double); - spa_assert(SPA_POD_BODY_SIZE(&pod) == 8); - spa_assert(SPA_POD_VALUE(struct spa_pod_double, &pod) == 0.67); - spa_assert(spa_pod_is_double(&pod.pod)); - spa_assert(spa_pod_get_double(&pod.pod, &val) == 0); - spa_assert(val == 0.67); + spa_assert_se(SPA_POD_SIZE(&pod) == 16); + spa_assert_se(SPA_POD_TYPE(&pod) == SPA_TYPE_Double); + spa_assert_se(SPA_POD_BODY_SIZE(&pod) == 8); + spa_assert_se(SPA_POD_VALUE(struct spa_pod_double, &pod) == 0.67); + spa_assert_se(spa_pod_is_double(&pod.pod)); + spa_assert_se(spa_pod_get_double(&pod.pod, &val) == 0); + spa_assert_se(val == 0.67); pod = SPA_POD_INIT_Double(-134.8); - spa_assert(SPA_POD_SIZE(&pod) == 16); - spa_assert(SPA_POD_TYPE(&pod) == SPA_TYPE_Double); - spa_assert(SPA_POD_BODY_SIZE(&pod) == 8); - spa_assert(SPA_POD_VALUE(struct spa_pod_double, &pod) == -134.8); - spa_assert(spa_pod_is_double(&pod.pod)); - spa_assert(spa_pod_get_double(&pod.pod, &val) == 0); - spa_assert(val == -134.8); + spa_assert_se(SPA_POD_SIZE(&pod) == 16); + spa_assert_se(SPA_POD_TYPE(&pod) == SPA_TYPE_Double); + spa_assert_se(SPA_POD_BODY_SIZE(&pod) == 8); + spa_assert_se(SPA_POD_VALUE(struct spa_pod_double, &pod) == -134.8); + spa_assert_se(spa_pod_is_double(&pod.pod)); + spa_assert_se(spa_pod_get_double(&pod.pod, &val) == 0); + spa_assert_se(val == -134.8); pod.pod = SPA_POD_INIT(0, SPA_TYPE_Double); - spa_assert(!spa_pod_is_double(&pod.pod)); - spa_assert(spa_pod_get_double(&pod.pod, &val) < 0); + spa_assert_se(!spa_pod_is_double(&pod.pod)); + spa_assert_se(spa_pod_get_double(&pod.pod, &val) < 0); } { struct { @@ -292,55 +292,55 @@ PWTEST(pod_init) pod.pod = SPA_POD_INIT_String(9); strncpy(pod.str, "test", 9); - spa_assert(SPA_POD_SIZE(&pod) == 17); - spa_assert(SPA_POD_TYPE(&pod) == SPA_TYPE_String); - spa_assert(SPA_POD_BODY_SIZE(&pod) == 9); - spa_assert(spa_pod_is_string(&pod.pod.pod)); - spa_assert(spa_pod_copy_string(&pod.pod.pod, sizeof(val), val) == 0); - spa_assert(spa_streq(pod.str, val)); + spa_assert_se(SPA_POD_SIZE(&pod) == 17); + spa_assert_se(SPA_POD_TYPE(&pod) == SPA_TYPE_String); + spa_assert_se(SPA_POD_BODY_SIZE(&pod) == 9); + spa_assert_se(spa_pod_is_string(&pod.pod.pod)); + spa_assert_se(spa_pod_copy_string(&pod.pod.pod, sizeof(val), val) == 0); + spa_assert_se(spa_streq(pod.str, val)); pod.pod = SPA_POD_INIT_String(6); memcpy(pod.str, "test123456789", 9); - spa_assert(SPA_POD_SIZE(&pod) == 14); - spa_assert(SPA_POD_TYPE(&pod) == SPA_TYPE_String); - spa_assert(SPA_POD_BODY_SIZE(&pod) == 6); - spa_assert(!spa_pod_is_string(&pod.pod.pod)); - spa_assert(spa_pod_copy_string(&pod.pod.pod, sizeof(val), val) < 0); + spa_assert_se(SPA_POD_SIZE(&pod) == 14); + spa_assert_se(SPA_POD_TYPE(&pod) == SPA_TYPE_String); + spa_assert_se(SPA_POD_BODY_SIZE(&pod) == 6); + spa_assert_se(!spa_pod_is_string(&pod.pod.pod)); + spa_assert_se(spa_pod_copy_string(&pod.pod.pod, sizeof(val), val) < 0); } { struct spa_pod_rectangle pod = SPA_POD_INIT_Rectangle(SPA_RECTANGLE(320,240)); struct spa_rectangle val; - spa_assert(SPA_POD_SIZE(&pod) == 16); - spa_assert(SPA_POD_TYPE(&pod) == SPA_TYPE_Rectangle); - spa_assert(SPA_POD_BODY_SIZE(&pod) == 8); - spa_assert(memcmp(&SPA_POD_VALUE(struct spa_pod_rectangle, &pod), + spa_assert_se(SPA_POD_SIZE(&pod) == 16); + spa_assert_se(SPA_POD_TYPE(&pod) == SPA_TYPE_Rectangle); + spa_assert_se(SPA_POD_BODY_SIZE(&pod) == 8); + spa_assert_se(memcmp(&SPA_POD_VALUE(struct spa_pod_rectangle, &pod), &SPA_RECTANGLE(320,240), sizeof(struct spa_rectangle)) == 0); - spa_assert(spa_pod_is_rectangle(&pod.pod)); - spa_assert(spa_pod_get_rectangle(&pod.pod, &val) == 0); - spa_assert(memcmp(&val, &SPA_RECTANGLE(320,240), sizeof(struct spa_rectangle)) == 0); + spa_assert_se(spa_pod_is_rectangle(&pod.pod)); + spa_assert_se(spa_pod_get_rectangle(&pod.pod, &val) == 0); + spa_assert_se(memcmp(&val, &SPA_RECTANGLE(320,240), sizeof(struct spa_rectangle)) == 0); pod.pod = SPA_POD_INIT(0, SPA_TYPE_Rectangle); - spa_assert(!spa_pod_is_rectangle(&pod.pod)); - spa_assert(spa_pod_get_rectangle(&pod.pod, &val) < 0); + spa_assert_se(!spa_pod_is_rectangle(&pod.pod)); + spa_assert_se(spa_pod_get_rectangle(&pod.pod, &val) < 0); } { struct spa_pod_fraction pod = SPA_POD_INIT_Fraction(SPA_FRACTION(25,1)); struct spa_fraction val; - spa_assert(SPA_POD_SIZE(&pod) == 16); - spa_assert(SPA_POD_TYPE(&pod) == SPA_TYPE_Fraction); - spa_assert(SPA_POD_BODY_SIZE(&pod) == 8); - spa_assert(memcmp(&SPA_POD_VALUE(struct spa_pod_fraction, &pod), + spa_assert_se(SPA_POD_SIZE(&pod) == 16); + spa_assert_se(SPA_POD_TYPE(&pod) == SPA_TYPE_Fraction); + spa_assert_se(SPA_POD_BODY_SIZE(&pod) == 8); + spa_assert_se(memcmp(&SPA_POD_VALUE(struct spa_pod_fraction, &pod), &SPA_FRACTION(25,1), sizeof(struct spa_fraction)) == 0); - spa_assert(spa_pod_is_fraction(&pod.pod)); - spa_assert(spa_pod_get_fraction(&pod.pod, &val) == 0); - spa_assert(memcmp(&val, &SPA_FRACTION(25,1), sizeof(struct spa_fraction)) == 0); + spa_assert_se(spa_pod_is_fraction(&pod.pod)); + spa_assert_se(spa_pod_get_fraction(&pod.pod, &val) == 0); + spa_assert_se(memcmp(&val, &SPA_FRACTION(25,1), sizeof(struct spa_fraction)) == 0); pod.pod = SPA_POD_INIT(0, SPA_TYPE_Fraction); - spa_assert(!spa_pod_is_fraction(&pod.pod)); - spa_assert(spa_pod_get_fraction(&pod.pod, &val) < 0); + spa_assert_se(!spa_pod_is_fraction(&pod.pod)); + spa_assert_se(spa_pod_get_fraction(&pod.pod, &val) < 0); } return PWTEST_PASS; } @@ -371,247 +371,247 @@ PWTEST(pod_build) struct spa_pod_frame f; spa_pod_builder_init(&b, buffer, sizeof(buffer)); - spa_assert(b.data == buffer); - spa_assert(b.size == sizeof(buffer)); - spa_assert(b.state.offset == 0); - spa_assert(b.state.flags == 0); + spa_assert_se(b.data == buffer); + spa_assert_se(b.size == sizeof(buffer)); + spa_assert_se(b.state.offset == 0); + spa_assert_se(b.state.flags == 0); - spa_assert(spa_pod_builder_none(&b) == 0); - spa_assert(b.state.offset == 8); - spa_assert(spa_pod_builder_bool(&b, true) == 0); - spa_assert(b.state.offset == 24); - spa_assert(spa_pod_builder_id(&b, SPA_TYPE_Object) == 0); - spa_assert(b.state.offset == 40); - spa_assert(spa_pod_builder_int(&b, 21) == 0); - spa_assert(b.state.offset == 56); - spa_assert(spa_pod_builder_float(&b, 0.8f) == 0); - spa_assert(b.state.offset == 72); - spa_assert(spa_pod_builder_double(&b, -1.56) == 0); - spa_assert(b.state.offset == 88); - spa_assert(spa_pod_builder_string(&b, "test") == 0); - spa_assert(b.state.offset == 104); - spa_assert(spa_pod_builder_bytes(&b, "PipeWire", 8) == 0); - spa_assert(b.state.offset == 120); - spa_assert(spa_pod_builder_pointer(&b, SPA_TYPE_Object, &b) == 0); - spa_assert(b.state.offset == 144); - spa_assert(spa_pod_builder_fd(&b, 4) == 0); - spa_assert(b.state.offset == 160); - spa_assert(spa_pod_builder_rectangle(&b, 320, 240) == 0); - spa_assert(b.state.offset == 176); - spa_assert(spa_pod_builder_fraction(&b, 25, 1) == 0); + spa_assert_se(spa_pod_builder_none(&b) == 0); + spa_assert_se(b.state.offset == 8); + spa_assert_se(spa_pod_builder_bool(&b, true) == 0); + spa_assert_se(b.state.offset == 24); + spa_assert_se(spa_pod_builder_id(&b, SPA_TYPE_Object) == 0); + spa_assert_se(b.state.offset == 40); + spa_assert_se(spa_pod_builder_int(&b, 21) == 0); + spa_assert_se(b.state.offset == 56); + spa_assert_se(spa_pod_builder_float(&b, 0.8f) == 0); + spa_assert_se(b.state.offset == 72); + spa_assert_se(spa_pod_builder_double(&b, -1.56) == 0); + spa_assert_se(b.state.offset == 88); + spa_assert_se(spa_pod_builder_string(&b, "test") == 0); + spa_assert_se(b.state.offset == 104); + spa_assert_se(spa_pod_builder_bytes(&b, "PipeWire", 8) == 0); + spa_assert_se(b.state.offset == 120); + spa_assert_se(spa_pod_builder_pointer(&b, SPA_TYPE_Object, &b) == 0); + spa_assert_se(b.state.offset == 144); + spa_assert_se(spa_pod_builder_fd(&b, 4) == 0); + spa_assert_se(b.state.offset == 160); + spa_assert_se(spa_pod_builder_rectangle(&b, 320, 240) == 0); + spa_assert_se(b.state.offset == 176); + spa_assert_se(spa_pod_builder_fraction(&b, 25, 1) == 0); - spa_assert(b.state.offset == 192); - spa_assert(spa_pod_builder_push_array(&b, &f) == 0); - spa_assert(f.offset == 192); - spa_assert(b.state.flags == (SPA_POD_BUILDER_FLAG_BODY | SPA_POD_BUILDER_FLAG_FIRST)); - spa_assert(b.state.offset == 200); - spa_assert(spa_pod_builder_int(&b, 1) == 0); - spa_assert(b.state.flags == SPA_POD_BUILDER_FLAG_BODY); - spa_assert(b.state.offset == 212); - spa_assert(spa_pod_builder_int(&b, 2) == 0); - spa_assert(b.state.offset == 216); - spa_assert(spa_pod_builder_int(&b, 3) == 0); + spa_assert_se(b.state.offset == 192); + spa_assert_se(spa_pod_builder_push_array(&b, &f) == 0); + spa_assert_se(f.offset == 192); + spa_assert_se(b.state.flags == (SPA_POD_BUILDER_FLAG_BODY | SPA_POD_BUILDER_FLAG_FIRST)); + spa_assert_se(b.state.offset == 200); + spa_assert_se(spa_pod_builder_int(&b, 1) == 0); + spa_assert_se(b.state.flags == SPA_POD_BUILDER_FLAG_BODY); + spa_assert_se(b.state.offset == 212); + spa_assert_se(spa_pod_builder_int(&b, 2) == 0); + spa_assert_se(b.state.offset == 216); + spa_assert_se(spa_pod_builder_int(&b, 3) == 0); array = spa_pod_builder_pop(&b, &f); - spa_assert(f.pod.size == 20); - spa_assert(array != NULL); - spa_assert(SPA_POD_BODY_SIZE(array) == 8 + 12); - spa_assert(b.state.flags == 0); + spa_assert_se(f.pod.size == 20); + spa_assert_se(array != NULL); + spa_assert_se(SPA_POD_BODY_SIZE(array) == 8 + 12); + spa_assert_se(b.state.flags == 0); - spa_assert(b.state.offset == 224); - spa_assert(spa_pod_builder_array(&b, + spa_assert_se(b.state.offset == 224); + spa_assert_se(spa_pod_builder_array(&b, sizeof(int64_t), SPA_TYPE_Long, SPA_N_ELEMENTS(longs), longs) == 0); - spa_assert(b.state.flags == 0); + spa_assert_se(b.state.flags == 0); - spa_assert(b.state.offset == 280); - spa_assert(spa_pod_builder_push_choice(&b, &f, SPA_CHOICE_Enum, 0) == 0); - spa_assert(b.state.flags == (SPA_POD_BUILDER_FLAG_BODY | SPA_POD_BUILDER_FLAG_FIRST)); - spa_assert(b.state.offset == 296); - spa_assert(spa_pod_builder_long(&b, 1) == 0); - spa_assert(b.state.flags == SPA_POD_BUILDER_FLAG_BODY); - spa_assert(b.state.offset == 312); - spa_assert(spa_pod_builder_long(&b, 2) == 0); - spa_assert(b.state.offset == 320); - spa_assert(spa_pod_builder_long(&b, 3) == 0); + spa_assert_se(b.state.offset == 280); + spa_assert_se(spa_pod_builder_push_choice(&b, &f, SPA_CHOICE_Enum, 0) == 0); + spa_assert_se(b.state.flags == (SPA_POD_BUILDER_FLAG_BODY | SPA_POD_BUILDER_FLAG_FIRST)); + spa_assert_se(b.state.offset == 296); + spa_assert_se(spa_pod_builder_long(&b, 1) == 0); + spa_assert_se(b.state.flags == SPA_POD_BUILDER_FLAG_BODY); + spa_assert_se(b.state.offset == 312); + spa_assert_se(spa_pod_builder_long(&b, 2) == 0); + spa_assert_se(b.state.offset == 320); + spa_assert_se(spa_pod_builder_long(&b, 3) == 0); choice = spa_pod_builder_pop(&b, &f); - spa_assert(choice != NULL); - spa_assert(b.state.flags == 0); + spa_assert_se(choice != NULL); + spa_assert_se(b.state.flags == 0); - spa_assert(b.state.offset == 328); - spa_assert(spa_pod_builder_push_struct(&b, &f) == 0); - spa_assert(b.state.flags == 0); - spa_assert(b.state.offset == 336); - spa_assert(spa_pod_builder_int(&b, 21) == 0); - spa_assert(b.state.offset == 352); - spa_assert(spa_pod_builder_float(&b, 0.8f) == 0); - spa_assert(b.state.offset == 368); - spa_assert(spa_pod_builder_double(&b, -1.56) == 0); - spa_assert(spa_pod_builder_pop(&b, &f) != NULL); + spa_assert_se(b.state.offset == 328); + spa_assert_se(spa_pod_builder_push_struct(&b, &f) == 0); + spa_assert_se(b.state.flags == 0); + spa_assert_se(b.state.offset == 336); + spa_assert_se(spa_pod_builder_int(&b, 21) == 0); + spa_assert_se(b.state.offset == 352); + spa_assert_se(spa_pod_builder_float(&b, 0.8f) == 0); + spa_assert_se(b.state.offset == 368); + spa_assert_se(spa_pod_builder_double(&b, -1.56) == 0); + spa_assert_se(spa_pod_builder_pop(&b, &f) != NULL); - spa_assert(b.state.offset == 384); - spa_assert(spa_pod_builder_push_object(&b, &f, SPA_TYPE_OBJECT_Props, 0) == 0); - spa_assert(b.state.flags == 0); - spa_assert(b.state.offset == 400); - spa_assert(spa_pod_builder_prop(&b, 1, 0) == 0); - spa_assert(b.state.flags == 0); - spa_assert(b.state.offset == 408); - spa_assert(spa_pod_builder_int(&b, 21) == 0); - spa_assert(b.state.flags == 0); - spa_assert(b.state.offset == 424); - spa_assert(spa_pod_builder_prop(&b, 2, 0) == 0); - spa_assert(b.state.flags == 0); - spa_assert(b.state.offset == 432); - spa_assert(spa_pod_builder_long(&b, 42) == 0); - spa_assert(b.state.flags == 0); - spa_assert(b.state.offset == 448); - spa_assert(spa_pod_builder_prop(&b, 3, 0) == 0); - spa_assert(b.state.offset == 456); - spa_assert(spa_pod_builder_string(&b, "test123") == 0); - spa_assert(spa_pod_builder_pop(&b, &f) != NULL); - spa_assert(b.state.flags == 0); + spa_assert_se(b.state.offset == 384); + spa_assert_se(spa_pod_builder_push_object(&b, &f, SPA_TYPE_OBJECT_Props, 0) == 0); + spa_assert_se(b.state.flags == 0); + spa_assert_se(b.state.offset == 400); + spa_assert_se(spa_pod_builder_prop(&b, 1, 0) == 0); + spa_assert_se(b.state.flags == 0); + spa_assert_se(b.state.offset == 408); + spa_assert_se(spa_pod_builder_int(&b, 21) == 0); + spa_assert_se(b.state.flags == 0); + spa_assert_se(b.state.offset == 424); + spa_assert_se(spa_pod_builder_prop(&b, 2, 0) == 0); + spa_assert_se(b.state.flags == 0); + spa_assert_se(b.state.offset == 432); + spa_assert_se(spa_pod_builder_long(&b, 42) == 0); + spa_assert_se(b.state.flags == 0); + spa_assert_se(b.state.offset == 448); + spa_assert_se(spa_pod_builder_prop(&b, 3, 0) == 0); + spa_assert_se(b.state.offset == 456); + spa_assert_se(spa_pod_builder_string(&b, "test123") == 0); + spa_assert_se(spa_pod_builder_pop(&b, &f) != NULL); + spa_assert_se(b.state.flags == 0); - spa_assert(b.state.offset == 472); - spa_assert(spa_pod_builder_push_sequence(&b, &f, 0) == 0); - spa_assert(b.state.flags == 0); - spa_assert(b.state.offset == 488); - spa_assert(spa_pod_builder_control(&b, 0, 0) == 0); - spa_assert(b.state.flags == 0); - spa_assert(b.state.offset == 496); - spa_assert(spa_pod_builder_float(&b, 0.667f) == 0); - spa_assert(b.state.flags == 0); - spa_assert(b.state.offset == 512); - spa_assert(spa_pod_builder_control(&b, 12, 0) == 0); - spa_assert(b.state.flags == 0); - spa_assert(b.state.offset == 520); - spa_assert(spa_pod_builder_double(&b, 1.22) == 0); - spa_assert(b.state.flags == 0); - spa_assert(spa_pod_builder_pop(&b, &f) != NULL); - spa_assert(b.state.flags == 0); + spa_assert_se(b.state.offset == 472); + spa_assert_se(spa_pod_builder_push_sequence(&b, &f, 0) == 0); + spa_assert_se(b.state.flags == 0); + spa_assert_se(b.state.offset == 488); + spa_assert_se(spa_pod_builder_control(&b, 0, 0) == 0); + spa_assert_se(b.state.flags == 0); + spa_assert_se(b.state.offset == 496); + spa_assert_se(spa_pod_builder_float(&b, 0.667f) == 0); + spa_assert_se(b.state.flags == 0); + spa_assert_se(b.state.offset == 512); + spa_assert_se(spa_pod_builder_control(&b, 12, 0) == 0); + spa_assert_se(b.state.flags == 0); + spa_assert_se(b.state.offset == 520); + spa_assert_se(spa_pod_builder_double(&b, 1.22) == 0); + spa_assert_se(b.state.flags == 0); + spa_assert_se(spa_pod_builder_pop(&b, &f) != NULL); + spa_assert_se(b.state.flags == 0); - spa_assert(b.state.offset == 536); + spa_assert_se(b.state.offset == 536); len = b.state.offset; pod = head = (struct spa_pod *)buffer; - spa_assert(spa_pod_is_inside(head, len, pod)); - spa_assert(spa_pod_is_none(pod)); - spa_assert((pod = spa_pod_next(pod)) != NULL && spa_pod_is_inside(head, len, pod)); - spa_assert(spa_pod_is_bool(pod)); - spa_assert(spa_pod_get_bool(pod, &val.b) == 0); - spa_assert(val.b == true); - spa_assert((pod = spa_pod_next(pod)) != NULL && spa_pod_is_inside(head, len, pod)); - spa_assert(spa_pod_is_id(pod)); - spa_assert(spa_pod_get_id(pod, &val.I) == 0); - spa_assert(val.I == SPA_TYPE_Object); - spa_assert((pod = spa_pod_next(pod)) != NULL && spa_pod_is_inside(head, len, pod)); - spa_assert(spa_pod_is_int(pod)); - spa_assert(spa_pod_get_int(pod, &val.i) == 0); - spa_assert(val.i == 21); - spa_assert((pod = spa_pod_next(pod)) != NULL && spa_pod_is_inside(head, len, pod)); - spa_assert(spa_pod_is_float(pod)); - spa_assert(spa_pod_get_float(pod, &val.f) == 0); - spa_assert(val.f == 0.8f); - spa_assert((pod = spa_pod_next(pod)) != NULL && spa_pod_is_inside(head, len, pod)); - spa_assert(spa_pod_is_double(pod)); - spa_assert(spa_pod_get_double(pod, &val.d) == 0); - spa_assert(val.d == -1.56); - spa_assert((pod = spa_pod_next(pod)) != NULL && spa_pod_is_inside(head, len, pod)); - spa_assert(spa_pod_is_string(pod)); - spa_assert(spa_pod_get_string(pod, &val.s) == 0); - spa_assert(spa_streq(val.s, "test")); - spa_assert((pod = spa_pod_next(pod)) != NULL && spa_pod_is_inside(head, len, pod)); - spa_assert(spa_pod_is_bytes(pod)); - spa_assert(spa_pod_get_bytes(pod, &val.y, &yl) == 0); - spa_assert(yl == 8); - spa_assert(memcmp(val.y, "PipeWire", yl) == 0); - spa_assert((pod = spa_pod_next(pod)) != NULL && spa_pod_is_inside(head, len, pod)); - spa_assert(spa_pod_is_pointer(pod)); - spa_assert(spa_pod_get_pointer(pod, &yl, &val.p) == 0); - spa_assert(yl == SPA_TYPE_Object); - spa_assert(val.p == &b); - spa_assert((pod = spa_pod_next(pod)) != NULL && spa_pod_is_inside(head, len, pod)); - spa_assert(spa_pod_is_fd(pod)); - spa_assert(spa_pod_get_fd(pod, &val.l) == 0); - spa_assert(val.l == 4); - spa_assert((pod = spa_pod_next(pod)) != NULL && spa_pod_is_inside(head, len, pod)); - spa_assert(spa_pod_is_rectangle(pod)); - spa_assert(spa_pod_get_rectangle(pod, &val.R) == 0); - spa_assert(memcmp(&val.R, &SPA_RECTANGLE(320,240), sizeof(struct spa_rectangle)) == 0); - spa_assert((pod = spa_pod_next(pod)) != NULL && spa_pod_is_inside(head, len, pod)); - spa_assert(spa_pod_is_fraction(pod)); - spa_assert(spa_pod_get_fraction(pod, &val.F) == 0); - spa_assert(memcmp(&val.F, &SPA_FRACTION(25,1), sizeof(struct spa_fraction)) == 0); + spa_assert_se(spa_pod_is_inside(head, len, pod)); + spa_assert_se(spa_pod_is_none(pod)); + spa_assert_se((pod = spa_pod_next(pod)) != NULL && spa_pod_is_inside(head, len, pod)); + spa_assert_se(spa_pod_is_bool(pod)); + spa_assert_se(spa_pod_get_bool(pod, &val.b) == 0); + spa_assert_se(val.b == true); + spa_assert_se((pod = spa_pod_next(pod)) != NULL && spa_pod_is_inside(head, len, pod)); + spa_assert_se(spa_pod_is_id(pod)); + spa_assert_se(spa_pod_get_id(pod, &val.I) == 0); + spa_assert_se(val.I == SPA_TYPE_Object); + spa_assert_se((pod = spa_pod_next(pod)) != NULL && spa_pod_is_inside(head, len, pod)); + spa_assert_se(spa_pod_is_int(pod)); + spa_assert_se(spa_pod_get_int(pod, &val.i) == 0); + spa_assert_se(val.i == 21); + spa_assert_se((pod = spa_pod_next(pod)) != NULL && spa_pod_is_inside(head, len, pod)); + spa_assert_se(spa_pod_is_float(pod)); + spa_assert_se(spa_pod_get_float(pod, &val.f) == 0); + spa_assert_se(val.f == 0.8f); + spa_assert_se((pod = spa_pod_next(pod)) != NULL && spa_pod_is_inside(head, len, pod)); + spa_assert_se(spa_pod_is_double(pod)); + spa_assert_se(spa_pod_get_double(pod, &val.d) == 0); + spa_assert_se(val.d == -1.56); + spa_assert_se((pod = spa_pod_next(pod)) != NULL && spa_pod_is_inside(head, len, pod)); + spa_assert_se(spa_pod_is_string(pod)); + spa_assert_se(spa_pod_get_string(pod, &val.s) == 0); + spa_assert_se(spa_streq(val.s, "test")); + spa_assert_se((pod = spa_pod_next(pod)) != NULL && spa_pod_is_inside(head, len, pod)); + spa_assert_se(spa_pod_is_bytes(pod)); + spa_assert_se(spa_pod_get_bytes(pod, &val.y, &yl) == 0); + spa_assert_se(yl == 8); + spa_assert_se(memcmp(val.y, "PipeWire", yl) == 0); + spa_assert_se((pod = spa_pod_next(pod)) != NULL && spa_pod_is_inside(head, len, pod)); + spa_assert_se(spa_pod_is_pointer(pod)); + spa_assert_se(spa_pod_get_pointer(pod, &yl, &val.p) == 0); + spa_assert_se(yl == SPA_TYPE_Object); + spa_assert_se(val.p == &b); + spa_assert_se((pod = spa_pod_next(pod)) != NULL && spa_pod_is_inside(head, len, pod)); + spa_assert_se(spa_pod_is_fd(pod)); + spa_assert_se(spa_pod_get_fd(pod, &val.l) == 0); + spa_assert_se(val.l == 4); + spa_assert_se((pod = spa_pod_next(pod)) != NULL && spa_pod_is_inside(head, len, pod)); + spa_assert_se(spa_pod_is_rectangle(pod)); + spa_assert_se(spa_pod_get_rectangle(pod, &val.R) == 0); + spa_assert_se(memcmp(&val.R, &SPA_RECTANGLE(320,240), sizeof(struct spa_rectangle)) == 0); + spa_assert_se((pod = spa_pod_next(pod)) != NULL && spa_pod_is_inside(head, len, pod)); + spa_assert_se(spa_pod_is_fraction(pod)); + spa_assert_se(spa_pod_get_fraction(pod, &val.F) == 0); + spa_assert_se(memcmp(&val.F, &SPA_FRACTION(25,1), sizeof(struct spa_fraction)) == 0); - spa_assert((pod = spa_pod_next(pod)) != NULL && spa_pod_is_inside(head, len, pod)); - spa_assert(spa_pod_is_array(pod)); - spa_assert(SPA_POD_ARRAY_VALUE_TYPE(pod) == SPA_TYPE_Int); - spa_assert(SPA_POD_ARRAY_VALUE_SIZE(pod) == sizeof(int32_t)); - spa_assert(SPA_POD_ARRAY_N_VALUES(pod) == 3); + spa_assert_se((pod = spa_pod_next(pod)) != NULL && spa_pod_is_inside(head, len, pod)); + spa_assert_se(spa_pod_is_array(pod)); + spa_assert_se(SPA_POD_ARRAY_VALUE_TYPE(pod) == SPA_TYPE_Int); + spa_assert_se(SPA_POD_ARRAY_VALUE_SIZE(pod) == sizeof(int32_t)); + spa_assert_se(SPA_POD_ARRAY_N_VALUES(pod) == 3); ai = SPA_POD_ARRAY_VALUES(pod); - spa_assert(ai != NULL); - spa_assert(SPA_POD_ARRAY_CHILD(pod)->type == SPA_TYPE_Int); - spa_assert(SPA_POD_ARRAY_CHILD(pod)->size == sizeof(int32_t)); - spa_assert(ai[0] == 1); - spa_assert(ai[1] == 2); - spa_assert(ai[2] == 3); + spa_assert_se(ai != NULL); + spa_assert_se(SPA_POD_ARRAY_CHILD(pod)->type == SPA_TYPE_Int); + spa_assert_se(SPA_POD_ARRAY_CHILD(pod)->size == sizeof(int32_t)); + spa_assert_se(ai[0] == 1); + spa_assert_se(ai[1] == 2); + spa_assert_se(ai[2] == 3); i = 1; SPA_POD_ARRAY_FOREACH((struct spa_pod_array*)pod, ai) { - spa_assert(*ai == i); + spa_assert_se(*ai == i); i++; } - spa_assert((pod = spa_pod_next(pod)) != NULL && spa_pod_is_inside(head, len, pod)); - spa_assert(spa_pod_is_array(pod)); - spa_assert(SPA_POD_ARRAY_VALUE_TYPE(pod) == SPA_TYPE_Long); - spa_assert(SPA_POD_ARRAY_VALUE_SIZE(pod) == sizeof(int64_t)); - spa_assert(SPA_POD_ARRAY_N_VALUES(pod) == SPA_N_ELEMENTS(longs)); + spa_assert_se((pod = spa_pod_next(pod)) != NULL && spa_pod_is_inside(head, len, pod)); + spa_assert_se(spa_pod_is_array(pod)); + spa_assert_se(SPA_POD_ARRAY_VALUE_TYPE(pod) == SPA_TYPE_Long); + spa_assert_se(SPA_POD_ARRAY_VALUE_SIZE(pod) == sizeof(int64_t)); + spa_assert_se(SPA_POD_ARRAY_N_VALUES(pod) == SPA_N_ELEMENTS(longs)); al = SPA_POD_ARRAY_VALUES(pod); - spa_assert(al != NULL); - spa_assert(SPA_POD_ARRAY_CHILD(pod)->type == SPA_TYPE_Long); - spa_assert(SPA_POD_ARRAY_CHILD(pod)->size == sizeof(int64_t)); + spa_assert_se(al != NULL); + spa_assert_se(SPA_POD_ARRAY_CHILD(pod)->type == SPA_TYPE_Long); + spa_assert_se(SPA_POD_ARRAY_CHILD(pod)->size == sizeof(int64_t)); for (i = 0; i < SPA_N_ELEMENTS(longs); i++) - spa_assert(al[i] == longs[i]); + spa_assert_se(al[i] == longs[i]); i = 0; SPA_POD_ARRAY_FOREACH((struct spa_pod_array*)pod, al) { - spa_assert(*al == longs[i++]); + spa_assert_se(*al == longs[i++]); } - spa_assert((pod = spa_pod_next(pod)) != NULL && spa_pod_is_inside(head, len, pod)); - spa_assert(spa_pod_is_choice(pod)); - spa_assert(SPA_POD_CHOICE_TYPE(pod) == SPA_CHOICE_Enum); - spa_assert(SPA_POD_CHOICE_FLAGS(pod) == 0); - spa_assert(SPA_POD_CHOICE_VALUE_TYPE(pod) == SPA_TYPE_Long); - spa_assert(SPA_POD_CHOICE_VALUE_SIZE(pod) == sizeof(int64_t)); - spa_assert(SPA_POD_CHOICE_N_VALUES(pod) == 3); + spa_assert_se((pod = spa_pod_next(pod)) != NULL && spa_pod_is_inside(head, len, pod)); + spa_assert_se(spa_pod_is_choice(pod)); + spa_assert_se(SPA_POD_CHOICE_TYPE(pod) == SPA_CHOICE_Enum); + spa_assert_se(SPA_POD_CHOICE_FLAGS(pod) == 0); + spa_assert_se(SPA_POD_CHOICE_VALUE_TYPE(pod) == SPA_TYPE_Long); + spa_assert_se(SPA_POD_CHOICE_VALUE_SIZE(pod) == sizeof(int64_t)); + spa_assert_se(SPA_POD_CHOICE_N_VALUES(pod) == 3); al = SPA_POD_CHOICE_VALUES(pod); - spa_assert(al != NULL); - spa_assert(SPA_POD_CHOICE_CHILD(pod)->type == SPA_TYPE_Long); - spa_assert(SPA_POD_CHOICE_CHILD(pod)->size == sizeof(int64_t)); - spa_assert(al[0] == 1); - spa_assert(al[1] == 2); - spa_assert(al[2] == 3); + spa_assert_se(al != NULL); + spa_assert_se(SPA_POD_CHOICE_CHILD(pod)->type == SPA_TYPE_Long); + spa_assert_se(SPA_POD_CHOICE_CHILD(pod)->size == sizeof(int64_t)); + spa_assert_se(al[0] == 1); + spa_assert_se(al[1] == 2); + spa_assert_se(al[2] == 3); i = 1; SPA_POD_CHOICE_FOREACH((struct spa_pod_choice*)pod, al) { - spa_assert(*al == i); + spa_assert_se(*al == i); i++; } - spa_assert((pod = spa_pod_next(pod)) != NULL && spa_pod_is_inside(head, len, pod)); - spa_assert(spa_pod_is_struct(pod)); + spa_assert_se((pod = spa_pod_next(pod)) != NULL && spa_pod_is_inside(head, len, pod)); + spa_assert_se(spa_pod_is_struct(pod)); i = 0; SPA_POD_STRUCT_FOREACH(pod, it) { switch (i++) { case 0: - spa_assert(spa_pod_is_int(it)); - spa_assert(spa_pod_get_int(it, &val.i) == 0 && val.i == 21); + spa_assert_se(spa_pod_is_int(it)); + spa_assert_se(spa_pod_get_int(it, &val.i) == 0 && val.i == 21); break; case 1: - spa_assert(spa_pod_is_float(it)); - spa_assert(spa_pod_get_float(it, &val.f) == 0 && val.f == 0.8f); + spa_assert_se(spa_pod_is_float(it)); + spa_assert_se(spa_pod_get_float(it, &val.f) == 0 && val.f == 0.8f); break; case 2: - spa_assert(spa_pod_is_double(it)); - spa_assert(spa_pod_get_double(it, &val.d) == 0 && val.d == -1.56); + spa_assert_se(spa_pod_is_double(it)); + spa_assert_se(spa_pod_get_double(it, &val.d) == 0 && val.d == -1.56); break; default: spa_assert_not_reached(); @@ -619,27 +619,27 @@ PWTEST(pod_build) } } - spa_assert((pod = spa_pod_next(pod)) != NULL && spa_pod_is_inside(head, len, pod)); - spa_assert(spa_pod_is_object(pod)); - spa_assert(spa_pod_is_object_type(pod, SPA_TYPE_OBJECT_Props)); - spa_assert(spa_pod_is_object_id(pod, 0)); + spa_assert_se((pod = spa_pod_next(pod)) != NULL && spa_pod_is_inside(head, len, pod)); + spa_assert_se(spa_pod_is_object(pod)); + spa_assert_se(spa_pod_is_object_type(pod, SPA_TYPE_OBJECT_Props)); + spa_assert_se(spa_pod_is_object_id(pod, 0)); i = 0; SPA_POD_OBJECT_FOREACH((const struct spa_pod_object*)pod, prop) { switch (i++) { case 0: - spa_assert(prop->key == 1); - spa_assert(SPA_POD_PROP_SIZE(prop) == 20); - spa_assert(spa_pod_get_int(&prop->value, &val.i) == 0 && val.i == 21); + spa_assert_se(prop->key == 1); + spa_assert_se(SPA_POD_PROP_SIZE(prop) == 20); + spa_assert_se(spa_pod_get_int(&prop->value, &val.i) == 0 && val.i == 21); break; case 1: - spa_assert(prop->key == 2); - spa_assert(SPA_POD_PROP_SIZE(prop) == 24); - spa_assert(spa_pod_get_long(&prop->value, &val.l) == 0 && val.l == 42); + spa_assert_se(prop->key == 2); + spa_assert_se(SPA_POD_PROP_SIZE(prop) == 24); + spa_assert_se(spa_pod_get_long(&prop->value, &val.l) == 0 && val.l == 42); break; case 2: - spa_assert(prop->key == 3); - spa_assert(SPA_POD_PROP_SIZE(prop) == 24); - spa_assert(spa_pod_get_string(&prop->value, &val.s) == 0 && + spa_assert_se(prop->key == 3); + spa_assert_se(SPA_POD_PROP_SIZE(prop) == 24); + spa_assert_se(spa_pod_get_string(&prop->value, &val.s) == 0 && spa_streq(val.s, "test123")); break; default: @@ -648,42 +648,42 @@ PWTEST(pod_build) } } prop = spa_pod_find_prop(pod, NULL, 3); - spa_assert(prop != NULL); - spa_assert(prop->key == 3); - spa_assert(spa_pod_get_string(&prop->value, &val.s) == 0 && + spa_assert_se(prop != NULL); + spa_assert_se(prop->key == 3); + spa_assert_se(spa_pod_get_string(&prop->value, &val.s) == 0 && spa_streq(val.s, "test123")); prop = spa_pod_find_prop(pod, prop, 1); - spa_assert(prop != NULL); - spa_assert(prop->key == 1); - spa_assert(spa_pod_get_int(&prop->value, &val.i) == 0 && val.i == 21); + spa_assert_se(prop != NULL); + spa_assert_se(prop->key == 1); + spa_assert_se(spa_pod_get_int(&prop->value, &val.i) == 0 && val.i == 21); prop = spa_pod_find_prop(pod, prop, 2); - spa_assert(prop != NULL); - spa_assert(prop->key == 2); - spa_assert(spa_pod_get_long(&prop->value, &val.l) == 0 && val.l == 42); + spa_assert_se(prop != NULL); + spa_assert_se(prop->key == 2); + spa_assert_se(spa_pod_get_long(&prop->value, &val.l) == 0 && val.l == 42); prop = spa_pod_find_prop(pod, prop, 5); - spa_assert(prop == NULL); + spa_assert_se(prop == NULL); prop = spa_pod_find_prop(pod, NULL, 3); - spa_assert(prop != NULL); - spa_assert(prop->key == 3); - spa_assert(spa_pod_get_string(&prop->value, &val.s) == 0 && + spa_assert_se(prop != NULL); + spa_assert_se(prop->key == 3); + spa_assert_se(spa_pod_get_string(&prop->value, &val.s) == 0 && spa_streq(val.s, "test123")); - spa_assert((pod = spa_pod_next(pod)) != NULL && spa_pod_is_inside(head, len, pod)); - spa_assert(spa_pod_is_sequence(pod)); + spa_assert_se((pod = spa_pod_next(pod)) != NULL && spa_pod_is_inside(head, len, pod)); + spa_assert_se(spa_pod_is_sequence(pod)); i = 0; SPA_POD_SEQUENCE_FOREACH((const struct spa_pod_sequence*)pod, control) { switch (i++) { case 0: - spa_assert(control->offset == 0); - spa_assert(SPA_POD_CONTROL_SIZE(control) == 20); - spa_assert(spa_pod_get_float(&control->value, &val.f) == 0 && val.f == 0.667f); + spa_assert_se(control->offset == 0); + spa_assert_se(SPA_POD_CONTROL_SIZE(control) == 20); + spa_assert_se(spa_pod_get_float(&control->value, &val.f) == 0 && val.f == 0.667f); break; case 1: - spa_assert(control->offset == 12); - spa_assert(SPA_POD_CONTROL_SIZE(control) == 24); - spa_assert(spa_pod_get_double(&control->value, &val.d) == 0 && val.d == 1.22); + spa_assert_se(control->offset == 12); + spa_assert_se(SPA_POD_CONTROL_SIZE(control) == 24); + spa_assert_se(spa_pod_get_double(&control->value, &val.d) == 0 && val.d == 1.22); break; default: spa_assert_not_reached(); @@ -705,73 +705,73 @@ PWTEST(pod_empty) /* create empty arrays */ spa_pod_builder_init(&b, buffer, sizeof(buffer)); - spa_assert(spa_pod_builder_push_array(&b, &f) == 0); - spa_assert(spa_pod_builder_child(&b, sizeof(uint32_t), SPA_TYPE_Id) == 0); + spa_assert_se(spa_pod_builder_push_array(&b, &f) == 0); + spa_assert_se(spa_pod_builder_child(&b, sizeof(uint32_t), SPA_TYPE_Id) == 0); array = spa_pod_builder_pop(&b, &f); - spa_assert(array != NULL); + spa_assert_se(array != NULL); spa_debug_mem(0, array, 16); - spa_assert(spa_pod_is_array(array)); + spa_assert_se(spa_pod_is_array(array)); a2 = spa_pod_get_array(array, &n_vals); - spa_assert(a2 != NULL); - spa_assert(n_vals == 0); + spa_assert_se(a2 != NULL); + spa_assert_se(n_vals == 0); spa_pod_builder_init(&b, buffer, sizeof(buffer)); - spa_assert(spa_pod_builder_push_array(&b, &f) == 0); + spa_assert_se(spa_pod_builder_push_array(&b, &f) == 0); array = spa_pod_builder_pop(&b, &f); - spa_assert(array != NULL); - spa_assert(spa_pod_is_array(array)); + spa_assert_se(array != NULL); + spa_assert_se(spa_pod_is_array(array)); a2 = spa_pod_get_array(array, &n_vals); - spa_assert(a2 != NULL); - spa_assert(n_vals == 0); + spa_assert_se(a2 != NULL); + spa_assert_se(n_vals == 0); spa_pod_builder_init(&b, buffer, sizeof(buffer)); - spa_assert(spa_pod_builder_push_array(&b, &f) == 0); - spa_assert(spa_pod_builder_none(&b) == 0); + spa_assert_se(spa_pod_builder_push_array(&b, &f) == 0); + spa_assert_se(spa_pod_builder_none(&b) == 0); array = spa_pod_builder_pop(&b, &f); - spa_assert(array != NULL); - spa_assert(spa_pod_is_array(array)); + spa_assert_se(array != NULL); + spa_assert_se(spa_pod_is_array(array)); a2 = spa_pod_get_array(array, &n_vals); - spa_assert(a2 != NULL); - spa_assert(n_vals == 0); + spa_assert_se(a2 != NULL); + spa_assert_se(n_vals == 0); spa_pod_builder_init(&b, buffer, sizeof(buffer)); - spa_assert(spa_pod_builder_array(&b, 4, SPA_TYPE_Id, 0, NULL) == 0); + spa_assert_se(spa_pod_builder_array(&b, 4, SPA_TYPE_Id, 0, NULL) == 0); array = (struct spa_pod*)buffer; - spa_assert(spa_pod_is_array(array)); + spa_assert_se(spa_pod_is_array(array)); a2 = spa_pod_get_array(array, &n_vals); - spa_assert(a2 != NULL); - spa_assert(n_vals == 0); + spa_assert_se(a2 != NULL); + spa_assert_se(n_vals == 0); /* create empty choice */ spa_pod_builder_init(&b, buffer, sizeof(buffer)); - spa_assert(spa_pod_builder_push_choice(&b, &f, 0, 0) == 0); - spa_assert(spa_pod_builder_child(&b, sizeof(uint32_t), SPA_TYPE_Id) == 0); + spa_assert_se(spa_pod_builder_push_choice(&b, &f, 0, 0) == 0); + spa_assert_se(spa_pod_builder_child(&b, sizeof(uint32_t), SPA_TYPE_Id) == 0); choice = spa_pod_builder_pop(&b, &f); - spa_assert(choice != NULL); + spa_assert_se(choice != NULL); spa_debug_mem(0, choice, 32); - spa_assert(spa_pod_is_choice(choice)); + spa_assert_se(spa_pod_is_choice(choice)); ch2 = spa_pod_get_values(choice, &n_vals, &ch); - spa_assert(ch2 != NULL); - spa_assert(n_vals == 0); + spa_assert_se(ch2 != NULL); + spa_assert_se(n_vals == 0); spa_pod_builder_init(&b, buffer, sizeof(buffer)); - spa_assert(spa_pod_builder_push_choice(&b, &f, 0, 0) == 0); + spa_assert_se(spa_pod_builder_push_choice(&b, &f, 0, 0) == 0); choice = spa_pod_builder_pop(&b, &f); - spa_assert(choice != NULL); - spa_assert(spa_pod_is_choice(choice)); + spa_assert_se(choice != NULL); + spa_assert_se(spa_pod_is_choice(choice)); ch2 = spa_pod_get_values(choice, &n_vals, &ch); - spa_assert(ch2 != NULL); - spa_assert(n_vals == 0); + spa_assert_se(ch2 != NULL); + spa_assert_se(n_vals == 0); spa_pod_builder_init(&b, buffer, sizeof(buffer)); - spa_assert(spa_pod_builder_push_choice(&b, &f, 0, 0) == 0); - spa_assert(spa_pod_builder_none(&b) == 0); + spa_assert_se(spa_pod_builder_push_choice(&b, &f, 0, 0) == 0); + spa_assert_se(spa_pod_builder_none(&b) == 0); choice = spa_pod_builder_pop(&b, &f); - spa_assert(choice != NULL); - spa_assert(spa_pod_is_choice(choice)); + spa_assert_se(choice != NULL); + spa_assert_se(spa_pod_is_choice(choice)); ch2 = spa_pod_get_values(choice, &n_vals, &ch); - spa_assert(ch2 != NULL); - spa_assert(n_vals == 0); + spa_assert_se(ch2 != NULL); + spa_assert_se(n_vals == 0); return PWTEST_PASS; } @@ -824,53 +824,53 @@ PWTEST(pod_varargs) SPA_POD_OBJECT_FOREACH((const struct spa_pod_object*)pod, prop) { switch (i++) { case 0: - spa_assert(prop->key == SPA_FORMAT_mediaType); - spa_assert(SPA_POD_PROP_SIZE(prop) == 20); - spa_assert(spa_pod_get_id(&prop->value, &val.I) == 0 && val.I == SPA_MEDIA_TYPE_video); + spa_assert_se(prop->key == SPA_FORMAT_mediaType); + spa_assert_se(SPA_POD_PROP_SIZE(prop) == 20); + spa_assert_se(spa_pod_get_id(&prop->value, &val.I) == 0 && val.I == SPA_MEDIA_TYPE_video); break; case 1: - spa_assert(prop->key == SPA_FORMAT_mediaSubtype); - spa_assert(SPA_POD_PROP_SIZE(prop) == 20); - spa_assert(spa_pod_get_id(&prop->value, &val.I) == 0 && val.I == SPA_MEDIA_SUBTYPE_raw); + spa_assert_se(prop->key == SPA_FORMAT_mediaSubtype); + spa_assert_se(SPA_POD_PROP_SIZE(prop) == 20); + spa_assert_se(spa_pod_get_id(&prop->value, &val.I) == 0 && val.I == SPA_MEDIA_SUBTYPE_raw); break; case 2: - spa_assert(prop->key == SPA_FORMAT_VIDEO_format); - spa_assert(spa_pod_is_choice(&prop->value)); - spa_assert(SPA_POD_CHOICE_TYPE(&prop->value) == SPA_CHOICE_Enum); - spa_assert(SPA_POD_CHOICE_N_VALUES(&prop->value) == 3); - spa_assert(SPA_POD_CHOICE_VALUE_TYPE(&prop->value) == SPA_TYPE_Id); - spa_assert(SPA_POD_CHOICE_VALUE_SIZE(&prop->value) == sizeof(uint32_t)); + spa_assert_se(prop->key == SPA_FORMAT_VIDEO_format); + spa_assert_se(spa_pod_is_choice(&prop->value)); + spa_assert_se(SPA_POD_CHOICE_TYPE(&prop->value) == SPA_CHOICE_Enum); + spa_assert_se(SPA_POD_CHOICE_N_VALUES(&prop->value) == 3); + spa_assert_se(SPA_POD_CHOICE_VALUE_TYPE(&prop->value) == SPA_TYPE_Id); + spa_assert_se(SPA_POD_CHOICE_VALUE_SIZE(&prop->value) == sizeof(uint32_t)); aI = SPA_POD_CHOICE_VALUES(&prop->value); - spa_assert(aI != NULL); - spa_assert(aI[0] == SPA_VIDEO_FORMAT_I420); - spa_assert(aI[1] == SPA_VIDEO_FORMAT_I420); - spa_assert(aI[2] == SPA_VIDEO_FORMAT_YUY2); + spa_assert_se(aI != NULL); + spa_assert_se(aI[0] == SPA_VIDEO_FORMAT_I420); + spa_assert_se(aI[1] == SPA_VIDEO_FORMAT_I420); + spa_assert_se(aI[2] == SPA_VIDEO_FORMAT_YUY2); break; case 3: - spa_assert(prop->key == SPA_FORMAT_VIDEO_size); - spa_assert(spa_pod_is_choice(&prop->value)); - spa_assert(SPA_POD_CHOICE_TYPE(&prop->value) == SPA_CHOICE_Range); - spa_assert(SPA_POD_CHOICE_N_VALUES(&prop->value) == 3); - spa_assert(SPA_POD_CHOICE_VALUE_TYPE(&prop->value) == SPA_TYPE_Rectangle); - spa_assert(SPA_POD_CHOICE_VALUE_SIZE(&prop->value) == sizeof(struct spa_rectangle)); + spa_assert_se(prop->key == SPA_FORMAT_VIDEO_size); + spa_assert_se(spa_pod_is_choice(&prop->value)); + spa_assert_se(SPA_POD_CHOICE_TYPE(&prop->value) == SPA_CHOICE_Range); + spa_assert_se(SPA_POD_CHOICE_N_VALUES(&prop->value) == 3); + spa_assert_se(SPA_POD_CHOICE_VALUE_TYPE(&prop->value) == SPA_TYPE_Rectangle); + spa_assert_se(SPA_POD_CHOICE_VALUE_SIZE(&prop->value) == sizeof(struct spa_rectangle)); aR = SPA_POD_CHOICE_VALUES(&prop->value); - spa_assert(aR != NULL); - spa_assert(memcmp(&aR[0], &SPA_RECTANGLE(320,242), sizeof(struct spa_rectangle)) == 0); - spa_assert(memcmp(&aR[1], &SPA_RECTANGLE(1,1), sizeof(struct spa_rectangle)) == 0); - spa_assert(memcmp(&aR[2], &SPA_RECTANGLE(INT32_MAX,INT32_MAX), sizeof(struct spa_rectangle)) == 0); + spa_assert_se(aR != NULL); + spa_assert_se(memcmp(&aR[0], &SPA_RECTANGLE(320,242), sizeof(struct spa_rectangle)) == 0); + spa_assert_se(memcmp(&aR[1], &SPA_RECTANGLE(1,1), sizeof(struct spa_rectangle)) == 0); + spa_assert_se(memcmp(&aR[2], &SPA_RECTANGLE(INT32_MAX,INT32_MAX), sizeof(struct spa_rectangle)) == 0); break; case 4: - spa_assert(prop->key == SPA_FORMAT_VIDEO_framerate); - spa_assert(spa_pod_is_choice(&prop->value)); - spa_assert(SPA_POD_CHOICE_TYPE(&prop->value) == SPA_CHOICE_Range); - spa_assert(SPA_POD_CHOICE_N_VALUES(&prop->value) == 3); - spa_assert(SPA_POD_CHOICE_VALUE_TYPE(&prop->value) == SPA_TYPE_Fraction); - spa_assert(SPA_POD_CHOICE_VALUE_SIZE(&prop->value) == sizeof(struct spa_fraction)); + spa_assert_se(prop->key == SPA_FORMAT_VIDEO_framerate); + spa_assert_se(spa_pod_is_choice(&prop->value)); + spa_assert_se(SPA_POD_CHOICE_TYPE(&prop->value) == SPA_CHOICE_Range); + spa_assert_se(SPA_POD_CHOICE_N_VALUES(&prop->value) == 3); + spa_assert_se(SPA_POD_CHOICE_VALUE_TYPE(&prop->value) == SPA_TYPE_Fraction); + spa_assert_se(SPA_POD_CHOICE_VALUE_SIZE(&prop->value) == sizeof(struct spa_fraction)); aF = SPA_POD_CHOICE_VALUES(&prop->value); - spa_assert(aF != NULL); - spa_assert(memcmp(&aF[0], &SPA_FRACTION(25,1), sizeof(struct spa_fraction)) == 0); - spa_assert(memcmp(&aF[1], &SPA_FRACTION(0,1), sizeof(struct spa_fraction)) == 0); - spa_assert(memcmp(&aF[2], &SPA_FRACTION(INT32_MAX,1), sizeof(struct spa_fraction)) == 0); + spa_assert_se(aF != NULL); + spa_assert_se(memcmp(&aF[0], &SPA_FRACTION(25,1), sizeof(struct spa_fraction)) == 0); + spa_assert_se(memcmp(&aF[1], &SPA_FRACTION(0,1), sizeof(struct spa_fraction)) == 0); + spa_assert_se(memcmp(&aF[2], &SPA_FRACTION(INT32_MAX,1), sizeof(struct spa_fraction)) == 0); break; default: spa_assert_not_reached(); @@ -878,7 +878,7 @@ PWTEST(pod_varargs) } } - spa_assert(spa_pod_parse_object(pod, + spa_assert_se(spa_pod_parse_object(pod, SPA_TYPE_OBJECT_Format, NULL, SPA_FORMAT_mediaType, SPA_POD_Id(&media_type), SPA_FORMAT_mediaSubtype, SPA_POD_Id(&media_subtype), @@ -886,34 +886,34 @@ PWTEST(pod_varargs) SPA_FORMAT_VIDEO_size, SPA_POD_PodChoice(&Vsize), SPA_FORMAT_VIDEO_framerate, SPA_POD_PodChoice(&Vframerate)) == 5); - spa_assert(media_type == SPA_MEDIA_TYPE_video); - spa_assert(media_subtype == SPA_MEDIA_SUBTYPE_raw); + spa_assert_se(media_type == SPA_MEDIA_TYPE_video); + spa_assert_se(media_subtype == SPA_MEDIA_SUBTYPE_raw); - spa_assert(spa_pod_is_choice(Vformat)); - spa_assert(SPA_POD_CHOICE_TYPE(Vformat) == SPA_CHOICE_Enum); - spa_assert(SPA_POD_CHOICE_N_VALUES(Vformat) == 3); - spa_assert(SPA_POD_CHOICE_VALUE_TYPE(Vformat) == SPA_TYPE_Id); - spa_assert(SPA_POD_CHOICE_VALUE_SIZE(Vformat) == sizeof(uint32_t)); + spa_assert_se(spa_pod_is_choice(Vformat)); + spa_assert_se(SPA_POD_CHOICE_TYPE(Vformat) == SPA_CHOICE_Enum); + spa_assert_se(SPA_POD_CHOICE_N_VALUES(Vformat) == 3); + spa_assert_se(SPA_POD_CHOICE_VALUE_TYPE(Vformat) == SPA_TYPE_Id); + spa_assert_se(SPA_POD_CHOICE_VALUE_SIZE(Vformat) == sizeof(uint32_t)); aI = SPA_POD_CHOICE_VALUES(Vformat); - spa_assert(aI != NULL); - spa_assert(aI[0] == SPA_VIDEO_FORMAT_I420); - spa_assert(aI[1] == SPA_VIDEO_FORMAT_I420); - spa_assert(aI[2] == SPA_VIDEO_FORMAT_YUY2); + spa_assert_se(aI != NULL); + spa_assert_se(aI[0] == SPA_VIDEO_FORMAT_I420); + spa_assert_se(aI[1] == SPA_VIDEO_FORMAT_I420); + spa_assert_se(aI[2] == SPA_VIDEO_FORMAT_YUY2); - spa_assert(spa_pod_is_choice(Vsize)); - spa_assert(SPA_POD_CHOICE_TYPE(Vsize) == SPA_CHOICE_Range); - spa_assert(SPA_POD_CHOICE_N_VALUES(Vsize) == 3); - spa_assert(SPA_POD_CHOICE_VALUE_TYPE(Vsize) == SPA_TYPE_Rectangle); - spa_assert(SPA_POD_CHOICE_VALUE_SIZE(Vsize) == sizeof(struct spa_rectangle)); + spa_assert_se(spa_pod_is_choice(Vsize)); + spa_assert_se(SPA_POD_CHOICE_TYPE(Vsize) == SPA_CHOICE_Range); + spa_assert_se(SPA_POD_CHOICE_N_VALUES(Vsize) == 3); + spa_assert_se(SPA_POD_CHOICE_VALUE_TYPE(Vsize) == SPA_TYPE_Rectangle); + spa_assert_se(SPA_POD_CHOICE_VALUE_SIZE(Vsize) == sizeof(struct spa_rectangle)); aR = SPA_POD_CHOICE_VALUES(Vsize); - spa_assert(aR != NULL); - spa_assert(memcmp(&aR[0], &SPA_RECTANGLE(320,242), sizeof(struct spa_rectangle)) == 0); - spa_assert(memcmp(&aR[1], &SPA_RECTANGLE(1,1), sizeof(struct spa_rectangle)) == 0); - spa_assert(memcmp(&aR[2], &SPA_RECTANGLE(INT32_MAX,INT32_MAX), sizeof(struct spa_rectangle)) == 0); + spa_assert_se(aR != NULL); + spa_assert_se(memcmp(&aR[0], &SPA_RECTANGLE(320,242), sizeof(struct spa_rectangle)) == 0); + spa_assert_se(memcmp(&aR[1], &SPA_RECTANGLE(1,1), sizeof(struct spa_rectangle)) == 0); + spa_assert_se(memcmp(&aR[2], &SPA_RECTANGLE(INT32_MAX,INT32_MAX), sizeof(struct spa_rectangle)) == 0); - spa_assert(spa_pod_is_choice(Vframerate)); + spa_assert_se(spa_pod_is_choice(Vframerate)); - spa_assert(spa_pod_parse_object(pod, + spa_assert_se(spa_pod_parse_object(pod, SPA_TYPE_OBJECT_Format, NULL, SPA_FORMAT_mediaType, SPA_POD_Id(&media_type), SPA_FORMAT_mediaSubtype, SPA_POD_Id(&media_subtype), @@ -922,7 +922,7 @@ PWTEST(pod_varargs) SPA_FORMAT_VIDEO_size, SPA_POD_Rectangle(&size), SPA_FORMAT_VIDEO_framerate, SPA_POD_Fraction(&framerate)) == -ESRCH); - spa_assert(spa_pod_parse_object(pod, + spa_assert_se(spa_pod_parse_object(pod, SPA_TYPE_OBJECT_Format, NULL, SPA_FORMAT_mediaType, SPA_POD_Id(&media_type), SPA_FORMAT_mediaSubtype, SPA_POD_Id(&media_subtype), @@ -933,7 +933,7 @@ PWTEST(pod_varargs) spa_debug_pod(0, NULL, pod); spa_pod_fixate(pod); - spa_assert(spa_pod_parse_object(pod, + spa_assert_se(spa_pod_parse_object(pod, SPA_TYPE_OBJECT_Format, NULL, SPA_FORMAT_mediaType, SPA_POD_Id(&media_type), SPA_FORMAT_mediaSubtype, SPA_POD_Id(&media_subtype), @@ -942,11 +942,11 @@ PWTEST(pod_varargs) SPA_FORMAT_VIDEO_size, SPA_POD_Rectangle(&size), SPA_FORMAT_VIDEO_framerate, SPA_POD_Fraction(&framerate)) == 5); - spa_assert(media_type == SPA_MEDIA_TYPE_video); - spa_assert(media_subtype == SPA_MEDIA_SUBTYPE_raw); - spa_assert(format == SPA_VIDEO_FORMAT_I420); - spa_assert(memcmp(&size, &SPA_RECTANGLE(320,242), sizeof(struct spa_rectangle)) == 0); - spa_assert(memcmp(&framerate, &SPA_FRACTION(25,1), sizeof(struct spa_fraction)) == 0); + spa_assert_se(media_type == SPA_MEDIA_TYPE_video); + spa_assert_se(media_subtype == SPA_MEDIA_SUBTYPE_raw); + spa_assert_se(format == SPA_VIDEO_FORMAT_I420); + spa_assert_se(memcmp(&size, &SPA_RECTANGLE(320,242), sizeof(struct spa_rectangle)) == 0); + spa_assert_se(memcmp(&framerate, &SPA_FRACTION(25,1), sizeof(struct spa_fraction)) == 0); spa_debug_pod(0, NULL, pod); return PWTEST_PASS; @@ -1006,104 +1006,104 @@ PWTEST(pod_varargs2) SPA_POD_OBJECT_FOREACH((const struct spa_pod_object*)pod, prop) { switch (i++) { case 0: - spa_assert(prop->key == 1); - spa_assert(SPA_POD_PROP_SIZE(prop) == 20); - spa_assert(spa_pod_get_bool(&prop->value, &val.b) == 0 && val.b == true); + spa_assert_se(prop->key == 1); + spa_assert_se(SPA_POD_PROP_SIZE(prop) == 20); + spa_assert_se(spa_pod_get_bool(&prop->value, &val.b) == 0 && val.b == true); break; case 1: - spa_assert(prop->key == 2); - spa_assert(SPA_POD_PROP_SIZE(prop) == 20); - spa_assert(spa_pod_get_id(&prop->value, &val.I) == 0 && val.I == SPA_TYPE_Id); + spa_assert_se(prop->key == 2); + spa_assert_se(SPA_POD_PROP_SIZE(prop) == 20); + spa_assert_se(spa_pod_get_id(&prop->value, &val.I) == 0 && val.I == SPA_TYPE_Id); break; case 2: - spa_assert(prop->key == 3); - spa_assert(SPA_POD_PROP_SIZE(prop) == 20); - spa_assert(spa_pod_get_int(&prop->value, &val.i) == 0 && val.i == 3); + spa_assert_se(prop->key == 3); + spa_assert_se(SPA_POD_PROP_SIZE(prop) == 20); + spa_assert_se(spa_pod_get_int(&prop->value, &val.i) == 0 && val.i == 3); break; case 3: - spa_assert(prop->key == 4); - spa_assert(SPA_POD_PROP_SIZE(prop) == 24); - spa_assert(spa_pod_get_long(&prop->value, &val.l) == 0 && val.l == 4); + spa_assert_se(prop->key == 4); + spa_assert_se(SPA_POD_PROP_SIZE(prop) == 24); + spa_assert_se(spa_pod_get_long(&prop->value, &val.l) == 0 && val.l == 4); break; case 4: - spa_assert(prop->key == 5); - spa_assert(SPA_POD_PROP_SIZE(prop) == 20); - spa_assert(spa_pod_get_float(&prop->value, &val.f) == 0 && val.f == 0.453f); + spa_assert_se(prop->key == 5); + spa_assert_se(SPA_POD_PROP_SIZE(prop) == 20); + spa_assert_se(spa_pod_get_float(&prop->value, &val.f) == 0 && val.f == 0.453f); break; case 5: - spa_assert(prop->key == 6); - spa_assert(SPA_POD_PROP_SIZE(prop) == 24); - spa_assert(spa_pod_get_double(&prop->value, &val.d) == 0 && val.d == 0.871); + spa_assert_se(prop->key == 6); + spa_assert_se(SPA_POD_PROP_SIZE(prop) == 24); + spa_assert_se(spa_pod_get_double(&prop->value, &val.d) == 0 && val.d == 0.871); break; case 6: - spa_assert(prop->key == 7); - spa_assert(SPA_POD_PROP_SIZE(prop) == 21); - spa_assert(spa_pod_get_string(&prop->value, &val.s) == 0); - spa_assert(spa_streq(val.s, "test")); + spa_assert_se(prop->key == 7); + spa_assert_se(SPA_POD_PROP_SIZE(prop) == 21); + spa_assert_se(spa_pod_get_string(&prop->value, &val.s) == 0); + spa_assert_se(spa_streq(val.s, "test")); break; case 7: - spa_assert(prop->key == 8); - spa_assert(SPA_POD_PROP_SIZE(prop) == 21); - spa_assert(spa_pod_get_bytes(&prop->value, &val.y, &val.yl) == 0); - spa_assert(val.yl == sizeof(bytes)); - spa_assert(memcmp(val.y, bytes, val.yl) == 0); + spa_assert_se(prop->key == 8); + spa_assert_se(SPA_POD_PROP_SIZE(prop) == 21); + spa_assert_se(spa_pod_get_bytes(&prop->value, &val.y, &val.yl) == 0); + spa_assert_se(val.yl == sizeof(bytes)); + spa_assert_se(memcmp(val.y, bytes, val.yl) == 0); break; case 8: - spa_assert(prop->key == 9); - spa_assert(SPA_POD_PROP_SIZE(prop) == 24); - spa_assert(spa_pod_get_rectangle(&prop->value, &val.R) == 0); - spa_assert(memcmp(&val.R, &SPA_RECTANGLE(3,4), sizeof(struct spa_rectangle)) == 0); + spa_assert_se(prop->key == 9); + spa_assert_se(SPA_POD_PROP_SIZE(prop) == 24); + spa_assert_se(spa_pod_get_rectangle(&prop->value, &val.R) == 0); + spa_assert_se(memcmp(&val.R, &SPA_RECTANGLE(3,4), sizeof(struct spa_rectangle)) == 0); break; case 9: - spa_assert(prop->key == 10); - spa_assert(SPA_POD_PROP_SIZE(prop) == 24); - spa_assert(spa_pod_get_fraction(&prop->value, &val.F) == 0); - spa_assert(memcmp(&val.F, &SPA_FRACTION(24,1), sizeof(struct spa_fraction)) == 0); + spa_assert_se(prop->key == 10); + spa_assert_se(SPA_POD_PROP_SIZE(prop) == 24); + spa_assert_se(spa_pod_get_fraction(&prop->value, &val.F) == 0); + spa_assert_se(memcmp(&val.F, &SPA_FRACTION(24,1), sizeof(struct spa_fraction)) == 0); break; case 10: - spa_assert(prop->key == 11); - spa_assert(SPA_POD_PROP_SIZE(prop) == 56); - spa_assert(spa_pod_is_array(&prop->value)); - spa_assert(SPA_POD_ARRAY_VALUE_TYPE(&prop->value) == SPA_TYPE_Long); - spa_assert(SPA_POD_ARRAY_VALUE_SIZE(&prop->value) == sizeof(int64_t)); - spa_assert(SPA_POD_ARRAY_N_VALUES(&prop->value) == SPA_N_ELEMENTS(longs)); + spa_assert_se(prop->key == 11); + spa_assert_se(SPA_POD_PROP_SIZE(prop) == 56); + spa_assert_se(spa_pod_is_array(&prop->value)); + spa_assert_se(SPA_POD_ARRAY_VALUE_TYPE(&prop->value) == SPA_TYPE_Long); + spa_assert_se(SPA_POD_ARRAY_VALUE_SIZE(&prop->value) == sizeof(int64_t)); + spa_assert_se(SPA_POD_ARRAY_N_VALUES(&prop->value) == SPA_N_ELEMENTS(longs)); al = SPA_POD_ARRAY_VALUES(&prop->value); - spa_assert(al != NULL); - spa_assert(SPA_POD_ARRAY_CHILD(&prop->value)->type == SPA_TYPE_Long); - spa_assert(SPA_POD_ARRAY_CHILD(&prop->value)->size == sizeof(int64_t)); + spa_assert_se(al != NULL); + spa_assert_se(SPA_POD_ARRAY_CHILD(&prop->value)->type == SPA_TYPE_Long); + spa_assert_se(SPA_POD_ARRAY_CHILD(&prop->value)->size == sizeof(int64_t)); for (j = 0; j < SPA_N_ELEMENTS(longs); j++) - spa_assert(al[j] == longs[j]); + spa_assert_se(al[j] == longs[j]); break; case 11: - spa_assert(prop->key == 12); - spa_assert(SPA_POD_PROP_SIZE(prop) == (sizeof(struct spa_pod_prop) + + spa_assert_se(prop->key == 12); + spa_assert_se(SPA_POD_PROP_SIZE(prop) == (sizeof(struct spa_pod_prop) + sizeof(struct spa_pod_pointer_body))); - spa_assert(spa_pod_get_pointer(&prop->value, &val.ptype, &val.p) == 0); - spa_assert(val.ptype == SPA_TYPE_Object); - spa_assert(val.p == &b); + spa_assert_se(spa_pod_get_pointer(&prop->value, &val.ptype, &val.p) == 0); + spa_assert_se(val.ptype == SPA_TYPE_Object); + spa_assert_se(val.p == &b); break; case 12: - spa_assert(prop->key == 13); - spa_assert(SPA_POD_PROP_SIZE(prop) == 24); - spa_assert(spa_pod_get_fd(&prop->value, &val.h) == 0); - spa_assert(val.h == 3); + spa_assert_se(prop->key == 13); + spa_assert_se(SPA_POD_PROP_SIZE(prop) == 24); + spa_assert_se(spa_pod_get_fd(&prop->value, &val.h) == 0); + spa_assert_se(val.h == 3); break; case 13: - spa_assert(prop->key == 14); - spa_assert(SPA_POD_PROP_SIZE(prop) == 20); - spa_assert(spa_pod_get_int(&prop->value, &val.i) == 0); - spa_assert(val.i == 77); + spa_assert_se(prop->key == 14); + spa_assert_se(SPA_POD_PROP_SIZE(prop) == 20); + spa_assert_se(spa_pod_get_int(&prop->value, &val.i) == 0); + spa_assert_se(val.i == 77); break; default: spa_assert_not_reached(); break; } } - spa_assert(spa_pod_parse_object(pod, SPA_TYPE_OBJECT_Format, NULL) == -EPROTO); - spa_assert(spa_pod_parse_object(pod, SPA_TYPE_OBJECT_Props, NULL) == 0); + spa_assert_se(spa_pod_parse_object(pod, SPA_TYPE_OBJECT_Format, NULL) == -EPROTO); + spa_assert_se(spa_pod_parse_object(pod, SPA_TYPE_OBJECT_Props, NULL) == 0); spa_zero(val); - spa_assert(spa_pod_parse_object(pod, + spa_assert_se(spa_pod_parse_object(pod, SPA_TYPE_OBJECT_Props, NULL, 1, SPA_POD_Bool(&val.b), 2, SPA_POD_Id(&val.I), @@ -1120,28 +1120,28 @@ PWTEST(pod_varargs2) 13, SPA_POD_Fd(&val.h), 14, SPA_POD_Pod(&val.P)) == 14); - spa_assert(val.b == true); - spa_assert(val.I == SPA_TYPE_Id); - spa_assert(val.i == 3); - spa_assert(val.l == 4); - spa_assert(val.f == 0.453f); - spa_assert(val.d == 0.871); - spa_assert(spa_streq(val.s, "test")); - spa_assert(val.yl == sizeof(bytes)); - spa_assert(memcmp(val.y, bytes, sizeof(bytes)) == 0); - spa_assert(memcmp(&val.R, &SPA_RECTANGLE(3, 4), sizeof(struct spa_rectangle)) == 0); - spa_assert(memcmp(&val.F, &SPA_FRACTION(24, 1), sizeof(struct spa_fraction)) == 0); - spa_assert(val.asize == sizeof(int64_t)); - spa_assert(val.atype == SPA_TYPE_Long); - spa_assert(val.anvals == SPA_N_ELEMENTS(longs)); - spa_assert(memcmp(val.a, longs, val.anvals * val.asize) == 0); - spa_assert(val.ptype == SPA_TYPE_Object); - spa_assert(val.p == &b); - spa_assert(val.h == 3); - spa_assert(memcmp(val.P, &pi, sizeof(pi)) == 0); + spa_assert_se(val.b == true); + spa_assert_se(val.I == SPA_TYPE_Id); + spa_assert_se(val.i == 3); + spa_assert_se(val.l == 4); + spa_assert_se(val.f == 0.453f); + spa_assert_se(val.d == 0.871); + spa_assert_se(spa_streq(val.s, "test")); + spa_assert_se(val.yl == sizeof(bytes)); + spa_assert_se(memcmp(val.y, bytes, sizeof(bytes)) == 0); + spa_assert_se(memcmp(&val.R, &SPA_RECTANGLE(3, 4), sizeof(struct spa_rectangle)) == 0); + spa_assert_se(memcmp(&val.F, &SPA_FRACTION(24, 1), sizeof(struct spa_fraction)) == 0); + spa_assert_se(val.asize == sizeof(int64_t)); + spa_assert_se(val.atype == SPA_TYPE_Long); + spa_assert_se(val.anvals == SPA_N_ELEMENTS(longs)); + spa_assert_se(memcmp(val.a, longs, val.anvals * val.asize) == 0); + spa_assert_se(val.ptype == SPA_TYPE_Object); + spa_assert_se(val.p == &b); + spa_assert_se(val.h == 3); + spa_assert_se(memcmp(val.P, &pi, sizeof(pi)) == 0); spa_zero(val); - spa_assert(spa_pod_parse_object(pod, + spa_assert_se(spa_pod_parse_object(pod, SPA_TYPE_OBJECT_Props, NULL, 0, SPA_POD_OPT_Bool(&val.b), 0, SPA_POD_OPT_Id(&val.I), @@ -1160,7 +1160,7 @@ PWTEST(pod_varargs2) for (i = 1; i < 15; i++) { spa_zero(val); - spa_assert(spa_pod_parse_object(pod, + spa_assert_se(spa_pod_parse_object(pod, SPA_TYPE_OBJECT_Props, NULL, i, SPA_POD_OPT_Bool(&val.b), i, SPA_POD_OPT_Id(&val.I), @@ -1231,47 +1231,47 @@ PWTEST(pod_parser) spa_debug_pod(0, NULL, pod); spa_pod_parser_pod(&p, pod); - spa_assert(p.state.offset == 0); - spa_assert(spa_pod_parser_get_bool(&p, &val.b) == -EINVAL); - spa_assert(p.state.offset == 0); - spa_assert(spa_pod_parser_get_id(&p, &val.I) == -EINVAL); - spa_assert(p.state.offset == 0); - spa_assert(spa_pod_parser_get_int(&p, &val.i) == -EINVAL); - spa_assert(p.state.offset == 0); - spa_assert(spa_pod_parser_get_long(&p, &val.l) == -EINVAL); - spa_assert(p.state.offset == 0); - spa_assert(spa_pod_parser_get_float(&p, &val.f) == -EINVAL); - spa_assert(p.state.offset == 0); - spa_assert(spa_pod_parser_get_double(&p, &val.d) == -EINVAL); - spa_assert(p.state.offset == 0); - spa_assert(spa_pod_parser_get_string(&p, &val.s) == -EINVAL); - spa_assert(p.state.offset == 0); - spa_assert(spa_pod_parser_get_bytes(&p, &val.y, &val.yl) == -EINVAL); - spa_assert(p.state.offset == 0); - spa_assert(spa_pod_parser_get_rectangle(&p, &val.R) == -EINVAL); - spa_assert(p.state.offset == 0); - spa_assert(spa_pod_parser_get_fraction(&p, &val.F) == -EINVAL); - spa_assert(p.state.offset == 0); - spa_assert(spa_pod_parser_get_pointer(&p, &val.ptype, &val.p) == -EINVAL); - spa_assert(p.state.offset == 0); - spa_assert(spa_pod_parser_get_fd(&p, &val.h) == -EINVAL); - spa_assert(p.state.offset == 0); - spa_assert(spa_pod_parser_get_pod(&p, &val.P) == 0); - spa_assert(p.state.offset == 392); - spa_assert(spa_pod_is_object(val.P)); + spa_assert_se(p.state.offset == 0); + spa_assert_se(spa_pod_parser_get_bool(&p, &val.b) == -EINVAL); + spa_assert_se(p.state.offset == 0); + spa_assert_se(spa_pod_parser_get_id(&p, &val.I) == -EINVAL); + spa_assert_se(p.state.offset == 0); + spa_assert_se(spa_pod_parser_get_int(&p, &val.i) == -EINVAL); + spa_assert_se(p.state.offset == 0); + spa_assert_se(spa_pod_parser_get_long(&p, &val.l) == -EINVAL); + spa_assert_se(p.state.offset == 0); + spa_assert_se(spa_pod_parser_get_float(&p, &val.f) == -EINVAL); + spa_assert_se(p.state.offset == 0); + spa_assert_se(spa_pod_parser_get_double(&p, &val.d) == -EINVAL); + spa_assert_se(p.state.offset == 0); + spa_assert_se(spa_pod_parser_get_string(&p, &val.s) == -EINVAL); + spa_assert_se(p.state.offset == 0); + spa_assert_se(spa_pod_parser_get_bytes(&p, &val.y, &val.yl) == -EINVAL); + spa_assert_se(p.state.offset == 0); + spa_assert_se(spa_pod_parser_get_rectangle(&p, &val.R) == -EINVAL); + spa_assert_se(p.state.offset == 0); + spa_assert_se(spa_pod_parser_get_fraction(&p, &val.F) == -EINVAL); + spa_assert_se(p.state.offset == 0); + spa_assert_se(spa_pod_parser_get_pointer(&p, &val.ptype, &val.p) == -EINVAL); + spa_assert_se(p.state.offset == 0); + spa_assert_se(spa_pod_parser_get_fd(&p, &val.h) == -EINVAL); + spa_assert_se(p.state.offset == 0); + spa_assert_se(spa_pod_parser_get_pod(&p, &val.P) == 0); + spa_assert_se(p.state.offset == 392); + spa_assert_se(spa_pod_is_object(val.P)); spa_pod_parser_pod(&p, val.P); - spa_assert(p.state.offset == 0); - spa_assert(spa_pod_parser_push_struct(&p, &f) == -EINVAL); - spa_assert(p.state.offset == 0); - spa_assert(spa_pod_parser_push_object(&p, &f, SPA_TYPE_OBJECT_Format, NULL) == -EPROTO); - spa_assert(p.state.offset == 0); - spa_assert(spa_pod_parser_push_object(&p, &f, SPA_TYPE_OBJECT_Props, NULL) == 0); - spa_assert(p.state.offset == 392); - spa_assert(spa_pod_parser_frame(&p, &f) == val.P); + spa_assert_se(p.state.offset == 0); + spa_assert_se(spa_pod_parser_push_struct(&p, &f) == -EINVAL); + spa_assert_se(p.state.offset == 0); + spa_assert_se(spa_pod_parser_push_object(&p, &f, SPA_TYPE_OBJECT_Format, NULL) == -EPROTO); + spa_assert_se(p.state.offset == 0); + spa_assert_se(spa_pod_parser_push_object(&p, &f, SPA_TYPE_OBJECT_Props, NULL) == 0); + spa_assert_se(p.state.offset == 392); + spa_assert_se(spa_pod_parser_frame(&p, &f) == val.P); spa_zero(val); - spa_assert(spa_pod_parser_get(&p, + spa_assert_se(spa_pod_parser_get(&p, 1, SPA_POD_OPT_Bool(&val.b), 2, SPA_POD_OPT_Id(&val.I), 3, SPA_POD_OPT_Int(&val.i), @@ -1288,27 +1288,27 @@ PWTEST(pod_parser) 14, SPA_POD_OPT_Pod(&val.P), 0) == 14); spa_pod_parser_pop(&p, &f); - spa_assert(val.b == true); - spa_assert(val.I == SPA_TYPE_Id); - spa_assert(val.i == 3); - spa_assert(val.l == 4); - spa_assert(val.f == 0.453f); - spa_assert(val.d == 0.871); - spa_assert(spa_streq(val.s, "test")); - spa_assert(val.yl == sizeof(bytes)); - spa_assert(memcmp(val.y, bytes, sizeof(bytes)) == 0); - spa_assert(memcmp(&val.R, &SPA_RECTANGLE(3, 4), sizeof(struct spa_rectangle)) == 0); - spa_assert(memcmp(&val.F, &SPA_FRACTION(24, 1), sizeof(struct spa_fraction)) == 0); - spa_assert(val.asize == sizeof(int64_t)); - spa_assert(val.atype == SPA_TYPE_Long); - spa_assert(val.anvals == SPA_N_ELEMENTS(longs)); - spa_assert(memcmp(val.a, longs, val.anvals * val.asize) == 0); - spa_assert(val.ptype == SPA_TYPE_Object); - spa_assert(val.p == &b); - spa_assert(val.h == 3); - spa_assert(memcmp(val.P, &pi, sizeof(pi)) == 0); + spa_assert_se(val.b == true); + spa_assert_se(val.I == SPA_TYPE_Id); + spa_assert_se(val.i == 3); + spa_assert_se(val.l == 4); + spa_assert_se(val.f == 0.453f); + spa_assert_se(val.d == 0.871); + spa_assert_se(spa_streq(val.s, "test")); + spa_assert_se(val.yl == sizeof(bytes)); + spa_assert_se(memcmp(val.y, bytes, sizeof(bytes)) == 0); + spa_assert_se(memcmp(&val.R, &SPA_RECTANGLE(3, 4), sizeof(struct spa_rectangle)) == 0); + spa_assert_se(memcmp(&val.F, &SPA_FRACTION(24, 1), sizeof(struct spa_fraction)) == 0); + spa_assert_se(val.asize == sizeof(int64_t)); + spa_assert_se(val.atype == SPA_TYPE_Long); + spa_assert_se(val.anvals == SPA_N_ELEMENTS(longs)); + spa_assert_se(memcmp(val.a, longs, val.anvals * val.asize) == 0); + spa_assert_se(val.ptype == SPA_TYPE_Object); + spa_assert_se(val.p == &b); + spa_assert_se(val.h == 3); + spa_assert_se(memcmp(val.P, &pi, sizeof(pi)) == 0); - spa_assert(p.state.offset == 392); + spa_assert_se(p.state.offset == 392); return PWTEST_PASS; } @@ -1362,90 +1362,90 @@ PWTEST(pod_parser2) spa_debug_pod(0, NULL, pod); spa_pod_parser_pod(&p, pod); - spa_assert(p.state.offset == 0); - spa_assert(spa_pod_parser_get_bool(&p, &val.b) == -EINVAL); - spa_assert(p.state.offset == 0); - spa_assert(spa_pod_parser_get_id(&p, &val.I) == -EINVAL); - spa_assert(p.state.offset == 0); - spa_assert(spa_pod_parser_get_int(&p, &val.i) == -EINVAL); - spa_assert(p.state.offset == 0); - spa_assert(spa_pod_parser_get_long(&p, &val.l) == -EINVAL); - spa_assert(p.state.offset == 0); - spa_assert(spa_pod_parser_get_float(&p, &val.f) == -EINVAL); - spa_assert(p.state.offset == 0); - spa_assert(spa_pod_parser_get_double(&p, &val.d) == -EINVAL); - spa_assert(p.state.offset == 0); - spa_assert(spa_pod_parser_get_string(&p, &val.s) == -EINVAL); - spa_assert(p.state.offset == 0); - spa_assert(spa_pod_parser_get_bytes(&p, &val.y, &val.yl) == -EINVAL); - spa_assert(p.state.offset == 0); - spa_assert(spa_pod_parser_get_rectangle(&p, &val.R) == -EINVAL); - spa_assert(p.state.offset == 0); - spa_assert(spa_pod_parser_get_fraction(&p, &val.F) == -EINVAL); - spa_assert(p.state.offset == 0); - spa_assert(spa_pod_parser_get_pointer(&p, &val.ptype, &val.p) == -EINVAL); - spa_assert(p.state.offset == 0); - spa_assert(spa_pod_parser_get_fd(&p, &val.h) == -EINVAL); - spa_assert(p.state.offset == 0); - spa_assert(spa_pod_parser_get_pod(&p, &val.P) == 0); - spa_assert(p.state.offset == 272); - spa_assert(spa_pod_is_struct(val.P)); + spa_assert_se(p.state.offset == 0); + spa_assert_se(spa_pod_parser_get_bool(&p, &val.b) == -EINVAL); + spa_assert_se(p.state.offset == 0); + spa_assert_se(spa_pod_parser_get_id(&p, &val.I) == -EINVAL); + spa_assert_se(p.state.offset == 0); + spa_assert_se(spa_pod_parser_get_int(&p, &val.i) == -EINVAL); + spa_assert_se(p.state.offset == 0); + spa_assert_se(spa_pod_parser_get_long(&p, &val.l) == -EINVAL); + spa_assert_se(p.state.offset == 0); + spa_assert_se(spa_pod_parser_get_float(&p, &val.f) == -EINVAL); + spa_assert_se(p.state.offset == 0); + spa_assert_se(spa_pod_parser_get_double(&p, &val.d) == -EINVAL); + spa_assert_se(p.state.offset == 0); + spa_assert_se(spa_pod_parser_get_string(&p, &val.s) == -EINVAL); + spa_assert_se(p.state.offset == 0); + spa_assert_se(spa_pod_parser_get_bytes(&p, &val.y, &val.yl) == -EINVAL); + spa_assert_se(p.state.offset == 0); + spa_assert_se(spa_pod_parser_get_rectangle(&p, &val.R) == -EINVAL); + spa_assert_se(p.state.offset == 0); + spa_assert_se(spa_pod_parser_get_fraction(&p, &val.F) == -EINVAL); + spa_assert_se(p.state.offset == 0); + spa_assert_se(spa_pod_parser_get_pointer(&p, &val.ptype, &val.p) == -EINVAL); + spa_assert_se(p.state.offset == 0); + spa_assert_se(spa_pod_parser_get_fd(&p, &val.h) == -EINVAL); + spa_assert_se(p.state.offset == 0); + spa_assert_se(spa_pod_parser_get_pod(&p, &val.P) == 0); + spa_assert_se(p.state.offset == 272); + spa_assert_se(spa_pod_is_struct(val.P)); spa_pod_parser_pod(&p, val.P); - spa_assert(p.state.offset == 0); - spa_assert(spa_pod_parser_push_object(&p, &f, SPA_TYPE_OBJECT_Format, NULL) == -EINVAL); - spa_assert(p.state.offset == 0); - spa_assert(spa_pod_parser_push_struct(&p, &f) == 0); - spa_assert(f.pod.type == SPA_TYPE_Struct); - spa_assert(f.pod.size == 264); - spa_assert(f.offset == 0); - spa_assert(p.state.frame == &f); - spa_assert(spa_pod_parser_frame(&p, &f) == val.P); - spa_assert(p.state.offset == 8); - spa_assert(spa_pod_parser_get_bool(&p, &val.b) == 0 && val.b == true); - spa_assert(p.state.offset == 24); - spa_assert(spa_pod_parser_get_id(&p, &val.I) == 0 && val.I == SPA_TYPE_Id); - spa_assert(p.state.offset == 40); - spa_assert(spa_pod_parser_get_int(&p, &val.i) == 0 && val.i == 3); - spa_assert(p.state.offset == 56); - spa_assert(spa_pod_parser_get_long(&p, &val.l) == 0 && val.l == 4); - spa_assert(p.state.offset == 72); - spa_assert(spa_pod_parser_get_float(&p, &val.f) == 0 && val.f == 0.453f); - spa_assert(p.state.offset == 88); - spa_assert(spa_pod_parser_get_double(&p, &val.d) == 0 && val.d == 0.871); - spa_assert(p.state.offset == 104); - spa_assert(spa_pod_parser_get_string(&p, &val.s) == 0 && spa_streq(val.s, "test")); - spa_assert(p.state.offset == 120); - spa_assert(spa_pod_parser_get_bytes(&p, &val.y, &val.yl) == 0); - spa_assert(val.yl == sizeof(bytes)); - spa_assert(memcmp(bytes, val.y, sizeof(bytes)) == 0); - spa_assert(p.state.offset == 136); - spa_assert(spa_pod_parser_get_rectangle(&p, &val.R) == 0); - spa_assert(memcmp(&val.R, &SPA_RECTANGLE(3,4), sizeof(struct spa_rectangle)) == 0); - spa_assert(p.state.offset == 152); - spa_assert(spa_pod_parser_get_fraction(&p, &val.F) == 0); - spa_assert(memcmp(&val.F, &SPA_FRACTION(24,1), sizeof(struct spa_fraction)) == 0); - spa_assert(p.state.offset == 168); + spa_assert_se(p.state.offset == 0); + spa_assert_se(spa_pod_parser_push_object(&p, &f, SPA_TYPE_OBJECT_Format, NULL) == -EINVAL); + spa_assert_se(p.state.offset == 0); + spa_assert_se(spa_pod_parser_push_struct(&p, &f) == 0); + spa_assert_se(f.pod.type == SPA_TYPE_Struct); + spa_assert_se(f.pod.size == 264); + spa_assert_se(f.offset == 0); + spa_assert_se(p.state.frame == &f); + spa_assert_se(spa_pod_parser_frame(&p, &f) == val.P); + spa_assert_se(p.state.offset == 8); + spa_assert_se(spa_pod_parser_get_bool(&p, &val.b) == 0 && val.b == true); + spa_assert_se(p.state.offset == 24); + spa_assert_se(spa_pod_parser_get_id(&p, &val.I) == 0 && val.I == SPA_TYPE_Id); + spa_assert_se(p.state.offset == 40); + spa_assert_se(spa_pod_parser_get_int(&p, &val.i) == 0 && val.i == 3); + spa_assert_se(p.state.offset == 56); + spa_assert_se(spa_pod_parser_get_long(&p, &val.l) == 0 && val.l == 4); + spa_assert_se(p.state.offset == 72); + spa_assert_se(spa_pod_parser_get_float(&p, &val.f) == 0 && val.f == 0.453f); + spa_assert_se(p.state.offset == 88); + spa_assert_se(spa_pod_parser_get_double(&p, &val.d) == 0 && val.d == 0.871); + spa_assert_se(p.state.offset == 104); + spa_assert_se(spa_pod_parser_get_string(&p, &val.s) == 0 && spa_streq(val.s, "test")); + spa_assert_se(p.state.offset == 120); + spa_assert_se(spa_pod_parser_get_bytes(&p, &val.y, &val.yl) == 0); + spa_assert_se(val.yl == sizeof(bytes)); + spa_assert_se(memcmp(bytes, val.y, sizeof(bytes)) == 0); + spa_assert_se(p.state.offset == 136); + spa_assert_se(spa_pod_parser_get_rectangle(&p, &val.R) == 0); + spa_assert_se(memcmp(&val.R, &SPA_RECTANGLE(3,4), sizeof(struct spa_rectangle)) == 0); + spa_assert_se(p.state.offset == 152); + spa_assert_se(spa_pod_parser_get_fraction(&p, &val.F) == 0); + spa_assert_se(memcmp(&val.F, &SPA_FRACTION(24,1), sizeof(struct spa_fraction)) == 0); + spa_assert_se(p.state.offset == 168); val.P = spa_pod_parser_next(&p); - spa_assert(val.P != NULL); - spa_assert(spa_pod_is_array(val.P)); - spa_assert(p.state.offset == 216); - spa_assert(SPA_POD_ARRAY_VALUE_TYPE(val.P) == SPA_TYPE_Long); - spa_assert(SPA_POD_ARRAY_VALUE_SIZE(val.P) == sizeof(int64_t)); - spa_assert(SPA_POD_ARRAY_N_VALUES(val.P) == SPA_N_ELEMENTS(longs)); - spa_assert(spa_pod_parser_get_pointer(&p, &val.ptype, &val.p) == 0); - spa_assert(val.ptype == SPA_TYPE_Object); - spa_assert(val.p == &b); - spa_assert(p.state.offset == 240); - spa_assert(spa_pod_parser_get_fd(&p, &val.h) == 0); - spa_assert(val.h == 3); - spa_assert(p.state.offset == 256); - spa_assert(spa_pod_parser_get_pod(&p, &val.P) == 0); - spa_assert(p.state.offset == 272); - spa_assert(spa_pod_is_int(val.P)); + spa_assert_se(val.P != NULL); + spa_assert_se(spa_pod_is_array(val.P)); + spa_assert_se(p.state.offset == 216); + spa_assert_se(SPA_POD_ARRAY_VALUE_TYPE(val.P) == SPA_TYPE_Long); + spa_assert_se(SPA_POD_ARRAY_VALUE_SIZE(val.P) == sizeof(int64_t)); + spa_assert_se(SPA_POD_ARRAY_N_VALUES(val.P) == SPA_N_ELEMENTS(longs)); + spa_assert_se(spa_pod_parser_get_pointer(&p, &val.ptype, &val.p) == 0); + spa_assert_se(val.ptype == SPA_TYPE_Object); + spa_assert_se(val.p == &b); + spa_assert_se(p.state.offset == 240); + spa_assert_se(spa_pod_parser_get_fd(&p, &val.h) == 0); + spa_assert_se(val.h == 3); + spa_assert_se(p.state.offset == 256); + spa_assert_se(spa_pod_parser_get_pod(&p, &val.P) == 0); + spa_assert_se(p.state.offset == 272); + spa_assert_se(spa_pod_is_int(val.P)); spa_pod_parser_pop(&p, &f); - spa_assert(p.state.offset == 272); - spa_assert(p.state.frame == NULL); + spa_assert_se(p.state.offset == 272); + spa_assert_se(p.state.frame == NULL); return PWTEST_PASS; } @@ -1543,12 +1543,12 @@ PWTEST(pod_static) SPA_FORMAT_VIDEO_size, SPA_POD_Rectangle(&vals.size), SPA_FORMAT_VIDEO_framerate, SPA_POD_Fraction(&vals.framerate)); - spa_assert(res == -EPROTO); - spa_assert(vals.media_type == SPA_MEDIA_TYPE_video); - spa_assert(vals.media_subtype == SPA_MEDIA_SUBTYPE_raw); - spa_assert(vals.format == 0); - spa_assert(vals.size.width == 0 && vals.size.height == 0); - spa_assert(vals.framerate.num == 0 && vals.framerate.denom == 0); + spa_assert_se(res == -EPROTO); + spa_assert_se(vals.media_type == SPA_MEDIA_TYPE_video); + spa_assert_se(vals.media_subtype == SPA_MEDIA_SUBTYPE_raw); + spa_assert_se(vals.format == 0); + spa_assert_se(vals.size.width == 0 && vals.size.height == 0); + spa_assert_se(vals.framerate.num == 0 && vals.framerate.denom == 0); spa_pod_fixate(&test_format.fmt.pod); @@ -1561,12 +1561,12 @@ PWTEST(pod_static) SPA_FORMAT_VIDEO_size, SPA_POD_Rectangle(&vals.size), SPA_FORMAT_VIDEO_framerate, SPA_POD_Fraction(&vals.framerate)); - spa_assert(res == 5); - spa_assert(vals.media_type == SPA_MEDIA_TYPE_video); - spa_assert(vals.media_subtype == SPA_MEDIA_SUBTYPE_raw); - spa_assert(vals.format == SPA_VIDEO_FORMAT_I420); - spa_assert(vals.size.width == 320 && vals.size.height == 243); - spa_assert(vals.framerate.num == 25 && vals.framerate.denom == 1); + spa_assert_se(res == 5); + spa_assert_se(vals.media_type == SPA_MEDIA_TYPE_video); + spa_assert_se(vals.media_subtype == SPA_MEDIA_SUBTYPE_raw); + spa_assert_se(vals.format == SPA_VIDEO_FORMAT_I420); + spa_assert_se(vals.size.width == 320 && vals.size.height == 243); + spa_assert_se(vals.framerate.num == 25 && vals.framerate.denom == 1); return PWTEST_PASS; } @@ -1622,18 +1622,18 @@ PWTEST(pod_overflow) spa_pod_builder_int(&b, idx); spa_pod_builder_string(&b, labels[idx]); } - spa_assert(b.state.offset > sizeof(buffer)); + spa_assert_se(b.state.offset > sizeof(buffer)); pod = spa_pod_builder_pop(&b, &f[1]); - spa_assert(pod == NULL); + spa_assert_se(pod == NULL); spa_pod_builder_reset(&b, &state); spa_pod_builder_prop(&b, SPA_PROP_INFO_labels, 0); spa_pod_builder_push_struct(&b, &f[1]); pod = spa_pod_builder_pop(&b, &f[1]); - spa_assert(b.state.offset < sizeof(buffer)); + spa_assert_se(b.state.offset < sizeof(buffer)); pod = spa_pod_builder_pop(&b, &f[0]); - spa_assert(pod != NULL); + spa_assert_se(pod != NULL); spa_debug_pod(0, NULL, pod); return PWTEST_PASS;