2012-03-03 12:42:46 +08: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.
|
|
|
|
*/
|
|
|
|
|
2012-05-09 00:17:25 +08:00
|
|
|
#include <math.h>
|
2012-03-03 12:42:46 +08:00
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
2012-03-03 13:29:21 +08:00
|
|
|
#include <stdarg.h>
|
2012-03-03 12:42:46 +08:00
|
|
|
#include <string.h>
|
|
|
|
#include <assert.h>
|
|
|
|
#include <sys/socket.h>
|
|
|
|
#include <unistd.h>
|
|
|
|
#include <errno.h>
|
2012-03-25 02:27:30 +08:00
|
|
|
#include <sys/types.h>
|
|
|
|
#include <sys/stat.h>
|
2012-03-03 12:42:46 +08:00
|
|
|
|
|
|
|
#include "../src/wayland-private.h"
|
|
|
|
#include "test-runner.h"
|
|
|
|
|
|
|
|
static const char message[] = "Hello, world";
|
|
|
|
|
|
|
|
static int
|
|
|
|
update_func(struct wl_connection *connection, uint32_t mask, void *data)
|
|
|
|
{
|
|
|
|
uint32_t *m = data;
|
|
|
|
|
|
|
|
*m = mask;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct wl_connection *
|
|
|
|
setup(int *s, uint32_t *mask)
|
|
|
|
{
|
|
|
|
struct wl_connection *connection;
|
|
|
|
|
|
|
|
assert(socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0, s) == 0);
|
|
|
|
|
|
|
|
connection = wl_connection_create(s[0], update_func, mask);
|
|
|
|
assert(connection);
|
|
|
|
assert(*mask == WL_CONNECTION_READABLE);
|
|
|
|
|
|
|
|
return connection;
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST(connection_create)
|
|
|
|
{
|
|
|
|
struct wl_connection *connection;
|
|
|
|
int s[2];
|
|
|
|
uint32_t mask;
|
|
|
|
|
|
|
|
connection = setup(s, &mask);
|
|
|
|
wl_connection_destroy(connection);
|
|
|
|
close(s[1]);
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST(connection_write)
|
|
|
|
{
|
|
|
|
struct wl_connection *connection;
|
|
|
|
int s[2];
|
|
|
|
uint32_t mask;
|
|
|
|
char buffer[64];
|
|
|
|
|
|
|
|
connection = setup(s, &mask);
|
|
|
|
|
|
|
|
assert(wl_connection_write(connection, message, sizeof message) == 0);
|
|
|
|
assert(mask == (WL_CONNECTION_WRITABLE | WL_CONNECTION_READABLE));
|
|
|
|
assert(wl_connection_data(connection, WL_CONNECTION_WRITABLE) == 0);
|
|
|
|
assert(mask == WL_CONNECTION_READABLE);
|
|
|
|
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];
|
|
|
|
uint32_t mask;
|
|
|
|
char buffer[64];
|
|
|
|
|
|
|
|
connection = setup(s, &mask);
|
|
|
|
|
|
|
|
assert(write(s[1], message, sizeof message) == sizeof message);
|
|
|
|
assert(mask == WL_CONNECTION_READABLE);
|
|
|
|
assert(wl_connection_data(connection, WL_CONNECTION_READABLE) ==
|
|
|
|
sizeof message);
|
|
|
|
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];
|
|
|
|
uint32_t mask;
|
|
|
|
char buffer[64];
|
|
|
|
|
|
|
|
connection = setup(s, &mask);
|
|
|
|
|
|
|
|
/* Test that wl_connection_queue() puts data in the output
|
|
|
|
* buffer without asking for WL_CONNECTION_WRITABLE. 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. */
|
|
|
|
|
|
|
|
assert(wl_connection_queue(connection, message, sizeof message) == 0);
|
|
|
|
assert(mask == WL_CONNECTION_READABLE);
|
|
|
|
assert(wl_connection_write(connection, message, sizeof message) == 0);
|
|
|
|
assert(mask == (WL_CONNECTION_WRITABLE | WL_CONNECTION_READABLE));
|
|
|
|
assert(wl_connection_data(connection, WL_CONNECTION_WRITABLE) == 0);
|
|
|
|
assert(mask == WL_CONNECTION_READABLE);
|
|
|
|
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]);
|
|
|
|
}
|
2012-03-03 13:29:21 +08:00
|
|
|
|
|
|
|
struct marshal_data {
|
2012-03-23 23:32:17 +08:00
|
|
|
struct wl_connection *read_connection;
|
|
|
|
struct wl_connection *write_connection;
|
2012-03-03 13:29:21 +08:00
|
|
|
int s[2];
|
2012-03-23 23:32:17 +08:00
|
|
|
uint32_t read_mask;
|
|
|
|
uint32_t write_mask;
|
2012-03-03 13:29:21 +08:00
|
|
|
uint32_t buffer[10];
|
2012-03-24 04:56:19 +08:00
|
|
|
union {
|
|
|
|
uint32_t u;
|
|
|
|
int32_t i;
|
|
|
|
const char *s;
|
2012-03-25 02:27:30 +08:00
|
|
|
int h;
|
2012-03-24 04:56:19 +08:00
|
|
|
} value;
|
2012-03-03 13:29:21 +08:00
|
|
|
};
|
|
|
|
|
2012-03-23 23:32:17 +08:00
|
|
|
static void
|
|
|
|
setup_marshal_data(struct marshal_data *data)
|
|
|
|
{
|
|
|
|
assert(socketpair(AF_UNIX,
|
|
|
|
SOCK_STREAM | SOCK_CLOEXEC, 0, data->s) == 0);
|
|
|
|
|
|
|
|
data->read_connection =
|
|
|
|
wl_connection_create(data->s[0],
|
|
|
|
update_func, &data->read_mask);
|
|
|
|
assert(data->read_connection);
|
|
|
|
assert(data->read_mask == WL_CONNECTION_READABLE);
|
|
|
|
|
|
|
|
data->write_connection =
|
|
|
|
wl_connection_create(data->s[1],
|
|
|
|
update_func, &data->write_mask);
|
|
|
|
assert(data->write_connection);
|
|
|
|
assert(data->write_mask == WL_CONNECTION_READABLE);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
release_marshal_data(struct marshal_data *data)
|
|
|
|
{
|
|
|
|
wl_connection_destroy(data->read_connection);
|
|
|
|
wl_connection_destroy(data->write_connection);
|
|
|
|
}
|
|
|
|
|
2012-03-03 13:29:21 +08:00
|
|
|
static void
|
2012-03-06 10:40:01 +08:00
|
|
|
marshal(struct marshal_data *data, const char *format, int size, ...)
|
2012-03-03 13:29:21 +08:00
|
|
|
{
|
2012-04-23 01:49:35 +08:00
|
|
|
struct wl_closure closure;
|
2012-04-13 22:11:11 +08:00
|
|
|
static const uint32_t opcode = 4444;
|
2012-03-03 13:29:21 +08:00
|
|
|
static struct wl_object sender = { NULL, NULL, 1234 };
|
2012-03-06 10:40:01 +08:00
|
|
|
struct wl_message message = { "test", format, NULL };
|
2012-03-03 13:29:21 +08:00
|
|
|
va_list ap;
|
2012-04-23 01:49:35 +08:00
|
|
|
int ret;
|
2012-03-03 13:29:21 +08:00
|
|
|
|
|
|
|
va_start(ap, size);
|
2012-04-23 01:49:35 +08:00
|
|
|
ret = wl_closure_vmarshal(&closure, &sender, opcode, ap, &message);
|
2012-03-03 13:29:21 +08:00
|
|
|
va_end(ap);
|
|
|
|
|
2012-04-23 01:49:35 +08:00
|
|
|
assert(ret == 0);
|
|
|
|
assert(wl_closure_send(&closure, data->write_connection) == 0);
|
|
|
|
wl_closure_destroy(&closure);
|
2012-03-23 23:32:17 +08:00
|
|
|
assert(data->write_mask ==
|
2012-03-03 13:29:21 +08:00
|
|
|
(WL_CONNECTION_WRITABLE | WL_CONNECTION_READABLE));
|
2012-03-23 23:32:17 +08:00
|
|
|
assert(wl_connection_data(data->write_connection,
|
2012-03-03 13:29:21 +08:00
|
|
|
WL_CONNECTION_WRITABLE) == 0);
|
2012-03-23 23:32:17 +08:00
|
|
|
assert(data->write_mask == WL_CONNECTION_READABLE);
|
|
|
|
assert(read(data->s[0], data->buffer, sizeof data->buffer) == size);
|
2012-03-03 13:29:21 +08:00
|
|
|
|
|
|
|
assert(data->buffer[0] == sender.id);
|
|
|
|
assert(data->buffer[1] == (opcode | (size << 16)));
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST(connection_marshal)
|
|
|
|
{
|
|
|
|
struct marshal_data data;
|
2012-03-06 10:53:38 +08:00
|
|
|
struct wl_object object;
|
|
|
|
struct wl_array array;
|
|
|
|
static const char text[] = "curry";
|
2012-03-03 13:29:21 +08:00
|
|
|
|
2012-03-23 23:32:17 +08:00
|
|
|
setup_marshal_data(&data);
|
2012-03-03 13:29:21 +08:00
|
|
|
|
2012-03-06 10:40:01 +08:00
|
|
|
marshal(&data, "i", 12, 42);
|
2012-03-03 13:29:21 +08:00
|
|
|
assert(data.buffer[2] == 42);
|
|
|
|
|
2012-03-06 10:40:01 +08:00
|
|
|
marshal(&data, "u", 12, 55);
|
2012-03-03 13:29:21 +08:00
|
|
|
assert(data.buffer[2] == 55);
|
|
|
|
|
2012-03-06 10:40:01 +08:00
|
|
|
marshal(&data, "s", 20, "frappo");
|
2012-03-03 13:29:21 +08:00
|
|
|
assert(data.buffer[2] == 7);
|
|
|
|
assert(strcmp((char *) &data.buffer[3], "frappo") == 0);
|
|
|
|
|
2012-03-06 10:53:38 +08:00
|
|
|
object.id = 557799;
|
|
|
|
marshal(&data, "o", 12, &object);
|
|
|
|
assert(data.buffer[2] == object.id);
|
|
|
|
|
|
|
|
marshal(&data, "o", 12, NULL);
|
|
|
|
assert(data.buffer[2] == 0);
|
|
|
|
|
|
|
|
marshal(&data, "n", 12, &object);
|
|
|
|
assert(data.buffer[2] == object.id);
|
|
|
|
|
|
|
|
marshal(&data, "n", 12, NULL);
|
|
|
|
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);
|
|
|
|
|
2012-03-23 23:32:17 +08:00
|
|
|
release_marshal_data(&data);
|
2012-03-03 13:29:21 +08:00
|
|
|
}
|
2012-03-06 11:26:17 +08:00
|
|
|
|
|
|
|
static void
|
2012-03-24 04:56:19 +08:00
|
|
|
validate_demarshal_u(struct marshal_data *data,
|
|
|
|
struct wl_object *object, uint32_t u)
|
2012-03-06 11:26:17 +08:00
|
|
|
{
|
2012-03-24 04:56:19 +08:00
|
|
|
assert(data->value.u == u);
|
2012-03-06 11:26:17 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2012-03-24 04:56:19 +08:00
|
|
|
validate_demarshal_i(struct marshal_data *data,
|
|
|
|
struct wl_object *object, int32_t i)
|
2012-03-06 11:26:17 +08:00
|
|
|
{
|
2012-03-24 04:56:19 +08:00
|
|
|
assert(data->value.i == i);
|
2012-03-06 11:26:17 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2012-03-24 04:56:19 +08:00
|
|
|
validate_demarshal_s(struct marshal_data *data,
|
|
|
|
struct wl_object *object, const char *s)
|
2012-03-06 11:26:17 +08:00
|
|
|
{
|
2012-03-24 04:56:19 +08:00
|
|
|
assert(strcmp(data->value.s, s) == 0);
|
2012-03-06 11:26:17 +08:00
|
|
|
}
|
|
|
|
|
2012-03-25 02:27:30 +08: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);
|
|
|
|
}
|
|
|
|
|
2012-05-09 00:17:25 +08:00
|
|
|
static void
|
|
|
|
validate_demarshal_f(struct marshal_data *data,
|
|
|
|
struct wl_object *object, wl_fixed_t f)
|
|
|
|
{
|
|
|
|
assert(data->value.i == f);
|
|
|
|
}
|
|
|
|
|
2012-03-06 11:26:17 +08:00
|
|
|
static void
|
|
|
|
demarshal(struct marshal_data *data, const char *format,
|
|
|
|
uint32_t *msg, void (*func)(void))
|
|
|
|
{
|
|
|
|
struct wl_message message = { "test", format, NULL };
|
2012-04-23 01:49:35 +08:00
|
|
|
struct wl_closure closure;
|
2012-03-06 11:26:17 +08:00
|
|
|
struct wl_map objects;
|
|
|
|
struct wl_object object;
|
2012-04-23 01:49:35 +08:00
|
|
|
int size = msg[1], ret;
|
2012-03-06 11:26:17 +08:00
|
|
|
|
|
|
|
assert(write(data->s[1], msg, size) == size);
|
2012-03-23 23:32:17 +08:00
|
|
|
assert(wl_connection_data(data->read_connection,
|
2012-03-06 11:26:17 +08:00
|
|
|
WL_CONNECTION_READABLE) == size);
|
|
|
|
|
|
|
|
wl_map_init(&objects);
|
|
|
|
object.id = msg[0];
|
2012-04-23 01:49:35 +08:00
|
|
|
ret = wl_connection_demarshal(data->read_connection,
|
|
|
|
&closure, size, &objects, &message);
|
|
|
|
assert(ret == 0);
|
|
|
|
wl_closure_invoke(&closure, &object, func, data);
|
2012-03-06 11:26:17 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
TEST(connection_demarshal)
|
|
|
|
{
|
|
|
|
struct marshal_data data;
|
|
|
|
uint32_t msg[10];
|
|
|
|
|
2012-03-23 23:32:17 +08:00
|
|
|
setup_marshal_data(&data);
|
2012-03-06 11:26:17 +08:00
|
|
|
|
2012-03-24 04:56:19 +08:00
|
|
|
data.value.u = 8000;
|
2012-03-06 11:26:17 +08:00
|
|
|
msg[0] = 400200; /* object id */
|
|
|
|
msg[1] = 12; /* size = 12, opcode = 0 */
|
2012-03-24 04:56:19 +08:00
|
|
|
msg[2] = data.value.u;
|
2012-03-06 11:26:17 +08:00
|
|
|
demarshal(&data, "u", msg, (void *) validate_demarshal_u);
|
|
|
|
|
2012-03-24 04:56:19 +08:00
|
|
|
data.value.i = -557799;
|
2012-03-06 11:26:17 +08:00
|
|
|
msg[0] = 400200;
|
|
|
|
msg[1] = 12;
|
2012-03-24 04:56:19 +08:00
|
|
|
msg[2] = data.value.i;
|
2012-03-06 11:26:17 +08:00
|
|
|
demarshal(&data, "i", msg, (void *) validate_demarshal_i);
|
|
|
|
|
2012-03-24 04:56:19 +08:00
|
|
|
data.value.s = "superdude";
|
2012-03-06 11:26:17 +08:00
|
|
|
msg[0] = 400200;
|
|
|
|
msg[1] = 24;
|
|
|
|
msg[2] = 10;
|
2012-03-24 04:56:19 +08:00
|
|
|
memcpy(&msg[3], data.value.s, msg[2]);
|
2012-03-06 11:26:17 +08:00
|
|
|
demarshal(&data, "s", msg, (void *) validate_demarshal_s);
|
|
|
|
|
2012-05-09 00:17:25 +08: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);
|
|
|
|
|
2012-03-23 23:32:17 +08:00
|
|
|
release_marshal_data(&data);
|
2012-03-06 11:26:17 +08:00
|
|
|
}
|
2012-03-23 23:41:34 +08:00
|
|
|
|
|
|
|
static void
|
|
|
|
marshal_demarshal(struct marshal_data *data,
|
|
|
|
void (*func)(void), int size, const char *format, ...)
|
|
|
|
{
|
2012-04-23 01:49:35 +08:00
|
|
|
struct wl_closure closure;
|
2012-03-23 23:41:34 +08: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;
|
|
|
|
struct wl_object object;
|
|
|
|
va_list ap;
|
|
|
|
uint32_t msg[1] = { 1234 };
|
2012-04-23 01:49:35 +08:00
|
|
|
int ret;
|
2012-03-23 23:41:34 +08:00
|
|
|
|
|
|
|
va_start(ap, format);
|
2012-04-23 01:49:35 +08:00
|
|
|
ret = wl_closure_vmarshal(&closure, &sender, opcode, ap, &message);
|
2012-03-23 23:41:34 +08:00
|
|
|
va_end(ap);
|
|
|
|
|
2012-04-23 01:49:35 +08:00
|
|
|
assert(ret == 0);
|
|
|
|
assert(wl_closure_send(&closure, data->write_connection) == 0);
|
|
|
|
wl_closure_destroy(&closure);
|
2012-03-23 23:41:34 +08:00
|
|
|
assert(data->write_mask ==
|
|
|
|
(WL_CONNECTION_WRITABLE | WL_CONNECTION_READABLE));
|
|
|
|
assert(wl_connection_data(data->write_connection,
|
|
|
|
WL_CONNECTION_WRITABLE) == 0);
|
|
|
|
assert(data->write_mask == WL_CONNECTION_READABLE);
|
|
|
|
|
|
|
|
assert(wl_connection_data(data->read_connection,
|
|
|
|
WL_CONNECTION_READABLE) == size);
|
|
|
|
|
|
|
|
wl_map_init(&objects);
|
|
|
|
object.id = msg[0];
|
2012-04-23 01:49:35 +08:00
|
|
|
ret = wl_connection_demarshal(data->read_connection,
|
|
|
|
&closure, size, &objects, &message);
|
|
|
|
wl_closure_invoke(&closure, &object, func, data);
|
|
|
|
wl_closure_destroy(&closure);
|
2012-03-23 23:41:34 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
TEST(connection_marshal_demarshal)
|
|
|
|
{
|
|
|
|
struct marshal_data data;
|
2012-03-25 02:27:30 +08:00
|
|
|
char f[] = "/tmp/weston-tests-XXXXXX";
|
2012-03-23 23:41:34 +08:00
|
|
|
|
|
|
|
setup_marshal_data(&data);
|
|
|
|
|
2012-03-24 04:57:34 +08: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);
|
|
|
|
|
2012-03-24 04:56:19 +08:00
|
|
|
data.value.s = "cookie robots";
|
|
|
|
marshal_demarshal(&data, (void *) validate_demarshal_s,
|
|
|
|
28, "s", data.value.s);
|
2012-03-23 23:41:34 +08:00
|
|
|
|
2012-03-25 02:27:30 +08:00
|
|
|
data.value.h = mkstemp(f);
|
|
|
|
assert(data.value.h >= 0);
|
|
|
|
marshal_demarshal(&data, (void *) validate_demarshal_h,
|
|
|
|
8, "h", data.value.h);
|
|
|
|
|
2012-05-09 00:17:25 +08: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);
|
|
|
|
|
2012-03-23 23:41:34 +08:00
|
|
|
release_marshal_data(&data);
|
|
|
|
}
|
2012-03-25 02:34:05 +08: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++) {
|
|
|
|
strcpy(f, "/tmp/weston-tests-XXXXXX");
|
|
|
|
data.value.h = mkstemp(f);
|
|
|
|
assert(data.value.h >= 0);
|
|
|
|
marshal_demarshal(&data, (void *) validate_demarshal_h,
|
|
|
|
8, "h", data.value.h);
|
|
|
|
}
|
|
|
|
|
|
|
|
release_marshal_data(&data);
|
|
|
|
}
|
2012-04-23 02:17:02 +08:00
|
|
|
|
|
|
|
static void
|
|
|
|
marshal_helper(const char *format, void *handler, ...)
|
|
|
|
{
|
|
|
|
struct wl_closure closure;
|
|
|
|
static struct wl_object sender = { NULL, NULL, 1234 }, object;
|
|
|
|
static const int opcode = 4444;
|
|
|
|
struct wl_message message = { "test", format, NULL };
|
|
|
|
va_list ap;
|
|
|
|
int ret, done;
|
|
|
|
|
|
|
|
va_start(ap, handler);
|
|
|
|
ret = wl_closure_vmarshal(&closure, &sender, opcode, ap, &message);
|
|
|
|
va_end(ap);
|
|
|
|
|
|
|
|
assert(ret == 0);
|
|
|
|
done = 0;
|
|
|
|
wl_closure_invoke(&closure, &object, handler, &done);
|
|
|
|
wl_closure_destroy(&closure);
|
|
|
|
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);
|
|
|
|
}
|