mirrors/pipewire
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/pipewire/pipewire.git synced 2025-11-01 22:58:50 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

test: replace all spa_assert() macros with spa_assert_se()

Browse source 
These are tests, we never want those to be optimized away.
This commit is contained in:
Peter Hutterer 2021-07-27 09:59:41 +10:00
parent 63d833dabf
commit 49f3d5842e
14 changed files with 981 additions and 981 deletions
Download patch file Download diff file Expand all files Collapse all files

56
src/modules/module-protocol-native/test-connection.c
View file

@ -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);

6
src/tests/test-client.c
View file

@ -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[])

80
src/tests/test-endpoint.c
View file

@ -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);

74
src/tests/test-interfaces.c
View file

@ -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[])

86
src/tests/test-stream.c
View file

@ -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);
}

36
src/tests/test-utils.c
View file

@ -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[])