mirrors/wayland
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/wayland/wayland.git synced 2025-11-03 09:01:42 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions
wayland/tests/connection-test.c

530 lines
13 KiB
C
Raw Normal View History

tests: Add connection tests
2012-03-02 23:42:46 -05:00
/*
* Copyright © 2012 Intel Corporation
*
* Permission to use, copy, modify, distribute, and sell this software and its
* documentation for any purpose is hereby granted without fee, provided that
* the above copyright notice appear in all copies and that both that copyright
* notice and this permission notice appear in supporting documentation, and
* that the name of the copyright holders not be used in advertising or
* publicity pertaining to distribution of the software without specific,
* written prior permission. The copyright holders make no representations
* about the suitability of this software for any purpose. It is provided "as
* is" without express or implied warranty.
*
* THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
* EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
* DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
* OF THIS SOFTWARE.
*/
Add support for signed 24.8 decimal numbers 'fixed' is a signed decimal type which offers a sign bit, 23 bits of integer precision, and 8 bits of decimal precision. This is exposed as an opaque struct with conversion helpers to and from double and int on the C API side. Signed-off-by: Daniel Stone <daniel@fooishbar.org>
2012-05-08 17:17:25 +01:00
#include <math.h>
tests: Add connection tests
2012-03-02 23:42:46 -05:00
#include <stdio.h>
#include <stdlib.h>
tests: Add connection marshalling tests
2012-03-03 00:29:21 -05:00
#include <stdarg.h>
tests: Add connection tests
2012-03-02 23:42:46 -05:00
#include <string.h>
#include <assert.h>
#include <sys/socket.h>
#include <unistd.h>
#include <errno.h>
connection-test: Test fd transport
2012-03-24 14:27:30 -04:00
#include <sys/types.h>
#include <sys/stat.h>
tests: Add connection tests
2012-03-02 23:42:46 -05:00
tests: fix make check for out-of-tree builds It was failing with missing include files. While here, destroy the ugly "../src/..." include paths used in the tests that was just hacking around this problem in the Makefile: sed -i s/..\\/src\\/// tests/*.c
2012-06-15 22:44:28 +00:00
#include "wayland-private.h"
tests: Add connection tests
2012-03-02 23:42:46 -05:00
#include "test-runner.h"
static const char message[] = "Hello, world";
static struct wl_connection *
Change filedescriptor API to be thread safe The update callback for the file descriptors was always a bit awkward and un-intuitive. The idea was that whenever the protocol code needed to write data to the fd it would call the 'update' function. This function would adjust the mainloop so that it polls for POLLOUT on the fd so we can eventually flush the data to the socket. The problem is that in multi-threaded applications, any thread can issue a request, which writes data to the output buffer and thus triggers the update callback. Thus, we'll be calling out with the display mutex held and may call from any thread. The solution is to eliminate the udpate callback and just require that the application or server flushes all connection buffers before blocking. This turns out to be a simpler API, although we now require clients to deal with EAGAIN and non-blocking writes. It also saves a few syscalls, since the socket will be writable most of the time and most writes will complete, so we avoid changing epoll to poll for POLLOUT, then write and then change it back for each write.
2012-10-04 16:54:22 -04:00
setup(int *s)
tests: Add connection tests
2012-03-02 23:42:46 -05:00
{
struct wl_connection *connection;
assert(socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0, s) == 0);
Change filedescriptor API to be thread safe The update callback for the file descriptors was always a bit awkward and un-intuitive. The idea was that whenever the protocol code needed to write data to the fd it would call the 'update' function. This function would adjust the mainloop so that it polls for POLLOUT on the fd so we can eventually flush the data to the socket. The problem is that in multi-threaded applications, any thread can issue a request, which writes data to the output buffer and thus triggers the update callback. Thus, we'll be calling out with the display mutex held and may call from any thread. The solution is to eliminate the udpate callback and just require that the application or server flushes all connection buffers before blocking. This turns out to be a simpler API, although we now require clients to deal with EAGAIN and non-blocking writes. It also saves a few syscalls, since the socket will be writable most of the time and most writes will complete, so we avoid changing epoll to poll for POLLOUT, then write and then change it back for each write.
2012-10-04 16:54:22 -04:00
connection = wl_connection_create(s[0]);
tests: Add connection tests
2012-03-02 23:42:46 -05:00
assert(connection);
return connection;
}
TEST(connection_create)
{
struct wl_connection *connection;
int s[2];
Change filedescriptor API to be thread safe The update callback for the file descriptors was always a bit awkward and un-intuitive. The idea was that whenever the protocol code needed to write data to the fd it would call the 'update' function. This function would adjust the mainloop so that it polls for POLLOUT on the fd so we can eventually flush the data to the socket. The problem is that in multi-threaded applications, any thread can issue a request, which writes data to the output buffer and thus triggers the update callback. Thus, we'll be calling out with the display mutex held and may call from any thread. The solution is to eliminate the udpate callback and just require that the application or server flushes all connection buffers before blocking. This turns out to be a simpler API, although we now require clients to deal with EAGAIN and non-blocking writes. It also saves a few syscalls, since the socket will be writable most of the time and most writes will complete, so we avoid changing epoll to poll for POLLOUT, then write and then change it back for each write.
2012-10-04 16:54:22 -04:00
connection = setup(s);
tests: Add connection tests
2012-03-02 23:42:46 -05:00
wl_connection_destroy(connection);
close(s[1]);
}
TEST(connection_write)
{
struct wl_connection *connection;
int s[2];
char buffer[64];
Change filedescriptor API to be thread safe The update callback for the file descriptors was always a bit awkward and un-intuitive. The idea was that whenever the protocol code needed to write data to the fd it would call the 'update' function. This function would adjust the mainloop so that it polls for POLLOUT on the fd so we can eventually flush the data to the socket. The problem is that in multi-threaded applications, any thread can issue a request, which writes data to the output buffer and thus triggers the update callback. Thus, we'll be calling out with the display mutex held and may call from any thread. The solution is to eliminate the udpate callback and just require that the application or server flushes all connection buffers before blocking. This turns out to be a simpler API, although we now require clients to deal with EAGAIN and non-blocking writes. It also saves a few syscalls, since the socket will be writable most of the time and most writes will complete, so we avoid changing epoll to poll for POLLOUT, then write and then change it back for each write.
2012-10-04 16:54:22 -04:00
connection = setup(s);
tests: Add connection tests
2012-03-02 23:42:46 -05:00
assert(wl_connection_write(connection, message, sizeof message) == 0);
Change filedescriptor API to be thread safe The update callback for the file descriptors was always a bit awkward and un-intuitive. The idea was that whenever the protocol code needed to write data to the fd it would call the 'update' function. This function would adjust the mainloop so that it polls for POLLOUT on the fd so we can eventually flush the data to the socket. The problem is that in multi-threaded applications, any thread can issue a request, which writes data to the output buffer and thus triggers the update callback. Thus, we'll be calling out with the display mutex held and may call from any thread. The solution is to eliminate the udpate callback and just require that the application or server flushes all connection buffers before blocking. This turns out to be a simpler API, although we now require clients to deal with EAGAIN and non-blocking writes. It also saves a few syscalls, since the socket will be writable most of the time and most writes will complete, so we avoid changing epoll to poll for POLLOUT, then write and then change it back for each write.
2012-10-04 16:54:22 -04:00
assert(wl_connection_flush(connection) == sizeof message);
tests: Add connection tests
2012-03-02 23:42:46 -05:00
assert(read(s[1], buffer, sizeof buffer) == sizeof message);
assert(memcmp(message, buffer, sizeof message) == 0);
wl_connection_destroy(connection);
close(s[1]);
}
TEST(connection_data)
{
struct wl_connection *connection;
int s[2];
char buffer[64];
Change filedescriptor API to be thread safe The update callback for the file descriptors was always a bit awkward and un-intuitive. The idea was that whenever the protocol code needed to write data to the fd it would call the 'update' function. This function would adjust the mainloop so that it polls for POLLOUT on the fd so we can eventually flush the data to the socket. The problem is that in multi-threaded applications, any thread can issue a request, which writes data to the output buffer and thus triggers the update callback. Thus, we'll be calling out with the display mutex held and may call from any thread. The solution is to eliminate the udpate callback and just require that the application or server flushes all connection buffers before blocking. This turns out to be a simpler API, although we now require clients to deal with EAGAIN and non-blocking writes. It also saves a few syscalls, since the socket will be writable most of the time and most writes will complete, so we avoid changing epoll to poll for POLLOUT, then write and then change it back for each write.
2012-10-04 16:54:22 -04:00
connection = setup(s);
tests: Add connection tests
2012-03-02 23:42:46 -05:00
assert(write(s[1], message, sizeof message) == sizeof message);
Change filedescriptor API to be thread safe The update callback for the file descriptors was always a bit awkward and un-intuitive. The idea was that whenever the protocol code needed to write data to the fd it would call the 'update' function. This function would adjust the mainloop so that it polls for POLLOUT on the fd so we can eventually flush the data to the socket. The problem is that in multi-threaded applications, any thread can issue a request, which writes data to the output buffer and thus triggers the update callback. Thus, we'll be calling out with the display mutex held and may call from any thread. The solution is to eliminate the udpate callback and just require that the application or server flushes all connection buffers before blocking. This turns out to be a simpler API, although we now require clients to deal with EAGAIN and non-blocking writes. It also saves a few syscalls, since the socket will be writable most of the time and most writes will complete, so we avoid changing epoll to poll for POLLOUT, then write and then change it back for each write.
2012-10-04 16:54:22 -04:00
assert(wl_connection_read(connection) == sizeof message);
tests: Add connection tests
2012-03-02 23:42:46 -05:00
wl_connection_copy(connection, buffer, sizeof message);
assert(memcmp(message, buffer, sizeof message) == 0);
wl_connection_consume(connection, sizeof message);
wl_connection_destroy(connection);
close(s[1]);
}
TEST(connection_queue)
{
struct wl_connection *connection;
int s[2];
char buffer[64];
Change filedescriptor API to be thread safe The update callback for the file descriptors was always a bit awkward and un-intuitive. The idea was that whenever the protocol code needed to write data to the fd it would call the 'update' function. This function would adjust the mainloop so that it polls for POLLOUT on the fd so we can eventually flush the data to the socket. The problem is that in multi-threaded applications, any thread can issue a request, which writes data to the output buffer and thus triggers the update callback. Thus, we'll be calling out with the display mutex held and may call from any thread. The solution is to eliminate the udpate callback and just require that the application or server flushes all connection buffers before blocking. This turns out to be a simpler API, although we now require clients to deal with EAGAIN and non-blocking writes. It also saves a few syscalls, since the socket will be writable most of the time and most writes will complete, so we avoid changing epoll to poll for POLLOUT, then write and then change it back for each write.
2012-10-04 16:54:22 -04:00
connection = setup(s);
tests: Add connection tests
2012-03-02 23:42:46 -05:00
/* Test that wl_connection_queue() puts data in the output
Change filedescriptor API to be thread safe The update callback for the file descriptors was always a bit awkward and un-intuitive. The idea was that whenever the protocol code needed to write data to the fd it would call the 'update' function. This function would adjust the mainloop so that it polls for POLLOUT on the fd so we can eventually flush the data to the socket. The problem is that in multi-threaded applications, any thread can issue a request, which writes data to the output buffer and thus triggers the update callback. Thus, we'll be calling out with the display mutex held and may call from any thread. The solution is to eliminate the udpate callback and just require that the application or server flushes all connection buffers before blocking. This turns out to be a simpler API, although we now require clients to deal with EAGAIN and non-blocking writes. It also saves a few syscalls, since the socket will be writable most of the time and most writes will complete, so we avoid changing epoll to poll for POLLOUT, then write and then change it back for each write.
2012-10-04 16:54:22 -04:00
* buffer without flush it. Verify that the data did get in
* the buffer by writing another message and making sure that
* we receive the two messages on the other fd. */
tests: Add connection tests
2012-03-02 23:42:46 -05:00
assert(wl_connection_queue(connection, message, sizeof message) == 0);
Change filedescriptor API to be thread safe The update callback for the file descriptors was always a bit awkward and un-intuitive. The idea was that whenever the protocol code needed to write data to the fd it would call the 'update' function. This function would adjust the mainloop so that it polls for POLLOUT on the fd so we can eventually flush the data to the socket. The problem is that in multi-threaded applications, any thread can issue a request, which writes data to the output buffer and thus triggers the update callback. Thus, we'll be calling out with the display mutex held and may call from any thread. The solution is to eliminate the udpate callback and just require that the application or server flushes all connection buffers before blocking. This turns out to be a simpler API, although we now require clients to deal with EAGAIN and non-blocking writes. It also saves a few syscalls, since the socket will be writable most of the time and most writes will complete, so we avoid changing epoll to poll for POLLOUT, then write and then change it back for each write.
2012-10-04 16:54:22 -04:00
assert(wl_connection_flush(connection) == 0);
tests: Add connection tests
2012-03-02 23:42:46 -05:00
assert(wl_connection_write(connection, message, sizeof message) == 0);
Change filedescriptor API to be thread safe The update callback for the file descriptors was always a bit awkward and un-intuitive. The idea was that whenever the protocol code needed to write data to the fd it would call the 'update' function. This function would adjust the mainloop so that it polls for POLLOUT on the fd so we can eventually flush the data to the socket. The problem is that in multi-threaded applications, any thread can issue a request, which writes data to the output buffer and thus triggers the update callback. Thus, we'll be calling out with the display mutex held and may call from any thread. The solution is to eliminate the udpate callback and just require that the application or server flushes all connection buffers before blocking. This turns out to be a simpler API, although we now require clients to deal with EAGAIN and non-blocking writes. It also saves a few syscalls, since the socket will be writable most of the time and most writes will complete, so we avoid changing epoll to poll for POLLOUT, then write and then change it back for each write.
2012-10-04 16:54:22 -04:00
assert(wl_connection_flush(connection) == 2 * sizeof message);
tests: Add connection tests
2012-03-02 23:42:46 -05:00
assert(read(s[1], buffer, sizeof buffer) == 2 * sizeof message);
assert(memcmp(message, buffer, sizeof message) == 0);
assert(memcmp(message, buffer + sizeof message, sizeof message) == 0);
wl_connection_destroy(connection);
close(s[1]);
}
tests: Add connection marshalling tests
2012-03-03 00:29:21 -05:00
struct marshal_data {
tests: Use different connections for read and write tests The connection tests so far only use one connection at a time, but this prepares for tests that use a connection on both sides of the socket.
2012-03-23 11:32:17 -04:00
struct wl_connection *read_connection;
struct wl_connection *write_connection;
tests: Add connection marshalling tests
2012-03-03 00:29:21 -05:00
int s[2];
uint32_t buffer[10];
connection-test: Store expected result in struct marshal_data
2012-03-23 16:56:19 -04:00
union {
uint32_t u;
int32_t i;
const char *s;
connection-test: Test fd transport
2012-03-24 14:27:30 -04:00
int h;
connection-test: Store expected result in struct marshal_data
2012-03-23 16:56:19 -04:00
} value;
tests: Add connection marshalling tests
2012-03-03 00:29:21 -05:00
};
tests: Use different connections for read and write tests The connection tests so far only use one connection at a time, but this prepares for tests that use a connection on both sides of the socket.
2012-03-23 11:32:17 -04:00
static void
setup_marshal_data(struct marshal_data *data)
{
assert(socketpair(AF_UNIX,
SOCK_STREAM | SOCK_CLOEXEC, 0, data->s) == 0);
Change filedescriptor API to be thread safe The update callback for the file descriptors was always a bit awkward and un-intuitive. The idea was that whenever the protocol code needed to write data to the fd it would call the 'update' function. This function would adjust the mainloop so that it polls for POLLOUT on the fd so we can eventually flush the data to the socket. The problem is that in multi-threaded applications, any thread can issue a request, which writes data to the output buffer and thus triggers the update callback. Thus, we'll be calling out with the display mutex held and may call from any thread. The solution is to eliminate the udpate callback and just require that the application or server flushes all connection buffers before blocking. This turns out to be a simpler API, although we now require clients to deal with EAGAIN and non-blocking writes. It also saves a few syscalls, since the socket will be writable most of the time and most writes will complete, so we avoid changing epoll to poll for POLLOUT, then write and then change it back for each write.
2012-10-04 16:54:22 -04:00
data->read_connection = wl_connection_create(data->s[0]);
tests: Use different connections for read and write tests The connection tests so far only use one connection at a time, but this prepares for tests that use a connection on both sides of the socket.
2012-03-23 11:32:17 -04:00
assert(data->read_connection);
Change filedescriptor API to be thread safe The update callback for the file descriptors was always a bit awkward and un-intuitive. The idea was that whenever the protocol code needed to write data to the fd it would call the 'update' function. This function would adjust the mainloop so that it polls for POLLOUT on the fd so we can eventually flush the data to the socket. The problem is that in multi-threaded applications, any thread can issue a request, which writes data to the output buffer and thus triggers the update callback. Thus, we'll be calling out with the display mutex held and may call from any thread. The solution is to eliminate the udpate callback and just require that the application or server flushes all connection buffers before blocking. This turns out to be a simpler API, although we now require clients to deal with EAGAIN and non-blocking writes. It also saves a few syscalls, since the socket will be writable most of the time and most writes will complete, so we avoid changing epoll to poll for POLLOUT, then write and then change it back for each write.
2012-10-04 16:54:22 -04:00
data->write_connection = wl_connection_create(data->s[1]);
tests: Use different connections for read and write tests The connection tests so far only use one connection at a time, but this prepares for tests that use a connection on both sides of the socket.
2012-03-23 11:32:17 -04:00
assert(data->write_connection);
}
static void
release_marshal_data(struct marshal_data *data)
{
wl_connection_destroy(data->read_connection);
wl_connection_destroy(data->write_connection);
}
tests: Add connection marshalling tests
2012-03-03 00:29:21 -05:00
static void
tests: Simplify connection tests a bit
2012-03-05 21:40:01 -05:00
marshal(struct marshal_data *data, const char *format, int size, ...)
tests: Add connection marshalling tests
2012-03-03 00:29:21 -05:00
{
tests: Update test cases to new closure allocate convention
2012-06-15 16:09:39 -04:00
struct wl_closure *closure;
tests: Fix signedness warnings
2012-04-13 10:11:11 -04:00
static const uint32_t opcode = 4444;
tests: Add connection marshalling tests
2012-03-03 00:29:21 -05:00
static struct wl_object sender = { NULL, NULL, 1234 };
tests: Simplify connection tests a bit
2012-03-05 21:40:01 -05:00
struct wl_message message = { "test", format, NULL };
tests: Add connection marshalling tests
2012-03-03 00:29:21 -05:00
va_list ap;
va_start(ap, size);
tests: Update test cases to new closure allocate convention
2012-06-15 16:09:39 -04:00
closure = wl_closure_vmarshal(&sender, opcode, ap, &message);
tests: Add connection marshalling tests
2012-03-03 00:29:21 -05:00
va_end(ap);
tests: Update test cases to new closure allocate convention
2012-06-15 16:09:39 -04:00
assert(closure);
assert(wl_closure_send(closure, data->write_connection) == 0);
wl_closure_destroy(closure);
Change filedescriptor API to be thread safe The update callback for the file descriptors was always a bit awkward and un-intuitive. The idea was that whenever the protocol code needed to write data to the fd it would call the 'update' function. This function would adjust the mainloop so that it polls for POLLOUT on the fd so we can eventually flush the data to the socket. The problem is that in multi-threaded applications, any thread can issue a request, which writes data to the output buffer and thus triggers the update callback. Thus, we'll be calling out with the display mutex held and may call from any thread. The solution is to eliminate the udpate callback and just require that the application or server flushes all connection buffers before blocking. This turns out to be a simpler API, although we now require clients to deal with EAGAIN and non-blocking writes. It also saves a few syscalls, since the socket will be writable most of the time and most writes will complete, so we avoid changing epoll to poll for POLLOUT, then write and then change it back for each write.
2012-10-04 16:54:22 -04:00
assert(wl_connection_flush(data->write_connection) == size);
tests: Use different connections for read and write tests The connection tests so far only use one connection at a time, but this prepares for tests that use a connection on both sides of the socket.
2012-03-23 11:32:17 -04:00
assert(read(data->s[0], data->buffer, sizeof data->buffer) == size);
tests: Add connection marshalling tests
2012-03-03 00:29:21 -05:00
assert(data->buffer[0] == sender.id);
assert(data->buffer[1] == (opcode | (size << 16)));
}
TEST(connection_marshal)
{
struct marshal_data data;
tests: Add more marshal tests
2012-03-05 21:53:38 -05:00
struct wl_object object;
struct wl_array array;
static const char text[] = "curry";
tests: Add connection marshalling tests
2012-03-03 00:29:21 -05:00
tests: Use different connections for read and write tests The connection tests so far only use one connection at a time, but this prepares for tests that use a connection on both sides of the socket.
2012-03-23 11:32:17 -04:00
setup_marshal_data(&data);
tests: Add connection marshalling tests
2012-03-03 00:29:21 -05:00
tests: Simplify connection tests a bit
2012-03-05 21:40:01 -05:00
marshal(&data, "i", 12, 42);
tests: Add connection marshalling tests
2012-03-03 00:29:21 -05:00
assert(data.buffer[2] == 42);
tests: Simplify connection tests a bit
2012-03-05 21:40:01 -05:00
marshal(&data, "u", 12, 55);
tests: Add connection marshalling tests
2012-03-03 00:29:21 -05:00
assert(data.buffer[2] == 55);
tests: Simplify connection tests a bit
2012-03-05 21:40:01 -05:00
marshal(&data, "s", 20, "frappo");
tests: Add connection marshalling tests
2012-03-03 00:29:21 -05:00
assert(data.buffer[2] == 7);
assert(strcmp((char *) &data.buffer[3], "frappo") == 0);
tests: Add more marshal tests
2012-03-05 21:53:38 -05:00
object.id = 557799;
marshal(&data, "o", 12, &object);
assert(data.buffer[2] == object.id);
marshal(&data, "n", 12, &object);
assert(data.buffer[2] == object.id);
More consistent ID printing Use unsigned rather than signed for IDs, so they match up with what we see in other prints. Signed-off-by: Daniel Stone <daniel@fooishbar.org>
2012-07-23 19:54:42 +01:00
marshal(&data, "?n", 12, NULL);
tests: Add more marshal tests
2012-03-05 21:53:38 -05:00
assert(data.buffer[2] == 0);
array.data = (void *) text;
array.size = sizeof text;
marshal(&data, "a", 20, &array);
assert(data.buffer[2] == array.size);
assert(memcmp(&data.buffer[3], text, array.size) == 0);
tests: Use different connections for read and write tests The connection tests so far only use one connection at a time, but this prepares for tests that use a connection on both sides of the socket.
2012-03-23 11:32:17 -04:00
release_marshal_data(&data);
tests: Add connection marshalling tests
2012-03-03 00:29:21 -05:00
}
tests: Add demarshal tests
2012-03-05 22:26:17 -05:00
protocol: Add explicit nullable types Most of the time it does not make sense to pass a NULL object, string, or array to a protocol request. This commit adds an explicit “allow-null” attribute to mark the request arguments where NULL makes sense. Passing a NULL object, string, or array to a protocol request which is not marked as allow-null is now an error. An implementation will never receive a NULL value for these arguments from a client. Signed-off-by: Christopher James Halse Rogers <christopher.halse.rogers@canonical.com>
2012-07-02 20:03:30 +10:00
static void
expected_fail_marshal(int expected_error, const char *format, ...)
{
struct wl_closure *closure;
static const uint32_t opcode = 4444;
static const struct wl_interface test_interface = {
.name = "test_object"
};
static struct wl_object sender = { 0 };
struct wl_message message = { "test", format, NULL };
sender.interface = &test_interface;
sender.id = 1234;
va_list ap;
va_start(ap, format);
closure = wl_closure_vmarshal(&sender, opcode, ap, &message);
va_end(ap);
assert(closure == NULL);
assert(errno == expected_error);
}
TEST(connection_marshal_nullables)
{
struct marshal_data data;
struct wl_object object;
struct wl_array array;
const char text[] = "curry";
setup_marshal_data(&data);
expected_fail_marshal(EINVAL, "o", NULL);
expected_fail_marshal(EINVAL, "s", NULL);
expected_fail_marshal(EINVAL, "a", NULL);
marshal(&data, "?o", 12, NULL);
assert(data.buffer[2] == 0);
marshal(&data, "?a", 12, NULL);
assert(data.buffer[2] == 0);
marshal(&data, "?s", 12, NULL);
assert(data.buffer[2] == 0);
object.id = 55293;
marshal(&data, "?o", 12, &object);
assert(data.buffer[2] == object.id);
array.data = (void *) text;
array.size = sizeof text;
marshal(&data, "?a", 20, &array);
assert(data.buffer[2] == array.size);
assert(memcmp(&data.buffer[3], text, array.size) == 0);
marshal(&data, "?s", 20, text);
assert(data.buffer[2] == sizeof text);
assert(strcmp((char *) &data.buffer[3], text) == 0);
release_marshal_data(&data);
}
tests: Add demarshal tests
2012-03-05 22:26:17 -05:00
static void
connection-test: Store expected result in struct marshal_data
2012-03-23 16:56:19 -04:00
validate_demarshal_u(struct marshal_data *data,
struct wl_object *object, uint32_t u)
tests: Add demarshal tests
2012-03-05 22:26:17 -05:00
{
connection-test: Store expected result in struct marshal_data
2012-03-23 16:56:19 -04:00
assert(data->value.u == u);
tests: Add demarshal tests
2012-03-05 22:26:17 -05:00
}
static void
connection-test: Store expected result in struct marshal_data
2012-03-23 16:56:19 -04:00
validate_demarshal_i(struct marshal_data *data,
struct wl_object *object, int32_t i)
tests: Add demarshal tests
2012-03-05 22:26:17 -05:00
{
connection-test: Store expected result in struct marshal_data
2012-03-23 16:56:19 -04:00
assert(data->value.i == i);
tests: Add demarshal tests
2012-03-05 22:26:17 -05:00
}
static void
connection-test: Store expected result in struct marshal_data
2012-03-23 16:56:19 -04:00
validate_demarshal_s(struct marshal_data *data,
struct wl_object *object, const char *s)
tests: Add demarshal tests
2012-03-05 22:26:17 -05:00
{
protocol: Add explicit nullable types Most of the time it does not make sense to pass a NULL object, string, or array to a protocol request. This commit adds an explicit “allow-null” attribute to mark the request arguments where NULL makes sense. Passing a NULL object, string, or array to a protocol request which is not marked as allow-null is now an error. An implementation will never receive a NULL value for these arguments from a client. Signed-off-by: Christopher James Halse Rogers <christopher.halse.rogers@canonical.com>
2012-07-02 20:03:30 +10:00
if (data->value.s != NULL)
assert(strcmp(data->value.s, s) == 0);
else
assert(s == NULL);
tests: Add demarshal tests
2012-03-05 22:26:17 -05:00
}
connection-test: Test fd transport
2012-03-24 14:27:30 -04:00
static void
validate_demarshal_h(struct marshal_data *data,
struct wl_object *object, int fd)
{
struct stat buf1, buf2;
assert(fd != data->value.h);
fstat(fd, &buf1);
fstat(data->value.h, &buf2);
assert(buf1.st_dev == buf2.st_dev);
assert(buf1.st_ino == buf2.st_ino);
close(fd);
close(data->value.h);
}
Add support for signed 24.8 decimal numbers 'fixed' is a signed decimal type which offers a sign bit, 23 bits of integer precision, and 8 bits of decimal precision. This is exposed as an opaque struct with conversion helpers to and from double and int on the C API side. Signed-off-by: Daniel Stone <daniel@fooishbar.org>
2012-05-08 17:17:25 +01:00
static void
validate_demarshal_f(struct marshal_data *data,
struct wl_object *object, wl_fixed_t f)
{
assert(data->value.i == f);
}
tests: Add demarshal tests
2012-03-05 22:26:17 -05:00
static void
demarshal(struct marshal_data *data, const char *format,
uint32_t *msg, void (*func)(void))
{
struct wl_message message = { "test", format, NULL };
tests: Update test cases to new closure allocate convention
2012-06-15 16:09:39 -04:00
struct wl_closure *closure;
tests: Add demarshal tests
2012-03-05 22:26:17 -05:00
struct wl_map objects;
Change wl_closure_invoke to take an opcode instead of an actual function pointer Signed-off-by: Jason Ekstrand <jason@jlekstrand.net>
2013-03-08 22:26:12 -06:00
struct wl_object object = { NULL, &func, 0 };
tests: Update test cases to new closure allocate convention
2012-06-15 16:09:39 -04:00
int size = msg[1];
tests: Add demarshal tests
2012-03-05 22:26:17 -05:00
assert(write(data->s[1], msg, size) == size);
Change filedescriptor API to be thread safe The update callback for the file descriptors was always a bit awkward and un-intuitive. The idea was that whenever the protocol code needed to write data to the fd it would call the 'update' function. This function would adjust the mainloop so that it polls for POLLOUT on the fd so we can eventually flush the data to the socket. The problem is that in multi-threaded applications, any thread can issue a request, which writes data to the output buffer and thus triggers the update callback. Thus, we'll be calling out with the display mutex held and may call from any thread. The solution is to eliminate the udpate callback and just require that the application or server flushes all connection buffers before blocking. This turns out to be a simpler API, although we now require clients to deal with EAGAIN and non-blocking writes. It also saves a few syscalls, since the socket will be writable most of the time and most writes will complete, so we avoid changing epoll to poll for POLLOUT, then write and then change it back for each write.
2012-10-04 16:54:22 -04:00
assert(wl_connection_read(data->read_connection) == size);
tests: Add demarshal tests
2012-03-05 22:26:17 -05:00
Update tests for wl_map changes and add a map_flags test
2013-06-05 09:52:39 -05:00
wl_map_init(&objects, WL_MAP_SERVER_SIDE);
tests: Add demarshal tests
2012-03-05 22:26:17 -05:00
object.id = msg[0];
tests: Update test cases to new closure allocate convention
2012-06-15 16:09:39 -04:00
closure = wl_connection_demarshal(data->read_connection,
size, &objects, &message);
assert(closure);
Change wl_closure_invoke to take an opcode instead of an actual function pointer Signed-off-by: Jason Ekstrand <jason@jlekstrand.net>
2013-03-08 22:26:12 -06:00
wl_closure_invoke(closure, WL_CLOSURE_INVOKE_SERVER, &object, 0, data);
tests: Update test cases to new closure allocate convention
2012-06-15 16:09:39 -04:00
wl_closure_destroy(closure);
tests: Add demarshal tests
2012-03-05 22:26:17 -05:00
}
TEST(connection_demarshal)
{
struct marshal_data data;
uint32_t msg[10];
tests: Use different connections for read and write tests The connection tests so far only use one connection at a time, but this prepares for tests that use a connection on both sides of the socket.
2012-03-23 11:32:17 -04:00
setup_marshal_data(&data);
tests: Add demarshal tests
2012-03-05 22:26:17 -05:00
connection-test: Store expected result in struct marshal_data
2012-03-23 16:56:19 -04:00
data.value.u = 8000;
tests: Add demarshal tests
2012-03-05 22:26:17 -05:00
msg[0] = 400200; /* object id */
msg[1] = 12; /* size = 12, opcode = 0 */
connection-test: Store expected result in struct marshal_data
2012-03-23 16:56:19 -04:00
msg[2] = data.value.u;
tests: Add demarshal tests
2012-03-05 22:26:17 -05:00
demarshal(&data, "u", msg, (void *) validate_demarshal_u);
connection-test: Store expected result in struct marshal_data
2012-03-23 16:56:19 -04:00
data.value.i = -557799;
tests: Add demarshal tests
2012-03-05 22:26:17 -05:00
msg[0] = 400200;
msg[1] = 12;
connection-test: Store expected result in struct marshal_data
2012-03-23 16:56:19 -04:00
msg[2] = data.value.i;
tests: Add demarshal tests
2012-03-05 22:26:17 -05:00
demarshal(&data, "i", msg, (void *) validate_demarshal_i);
connection-test: Store expected result in struct marshal_data
2012-03-23 16:56:19 -04:00
data.value.s = "superdude";
tests: Add demarshal tests
2012-03-05 22:26:17 -05:00
msg[0] = 400200;
msg[1] = 24;
msg[2] = 10;
connection-test: Store expected result in struct marshal_data
2012-03-23 16:56:19 -04:00
memcpy(&msg[3], data.value.s, msg[2]);
tests: Add demarshal tests
2012-03-05 22:26:17 -05:00
demarshal(&data, "s", msg, (void *) validate_demarshal_s);
protocol: Add explicit nullable types Most of the time it does not make sense to pass a NULL object, string, or array to a protocol request. This commit adds an explicit “allow-null” attribute to mark the request arguments where NULL makes sense. Passing a NULL object, string, or array to a protocol request which is not marked as allow-null is now an error. An implementation will never receive a NULL value for these arguments from a client. Signed-off-by: Christopher James Halse Rogers <christopher.halse.rogers@canonical.com>
2012-07-02 20:03:30 +10:00
data.value.s = "superdude";
msg[0] = 400200;
msg[1] = 24;
msg[2] = 10;
memcpy(&msg[3], data.value.s, msg[2]);
demarshal(&data, "?s", msg, (void *) validate_demarshal_s);
Add support for signed 24.8 decimal numbers 'fixed' is a signed decimal type which offers a sign bit, 23 bits of integer precision, and 8 bits of decimal precision. This is exposed as an opaque struct with conversion helpers to and from double and int on the C API side. Signed-off-by: Daniel Stone <daniel@fooishbar.org>
2012-05-08 17:17:25 +01:00
data.value.i = wl_fixed_from_double(-90000.2390);
msg[0] = 400200;
msg[1] = 12;
msg[2] = data.value.i;
demarshal(&data, "f", msg, (void *) validate_demarshal_f);
protocol: Add explicit nullable types Most of the time it does not make sense to pass a NULL object, string, or array to a protocol request. This commit adds an explicit “allow-null” attribute to mark the request arguments where NULL makes sense. Passing a NULL object, string, or array to a protocol request which is not marked as allow-null is now an error. An implementation will never receive a NULL value for these arguments from a client. Signed-off-by: Christopher James Halse Rogers <christopher.halse.rogers@canonical.com>
2012-07-02 20:03:30 +10:00
data.value.s = NULL;
msg[0] = 400200;
msg[1] = 12;
msg[2] = 0;
demarshal(&data, "?s", msg, (void *) validate_demarshal_s);
tests: Use different connections for read and write tests The connection tests so far only use one connection at a time, but this prepares for tests that use a connection on both sides of the socket.
2012-03-23 11:32:17 -04:00
release_marshal_data(&data);
tests: Add demarshal tests
2012-03-05 22:26:17 -05:00
}
tests: Add marshal+demarshal connection test
2012-03-23 11:41:34 -04:00
static void
marshal_demarshal(struct marshal_data *data,
void (*func)(void), int size, const char *format, ...)
{
tests: Update test cases to new closure allocate convention
2012-06-15 16:09:39 -04:00
struct wl_closure *closure;
tests: Add marshal+demarshal connection test
2012-03-23 11:41:34 -04:00
static const int opcode = 4444;
static struct wl_object sender = { NULL, NULL, 1234 };
struct wl_message message = { "test", format, NULL };
struct wl_map objects;
Change wl_closure_invoke to take an opcode instead of an actual function pointer Signed-off-by: Jason Ekstrand <jason@jlekstrand.net>
2013-03-08 22:26:12 -06:00
struct wl_object object = { NULL, &func, 0 };
tests: Add marshal+demarshal connection test
2012-03-23 11:41:34 -04:00
va_list ap;
uint32_t msg[1] = { 1234 };
va_start(ap, format);
tests: Update test cases to new closure allocate convention
2012-06-15 16:09:39 -04:00
closure = wl_closure_vmarshal(&sender, opcode, ap, &message);
tests: Add marshal+demarshal connection test
2012-03-23 11:41:34 -04:00
va_end(ap);
tests: Update test cases to new closure allocate convention
2012-06-15 16:09:39 -04:00
assert(closure);
assert(wl_closure_send(closure, data->write_connection) == 0);
wl_closure_destroy(closure);
Change filedescriptor API to be thread safe The update callback for the file descriptors was always a bit awkward and un-intuitive. The idea was that whenever the protocol code needed to write data to the fd it would call the 'update' function. This function would adjust the mainloop so that it polls for POLLOUT on the fd so we can eventually flush the data to the socket. The problem is that in multi-threaded applications, any thread can issue a request, which writes data to the output buffer and thus triggers the update callback. Thus, we'll be calling out with the display mutex held and may call from any thread. The solution is to eliminate the udpate callback and just require that the application or server flushes all connection buffers before blocking. This turns out to be a simpler API, although we now require clients to deal with EAGAIN and non-blocking writes. It also saves a few syscalls, since the socket will be writable most of the time and most writes will complete, so we avoid changing epoll to poll for POLLOUT, then write and then change it back for each write.
2012-10-04 16:54:22 -04:00
assert(wl_connection_flush(data->write_connection) == size);
assert(wl_connection_read(data->read_connection) == size);
tests: Add marshal+demarshal connection test
2012-03-23 11:41:34 -04:00
Update tests for wl_map changes and add a map_flags test
2013-06-05 09:52:39 -05:00
wl_map_init(&objects, WL_MAP_SERVER_SIDE);
tests: Add marshal+demarshal connection test
2012-03-23 11:41:34 -04:00
object.id = msg[0];
tests: Update test cases to new closure allocate convention
2012-06-15 16:09:39 -04:00
closure = wl_connection_demarshal(data->read_connection,
size, &objects, &message);
Change wl_closure_invoke to take an opcode instead of an actual function pointer Signed-off-by: Jason Ekstrand <jason@jlekstrand.net>
2013-03-08 22:26:12 -06:00
wl_closure_invoke(closure, WL_CLOSURE_INVOKE_SERVER, &object, 0, data);
tests: Update test cases to new closure allocate convention
2012-06-15 16:09:39 -04:00
wl_closure_destroy(closure);
tests: Add marshal+demarshal connection test
2012-03-23 11:41:34 -04:00
}
TEST(connection_marshal_demarshal)
{
struct marshal_data data;
tests: rename temporary files This is libwayland, not weston, so call the temporary files wayland-tests-*, not weston-tests-*. This is a candidate for the stable branch. Signed-off-by: Pekka Paalanen <ppaalanen@gmail.com>
2012-12-03 16:58:25 +02:00
char f[] = "/tmp/wayland-tests-XXXXXX";
tests: Add marshal+demarshal connection test
2012-03-23 11:41:34 -04:00
setup_marshal_data(&data);
connection-test: Add more test cases
2012-03-23 16:57:34 -04:00
data.value.u = 889911;
marshal_demarshal(&data, (void *) validate_demarshal_u,
12, "u", data.value.u);
data.value.i = -13;
marshal_demarshal(&data, (void *) validate_demarshal_i,
12, "i", data.value.i);
connection-test: Store expected result in struct marshal_data
2012-03-23 16:56:19 -04:00
data.value.s = "cookie robots";
marshal_demarshal(&data, (void *) validate_demarshal_s,
28, "s", data.value.s);
tests: Add marshal+demarshal connection test
2012-03-23 11:41:34 -04:00
protocol: Add explicit nullable types Most of the time it does not make sense to pass a NULL object, string, or array to a protocol request. This commit adds an explicit “allow-null” attribute to mark the request arguments where NULL makes sense. Passing a NULL object, string, or array to a protocol request which is not marked as allow-null is now an error. An implementation will never receive a NULL value for these arguments from a client. Signed-off-by: Christopher James Halse Rogers <christopher.halse.rogers@canonical.com>
2012-07-02 20:03:30 +10:00
data.value.s = "cookie robots";
marshal_demarshal(&data, (void *) validate_demarshal_s,
28, "?s", data.value.s);
connection-test: Test fd transport
2012-03-24 14:27:30 -04:00
data.value.h = mkstemp(f);
assert(data.value.h >= 0);
tests: Don't leave temporary files behind Signed-off-by: Sven Joachim <svenjoac@gmx.de>
2012-12-02 22:42:11 +01:00
unlink(f);
connection-test: Test fd transport
2012-03-24 14:27:30 -04:00
marshal_demarshal(&data, (void *) validate_demarshal_h,
8, "h", data.value.h);
Add support for signed 24.8 decimal numbers 'fixed' is a signed decimal type which offers a sign bit, 23 bits of integer precision, and 8 bits of decimal precision. This is exposed as an opaque struct with conversion helpers to and from double and int on the C API side. Signed-off-by: Daniel Stone <daniel@fooishbar.org>
2012-05-08 17:17:25 +01:00
data.value.i = wl_fixed_from_double(1234.5678);
marshal_demarshal(&data, (void *) validate_demarshal_f,
12, "f", data.value.i);
data.value.i = wl_fixed_from_double(-90000.2390);
marshal_demarshal(&data, (void *) validate_demarshal_f,
12, "f", data.value.i);
data.value.i = wl_fixed_from_double((1 << 23) - 1 + 0.0941);
marshal_demarshal(&data, (void *) validate_demarshal_f,
12, "f", data.value.i);
tests: Add marshal+demarshal connection test
2012-03-23 11:41:34 -04:00
release_marshal_data(&data);
}
connection-test: Add test case to stress connection buffers This catches the bug fixed in cab70c9e5d8c38260a07bb1ddb7618826a120465.
2012-03-24 14:34:05 -04:00
TEST(connection_marshal_alot)
{
struct marshal_data data;
char f[64];
int i;
setup_marshal_data(&data);
/* We iterate enough to make sure we wrap the circular buffers
* for both regular data an fds. */
for (i = 0; i < 2000; i++) {
tests: rename temporary files This is libwayland, not weston, so call the temporary files wayland-tests-*, not weston-tests-*. This is a candidate for the stable branch. Signed-off-by: Pekka Paalanen <ppaalanen@gmail.com>
2012-12-03 16:58:25 +02:00
strcpy(f, "/tmp/wayland-tests-XXXXXX");
connection-test: Add test case to stress connection buffers This catches the bug fixed in cab70c9e5d8c38260a07bb1ddb7618826a120465.
2012-03-24 14:34:05 -04:00
data.value.h = mkstemp(f);
assert(data.value.h >= 0);
tests: Don't leave temporary files behind Signed-off-by: Sven Joachim <svenjoac@gmx.de>
2012-12-02 22:42:11 +01:00
unlink(f);
connection-test: Add test case to stress connection buffers This catches the bug fixed in cab70c9e5d8c38260a07bb1ddb7618826a120465.
2012-03-24 14:34:05 -04:00
marshal_demarshal(&data, (void *) validate_demarshal_h,
8, "h", data.value.h);
}
release_marshal_data(&data);
}
tests: Test invoking closures built with wl_closure_vmarshal()
2012-04-22 14:17:02 -04:00
static void
marshal_helper(const char *format, void *handler, ...)
{
tests: Update test cases to new closure allocate convention
2012-06-15 16:09:39 -04:00
struct wl_closure *closure;
Change wl_closure_invoke to take an opcode instead of an actual function pointer Signed-off-by: Jason Ekstrand <jason@jlekstrand.net>
2013-03-08 22:26:12 -06:00
static struct wl_object sender = { NULL, NULL, 1234 };
struct wl_object object = { NULL, &handler, 0 };
tests: Test invoking closures built with wl_closure_vmarshal()
2012-04-22 14:17:02 -04:00
static const int opcode = 4444;
struct wl_message message = { "test", format, NULL };
va_list ap;
tests: Update test cases to new closure allocate convention
2012-06-15 16:09:39 -04:00
int done;
tests: Test invoking closures built with wl_closure_vmarshal()
2012-04-22 14:17:02 -04:00
va_start(ap, handler);
tests: Update test cases to new closure allocate convention
2012-06-15 16:09:39 -04:00
closure = wl_closure_vmarshal(&sender, opcode, ap, &message);
tests: Test invoking closures built with wl_closure_vmarshal()
2012-04-22 14:17:02 -04:00
va_end(ap);
tests: Update test cases to new closure allocate convention
2012-06-15 16:09:39 -04:00
assert(closure);
tests: Test invoking closures built with wl_closure_vmarshal()
2012-04-22 14:17:02 -04:00
done = 0;
Change wl_closure_invoke to take an opcode instead of an actual function pointer Signed-off-by: Jason Ekstrand <jason@jlekstrand.net>
2013-03-08 22:26:12 -06:00
wl_closure_invoke(closure, WL_CLOSURE_INVOKE_SERVER, &object, 0, &done);
tests: Update test cases to new closure allocate convention
2012-06-15 16:09:39 -04:00
wl_closure_destroy(closure);
tests: Test invoking closures built with wl_closure_vmarshal()
2012-04-22 14:17:02 -04:00
assert(done);
}
static void
suu_handler(void *data, struct wl_object *object,
const char *s, uint32_t u1, uint32_t u2)
{
int *done = data;
assert(strcmp(s, "foo") == 0);
assert(u1 = 500);
assert(u2 = 404040);
*done = 1;
}
TEST(invoke_closure)
{
marshal_helper("suu", suu_handler, "foo", 500, 404040);
}
Reference in a new issue Copy permalink