Adding upstream version 0.3.65.upstream/0.3.65upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

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;
+}