[deb_xorg-server.git] / test / xi2 / protocol-xiquerydevice.c

/**
 * Copyright © 2009 Red Hat, Inc.
 *
 *  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.
 */

#ifdef HAVE_DIX_CONFIG_H
#include <dix-config.h>
#endif

#include <stdint.h>
#include <X11/X.h>
#include <X11/Xproto.h>
#include <X11/extensions/XI2proto.h>
#include <X11/Xatom.h>
#include "inputstr.h"
#include "extinit.h"
#include "exglobals.h"
#include "scrnintstr.h"
#include "xkbsrv.h"

#include "xiquerydevice.h"

#include "protocol-common.h"
/*
 * Protocol testing for XIQueryDevice request and reply.
 *
 * Test approach:
 * Wrap WriteToClient to intercept server's reply. ProcXIQueryDevice returns
 * data in two batches, once for the request, once for the trailing data
 * with the device information.
 * Repeatedly test with varying deviceids and check against data in reply.
 */

struct test_data {
    int which_device;
    int num_devices_in_reply;
};

static void reply_XIQueryDevice_data(ClientPtr client, int len, char *data,
                                     void *closure);
static void reply_XIQueryDevice(ClientPtr client, int len, char *data,
                                void *closure);

/* reply handling for the first bytes that constitute the reply */
static void
reply_XIQueryDevice(ClientPtr client, int len, char *data, void *userdata)
{
    xXIQueryDeviceReply *rep = (xXIQueryDeviceReply *) data;
    struct test_data *querydata = (struct test_data *) userdata;

    if (client->swapped) {
        swapl(&rep->length);
        swaps(&rep->sequenceNumber);
        swaps(&rep->num_devices);
    }

    reply_check_defaults(rep, len, XIQueryDevice);

    if (querydata->which_device == XIAllDevices)
        assert(rep->num_devices == devices.num_devices);
    else if (querydata->which_device == XIAllMasterDevices)
        assert(rep->num_devices == devices.num_master_devices);
    else
        assert(rep->num_devices == 1);

    querydata->num_devices_in_reply = rep->num_devices;
    reply_handler = reply_XIQueryDevice_data;
}

/* reply handling for the trailing bytes that constitute the device info */
static void
reply_XIQueryDevice_data(ClientPtr client, int len, char *data, void *closure)
{
    int i, j;
    struct test_data *querydata = (struct test_data *) closure;

    DeviceIntPtr dev;
    xXIDeviceInfo *info = (xXIDeviceInfo *) data;
    xXIAnyInfo *any;

    for (i = 0; i < querydata->num_devices_in_reply; i++) {
        if (client->swapped) {
            swaps(&info->deviceid);
            swaps(&info->attachment);
            swaps(&info->use);
            swaps(&info->num_classes);
            swaps(&info->name_len);
        }

        if (querydata->which_device > XIAllMasterDevices)
            assert(info->deviceid == querydata->which_device);

        assert(info->deviceid >= 2);    /* 0 and 1 is reserved */

        switch (info->deviceid) {
        case 2:                /* VCP */
            dev = devices.vcp;
            assert(info->use == XIMasterPointer);
            assert(info->attachment == devices.vck->id);
            assert(info->num_classes == 3);     /* 2 axes + button */
            break;
        case 3:                /* VCK */
            dev = devices.vck;
            assert(info->use == XIMasterKeyboard);
            assert(info->attachment == devices.vcp->id);
            assert(info->num_classes == 1);
            break;
        case 4:                /* mouse */
            dev = devices.mouse;
            assert(info->use == XISlavePointer);
            assert(info->attachment == devices.vcp->id);
            assert(info->num_classes == 7);     /* 4 axes + button + 2 scroll */
            break;
        case 5:                /* keyboard */
            dev = devices.kbd;
            assert(info->use == XISlaveKeyboard);
            assert(info->attachment == devices.vck->id);
            assert(info->num_classes == 1);
            break;

        default:
            /* We shouldn't get here */
            assert(0);
            break;
        }
        assert(info->enabled == dev->enabled);
        assert(info->name_len == strlen(dev->name));
        assert(strncmp((char *) &info[1], dev->name, info->name_len) == 0);

        any =
            (xXIAnyInfo *) ((char *) &info[1] + ((info->name_len + 3) / 4) * 4);
        for (j = 0; j < info->num_classes; j++) {
            if (client->swapped) {
                swaps(&any->type);
                swaps(&any->length);
                swaps(&any->sourceid);
            }

            switch (info->deviceid) {
            case 3:            /* VCK and kbd have the same properties */
            case 5:
            {
                int k;
                xXIKeyInfo *ki = (xXIKeyInfo *) any;
                XkbDescPtr xkb = devices.vck->key->xkbInfo->desc;
                uint32_t *kc;

                if (client->swapped)
                    swaps(&ki->num_keycodes);

                assert(any->type == XIKeyClass);
                assert(ki->num_keycodes ==
                       (xkb->max_key_code - xkb->min_key_code + 1));
                assert(any->length == (2 + ki->num_keycodes));

                kc = (uint32_t *) &ki[1];
                for (k = 0; k < ki->num_keycodes; k++, kc++) {
                    if (client->swapped)
                        swapl(kc);

                    assert(*kc >= xkb->min_key_code);
                    assert(*kc <= xkb->max_key_code);
                }
                break;
            }
            case 4:
            {
                assert(any->type == XIButtonClass ||
                       any->type == XIValuatorClass ||
                       any->type == XIScrollClass);

                if (any->type == XIScrollClass) {
                    xXIScrollInfo *si = (xXIScrollInfo *) any;

                    if (client->swapped) {
                        swaps(&si->number);
                        swaps(&si->scroll_type);
                        swapl(&si->increment.integral);
                        swapl(&si->increment.frac);
                    }
                    assert(si->length == 6);
                    assert(si->number == 2 || si->number == 3);
                    if (si->number == 2) {
                        assert(si->scroll_type == XIScrollTypeVertical);
                        assert(!si->flags);
                    }
                    if (si->number == 3) {
                        assert(si->scroll_type == XIScrollTypeHorizontal);
                        assert(si->flags & XIScrollFlagPreferred);
                        assert(!(si->flags & ~XIScrollFlagPreferred));
                    }

                    assert(si->increment.integral == si->number);
                    /* protocol-common.c sets up increments of 2.4 and 3.5 */
                    assert(si->increment.frac > 0.3 * (1ULL << 32));
                    assert(si->increment.frac < 0.6 * (1ULL << 32));
                }

            }
                /* fall through */
            case 2:            /* VCP and mouse have the same properties except for scroll */
            {
                if (info->deviceid == 2)        /* VCP */
                    assert(any->type == XIButtonClass ||
                           any->type == XIValuatorClass);

                if (any->type == XIButtonClass) {
                    int l;
                    xXIButtonInfo *bi = (xXIButtonInfo *) any;

                    if (client->swapped)
                        swaps(&bi->num_buttons);

                    assert(bi->num_buttons == devices.vcp->button->numButtons);

                    l = 2 + bi->num_buttons +
                        bytes_to_int32(bits_to_bytes(bi->num_buttons));
                    assert(bi->length == l);
                }
                else if (any->type == XIValuatorClass) {
                    xXIValuatorInfo *vi = (xXIValuatorInfo *) any;

                    if (client->swapped) {
                        swaps(&vi->number);
                        swapl(&vi->label);
                        swapl(&vi->min.integral);
                        swapl(&vi->min.frac);
                        swapl(&vi->max.integral);
                        swapl(&vi->max.frac);
                        swapl(&vi->resolution);
                    }

                    assert(vi->length == 11);
                    assert(vi->number >= 0 && vi->number < 4);
                    if (info->deviceid == 2)    /* VCP */
                        assert(vi->number < 2);

                    assert(vi->mode == XIModeRelative);
                    /* device was set up as relative, so standard
                     * values here. */
                    assert(vi->min.integral == -1);
                    assert(vi->min.frac == 0);
                    assert(vi->max.integral == -1);
                    assert(vi->max.frac == 0);
                    assert(vi->resolution == 0);
                }
            }
                break;
            }
            any = (xXIAnyInfo *) (((char *) any) + any->length * 4);
        }

        info = (xXIDeviceInfo *) any;
    }
}

static void
request_XIQueryDevice(struct test_data *querydata, int deviceid, int error)
{
    int rc;
    ClientRec client;
    xXIQueryDeviceReq request;

    request_init(&request, XIQueryDevice);
    client = init_client(request.length, &request);
    reply_handler = reply_XIQueryDevice;

    querydata->which_device = deviceid;

    request.deviceid = deviceid;
    rc = ProcXIQueryDevice(&client);
    assert(rc == error);

    if (rc != Success)
        assert(client.errorValue == deviceid);

    reply_handler = reply_XIQueryDevice;

    client.swapped = TRUE;
    swaps(&request.length);
    swaps(&request.deviceid);
    rc = SProcXIQueryDevice(&client);
    assert(rc == error);

    if (rc != Success)
        assert(client.errorValue == deviceid);
}

static void
test_XIQueryDevice(void)
{
    int i;
    xXIQueryDeviceReq request;
    struct test_data data;

    reply_handler = reply_XIQueryDevice;
    userdata = &data;
    request_init(&request, XIQueryDevice);

    printf("Testing XIAllDevices.\n");
    request_XIQueryDevice(&data, XIAllDevices, Success);
    printf("Testing XIAllMasterDevices.\n");
    request_XIQueryDevice(&data, XIAllMasterDevices, Success);

    printf("Testing existing device ids.\n");
    for (i = 2; i < 6; i++)
        request_XIQueryDevice(&data, i, Success);

    printf("Testing non-existing device ids.\n");
    for (i = 6; i <= 0xFFFF; i++)
        request_XIQueryDevice(&data, i, BadDevice);

    reply_handler = NULL;

}

int
main(int argc, char **argv)
{
    init_simple();

    test_XIQueryDevice();

    return 0;
}
Commit	Line	Data
a09e091a JB	1	/**
	2	* Copyright © 2009 Red Hat, Inc.
	3	*
	4	* Permission is hereby granted, free of charge, to any person obtaining a
	5	* copy of this software and associated documentation files (the "Software"),
	6	* to deal in the Software without restriction, including without limitation
	7	* the rights to use, copy, modify, merge, publish, distribute, sublicense,
	8	* and/or sell copies of the Software, and to permit persons to whom the
	9	* Software is furnished to do so, subject to the following conditions:
	10	*
	11	* The above copyright notice and this permission notice (including the next
	12	* paragraph) shall be included in all copies or substantial portions of the
	13	* Software.
	14	*
	15	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	16	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	17	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
	18	* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	19	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
	20	* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
	21	* DEALINGS IN THE SOFTWARE.
	22	*/
	23
	24	#ifdef HAVE_DIX_CONFIG_H
	25	#include <dix-config.h>
	26	#endif
	27
	28	#include <stdint.h>
	29	#include <X11/X.h>
	30	#include <X11/Xproto.h>
	31	#include <X11/extensions/XI2proto.h>
	32	#include <X11/Xatom.h>
	33	#include "inputstr.h"
	34	#include "extinit.h"
	35	#include "exglobals.h"
	36	#include "scrnintstr.h"
	37	#include "xkbsrv.h"
	38
	39	#include "xiquerydevice.h"
	40
	41	#include "protocol-common.h"
	42	/*
	43	* Protocol testing for XIQueryDevice request and reply.
	44	*
	45	* Test approach:
	46	* Wrap WriteToClient to intercept server's reply. ProcXIQueryDevice returns
	47	* data in two batches, once for the request, once for the trailing data
	48	* with the device information.
	49	* Repeatedly test with varying deviceids and check against data in reply.
	50	*/
	51
	52	struct test_data {
	53	int which_device;
	54	int num_devices_in_reply;
	55	};
	56
	57	static void reply_XIQueryDevice_data(ClientPtr client, int len, char *data,
	58	void *closure);
	59	static void reply_XIQueryDevice(ClientPtr client, int len, char *data,
	60	void *closure);
	61
	62	/* reply handling for the first bytes that constitute the reply */
	63	static void
	64	reply_XIQueryDevice(ClientPtr client, int len, char data, void userdata)
65	{
66	xXIQueryDeviceReply rep = (xXIQueryDeviceReply ) data;
67	struct test_data querydata = (struct test_data ) userdata;
68
69	if (client->swapped) {
70	swapl(&rep->length);
71	swaps(&rep->sequenceNumber);
72	swaps(&rep->num_devices);
73	}
74
75	reply_check_defaults(rep, len, XIQueryDevice);
76
77	if (querydata->which_device == XIAllDevices)
78	assert(rep->num_devices == devices.num_devices);
79	else if (querydata->which_device == XIAllMasterDevices)
80	assert(rep->num_devices == devices.num_master_devices);
81	else
82	assert(rep->num_devices == 1);
83
84	querydata->num_devices_in_reply = rep->num_devices;
85	reply_handler = reply_XIQueryDevice_data;
86	}
87
88	/* reply handling for the trailing bytes that constitute the device info */
89	static void
90	reply_XIQueryDevice_data(ClientPtr client, int len, char data, void closure)
91	{
92	int i, j;
93	struct test_data querydata = (struct test_data ) closure;
94
95	DeviceIntPtr dev;
96	xXIDeviceInfo info = (xXIDeviceInfo ) data;
97	xXIAnyInfo *any;
98
99	for (i = 0; i < querydata->num_devices_in_reply; i++) {
100	if (client->swapped) {
101	swaps(&info->deviceid);
102	swaps(&info->attachment);
103	swaps(&info->use);
104	swaps(&info->num_classes);
105	swaps(&info->name_len);
106	}
107
108	if (querydata->which_device > XIAllMasterDevices)
109	assert(info->deviceid == querydata->which_device);
110
111	assert(info->deviceid >= 2); /* 0 and 1 is reserved */
112
113	switch (info->deviceid) {
114	case 2: /* VCP */
115	dev = devices.vcp;
116	assert(info->use == XIMasterPointer);
117	assert(info->attachment == devices.vck->id);
118	assert(info->num_classes == 3); /* 2 axes + button */
119	break;
120	case 3: /* VCK */
121	dev = devices.vck;
122	assert(info->use == XIMasterKeyboard);
123	assert(info->attachment == devices.vcp->id);
124	assert(info->num_classes == 1);
125	break;
126	case 4: /* mouse */
127	dev = devices.mouse;
128	assert(info->use == XISlavePointer);
129	assert(info->attachment == devices.vcp->id);
130	assert(info->num_classes == 7); /* 4 axes + button + 2 scroll */
131	break;
132	case 5: /* keyboard */
133	dev = devices.kbd;
134	assert(info->use == XISlaveKeyboard);
135	assert(info->attachment == devices.vck->id);
136	assert(info->num_classes == 1);
137	break;
138
139	default:
140	/* We shouldn't get here */
141	assert(0);
142	break;
143	}
144	assert(info->enabled == dev->enabled);
145	assert(info->name_len == strlen(dev->name));
146	assert(strncmp((char *) &info[1], dev->name, info->name_len) == 0);
147
148	any =
149	(xXIAnyInfo ) ((char ) &info[1] + ((info->name_len + 3) / 4) * 4);
150	for (j = 0; j < info->num_classes; j++) {
151	if (client->swapped) {
152	swaps(&any->type);
153	swaps(&any->length);
154	swaps(&any->sourceid);
155	}
156
157	switch (info->deviceid) {
158	case 3: /* VCK and kbd have the same properties */
159	case 5:
160	{
161	int k;
162	xXIKeyInfo ki = (xXIKeyInfo ) any;
163	XkbDescPtr xkb = devices.vck->key->xkbInfo->desc;
164	uint32_t *kc;
165
166	if (client->swapped)
167	swaps(&ki->num_keycodes);
168
169	assert(any->type == XIKeyClass);
170	assert(ki->num_keycodes ==
171	(xkb->max_key_code - xkb->min_key_code + 1));
172	assert(any->length == (2 + ki->num_keycodes));
173
174	kc = (uint32_t *) &ki[1];
175	for (k = 0; k < ki->num_keycodes; k++, kc++) {
176	if (client->swapped)
177	swapl(kc);
178
179	assert(*kc >= xkb->min_key_code);
180	assert(*kc <= xkb->max_key_code);
181	}
182	break;
183	}
184	case 4:
185	{
186	assert(any->type == XIButtonClass \|\|
187	any->type == XIValuatorClass \|\|
188	any->type == XIScrollClass);
189
190	if (any->type == XIScrollClass) {
191	xXIScrollInfo si = (xXIScrollInfo ) any;
192
193	if (client->swapped) {
194	swaps(&si->number);
195	swaps(&si->scroll_type);
196	swapl(&si->increment.integral);
197	swapl(&si->increment.frac);
198	}
199	assert(si->length == 6);
200	assert(si->number == 2 \|\| si->number == 3);
201	if (si->number == 2) {
202	assert(si->scroll_type == XIScrollTypeVertical);
203	assert(!si->flags);
204	}
205	if (si->number == 3) {
206	assert(si->scroll_type == XIScrollTypeHorizontal);
207	assert(si->flags & XIScrollFlagPreferred);
208	assert(!(si->flags & ~XIScrollFlagPreferred));
209	}
210
211	assert(si->increment.integral == si->number);
212	/* protocol-common.c sets up increments of 2.4 and 3.5 */
213	assert(si->increment.frac > 0.3 * (1ULL << 32));
214	assert(si->increment.frac < 0.6 * (1ULL << 32));
215	}
216
217	}
218	/* fall through */
219	case 2: /* VCP and mouse have the same properties except for scroll */
220	{
221	if (info->deviceid == 2) /* VCP */
222	assert(any->type == XIButtonClass \|\|
223	any->type == XIValuatorClass);
224
225	if (any->type == XIButtonClass) {
226	int l;
227	xXIButtonInfo bi = (xXIButtonInfo ) any;
228
229	if (client->swapped)
230	swaps(&bi->num_buttons);
231
232	assert(bi->num_buttons == devices.vcp->button->numButtons);
233
234	l = 2 + bi->num_buttons +
235	bytes_to_int32(bits_to_bytes(bi->num_buttons));
236	assert(bi->length == l);
237	}
238	else if (any->type == XIValuatorClass) {
239	xXIValuatorInfo vi = (xXIValuatorInfo ) any;
240
241	if (client->swapped) {
242	swaps(&vi->number);
243	swapl(&vi->label);
244	swapl(&vi->min.integral);
245	swapl(&vi->min.frac);
246	swapl(&vi->max.integral);
247	swapl(&vi->max.frac);
248	swapl(&vi->resolution);
249	}
250
251	assert(vi->length == 11);
252	assert(vi->number >= 0 && vi->number < 4);
253	if (info->deviceid == 2) /* VCP */
254	assert(vi->number < 2);
255
256	assert(vi->mode == XIModeRelative);
257	/* device was set up as relative, so standard
258	* values here. */
259	assert(vi->min.integral == -1);
260	assert(vi->min.frac == 0);
261	assert(vi->max.integral == -1);
262	assert(vi->max.frac == 0);
263	assert(vi->resolution == 0);
264	}
265	}
266	break;
267	}
268	any = (xXIAnyInfo ) (((char ) any) + any->length * 4);
269	}
270
271	info = (xXIDeviceInfo *) any;
272	}
273	}
274
275	static void
276	request_XIQueryDevice(struct test_data *querydata, int deviceid, int error)
277	{
278	int rc;
279	ClientRec client;
280	xXIQueryDeviceReq request;
281
282	request_init(&request, XIQueryDevice);
283	client = init_client(request.length, &request);
284	reply_handler = reply_XIQueryDevice;
285
286	querydata->which_device = deviceid;
287
288	request.deviceid = deviceid;
289	rc = ProcXIQueryDevice(&client);
290	assert(rc == error);
291
292	if (rc != Success)
293	assert(client.errorValue == deviceid);
294
295	reply_handler = reply_XIQueryDevice;
296
297	client.swapped = TRUE;
298	swaps(&request.length);
299	swaps(&request.deviceid);
300	rc = SProcXIQueryDevice(&client);
301	assert(rc == error);
302
303	if (rc != Success)
304	assert(client.errorValue == deviceid);
305	}
306
307	static void
308	test_XIQueryDevice(void)
309	{
310	int i;
311	xXIQueryDeviceReq request;
312	struct test_data data;
313
314	reply_handler = reply_XIQueryDevice;
315	userdata = &data;
316	request_init(&request, XIQueryDevice);
317
318	printf("Testing XIAllDevices.\n");
319	request_XIQueryDevice(&data, XIAllDevices, Success);
320	printf("Testing XIAllMasterDevices.\n");
321	request_XIQueryDevice(&data, XIAllMasterDevices, Success);
322
323	printf("Testing existing device ids.\n");
324	for (i = 2; i < 6; i++)
325	request_XIQueryDevice(&data, i, Success);
326
327	printf("Testing non-existing device ids.\n");
328	for (i = 6; i <= 0xFFFF; i++)
329	request_XIQueryDevice(&data, i, BadDevice);
330
331	reply_handler = NULL;
332
333	}
334
335	int
336	main(int argc, char **argv)
337	{
338	init_simple();
339
340	test_XIQueryDevice();
341
342	return 0;
343	}