Bug Summary

File:test/input.c
Location:line 270, column 5
Description:The left expression of the compound assignment is an uninitialized value. The computed value will also be garbage

Annotated Source Code

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_H1
25#include <dix-config.h>
26#endif
27
28#include <stdint.h>
29#include <X11/X.h>
30#include "misc.h"
31#include "resource.h"
32#include <X11/Xproto.h>
33#include <X11/extensions/XI2proto.h>
34#include <X11/Xatom.h>
35#include "windowstr.h"
36#include "inputstr.h"
37#include "eventconvert.h"
38#include "exevents.h"
39#include "exglobals.h"
40#include "dixgrabs.h"
41#include "eventstr.h"
42#include "inpututils.h"
43#include "mi.h"
44#include "assert.h"
45
46/**
47 * Init a device with axes.
48 * Verify values set on the device.
49 *
50 * Result: All axes set to default values (usually 0).
51 */
52static void
53dix_init_valuators(void)
54{
55 DeviceIntRec dev;
56 ValuatorClassPtr val;
57 AxisInfoPtr axis;
58 const int num_axes = 2;
59 int i;
60 Atom atoms[MAX_VALUATORS36] = { 0 };
61
62 memset(&dev, 0, sizeof(DeviceIntRec))__builtin___memset_chk (&dev, 0, sizeof(DeviceIntRec), __builtin_object_size
(&dev, 0))
;
63 dev.type = MASTER_POINTER1; /* claim it's a master to stop ptracccel */
64
65 assert(InitValuatorClassDeviceStruct(NULL, 0, atoms, 0, 0) == FALSE)(__builtin_expect(!(InitValuatorClassDeviceStruct(((void*)0),
0, atoms, 0, 0) == 0), 0) ? __assert_rtn(__func__, "input.c"
, 65, "InitValuatorClassDeviceStruct(NULL, 0, atoms, 0, 0) == FALSE"
) : (void)0)
;
66 assert(InitValuatorClassDeviceStruct(&dev, num_axes, atoms, 0, Absolute))(__builtin_expect(!(InitValuatorClassDeviceStruct(&dev, num_axes
, atoms, 0, 1)), 0) ? __assert_rtn(__func__, "input.c", 66, "InitValuatorClassDeviceStruct(&dev, num_axes, atoms, 0, Absolute)"
) : (void)0)
;
67
68 val = dev.valuator;
69 assert(val)(__builtin_expect(!(val), 0) ? __assert_rtn(__func__, "input.c"
, 69, "val") : (void)0)
;
70 assert(val->numAxes == num_axes)(__builtin_expect(!(val->numAxes == num_axes), 0) ? __assert_rtn
(__func__, "input.c", 70, "val->numAxes == num_axes") : (void
)0)
;
71 assert(val->numMotionEvents == 0)(__builtin_expect(!(val->numMotionEvents == 0), 0) ? __assert_rtn
(__func__, "input.c", 71, "val->numMotionEvents == 0") : (
void)0)
;
72 assert(val->axisVal)(__builtin_expect(!(val->axisVal), 0) ? __assert_rtn(__func__
, "input.c", 72, "val->axisVal") : (void)0)
;
73
74 for (i = 0; i < num_axes; i++) {
75 assert(val->axisVal[i] == 0)(__builtin_expect(!(val->axisVal[i] == 0), 0) ? __assert_rtn
(__func__, "input.c", 75, "val->axisVal[i] == 0") : (void)
0)
;
76 assert(val->axes->min_value == NO_AXIS_LIMITS)(__builtin_expect(!(val->axes->min_value == -1), 0) ? __assert_rtn
(__func__, "input.c", 76, "val->axes->min_value == NO_AXIS_LIMITS"
) : (void)0)
;
77 assert(val->axes->max_value == NO_AXIS_LIMITS)(__builtin_expect(!(val->axes->max_value == -1), 0) ? __assert_rtn
(__func__, "input.c", 77, "val->axes->max_value == NO_AXIS_LIMITS"
) : (void)0)
;
78 assert(val->axes->mode == Absolute)(__builtin_expect(!(val->axes->mode == 1), 0) ? __assert_rtn
(__func__, "input.c", 78, "val->axes->mode == Absolute"
) : (void)0)
;
79 }
80
81 assert(dev.last.numValuators == num_axes)(__builtin_expect(!(dev.last.numValuators == num_axes), 0) ? __assert_rtn
(__func__, "input.c", 81, "dev.last.numValuators == num_axes"
) : (void)0)
;
82
83 /* invalid increment */
84 assert(SetScrollValuator(__builtin_expect(!(SetScrollValuator (&dev, 0, SCROLL_TYPE_VERTICAL
, 0.0, SCROLL_FLAG_NONE) == 0), 0) ? __assert_rtn(__func__, "input.c"
, 85, "SetScrollValuator (&dev, 0, SCROLL_TYPE_VERTICAL, 0.0, SCROLL_FLAG_NONE) == FALSE"
) : (void)0)
85 (&dev, 0, SCROLL_TYPE_VERTICAL, 0.0, SCROLL_FLAG_NONE) == FALSE)(__builtin_expect(!(SetScrollValuator (&dev, 0, SCROLL_TYPE_VERTICAL
, 0.0, SCROLL_FLAG_NONE) == 0), 0) ? __assert_rtn(__func__, "input.c"
, 85, "SetScrollValuator (&dev, 0, SCROLL_TYPE_VERTICAL, 0.0, SCROLL_FLAG_NONE) == FALSE"
) : (void)0)
;
86 /* invalid type */
87 assert(SetScrollValuator(__builtin_expect(!(SetScrollValuator (&dev, 0, SCROLL_TYPE_VERTICAL
- 1, 1.0, SCROLL_FLAG_NONE) == 0), 0) ? __assert_rtn(__func__
, "input.c", 88, "SetScrollValuator (&dev, 0, SCROLL_TYPE_VERTICAL - 1, 1.0, SCROLL_FLAG_NONE) == FALSE"
) : (void)0)
88 (&dev, 0, SCROLL_TYPE_VERTICAL - 1, 1.0, SCROLL_FLAG_NONE) == FALSE)(__builtin_expect(!(SetScrollValuator (&dev, 0, SCROLL_TYPE_VERTICAL
- 1, 1.0, SCROLL_FLAG_NONE) == 0), 0) ? __assert_rtn(__func__
, "input.c", 88, "SetScrollValuator (&dev, 0, SCROLL_TYPE_VERTICAL - 1, 1.0, SCROLL_FLAG_NONE) == FALSE"
) : (void)0)
;
89 assert(SetScrollValuator(__builtin_expect(!(SetScrollValuator (&dev, 0, SCROLL_TYPE_HORIZONTAL
+ 1, 1.0, SCROLL_FLAG_NONE) == 0), 0) ? __assert_rtn(__func__
, "input.c", 91, "SetScrollValuator (&dev, 0, SCROLL_TYPE_HORIZONTAL + 1, 1.0, SCROLL_FLAG_NONE) == FALSE"
) : (void)0)
90 (&dev, 0, SCROLL_TYPE_HORIZONTAL + 1, 1.0,(__builtin_expect(!(SetScrollValuator (&dev, 0, SCROLL_TYPE_HORIZONTAL
+ 1, 1.0, SCROLL_FLAG_NONE) == 0), 0) ? __assert_rtn(__func__
, "input.c", 91, "SetScrollValuator (&dev, 0, SCROLL_TYPE_HORIZONTAL + 1, 1.0, SCROLL_FLAG_NONE) == FALSE"
) : (void)0)
91 SCROLL_FLAG_NONE) == FALSE)(__builtin_expect(!(SetScrollValuator (&dev, 0, SCROLL_TYPE_HORIZONTAL
+ 1, 1.0, SCROLL_FLAG_NONE) == 0), 0) ? __assert_rtn(__func__
, "input.c", 91, "SetScrollValuator (&dev, 0, SCROLL_TYPE_HORIZONTAL + 1, 1.0, SCROLL_FLAG_NONE) == FALSE"
) : (void)0)
;
92 /* invalid axisnum */
93 assert(SetScrollValuator(__builtin_expect(!(SetScrollValuator (&dev, 2, SCROLL_TYPE_HORIZONTAL
, 1.0, SCROLL_FLAG_NONE) == 0), 0) ? __assert_rtn(__func__, "input.c"
, 94, "SetScrollValuator (&dev, 2, SCROLL_TYPE_HORIZONTAL, 1.0, SCROLL_FLAG_NONE) == FALSE"
) : (void)0)
94 (&dev, 2, SCROLL_TYPE_HORIZONTAL, 1.0, SCROLL_FLAG_NONE) == FALSE)(__builtin_expect(!(SetScrollValuator (&dev, 2, SCROLL_TYPE_HORIZONTAL
, 1.0, SCROLL_FLAG_NONE) == 0), 0) ? __assert_rtn(__func__, "input.c"
, 94, "SetScrollValuator (&dev, 2, SCROLL_TYPE_HORIZONTAL, 1.0, SCROLL_FLAG_NONE) == FALSE"
) : (void)0)
;
95
96 /* valid */
97 assert(SetScrollValuator(__builtin_expect(!(SetScrollValuator (&dev, 0, SCROLL_TYPE_VERTICAL
, 3.0, SCROLL_FLAG_NONE) == 1), 0) ? __assert_rtn(__func__, "input.c"
, 98, "SetScrollValuator (&dev, 0, SCROLL_TYPE_VERTICAL, 3.0, SCROLL_FLAG_NONE) == TRUE"
) : (void)0)
98 (&dev, 0, SCROLL_TYPE_VERTICAL, 3.0, SCROLL_FLAG_NONE) == TRUE)(__builtin_expect(!(SetScrollValuator (&dev, 0, SCROLL_TYPE_VERTICAL
, 3.0, SCROLL_FLAG_NONE) == 1), 0) ? __assert_rtn(__func__, "input.c"
, 98, "SetScrollValuator (&dev, 0, SCROLL_TYPE_VERTICAL, 3.0, SCROLL_FLAG_NONE) == TRUE"
) : (void)0)
;
99 axis = &dev.valuator->axes[0];
100 assert(axis->scroll.increment == 3.0)(__builtin_expect(!(axis->scroll.increment == 3.0), 0) ? __assert_rtn
(__func__, "input.c", 100, "axis->scroll.increment == 3.0"
) : (void)0)
;
101 assert(axis->scroll.type == SCROLL_TYPE_VERTICAL)(__builtin_expect(!(axis->scroll.type == SCROLL_TYPE_VERTICAL
), 0) ? __assert_rtn(__func__, "input.c", 101, "axis->scroll.type == SCROLL_TYPE_VERTICAL"
) : (void)0)
;
102 assert(axis->scroll.flags == 0)(__builtin_expect(!(axis->scroll.flags == 0), 0) ? __assert_rtn
(__func__, "input.c", 102, "axis->scroll.flags == 0") : (void
)0)
;
103
104 /* valid */
105 assert(SetScrollValuator(__builtin_expect(!(SetScrollValuator (&dev, 1, SCROLL_TYPE_HORIZONTAL
, 2.0, SCROLL_FLAG_NONE) == 1), 0) ? __assert_rtn(__func__, "input.c"
, 106, "SetScrollValuator (&dev, 1, SCROLL_TYPE_HORIZONTAL, 2.0, SCROLL_FLAG_NONE) == TRUE"
) : (void)0)
106 (&dev, 1, SCROLL_TYPE_HORIZONTAL, 2.0, SCROLL_FLAG_NONE) == TRUE)(__builtin_expect(!(SetScrollValuator (&dev, 1, SCROLL_TYPE_HORIZONTAL
, 2.0, SCROLL_FLAG_NONE) == 1), 0) ? __assert_rtn(__func__, "input.c"
, 106, "SetScrollValuator (&dev, 1, SCROLL_TYPE_HORIZONTAL, 2.0, SCROLL_FLAG_NONE) == TRUE"
) : (void)0)
;
107 axis = &dev.valuator->axes[1];
108 assert(axis->scroll.increment == 2.0)(__builtin_expect(!(axis->scroll.increment == 2.0), 0) ? __assert_rtn
(__func__, "input.c", 108, "axis->scroll.increment == 2.0"
) : (void)0)
;
109 assert(axis->scroll.type == SCROLL_TYPE_HORIZONTAL)(__builtin_expect(!(axis->scroll.type == SCROLL_TYPE_HORIZONTAL
), 0) ? __assert_rtn(__func__, "input.c", 109, "axis->scroll.type == SCROLL_TYPE_HORIZONTAL"
) : (void)0)
;
110 assert(axis->scroll.flags == 0)(__builtin_expect(!(axis->scroll.flags == 0), 0) ? __assert_rtn
(__func__, "input.c", 110, "axis->scroll.flags == 0") : (void
)0)
;
111
112 /* can add another non-preffered axis */
113 assert(SetScrollValuator(__builtin_expect(!(SetScrollValuator (&dev, 1, SCROLL_TYPE_VERTICAL
, 5.0, SCROLL_FLAG_NONE) == 1), 0) ? __assert_rtn(__func__, "input.c"
, 114, "SetScrollValuator (&dev, 1, SCROLL_TYPE_VERTICAL, 5.0, SCROLL_FLAG_NONE) == TRUE"
) : (void)0)
114 (&dev, 1, SCROLL_TYPE_VERTICAL, 5.0, SCROLL_FLAG_NONE) == TRUE)(__builtin_expect(!(SetScrollValuator (&dev, 1, SCROLL_TYPE_VERTICAL
, 5.0, SCROLL_FLAG_NONE) == 1), 0) ? __assert_rtn(__func__, "input.c"
, 114, "SetScrollValuator (&dev, 1, SCROLL_TYPE_VERTICAL, 5.0, SCROLL_FLAG_NONE) == TRUE"
) : (void)0)
;
115 assert(SetScrollValuator(__builtin_expect(!(SetScrollValuator (&dev, 0, SCROLL_TYPE_HORIZONTAL
, 5.0, SCROLL_FLAG_NONE) == 1), 0) ? __assert_rtn(__func__, "input.c"
, 116, "SetScrollValuator (&dev, 0, SCROLL_TYPE_HORIZONTAL, 5.0, SCROLL_FLAG_NONE) == TRUE"
) : (void)0)
116 (&dev, 0, SCROLL_TYPE_HORIZONTAL, 5.0, SCROLL_FLAG_NONE) == TRUE)(__builtin_expect(!(SetScrollValuator (&dev, 0, SCROLL_TYPE_HORIZONTAL
, 5.0, SCROLL_FLAG_NONE) == 1), 0) ? __assert_rtn(__func__, "input.c"
, 116, "SetScrollValuator (&dev, 0, SCROLL_TYPE_HORIZONTAL, 5.0, SCROLL_FLAG_NONE) == TRUE"
) : (void)0)
;
117
118 /* can overwrite with Preferred */
119 assert(SetScrollValuator(__builtin_expect(!(SetScrollValuator (&dev, 1, SCROLL_TYPE_VERTICAL
, 5.5, SCROLL_FLAG_PREFERRED) == 1), 0) ? __assert_rtn(__func__
, "input.c", 120, "SetScrollValuator (&dev, 1, SCROLL_TYPE_VERTICAL, 5.5, SCROLL_FLAG_PREFERRED) == TRUE"
) : (void)0)
120 (&dev, 1, SCROLL_TYPE_VERTICAL, 5.5, SCROLL_FLAG_PREFERRED) == TRUE)(__builtin_expect(!(SetScrollValuator (&dev, 1, SCROLL_TYPE_VERTICAL
, 5.5, SCROLL_FLAG_PREFERRED) == 1), 0) ? __assert_rtn(__func__
, "input.c", 120, "SetScrollValuator (&dev, 1, SCROLL_TYPE_VERTICAL, 5.5, SCROLL_FLAG_PREFERRED) == TRUE"
) : (void)0)
;
121 axis = &dev.valuator->axes[1];
122 assert(axis->scroll.increment == 5.5)(__builtin_expect(!(axis->scroll.increment == 5.5), 0) ? __assert_rtn
(__func__, "input.c", 122, "axis->scroll.increment == 5.5"
) : (void)0)
;
123 assert(axis->scroll.type == SCROLL_TYPE_VERTICAL)(__builtin_expect(!(axis->scroll.type == SCROLL_TYPE_VERTICAL
), 0) ? __assert_rtn(__func__, "input.c", 123, "axis->scroll.type == SCROLL_TYPE_VERTICAL"
) : (void)0)
;
124 assert(axis->scroll.flags == SCROLL_FLAG_PREFERRED)(__builtin_expect(!(axis->scroll.flags == SCROLL_FLAG_PREFERRED
), 0) ? __assert_rtn(__func__, "input.c", 124, "axis->scroll.flags == SCROLL_FLAG_PREFERRED"
) : (void)0)
;
125
126 assert(SetScrollValuator(__builtin_expect(!(SetScrollValuator (&dev, 0, SCROLL_TYPE_HORIZONTAL
, 8.8, SCROLL_FLAG_PREFERRED) == 1), 0) ? __assert_rtn(__func__
, "input.c", 128, "SetScrollValuator (&dev, 0, SCROLL_TYPE_HORIZONTAL, 8.8, SCROLL_FLAG_PREFERRED) == TRUE"
) : (void)0)
127 (&dev, 0, SCROLL_TYPE_HORIZONTAL, 8.8,(__builtin_expect(!(SetScrollValuator (&dev, 0, SCROLL_TYPE_HORIZONTAL
, 8.8, SCROLL_FLAG_PREFERRED) == 1), 0) ? __assert_rtn(__func__
, "input.c", 128, "SetScrollValuator (&dev, 0, SCROLL_TYPE_HORIZONTAL, 8.8, SCROLL_FLAG_PREFERRED) == TRUE"
) : (void)0)
128 SCROLL_FLAG_PREFERRED) == TRUE)(__builtin_expect(!(SetScrollValuator (&dev, 0, SCROLL_TYPE_HORIZONTAL
, 8.8, SCROLL_FLAG_PREFERRED) == 1), 0) ? __assert_rtn(__func__
, "input.c", 128, "SetScrollValuator (&dev, 0, SCROLL_TYPE_HORIZONTAL, 8.8, SCROLL_FLAG_PREFERRED) == TRUE"
) : (void)0)
;
129 axis = &dev.valuator->axes[0];
130 assert(axis->scroll.increment == 8.8)(__builtin_expect(!(axis->scroll.increment == 8.8), 0) ? __assert_rtn
(__func__, "input.c", 130, "axis->scroll.increment == 8.8"
) : (void)0)
;
131 assert(axis->scroll.type == SCROLL_TYPE_HORIZONTAL)(__builtin_expect(!(axis->scroll.type == SCROLL_TYPE_HORIZONTAL
), 0) ? __assert_rtn(__func__, "input.c", 131, "axis->scroll.type == SCROLL_TYPE_HORIZONTAL"
) : (void)0)
;
132 assert(axis->scroll.flags == SCROLL_FLAG_PREFERRED)(__builtin_expect(!(axis->scroll.flags == SCROLL_FLAG_PREFERRED
), 0) ? __assert_rtn(__func__, "input.c", 132, "axis->scroll.flags == SCROLL_FLAG_PREFERRED"
) : (void)0)
;
133
134 /* can overwrite as none */
135 assert(SetScrollValuator(&dev, 0, SCROLL_TYPE_NONE, 5.0,(__builtin_expect(!(SetScrollValuator(&dev, 0, SCROLL_TYPE_NONE
, 5.0, SCROLL_FLAG_NONE) == 1), 0) ? __assert_rtn(__func__, "input.c"
, 136, "SetScrollValuator(&dev, 0, SCROLL_TYPE_NONE, 5.0, SCROLL_FLAG_NONE) == TRUE"
) : (void)0)
136 SCROLL_FLAG_NONE) == TRUE)(__builtin_expect(!(SetScrollValuator(&dev, 0, SCROLL_TYPE_NONE
, 5.0, SCROLL_FLAG_NONE) == 1), 0) ? __assert_rtn(__func__, "input.c"
, 136, "SetScrollValuator(&dev, 0, SCROLL_TYPE_NONE, 5.0, SCROLL_FLAG_NONE) == TRUE"
) : (void)0)
;
137 axis = &dev.valuator->axes[0];
138 assert(axis->scroll.type == SCROLL_TYPE_NONE)(__builtin_expect(!(axis->scroll.type == SCROLL_TYPE_NONE)
, 0) ? __assert_rtn(__func__, "input.c", 138, "axis->scroll.type == SCROLL_TYPE_NONE"
) : (void)0)
;
139
140 /* can overwrite axis with new settings */
141 assert(SetScrollValuator(__builtin_expect(!(SetScrollValuator (&dev, 0, SCROLL_TYPE_VERTICAL
, 5.0, SCROLL_FLAG_NONE) == 1), 0) ? __assert_rtn(__func__, "input.c"
, 142, "SetScrollValuator (&dev, 0, SCROLL_TYPE_VERTICAL, 5.0, SCROLL_FLAG_NONE) == TRUE"
) : (void)0)
142 (&dev, 0, SCROLL_TYPE_VERTICAL, 5.0, SCROLL_FLAG_NONE) == TRUE)(__builtin_expect(!(SetScrollValuator (&dev, 0, SCROLL_TYPE_VERTICAL
, 5.0, SCROLL_FLAG_NONE) == 1), 0) ? __assert_rtn(__func__, "input.c"
, 142, "SetScrollValuator (&dev, 0, SCROLL_TYPE_VERTICAL, 5.0, SCROLL_FLAG_NONE) == TRUE"
) : (void)0)
;
143 axis = &dev.valuator->axes[0];
144 assert(axis->scroll.type == SCROLL_TYPE_VERTICAL)(__builtin_expect(!(axis->scroll.type == SCROLL_TYPE_VERTICAL
), 0) ? __assert_rtn(__func__, "input.c", 144, "axis->scroll.type == SCROLL_TYPE_VERTICAL"
) : (void)0)
;
145 assert(axis->scroll.increment == 5.0)(__builtin_expect(!(axis->scroll.increment == 5.0), 0) ? __assert_rtn
(__func__, "input.c", 145, "axis->scroll.increment == 5.0"
) : (void)0)
;
146 assert(axis->scroll.flags == SCROLL_FLAG_NONE)(__builtin_expect(!(axis->scroll.flags == SCROLL_FLAG_NONE
), 0) ? __assert_rtn(__func__, "input.c", 146, "axis->scroll.flags == SCROLL_FLAG_NONE"
) : (void)0)
;
147 assert(SetScrollValuator(__builtin_expect(!(SetScrollValuator (&dev, 0, SCROLL_TYPE_VERTICAL
, 3.0, SCROLL_FLAG_NONE) == 1), 0) ? __assert_rtn(__func__, "input.c"
, 148, "SetScrollValuator (&dev, 0, SCROLL_TYPE_VERTICAL, 3.0, SCROLL_FLAG_NONE) == TRUE"
) : (void)0)
148 (&dev, 0, SCROLL_TYPE_VERTICAL, 3.0, SCROLL_FLAG_NONE) == TRUE)(__builtin_expect(!(SetScrollValuator (&dev, 0, SCROLL_TYPE_VERTICAL
, 3.0, SCROLL_FLAG_NONE) == 1), 0) ? __assert_rtn(__func__, "input.c"
, 148, "SetScrollValuator (&dev, 0, SCROLL_TYPE_VERTICAL, 3.0, SCROLL_FLAG_NONE) == TRUE"
) : (void)0)
;
149 assert(axis->scroll.type == SCROLL_TYPE_VERTICAL)(__builtin_expect(!(axis->scroll.type == SCROLL_TYPE_VERTICAL
), 0) ? __assert_rtn(__func__, "input.c", 149, "axis->scroll.type == SCROLL_TYPE_VERTICAL"
) : (void)0)
;
150 assert(axis->scroll.increment == 3.0)(__builtin_expect(!(axis->scroll.increment == 3.0), 0) ? __assert_rtn
(__func__, "input.c", 150, "axis->scroll.increment == 3.0"
) : (void)0)
;
151 assert(axis->scroll.flags == SCROLL_FLAG_NONE)(__builtin_expect(!(axis->scroll.flags == SCROLL_FLAG_NONE
), 0) ? __assert_rtn(__func__, "input.c", 151, "axis->scroll.flags == SCROLL_FLAG_NONE"
) : (void)0)
;
152}
153
154/* just check the known success cases, and that error cases set the client's
155 * error value correctly. */
156static void
157dix_check_grab_values(void)
158{
159 ClientRec client;
160 GrabParameters param;
161 int rc;
162
163 memset(&client, 0, sizeof(client))__builtin___memset_chk (&client, 0, sizeof(client), __builtin_object_size
(&client, 0))
;
164
165 param.grabtype = CORE;
166 param.this_device_mode = GrabModeSync0;
167 param.other_devices_mode = GrabModeSync0;
168 param.modifiers = AnyModifier(1<<15);
169 param.ownerEvents = FALSE0;
170
171 rc = CheckGrabValues(&client, &param);
172 assert(rc == Success)(__builtin_expect(!(rc == 0), 0) ? __assert_rtn(__func__, "input.c"
, 172, "rc == Success") : (void)0)
;
173
174 param.this_device_mode = GrabModeAsync1;
175 rc = CheckGrabValues(&client, &param);
176 assert(rc == Success)(__builtin_expect(!(rc == 0), 0) ? __assert_rtn(__func__, "input.c"
, 176, "rc == Success") : (void)0)
;
177
178 param.this_device_mode = XIGrabModeTouch2;
179 rc = CheckGrabValues(&client, &param);
180 assert(rc == Success)(__builtin_expect(!(rc == 0), 0) ? __assert_rtn(__func__, "input.c"
, 180, "rc == Success") : (void)0)
;
181
182 param.this_device_mode = XIGrabModeTouch2 + 1;
183 rc = CheckGrabValues(&client, &param);
184 assert(rc == BadValue)(__builtin_expect(!(rc == 2), 0) ? __assert_rtn(__func__, "input.c"
, 184, "rc == BadValue") : (void)0)
;
185 assert(client.errorValue == param.this_device_mode)(__builtin_expect(!(client.errorValue == param.this_device_mode
), 0) ? __assert_rtn(__func__, "input.c", 185, "client.errorValue == param.this_device_mode"
) : (void)0)
;
186 assert(client.errorValue == XIGrabModeTouch + 1)(__builtin_expect(!(client.errorValue == 2 + 1), 0) ? __assert_rtn
(__func__, "input.c", 186, "client.errorValue == XIGrabModeTouch + 1"
) : (void)0)
;
187
188 param.this_device_mode = GrabModeSync0;
189 param.other_devices_mode = GrabModeAsync1;
190 rc = CheckGrabValues(&client, &param);
191
192 param.this_device_mode = GrabModeSync0;
193 param.other_devices_mode = XIGrabModeTouch2;
194 rc = CheckGrabValues(&client, &param);
195 assert(rc == Success)(__builtin_expect(!(rc == 0), 0) ? __assert_rtn(__func__, "input.c"
, 195, "rc == Success") : (void)0)
;
196 assert(rc == Success)(__builtin_expect(!(rc == 0), 0) ? __assert_rtn(__func__, "input.c"
, 196, "rc == Success") : (void)0)
;
197
198 param.other_devices_mode = XIGrabModeTouch2 + 1;
199 rc = CheckGrabValues(&client, &param);
200 assert(rc == BadValue)(__builtin_expect(!(rc == 2), 0) ? __assert_rtn(__func__, "input.c"
, 200, "rc == BadValue") : (void)0)
;
201 assert(client.errorValue == param.other_devices_mode)(__builtin_expect(!(client.errorValue == param.other_devices_mode
), 0) ? __assert_rtn(__func__, "input.c", 201, "client.errorValue == param.other_devices_mode"
) : (void)0)
;
202 assert(client.errorValue == XIGrabModeTouch + 1)(__builtin_expect(!(client.errorValue == 2 + 1), 0) ? __assert_rtn
(__func__, "input.c", 202, "client.errorValue == XIGrabModeTouch + 1"
) : (void)0)
;
203
204 param.other_devices_mode = GrabModeSync0;
205
206 param.modifiers = 1 << 13;
207 rc = CheckGrabValues(&client, &param);
208 assert(rc == BadValue)(__builtin_expect(!(rc == 2), 0) ? __assert_rtn(__func__, "input.c"
, 208, "rc == BadValue") : (void)0)
;
209 assert(client.errorValue == param.modifiers)(__builtin_expect(!(client.errorValue == param.modifiers), 0)
? __assert_rtn(__func__, "input.c", 209, "client.errorValue == param.modifiers"
) : (void)0)
;
210 assert(client.errorValue == (1 << 13))(__builtin_expect(!(client.errorValue == (1 << 13)), 0)
? __assert_rtn(__func__, "input.c", 210, "client.errorValue == (1 << 13)"
) : (void)0)
;
211
212 param.modifiers = AnyModifier(1<<15);
213 param.ownerEvents = TRUE1;
214 rc = CheckGrabValues(&client, &param);
215 assert(rc == Success)(__builtin_expect(!(rc == 0), 0) ? __assert_rtn(__func__, "input.c"
, 215, "rc == Success") : (void)0)
;
216
217 param.ownerEvents = 3;
218 rc = CheckGrabValues(&client, &param);
219 assert(rc == BadValue)(__builtin_expect(!(rc == 2), 0) ? __assert_rtn(__func__, "input.c"
, 219, "rc == BadValue") : (void)0)
;
220 assert(client.errorValue == param.ownerEvents)(__builtin_expect(!(client.errorValue == param.ownerEvents), 0
) ? __assert_rtn(__func__, "input.c", 220, "client.errorValue == param.ownerEvents"
) : (void)0)
;
221 assert(client.errorValue == 3)(__builtin_expect(!(client.errorValue == 3), 0) ? __assert_rtn
(__func__, "input.c", 221, "client.errorValue == 3") : (void)
0)
;
222}
223
224/**
225 * Convert various internal events to the matching core event and verify the
226 * parameters.
227 */
228static void
229dix_event_to_core(int type)
230{
231 DeviceEvent ev;
232 xEvent *core;
233 int time;
234 int x, y;
235 int rc;
236 int state;
237 int detail;
238 int count;
239 const int ROOT_WINDOW_ID = 0x100;
240
241 /* EventToCore memsets the event to 0 */
242#define test_event() \
243 assert(rc == Success)(__builtin_expect(!(rc == 0), 0) ? __assert_rtn(__func__, "input.c"
, 243, "rc == Success") : (void)0)
; \
244 assert(core)(__builtin_expect(!(core), 0) ? __assert_rtn(__func__, "input.c"
, 244, "core") : (void)0)
; \
245 assert(count == 1)(__builtin_expect(!(count == 1), 0) ? __assert_rtn(__func__, "input.c"
, 245, "count == 1") : (void)0)
; \
246 assert(core->u.u.type == type)(__builtin_expect(!(core->u.u.type == type), 0) ? __assert_rtn
(__func__, "input.c", 246, "core->u.u.type == type") : (void
)0)
; \
247 assert(core->u.u.detail == detail)(__builtin_expect(!(core->u.u.detail == detail), 0) ? __assert_rtn
(__func__, "input.c", 247, "core->u.u.detail == detail") :
(void)0)
; \
248 assert(core->u.keyButtonPointer.time == time)(__builtin_expect(!(core->u.keyButtonPointer.time == time)
, 0) ? __assert_rtn(__func__, "input.c", 248, "core->u.keyButtonPointer.time == time"
) : (void)0)
; \
249 assert(core->u.keyButtonPointer.rootX == x)(__builtin_expect(!(core->u.keyButtonPointer.rootX == x), 0
) ? __assert_rtn(__func__, "input.c", 249, "core->u.keyButtonPointer.rootX == x"
) : (void)0)
; \
250 assert(core->u.keyButtonPointer.rootY == y)(__builtin_expect(!(core->u.keyButtonPointer.rootY == y), 0
) ? __assert_rtn(__func__, "input.c", 250, "core->u.keyButtonPointer.rootY == y"
) : (void)0)
; \
251 assert(core->u.keyButtonPointer.state == state)(__builtin_expect(!(core->u.keyButtonPointer.state == state
), 0) ? __assert_rtn(__func__, "input.c", 251, "core->u.keyButtonPointer.state == state"
) : (void)0)
; \
252 assert(core->u.keyButtonPointer.eventX == 0)(__builtin_expect(!(core->u.keyButtonPointer.eventX == 0),
0) ? __assert_rtn(__func__, "input.c", 252, "core->u.keyButtonPointer.eventX == 0"
) : (void)0)
; \
253 assert(core->u.keyButtonPointer.eventY == 0)(__builtin_expect(!(core->u.keyButtonPointer.eventY == 0),
0) ? __assert_rtn(__func__, "input.c", 253, "core->u.keyButtonPointer.eventY == 0"
) : (void)0)
; \
254 assert(core->u.keyButtonPointer.root == ROOT_WINDOW_ID)(__builtin_expect(!(core->u.keyButtonPointer.root == ROOT_WINDOW_ID
), 0) ? __assert_rtn(__func__, "input.c", 254, "core->u.keyButtonPointer.root == ROOT_WINDOW_ID"
) : (void)0)
; \
255 assert(core->u.keyButtonPointer.event == 0)(__builtin_expect(!(core->u.keyButtonPointer.event == 0), 0
) ? __assert_rtn(__func__, "input.c", 255, "core->u.keyButtonPointer.event == 0"
) : (void)0)
; \
256 assert(core->u.keyButtonPointer.child == 0)(__builtin_expect(!(core->u.keyButtonPointer.child == 0), 0
) ? __assert_rtn(__func__, "input.c", 256, "core->u.keyButtonPointer.child == 0"
) : (void)0)
; \
257 assert(core->u.keyButtonPointer.sameScreen == FALSE)(__builtin_expect(!(core->u.keyButtonPointer.sameScreen ==
0), 0) ? __assert_rtn(__func__, "input.c", 257, "core->u.keyButtonPointer.sameScreen == FALSE"
) : (void)0)
;
258
259 x = 0;
260 y = 0;
261 time = 12345;
262 state = 0;
263 detail = 0;
264
265 ev.header = 0xFF;
266 ev.length = sizeof(DeviceEvent);
267 ev.time = time;
268 ev.root_y = x;
269 ev.root_x = y;
270 SetBit(ev.valuators.mask, 0)(((BYTE *) (ev.valuators.mask))[(0)>>3] |= (1 << (
(0) & 7)))
;
Within the expansion of the macro 'SetBit':
a
The left expression of the compound assignment is an uninitialized value. The computed value will also be garbage
271 SetBit(ev.valuators.mask, 1)(((BYTE *) (ev.valuators.mask))[(1)>>3] |= (1 << (
(1) & 7)))
;
272 ev.root = ROOT_WINDOW_ID;
273 ev.corestate = state;
274 ev.detail.key = detail;
275
276 ev.type = type;
277 ev.detail.key = 0;
278 rc = EventToCore((InternalEvent *) &ev, &core, &count);
279 test_event();
280
281 x = 1;
282 y = 2;
283 ev.root_x = x;
284 ev.root_y = y;
285 rc = EventToCore((InternalEvent *) &ev, &core, &count);
286 test_event();
287
288 x = 0x7FFF;
289 y = 0x7FFF;
290 ev.root_x = x;
291 ev.root_y = y;
292 rc = EventToCore((InternalEvent *) &ev, &core, &count);
293 test_event();
294
295 x = 0x8000; /* too high */
296 y = 0x8000; /* too high */
297 ev.root_x = x;
298 ev.root_y = y;
299 rc = EventToCore((InternalEvent *) &ev, &core, &count);
300 assert(rc == Success)(__builtin_expect(!(rc == 0), 0) ? __assert_rtn(__func__, "input.c"
, 300, "rc == Success") : (void)0)
;
301 assert(core)(__builtin_expect(!(core), 0) ? __assert_rtn(__func__, "input.c"
, 301, "core") : (void)0)
;
302 assert(count == 1)(__builtin_expect(!(count == 1), 0) ? __assert_rtn(__func__, "input.c"
, 302, "count == 1") : (void)0)
;
303 assert(core->u.keyButtonPointer.rootX != x)(__builtin_expect(!(core->u.keyButtonPointer.rootX != x), 0
) ? __assert_rtn(__func__, "input.c", 303, "core->u.keyButtonPointer.rootX != x"
) : (void)0)
;
304 assert(core->u.keyButtonPointer.rootY != y)(__builtin_expect(!(core->u.keyButtonPointer.rootY != y), 0
) ? __assert_rtn(__func__, "input.c", 304, "core->u.keyButtonPointer.rootY != y"
) : (void)0)
;
305
306 x = 0x7FFF;
307 y = 0x7FFF;
308 ev.root_x = x;
309 ev.root_y = y;
310 time = 0;
311 ev.time = time;
312 rc = EventToCore((InternalEvent *) &ev, &core, &count);
313 test_event();
314
315 detail = 1;
316 ev.detail.key = detail;
317 rc = EventToCore((InternalEvent *) &ev, &core, &count);
318 test_event();
319
320 detail = 0xFF; /* highest value */
321 ev.detail.key = detail;
322 rc = EventToCore((InternalEvent *) &ev, &core, &count);
323 test_event();
324
325 detail = 0xFFF; /* too big */
326 ev.detail.key = detail;
327 rc = EventToCore((InternalEvent *) &ev, &core, &count);
328 assert(rc == BadMatch)(__builtin_expect(!(rc == 8), 0) ? __assert_rtn(__func__, "input.c"
, 328, "rc == BadMatch") : (void)0)
;
329
330 detail = 0xFF; /* too big */
331 ev.detail.key = detail;
332 state = 0xFFFF; /* highest value */
333 ev.corestate = state;
334 rc = EventToCore((InternalEvent *) &ev, &core, &count);
335 test_event();
336
337 state = 0x10000; /* too big */
338 ev.corestate = state;
339 rc = EventToCore((InternalEvent *) &ev, &core, &count);
340 assert(rc == Success)(__builtin_expect(!(rc == 0), 0) ? __assert_rtn(__func__, "input.c"
, 340, "rc == Success") : (void)0)
;
341 assert(core)(__builtin_expect(!(core), 0) ? __assert_rtn(__func__, "input.c"
, 341, "core") : (void)0)
;
342 assert(count == 1)(__builtin_expect(!(count == 1), 0) ? __assert_rtn(__func__, "input.c"
, 342, "count == 1") : (void)0)
;
343 assert(core->u.keyButtonPointer.state != state)(__builtin_expect(!(core->u.keyButtonPointer.state != state
), 0) ? __assert_rtn(__func__, "input.c", 343, "core->u.keyButtonPointer.state != state"
) : (void)0)
;
344 assert(core->u.keyButtonPointer.state == (state & 0xFFFF))(__builtin_expect(!(core->u.keyButtonPointer.state == (state
& 0xFFFF)), 0) ? __assert_rtn(__func__, "input.c", 344, "core->u.keyButtonPointer.state == (state & 0xFFFF)"
) : (void)0)
;
345
346#undef test_event
347}
348
349static void
350dix_event_to_core_fail(int evtype, int expected_rc)
351{
352 DeviceEvent ev;
353 xEvent *core;
354 int rc;
355 int count;
356
357 ev.header = 0xFF;
358 ev.length = sizeof(DeviceEvent);
359
360 ev.type = evtype;
361 rc = EventToCore((InternalEvent *) &ev, &core, &count);
362 assert(rc == expected_rc)(__builtin_expect(!(rc == expected_rc), 0) ? __assert_rtn(__func__
, "input.c", 362, "rc == expected_rc") : (void)0)
;
363}
364
365static void
366dix_event_to_core_conversion(void)
367{
368 dix_event_to_core_fail(0, BadImplementation17);
369 dix_event_to_core_fail(1, BadImplementation17);
370 dix_event_to_core_fail(ET_ProximityOut + 1, BadImplementation17);
371 dix_event_to_core_fail(ET_ProximityIn, BadMatch8);
372 dix_event_to_core_fail(ET_ProximityOut, BadMatch8);
373
374 dix_event_to_core(ET_KeyPress);
375 dix_event_to_core(ET_KeyRelease);
376 dix_event_to_core(ET_ButtonPress);
377 dix_event_to_core(ET_ButtonRelease);
378 dix_event_to_core(ET_Motion);
379}
380
381static void
382_dix_test_xi_convert(DeviceEvent *ev, int expected_rc, int expected_count)
383{
384 xEvent *xi;
385 int count = 0;
386 int rc;
387
388 rc = EventToXI((InternalEvent *) ev, &xi, &count);
389 assert(rc == expected_rc)(__builtin_expect(!(rc == expected_rc), 0) ? __assert_rtn(__func__
, "input.c", 389, "rc == expected_rc") : (void)0)
;
390 assert(count >= expected_count)(__builtin_expect(!(count >= expected_count), 0) ? __assert_rtn
(__func__, "input.c", 390, "count >= expected_count") : (void
)0)
;
391 if (count > 0) {
392 deviceKeyButtonPointer *kbp = (deviceKeyButtonPointer *) xi;
393
394 assert(kbp->type == IEventBase + ev->type)(__builtin_expect(!(kbp->type == IEventBase + ev->type)
, 0) ? __assert_rtn(__func__, "input.c", 394, "kbp->type == IEventBase + ev->type"
) : (void)0)
;
395 assert(kbp->detail == ev->detail.key)(__builtin_expect(!(kbp->detail == ev->detail.key), 0) ?
__assert_rtn(__func__, "input.c", 395, "kbp->detail == ev->detail.key"
) : (void)0)
;
396 assert(kbp->time == ev->time)(__builtin_expect(!(kbp->time == ev->time), 0) ? __assert_rtn
(__func__, "input.c", 396, "kbp->time == ev->time") : (
void)0)
;
397 assert((kbp->deviceid & ~MORE_EVENTS) == ev->deviceid)(__builtin_expect(!((kbp->deviceid & ~0x80) == ev->
deviceid), 0) ? __assert_rtn(__func__, "input.c", 397, "(kbp->deviceid & ~MORE_EVENTS) == ev->deviceid"
) : (void)0)
;
398 assert(kbp->root_x == ev->root_x)(__builtin_expect(!(kbp->root_x == ev->root_x), 0) ? __assert_rtn
(__func__, "input.c", 398, "kbp->root_x == ev->root_x")
: (void)0)
;
399 assert(kbp->root_y == ev->root_y)(__builtin_expect(!(kbp->root_y == ev->root_y), 0) ? __assert_rtn
(__func__, "input.c", 399, "kbp->root_y == ev->root_y")
: (void)0)
;
400 assert(kbp->state == ev->corestate)(__builtin_expect(!(kbp->state == ev->corestate), 0) ? __assert_rtn
(__func__, "input.c", 400, "kbp->state == ev->corestate"
) : (void)0)
;
401 assert(kbp->event_x == 0)(__builtin_expect(!(kbp->event_x == 0), 0) ? __assert_rtn(
__func__, "input.c", 401, "kbp->event_x == 0") : (void)0)
;
402 assert(kbp->event_y == 0)(__builtin_expect(!(kbp->event_y == 0), 0) ? __assert_rtn(
__func__, "input.c", 402, "kbp->event_y == 0") : (void)0)
;
403 assert(kbp->root == ev->root)(__builtin_expect(!(kbp->root == ev->root), 0) ? __assert_rtn
(__func__, "input.c", 403, "kbp->root == ev->root") : (
void)0)
;
404 assert(kbp->event == 0)(__builtin_expect(!(kbp->event == 0), 0) ? __assert_rtn(__func__
, "input.c", 404, "kbp->event == 0") : (void)0)
;
405 assert(kbp->child == 0)(__builtin_expect(!(kbp->child == 0), 0) ? __assert_rtn(__func__
, "input.c", 405, "kbp->child == 0") : (void)0)
;
406 assert(kbp->same_screen == FALSE)(__builtin_expect(!(kbp->same_screen == 0), 0) ? __assert_rtn
(__func__, "input.c", 406, "kbp->same_screen == FALSE") : (
void)0)
;
407
408 while (--count > 0) {
409 deviceValuator *v = (deviceValuator *) &xi[count];
410
411 assert(v->type == DeviceValuator)(__builtin_expect(!(v->type == DeviceValuator), 0) ? __assert_rtn
(__func__, "input.c", 411, "v->type == DeviceValuator") : (
void)0)
;
412 assert(v->num_valuators <= 6)(__builtin_expect(!(v->num_valuators <= 6), 0) ? __assert_rtn
(__func__, "input.c", 412, "v->num_valuators <= 6") : (
void)0)
;
413 }
414
415 free(xi);
416 }
417}
418
419/**
420 * This tests for internal event → XI1 event conversion
421 * - all conversions should generate the right XI event type
422 * - right number of events generated
423 * - extra events are valuators
424 */
425static void
426dix_event_to_xi1_conversion(void)
427{
428 DeviceEvent ev = { 0 };
429 int time;
430 int x, y;
431 int state;
432 int detail;
433 const int ROOT_WINDOW_ID = 0x100;
434 int deviceid;
435
436 IEventBase = 80;
437 DeviceValuator = IEventBase - 1;
438 DeviceKeyPress = IEventBase + ET_KeyPress;
439 DeviceKeyRelease = IEventBase + ET_KeyRelease;
440 DeviceButtonPress = IEventBase + ET_ButtonPress;
441 DeviceButtonRelease = IEventBase + ET_ButtonRelease;
442 DeviceMotionNotify = IEventBase + ET_Motion;
443 DeviceFocusIn = IEventBase + ET_FocusIn;
444 DeviceFocusOut = IEventBase + ET_FocusOut;
445 ProximityIn = IEventBase + ET_ProximityIn;
446 ProximityOut = IEventBase + ET_ProximityOut;
447
448 /* EventToXI callocs */
449 x = 0;
450 y = 0;
451 time = 12345;
452 state = 0;
453 detail = 0;
454 deviceid = 4;
455
456 ev.header = 0xFF;
457
458 ev.header = 0xFF;
459 ev.length = sizeof(DeviceEvent);
460 ev.time = time;
461 ev.root_y = x;
462 ev.root_x = y;
463 SetBit(ev.valuators.mask, 0)(((BYTE *) (ev.valuators.mask))[(0)>>3] |= (1 << (
(0) & 7)))
;
464 SetBit(ev.valuators.mask, 1)(((BYTE *) (ev.valuators.mask))[(1)>>3] |= (1 << (
(1) & 7)))
;
465 ev.root = ROOT_WINDOW_ID;
466 ev.corestate = state;
467 ev.detail.key = detail;
468 ev.deviceid = deviceid;
469
470 /* test all types for bad match */
471 ev.type = ET_KeyPress;
472 _dix_test_xi_convert(&ev, Success0, 1);
473 ev.type = ET_KeyRelease;
474 _dix_test_xi_convert(&ev, Success0, 1);
475 ev.type = ET_ButtonPress;
476 _dix_test_xi_convert(&ev, Success0, 1);
477 ev.type = ET_ButtonRelease;
478 _dix_test_xi_convert(&ev, Success0, 1);
479 ev.type = ET_Motion;
480 _dix_test_xi_convert(&ev, Success0, 1);
481 ev.type = ET_ProximityIn;
482 _dix_test_xi_convert(&ev, Success0, 1);
483 ev.type = ET_ProximityOut;
484 _dix_test_xi_convert(&ev, Success0, 1);
485
486 /* No axes */
487 ClearBit(ev.valuators.mask, 0)(((BYTE *)(ev.valuators.mask))[(0)>>3] &= ~(1 <<
((0) & 7)))
;
488 ClearBit(ev.valuators.mask, 1)(((BYTE *)(ev.valuators.mask))[(1)>>3] &= ~(1 <<
((1) & 7)))
;
489 ev.type = ET_KeyPress;
490 _dix_test_xi_convert(&ev, Success0, 1);
491 ev.type = ET_KeyRelease;
492 _dix_test_xi_convert(&ev, Success0, 1);
493 ev.type = ET_ButtonPress;
494 _dix_test_xi_convert(&ev, Success0, 1);
495 ev.type = ET_ButtonRelease;
496 _dix_test_xi_convert(&ev, Success0, 1);
497 ev.type = ET_Motion;
498 _dix_test_xi_convert(&ev, BadMatch8, 0);
499 ev.type = ET_ProximityIn;
500 _dix_test_xi_convert(&ev, BadMatch8, 0);
501 ev.type = ET_ProximityOut;
502 _dix_test_xi_convert(&ev, BadMatch8, 0);
503
504 /* more than 6 axes → 2 valuator events */
505 SetBit(ev.valuators.mask, 0)(((BYTE *) (ev.valuators.mask))[(0)>>3] |= (1 << (
(0) & 7)))
;
506 SetBit(ev.valuators.mask, 1)(((BYTE *) (ev.valuators.mask))[(1)>>3] |= (1 << (
(1) & 7)))
;
507 SetBit(ev.valuators.mask, 2)(((BYTE *) (ev.valuators.mask))[(2)>>3] |= (1 << (
(2) & 7)))
;
508 SetBit(ev.valuators.mask, 3)(((BYTE *) (ev.valuators.mask))[(3)>>3] |= (1 << (
(3) & 7)))
;
509 SetBit(ev.valuators.mask, 4)(((BYTE *) (ev.valuators.mask))[(4)>>3] |= (1 << (
(4) & 7)))
;
510 SetBit(ev.valuators.mask, 5)(((BYTE *) (ev.valuators.mask))[(5)>>3] |= (1 << (
(5) & 7)))
;
511 SetBit(ev.valuators.mask, 6)(((BYTE *) (ev.valuators.mask))[(6)>>3] |= (1 << (
(6) & 7)))
;
512 ev.type = ET_KeyPress;
513 _dix_test_xi_convert(&ev, Success0, 2);
514 ev.type = ET_KeyRelease;
515 _dix_test_xi_convert(&ev, Success0, 2);
516 ev.type = ET_ButtonPress;
517 _dix_test_xi_convert(&ev, Success0, 2);
518 ev.type = ET_ButtonRelease;
519 _dix_test_xi_convert(&ev, Success0, 2);
520 ev.type = ET_Motion;
521 _dix_test_xi_convert(&ev, Success0, 2);
522 ev.type = ET_ProximityIn;
523 _dix_test_xi_convert(&ev, Success0, 2);
524 ev.type = ET_ProximityOut;
525 _dix_test_xi_convert(&ev, Success0, 2);
526
527 /* keycode too high */
528 ev.type = ET_KeyPress;
529 ev.detail.key = 256;
530 _dix_test_xi_convert(&ev, Success0, 0);
531
532 /* deviceid too high */
533 ev.type = ET_KeyPress;
534 ev.detail.key = 18;
535 ev.deviceid = 128;
536 _dix_test_xi_convert(&ev, Success0, 0);
537}
538
539static void
540xi2_struct_sizes(void)
541{
542#define compare(req) \
543 assert(sizeof(req) == sz_##req)(__builtin_expect(!(sizeof(req) == sz_##req), 0) ? __assert_rtn
(__func__, "input.c", 543, "sizeof(req) == sz_##req") : (void
)0)
;
544
545 compare(xXIQueryVersionReq);
546 compare(xXIWarpPointerReq);
547 compare(xXIChangeCursorReq);
548 compare(xXIChangeHierarchyReq);
549 compare(xXISetClientPointerReq);
550 compare(xXIGetClientPointerReq);
551 compare(xXISelectEventsReq);
552 compare(xXIQueryVersionReq);
553 compare(xXIQueryDeviceReq);
554 compare(xXISetFocusReq);
555 compare(xXIGetFocusReq);
556 compare(xXIGrabDeviceReq);
557 compare(xXIUngrabDeviceReq);
558 compare(xXIAllowEventsReq);
559 compare(xXIPassiveGrabDeviceReq);
560 compare(xXIPassiveUngrabDeviceReq);
561 compare(xXIListPropertiesReq);
562 compare(xXIChangePropertyReq);
563 compare(xXIDeletePropertyReq);
564 compare(xXIGetPropertyReq);
565 compare(xXIGetSelectedEventsReq);
566#undef compare
567}
568
569static void
570dix_grab_matching(void)
571{
572 DeviceIntRec xi_all_devices, xi_all_master_devices, dev1, dev2;
573 GrabRec a, b;
574 BOOL rc;
575
576 memset(&a, 0, sizeof(a))__builtin___memset_chk (&a, 0, sizeof(a), __builtin_object_size
(&a, 0))
;
577 memset(&b, 0, sizeof(b))__builtin___memset_chk (&b, 0, sizeof(b), __builtin_object_size
(&b, 0))
;
578
579 /* different grabtypes must fail */
580 a.grabtype = CORE;
581 b.grabtype = XI2;
582 rc = GrabMatchesSecond(&a, &b, FALSE0);
583 assert(rc == FALSE)(__builtin_expect(!(rc == 0), 0) ? __assert_rtn(__func__, "input.c"
, 583, "rc == FALSE") : (void)0)
;
584 rc = GrabMatchesSecond(&b, &a, FALSE0);
585 assert(rc == FALSE)(__builtin_expect(!(rc == 0), 0) ? __assert_rtn(__func__, "input.c"
, 585, "rc == FALSE") : (void)0)
;
586
587 a.grabtype = XI;
588 b.grabtype = XI2;
589 rc = GrabMatchesSecond(&a, &b, FALSE0);
590 assert(rc == FALSE)(__builtin_expect(!(rc == 0), 0) ? __assert_rtn(__func__, "input.c"
, 590, "rc == FALSE") : (void)0)
;
591 rc = GrabMatchesSecond(&b, &a, FALSE0);
592 assert(rc == FALSE)(__builtin_expect(!(rc == 0), 0) ? __assert_rtn(__func__, "input.c"
, 592, "rc == FALSE") : (void)0)
;
593
594 a.grabtype = XI;
595 b.grabtype = CORE;
596 rc = GrabMatchesSecond(&a, &b, FALSE0);
597 assert(rc == FALSE)(__builtin_expect(!(rc == 0), 0) ? __assert_rtn(__func__, "input.c"
, 597, "rc == FALSE") : (void)0)
;
598 rc = GrabMatchesSecond(&b, &a, FALSE0);
599 assert(rc == FALSE)(__builtin_expect(!(rc == 0), 0) ? __assert_rtn(__func__, "input.c"
, 599, "rc == FALSE") : (void)0)
;
600
601 /* XI2 grabs for different devices must fail, regardless of ignoreDevice
602 * XI2 grabs for master devices must fail against a slave */
603 memset(&xi_all_devices, 0, sizeof(DeviceIntRec))__builtin___memset_chk (&xi_all_devices, 0, sizeof(DeviceIntRec
), __builtin_object_size (&xi_all_devices, 0))
;
604 memset(&xi_all_master_devices, 0, sizeof(DeviceIntRec))__builtin___memset_chk (&xi_all_master_devices, 0, sizeof
(DeviceIntRec), __builtin_object_size (&xi_all_master_devices
, 0))
;
605 memset(&dev1, 0, sizeof(DeviceIntRec))__builtin___memset_chk (&dev1, 0, sizeof(DeviceIntRec), __builtin_object_size
(&dev1, 0))
;
606 memset(&dev2, 0, sizeof(DeviceIntRec))__builtin___memset_chk (&dev2, 0, sizeof(DeviceIntRec), __builtin_object_size
(&dev2, 0))
;
607
608 xi_all_devices.id = XIAllDevices0;
609 xi_all_master_devices.id = XIAllMasterDevices1;
610 dev1.id = 10;
611 dev1.type = SLAVE3;
612 dev2.id = 11;
613 dev2.type = SLAVE3;
614
615 inputInfo.all_devices = &xi_all_devices;
616 inputInfo.all_master_devices = &xi_all_master_devices;
617 a.grabtype = XI2;
618 b.grabtype = XI2;
619 a.device = &dev1;
620 b.device = &dev2;
621
622 rc = GrabMatchesSecond(&a, &b, FALSE0);
623 assert(rc == FALSE)(__builtin_expect(!(rc == 0), 0) ? __assert_rtn(__func__, "input.c"
, 623, "rc == FALSE") : (void)0)
;
624
625 a.device = &dev2;
626 b.device = &dev1;
627 rc = GrabMatchesSecond(&a, &b, FALSE0);
628 assert(rc == FALSE)(__builtin_expect(!(rc == 0), 0) ? __assert_rtn(__func__, "input.c"
, 628, "rc == FALSE") : (void)0)
;
629 rc = GrabMatchesSecond(&a, &b, TRUE1);
630 assert(rc == FALSE)(__builtin_expect(!(rc == 0), 0) ? __assert_rtn(__func__, "input.c"
, 630, "rc == FALSE") : (void)0)
;
631
632 a.device = inputInfo.all_master_devices;
633 b.device = &dev1;
634 rc = GrabMatchesSecond(&a, &b, FALSE0);
635 assert(rc == FALSE)(__builtin_expect(!(rc == 0), 0) ? __assert_rtn(__func__, "input.c"
, 635, "rc == FALSE") : (void)0)
;
636 rc = GrabMatchesSecond(&a, &b, TRUE1);
637 assert(rc == FALSE)(__builtin_expect(!(rc == 0), 0) ? __assert_rtn(__func__, "input.c"
, 637, "rc == FALSE") : (void)0)
;
638
639 a.device = &dev1;
640 b.device = inputInfo.all_master_devices;
641 rc = GrabMatchesSecond(&a, &b, FALSE0);
642 assert(rc == FALSE)(__builtin_expect(!(rc == 0), 0) ? __assert_rtn(__func__, "input.c"
, 642, "rc == FALSE") : (void)0)
;
643 rc = GrabMatchesSecond(&a, &b, TRUE1);
644 assert(rc == FALSE)(__builtin_expect(!(rc == 0), 0) ? __assert_rtn(__func__, "input.c"
, 644, "rc == FALSE") : (void)0)
;
645
646 /* ignoreDevice FALSE must fail for different devices for CORE and XI */
647 a.grabtype = XI;
648 b.grabtype = XI;
649 a.device = &dev1;
650 b.device = &dev2;
651 a.modifierDevice = &dev1;
652 b.modifierDevice = &dev1;
653 rc = GrabMatchesSecond(&a, &b, FALSE0);
654 assert(rc == FALSE)(__builtin_expect(!(rc == 0), 0) ? __assert_rtn(__func__, "input.c"
, 654, "rc == FALSE") : (void)0)
;
655
656 a.grabtype = CORE;
657 b.grabtype = CORE;
658 a.device = &dev1;
659 b.device = &dev2;
660 a.modifierDevice = &dev1;
661 b.modifierDevice = &dev1;
662 rc = GrabMatchesSecond(&a, &b, FALSE0);
663 assert(rc == FALSE)(__builtin_expect(!(rc == 0), 0) ? __assert_rtn(__func__, "input.c"
, 663, "rc == FALSE") : (void)0)
;
664
665 /* ignoreDevice FALSE must fail for different modifier devices for CORE
666 * and XI */
667 a.grabtype = XI;
668 b.grabtype = XI;
669 a.device = &dev1;
670 b.device = &dev1;
671 a.modifierDevice = &dev1;
672 b.modifierDevice = &dev2;
673 rc = GrabMatchesSecond(&a, &b, FALSE0);
674 assert(rc == FALSE)(__builtin_expect(!(rc == 0), 0) ? __assert_rtn(__func__, "input.c"
, 674, "rc == FALSE") : (void)0)
;
675
676 a.grabtype = CORE;
677 b.grabtype = CORE;
678 a.device = &dev1;
679 b.device = &dev1;
680 a.modifierDevice = &dev1;
681 b.modifierDevice = &dev2;
682 rc = GrabMatchesSecond(&a, &b, FALSE0);
683 assert(rc == FALSE)(__builtin_expect(!(rc == 0), 0) ? __assert_rtn(__func__, "input.c"
, 683, "rc == FALSE") : (void)0)
;
684
685 /* different event type must fail */
686 a.grabtype = XI2;
687 b.grabtype = XI2;
688 a.device = &dev1;
689 b.device = &dev1;
690 a.modifierDevice = &dev1;
691 b.modifierDevice = &dev1;
692 a.type = XI_KeyPress2;
693 b.type = XI_KeyRelease3;
694 rc = GrabMatchesSecond(&a, &b, FALSE0);
695 assert(rc == FALSE)(__builtin_expect(!(rc == 0), 0) ? __assert_rtn(__func__, "input.c"
, 695, "rc == FALSE") : (void)0)
;
696 rc = GrabMatchesSecond(&a, &b, TRUE1);
697 assert(rc == FALSE)(__builtin_expect(!(rc == 0), 0) ? __assert_rtn(__func__, "input.c"
, 697, "rc == FALSE") : (void)0)
;
698
699 a.grabtype = CORE;
700 b.grabtype = CORE;
701 a.device = &dev1;
702 b.device = &dev1;
703 a.modifierDevice = &dev1;
704 b.modifierDevice = &dev1;
705 a.type = XI_KeyPress2;
706 b.type = XI_KeyRelease3;
707 rc = GrabMatchesSecond(&a, &b, FALSE0);
708 assert(rc == FALSE)(__builtin_expect(!(rc == 0), 0) ? __assert_rtn(__func__, "input.c"
, 708, "rc == FALSE") : (void)0)
;
709 rc = GrabMatchesSecond(&a, &b, TRUE1);
710 assert(rc == FALSE)(__builtin_expect(!(rc == 0), 0) ? __assert_rtn(__func__, "input.c"
, 710, "rc == FALSE") : (void)0)
;
711
712 a.grabtype = XI;
713 b.grabtype = XI;
714 a.device = &dev1;
715 b.device = &dev1;
716 a.modifierDevice = &dev1;
717 b.modifierDevice = &dev1;
718 a.type = XI_KeyPress2;
719 b.type = XI_KeyRelease3;
720 rc = GrabMatchesSecond(&a, &b, FALSE0);
721 assert(rc == FALSE)(__builtin_expect(!(rc == 0), 0) ? __assert_rtn(__func__, "input.c"
, 721, "rc == FALSE") : (void)0)
;
722 rc = GrabMatchesSecond(&a, &b, TRUE1);
723 assert(rc == FALSE)(__builtin_expect(!(rc == 0), 0) ? __assert_rtn(__func__, "input.c"
, 723, "rc == FALSE") : (void)0)
;
724
725 /* different modifiers must fail */
726 a.grabtype = XI2;
727 b.grabtype = XI2;
728 a.device = &dev1;
729 b.device = &dev1;
730 a.modifierDevice = &dev1;
731 b.modifierDevice = &dev1;
732 a.type = XI_KeyPress2;
733 b.type = XI_KeyPress2;
734 a.modifiersDetail.exact = 1;
735 b.modifiersDetail.exact = 2;
736 rc = GrabMatchesSecond(&a, &b, FALSE0);
737 assert(rc == FALSE)(__builtin_expect(!(rc == 0), 0) ? __assert_rtn(__func__, "input.c"
, 737, "rc == FALSE") : (void)0)
;
738 rc = GrabMatchesSecond(&b, &a, FALSE0);
739 assert(rc == FALSE)(__builtin_expect(!(rc == 0), 0) ? __assert_rtn(__func__, "input.c"
, 739, "rc == FALSE") : (void)0)
;
740
741 a.grabtype = CORE;
742 b.grabtype = CORE;
743 rc = GrabMatchesSecond(&a, &b, FALSE0);
744 assert(rc == FALSE)(__builtin_expect(!(rc == 0), 0) ? __assert_rtn(__func__, "input.c"
, 744, "rc == FALSE") : (void)0)
;
745 rc = GrabMatchesSecond(&b, &a, FALSE0);
746 assert(rc == FALSE)(__builtin_expect(!(rc == 0), 0) ? __assert_rtn(__func__, "input.c"
, 746, "rc == FALSE") : (void)0)
;
747
748 a.grabtype = XI;
749 b.grabtype = XI;
750 rc = GrabMatchesSecond(&a, &b, FALSE0);
751 assert(rc == FALSE)(__builtin_expect(!(rc == 0), 0) ? __assert_rtn(__func__, "input.c"
, 751, "rc == FALSE") : (void)0)
;
752 rc = GrabMatchesSecond(&b, &a, FALSE0);
753 assert(rc == FALSE)(__builtin_expect(!(rc == 0), 0) ? __assert_rtn(__func__, "input.c"
, 753, "rc == FALSE") : (void)0)
;
754
755 /* AnyModifier must fail for XI2 */
756 a.grabtype = XI2;
757 b.grabtype = XI2;
758 a.modifiersDetail.exact = AnyModifier(1<<15);
759 b.modifiersDetail.exact = 1;
760 rc = GrabMatchesSecond(&a, &b, FALSE0);
761 assert(rc == FALSE)(__builtin_expect(!(rc == 0), 0) ? __assert_rtn(__func__, "input.c"
, 761, "rc == FALSE") : (void)0)
;
762 rc = GrabMatchesSecond(&b, &a, FALSE0);
763 assert(rc == FALSE)(__builtin_expect(!(rc == 0), 0) ? __assert_rtn(__func__, "input.c"
, 763, "rc == FALSE") : (void)0)
;
764
765 /* XIAnyModifier must fail for CORE and XI */
766 a.grabtype = XI;
767 b.grabtype = XI;
768 a.modifiersDetail.exact = XIAnyModifier(1U << 31);
769 b.modifiersDetail.exact = 1;
770 rc = GrabMatchesSecond(&a, &b, FALSE0);
771 assert(rc == FALSE)(__builtin_expect(!(rc == 0), 0) ? __assert_rtn(__func__, "input.c"
, 771, "rc == FALSE") : (void)0)
;
772 rc = GrabMatchesSecond(&b, &a, FALSE0);
773 assert(rc == FALSE)(__builtin_expect(!(rc == 0), 0) ? __assert_rtn(__func__, "input.c"
, 773, "rc == FALSE") : (void)0)
;
774
775 a.grabtype = CORE;
776 b.grabtype = CORE;
777 a.modifiersDetail.exact = XIAnyModifier(1U << 31);
778 b.modifiersDetail.exact = 1;
779 rc = GrabMatchesSecond(&a, &b, FALSE0);
780 assert(rc == FALSE)(__builtin_expect(!(rc == 0), 0) ? __assert_rtn(__func__, "input.c"
, 780, "rc == FALSE") : (void)0)
;
781 rc = GrabMatchesSecond(&b, &a, FALSE0);
782 assert(rc == FALSE)(__builtin_expect(!(rc == 0), 0) ? __assert_rtn(__func__, "input.c"
, 782, "rc == FALSE") : (void)0)
;
783
784 /* different detail must fail */
785 a.grabtype = XI2;
786 b.grabtype = XI2;
787 a.detail.exact = 1;
788 b.detail.exact = 2;
789 a.modifiersDetail.exact = 1;
790 b.modifiersDetail.exact = 1;
791 rc = GrabMatchesSecond(&a, &b, FALSE0);
792 assert(rc == FALSE)(__builtin_expect(!(rc == 0), 0) ? __assert_rtn(__func__, "input.c"
, 792, "rc == FALSE") : (void)0)
;
793 rc = GrabMatchesSecond(&b, &a, FALSE0);
794 assert(rc == FALSE)(__builtin_expect(!(rc == 0), 0) ? __assert_rtn(__func__, "input.c"
, 794, "rc == FALSE") : (void)0)
;
795
796 a.grabtype = XI;
797 b.grabtype = XI;
798 rc = GrabMatchesSecond(&a, &b, FALSE0);
799 assert(rc == FALSE)(__builtin_expect(!(rc == 0), 0) ? __assert_rtn(__func__, "input.c"
, 799, "rc == FALSE") : (void)0)
;
800 rc = GrabMatchesSecond(&b, &a, FALSE0);
801 assert(rc == FALSE)(__builtin_expect(!(rc == 0), 0) ? __assert_rtn(__func__, "input.c"
, 801, "rc == FALSE") : (void)0)
;
802
803 a.grabtype = CORE;
804 b.grabtype = CORE;
805 rc = GrabMatchesSecond(&a, &b, FALSE0);
806 assert(rc == FALSE)(__builtin_expect(!(rc == 0), 0) ? __assert_rtn(__func__, "input.c"
, 806, "rc == FALSE") : (void)0)
;
807 rc = GrabMatchesSecond(&b, &a, FALSE0);
808 assert(rc == FALSE)(__builtin_expect(!(rc == 0), 0) ? __assert_rtn(__func__, "input.c"
, 808, "rc == FALSE") : (void)0)
;
809
810 /* detail of AnyModifier must fail */
811 a.grabtype = XI2;
812 b.grabtype = XI2;
813 a.detail.exact = AnyModifier(1<<15);
814 b.detail.exact = 1;
815 a.modifiersDetail.exact = 1;
816 b.modifiersDetail.exact = 1;
817 rc = GrabMatchesSecond(&a, &b, FALSE0);
818 assert(rc == FALSE)(__builtin_expect(!(rc == 0), 0) ? __assert_rtn(__func__, "input.c"
, 818, "rc == FALSE") : (void)0)
;
819 rc = GrabMatchesSecond(&b, &a, FALSE0);
820 assert(rc == FALSE)(__builtin_expect(!(rc == 0), 0) ? __assert_rtn(__func__, "input.c"
, 820, "rc == FALSE") : (void)0)
;
821
822 a.grabtype = CORE;
823 b.grabtype = CORE;
824 rc = GrabMatchesSecond(&a, &b, FALSE0);
825 assert(rc == FALSE)(__builtin_expect(!(rc == 0), 0) ? __assert_rtn(__func__, "input.c"
, 825, "rc == FALSE") : (void)0)
;
826 rc = GrabMatchesSecond(&b, &a, FALSE0);
827 assert(rc == FALSE)(__builtin_expect(!(rc == 0), 0) ? __assert_rtn(__func__, "input.c"
, 827, "rc == FALSE") : (void)0)
;
828
829 a.grabtype = XI;
830 b.grabtype = XI;
831 rc = GrabMatchesSecond(&a, &b, FALSE0);
832 assert(rc == FALSE)(__builtin_expect(!(rc == 0), 0) ? __assert_rtn(__func__, "input.c"
, 832, "rc == FALSE") : (void)0)
;
833 rc = GrabMatchesSecond(&b, &a, FALSE0);
834 assert(rc == FALSE)(__builtin_expect(!(rc == 0), 0) ? __assert_rtn(__func__, "input.c"
, 834, "rc == FALSE") : (void)0)
;
835
836 /* detail of XIAnyModifier must fail */
837 a.grabtype = XI2;
838 b.grabtype = XI2;
839 a.detail.exact = XIAnyModifier(1U << 31);
840 b.detail.exact = 1;
841 a.modifiersDetail.exact = 1;
842 b.modifiersDetail.exact = 1;
843 rc = GrabMatchesSecond(&a, &b, FALSE0);
844 assert(rc == FALSE)(__builtin_expect(!(rc == 0), 0) ? __assert_rtn(__func__, "input.c"
, 844, "rc == FALSE") : (void)0)
;
845 rc = GrabMatchesSecond(&b, &a, FALSE0);
846 assert(rc == FALSE)(__builtin_expect(!(rc == 0), 0) ? __assert_rtn(__func__, "input.c"
, 846, "rc == FALSE") : (void)0)
;
847
848 a.grabtype = CORE;
849 b.grabtype = CORE;
850 rc = GrabMatchesSecond(&a, &b, FALSE0);
851 assert(rc == FALSE)(__builtin_expect(!(rc == 0), 0) ? __assert_rtn(__func__, "input.c"
, 851, "rc == FALSE") : (void)0)
;
852 rc = GrabMatchesSecond(&b, &a, FALSE0);
853 assert(rc == FALSE)(__builtin_expect(!(rc == 0), 0) ? __assert_rtn(__func__, "input.c"
, 853, "rc == FALSE") : (void)0)
;
854
855 a.grabtype = XI;
856 b.grabtype = XI;
857 rc = GrabMatchesSecond(&a, &b, FALSE0);
858 assert(rc == FALSE)(__builtin_expect(!(rc == 0), 0) ? __assert_rtn(__func__, "input.c"
, 858, "rc == FALSE") : (void)0)
;
859 rc = GrabMatchesSecond(&b, &a, FALSE0);
860 assert(rc == FALSE)(__builtin_expect(!(rc == 0), 0) ? __assert_rtn(__func__, "input.c"
, 860, "rc == FALSE") : (void)0)
;
861
862 /* XIAnyModifier or AnyModifer must succeed */
863 a.grabtype = XI2;
864 b.grabtype = XI2;
865 a.detail.exact = 1;
866 b.detail.exact = 1;
867 a.modifiersDetail.exact = XIAnyModifier(1U << 31);
868 b.modifiersDetail.exact = 1;
869 rc = GrabMatchesSecond(&a, &b, FALSE0);
870 assert(rc == TRUE)(__builtin_expect(!(rc == 1), 0) ? __assert_rtn(__func__, "input.c"
, 870, "rc == TRUE") : (void)0)
;
871 rc = GrabMatchesSecond(&b, &a, FALSE0);
872 assert(rc == TRUE)(__builtin_expect(!(rc == 1), 0) ? __assert_rtn(__func__, "input.c"
, 872, "rc == TRUE") : (void)0)
;
873
874 a.grabtype = CORE;
875 b.grabtype = CORE;
876 a.detail.exact = 1;
877 b.detail.exact = 1;
878 a.modifiersDetail.exact = AnyModifier(1<<15);
879 b.modifiersDetail.exact = 1;
880 rc = GrabMatchesSecond(&a, &b, FALSE0);
881 assert(rc == TRUE)(__builtin_expect(!(rc == 1), 0) ? __assert_rtn(__func__, "input.c"
, 881, "rc == TRUE") : (void)0)
;
882 rc = GrabMatchesSecond(&b, &a, FALSE0);
883 assert(rc == TRUE)(__builtin_expect(!(rc == 1), 0) ? __assert_rtn(__func__, "input.c"
, 883, "rc == TRUE") : (void)0)
;
884
885 a.grabtype = XI;
886 b.grabtype = XI;
887 a.detail.exact = 1;
888 b.detail.exact = 1;
889 a.modifiersDetail.exact = AnyModifier(1<<15);
890 b.modifiersDetail.exact = 1;
891 rc = GrabMatchesSecond(&a, &b, FALSE0);
892 assert(rc == TRUE)(__builtin_expect(!(rc == 1), 0) ? __assert_rtn(__func__, "input.c"
, 892, "rc == TRUE") : (void)0)
;
893 rc = GrabMatchesSecond(&b, &a, FALSE0);
894 assert(rc == TRUE)(__builtin_expect(!(rc == 1), 0) ? __assert_rtn(__func__, "input.c"
, 894, "rc == TRUE") : (void)0)
;
895
896 /* AnyKey or XIAnyKeycode must succeed */
897 a.grabtype = XI2;
898 b.grabtype = XI2;
899 a.detail.exact = XIAnyKeycode0;
900 b.detail.exact = 1;
901 a.modifiersDetail.exact = 1;
902 b.modifiersDetail.exact = 1;
903 rc = GrabMatchesSecond(&a, &b, FALSE0);
904 assert(rc == TRUE)(__builtin_expect(!(rc == 1), 0) ? __assert_rtn(__func__, "input.c"
, 904, "rc == TRUE") : (void)0)
;
905 rc = GrabMatchesSecond(&b, &a, FALSE0);
906 assert(rc == TRUE)(__builtin_expect(!(rc == 1), 0) ? __assert_rtn(__func__, "input.c"
, 906, "rc == TRUE") : (void)0)
;
907
908 a.grabtype = CORE;
909 b.grabtype = CORE;
910 a.detail.exact = AnyKey0L;
911 b.detail.exact = 1;
912 a.modifiersDetail.exact = 1;
913 b.modifiersDetail.exact = 1;
914 rc = GrabMatchesSecond(&a, &b, FALSE0);
915 assert(rc == TRUE)(__builtin_expect(!(rc == 1), 0) ? __assert_rtn(__func__, "input.c"
, 915, "rc == TRUE") : (void)0)
;
916 rc = GrabMatchesSecond(&b, &a, FALSE0);
917 assert(rc == TRUE)(__builtin_expect(!(rc == 1), 0) ? __assert_rtn(__func__, "input.c"
, 917, "rc == TRUE") : (void)0)
;
918
919 a.grabtype = XI;
920 b.grabtype = XI;
921 a.detail.exact = AnyKey0L;
922 b.detail.exact = 1;
923 a.modifiersDetail.exact = 1;
924 b.modifiersDetail.exact = 1;
925 rc = GrabMatchesSecond(&a, &b, FALSE0);
926 assert(rc == TRUE)(__builtin_expect(!(rc == 1), 0) ? __assert_rtn(__func__, "input.c"
, 926, "rc == TRUE") : (void)0)
;
927 rc = GrabMatchesSecond(&b, &a, FALSE0);
928 assert(rc == TRUE)(__builtin_expect(!(rc == 1), 0) ? __assert_rtn(__func__, "input.c"
, 928, "rc == TRUE") : (void)0)
;
929}
930
931static void
932test_bits_to_byte(int i)
933{
934 int expected_bytes;
935
936 expected_bytes = (i + 7) / 8;
937
938 assert(bits_to_bytes(i) >= i / 8)(__builtin_expect(!(bits_to_bytes(i) >= i / 8), 0) ? __assert_rtn
(__func__, "input.c", 938, "bits_to_bytes(i) >= i / 8") : (
void)0)
;
939 assert((bits_to_bytes(i) * 8) - i <= 7)(__builtin_expect(!((bits_to_bytes(i) * 8) - i <= 7), 0) ?
__assert_rtn(__func__, "input.c", 939, "(bits_to_bytes(i) * 8) - i <= 7"
) : (void)0)
;
940 assert(expected_bytes == bits_to_bytes(i))(__builtin_expect(!(expected_bytes == bits_to_bytes(i)), 0) ?
__assert_rtn(__func__, "input.c", 940, "expected_bytes == bits_to_bytes(i)"
) : (void)0)
;
941}
942
943static void
944test_bytes_to_int32(int i)
945{
946 int expected_4byte;
947
948 expected_4byte = (i + 3) / 4;
949
950 assert(bytes_to_int32(i) <= i)(__builtin_expect(!(bytes_to_int32(i) <= i), 0) ? __assert_rtn
(__func__, "input.c", 950, "bytes_to_int32(i) <= i") : (void
)0)
;
951 assert((bytes_to_int32(i) * 4) - i <= 3)(__builtin_expect(!((bytes_to_int32(i) * 4) - i <= 3), 0) ?
__assert_rtn(__func__, "input.c", 951, "(bytes_to_int32(i) * 4) - i <= 3"
) : (void)0)
;
952 assert(expected_4byte == bytes_to_int32(i))(__builtin_expect(!(expected_4byte == bytes_to_int32(i)), 0) ?
__assert_rtn(__func__, "input.c", 952, "expected_4byte == bytes_to_int32(i)"
) : (void)0)
;
953}
954
955static void
956test_pad_to_int32(int i)
957{
958 int expected_bytes;
959
960 expected_bytes = ((i + 3) / 4) * 4;
961
962 assert(pad_to_int32(i) >= i)(__builtin_expect(!(pad_to_int32(i) >= i), 0) ? __assert_rtn
(__func__, "input.c", 962, "pad_to_int32(i) >= i") : (void
)0)
;
963 assert(pad_to_int32(i) - i <= 3)(__builtin_expect(!(pad_to_int32(i) - i <= 3), 0) ? __assert_rtn
(__func__, "input.c", 963, "pad_to_int32(i) - i <= 3") : (
void)0)
;
964 assert(expected_bytes == pad_to_int32(i))(__builtin_expect(!(expected_bytes == pad_to_int32(i)), 0) ? __assert_rtn
(__func__, "input.c", 964, "expected_bytes == pad_to_int32(i)"
) : (void)0)
;
965}
966
967static void
968test_padding_for_int32(int i)
969{
970 static const int padlength[4] = { 0, 3, 2, 1 };
971 int expected_bytes = (((i + 3) / 4) * 4) - i;
972
973 assert(padding_for_int32(i) >= 0)(__builtin_expect(!(padding_for_int32(i) >= 0), 0) ? __assert_rtn
(__func__, "input.c", 973, "padding_for_int32(i) >= 0") : (
void)0)
;
974 assert(padding_for_int32(i) <= 3)(__builtin_expect(!(padding_for_int32(i) <= 3), 0) ? __assert_rtn
(__func__, "input.c", 974, "padding_for_int32(i) <= 3") : (
void)0)
;
975 assert(padding_for_int32(i) == expected_bytes)(__builtin_expect(!(padding_for_int32(i) == expected_bytes), 0
) ? __assert_rtn(__func__, "input.c", 975, "padding_for_int32(i) == expected_bytes"
) : (void)0)
;
976 assert(padding_for_int32(i) == padlength[i & 3])(__builtin_expect(!(padding_for_int32(i) == padlength[i &
3]), 0) ? __assert_rtn(__func__, "input.c", 976, "padding_for_int32(i) == padlength[i & 3]"
) : (void)0)
;
977 assert((padding_for_int32(i) + i) == pad_to_int32(i))(__builtin_expect(!((padding_for_int32(i) + i) == pad_to_int32
(i)), 0) ? __assert_rtn(__func__, "input.c", 977, "(padding_for_int32(i) + i) == pad_to_int32(i)"
) : (void)0)
;
978}
979
980static void
981include_byte_padding_macros(void)
982{
983 printf("Testing bits_to_bytes()\n");
984
985 /* the macros don't provide overflow protection */
986 test_bits_to_byte(0);
987 test_bits_to_byte(1);
988 test_bits_to_byte(2);
989 test_bits_to_byte(7);
990 test_bits_to_byte(8);
991 test_bits_to_byte(0xFF);
992 test_bits_to_byte(0x100);
993 test_bits_to_byte(INT_MAX2147483647 - 9);
994 test_bits_to_byte(INT_MAX2147483647 - 8);
995
996 printf("Testing bytes_to_int32()\n");
997
998 test_bytes_to_int32(0);
999 test_bytes_to_int32(1);
1000 test_bytes_to_int32(2);
1001 test_bytes_to_int32(7);
1002 test_bytes_to_int32(8);
1003 test_bytes_to_int32(0xFF);
1004 test_bytes_to_int32(0x100);
1005 test_bytes_to_int32(0xFFFF);
1006 test_bytes_to_int32(0x10000);
1007 test_bytes_to_int32(0xFFFFFF);
1008 test_bytes_to_int32(0x1000000);
1009 test_bytes_to_int32(INT_MAX2147483647 - 4);
1010 test_bytes_to_int32(INT_MAX2147483647 - 3);
1011
1012 printf("Testing pad_to_int32()\n");
1013
1014 test_pad_to_int32(0);
1015 test_pad_to_int32(1);
1016 test_pad_to_int32(2);
1017 test_pad_to_int32(3);
1018 test_pad_to_int32(7);
1019 test_pad_to_int32(8);
1020 test_pad_to_int32(0xFF);
1021 test_pad_to_int32(0x100);
1022 test_pad_to_int32(0xFFFF);
1023 test_pad_to_int32(0x10000);
1024 test_pad_to_int32(0xFFFFFF);
1025 test_pad_to_int32(0x1000000);
1026 test_pad_to_int32(INT_MAX2147483647 - 4);
1027 test_pad_to_int32(INT_MAX2147483647 - 3);
1028
1029 printf("Testing padding_for_int32()\n");
1030
1031 test_padding_for_int32(0);
1032 test_padding_for_int32(1);
1033 test_padding_for_int32(2);
1034 test_padding_for_int32(3);
1035 test_padding_for_int32(7);
1036 test_padding_for_int32(8);
1037 test_padding_for_int32(0xFF);
1038 test_padding_for_int32(0x100);
1039 test_padding_for_int32(0xFFFF);
1040 test_padding_for_int32(0x10000);
1041 test_padding_for_int32(0xFFFFFF);
1042 test_padding_for_int32(0x1000000);
1043 test_padding_for_int32(INT_MAX2147483647 - 4);
1044 test_padding_for_int32(INT_MAX2147483647 - 3);
1045}
1046
1047static void
1048xi_unregister_handlers(void)
1049{
1050 DeviceIntRec dev;
1051 int handler;
1052
1053 memset(&dev, 0, sizeof(dev))__builtin___memset_chk (&dev, 0, sizeof(dev), __builtin_object_size
(&dev, 0))
;
1054
1055 handler = XIRegisterPropertyHandler(&dev, NULL((void*)0), NULL((void*)0), NULL((void*)0));
1056 assert(handler == 1)(__builtin_expect(!(handler == 1), 0) ? __assert_rtn(__func__
, "input.c", 1056, "handler == 1") : (void)0)
;
1057 handler = XIRegisterPropertyHandler(&dev, NULL((void*)0), NULL((void*)0), NULL((void*)0));
1058 assert(handler == 2)(__builtin_expect(!(handler == 2), 0) ? __assert_rtn(__func__
, "input.c", 1058, "handler == 2") : (void)0)
;
1059 handler = XIRegisterPropertyHandler(&dev, NULL((void*)0), NULL((void*)0), NULL((void*)0));
1060 assert(handler == 3)(__builtin_expect(!(handler == 3), 0) ? __assert_rtn(__func__
, "input.c", 1060, "handler == 3") : (void)0)
;
1061
1062 printf("Unlinking from front.\n");
1063
1064 XIUnregisterPropertyHandler(&dev, 4); /* NOOP */
1065 assert(dev.properties.handlers->id == 3)(__builtin_expect(!(dev.properties.handlers->id == 3), 0) ?
__assert_rtn(__func__, "input.c", 1065, "dev.properties.handlers->id == 3"
) : (void)0)
;
1066 XIUnregisterPropertyHandler(&dev, 3);
1067 assert(dev.properties.handlers->id == 2)(__builtin_expect(!(dev.properties.handlers->id == 2), 0) ?
__assert_rtn(__func__, "input.c", 1067, "dev.properties.handlers->id == 2"
) : (void)0)
;
1068 XIUnregisterPropertyHandler(&dev, 2);
1069 assert(dev.properties.handlers->id == 1)(__builtin_expect(!(dev.properties.handlers->id == 1), 0) ?
__assert_rtn(__func__, "input.c", 1069, "dev.properties.handlers->id == 1"
) : (void)0)
;
1070 XIUnregisterPropertyHandler(&dev, 1);
1071 assert(dev.properties.handlers == NULL)(__builtin_expect(!(dev.properties.handlers == ((void*)0)), 0
) ? __assert_rtn(__func__, "input.c", 1071, "dev.properties.handlers == NULL"
) : (void)0)
;
1072
1073 handler = XIRegisterPropertyHandler(&dev, NULL((void*)0), NULL((void*)0), NULL((void*)0));
1074 assert(handler == 4)(__builtin_expect(!(handler == 4), 0) ? __assert_rtn(__func__
, "input.c", 1074, "handler == 4") : (void)0)
;
1075 handler = XIRegisterPropertyHandler(&dev, NULL((void*)0), NULL((void*)0), NULL((void*)0));
1076 assert(handler == 5)(__builtin_expect(!(handler == 5), 0) ? __assert_rtn(__func__
, "input.c", 1076, "handler == 5") : (void)0)
;
1077 handler = XIRegisterPropertyHandler(&dev, NULL((void*)0), NULL((void*)0), NULL((void*)0));
1078 assert(handler == 6)(__builtin_expect(!(handler == 6), 0) ? __assert_rtn(__func__
, "input.c", 1078, "handler == 6") : (void)0)
;
1079 XIUnregisterPropertyHandler(&dev, 3); /* NOOP */
1080 assert(dev.properties.handlers->next->next->next == NULL)(__builtin_expect(!(dev.properties.handlers->next->next
->next == ((void*)0)), 0) ? __assert_rtn(__func__, "input.c"
, 1080, "dev.properties.handlers->next->next->next == NULL"
) : (void)0)
;
1081 XIUnregisterPropertyHandler(&dev, 4);
1082 assert(dev.properties.handlers->next->next == NULL)(__builtin_expect(!(dev.properties.handlers->next->next
== ((void*)0)), 0) ? __assert_rtn(__func__, "input.c", 1082,
"dev.properties.handlers->next->next == NULL") : (void
)0)
;
1083 XIUnregisterPropertyHandler(&dev, 5);
1084 assert(dev.properties.handlers->next == NULL)(__builtin_expect(!(dev.properties.handlers->next == ((void
*)0)), 0) ? __assert_rtn(__func__, "input.c", 1084, "dev.properties.handlers->next == NULL"
) : (void)0)
;
1085 XIUnregisterPropertyHandler(&dev, 6);
1086 assert(dev.properties.handlers == NULL)(__builtin_expect(!(dev.properties.handlers == ((void*)0)), 0
) ? __assert_rtn(__func__, "input.c", 1086, "dev.properties.handlers == NULL"
) : (void)0)
;
1087
1088 handler = XIRegisterPropertyHandler(&dev, NULL((void*)0), NULL((void*)0), NULL((void*)0));
1089 assert(handler == 7)(__builtin_expect(!(handler == 7), 0) ? __assert_rtn(__func__
, "input.c", 1089, "handler == 7") : (void)0)
;
1090 handler = XIRegisterPropertyHandler(&dev, NULL((void*)0), NULL((void*)0), NULL((void*)0));
1091 assert(handler == 8)(__builtin_expect(!(handler == 8), 0) ? __assert_rtn(__func__
, "input.c", 1091, "handler == 8") : (void)0)
;
1092 handler = XIRegisterPropertyHandler(&dev, NULL((void*)0), NULL((void*)0), NULL((void*)0));
1093 assert(handler == 9)(__builtin_expect(!(handler == 9), 0) ? __assert_rtn(__func__
, "input.c", 1093, "handler == 9") : (void)0)
;
1094
1095 XIDeleteAllDeviceProperties(&dev);
1096 assert(dev.properties.handlers == NULL)(__builtin_expect(!(dev.properties.handlers == ((void*)0)), 0
) ? __assert_rtn(__func__, "input.c", 1096, "dev.properties.handlers == NULL"
) : (void)0)
;
1097 XIUnregisterPropertyHandler(&dev, 7); /* NOOP */
1098
1099}
1100
1101static void
1102cmp_attr_fields(InputAttributes * attr1, InputAttributes * attr2)
1103{
1104 char **tags1, **tags2;
1105
1106 assert(attr1 && attr2)(__builtin_expect(!(attr1 && attr2), 0) ? __assert_rtn
(__func__, "input.c", 1106, "attr1 && attr2") : (void
)0)
;
1107 assert(attr1 != attr2)(__builtin_expect(!(attr1 != attr2), 0) ? __assert_rtn(__func__
, "input.c", 1107, "attr1 != attr2") : (void)0)
;
1108 assert(attr1->flags == attr2->flags)(__builtin_expect(!(attr1->flags == attr2->flags), 0) ?
__assert_rtn(__func__, "input.c", 1108, "attr1->flags == attr2->flags"
) : (void)0)
;
1109
1110 if (attr1->product != NULL((void*)0)) {
1111 assert(attr1->product != attr2->product)(__builtin_expect(!(attr1->product != attr2->product), 0
) ? __assert_rtn(__func__, "input.c", 1111, "attr1->product != attr2->product"
) : (void)0)
;
1112 assert(strcmp(attr1->product, attr2->product) == 0)(__builtin_expect(!(strcmp(attr1->product, attr2->product
) == 0), 0) ? __assert_rtn(__func__, "input.c", 1112, "strcmp(attr1->product, attr2->product) == 0"
) : (void)0)
;
1113 }
1114 else
1115 assert(attr2->product == NULL)(__builtin_expect(!(attr2->product == ((void*)0)), 0) ? __assert_rtn
(__func__, "input.c", 1115, "attr2->product == NULL") : (void
)0)
;
1116
1117 if (attr1->vendor != NULL((void*)0)) {
1118 assert(attr1->vendor != attr2->vendor)(__builtin_expect(!(attr1->vendor != attr2->vendor), 0)
? __assert_rtn(__func__, "input.c", 1118, "attr1->vendor != attr2->vendor"
) : (void)0)
;
1119 assert(strcmp(attr1->vendor, attr2->vendor) == 0)(__builtin_expect(!(strcmp(attr1->vendor, attr2->vendor
) == 0), 0) ? __assert_rtn(__func__, "input.c", 1119, "strcmp(attr1->vendor, attr2->vendor) == 0"
) : (void)0)
;
1120 }
1121 else
1122 assert(attr2->vendor == NULL)(__builtin_expect(!(attr2->vendor == ((void*)0)), 0) ? __assert_rtn
(__func__, "input.c", 1122, "attr2->vendor == NULL") : (void
)0)
;
1123
1124 if (attr1->device != NULL((void*)0)) {
1125 assert(attr1->device != attr2->device)(__builtin_expect(!(attr1->device != attr2->device), 0)
? __assert_rtn(__func__, "input.c", 1125, "attr1->device != attr2->device"
) : (void)0)
;
1126 assert(strcmp(attr1->device, attr2->device) == 0)(__builtin_expect(!(strcmp(attr1->device, attr2->device
) == 0), 0) ? __assert_rtn(__func__, "input.c", 1126, "strcmp(attr1->device, attr2->device) == 0"
) : (void)0)
;
1127 }
1128 else
1129 assert(attr2->device == NULL)(__builtin_expect(!(attr2->device == ((void*)0)), 0) ? __assert_rtn
(__func__, "input.c", 1129, "attr2->device == NULL") : (void
)0)
;
1130
1131 if (attr1->pnp_id != NULL((void*)0)) {
1132 assert(attr1->pnp_id != attr2->pnp_id)(__builtin_expect(!(attr1->pnp_id != attr2->pnp_id), 0)
? __assert_rtn(__func__, "input.c", 1132, "attr1->pnp_id != attr2->pnp_id"
) : (void)0)
;
1133 assert(strcmp(attr1->pnp_id, attr2->pnp_id) == 0)(__builtin_expect(!(strcmp(attr1->pnp_id, attr2->pnp_id
) == 0), 0) ? __assert_rtn(__func__, "input.c", 1133, "strcmp(attr1->pnp_id, attr2->pnp_id) == 0"
) : (void)0)
;
1134 }
1135 else
1136 assert(attr2->pnp_id == NULL)(__builtin_expect(!(attr2->pnp_id == ((void*)0)), 0) ? __assert_rtn
(__func__, "input.c", 1136, "attr2->pnp_id == NULL") : (void
)0)
;
1137
1138 if (attr1->usb_id != NULL((void*)0)) {
1139 assert(attr1->usb_id != attr2->usb_id)(__builtin_expect(!(attr1->usb_id != attr2->usb_id), 0)
? __assert_rtn(__func__, "input.c", 1139, "attr1->usb_id != attr2->usb_id"
) : (void)0)
;
1140 assert(strcmp(attr1->usb_id, attr2->usb_id) == 0)(__builtin_expect(!(strcmp(attr1->usb_id, attr2->usb_id
) == 0), 0) ? __assert_rtn(__func__, "input.c", 1140, "strcmp(attr1->usb_id, attr2->usb_id) == 0"
) : (void)0)
;
1141 }
1142 else
1143 assert(attr2->usb_id == NULL)(__builtin_expect(!(attr2->usb_id == ((void*)0)), 0) ? __assert_rtn
(__func__, "input.c", 1143, "attr2->usb_id == NULL") : (void
)0)
;
1144
1145 tags1 = attr1->tags;
1146 tags2 = attr2->tags;
1147
1148 /* if we don't have any tags, skip the tag checking bits */
1149 if (!tags1) {
1150 assert(!tags2)(__builtin_expect(!(!tags2), 0) ? __assert_rtn(__func__, "input.c"
, 1150, "!tags2") : (void)0)
;
1151 return;
1152 }
1153
1154 /* Don't lug around empty arrays */
1155 assert(*tags1)(__builtin_expect(!(*tags1), 0) ? __assert_rtn(__func__, "input.c"
, 1155, "*tags1") : (void)0)
;
1156 assert(*tags2)(__builtin_expect(!(*tags2), 0) ? __assert_rtn(__func__, "input.c"
, 1156, "*tags2") : (void)0)
;
1157
1158 /* check for identical content, but duplicated */
1159 while (*tags1) {
1160 assert(*tags1 != *tags2)(__builtin_expect(!(*tags1 != *tags2), 0) ? __assert_rtn(__func__
, "input.c", 1160, "*tags1 != *tags2") : (void)0)
;
1161 assert(strcmp(*tags1, *tags2) == 0)(__builtin_expect(!(strcmp(*tags1, *tags2) == 0), 0) ? __assert_rtn
(__func__, "input.c", 1161, "strcmp(*tags1, *tags2) == 0") : (
void)0)
;
1162 tags1++;
1163 tags2++;
1164 }
1165
1166 /* ensure tags1 and tags2 have the same no of elements */
1167 assert(!*tags2)(__builtin_expect(!(!*tags2), 0) ? __assert_rtn(__func__, "input.c"
, 1167, "!*tags2") : (void)0)
;
1168
1169 /* check for not sharing memory */
1170 tags1 = attr1->tags;
1171 while (*tags1) {
1172 tags2 = attr2->tags;
1173 while (*tags2)
1174 assert(*tags1 != *tags2++)(__builtin_expect(!(*tags1 != *tags2++), 0) ? __assert_rtn(__func__
, "input.c", 1174, "*tags1 != *tags2++") : (void)0)
;
1175
1176 tags1++;
1177 }
1178}
1179
1180static void
1181dix_input_attributes(void)
1182{
1183 InputAttributes *orig;
1184 InputAttributes *new;
1185
1186 new = DuplicateInputAttributes(NULL((void*)0));
1187 assert(!new)(__builtin_expect(!(!new), 0) ? __assert_rtn(__func__, "input.c"
, 1187, "!new") : (void)0)
;
1188
1189 orig = calloc(1, sizeof(InputAttributes));
1190 assert(orig)(__builtin_expect(!(orig), 0) ? __assert_rtn(__func__, "input.c"
, 1190, "orig") : (void)0)
;
1191
1192 new = DuplicateInputAttributes(orig);
1193 assert(memcmp(orig, new, sizeof(InputAttributes)) == 0)(__builtin_expect(!(memcmp(orig, new, sizeof(InputAttributes)
) == 0), 0) ? __assert_rtn(__func__, "input.c", 1193, "memcmp(orig, new, sizeof(InputAttributes)) == 0"
) : (void)0)
;
1194
1195 orig->product = xnfstrdup("product name")XNFstrdup("product name");
1196 new = DuplicateInputAttributes(orig);
1197 cmp_attr_fields(orig, new);
1198 FreeInputAttributes(new);
1199
1200 orig->vendor = xnfstrdup("vendor name")XNFstrdup("vendor name");
1201 new = DuplicateInputAttributes(orig);
1202 cmp_attr_fields(orig, new);
1203 FreeInputAttributes(new);
1204
1205 orig->device = xnfstrdup("device path")XNFstrdup("device path");
1206 new = DuplicateInputAttributes(orig);
1207 cmp_attr_fields(orig, new);
1208 FreeInputAttributes(new);
1209
1210 orig->pnp_id = xnfstrdup("PnPID")XNFstrdup("PnPID");
1211 new = DuplicateInputAttributes(orig);
1212 cmp_attr_fields(orig, new);
1213 FreeInputAttributes(new);
1214
1215 orig->usb_id = xnfstrdup("USBID")XNFstrdup("USBID");
1216 new = DuplicateInputAttributes(orig);
1217 cmp_attr_fields(orig, new);
1218 FreeInputAttributes(new);
1219
1220 orig->flags = 0xF0;
1221 new = DuplicateInputAttributes(orig);
1222 cmp_attr_fields(orig, new);
1223 FreeInputAttributes(new);
1224
1225 orig->tags = xstrtokenize("tag1 tag2 tag3", " ");
1226 new = DuplicateInputAttributes(orig);
1227 cmp_attr_fields(orig, new);
1228 FreeInputAttributes(new);
1229
1230 FreeInputAttributes(orig);
1231}
1232
1233static void
1234dix_input_valuator_masks(void)
1235{
1236 ValuatorMask *mask = NULL((void*)0), *copy;
1237 int nvaluators = MAX_VALUATORS36;
1238 double valuators[nvaluators];
1239 int val_ranged[nvaluators];
1240 int i;
1241 int first_val, num_vals;
1242
1243 for (i = 0; i < nvaluators; i++) {
1244 valuators[i] = i + 0.5;
1245 val_ranged[i] = i;
1246 }
1247
1248 mask = valuator_mask_new(nvaluators);
1249 assert(mask != NULL)(__builtin_expect(!(mask != ((void*)0)), 0) ? __assert_rtn(__func__
, "input.c", 1249, "mask != NULL") : (void)0)
;
1250 assert(valuator_mask_size(mask) == 0)(__builtin_expect(!(valuator_mask_size(mask) == 0), 0) ? __assert_rtn
(__func__, "input.c", 1250, "valuator_mask_size(mask) == 0") :
(void)0)
;
1251 assert(valuator_mask_num_valuators(mask) == 0)(__builtin_expect(!(valuator_mask_num_valuators(mask) == 0), 0
) ? __assert_rtn(__func__, "input.c", 1251, "valuator_mask_num_valuators(mask) == 0"
) : (void)0)
;
1252
1253 for (i = 0; i < nvaluators; i++) {
1254 assert(!valuator_mask_isset(mask, i))(__builtin_expect(!(!valuator_mask_isset(mask, i)), 0) ? __assert_rtn
(__func__, "input.c", 1254, "!valuator_mask_isset(mask, i)") :
(void)0)
;
1255 valuator_mask_set_double(mask, i, valuators[i]);
1256 assert(valuator_mask_isset(mask, i))(__builtin_expect(!(valuator_mask_isset(mask, i)), 0) ? __assert_rtn
(__func__, "input.c", 1256, "valuator_mask_isset(mask, i)") :
(void)0)
;
1257 assert(valuator_mask_get(mask, i) == trunc(valuators[i]))(__builtin_expect(!(valuator_mask_get(mask, i) == trunc(valuators
[i])), 0) ? __assert_rtn(__func__, "input.c", 1257, "valuator_mask_get(mask, i) == trunc(valuators[i])"
) : (void)0)
;
1258 assert(valuator_mask_get_double(mask, i) == valuators[i])(__builtin_expect(!(valuator_mask_get_double(mask, i) == valuators
[i]), 0) ? __assert_rtn(__func__, "input.c", 1258, "valuator_mask_get_double(mask, i) == valuators[i]"
) : (void)0)
;
1259 assert(valuator_mask_size(mask) == i + 1)(__builtin_expect(!(valuator_mask_size(mask) == i + 1), 0) ? __assert_rtn
(__func__, "input.c", 1259, "valuator_mask_size(mask) == i + 1"
) : (void)0)
;
1260 assert(valuator_mask_num_valuators(mask) == i + 1)(__builtin_expect(!(valuator_mask_num_valuators(mask) == i + 1
), 0) ? __assert_rtn(__func__, "input.c", 1260, "valuator_mask_num_valuators(mask) == i + 1"
) : (void)0)
;
1261 }
1262
1263 for (i = 0; i < nvaluators; i++) {
1264 assert(valuator_mask_isset(mask, i))(__builtin_expect(!(valuator_mask_isset(mask, i)), 0) ? __assert_rtn
(__func__, "input.c", 1264, "valuator_mask_isset(mask, i)") :
(void)0)
;
1265 valuator_mask_unset(mask, i);
1266 /* we're removing valuators from the front, so size should stay the
1267 * same until the last bit is removed */
1268 if (i < nvaluators - 1)
1269 assert(valuator_mask_size(mask) == nvaluators)(__builtin_expect(!(valuator_mask_size(mask) == nvaluators), 0
) ? __assert_rtn(__func__, "input.c", 1269, "valuator_mask_size(mask) == nvaluators"
) : (void)0)
;
1270 assert(!valuator_mask_isset(mask, i))(__builtin_expect(!(!valuator_mask_isset(mask, i)), 0) ? __assert_rtn
(__func__, "input.c", 1270, "!valuator_mask_isset(mask, i)") :
(void)0)
;
1271 }
1272
1273 assert(valuator_mask_size(mask) == 0)(__builtin_expect(!(valuator_mask_size(mask) == 0), 0) ? __assert_rtn
(__func__, "input.c", 1273, "valuator_mask_size(mask) == 0") :
(void)0)
;
1274 valuator_mask_zero(mask);
1275 assert(valuator_mask_size(mask) == 0)(__builtin_expect(!(valuator_mask_size(mask) == 0), 0) ? __assert_rtn
(__func__, "input.c", 1275, "valuator_mask_size(mask) == 0") :
(void)0)
;
1276 assert(valuator_mask_num_valuators(mask) == 0)(__builtin_expect(!(valuator_mask_num_valuators(mask) == 0), 0
) ? __assert_rtn(__func__, "input.c", 1276, "valuator_mask_num_valuators(mask) == 0"
) : (void)0)
;
1277 for (i = 0; i < nvaluators; i++)
1278 assert(!valuator_mask_isset(mask, i))(__builtin_expect(!(!valuator_mask_isset(mask, i)), 0) ? __assert_rtn
(__func__, "input.c", 1278, "!valuator_mask_isset(mask, i)") :
(void)0)
;
1279
1280 first_val = 5;
1281 num_vals = 6;
1282
1283 valuator_mask_set_range(mask, first_val, num_vals, val_ranged);
1284 assert(valuator_mask_size(mask) == first_val + num_vals)(__builtin_expect(!(valuator_mask_size(mask) == first_val + num_vals
), 0) ? __assert_rtn(__func__, "input.c", 1284, "valuator_mask_size(mask) == first_val + num_vals"
) : (void)0)
;
1285 assert(valuator_mask_num_valuators(mask) == num_vals)(__builtin_expect(!(valuator_mask_num_valuators(mask) == num_vals
), 0) ? __assert_rtn(__func__, "input.c", 1285, "valuator_mask_num_valuators(mask) == num_vals"
) : (void)0)
;
1286 for (i = 0; i < nvaluators; i++) {
1287 double val;
1288
1289 if (i < first_val || i >= first_val + num_vals) {
1290 assert(!valuator_mask_isset(mask, i))(__builtin_expect(!(!valuator_mask_isset(mask, i)), 0) ? __assert_rtn
(__func__, "input.c", 1290, "!valuator_mask_isset(mask, i)") :
(void)0)
;
1291 assert(!valuator_mask_fetch_double(mask, i, &val))(__builtin_expect(!(!valuator_mask_fetch_double(mask, i, &
val)), 0) ? __assert_rtn(__func__, "input.c", 1291, "!valuator_mask_fetch_double(mask, i, &val)"
) : (void)0)
;
1292 }
1293 else {
1294 assert(valuator_mask_isset(mask, i))(__builtin_expect(!(valuator_mask_isset(mask, i)), 0) ? __assert_rtn
(__func__, "input.c", 1294, "valuator_mask_isset(mask, i)") :
(void)0)
;
1295 assert(valuator_mask_get(mask, i) == val_ranged[i - first_val])(__builtin_expect(!(valuator_mask_get(mask, i) == val_ranged[
i - first_val]), 0) ? __assert_rtn(__func__, "input.c", 1295,
"valuator_mask_get(mask, i) == val_ranged[i - first_val]") :
(void)0)
;
1296 assert(valuator_mask_get_double(mask, i) ==(__builtin_expect(!(valuator_mask_get_double(mask, i) == val_ranged
[i - first_val]), 0) ? __assert_rtn(__func__, "input.c", 1297
, "valuator_mask_get_double(mask, i) == val_ranged[i - first_val]"
) : (void)0)
1297 val_ranged[i - first_val])(__builtin_expect(!(valuator_mask_get_double(mask, i) == val_ranged
[i - first_val]), 0) ? __assert_rtn(__func__, "input.c", 1297
, "valuator_mask_get_double(mask, i) == val_ranged[i - first_val]"
) : (void)0)
;
1298 assert(valuator_mask_fetch_double(mask, i, &val))(__builtin_expect(!(valuator_mask_fetch_double(mask, i, &
val)), 0) ? __assert_rtn(__func__, "input.c", 1298, "valuator_mask_fetch_double(mask, i, &val)"
) : (void)0)
;
1299 assert(val_ranged[i - first_val] == val)(__builtin_expect(!(val_ranged[i - first_val] == val), 0) ? __assert_rtn
(__func__, "input.c", 1299, "val_ranged[i - first_val] == val"
) : (void)0)
;
1300 }
1301 }
1302
1303 copy = valuator_mask_new(nvaluators);
1304 valuator_mask_copy(copy, mask);
1305 assert(mask != copy)(__builtin_expect(!(mask != copy), 0) ? __assert_rtn(__func__
, "input.c", 1305, "mask != copy") : (void)0)
;
1306 assert(valuator_mask_size(mask) == valuator_mask_size(copy))(__builtin_expect(!(valuator_mask_size(mask) == valuator_mask_size
(copy)), 0) ? __assert_rtn(__func__, "input.c", 1306, "valuator_mask_size(mask) == valuator_mask_size(copy)"
) : (void)0)
;
1307 assert(valuator_mask_num_valuators(mask) ==(__builtin_expect(!(valuator_mask_num_valuators(mask) == valuator_mask_num_valuators
(copy)), 0) ? __assert_rtn(__func__, "input.c", 1308, "valuator_mask_num_valuators(mask) == valuator_mask_num_valuators(copy)"
) : (void)0)
1308 valuator_mask_num_valuators(copy))(__builtin_expect(!(valuator_mask_num_valuators(mask) == valuator_mask_num_valuators
(copy)), 0) ? __assert_rtn(__func__, "input.c", 1308, "valuator_mask_num_valuators(mask) == valuator_mask_num_valuators(copy)"
) : (void)0)
;
1309
1310 for (i = 0; i < nvaluators; i++) {
1311 double a, b;
1312
1313 assert(valuator_mask_isset(mask, i) == valuator_mask_isset(copy, i))(__builtin_expect(!(valuator_mask_isset(mask, i) == valuator_mask_isset
(copy, i)), 0) ? __assert_rtn(__func__, "input.c", 1313, "valuator_mask_isset(mask, i) == valuator_mask_isset(copy, i)"
) : (void)0)
;
1314
1315 if (!valuator_mask_isset(mask, i))
1316 continue;
1317
1318 assert(valuator_mask_get(mask, i) == valuator_mask_get(copy, i))(__builtin_expect(!(valuator_mask_get(mask, i) == valuator_mask_get
(copy, i)), 0) ? __assert_rtn(__func__, "input.c", 1318, "valuator_mask_get(mask, i) == valuator_mask_get(copy, i)"
) : (void)0)
;
1319 assert(valuator_mask_get_double(mask, i) ==(__builtin_expect(!(valuator_mask_get_double(mask, i) == valuator_mask_get_double
(copy, i)), 0) ? __assert_rtn(__func__, "input.c", 1320, "valuator_mask_get_double(mask, i) == valuator_mask_get_double(copy, i)"
) : (void)0)
1320 valuator_mask_get_double(copy, i))(__builtin_expect(!(valuator_mask_get_double(mask, i) == valuator_mask_get_double
(copy, i)), 0) ? __assert_rtn(__func__, "input.c", 1320, "valuator_mask_get_double(mask, i) == valuator_mask_get_double(copy, i)"
) : (void)0)
;
1321 assert(valuator_mask_fetch_double(mask, i, &a))(__builtin_expect(!(valuator_mask_fetch_double(mask, i, &
a)), 0) ? __assert_rtn(__func__, "input.c", 1321, "valuator_mask_fetch_double(mask, i, &a)"
) : (void)0)
;
1322 assert(valuator_mask_fetch_double(copy, i, &b))(__builtin_expect(!(valuator_mask_fetch_double(copy, i, &
b)), 0) ? __assert_rtn(__func__, "input.c", 1322, "valuator_mask_fetch_double(copy, i, &b)"
) : (void)0)
;
1323 assert(a == b)(__builtin_expect(!(a == b), 0) ? __assert_rtn(__func__, "input.c"
, 1323, "a == b") : (void)0)
;
1324 }
1325
1326 valuator_mask_free(&mask);
1327 assert(mask == NULL)(__builtin_expect(!(mask == ((void*)0)), 0) ? __assert_rtn(__func__
, "input.c", 1327, "mask == NULL") : (void)0)
;
1328}
1329
1330static void
1331dix_valuator_mode(void)
1332{
1333 DeviceIntRec dev;
1334 const int num_axes = MAX_VALUATORS36;
1335 int i;
1336 Atom atoms[MAX_VALUATORS36] = { 0 };
1337
1338 memset(&dev, 0, sizeof(DeviceIntRec))__builtin___memset_chk (&dev, 0, sizeof(DeviceIntRec), __builtin_object_size
(&dev, 0))
;
1339 dev.type = MASTER_POINTER1; /* claim it's a master to stop ptracccel */
1340
1341 assert(InitValuatorClassDeviceStruct(NULL, 0, atoms, 0, 0) == FALSE)(__builtin_expect(!(InitValuatorClassDeviceStruct(((void*)0),
0, atoms, 0, 0) == 0), 0) ? __assert_rtn(__func__, "input.c"
, 1341, "InitValuatorClassDeviceStruct(NULL, 0, atoms, 0, 0) == FALSE"
) : (void)0)
;
1342 assert(InitValuatorClassDeviceStruct(&dev, num_axes, atoms, 0, Absolute))(__builtin_expect(!(InitValuatorClassDeviceStruct(&dev, num_axes
, atoms, 0, 1)), 0) ? __assert_rtn(__func__, "input.c", 1342,
"InitValuatorClassDeviceStruct(&dev, num_axes, atoms, 0, Absolute)"
) : (void)0)
;
1343
1344 for (i = 0; i < num_axes; i++) {
1345 assert(valuator_get_mode(&dev, i) == Absolute)(__builtin_expect(!(valuator_get_mode(&dev, i) == 1), 0) ?
__assert_rtn(__func__, "input.c", 1345, "valuator_get_mode(&dev, i) == Absolute"
) : (void)0)
;
1346 valuator_set_mode(&dev, i, Relative0);
1347 assert(dev.valuator->axes[i].mode == Relative)(__builtin_expect(!(dev.valuator->axes[i].mode == 0), 0) ?
__assert_rtn(__func__, "input.c", 1347, "dev.valuator->axes[i].mode == Relative"
) : (void)0)
;
1348 assert(valuator_get_mode(&dev, i) == Relative)(__builtin_expect(!(valuator_get_mode(&dev, i) == 0), 0) ?
__assert_rtn(__func__, "input.c", 1348, "valuator_get_mode(&dev, i) == Relative"
) : (void)0)
;
1349 }
1350
1351 valuator_set_mode(&dev, VALUATOR_MODE_ALL_AXES-1, Absolute1);
1352 for (i = 0; i < num_axes; i++)
1353 assert(valuator_get_mode(&dev, i) == Absolute)(__builtin_expect(!(valuator_get_mode(&dev, i) == 1), 0) ?
__assert_rtn(__func__, "input.c", 1353, "valuator_get_mode(&dev, i) == Absolute"
) : (void)0)
;
1354
1355 valuator_set_mode(&dev, VALUATOR_MODE_ALL_AXES-1, Relative0);
1356 for (i = 0; i < num_axes; i++)
1357 assert(valuator_get_mode(&dev, i) == Relative)(__builtin_expect(!(valuator_get_mode(&dev, i) == 0), 0) ?
__assert_rtn(__func__, "input.c", 1357, "valuator_get_mode(&dev, i) == Relative"
) : (void)0)
;
1358}
1359
1360static void
1361dix_input_valuator_masks_unaccel(void)
1362{
1363 ValuatorMask *mask = NULL((void*)0);
1364 double x, ux;
1365
1366 /* set mask normally */
1367 mask = valuator_mask_new(MAX_VALUATORS36);
1368 assert(!valuator_mask_has_unaccelerated(mask))(__builtin_expect(!(!valuator_mask_has_unaccelerated(mask)), 0
) ? __assert_rtn(__func__, "input.c", 1368, "!valuator_mask_has_unaccelerated(mask)"
) : (void)0)
;
1369 valuator_mask_set_double(mask, 0, 1.0);
1370 assert(!valuator_mask_has_unaccelerated(mask))(__builtin_expect(!(!valuator_mask_has_unaccelerated(mask)), 0
) ? __assert_rtn(__func__, "input.c", 1370, "!valuator_mask_has_unaccelerated(mask)"
) : (void)0)
;
1371 valuator_mask_unset(mask, 0);
1372 assert(!valuator_mask_has_unaccelerated(mask))(__builtin_expect(!(!valuator_mask_has_unaccelerated(mask)), 0
) ? __assert_rtn(__func__, "input.c", 1372, "!valuator_mask_has_unaccelerated(mask)"
) : (void)0)
;
1373
1374 /* all unset, now set accel mask */
1375 valuator_mask_set_unaccelerated(mask, 0, 1.0, 2.0);
1376 assert(valuator_mask_has_unaccelerated(mask))(__builtin_expect(!(valuator_mask_has_unaccelerated(mask)), 0
) ? __assert_rtn(__func__, "input.c", 1376, "valuator_mask_has_unaccelerated(mask)"
) : (void)0)
;
1377 assert(valuator_mask_isset(mask, 0))(__builtin_expect(!(valuator_mask_isset(mask, 0)), 0) ? __assert_rtn
(__func__, "input.c", 1377, "valuator_mask_isset(mask, 0)") :
(void)0)
;
1378 assert(!valuator_mask_isset(mask, 1))(__builtin_expect(!(!valuator_mask_isset(mask, 1)), 0) ? __assert_rtn
(__func__, "input.c", 1378, "!valuator_mask_isset(mask, 1)") :
(void)0)
;
1379 assert(valuator_mask_get_accelerated(mask, 0) == 1.0)(__builtin_expect(!(valuator_mask_get_accelerated(mask, 0) ==
1.0), 0) ? __assert_rtn(__func__, "input.c", 1379, "valuator_mask_get_accelerated(mask, 0) == 1.0"
) : (void)0)
;
1380 assert(valuator_mask_get_unaccelerated(mask, 0) == 2.0)(__builtin_expect(!(valuator_mask_get_unaccelerated(mask, 0) ==
2.0), 0) ? __assert_rtn(__func__, "input.c", 1380, "valuator_mask_get_unaccelerated(mask, 0) == 2.0"
) : (void)0)
;
1381 assert(valuator_mask_fetch_unaccelerated(mask, 0, &x, &ux))(__builtin_expect(!(valuator_mask_fetch_unaccelerated(mask, 0
, &x, &ux)), 0) ? __assert_rtn(__func__, "input.c", 1381
, "valuator_mask_fetch_unaccelerated(mask, 0, &x, &ux)"
) : (void)0)
;
1382 assert(x == 1.0)(__builtin_expect(!(x == 1.0), 0) ? __assert_rtn(__func__, "input.c"
, 1382, "x == 1.0") : (void)0)
;
1383 assert(ux == 2.0)(__builtin_expect(!(ux == 2.0), 0) ? __assert_rtn(__func__, "input.c"
, 1383, "ux == 2.0") : (void)0)
;
1384 x = 0xff;
1385 ux = 0xfe;
1386 assert(!valuator_mask_fetch_unaccelerated(mask, 1, &x, &ux))(__builtin_expect(!(!valuator_mask_fetch_unaccelerated(mask, 1
, &x, &ux)), 0) ? __assert_rtn(__func__, "input.c", 1386
, "!valuator_mask_fetch_unaccelerated(mask, 1, &x, &ux)"
) : (void)0)
;
1387 assert(x == 0xff)(__builtin_expect(!(x == 0xff), 0) ? __assert_rtn(__func__, "input.c"
, 1387, "x == 0xff") : (void)0)
;
1388 assert(ux == 0xfe)(__builtin_expect(!(ux == 0xfe), 0) ? __assert_rtn(__func__, "input.c"
, 1388, "ux == 0xfe") : (void)0)
;
1389
1390 /* all unset, now set normally again */
1391 valuator_mask_unset(mask, 0);
1392 assert(!valuator_mask_has_unaccelerated(mask))(__builtin_expect(!(!valuator_mask_has_unaccelerated(mask)), 0
) ? __assert_rtn(__func__, "input.c", 1392, "!valuator_mask_has_unaccelerated(mask)"
) : (void)0)
;
1393 assert(!valuator_mask_isset(mask, 0))(__builtin_expect(!(!valuator_mask_isset(mask, 0)), 0) ? __assert_rtn
(__func__, "input.c", 1393, "!valuator_mask_isset(mask, 0)") :
(void)0)
;
1394 valuator_mask_set_double(mask, 0, 1.0);
1395 assert(!valuator_mask_has_unaccelerated(mask))(__builtin_expect(!(!valuator_mask_has_unaccelerated(mask)), 0
) ? __assert_rtn(__func__, "input.c", 1395, "!valuator_mask_has_unaccelerated(mask)"
) : (void)0)
;
1396 valuator_mask_unset(mask, 0);
1397 assert(!valuator_mask_has_unaccelerated(mask))(__builtin_expect(!(!valuator_mask_has_unaccelerated(mask)), 0
) ? __assert_rtn(__func__, "input.c", 1397, "!valuator_mask_has_unaccelerated(mask)"
) : (void)0)
;
1398
1399 valuator_mask_zero(mask);
1400 assert(!valuator_mask_has_unaccelerated(mask))(__builtin_expect(!(!valuator_mask_has_unaccelerated(mask)), 0
) ? __assert_rtn(__func__, "input.c", 1400, "!valuator_mask_has_unaccelerated(mask)"
) : (void)0)
;
1401
1402 valuator_mask_set_unaccelerated(mask, 0, 1.0, 2.0);
1403 valuator_mask_set_unaccelerated(mask, 1, 3.0, 4.5);
1404 assert(valuator_mask_isset(mask, 0))(__builtin_expect(!(valuator_mask_isset(mask, 0)), 0) ? __assert_rtn
(__func__, "input.c", 1404, "valuator_mask_isset(mask, 0)") :
(void)0)
;
1405 assert(valuator_mask_isset(mask, 1))(__builtin_expect(!(valuator_mask_isset(mask, 1)), 0) ? __assert_rtn
(__func__, "input.c", 1405, "valuator_mask_isset(mask, 1)") :
(void)0)
;
1406 assert(!valuator_mask_isset(mask, 2))(__builtin_expect(!(!valuator_mask_isset(mask, 2)), 0) ? __assert_rtn
(__func__, "input.c", 1406, "!valuator_mask_isset(mask, 2)") :
(void)0)
;
1407 assert(valuator_mask_has_unaccelerated(mask))(__builtin_expect(!(valuator_mask_has_unaccelerated(mask)), 0
) ? __assert_rtn(__func__, "input.c", 1407, "valuator_mask_has_unaccelerated(mask)"
) : (void)0)
;
1408 assert(valuator_mask_get_accelerated(mask, 0) == 1.0)(__builtin_expect(!(valuator_mask_get_accelerated(mask, 0) ==
1.0), 0) ? __assert_rtn(__func__, "input.c", 1408, "valuator_mask_get_accelerated(mask, 0) == 1.0"
) : (void)0)
;
1409 assert(valuator_mask_get_accelerated(mask, 1) == 3.0)(__builtin_expect(!(valuator_mask_get_accelerated(mask, 1) ==
3.0), 0) ? __assert_rtn(__func__, "input.c", 1409, "valuator_mask_get_accelerated(mask, 1) == 3.0"
) : (void)0)
;
1410 assert(valuator_mask_get_unaccelerated(mask, 0) == 2.0)(__builtin_expect(!(valuator_mask_get_unaccelerated(mask, 0) ==
2.0), 0) ? __assert_rtn(__func__, "input.c", 1410, "valuator_mask_get_unaccelerated(mask, 0) == 2.0"
) : (void)0)
;
1411 assert(valuator_mask_get_unaccelerated(mask, 1) == 4.5)(__builtin_expect(!(valuator_mask_get_unaccelerated(mask, 1) ==
4.5), 0) ? __assert_rtn(__func__, "input.c", 1411, "valuator_mask_get_unaccelerated(mask, 1) == 4.5"
) : (void)0)
;
1412 assert(valuator_mask_fetch_unaccelerated(mask, 0, &x, &ux))(__builtin_expect(!(valuator_mask_fetch_unaccelerated(mask, 0
, &x, &ux)), 0) ? __assert_rtn(__func__, "input.c", 1412
, "valuator_mask_fetch_unaccelerated(mask, 0, &x, &ux)"
) : (void)0)
;
1413 assert(x == 1.0)(__builtin_expect(!(x == 1.0), 0) ? __assert_rtn(__func__, "input.c"
, 1413, "x == 1.0") : (void)0)
;
1414 assert(ux == 2.0)(__builtin_expect(!(ux == 2.0), 0) ? __assert_rtn(__func__, "input.c"
, 1414, "ux == 2.0") : (void)0)
;
1415 assert(valuator_mask_fetch_unaccelerated(mask, 1, &x, &ux))(__builtin_expect(!(valuator_mask_fetch_unaccelerated(mask, 1
, &x, &ux)), 0) ? __assert_rtn(__func__, "input.c", 1415
, "valuator_mask_fetch_unaccelerated(mask, 1, &x, &ux)"
) : (void)0)
;
1416 assert(x == 3.0)(__builtin_expect(!(x == 3.0), 0) ? __assert_rtn(__func__, "input.c"
, 1416, "x == 3.0") : (void)0)
;
1417 assert(ux == 4.5)(__builtin_expect(!(ux == 4.5), 0) ? __assert_rtn(__func__, "input.c"
, 1417, "ux == 4.5") : (void)0)
;
1418
1419 valuator_mask_free(&mask);
1420}
1421
1422static void
1423include_bit_test_macros(void)
1424{
1425 uint8_t mask[9] = { 0 };
1426 int i;
1427
1428 for (i = 0; i < sizeof(mask) / sizeof(mask[0]); i++) {
1429 assert(BitIsOn(mask, i) == 0)(__builtin_expect(!((!!(((const BYTE *) (mask))[(i)>>3]
& (1 << ((i) & 7)))) == 0), 0) ? __assert_rtn(
__func__, "input.c", 1429, "BitIsOn(mask, i) == 0") : (void)0
)
;
1430 SetBit(mask, i)(((BYTE *) (mask))[(i)>>3] |= (1 << ((i) & 7)
))
;
1431 assert(BitIsOn(mask, i) == 1)(__builtin_expect(!((!!(((const BYTE *) (mask))[(i)>>3]
& (1 << ((i) & 7)))) == 1), 0) ? __assert_rtn(
__func__, "input.c", 1431, "BitIsOn(mask, i) == 1") : (void)0
)
;
1432 assert(! !(mask[i / 8] & (1 << (i % 8))))(__builtin_expect(!(! !(mask[i / 8] & (1 << (i % 8)
))), 0) ? __assert_rtn(__func__, "input.c", 1432, "! !(mask[i / 8] & (1 << (i % 8)))"
) : (void)0)
;
1433 assert(CountBits(mask, sizeof(mask)) == 1)(__builtin_expect(!(CountBits(mask, sizeof(mask)) == 1), 0) ?
__assert_rtn(__func__, "input.c", 1433, "CountBits(mask, sizeof(mask)) == 1"
) : (void)0)
;
1434 ClearBit(mask, i)(((BYTE *)(mask))[(i)>>3] &= ~(1 << ((i) &
7)))
;
1435 assert(BitIsOn(mask, i) == 0)(__builtin_expect(!((!!(((const BYTE *) (mask))[(i)>>3]
& (1 << ((i) & 7)))) == 0), 0) ? __assert_rtn(
__func__, "input.c", 1435, "BitIsOn(mask, i) == 0") : (void)0
)
;
1436 }
1437}
1438
1439/**
1440 * Ensure that val->axisVal and val->axes are aligned on doubles.
1441 */
1442static void
1443dix_valuator_alloc(void)
1444{
1445 ValuatorClassPtr v = NULL((void*)0);
1446 int num_axes = 0;
1447
1448 while (num_axes < 5) {
1449 v = AllocValuatorClass(v, num_axes);
1450
1451 assert(v)(__builtin_expect(!(v), 0) ? __assert_rtn(__func__, "input.c"
, 1451, "v") : (void)0)
;
1452 assert(v->numAxes == num_axes)(__builtin_expect(!(v->numAxes == num_axes), 0) ? __assert_rtn
(__func__, "input.c", 1452, "v->numAxes == num_axes") : (void
)0)
;
1453#if !defined(__i386__) && !defined(__m68k__) && !defined(__sh__)
1454 /* must be double-aligned on 64 bit */
1455 assert(offsetof(struct _ValuatorClassRec, axisVal) % sizeof(double) == 0)(__builtin_expect(!(__builtin_offsetof(struct _ValuatorClassRec
, axisVal) % sizeof(double) == 0), 0) ? __assert_rtn(__func__
, "input.c", 1455, "offsetof(struct _ValuatorClassRec, axisVal) % sizeof(double) == 0"
) : (void)0)
;
1456 assert(offsetof(struct _ValuatorClassRec, axes) % sizeof(double) == 0)(__builtin_expect(!(__builtin_offsetof(struct _ValuatorClassRec
, axes) % sizeof(double) == 0), 0) ? __assert_rtn(__func__, "input.c"
, 1456, "offsetof(struct _ValuatorClassRec, axes) % sizeof(double) == 0"
) : (void)0)
;
1457#endif
1458 num_axes++;
1459 }
1460
1461 free(v);
1462}
1463
1464static void
1465dix_get_master(void)
1466{
1467 DeviceIntRec vcp, vck;
1468 DeviceIntRec ptr, kbd;
1469 DeviceIntRec floating;
1470 SpriteInfoRec vcp_sprite, vck_sprite;
1471 SpriteInfoRec ptr_sprite, kbd_sprite;
1472 SpriteInfoRec floating_sprite;
1473
1474 memset(&vcp, 0, sizeof(vcp))__builtin___memset_chk (&vcp, 0, sizeof(vcp), __builtin_object_size
(&vcp, 0))
;
1475 memset(&vck, 0, sizeof(vck))__builtin___memset_chk (&vck, 0, sizeof(vck), __builtin_object_size
(&vck, 0))
;
1476 memset(&ptr, 0, sizeof(ptr))__builtin___memset_chk (&ptr, 0, sizeof(ptr), __builtin_object_size
(&ptr, 0))
;
1477 memset(&kbd, 0, sizeof(kbd))__builtin___memset_chk (&kbd, 0, sizeof(kbd), __builtin_object_size
(&kbd, 0))
;
1478 memset(&floating, 0, sizeof(floating))__builtin___memset_chk (&floating, 0, sizeof(floating), __builtin_object_size
(&floating, 0))
;
1479
1480 memset(&vcp_sprite, 0, sizeof(vcp_sprite))__builtin___memset_chk (&vcp_sprite, 0, sizeof(vcp_sprite
), __builtin_object_size (&vcp_sprite, 0))
;
1481 memset(&vck_sprite, 0, sizeof(vck_sprite))__builtin___memset_chk (&vck_sprite, 0, sizeof(vck_sprite
), __builtin_object_size (&vck_sprite, 0))
;
1482 memset(&ptr_sprite, 0, sizeof(ptr_sprite))__builtin___memset_chk (&ptr_sprite, 0, sizeof(ptr_sprite
), __builtin_object_size (&ptr_sprite, 0))
;
1483 memset(&kbd_sprite, 0, sizeof(kbd_sprite))__builtin___memset_chk (&kbd_sprite, 0, sizeof(kbd_sprite
), __builtin_object_size (&kbd_sprite, 0))
;
1484 memset(&floating_sprite, 0, sizeof(floating_sprite))__builtin___memset_chk (&floating_sprite, 0, sizeof(floating_sprite
), __builtin_object_size (&floating_sprite, 0))
;
1485
1486 vcp.type = MASTER_POINTER1;
1487 vck.type = MASTER_KEYBOARD2;
1488 ptr.type = SLAVE3;
1489 kbd.type = SLAVE3;
1490 floating.type = SLAVE3;
1491
1492 vcp.spriteInfo = &vcp_sprite;
1493 vck.spriteInfo = &vck_sprite;
1494 ptr.spriteInfo = &ptr_sprite;
1495 kbd.spriteInfo = &kbd_sprite;
1496 floating.spriteInfo = &floating_sprite;
1497
1498 vcp_sprite.paired = &vck;
1499 vck_sprite.paired = &vcp;
1500 ptr_sprite.paired = &vcp;
1501 kbd_sprite.paired = &vck;
1502 floating_sprite.paired = &floating;
1503
1504 vcp_sprite.spriteOwner = TRUE1;
1505 floating_sprite.spriteOwner = TRUE1;
1506
1507 ptr.master = &vcp;
1508 kbd.master = &vck;
1509
1510 assert(GetPairedDevice(&vcp) == &vck)(__builtin_expect(!(GetPairedDevice(&vcp) == &vck), 0
) ? __assert_rtn(__func__, "input.c", 1510, "GetPairedDevice(&vcp) == &vck"
) : (void)0)
;
1511 assert(GetPairedDevice(&vck) == &vcp)(__builtin_expect(!(GetPairedDevice(&vck) == &vcp), 0
) ? __assert_rtn(__func__, "input.c", 1511, "GetPairedDevice(&vck) == &vcp"
) : (void)0)
;
1512 assert(GetMaster(&ptr, MASTER_POINTER) == &vcp)(__builtin_expect(!(GetMaster(&ptr, 1) == &vcp), 0) ?
__assert_rtn(__func__, "input.c", 1512, "GetMaster(&ptr, MASTER_POINTER) == &vcp"
) : (void)0)
;
1513 assert(GetMaster(&ptr, MASTER_KEYBOARD) == &vck)(__builtin_expect(!(GetMaster(&ptr, 2) == &vck), 0) ?
__assert_rtn(__func__, "input.c", 1513, "GetMaster(&ptr, MASTER_KEYBOARD) == &vck"
) : (void)0)
;
1514 assert(GetMaster(&kbd, MASTER_POINTER) == &vcp)(__builtin_expect(!(GetMaster(&kbd, 1) == &vcp), 0) ?
__assert_rtn(__func__, "input.c", 1514, "GetMaster(&kbd, MASTER_POINTER) == &vcp"
) : (void)0)
;
1515 assert(GetMaster(&kbd, MASTER_KEYBOARD) == &vck)(__builtin_expect(!(GetMaster(&kbd, 2) == &vck), 0) ?
__assert_rtn(__func__, "input.c", 1515, "GetMaster(&kbd, MASTER_KEYBOARD) == &vck"
) : (void)0)
;
1516 assert(GetMaster(&ptr, MASTER_ATTACHED) == &vcp)(__builtin_expect(!(GetMaster(&ptr, 4) == &vcp), 0) ?
__assert_rtn(__func__, "input.c", 1516, "GetMaster(&ptr, MASTER_ATTACHED) == &vcp"
) : (void)0)
;
1517 assert(GetMaster(&kbd, MASTER_ATTACHED) == &vck)(__builtin_expect(!(GetMaster(&kbd, 4) == &vck), 0) ?
__assert_rtn(__func__, "input.c", 1517, "GetMaster(&kbd, MASTER_ATTACHED) == &vck"
) : (void)0)
;
1518
1519 assert(GetPairedDevice(&floating) == &floating)(__builtin_expect(!(GetPairedDevice(&floating) == &floating
), 0) ? __assert_rtn(__func__, "input.c", 1519, "GetPairedDevice(&floating) == &floating"
) : (void)0)
;
1520 assert(GetMaster(&floating, MASTER_POINTER) == NULL)(__builtin_expect(!(GetMaster(&floating, 1) == ((void*)0)
), 0) ? __assert_rtn(__func__, "input.c", 1520, "GetMaster(&floating, MASTER_POINTER) == NULL"
) : (void)0)
;
1521 assert(GetMaster(&floating, MASTER_KEYBOARD) == NULL)(__builtin_expect(!(GetMaster(&floating, 2) == ((void*)0)
), 0) ? __assert_rtn(__func__, "input.c", 1521, "GetMaster(&floating, MASTER_KEYBOARD) == NULL"
) : (void)0)
;
1522 assert(GetMaster(&floating, MASTER_ATTACHED) == NULL)(__builtin_expect(!(GetMaster(&floating, 4) == ((void*)0)
), 0) ? __assert_rtn(__func__, "input.c", 1522, "GetMaster(&floating, MASTER_ATTACHED) == NULL"
) : (void)0)
;
1523
1524 assert(GetMaster(&vcp, POINTER_OR_FLOAT) == &vcp)(__builtin_expect(!(GetMaster(&vcp, 6) == &vcp), 0) ?
__assert_rtn(__func__, "input.c", 1524, "GetMaster(&vcp, POINTER_OR_FLOAT) == &vcp"
) : (void)0)
;
1525 assert(GetMaster(&vck, POINTER_OR_FLOAT) == &vcp)(__builtin_expect(!(GetMaster(&vck, 6) == &vcp), 0) ?
__assert_rtn(__func__, "input.c", 1525, "GetMaster(&vck, POINTER_OR_FLOAT) == &vcp"
) : (void)0)
;
1526 assert(GetMaster(&ptr, POINTER_OR_FLOAT) == &vcp)(__builtin_expect(!(GetMaster(&ptr, 6) == &vcp), 0) ?
__assert_rtn(__func__, "input.c", 1526, "GetMaster(&ptr, POINTER_OR_FLOAT) == &vcp"
) : (void)0)
;
1527 assert(GetMaster(&kbd, POINTER_OR_FLOAT) == &vcp)(__builtin_expect(!(GetMaster(&kbd, 6) == &vcp), 0) ?
__assert_rtn(__func__, "input.c", 1527, "GetMaster(&kbd, POINTER_OR_FLOAT) == &vcp"
) : (void)0)
;
1528
1529 assert(GetMaster(&vcp, KEYBOARD_OR_FLOAT) == &vck)(__builtin_expect(!(GetMaster(&vcp, 5) == &vck), 0) ?
__assert_rtn(__func__, "input.c", 1529, "GetMaster(&vcp, KEYBOARD_OR_FLOAT) == &vck"
) : (void)0)
;
1530 assert(GetMaster(&vck, KEYBOARD_OR_FLOAT) == &vck)(__builtin_expect(!(GetMaster(&vck, 5) == &vck), 0) ?
__assert_rtn(__func__, "input.c", 1530, "GetMaster(&vck, KEYBOARD_OR_FLOAT) == &vck"
) : (void)0)
;
1531 assert(GetMaster(&ptr, KEYBOARD_OR_FLOAT) == &vck)(__builtin_expect(!(GetMaster(&ptr, 5) == &vck), 0) ?
__assert_rtn(__func__, "input.c", 1531, "GetMaster(&ptr, KEYBOARD_OR_FLOAT) == &vck"
) : (void)0)
;
1532 assert(GetMaster(&kbd, KEYBOARD_OR_FLOAT) == &vck)(__builtin_expect(!(GetMaster(&kbd, 5) == &vck), 0) ?
__assert_rtn(__func__, "input.c", 1532, "GetMaster(&kbd, KEYBOARD_OR_FLOAT) == &vck"
) : (void)0)
;
1533
1534 assert(GetMaster(&floating, KEYBOARD_OR_FLOAT) == &floating)(__builtin_expect(!(GetMaster(&floating, 5) == &floating
), 0) ? __assert_rtn(__func__, "input.c", 1534, "GetMaster(&floating, KEYBOARD_OR_FLOAT) == &floating"
) : (void)0)
;
1535 assert(GetMaster(&floating, POINTER_OR_FLOAT) == &floating)(__builtin_expect(!(GetMaster(&floating, 6) == &floating
), 0) ? __assert_rtn(__func__, "input.c", 1535, "GetMaster(&floating, POINTER_OR_FLOAT) == &floating"
) : (void)0)
;
1536}
1537
1538static void
1539input_option_test(void)
1540{
1541 InputOption *list = NULL((void*)0);
1542 InputOption *opt;
1543 const char *val;
1544
1545 printf("Testing input_option list interface\n");
1546
1547 list = input_option_new(list, "key", "value");
1548 assert(list)(__builtin_expect(!(list), 0) ? __assert_rtn(__func__, "input.c"
, 1548, "list") : (void)0)
;
1549 opt = input_option_find(list, "key");
1550 val = input_option_get_value(opt);
1551 assert(strcmp(val, "value") == 0)(__builtin_expect(!(strcmp(val, "value") == 0), 0) ? __assert_rtn
(__func__, "input.c", 1551, "strcmp(val, \"value\") == 0") : (
void)0)
;
1552
1553 list = input_option_new(list, "2", "v2");
1554 opt = input_option_find(list, "key");
1555 val = input_option_get_value(opt);
1556 assert(strcmp(val, "value") == 0)(__builtin_expect(!(strcmp(val, "value") == 0), 0) ? __assert_rtn
(__func__, "input.c", 1556, "strcmp(val, \"value\") == 0") : (
void)0)
;
1557
1558 opt = input_option_find(list, "2");
1559 val = input_option_get_value(opt);
1560 assert(strcmp(val, "v2") == 0)(__builtin_expect(!(strcmp(val, "v2") == 0), 0) ? __assert_rtn
(__func__, "input.c", 1560, "strcmp(val, \"v2\") == 0") : (void
)0)
;
1561
1562 list = input_option_new(list, "3", "v3");
1563
1564 /* search, delete */
1565 opt = input_option_find(list, "key");
1566 val = input_option_get_value(opt);
1567 assert(strcmp(val, "value") == 0)(__builtin_expect(!(strcmp(val, "value") == 0), 0) ? __assert_rtn
(__func__, "input.c", 1567, "strcmp(val, \"value\") == 0") : (
void)0)
;
1568 list = input_option_free_element(list, "key");
1569 opt = input_option_find(list, "key");
1570 assert(opt == NULL)(__builtin_expect(!(opt == ((void*)0)), 0) ? __assert_rtn(__func__
, "input.c", 1570, "opt == NULL") : (void)0)
;
1571
1572 opt = input_option_find(list, "2");
1573 val = input_option_get_value(opt);
1574 assert(strcmp(val, "v2") == 0)(__builtin_expect(!(strcmp(val, "v2") == 0), 0) ? __assert_rtn
(__func__, "input.c", 1574, "strcmp(val, \"v2\") == 0") : (void
)0)
;
1575 list = input_option_free_element(list, "2");
1576 opt = input_option_find(list, "2");
1577 assert(opt == NULL)(__builtin_expect(!(opt == ((void*)0)), 0) ? __assert_rtn(__func__
, "input.c", 1577, "opt == NULL") : (void)0)
;
1578
1579 opt = input_option_find(list, "3");
1580 val = input_option_get_value(opt);
1581 assert(strcmp(val, "v3") == 0)(__builtin_expect(!(strcmp(val, "v3") == 0), 0) ? __assert_rtn
(__func__, "input.c", 1581, "strcmp(val, \"v3\") == 0") : (void
)0)
;
1582 list = input_option_free_element(list, "3");
1583 opt = input_option_find(list, "3");
1584 assert(opt == NULL)(__builtin_expect(!(opt == ((void*)0)), 0) ? __assert_rtn(__func__
, "input.c", 1584, "opt == NULL") : (void)0)
;
1585
1586 /* list deletion */
1587 list = input_option_new(list, "1", "v3");
1588 list = input_option_new(list, "2", "v3");
1589 list = input_option_new(list, "3", "v3");
1590 input_option_free_list(&list);
1591
1592 assert(list == NULL)(__builtin_expect(!(list == ((void*)0)), 0) ? __assert_rtn(__func__
, "input.c", 1592, "list == NULL") : (void)0)
;
1593
1594 list = input_option_new(list, "1", "v1");
1595 list = input_option_new(list, "2", "v2");
1596 list = input_option_new(list, "3", "v3");
1597
1598 /* value replacement */
1599 opt = input_option_find(list, "2");
1600 val = input_option_get_value(opt);
1601 assert(strcmp(val, "v2") == 0)(__builtin_expect(!(strcmp(val, "v2") == 0), 0) ? __assert_rtn
(__func__, "input.c", 1601, "strcmp(val, \"v2\") == 0") : (void
)0)
;
1602 input_option_set_value(opt, "foo");
1603 val = input_option_get_value(opt);
1604 assert(strcmp(val, "foo") == 0)(__builtin_expect(!(strcmp(val, "foo") == 0), 0) ? __assert_rtn
(__func__, "input.c", 1604, "strcmp(val, \"foo\") == 0") : (void
)0)
;
1605 opt = input_option_find(list, "2");
1606 val = input_option_get_value(opt);
1607 assert(strcmp(val, "foo") == 0)(__builtin_expect(!(strcmp(val, "foo") == 0), 0) ? __assert_rtn
(__func__, "input.c", 1607, "strcmp(val, \"foo\") == 0") : (void
)0)
;
1608
1609 /* key replacement */
1610 input_option_set_key(opt, "bar");
1611 val = input_option_get_key(opt);
1612 assert(strcmp(val, "bar") == 0)(__builtin_expect(!(strcmp(val, "bar") == 0), 0) ? __assert_rtn
(__func__, "input.c", 1612, "strcmp(val, \"bar\") == 0") : (void
)0)
;
1613 opt = input_option_find(list, "bar");
1614 val = input_option_get_value(opt);
1615 assert(strcmp(val, "foo") == 0)(__builtin_expect(!(strcmp(val, "foo") == 0), 0) ? __assert_rtn
(__func__, "input.c", 1615, "strcmp(val, \"foo\") == 0") : (void
)0)
;
1616
1617 /* value replacement in input_option_new */
1618 list = input_option_new(list, "bar", "foobar");
1619 opt = input_option_find(list, "bar");
1620 val = input_option_get_value(opt);
1621 assert(strcmp(val, "foobar") == 0)(__builtin_expect(!(strcmp(val, "foobar") == 0), 0) ? __assert_rtn
(__func__, "input.c", 1621, "strcmp(val, \"foobar\") == 0") :
(void)0)
;
1622
1623 input_option_free_list(&list);
1624 assert(list == NULL)(__builtin_expect(!(list == ((void*)0)), 0) ? __assert_rtn(__func__
, "input.c", 1624, "list == NULL") : (void)0)
;
1625}
1626
1627static void
1628_test_double_fp16_values(double orig_d)
1629{
1630 FP1616 first_fp16, final_fp16;
1631 double final_d;
1632
1633 if (orig_d > 0x7FFF) {
1634 printf("Test out of range\n");
1635 assert(0)(__builtin_expect(!(0), 0) ? __assert_rtn(__func__, "input.c"
, 1635, "0") : (void)0)
;
1636 }
1637
1638 first_fp16 = double_to_fp1616(orig_d);
1639 final_d = fp1616_to_double(first_fp16);
1640 final_fp16 = double_to_fp1616(final_d);
1641
1642 /* {
1643 * char first_fp16_s[64];
1644 * char final_fp16_s[64];
1645 * snprintf(first_fp16_s, sizeof(first_fp16_s), "%d + %u * 2^-16", (first_fp16 & 0xffff0000) >> 16, first_fp16 & 0xffff);
1646 * snprintf(final_fp16_s, sizeof(final_fp16_s), "%d + %u * 2^-16", (final_fp16 & 0xffff0000) >> 16, final_fp16 & 0xffff);
1647 *
1648 * printf("FP16: original double: %f first fp16: %s, re-encoded double: %f, final fp16: %s\n", orig_d, first_fp16_s, final_d, final_fp16_s);
1649 * }
1650 */
1651
1652 /* since we lose precision, we only do rough range testing */
1653 assert(final_d > orig_d - 0.1)(__builtin_expect(!(final_d > orig_d - 0.1), 0) ? __assert_rtn
(__func__, "input.c", 1653, "final_d > orig_d - 0.1") : (void
)0)
;
1654 assert(final_d < orig_d + 0.1)(__builtin_expect(!(final_d < orig_d + 0.1), 0) ? __assert_rtn
(__func__, "input.c", 1654, "final_d < orig_d + 0.1") : (void
)0)
;
1655
1656 assert(memcmp(&first_fp16, &final_fp16, sizeof(FP1616)) == 0)(__builtin_expect(!(memcmp(&first_fp16, &final_fp16, sizeof
(FP1616)) == 0), 0) ? __assert_rtn(__func__, "input.c", 1656,
"memcmp(&first_fp16, &final_fp16, sizeof(FP1616)) == 0"
) : (void)0)
;
1657
1658 if (orig_d > 0)
1659 _test_double_fp16_values(-orig_d);
1660}
1661
1662static void
1663_test_double_fp32_values(double orig_d)
1664{
1665 FP3232 first_fp32, final_fp32;
1666 double final_d;
1667
1668 if (orig_d > 0x7FFFFFFF) {
1669 printf("Test out of range\n");
1670 assert(0)(__builtin_expect(!(0), 0) ? __assert_rtn(__func__, "input.c"
, 1670, "0") : (void)0)
;
1671 }
1672
1673 first_fp32 = double_to_fp3232(orig_d);
1674 final_d = fp3232_to_double(first_fp32);
1675 final_fp32 = double_to_fp3232(final_d);
1676
1677 /* {
1678 * char first_fp32_s[64];
1679 * char final_fp32_s[64];
1680 * snprintf(first_fp32_s, sizeof(first_fp32_s), "%d + %u * 2^-32", first_fp32.integral, first_fp32.frac);
1681 * snprintf(final_fp32_s, sizeof(final_fp32_s), "%d + %u * 2^-32", first_fp32.integral, final_fp32.frac);
1682 *
1683 * printf("FP32: original double: %f first fp32: %s, re-encoded double: %f, final fp32: %s\n", orig_d, first_fp32_s, final_d, final_fp32_s);
1684 * }
1685 */
1686
1687 /* since we lose precision, we only do rough range testing */
1688 assert(final_d > orig_d - 0.1)(__builtin_expect(!(final_d > orig_d - 0.1), 0) ? __assert_rtn
(__func__, "input.c", 1688, "final_d > orig_d - 0.1") : (void
)0)
;
1689 assert(final_d < orig_d + 0.1)(__builtin_expect(!(final_d < orig_d + 0.1), 0) ? __assert_rtn
(__func__, "input.c", 1689, "final_d < orig_d + 0.1") : (void
)0)
;
1690
1691 assert(memcmp(&first_fp32, &final_fp32, sizeof(FP3232)) == 0)(__builtin_expect(!(memcmp(&first_fp32, &final_fp32, sizeof
(FP3232)) == 0), 0) ? __assert_rtn(__func__, "input.c", 1691,
"memcmp(&first_fp32, &final_fp32, sizeof(FP3232)) == 0"
) : (void)0)
;
1692
1693 if (orig_d > 0)
1694 _test_double_fp32_values(-orig_d);
1695}
1696
1697static void
1698dix_double_fp_conversion(void)
1699{
1700 uint32_t i;
1701
1702 printf("Testing double to FP1616/FP3232 conversions\n");
1703
1704 _test_double_fp16_values(0);
1705 for (i = 1; i < 0x7FFF; i <<= 1) {
1706 double val;
1707
1708 val = i;
1709 _test_double_fp16_values(val);
1710 _test_double_fp32_values(val);
1711
1712 /* and some pseudo-random floating points */
1713 val = i - 0.00382;
1714 _test_double_fp16_values(val);
1715 _test_double_fp32_values(val);
1716
1717 val = i + 0.00382;
1718 _test_double_fp16_values(val);
1719 _test_double_fp32_values(val);
1720
1721 val = i + 0.05234;
1722 _test_double_fp16_values(val);
1723 _test_double_fp32_values(val);
1724
1725 val = i + 0.12342;
1726 _test_double_fp16_values(val);
1727 _test_double_fp32_values(val);
1728
1729 val = i + 0.27583;
1730 _test_double_fp16_values(val);
1731 _test_double_fp32_values(val);
1732
1733 val = i + 0.50535;
1734 _test_double_fp16_values(val);
1735 _test_double_fp32_values(val);
1736
1737 val = i + 0.72342;
1738 _test_double_fp16_values(val);
1739 _test_double_fp32_values(val);
1740
1741 val = i + 0.80408;
1742 _test_double_fp16_values(val);
1743 _test_double_fp32_values(val);
1744 }
1745
1746 for (i = 0x7FFFF; i < 0x7FFFFFFF; i <<= 1) {
1747 _test_double_fp32_values(i);
1748 /* and a few more random floating points, obtained
1749 * by faceplanting into the numpad repeatedly */
1750 _test_double_fp32_values(i + 0.010177);
1751 _test_double_fp32_values(i + 0.213841);
1752 _test_double_fp32_values(i + 0.348720);
1753 _test_double_fp32_values(i + 0.472020);
1754 _test_double_fp32_values(i + 0.572020);
1755 _test_double_fp32_values(i + 0.892929);
1756 }
1757}
1758
1759/* The mieq test verifies that events added to the queue come out in the same
1760 * order that they went in.
1761 */
1762static uint32_t mieq_test_event_last_processed;
1763
1764static void
1765mieq_test_event_handler(int screenNum, InternalEvent *ie, DeviceIntPtr dev)
1766{
1767 RawDeviceEvent *e = (RawDeviceEvent *) ie;
1768
1769 assert(e->type == ET_RawMotion)(__builtin_expect(!(e->type == ET_RawMotion), 0) ? __assert_rtn
(__func__, "input.c", 1769, "e->type == ET_RawMotion") : (
void)0)
;
1770 assert(e->flags > mieq_test_event_last_processed)(__builtin_expect(!(e->flags > mieq_test_event_last_processed
), 0) ? __assert_rtn(__func__, "input.c", 1770, "e->flags > mieq_test_event_last_processed"
) : (void)0)
;
1771 mieq_test_event_last_processed = e->flags;
1772}
1773
1774static void
1775_mieq_test_generate_events(uint32_t start, uint32_t count)
1776{
1777 static DeviceIntRec dev;
1778 static SpriteInfoRec spriteInfo;
1779 static SpriteRec sprite;
1780
1781 memset(&dev, 0, sizeof(dev))__builtin___memset_chk (&dev, 0, sizeof(dev), __builtin_object_size
(&dev, 0))
;
1782 memset(&spriteInfo, 0, sizeof(spriteInfo))__builtin___memset_chk (&spriteInfo, 0, sizeof(spriteInfo
), __builtin_object_size (&spriteInfo, 0))
;
1783 memset(&sprite, 0, sizeof(sprite))__builtin___memset_chk (&sprite, 0, sizeof(sprite), __builtin_object_size
(&sprite, 0))
;
1784 dev.spriteInfo = &spriteInfo;
1785 spriteInfo.sprite = &sprite;
1786
1787 dev.enabled = 1;
1788
1789 count += start;
1790 while (start < count) {
1791 RawDeviceEvent e = { 0 };
1792 e.header = ET_Internal;
1793 e.type = ET_RawMotion;
1794 e.length = sizeof(e);
1795 e.time = GetTimeInMillis();
1796 e.flags = start;
1797
1798 mieqEnqueue(&dev, (InternalEvent *) &e);
1799
1800 start++;
1801 }
1802}
1803
1804#define mieq_test_generate_events(c){ _mieq_test_generate_events(next, c); next += c; } { _mieq_test_generate_events(next, c); next += c; }
1805
1806static void
1807mieq_test(void)
1808{
1809 uint32_t next = 1;
1810
1811 mieq_test_event_last_processed = 0;
1812 mieqInit();
1813 mieqSetHandler(ET_RawMotion, mieq_test_event_handler);
1814
1815 /* Enough to fit the buffer but trigger a grow */
1816 mieq_test_generate_events(180){ _mieq_test_generate_events(next, 180); next += 180; };
1817
1818 /* We should resize to 512 now */
1819 mieqProcessInputEvents();
1820
1821 /* Some should now get dropped */
1822 mieq_test_generate_events(500){ _mieq_test_generate_events(next, 500); next += 500; };
1823
1824 /* Tell us how many got dropped, 1024 now */
1825 mieqProcessInputEvents();
1826
1827 /* Now make it 2048 */
1828 mieq_test_generate_events(900){ _mieq_test_generate_events(next, 900); next += 900; };
1829 mieqProcessInputEvents();
1830
1831 /* Now make it 4096 (max) */
1832 mieq_test_generate_events(1950){ _mieq_test_generate_events(next, 1950); next += 1950; };
1833 mieqProcessInputEvents();
1834
1835 /* Now overflow one last time with the maximal queue and reach the verbosity limit */
1836 mieq_test_generate_events(10000){ _mieq_test_generate_events(next, 10000); next += 10000; };
1837 mieqProcessInputEvents();
1838
1839 mieqFini();
1840}
1841
1842/* Simple check that we're replaying events in-order */
1843static void
1844process_input_proc(InternalEvent *ev, DeviceIntPtr device)
1845{
1846 static int last_evtype = -1;
1847
1848 if (ev->any.header == 0xac)
1849 last_evtype = -1;
1850
1851 assert(ev->any.type == ++last_evtype)(__builtin_expect(!(ev->any.type == ++last_evtype), 0) ? __assert_rtn
(__func__, "input.c", 1851, "ev->any.type == ++last_evtype"
) : (void)0)
;
1852}
1853
1854static void
1855dix_enqueue_events(void)
1856{
1857#define NEVENTS5 5
1858 DeviceIntRec dev;
1859 InternalEvent ev[NEVENTS5];
1860 SpriteInfoRec spriteInfo;
1861 SpriteRec sprite;
1862 QdEventPtr qe;
1863 int i;
1864
1865 memset(&dev, 0, sizeof(dev))__builtin___memset_chk (&dev, 0, sizeof(dev), __builtin_object_size
(&dev, 0))
;
1866 dev.public.processInputProc = process_input_proc;
1867
1868 memset(&spriteInfo, 0, sizeof(spriteInfo))__builtin___memset_chk (&spriteInfo, 0, sizeof(spriteInfo
), __builtin_object_size (&spriteInfo, 0))
;
1869 memset(&sprite, 0, sizeof(sprite))__builtin___memset_chk (&sprite, 0, sizeof(sprite), __builtin_object_size
(&sprite, 0))
;
1870 dev.spriteInfo = &spriteInfo;
1871 spriteInfo.sprite = &sprite;
1872
1873 InitEvents();
1874 assert(xorg_list_is_empty(&syncEvents.pending))(__builtin_expect(!(xorg_list_is_empty(&syncEvents.pending
)), 0) ? __assert_rtn(__func__, "input.c", 1874, "xorg_list_is_empty(&syncEvents.pending)"
) : (void)0)
;
1875
1876 /* this way PlayReleasedEvents really runs through all events in the
1877 * queue */
1878 inputInfo.devices = &dev;
1879
1880 /* to reset process_input_proc */
1881 ev[0].any.header = 0xac;
1882
1883 for (i = 0; i < NEVENTS5; i++) {
1884 ev[i].any.length = sizeof(*ev);
1885 ev[i].any.type = i;
1886 EnqueueEvent(&ev[i], &dev);
1887 assert(!xorg_list_is_empty(&syncEvents.pending))(__builtin_expect(!(!xorg_list_is_empty(&syncEvents.pending
)), 0) ? __assert_rtn(__func__, "input.c", 1887, "!xorg_list_is_empty(&syncEvents.pending)"
) : (void)0)
;
1888 qe = xorg_list_last_entry(&syncEvents.pending, QdEventRec, next)(QdEventRec *)((char *)((&syncEvents.pending)->prev) -
__builtin_offsetof(QdEventRec, next))
;
1889 assert(memcmp(qe->event, &ev[i], ev[i].any.length) == 0)(__builtin_expect(!(memcmp(qe->event, &ev[i], ev[i].any
.length) == 0), 0) ? __assert_rtn(__func__, "input.c", 1889, "memcmp(qe->event, &ev[i], ev[i].any.length) == 0"
) : (void)0)
;
1890 qe = xorg_list_first_entry(&syncEvents.pending, QdEventRec, next)(QdEventRec *)((char *)((&syncEvents.pending)->next) -
__builtin_offsetof(QdEventRec, next))
;
1891 assert(memcmp(qe->event, &ev[0], ev[i].any.length) == 0)(__builtin_expect(!(memcmp(qe->event, &ev[0], ev[i].any
.length) == 0), 0) ? __assert_rtn(__func__, "input.c", 1891, "memcmp(qe->event, &ev[0], ev[i].any.length) == 0"
) : (void)0)
;
1892 }
1893
1894 /* calls process_input_proc */
1895 dev.deviceGrab.sync.frozen = 1;
1896 PlayReleasedEvents();
1897 assert(!xorg_list_is_empty(&syncEvents.pending))(__builtin_expect(!(!xorg_list_is_empty(&syncEvents.pending
)), 0) ? __assert_rtn(__func__, "input.c", 1897, "!xorg_list_is_empty(&syncEvents.pending)"
) : (void)0)
;
1898
1899 dev.deviceGrab.sync.frozen = 0;
1900 PlayReleasedEvents();
1901 assert(xorg_list_is_empty(&syncEvents.pending))(__builtin_expect(!(xorg_list_is_empty(&syncEvents.pending
)), 0) ? __assert_rtn(__func__, "input.c", 1901, "xorg_list_is_empty(&syncEvents.pending)"
) : (void)0)
;
1902
1903 inputInfo.devices = NULL((void*)0);
1904}
1905
1906int
1907main(int argc, char **argv)
1908{
1909 dix_enqueue_events();
1910 dix_double_fp_conversion();
1911 dix_input_valuator_masks();
1912 dix_input_valuator_masks_unaccel();
1913 dix_input_attributes();
1914 dix_init_valuators();
1915 dix_event_to_core_conversion();
1916 dix_event_to_xi1_conversion();
1917 dix_check_grab_values();
1918 xi2_struct_sizes();
1919 dix_grab_matching();
1920 dix_valuator_mode();
1921 include_byte_padding_macros();
1922 include_bit_test_macros();
1923 xi_unregister_handlers();
1924 dix_valuator_alloc();
1925 dix_get_master();
1926 input_option_test();
1927 mieq_test();
1928
1929 return 0;
1930}