diff options
Diffstat (limited to 'test/test-spa-node.c')
| -rw-r--r-- | test/test-spa-node.c | 251 |
1 files changed, 251 insertions, 0 deletions
diff --git a/test/test-spa-node.c b/test/test-spa-node.c new file mode 100644 index 0000000..196bd03 --- /dev/null +++ b/test/test-spa-node.c @@ -0,0 +1,251 @@ +/* Simple Plugin API + * + * Copyright © 2019 Wim Taymans <wim.taymans@gmail.com> + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice (including the next + * paragraph) shall be included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + */ + +#include <spa/utils/defs.h> +#include <spa/node/node.h> +#include <spa/node/io.h> +#include <spa/node/command.h> +#include <spa/node/event.h> + +#include "pwtest.h" + +PWTEST(node_io_abi_sizes) +{ +#if defined(__x86_64__) && defined(__LP64__) + pwtest_int_eq(sizeof(struct spa_io_buffers), 8U); + pwtest_int_eq(sizeof(struct spa_io_memory), 16U); + pwtest_int_eq(sizeof(struct spa_io_range), 16U); + pwtest_int_eq(sizeof(struct spa_io_clock), 160U); + pwtest_int_eq(sizeof(struct spa_io_latency), 24U); + pwtest_int_eq(sizeof(struct spa_io_sequence), 16U); + pwtest_int_eq(sizeof(struct spa_io_segment_bar), 64U); + pwtest_int_eq(sizeof(struct spa_io_segment_video), 80U); + pwtest_int_eq(sizeof(struct spa_io_segment), 184U); + + pwtest_int_eq(sizeof(struct spa_io_position), 1688U); + pwtest_int_eq(sizeof(struct spa_io_rate_match), 48U); + + spa_assert_se(sizeof(struct spa_node_info) == 48); + spa_assert_se(sizeof(struct spa_port_info) == 48); + + spa_assert_se(sizeof(struct spa_result_node_error) == 8); + spa_assert_se(sizeof(struct spa_result_node_params) == 24); + + return PWTEST_PASS; +#else + fprintf(stderr, "%zd\n", sizeof(struct spa_io_buffers)); + fprintf(stderr, "%zd\n", sizeof(struct spa_io_memory)); + fprintf(stderr, "%zd\n", sizeof(struct spa_io_range)); + fprintf(stderr, "%zd\n", sizeof(struct spa_io_clock)); + fprintf(stderr, "%zd\n", sizeof(struct spa_io_latency)); + fprintf(stderr, "%zd\n", sizeof(struct spa_io_sequence)); + fprintf(stderr, "%zd\n", sizeof(struct spa_io_segment_bar)); + fprintf(stderr, "%zd\n", sizeof(struct spa_io_segment_video)); + fprintf(stderr, "%zd\n", sizeof(struct spa_io_segment)); + + fprintf(stderr, "%zd\n", sizeof(struct spa_io_position)); + fprintf(stderr, "%zd\n", sizeof(struct spa_io_rate_match)); + + fprintf(stderr, "%zd\n", sizeof(struct spa_node_info)); + fprintf(stderr, "%zd\n", sizeof(struct spa_port_info)); + + fprintf(stderr, "%zd\n", sizeof(struct spa_result_node_error)); + fprintf(stderr, "%zd\n", sizeof(struct spa_result_node_params)); + + return PWTEST_SKIP; +#endif + +} + +PWTEST(node_io_abi) +{ + /* io */ + pwtest_int_eq(SPA_IO_Invalid, 0); + pwtest_int_eq(SPA_IO_Buffers, 1); + pwtest_int_eq(SPA_IO_Range, 2); + pwtest_int_eq(SPA_IO_Clock, 3); + pwtest_int_eq(SPA_IO_Latency, 4); + pwtest_int_eq(SPA_IO_Control, 5); + pwtest_int_eq(SPA_IO_Notify, 6); + pwtest_int_eq(SPA_IO_Position, 7); + pwtest_int_eq(SPA_IO_RateMatch, 8); + pwtest_int_eq(SPA_IO_Memory, 9); + + /* position state */ + pwtest_int_eq(SPA_IO_POSITION_STATE_STOPPED, 0); + pwtest_int_eq(SPA_IO_POSITION_STATE_STARTING, 1); + pwtest_int_eq(SPA_IO_POSITION_STATE_RUNNING, 2); + + return PWTEST_PASS; +} + +PWTEST(node_command_abi) +{ + pwtest_int_eq(SPA_NODE_COMMAND_Suspend, 0); + pwtest_int_eq(SPA_NODE_COMMAND_Pause, 1); + pwtest_int_eq(SPA_NODE_COMMAND_Start, 2); + pwtest_int_eq(SPA_NODE_COMMAND_Enable, 3); + pwtest_int_eq(SPA_NODE_COMMAND_Disable, 4); + pwtest_int_eq(SPA_NODE_COMMAND_Flush, 5); + pwtest_int_eq(SPA_NODE_COMMAND_Drain, 6); + pwtest_int_eq(SPA_NODE_COMMAND_Marker, 7); + + return PWTEST_PASS; +} + +PWTEST(node_event_abi) +{ + pwtest_int_eq(SPA_NODE_EVENT_Error, 0); + pwtest_int_eq(SPA_NODE_EVENT_Buffering, 1); + pwtest_int_eq(SPA_NODE_EVENT_RequestRefresh, 2); + + return PWTEST_PASS; +} + +#define TEST_FUNC(a,b,func, id) \ +do { \ + off_t diff = SPA_PTRDIFF(&a.func, &a); \ + a.func = b.func; \ + pwtest_ptr_eq(diff, SPA_PTRDIFF(&b.func, &b)); \ + pwtest_bool_true(diff == 0 || (diff-1)/sizeof(void*) == id); \ +} while(0) + +PWTEST(node_node_abi) +{ + struct spa_node_events e; + struct spa_node_callbacks c; + struct spa_node_methods m; + struct { + uint32_t version; + void (*info) (void *data, const struct spa_node_info *info); + void (*port_info) (void *data, + enum spa_direction direction, uint32_t port, + const struct spa_port_info *info); + void (*result) (void *data, int seq, int res, + uint32_t type, const void *result); + void (*event) (void *data, const struct spa_event *event); + } events = { SPA_VERSION_NODE_EVENTS, }; + struct { + uint32_t version; + int (*ready) (void *data, int state); + int (*reuse_buffer) (void *data, + uint32_t port_id, + uint32_t buffer_id); + int (*xrun) (void *data, uint64_t trigger, uint64_t delay, + struct spa_pod *info); + } callbacks = { SPA_VERSION_NODE_CALLBACKS, }; + struct { + uint32_t version; + int (*add_listener) (void *object, + struct spa_hook *listener, + const struct spa_node_events *events, + void *data); + int (*set_callbacks) (void *object, + const struct spa_node_callbacks *callbacks, + void *data); + int (*sync) (void *object, int seq); + int (*enum_params) (void *object, int seq, + uint32_t id, uint32_t start, uint32_t max, + const struct spa_pod *filter); + int (*set_param) (void *object, + uint32_t id, uint32_t flags, + const struct spa_pod *param); + int (*set_io) (void *object, + uint32_t id, void *data, size_t size); + int (*send_command) (void *object, const struct spa_command *command); + int (*add_port) (void *object, + enum spa_direction direction, uint32_t port_id, + const struct spa_dict *props); + int (*remove_port) (void *object, + enum spa_direction direction, uint32_t port_id); + int (*port_enum_params) (void *object, int seq, + enum spa_direction direction, uint32_t port_id, + uint32_t id, uint32_t start, uint32_t max, + const struct spa_pod *filter); + int (*port_set_param) (void *object, + enum spa_direction direction, + uint32_t port_id, + uint32_t id, uint32_t flags, + const struct spa_pod *param); + int (*port_use_buffers) (void *object, + enum spa_direction direction, + uint32_t port_id, + uint32_t flags, + struct spa_buffer **buffers, + uint32_t n_buffers); + int (*port_set_io) (void *object, + enum spa_direction direction, + uint32_t port_id, + uint32_t id, + void *data, size_t size); + int (*port_reuse_buffer) (void *object, uint32_t port_id, uint32_t buffer_id); + int (*process) (void *object); + } methods = { SPA_VERSION_NODE_METHODS, 0 }; + + TEST_FUNC(e, events, version, 0); + TEST_FUNC(e, events, info, SPA_NODE_EVENT_INFO); + TEST_FUNC(e, events, port_info, SPA_NODE_EVENT_PORT_INFO); + TEST_FUNC(e, events, result, SPA_NODE_EVENT_RESULT); + TEST_FUNC(e, events, event, SPA_NODE_EVENT_EVENT); + pwtest_int_eq(SPA_NODE_EVENT_NUM, 4); + pwtest_int_eq(sizeof(e), sizeof(events)); + + TEST_FUNC(c, callbacks, version, 0); + TEST_FUNC(c, callbacks, ready, SPA_NODE_CALLBACK_READY); + TEST_FUNC(c, callbacks, reuse_buffer, SPA_NODE_CALLBACK_REUSE_BUFFER); + TEST_FUNC(c, callbacks, xrun, SPA_NODE_CALLBACK_XRUN); + pwtest_int_eq(SPA_NODE_CALLBACK_NUM, 3); + pwtest_int_eq(sizeof(c), sizeof(callbacks)); + + TEST_FUNC(m, methods, version, 0); + TEST_FUNC(m, methods, add_listener, SPA_NODE_METHOD_ADD_LISTENER); + TEST_FUNC(m, methods, set_callbacks, SPA_NODE_METHOD_SET_CALLBACKS); + TEST_FUNC(m, methods, sync, SPA_NODE_METHOD_SYNC); + TEST_FUNC(m, methods, enum_params, SPA_NODE_METHOD_ENUM_PARAMS); + TEST_FUNC(m, methods, set_param, SPA_NODE_METHOD_SET_PARAM); + TEST_FUNC(m, methods, set_io, SPA_NODE_METHOD_SET_IO); + TEST_FUNC(m, methods, send_command, SPA_NODE_METHOD_SEND_COMMAND); + TEST_FUNC(m, methods, add_port, SPA_NODE_METHOD_ADD_PORT); + TEST_FUNC(m, methods, remove_port, SPA_NODE_METHOD_REMOVE_PORT); + TEST_FUNC(m, methods, port_enum_params, SPA_NODE_METHOD_PORT_ENUM_PARAMS); + TEST_FUNC(m, methods, port_use_buffers, SPA_NODE_METHOD_PORT_USE_BUFFERS); + TEST_FUNC(m, methods, port_set_io, SPA_NODE_METHOD_PORT_SET_IO); + TEST_FUNC(m, methods, port_reuse_buffer, SPA_NODE_METHOD_PORT_REUSE_BUFFER); + TEST_FUNC(m, methods, process, SPA_NODE_METHOD_PROCESS); + pwtest_int_eq(SPA_NODE_METHOD_NUM, 15); + pwtest_int_eq(sizeof(m), sizeof(methods)); + + return PWTEST_PASS; +} + +PWTEST_SUITE(spa_node) +{ + pwtest_add(node_io_abi_sizes, PWTEST_NOARG); + pwtest_add(node_io_abi, PWTEST_NOARG); + pwtest_add(node_command_abi, PWTEST_NOARG); + pwtest_add(node_event_abi, PWTEST_NOARG); + pwtest_add(node_node_abi, PWTEST_NOARG); + + return PWTEST_PASS; +} |