frederik
/
xserver
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'whot/for-keith'

This commit is contained in:
Keith Packard 2011-04-22 10:48:37 -07:00
parent 001b6b8b70 6f97fe5df1
commit 302bdc3c96
39 changed files with 1076 additions and 818 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Xext/xtest.c
View File

@ -423,7 +423,7 @@ ProcXTestFakeInput(ClientPtr client)
break;
case KeyPress:
case KeyRelease:
nevents = GetKeyboardEvents(xtest_evlist, dev, type, ev->u.u.detail);
nevents = GetKeyboardEvents(xtest_evlist, dev, type, ev->u.u.detail, NULL);
break;
}

11
Xi/exevents.c
View File

@ -535,6 +535,7 @@ DeepCopyPointerClasses(DeviceIntPtr from, DeviceIntPtr to)
if (from->valuator)
{
ValuatorClassPtr v;
if (!to->valuator)
{
classes = to->unused_classes;
@ -543,18 +544,14 @@ DeepCopyPointerClasses(DeviceIntPtr from, DeviceIntPtr to)
classes->valuator = NULL;
}
to->valuator = realloc(to->valuator, sizeof(ValuatorClassRec) +
from->valuator->numAxes * sizeof(AxisInfo) +
from->valuator->numAxes * sizeof(double));
v = to->valuator;
v = AllocValuatorClass(to->valuator, from->valuator->numAxes);
if (!v)
FatalError("[Xi] no memory for class shift.\n");
v->numAxes = from->valuator->numAxes;
v->axes = (AxisInfoPtr)&v[1];
to->valuator = v;
memcpy(v->axes, from->valuator->axes, v->numAxes * sizeof(AxisInfo));
v->axisVal = (double*)(v->axes + from->valuator->numAxes);
v->sourceid = from->id;
} else if (to->valuator && !from->valuator)
{

2
Xi/extinit.c
View File

@ -511,7 +511,7 @@ SReplyIDispatch(ClientPtr client, int len, xGrabDeviceReply * rep)
SRepXIQueryDevice(client, len, (xXIQueryDeviceReply*)rep);
else if (rep->RepType == X_XIGrabDevice)
SRepXIGrabDevice(client, len, (xXIGrabDeviceReply *) rep);
else if (rep->RepType == X_XIGrabDevice)
else if (rep->RepType == X_XIPassiveGrabDevice)
SRepXIPassiveGrabDevice(client, len, (xXIPassiveGrabDeviceReply *) rep);
else if (rep->RepType == X_XIListProperties)
SRepXIListProperties(client, len, (xXIListPropertiesReply *) rep);

2
Xi/xichangehierarchy.c
View File

@ -116,7 +116,9 @@ void XISendDeviceHierarchyEvent(int flags[MAXDEVICES])
ev->length = bytes_to_int32(ev->num_info * sizeof(xXIHierarchyInfo));
memset(&dummyDev, 0, sizeof(dummyDev));
dummyDev.id = XIAllDevices;
dummyDev.type = SLAVE;
SendEventToAllWindows(&dummyDev, (XI_HierarchyChangedMask >> 8), (xEvent*)ev, 1);
free(ev);
}

16
Xi/xipassivegrab.c
View File

@ -43,6 +43,7 @@
#include "exevents.h"
#include "xipassivegrab.h"
#include "dixgrabs.h"
#include "misc.h"
int
SProcXIPassiveGrabDevice(ClientPtr client)
@ -87,6 +88,7 @@ ProcXIPassiveGrabDevice(ClientPtr client)
GrabParameters param;
void *tmp;
int mask_len;
int n;
REQUEST(xXIPassiveGrabDeviceReq);
REQUEST_AT_LEAST_SIZE(xXIPassiveGrabDeviceReq);
@ -99,7 +101,10 @@ ProcXIPassiveGrabDevice(ClientPtr client)
{
ret = dixLookupDevice(&dev, stuff->deviceid, client, DixGrabAccess);
if (ret != Success)
{
client->errorValue = stuff->deviceid;
return ret;
}
}
if (stuff->grab_type != XIGrabtypeButton &&
@ -156,6 +161,8 @@ ProcXIPassiveGrabDevice(ClientPtr client)
return status;
status = CheckGrabValues(client, &param);
if (status != Success)
return status;
modifiers = (uint32_t*)&stuff[1] + stuff->mask_len;
modifiers_failed = calloc(stuff->num_modifiers, sizeof(xXIGrabModifierInfo));
@ -190,6 +197,9 @@ ProcXIPassiveGrabDevice(ClientPtr client)
info->status = status;
info->modifiers = *modifiers;
if (client->swapped)
swapl(&info->modifiers, n);
rep.num_modifiers++;
rep.length += bytes_to_int32(sizeof(xXIGrabModifierInfo));
}
@ -197,10 +207,8 @@ ProcXIPassiveGrabDevice(ClientPtr client)
WriteReplyToClient(client, sizeof(rep), &rep);
if (rep.num_modifiers)
{
client->pSwapReplyFunc = (ReplySwapPtr) Swap32Write;
WriteSwappedDataToClient(client, rep.length * 4, (char*)modifiers_failed);
}
WriteToClient(client, rep.length * 4, (char*)modifiers_failed);
free(modifiers_failed);
return ret;
}

4
configure.ac
View File

@ -35,7 +35,7 @@ AM_MAINTAINER_MODE
# Require xorg-macros minimum of 1.13 for XORG_ENABLE_UNIT_TESTS
m4_ifndef([XORG_MACROS_VERSION],
[m4_fatal([must install xorg-macros 1.13 or later before running autoconf/autogen])])
XORG_MACROS_VERSION(1.10)
XORG_MACROS_VERSION(1.13)
XORG_DEFAULT_OPTIONS
XORG_WITH_DOXYGEN(1.6.1)
XORG_CHECK_SGML_DOCTOOLS(1.5)
@ -44,7 +44,6 @@ XORG_ENABLE_DEVEL_DOCS
XORG_WITH_XMLTO(0.0.20)
XORG_WITH_FOP
XORG_ENABLE_UNIT_TESTS
XORG_WITH_GLIB
XORG_LD_WRAP
m4_ifndef([XORG_FONT_MACROS_VERSION], [m4_fatal([must install fontutil 1.1 or later before running autoconf/autogen])])
@ -791,7 +790,6 @@ LIBXFONT="xfont >= 1.4.2"
LIBXI="xi >= 1.2.99.1"
LIBXTST="xtst >= 1.0.99.2"
LIBPCIACCESS="pciaccess >= 0.8.0"
LIBGLIB="glib-2.0 >= 2.16"
LIBUDEV="libudev >= 143"
LIBSELINUX="libselinux >= 2.0.86"
LIBDBUS="dbus-1 >= 1.0"

49
dix/devices.c
View File

@ -1221,13 +1221,46 @@ InitButtonClassDeviceStruct(DeviceIntPtr dev, int numButtons, Atom* labels,
return TRUE;
}
/**
* Allocate a valuator class and set up the pointers for the axis values
* appropriately.
*
* @param src If non-NULL, the memory is reallocated from src. If NULL, the
* memory is calloc'd.
* @parma numAxes Number of axes to allocate.
* @return The allocated valuator struct.
*/
ValuatorClassPtr
AllocValuatorClass(ValuatorClassPtr src, int numAxes)
{
ValuatorClassPtr v;
/* force alignment with double */
union align_u { ValuatorClassRec valc; double d; } *align;
int size;
size = sizeof(union align_u) + numAxes * (sizeof(double) + sizeof(AxisInfo));
align = (union align_u *) realloc(src, size);
if (!align)
return NULL;
if (!src)
memset(align, 0, size);
v = &align->valc;
v->numAxes = numAxes;
v->axisVal = (double*)(align + 1);
v->axes = (AxisInfoPtr)(v->axisVal + numAxes);
return v;
}
Bool
InitValuatorClassDeviceStruct(DeviceIntPtr dev, int numAxes, Atom *labels,
int numMotionEvents, int mode)
{
int i;
ValuatorClassPtr valc;
union align_u { ValuatorClassRec valc; double d; } *align;
if (!dev)
return FALSE;
@ -1240,13 +1273,10 @@ InitValuatorClassDeviceStruct(DeviceIntPtr dev, int numAxes, Atom *labels,
numAxes = MAX_VALUATORS;
}
align = (union align_u *) calloc(1, sizeof(union align_u) +
numAxes * sizeof(double) +
numAxes * sizeof(AxisInfo));
if (!align)
return FALSE;
valc = AllocValuatorClass(NULL, numAxes);
if (!valc)
return FALSE;
valc = &align->valc;
valc->sourceid = dev->id;
valc->motion = NULL;
valc->first_motion = 0;
@ -1254,9 +1284,6 @@ InitValuatorClassDeviceStruct(DeviceIntPtr dev, int numAxes, Atom *labels,
valc->numMotionEvents = numMotionEvents;
valc->motionHintWindow = NullWindow;
valc->numAxes = numAxes;
valc->axisVal = (double *)(align + 1);
valc->axes = (AxisInfoPtr)(valc->axisVal + numAxes);
if (mode & OutOfProximity)
InitProximityClassDeviceStruct(dev);
@ -2365,7 +2392,7 @@ ReleaseButtonsAndKeys(DeviceIntPtr dev)
{
if (BitIsOn(k->down, i))
{
nevents = GetKeyboardEvents(eventlist, dev, KeyRelease, i);
nevents = GetKeyboardEvents(eventlist, dev, KeyRelease, i, NULL);
for (j = 0; j < nevents; j++)
mieqProcessDeviceEvent(dev, (InternalEvent*)(eventlist+j)->event, NULL);
}

21
dix/getevents.c
View File

@ -616,8 +616,8 @@ updateMotionHistory(DeviceIntPtr pDev, CARD32 ms, ValuatorMask *mask,
/**
* Returns the maximum number of events GetKeyboardEvents,
* GetKeyboardValuatorEvents, and GetPointerEvents will ever return.
* Returns the maximum number of events GetKeyboardEvents
* and GetPointerEvents will ever return.
*
* This MUST be absolutely constant, from init until exit.
*/
@ -925,19 +925,6 @@ updateHistory(DeviceIntPtr dev, ValuatorMask *mask, CARD32 ms)
}
}
/**
* Convenience wrapper around GetKeyboardValuatorEvents, that takes no
* valuators.
*/
int
GetKeyboardEvents(EventList *events, DeviceIntPtr pDev, int type, int key_code) {
ValuatorMask mask;
valuator_mask_zero(&mask);
return GetKeyboardValuatorEvents(events, pDev, type, key_code, &mask);
}
/**
* Returns a set of InternalEvents for KeyPress/KeyRelease, optionally
* also with valuator events.
@ -947,8 +934,8 @@ GetKeyboardEvents(EventList *events, DeviceIntPtr pDev, int type, int key_code)
* place via GetMaximumEventsNum(), and for freeing it.
*/
int
GetKeyboardValuatorEvents(EventList *events, DeviceIntPtr pDev, int type,
int key_code, const ValuatorMask *mask_in) {
GetKeyboardEvents(EventList *events, DeviceIntPtr pDev, int type,
int key_code, const ValuatorMask *mask_in) {
int num_events = 0;
CARD32 ms = 0;
DeviceEvent *event;

292
dix/ptrveloc.c
View File

@ -429,82 +429,115 @@ InitTrackers(DeviceVelocityPtr vel, int ntracker)
vel->num_tracker = ntracker;
}
enum directions {
N = (1 << 0),
NE = (1 << 1),
E = (1 << 2),
SE = (1 << 3),
S = (1 << 4),
SW = (1 << 5),
W = (1 << 6),
NW = (1 << 7),
UNDEFINED = 0xFF
};
/**
* return a bit field of possible directions.
* 0 = N, 2 = E, 4 = S, 6 = W, in-between is as you guess.
* There's no reason against widening to more precise directions (<45 degrees),
* should it not perform well. All this is needed for is sort out non-linear
* motion, so precision isn't paramount. However, one should not flag direction
* too narrow, since it would then cut the linear segment to zero size way too
* often.
*
* @return A bitmask for N, NE, S, SE, etc. indicating the directions for
* this movement.
*/
static int
DoGetDirection(int dx, int dy){
float r;
int i1, i2;
int dir = 0;
/* on insignificant mickeys, flag 135 degrees */
if(abs(dx) < 2 && abs(dy < 2)){
/* first check diagonal cases */
if(dx > 0 && dy > 0)
return 4+8+16;
if(dx > 0 && dy < 0)
return 1+2+4;
if(dx < 0 && dy < 0)
return 1+128+64;
if(dx < 0 && dy > 0)
return 16+32+64;
if(abs(dx) < 2 && abs(dy) < 2){
/* first check diagonal cases */
if(dx > 0 && dy > 0)
dir = E | SE | S;
else if(dx > 0 && dy < 0)
dir = N | NE | E;
else if(dx < 0 && dy < 0)
dir = W | NW | N;
else if(dx < 0 && dy > 0)
dir = W | SW | S;
/* check axis-aligned directions */
if(dx > 0)
return 2+4+8; /*E*/
if(dx < 0)
return 128+64+32; /*W*/
if(dy > 0)
return 32+16+8; /*S*/
if(dy < 0)
return 128+1+2; /*N*/
return 255; /* shouldn't happen */
}
/* else, compute angle and set appropriate flags */
else if(dx > 0)
dir = NE | E | SE;
else if(dx < 0)
dir = NW | W | SW;
else if(dy > 0)
dir = SE | S | SW;
else if(dy < 0)
dir = NE | N | NW;
else
dir = UNDEFINED; /* shouldn't happen */
} else { /* compute angle and set appropriate flags */
float r;
int i1, i2;
#ifdef _ISOC99_SOURCE
r = atan2f(dy, dx);
r = atan2f(dy, dx);
#else
r = atan2(dy, dx);
r = atan2(dy, dx);
#endif
/* find direction. We avoid r to become negative,
* since C has no well-defined modulo for such cases. */
r = (r+(M_PI*2.5))/(M_PI/4);
/* this intends to flag 2 directions (90 degrees),
* except on very well-aligned mickeys. */
i1 = (int)(r+0.1) % 8;
i2 = (int)(r+0.9) % 8;
if(i1 < 0 || i1 > 7 || i2 < 0 || i2 > 7)
return 255; /* shouldn't happen */
return 1 << i1 | 1 << i2;
/* find direction.
*
* Add 360° to avoid r become negative since C has no well-defined
* modulo for such cases. Then divide by 45° to get the octant
* number, e.g.
* 0 <= r <= 1 is [0-45]°
* 1 <= r <= 2 is [45-90]°
* etc.
* But we add extra 90° to match up with our N, S, etc. defines up
* there, rest stays the same.
*/
r = (r+(M_PI*2.5))/(M_PI/4);
/* this intends to flag 2 directions (45 degrees),
* except on very well-aligned mickeys. */
i1 = (int)(r+0.1) % 8;
i2 = (int)(r+0.9) % 8;
if(i1 < 0 || i1 > 7 || i2 < 0 || i2 > 7)
dir = UNDEFINED; /* shouldn't happen */
else
dir = (1 << i1 | 1 << i2);
}
return dir;
}
#define DIRECTION_CACHE_RANGE 5
#define DIRECTION_CACHE_SIZE (DIRECTION_CACHE_RANGE*2+1)
/* cache DoGetDirection(). */
/* cache DoGetDirection().
* To avoid excessive use of direction calculation, cache the values for
* [-5..5] for both x/y. Anything outside of that is calcualted on the fly.
*
* @return A bitmask for N, NE, S, SE, etc. indicating the directions for
* this movement.
*/
static int
GetDirection(int dx, int dy){
static int cache[DIRECTION_CACHE_SIZE][DIRECTION_CACHE_SIZE];
int i;
int dir;
if (abs(dx) <= DIRECTION_CACHE_RANGE &&
abs(dy) <= DIRECTION_CACHE_RANGE) {
/* cacheable */
i = cache[DIRECTION_CACHE_RANGE+dx][DIRECTION_CACHE_RANGE+dy];
if(i != 0){
return i;
}else{
i = DoGetDirection(dx, dy);
cache[DIRECTION_CACHE_RANGE+dx][DIRECTION_CACHE_RANGE+dy] = i;
return i;
dir = cache[DIRECTION_CACHE_RANGE+dx][DIRECTION_CACHE_RANGE+dy];
if(dir == 0) {
dir = DoGetDirection(dx, dy);
cache[DIRECTION_CACHE_RANGE+dx][DIRECTION_CACHE_RANGE+dy] = dir;
}
}else{
/* non-cacheable */
return DoGetDirection(dx, dy);
dir = DoGetDirection(dx, dy);
}
return dir;
}
#undef DIRECTION_CACHE_RANGE
@ -513,7 +546,12 @@ GetDirection(int dx, int dy){
/* convert offset (age) to array index */
#define TRACKER_INDEX(s, d) (((s)->num_tracker + (s)->cur_tracker - (d)) % (s)->num_tracker)
#define TRACKER(s, d) &(s)->tracker[TRACKER_INDEX(s,d)]
/**
* Add the delta motion to each tracker, then reset the latest tracker to
* 0/0 and set it as the current one.
*/
static inline void
FeedTrackers(DeviceVelocityPtr vel, int dx, int dy, int cur_t)
{
@ -539,11 +577,9 @@ FeedTrackers(DeviceVelocityPtr vel, int dx, int dy, int cur_t)
* This assumes linear motion.
*/
static float
CalcTracker(DeviceVelocityPtr vel, int offset, int cur_t){
int index = TRACKER_INDEX(vel, offset);
float dist = sqrt( vel->tracker[index].dx * vel->tracker[index].dx
+ vel->tracker[index].dy * vel->tracker[index].dy);
int dtime = cur_t - vel->tracker[index].time;
CalcTracker(const MotionTracker *tracker, int cur_t){
float dist = sqrt(tracker->dx * tracker->dx + tracker->dy * tracker->dy);
int dtime = cur_t - tracker->time;
if(dtime > 0)
return dist / dtime;
else
@ -551,22 +587,24 @@ CalcTracker(DeviceVelocityPtr vel, int offset, int cur_t){
}
/* find the most plausible velocity. That is, the most distant
* (in time) tracker which isn't too old, beyond a linear partition,
* or simply too much off initial velocity.
* (in time) tracker which isn't too old, the movement vector was
* in the same octant, and where the velocity is within an
* acceptable range to the inital velocity.
*
* May return 0.
* @return The tracker's velocity or 0 if the above conditions are unmet
*/
static float
QueryTrackers(DeviceVelocityPtr vel, int cur_t){
int n, offset, dir = 255, i = -1, age_ms;
int offset, dir = UNDEFINED, used_offset = -1, age_ms;
/* initial velocity: a low-offset, valid velocity */
float iveloc = 0, res = 0, tmp, vdiff;
float vfac = vel->corr_mul * vel->const_acceleration; /* premultiply */
float initial_velocity = 0, result = 0, velocity_diff;
float velocity_factor = vel->corr_mul * vel->const_acceleration; /* premultiply */
/* loop from current to older data */
for(offset = 1; offset < vel->num_tracker; offset++){
n = TRACKER_INDEX(vel, offset);
MotionTracker *tracker = TRACKER(vel, offset);
float tracker_velocity;
age_ms = cur_t - vel->tracker[n].time;
age_ms = cur_t - tracker->time;
/* bail out if data is too old and protect from overrun */
if (age_ms >= vel->reset_time || age_ms < 0) {
@ -580,60 +618,60 @@ QueryTrackers(DeviceVelocityPtr vel, int cur_t){
* even more precision we could subdivide as a final step, so possible
* non-linearities are accounted for.
*/
dir &= vel->tracker[n].dir;
if(dir == 0){
dir &= tracker->dir;
if(dir == 0){ /* we've changed octant of movement (e.g. NE → NW) */
DebugAccelF("(dix prtacc) query: no longer linear\n");
/* instead of breaking it we might also inspect the partition after,
* but actual improvement with this is probably rare. */
break;
}
tmp = CalcTracker(vel, offset, cur_t) * vfac;
tracker_velocity = CalcTracker(tracker, cur_t) * velocity_factor;
if ((iveloc == 0 || offset <= vel->initial_range) && tmp != 0) {
if ((initial_velocity == 0 || offset <= vel->initial_range) && tracker_velocity != 0) {
/* set initial velocity and result */
res = iveloc = tmp;
i = offset;
} else if (iveloc != 0 && tmp != 0) {
vdiff = fabs(iveloc - tmp);
if (vdiff <= vel->max_diff ||
vdiff/(iveloc + tmp) < vel->max_rel_diff) {
/* we're in range with the initial velocity,
* so this result is likely better
* (it contains more information). */
res = tmp;
i = offset;
}else{
result = initial_velocity = tracker_velocity;
used_offset = offset;
} else if (initial_velocity != 0 && tracker_velocity != 0) {
velocity_diff = fabs(initial_velocity - tracker_velocity);
if (velocity_diff > vel->max_diff &&
velocity_diff/(initial_velocity + tracker_velocity) >= vel->max_rel_diff) {
/* we're not in range, quit - it won't get better. */
DebugAccelF("(dix prtacc) query: tracker too different:"
" old %2.2f initial %2.2f diff: %2.2f\n",
tmp, iveloc, vdiff);
tracker_velocity, initial_velocity, velocity_diff);
break;
}
/* we're in range with the initial velocity,
* so this result is likely better
* (it contains more information). */
result = tracker_velocity;
used_offset = offset;
}
}
if(offset == vel->num_tracker){
DebugAccelF("(dix prtacc) query: last tracker in effect\n");
i = vel->num_tracker-1;
used_offset = vel->num_tracker-1;
}
if(i>=0){
n = TRACKER_INDEX(vel, i);
#ifdef PTRACCEL_DEBUGGING
if(used_offset >= 0){
MotionTracker *tracker = TRACKER(vel, used_offset);
DebugAccelF("(dix prtacc) result: offset %i [dx: %i dy: %i diff: %i]\n",
i,
vel->tracker[n].dx,
vel->tracker[n].dy,
cur_t - vel->tracker[n].time);
used_offset, tracker->dx, tracker->dy, cur_t - tracker->time);
}
return res;
#endif
return result;
}
#undef TRACKER_INDEX
#undef TRACKER
/**
* Perform velocity approximation based on 2D 'mickeys' (mouse motion delta).
* return true if non-visible state reset is suggested
*/
short
BOOL
ProcessVelocityData2D(
DeviceVelocityPtr vel,
int dx,
@ -657,36 +695,41 @@ ProcessVelocityData2D(
* constant-velocity response
*/
static inline float
ApplySimpleSoftening(int od, int d)
ApplySimpleSoftening(int prev_delta, int delta)
{
float res = d;
if (d <= 1 && d >= -1)
return res;
if (d > od)
res -= 0.5;
else if (d < od)
res += 0.5;
return res;
float result = delta;
if (delta < -1 || delta > 1) {
if (delta > prev_delta)
result -= 0.5;
else if (delta < prev_delta)
result += 0.5;
}
return result;
}
/**
* Soften the delta based on previous deltas stored in vel.
*
* @param[in,out] fdx Delta X, modified in-place.
* @param[in,out] fdx Delta Y, modified in-place.
*/
static void
ApplySofteningAndConstantDeceleration(
ApplySoftening(
DeviceVelocityPtr vel,
int dx,
int dy,
float* fdx,
float* fdy,
short do_soften)
float* fdy)
{
if (do_soften && vel->use_softening) {
*fdx = ApplySimpleSoftening(vel->last_dx, dx);
*fdy = ApplySimpleSoftening(vel->last_dy, dy);
} else {
*fdx = dx;
*fdy = dy;
if (vel->use_softening) {
*fdx = ApplySimpleSoftening(vel->last_dx, *fdx);
*fdy = ApplySimpleSoftening(vel->last_dy, *fdy);
}
}
static void
ApplyConstantDeceleration(DeviceVelocityPtr vel, float *fdx, float *fdy)
{
*fdx *= vel->const_acceleration;
*fdy *= vel->const_acceleration;
}
@ -713,6 +756,8 @@ BasicComputeAcceleration(
/**
* Compute acceleration. Takes into account averaging, nv-reset, etc.
* If the velocity has changed, an average is taken of 6 velocity factors:
* current velocity, last velocity and 4 times the average between the two.
*/
static float
ComputeAcceleration(
@ -720,7 +765,7 @@ ComputeAcceleration(
DeviceVelocityPtr vel,
float threshold,
float acc){
float res;
float result;
if(vel->velocity <= 0){
DebugAccelF("(dix ptracc) profile skipped\n");
@ -735,24 +780,24 @@ ComputeAcceleration(
* current and previous velocity.
* Though being the more natural choice, it causes a minor delay
* in comparison, so it can be disabled. */
res = BasicComputeAcceleration(
result = BasicComputeAcceleration(
dev, vel, vel->velocity, threshold, acc);
res += BasicComputeAcceleration(
result += BasicComputeAcceleration(
dev, vel, vel->last_velocity, threshold, acc);
res += 4.0f * BasicComputeAcceleration(dev, vel,
result += 4.0f * BasicComputeAcceleration(dev, vel,
(vel->last_velocity + vel->velocity) / 2,
threshold, acc);
res /= 6.0f;
result /= 6.0f;
DebugAccelF("(dix ptracc) profile average [%.2f ... %.2f] is %.3f\n",
vel->velocity, vel->last_velocity, res);
return res;
vel->velocity, vel->last_velocity, result);
}else{
res = BasicComputeAcceleration(dev, vel,
vel->velocity, threshold, acc);
result = BasicComputeAcceleration(dev, vel,
vel->velocity, threshold, acc);
DebugAccelF("(dix ptracc) profile sample [%.2f] is %.3f\n",
vel->velocity, res);
return res;
}
return result;
}
@ -1074,7 +1119,6 @@ acceleratePointerPredictable(
ValuatorMask* val,
CARD32 evtime)
{
float fdx, fdy, tmp, mult; /* no need to init */
int dx = 0, dy = 0, tmpi;
DeviceVelocityPtr velocitydata = GetDevicePredictableAccelData(dev);
Bool soften = TRUE;
@ -1102,6 +1146,8 @@ acceleratePointerPredictable(
}
if (dev->ptrfeed && dev->ptrfeed->ctrl.num) {
float mult;
/* invoke acceleration profile to determine acceleration */
mult = ComputeAcceleration (dev, velocitydata,
dev->ptrfeed->ctrl.threshold,
@ -1109,12 +1155,17 @@ acceleratePointerPredictable(
(float)dev->ptrfeed->ctrl.den);
if(mult != 1.0f || velocitydata->const_acceleration != 1.0f) {
ApplySofteningAndConstantDeceleration(velocitydata,
dx, dy,
&fdx, &fdy,
(mult > 1.0f) && soften);
float fdx = dx,
fdy = dy;
if (mult > 1.0f && soften)
ApplySoftening(velocitydata, &fdx, &fdy);
ApplyConstantDeceleration(velocitydata, &fdx, &fdy);
/* Calculate the new delta (with accel) and drop it back
* into the valuator masks */
if (dx) {
float tmp;
tmp = mult * fdx + dev->last.remainder[0];
/* Since it may not be apparent: lrintf() does not offer
* strong statements about rounding; however because we
@ -1126,6 +1177,7 @@ acceleratePointerPredictable(
dev->last.remainder[0] = tmp - (float)tmpi;
}
if (dy) {
float tmp;
tmp = mult * fdy + dev->last.remainder[1];
tmpi = lrintf(tmp);
valuator_mask_set(val, 1, tmpi);

2
dix/resource.c
View File

@ -489,7 +489,7 @@ AddResource(XID id, RESTYPE type, pointer value)
rrec = &clientTable[client];
if (!rrec->buckets)
{
ErrorF("[dix] AddResource(%lx, %lx, %lx), client=%d \n",
ErrorF("[dix] AddResource(%lx, %x, %lx), client=%d \n",
(unsigned long)id, type, (unsigned long)value, client);
FatalError("client not in use\n");
}

6
hw/dmx/input/dmxevents.c
View File

@ -453,8 +453,8 @@ static int dmxTranslateAndEnqueueExtEvent(DMXLocalInputInfoPtr dmxLocal,
if (block)
dmxSigioBlock();
GetEventList(&events);
nevents = GetKeyboardValuatorEvents(events, pDevice, event,
ke->keycode, &mask);
nevents = GetKeyboardEvents(events, pDevice, event,
ke->keycode, &mask);
for (i = 0; i < nevents; i++)
mieqEnqueue(pDevice, (InternalEvent*)(events + i)->event);
@ -685,7 +685,7 @@ void dmxEnqueue(DevicePtr pDev, int type, int detail, KeySym keySym,
GetEventList(&events);
/*ErrorF("KEY %d sym %d\n", detail, (int) keySym);*/
nevents = GetKeyboardEvents(events, p, type, detail);
nevents = GetKeyboardEvents(events, p, type, detail, NULL);
for (i = 0; i < nevents; i++)
mieqEnqueue(p, (InternalEvent*)(events + i)->event);
return;

4
hw/kdrive/src/kinput.c
View File

@ -1804,7 +1804,7 @@ KdReleaseAllKeys (void)
if (key_is_down(ki->dixdev, key, KEY_POSTED | KEY_PROCESSED)) {
KdHandleKeyboardEvent(ki, KeyRelease, key);
GetEventList(&kdEvents);
nEvents = GetKeyboardEvents(kdEvents, ki->dixdev, KeyRelease, key);
nEvents = GetKeyboardEvents(kdEvents, ki->dixdev, KeyRelease, key, NULL);
for (i = 0; i < nEvents; i++)
KdQueueEvent (ki->dixdev, (kdEvents + i)->event);
}
@ -1864,7 +1864,7 @@ KdEnqueueKeyboardEvent(KdKeyboardInfo *ki,
GetEventList(&kdEvents);
nEvents = GetKeyboardEvents(kdEvents, ki->dixdev, type, key_code);
nEvents = GetKeyboardEvents(kdEvents, ki->dixdev, type, key_code, NULL);
for (i = 0; i < nEvents; i++)
KdQueueEvent(ki->dixdev, (InternalEvent *)((kdEvents + i)->event));
}

13
hw/xfree86/common/xf86Configure.c
View File

@ -63,6 +63,9 @@ static char *DFLT_MOUSE_PROTO = "auto";
#elif defined(linux)
static char DFLT_MOUSE_DEV[] = "/dev/input/mice";
static char DFLT_MOUSE_PROTO[] = "auto";
#elif defined(WSCONS_SUPPORT)
static char *DFLT_MOUSE_DEV = "/dev/wsmouse";
static char *DFLT_MOUSE_PROTO = "wsmouse";
#else
static char *DFLT_MOUSE_DEV = "/dev/mouse";
static char *DFLT_MOUSE_PROTO = "auto";
@ -154,16 +157,6 @@ configureInputSection (void)
/* Crude mechanism to auto-detect mouse (os dependent) */
{
int fd;
#ifdef WSCONS_SUPPORT
fd = open("/dev/wsmouse", 0);
if (fd >= 0) {
DFLT_MOUSE_DEV = "/dev/wsmouse";
DFLT_MOUSE_PROTO = "wsmouse";
close(fd);
} else {
ErrorF("cannot open /dev/wsmouse\n");
}
#endif
fd = open(DFLT_MOUSE_DEV, 0);
if (fd != -1) {

2
hw/xfree86/common/xf86Events.c
View File

@ -399,7 +399,7 @@ xf86ReleaseKeys(DeviceIntPtr pDev)
i++) {
if (key_is_down(pDev, i, KEY_POSTED)) {
sigstate = xf86BlockSIGIO ();
nevents = GetKeyboardEvents(xf86Events, pDev, KeyRelease, i);
nevents = GetKeyboardEvents(xf86Events, pDev, KeyRelease, i, NULL);
for (j = 0; j < nevents; j++)
mieqEnqueue(pDev, (InternalEvent*)(xf86Events + j)->event);
xf86UnblockSIGIO(sigstate);

15
hw/xfree86/common/xf86Xinput.c
View File

@ -1013,7 +1013,6 @@ xf86PostMotionEventM(DeviceIntPtr device,
const ValuatorMask *mask)
{
int i = 0, nevents = 0;
DeviceEvent *event;
int flags = 0;
if (valuator_mask_num_valuators(mask) > 0)
@ -1054,7 +1053,6 @@ xf86PostMotionEventM(DeviceIntPtr device,
nevents = GetPointerEvents(xf86Events, device, MotionNotify, 0, flags, mask);
for (i = 0; i < nevents; i++) {
event = (DeviceEvent*)((xf86Events + i)->event);
mieqEnqueue(device, (InternalEvent*)((xf86Events + i)->event));
}
}
@ -1252,16 +1250,9 @@ xf86PostKeyEventM(DeviceIntPtr device,
}
#endif
if (is_absolute) {
nevents = GetKeyboardValuatorEvents(xf86Events, device,
is_down ? KeyPress : KeyRelease,
key_code, mask);
}
else {
nevents = GetKeyboardEvents(xf86Events, device,
is_down ? KeyPress : KeyRelease,
key_code);
}
nevents = GetKeyboardEvents(xf86Events, device,
is_down ? KeyPress : KeyRelease,
key_code, mask);
for (i = 0; i < nevents; i++)
mieqEnqueue(device, (InternalEvent*)((xf86Events + i)->event));

2
hw/xnest/Events.c
View File

@ -108,7 +108,7 @@ xnestQueueKeyEvent(int type, unsigned int keycode)
GetEventList(&xnestEvents);
lastEventTime = GetTimeInMillis();
n = GetKeyboardEvents(xnestEvents, xnestKeyboardDevice, type, keycode);
n = GetKeyboardEvents(xnestEvents, xnestKeyboardDevice, type, keycode, NULL);
for (i = 0; i < n; i++)
mieqEnqueue(xnestKeyboardDevice, (InternalEvent*)(xnestEvents + i)->event);
}

2
hw/xquartz/darwinEvents.c
View File

@ -482,7 +482,7 @@ void DarwinSendKeyboardEvents(int ev_type, int keycode) {
}
darwinEvents_lock(); {
num_events = GetKeyboardEvents(darwinEvents, darwinKeyboard, ev_type, keycode + MIN_KEYCODE);
num_events = GetKeyboardEvents(darwinEvents, darwinKeyboard, ev_type, keycode + MIN_KEYCODE, NULL);
for(i=0; i<num_events; i++) mieqEnqueue(darwinKeyboard, (InternalEvent*)darwinEvents[i].event);
if(num_events > 0) DarwinPokeEQ();
} darwinEvents_unlock();

2
hw/xwin/winkeybd.c
View File

@ -485,7 +485,7 @@ winSendKeyEvent (DWORD dwKey, Bool fDown)
g_winKeyState[dwKey] = fDown;
GetEventList(&events);
nevents = GetKeyboardEvents(events, g_pwinKeyboard, fDown ? KeyPress : KeyRelease, dwKey + MIN_KEYCODE);
nevents = GetKeyboardEvents(events, g_pwinKeyboard, fDown ? KeyPress : KeyRelease, dwKey + MIN_KEYCODE, NULL);
for (i = 0; i < nevents; i++)
mieqEnqueue(g_pwinKeyboard, (InternalEvent*)events[i].event);

11
include/input.h
View File

@ -102,6 +102,7 @@ typedef unsigned long Leds;
typedef struct _OtherClients *OtherClientsPtr;
typedef struct _InputClients *InputClientsPtr;
typedef struct _DeviceIntRec *DeviceIntPtr;
typedef struct _ValuatorClassRec *ValuatorClassPtr;
typedef struct _ClassesRec *ClassesPtr;
typedef struct _SpriteRec *SpritePtr;
typedef union _GrabMask GrabMask;
@ -300,6 +301,10 @@ extern _X_EXPORT Bool InitButtonClassDeviceStruct(
Atom* /* labels */,
CARD8* /*map*/);
extern _X_INTERNAL ValuatorClassPtr AllocValuatorClass(
ValuatorClassPtr src,
int numAxes);
extern _X_EXPORT Bool InitValuatorClassDeviceStruct(
DeviceIntPtr /*device*/,
int /*numAxes*/,
@ -457,12 +462,6 @@ extern _X_EXPORT int GetPointerEvents(
const ValuatorMask *mask);
extern _X_EXPORT int GetKeyboardEvents(
EventListPtr events,
DeviceIntPtr pDev,
int type,
int key_code);
extern int GetKeyboardValuatorEvents(
EventListPtr events,
DeviceIntPtr pDev,
int type,

2
include/inputstr.h
View File

@ -283,7 +283,7 @@ typedef struct _ValuatorClassRec {
unsigned short numAxes;
double *axisVal; /* always absolute, but device-coord system */
ValuatorAccelerationRec accelScheme;
} ValuatorClassRec, *ValuatorClassPtr;
} ValuatorClassRec;
typedef struct _ButtonClassRec {
int sourceid;

2
include/ptrveloc.h
View File

@ -106,7 +106,7 @@ InitVelocityData(DeviceVelocityPtr vel);
extern _X_EXPORT void
InitTrackers(DeviceVelocityPtr vel, int ntracker);
extern _X_EXPORT short
extern _X_EXPORT BOOL
ProcessVelocityData2D(DeviceVelocityPtr vel, int dx, int dy, int time);
extern _X_EXPORT float

6
test/Makefile.am
View File

@ -1,5 +1,4 @@
if ENABLE_UNIT_TESTS
if HAVE_GLIB
if HAVE_LD_WRAP
SUBDIRS= . xi2
noinst_PROGRAMS = xkb input xtest list
@ -7,9 +6,9 @@ check_LTLIBRARIES = libxservertest.la
TESTS=$(noinst_PROGRAMS)
AM_CFLAGS = $(DIX_CFLAGS) $(GLIB_CFLAGS) @XORG_CFLAGS@
AM_CFLAGS = $(DIX_CFLAGS) @XORG_CFLAGS@
INCLUDES = @XORG_INCS@
TEST_LDADD=libxservertest.la $(XORG_SYS_LIBS) $(XSERVER_SYS_LIBS) $(GLIB_LIBS)
TEST_LDADD=libxservertest.la $(XORG_SYS_LIBS) $(XSERVER_SYS_LIBS)
if SPECIAL_DTRACE_OBJECTS
TEST_LDADD += $(OS_LIB) $(DIX_LIB)
@ -38,7 +37,6 @@ libxservertest_la_LIBADD = \
@XORG_LIBS@
endif
endif
endif
CLEANFILES=libxservertest.c

521
test/input.c
View File

File diff suppressed because it is too large Load Diff

57
test/list.c
View File

@ -28,7 +28,7 @@
#include <X11/Xlib.h>
#include <list.h>
#include <string.h>
#include <glib.h>
#include <assert.h>
struct parent {
int a;
@ -56,10 +56,10 @@ test_list_init(void)
list_init(&parent.children);
/* test we haven't touched anything else. */
g_assert(parent.a == tmp.a);
g_assert(parent.b == tmp.b);
assert(parent.a == tmp.a);
assert(parent.b == tmp.b);
g_assert(list_is_empty(&parent.children));
assert(list_is_empty(&parent.children));
}
static void
@ -72,19 +72,19 @@ test_list_add(void)
list_init(&parent.children);
list_add(&child[0].node, &parent.children);
g_assert(!list_is_empty(&parent.children));
assert(!list_is_empty(&parent.children));
c = list_first_entry(&parent.children, struct child, node);
g_assert(memcmp(c, &child[0], sizeof(struct child)) == 0);
assert(memcmp(c, &child[0], sizeof(struct child)) == 0);
/* note: list_add prepends */
list_add(&child[1].node, &parent.children);
c = list_first_entry(&parent.children, struct child, node);
g_assert(memcmp(c, &child[1], sizeof(struct child)) == 0);
assert(memcmp(c, &child[1], sizeof(struct child)) == 0);
list_add(&child[2].node, &parent.children);
c = list_first_entry(&parent.children, struct child, node);
g_assert(memcmp(c, &child[2], sizeof(struct child)) == 0);
assert(memcmp(c, &child[2], sizeof(struct child)) == 0);
};
static void
@ -97,40 +97,40 @@ test_list_del(void)
list_init(&parent.children);
list_add(&child[0].node, &parent.children);
g_assert(!list_is_empty(&parent.children));
assert(!list_is_empty(&parent.children));
list_del(&parent.children);
g_assert(list_is_empty(&parent.children));
assert(list_is_empty(&parent.children));
list_add(&child[0].node, &parent.children);
list_del(&child[0].node);
g_assert(list_is_empty(&parent.children));
assert(list_is_empty(&parent.children));
list_add(&child[0].node, &parent.children);
list_add(&child[1].node, &parent.children);
c = list_first_entry(&parent.children, struct child, node);
g_assert(memcmp(c, &child[1], sizeof(struct child)) == 0);
assert(memcmp(c, &child[1], sizeof(struct child)) == 0);
/* delete first node */
list_del(&child[1].node);
g_assert(!list_is_empty(&parent.children));
g_assert(list_is_empty(&child[1].node));
assert(!list_is_empty(&parent.children));
assert(list_is_empty(&child[1].node));
c = list_first_entry(&parent.children, struct child, node);
g_assert(memcmp(c, &child[0], sizeof(struct child)) == 0);
assert(memcmp(c, &child[0], sizeof(struct child)) == 0);
/* delete last node */
list_add(&child[1].node, &parent.children);
list_del(&child[0].node);
c = list_first_entry(&parent.children, struct child, node);
g_assert(memcmp(c, &child[1], sizeof(struct child)) == 0);
assert(memcmp(c, &child[1], sizeof(struct child)) == 0);
/* delete list head */
list_add(&child[0].node, &parent.children);
list_del(&parent.children);
g_assert(list_is_empty(&parent.children));
g_assert(!list_is_empty(&child[1].node));
g_assert(!list_is_empty(&child[2].node));
assert(list_is_empty(&parent.children));
assert(!list_is_empty(&child[1].node));
assert(!list_is_empty(&child[2].node));
}
static void
@ -148,29 +148,26 @@ test_list_for_each(void)
list_add(&child[0].node, &parent.children);
list_for_each_entry(c, &parent.children, node) {
g_assert(memcmp(c, &child[i], sizeof(struct child)) == 0);
assert(memcmp(c, &child[i], sizeof(struct child)) == 0);
i++;
}
/* foreach on empty list */
list_del(&parent.children);
g_assert(list_is_empty(&parent.children));
assert(list_is_empty(&parent.children));
list_for_each_entry(c, &parent.children, node) {
g_assert(0); /* we must not get here */
assert(0); /* we must not get here */
}
}
int main(int argc, char** argv)
{
g_test_init(&argc, &argv,NULL);
g_test_bug_base("https://bugzilla.freedesktop.org/show_bug.cgi?id=");
test_list_init();
test_list_add();
test_list_del();
test_list_for_each();
g_test_add_func("/list/init", test_list_init);
g_test_add_func("/list/add", test_list_add);
g_test_add_func("/list/del", test_list_del);
g_test_add_func("/list/for_each", test_list_for_each);
return g_test_run();
return 0;
}

10
test/xi2/Makefile.am
View File

@ -1,5 +1,4 @@
if ENABLE_UNIT_TESTS
if HAVE_GLIB
if HAVE_LD_WRAP
noinst_PROGRAMS = \
protocol-xiqueryversion \
@ -8,15 +7,16 @@ noinst_PROGRAMS = \
protocol-xigetselectedevents \
protocol-xisetclientpointer \
protocol-xigetclientpointer \
protocol-xipassivegrabdevice \
protocol-xiquerypointer \
protocol-xiwarppointer \
protocol-eventconvert
TESTS=$(noinst_PROGRAMS)
AM_CFLAGS = $(DIX_CFLAGS) $(GLIB_CFLAGS) @XORG_CFLAGS@
AM_CFLAGS = $(DIX_CFLAGS) @XORG_CFLAGS@
INCLUDES = @XORG_INCS@
TEST_LDADD=../libxservertest.la $(XORG_SYS_LIBS) $(XSERVER_SYS_LIBS) $(GLIB_LIBS)
TEST_LDADD=../libxservertest.la $(XORG_SYS_LIBS) $(XSERVER_SYS_LIBS)
COMMON_SOURCES=protocol-common.h protocol-common.c
if SPECIAL_DTRACE_OBJECTS
@ -30,6 +30,7 @@ protocol_xigetselectedevents_LDADD=$(TEST_LDADD)
protocol_xisetclientpointer_LDADD=$(TEST_LDADD)
protocol_xigetclientpointer_LDADD=$(TEST_LDADD)
protocol_xiquerypointer_LDADD=$(TEST_LDADD)
protocol_xipassivegrabdevice_LDADD=$(TEST_LDADD)
protocol_xiwarppointer_LDADD=$(TEST_LDADD)
protocol_eventconvert_LDADD=$(TEST_LDADD)
@ -39,6 +40,7 @@ protocol_xiselectevents_LDFLAGS=$(AM_LDFLAGS) -Wl,-wrap,dixLookupWindow -Wl,-wra
protocol_xigetselectedevents_LDFLAGS=$(AM_LDFLAGS) -Wl,-wrap,WriteToClient -Wl,-wrap,dixLookupWindow -Wl,-wrap,AddResource
protocol_xisetclientpointer_LDFLAGS=$(AM_LDFLAGS) -Wl,-wrap,dixLookupClient
protocol_xigetclientpointer_LDFLAGS=$(AM_LDFLAGS) -Wl,-wrap,WriteToClient -Wl,-wrap,dixLookupClient
protocol_xipassivegrabdevice_LDFLAGS=$(AM_LDFLAGS) -Wl,-wrap,GrabButton -Wl,-wrap,dixLookupWindow -Wl,-wrap,WriteToClient
protocol_xiquerypointer_LDFLAGS=$(AM_LDFLAGS) -Wl,-wrap,WriteToClient -Wl,-wrap,dixLookupWindow
protocol_xiwarppointer_LDFLAGS=$(AM_LDFLAGS) -Wl,-wrap,WriteToClient -Wl,-wrap,dixLookupWindow
@ -49,7 +51,7 @@ protocol_xigetselectedevents_SOURCES=$(COMMON_SOURCES) protocol-xigetselectedeve
protocol_xisetclientpointer_SOURCES=$(COMMON_SOURCES) protocol-xisetclientpointer.c
protocol_xigetclientpointer_SOURCES=$(COMMON_SOURCES) protocol-xigetclientpointer.c
protocol_xiquerypointer_SOURCES=$(COMMON_SOURCES) protocol-xiquerypointer.c
protocol_xipassivegrabdevice_SOURCES=$(COMMON_SOURCES) protocol-xipassivegrabdevice.c
protocol_xiwarppointer_SOURCES=$(COMMON_SOURCES) protocol-xiwarppointer.c
endif
endif
endif

5
test/xi2/protocol-common.c
View File

@ -29,7 +29,6 @@
#include "extinit.h" /* for XInputExtensionInit */
#include "exglobals.h"
#include "xkbsrv.h" /* for XkbInitPrivates */
#include <glib.h>
#include "protocol-common.h"
@ -134,7 +133,7 @@ void init_window(WindowPtr window, WindowPtr parent, int id)
}
window->parent = parent;
window->optional = calloc(1, sizeof(WindowOptRec));
g_assert(window->optional);
assert(window->optional);
}
extern DevPrivateKeyRec miPointerScreenKeyRec;
@ -171,7 +170,7 @@ void init_simple(void)
void __wrap_WriteToClient(ClientPtr client, int len, void *data)
{
g_assert(reply_handler != NULL);
assert(reply_handler != NULL);
(*reply_handler)(client, len, data, userdata);
}

11
test/xi2/protocol-common.h
View File

@ -29,6 +29,7 @@
#include "windowstr.h"
#include "scrnintstr.h"
#include "exevents.h"
#include <assert.h>
#ifndef PROTOCOL_COMMON_H
#define PROTOCOL_COMMON_H
@ -38,11 +39,11 @@ extern int BadDevice;
/* Check default values in a reply */
#define reply_check_defaults(rep, len, type) \
{ \
g_assert((len) >= sz_x##type##Reply); \
g_assert((rep)->repType == X_Reply); \
g_assert((rep)->RepType == X_##type); \
g_assert((rep)->sequenceNumber == CLIENT_SEQUENCE); \
g_assert((rep)->length >= (sz_x##type##Reply - 32)/4); \
assert((len) >= sz_x##type##Reply); \
assert((rep)->repType == X_Reply); \
assert((rep)->RepType == X_##type); \
assert((rep)->sequenceNumber == CLIENT_SEQUENCE); \
assert((rep)->length >= (sz_x##type##Reply - 32)/4); \
}
/* initialise default values for request */

172
test/xi2/protocol-eventconvert.c
View File

@ -25,7 +25,6 @@
#endif
#include <stdint.h>
#include <glib.h>
#include "inputstr.h"
#include "eventstr.h"
@ -33,7 +32,6 @@
#include "exevents.h"
#include <X11/extensions/XI2proto.h>
static void test_values_XIRawEvent(RawDeviceEvent *in, xXIRawEvent *out,
BOOL swap)
{
@ -58,21 +56,21 @@ static void test_values_XIRawEvent(RawDeviceEvent *in, xXIRawEvent *out,
}
g_assert(out->type == GenericEvent);
g_assert(out->extension == 0); /* IReqCode defaults to 0 */
g_assert(out->evtype == GetXI2Type((InternalEvent*)in));
g_assert(out->time == in->time);
g_assert(out->detail == in->detail.button);
g_assert(out->deviceid == in->deviceid);
g_assert(out->valuators_len >= bytes_to_int32(bits_to_bytes(sizeof(in->valuators.mask))));
g_assert(out->flags == 0); /* FIXME: we don't set the flags yet */
assert(out->type == GenericEvent);
assert(out->extension == 0); /* IReqCode defaults to 0 */
assert(out->evtype == GetXI2Type((InternalEvent*)in));
assert(out->time == in->time);
assert(out->detail == in->detail.button);
assert(out->deviceid == in->deviceid);
assert(out->valuators_len >= bytes_to_int32(bits_to_bytes(sizeof(in->valuators.mask))));
assert(out->flags == 0); /* FIXME: we don't set the flags yet */
ptr = (unsigned char*)&out[1];
bits_set = 0;
for (i = 0; out->valuators_len && i < sizeof(in->valuators.mask) * 8; i++)
{
g_assert (XIMaskIsSet(in->valuators.mask, i) == XIMaskIsSet(ptr, i));
assert (XIMaskIsSet(in->valuators.mask, i) == XIMaskIsSet(ptr, i));
if (XIMaskIsSet(in->valuators.mask, i))
bits_set++;
}
@ -81,13 +79,13 @@ static void test_values_XIRawEvent(RawDeviceEvent *in, xXIRawEvent *out,
* set. Each bit set represents 2 8-byte values, hence the
* 'bits_set * 4' */
len = out->valuators_len + bits_set * 4;
g_assert(out->length == len);
assert(out->length == len);
nvals = 0;
for (i = 0; out->valuators_len && i < MAX_VALUATORS; i++)
{
g_assert (XIMaskIsSet(in->valuators.mask, i) == XIMaskIsSet(ptr, i));
assert (XIMaskIsSet(in->valuators.mask, i) == XIMaskIsSet(ptr, i));
if (XIMaskIsSet(in->valuators.mask, i))
{
FP3232 vi, vo;
@ -106,8 +104,8 @@ static void test_values_XIRawEvent(RawDeviceEvent *in, xXIRawEvent *out,
swapl(&vo.frac, n);
}
g_assert(vi.integral == vo.integral);
g_assert(vi.frac == vo.frac);
assert(vi.integral == vo.integral);
assert(vi.frac == vo.frac);
raw_value = value + bits_set;
@ -123,8 +121,8 @@ static void test_values_XIRawEvent(RawDeviceEvent *in, xXIRawEvent *out,
swapl(&vo.frac, n);
}
g_assert(vi.integral == vo.integral);
g_assert(vi.frac == vo.frac);
assert(vi.integral == vo.integral);
assert(vi.frac == vo.frac);
nvals++;
}
@ -137,7 +135,7 @@ static void test_XIRawEvent(RawDeviceEvent *in)
int rc;
rc = EventToXI2((InternalEvent*)in, (xEvent**)&out);
g_assert(rc == Success);
assert(rc == Success);
test_values_XIRawEvent(in, out, FALSE);
@ -158,24 +156,24 @@ static void test_convert_XIFocusEvent(void)
in.header = ET_Internal;
in.type = ET_Enter;
rc = EventToXI2((InternalEvent*)&in, &out);
g_assert(rc == Success);
g_assert(out == NULL);
assert(rc == Success);
assert(out == NULL);
in.header = ET_Internal;
in.type = ET_FocusIn;
rc = EventToXI2((InternalEvent*)&in, &out);
g_assert(rc == Success);
g_assert(out == NULL);
assert(rc == Success);
assert(out == NULL);
in.header = ET_Internal;
in.type = ET_FocusOut;
rc = EventToXI2((InternalEvent*)&in, &out);
g_assert(rc == BadImplementation);
assert(rc == BadImplementation);
in.header = ET_Internal;
in.type = ET_Leave;
rc = EventToXI2((InternalEvent*)&in, &out);
g_assert(rc == BadImplementation);
assert(rc == BadImplementation);
}
@ -186,7 +184,7 @@ static void test_convert_XIRawEvent(void)
memset(&in, 0, sizeof(in));
g_test_message("Testing all event types");
printf("Testing all event types\n");
in.header = ET_Internal;
in.type = ET_RawMotion;
test_XIRawEvent(&in);
@ -207,7 +205,7 @@ static void test_convert_XIRawEvent(void)
in.type = ET_RawButtonRelease;
test_XIRawEvent(&in);
g_test_message("Testing details and other fields");
printf("Testing details and other fields\n");
in.detail.button = 1L;
test_XIRawEvent(&in);
in.detail.button = 1L << 8;
@ -239,7 +237,7 @@ static void test_convert_XIRawEvent(void)
in.deviceid = ~0 & 0xFF;
test_XIRawEvent(&in);
g_test_message("Testing valuator masks");
printf("Testing valuator masks\n");
for (i = 0; i < sizeof(in.valuators.mask) * 8; i++)
{
XISetMask(in.valuators.mask, i);
@ -301,14 +299,14 @@ static void test_values_XIDeviceEvent(DeviceEvent *in, xXIDeviceEvent *out,
swapl(&out->flags, n);
}
g_assert(out->extension == 0); /* IReqCode defaults to 0 */
g_assert(out->evtype == GetXI2Type((InternalEvent*)in));
g_assert(out->time == in->time);
g_assert(out->detail == in->detail.button);
g_assert(out->length >= 12);
assert(out->extension == 0); /* IReqCode defaults to 0 */
assert(out->evtype == GetXI2Type((InternalEvent*)in));
assert(out->time == in->time);
assert(out->detail == in->detail.button);
assert(out->length >= 12);
g_assert(out->deviceid == in->deviceid);
g_assert(out->sourceid == in->sourceid);
assert(out->deviceid == in->deviceid);
assert(out->sourceid == in->sourceid);
switch (in->type) {
case ET_KeyPress:
@ -318,41 +316,41 @@ static void test_values_XIDeviceEvent(DeviceEvent *in, xXIDeviceEvent *out,
flagmask = 0;
break;
}
g_assert((out->flags & ~flagmask) == 0);
assert((out->flags & ~flagmask) == 0);
g_assert(out->root == in->root);
g_assert(out->event == None); /* set in FixUpEventFromWindow */
g_assert(out->child == None); /* set in FixUpEventFromWindow */
assert(out->root == in->root);
assert(out->event == None); /* set in FixUpEventFromWindow */
assert(out->child == None); /* set in FixUpEventFromWindow */
g_assert(out->mods.base_mods == in->mods.base);
g_assert(out->mods.latched_mods == in->mods.latched);
g_assert(out->mods.locked_mods == in->mods.locked);
g_assert(out->mods.effective_mods == in->mods.effective);
assert(out->mods.base_mods == in->mods.base);
assert(out->mods.latched_mods == in->mods.latched);
assert(out->mods.locked_mods == in->mods.locked);
assert(out->mods.effective_mods == in->mods.effective);
g_assert(out->group.base_group == in->group.base);
g_assert(out->group.latched_group == in->group.latched);
g_assert(out->group.locked_group == in->group.locked);
g_assert(out->group.effective_group == in->group.effective);
assert(out->group.base_group == in->group.base);
assert(out->group.latched_group == in->group.latched);
assert(out->group.locked_group == in->group.locked);
assert(out->group.effective_group == in->group.effective);
g_assert(out->event_x == 0); /* set in FixUpEventFromWindow */
g_assert(out->event_y == 0); /* set in FixUpEventFromWindow */
assert(out->event_x == 0); /* set in FixUpEventFromWindow */
assert(out->event_y == 0); /* set in FixUpEventFromWindow */
g_assert(out->root_x == FP1616(in->root_x, in->root_x_frac));
g_assert(out->root_y == FP1616(in->root_y, in->root_y_frac));
assert(out->root_x == FP1616(in->root_x, in->root_x_frac));
assert(out->root_y == FP1616(in->root_y, in->root_y_frac));
buttons = 0;
for (i = 0; i < bits_to_bytes(sizeof(in->buttons)); i++)
{
if (XIMaskIsSet(in->buttons, i))
{
g_assert(out->buttons_len >= bytes_to_int32(bits_to_bytes(i)));
assert(out->buttons_len >= bytes_to_int32(bits_to_bytes(i)));
buttons++;
}
}
ptr = (unsigned char*)&out[1];
for (i = 0; i < sizeof(in->buttons) * 8; i++)
g_assert(XIMaskIsSet(in->buttons, i) == XIMaskIsSet(ptr, i));
assert(XIMaskIsSet(in->buttons, i) == XIMaskIsSet(ptr, i));
valuators = 0;
@ -360,7 +358,7 @@ static void test_values_XIDeviceEvent(DeviceEvent *in, xXIDeviceEvent *out,
if (XIMaskIsSet(in->valuators.mask, i))
valuators++;
g_assert(out->valuators_len >= bytes_to_int32(bits_to_bytes(valuators)));
assert(out->valuators_len >= bytes_to_int32(bits_to_bytes(valuators)));
ptr += out->buttons_len * 4;
values = (FP3232*)(ptr + out->valuators_len * 4);
@ -368,11 +366,11 @@ static void test_values_XIDeviceEvent(DeviceEvent *in, xXIDeviceEvent *out,
i < (out->valuators_len * 4) * 8; i++)
{
if (i > sizeof(in->valuators.mask) * 8)
g_assert(!XIMaskIsSet(ptr, i));
assert(!XIMaskIsSet(ptr, i));
else if (i > out->valuators_len * 4 * 8)
g_assert(!XIMaskIsSet(in->valuators.mask, i));
assert(!XIMaskIsSet(in->valuators.mask, i));
else {
g_assert(XIMaskIsSet(in->valuators.mask, i) ==
assert(XIMaskIsSet(in->valuators.mask, i) ==
XIMaskIsSet(ptr, i));
if (XIMaskIsSet(ptr, i))
@ -392,8 +390,8 @@ static void test_values_XIDeviceEvent(DeviceEvent *in, xXIDeviceEvent *out,
}
g_assert(vi.integral == vo.integral);
g_assert(vi.frac == vo.frac);
assert(vi.integral == vo.integral);
assert(vi.frac == vo.frac);
values++;
}
}
@ -406,7 +404,7 @@ static void test_XIDeviceEvent(DeviceEvent *in)
int rc;
rc = EventToXI2((InternalEvent*)in, (xEvent**)&out);
g_assert(rc == Success);
assert(rc == Success);
test_values_XIDeviceEvent(in, out, FALSE);
@ -425,7 +423,7 @@ static void test_convert_XIDeviceEvent(void)
memset(&in, 0, sizeof(in));
g_test_message("Testing simple field values");
printf("Testing simple field values\n");
in.header = ET_Internal;
in.type = ET_Motion;
in.length = sizeof(DeviceEvent);
@ -449,7 +447,7 @@ static void test_convert_XIDeviceEvent(void)
test_XIDeviceEvent(&in);
g_test_message("Testing field ranges");
printf("Testing field ranges\n");
/* 32 bit */
in.detail.button = 1L;
test_XIDeviceEvent(&in);
@ -597,7 +595,7 @@ static void test_convert_XIDeviceEvent(void)
in.mods.effective = ~0 & 0xFF;
test_XIDeviceEvent(&in);
g_test_message("Testing button masks");
printf("Testing button masks\n");
for (i = 0; i < sizeof(in.buttons) * 8; i++)
{
XISetMask(in.buttons, i);
@ -611,7 +609,7 @@ static void test_convert_XIDeviceEvent(void)
test_XIDeviceEvent(&in);
}
g_test_message("Testing valuator masks");
printf("Testing valuator masks\n");
for (i = 0; i < sizeof(in.valuators.mask) * 8; i++)
{
XISetMask(in.valuators.mask, i);
@ -656,12 +654,12 @@ static void test_values_XIDeviceChangedEvent(DeviceChangedEvent *in,
swaps(&out->num_classes, n);
}
g_assert(out->type == GenericEvent);
g_assert(out->extension == 0); /* IReqCode defaults to 0 */
g_assert(out->evtype == GetXI2Type((InternalEvent*)in));
g_assert(out->time == in->time);
g_assert(out->deviceid == in->deviceid);
g_assert(out->sourceid == in->sourceid);
assert(out->type == GenericEvent);
assert(out->extension == 0); /* IReqCode defaults to 0 */
assert(out->evtype == GetXI2Type((InternalEvent*)in));
assert(out->time == in->time);
assert(out->deviceid == in->deviceid);
assert(out->sourceid == in->sourceid);
ptr = (unsigned char*)&out[1];
for (i = 0; i < out->num_classes; i++)
@ -689,11 +687,11 @@ static void test_values_XIDeviceChangedEvent(DeviceChangedEvent *in,
swaps(&b->num_buttons, n);
}
g_assert(b->length ==
assert(b->length ==
bytes_to_int32(sizeof(xXIButtonInfo)) +
bytes_to_int32(bits_to_bytes(b->num_buttons)) +
b->num_buttons);
g_assert(b->num_buttons == in->buttons.num_buttons);
assert(b->num_buttons == in->buttons.num_buttons);
names = (Atom*)((char*)&b[1] +
pad_to_int32(bits_to_bytes(b->num_buttons)));
@ -704,7 +702,7 @@ static void test_values_XIDeviceChangedEvent(DeviceChangedEvent *in,
char n;
swapl(&names[j], n);
}
g_assert(names[j] == in->buttons.names[j]);
assert(names[j] == in->buttons.names[j]);
}
}
break;
@ -719,10 +717,10 @@ static void test_values_XIDeviceChangedEvent(DeviceChangedEvent *in,
swaps(&k->num_keycodes, n);
}
g_assert(k->length ==
assert(k->length ==
bytes_to_int32(sizeof(xXIKeyInfo)) +
k->num_keycodes);
g_assert(k->num_keycodes == in->keys.max_keycode -
assert(k->num_keycodes == in->keys.max_keycode -
in->keys.min_keycode + 1);
kc = (uint32_t*)&k[1];
@ -733,21 +731,22 @@ static void test_values_XIDeviceChangedEvent(DeviceChangedEvent *in,
char n;
swapl(&kc[j], n);
}
g_assert(kc[j] >= in->keys.min_keycode);
g_assert(kc[j] <= in->keys.max_keycode);
assert(kc[j] >= in->keys.min_keycode);
assert(kc[j] <= in->keys.max_keycode);
}
}
break;
case XIValuatorClass:
{
xXIValuatorInfo *v = (xXIValuatorInfo*)any;
g_assert(v->length ==
assert(v->length ==
bytes_to_int32(sizeof(xXIValuatorInfo)));
}
break;
default:
g_error("Invalid class type.\n");
printf("Invalid class type.\n\n");
assert(1);
break;
}
@ -762,7 +761,7 @@ static void test_XIDeviceChangedEvent(DeviceChangedEvent *in)
int rc;
rc = EventToXI2((InternalEvent*)in, (xEvent**)&out);
g_assert(rc == Success);
assert(rc == Success);
test_values_XIDeviceChangedEvent(in, out, FALSE);
@ -779,7 +778,7 @@ static void test_convert_XIDeviceChangedEvent(void)
DeviceChangedEvent in;
int i;
g_test_message("Testing simple field values");
printf("Testing simple field values\n");
memset(&in, 0, sizeof(in));
in.header = ET_Internal;
in.type = ET_DeviceChanged;
@ -905,13 +904,10 @@ static void test_convert_XIDeviceChangedEvent(void)
int main(int argc, char** argv)
{
g_test_init(&argc, &argv,NULL);
g_test_bug_base("https://bugzilla.freedesktop.org/show_bug.cgi?id=");
test_convert_XIRawEvent();
test_convert_XIFocusEvent();
test_convert_XIDeviceEvent();
test_convert_XIDeviceChangedEvent();
g_test_add_func("/xi2/eventconvert/XIRawEvent", test_convert_XIRawEvent);
g_test_add_func("/xi2/eventconvert/XIFocusEvent", test_convert_XIFocusEvent);
g_test_add_func("/xi2/eventconvert/XIDeviceEvent", test_convert_XIDeviceEvent);
g_test_add_func("/xi2/eventconvert/XIDeviceChangedEvent", test_convert_XIDeviceChangedEvent);
return g_test_run();
return 0;
}

31
test/xi2/protocol-xigetclientpointer.c
View File

@ -39,7 +39,6 @@
#include "exevents.h"
#include "protocol-common.h"
#include <glib.h>
struct {
int cp_is_set;
@ -79,9 +78,9 @@ static void reply_XIGetClientPointer(ClientPtr client, int len, char *data, void
reply_check_defaults(rep, len, XIGetClientPointer);
g_assert(rep->set == test_data.cp_is_set);
assert(rep->set == test_data.cp_is_set);
if (rep->set)
g_assert(rep->deviceid == test_data.dev->id);
assert(rep->deviceid == test_data.dev->id);
}
static void request_XIGetClientPointer(ClientPtr client, xXIGetClientPointerReq* req, int error)
@ -92,19 +91,19 @@ static void request_XIGetClientPointer(ClientPtr client, xXIGetClientPointerReq*
test_data.win = req->win;
rc = ProcXIGetClientPointer(&client_request);
g_assert(rc == error);
assert(rc == error);
if (rc == BadWindow)
g_assert(client_request.errorValue == req->win);
assert(client_request.errorValue == req->win);
client_request.swapped = TRUE;
swapl(&req->win, n);
swaps(&req->length, n);
rc = SProcXIGetClientPointer(&client_request);
g_assert(rc == error);
assert(rc == error);
if (rc == BadWindow)
g_assert(client_request.errorValue == req->win);
assert(client_request.errorValue == req->win);
}
@ -121,21 +120,21 @@ static void test_XIGetClientPointer(void)
client_request = init_client(request.length, &request);
g_test_message("Testing invalid window");
printf("Testing invalid window\n");
request.win = INVALID_WINDOW_ID;
request_XIGetClientPointer(&client_request, &request, BadWindow);
test_data.cp_is_set = FALSE;
g_test_message("Testing window None, unset ClientPointer.");
printf("Testing window None, unset ClientPointer.\n");
request.win = None;
request_XIGetClientPointer(&client_request, &request, Success);
g_test_message("Testing valid window, unset ClientPointer.");
printf("Testing valid window, unset ClientPointer.\n");
request.win = CLIENT_WINDOW_ID;
request_XIGetClientPointer(&client_request, &request, Success);
g_test_message("Testing valid window, set ClientPointer.");
printf("Testing valid window, set ClientPointer.\n");
client_window.clientPtr = devices.vcp;
test_data.dev = devices.vcp;
test_data.cp_is_set = TRUE;
@ -144,7 +143,7 @@ static void test_XIGetClientPointer(void)
client_window.clientPtr = NULL;
g_test_message("Testing window None, set ClientPointer.");
printf("Testing window None, set ClientPointer.\n");
client_request.clientPtr = devices.vcp;
test_data.dev = devices.vcp;
test_data.cp_is_set = TRUE;
@ -154,14 +153,10 @@ static void test_XIGetClientPointer(void)
int main(int argc, char** argv)
{
g_test_init(&argc, &argv,NULL);
g_test_bug_base("https://bugzilla.freedesktop.org/show_bug.cgi?id=");
init_simple();
client_window = init_client(0, NULL);
test_XIGetClientPointer();
g_test_add_func("/xi2/protocol/XIGetClientPointer", test_XIGetClientPointer);
return g_test_run();
return 0;
}

28
test/xi2/protocol-xigetselectedevents.c
View File

@ -48,7 +48,6 @@
#include "exevents.h"
#include "protocol-common.h"
#include <glib.h>
static void reply_XIGetSelectedEvents(ClientPtr client, int len, char *data, void *userdata);
static void reply_XIGetSelectedEvents_data(ClientPtr client, int len, char *data, void *userdata);
@ -100,7 +99,7 @@ static void reply_XIGetSelectedEvents(ClientPtr client, int len, char *data, voi
reply_check_defaults(rep, len, XIGetSelectedEvents);
g_assert(rep->num_masks == test_data.num_masks_expected);
assert(rep->num_masks == test_data.num_masks_expected);
reply_handler = reply_XIGetSelectedEvents_data;
}
@ -121,11 +120,11 @@ static void reply_XIGetSelectedEvents_data(ClientPtr client, int len, char *data
swaps(&mask->mask_len, n);
}
g_assert(mask->deviceid < 6);
g_assert(mask->mask_len <= (((XI2LASTEVENT + 8)/8) + 3)/4) ;
assert(mask->deviceid < 6);
assert(mask->mask_len <= (((XI2LASTEVENT + 8)/8) + 3)/4) ;
bitmask = (unsigned char*)&mask[1];
g_assert(memcmp(bitmask,
assert(memcmp(bitmask,
test_data.mask[mask->deviceid],
mask->mask_len * 4) == 0);
@ -145,14 +144,14 @@ static void request_XIGetSelectedEvents(xXIGetSelectedEventsReq* req, int error)
reply_handler = reply_XIGetSelectedEvents;
rc = ProcXIGetSelectedEvents(&client);
g_assert(rc == error);
assert(rc == error);
reply_handler = reply_XIGetSelectedEvents;
client.swapped = TRUE;
swapl(&req->win, n);
swaps(&req->length, n);
rc = SProcXIGetSelectedEvents(&client);
g_assert(rc == error);
assert(rc == error);
}
static void test_XIGetSelectedEvents(void)
@ -165,11 +164,11 @@ static void test_XIGetSelectedEvents(void)
request_init(&request, XIGetSelectedEvents);
g_test_message("Testing for BadWindow on invalid window.");
printf("Testing for BadWindow on invalid window.\n");
request.win = None;
request_XIGetSelectedEvents(&request, BadWindow);
g_test_message("Testing for zero-length (unset) masks.");
printf("Testing for zero-length (unset) masks.\n");
/* No masks set yet */
test_data.num_masks_expected = 0;
request.win = ROOT_WINDOW_ID;
@ -181,7 +180,7 @@ static void test_XIGetSelectedEvents(void)
memset(test_data.mask, 0,
sizeof(test_data.mask));
g_test_message("Testing for valid masks");
printf("Testing for valid masks\n");
memset(&dev, 0, sizeof(dev)); /* dev->id is enough for XISetEventMask */
request.win = ROOT_WINDOW_ID;
@ -210,7 +209,7 @@ static void test_XIGetSelectedEvents(void)
}
}
g_test_message("Testing removing all masks");
printf("Testing removing all masks\n");
/* Unset all masks one-by-one */
for (j = MAXDEVICES - 1; j >= 0; j--)
{
@ -229,13 +228,10 @@ static void test_XIGetSelectedEvents(void)
int main(int argc, char** argv)
{
g_test_init(&argc, &argv,NULL);
g_test_bug_base("https://bugzilla.freedesktop.org/show_bug.cgi?id=");
init_simple();
g_test_add_func("/xi2/protocol/XIGetSelectedEvents", test_XIGetSelectedEvents);
test_XIGetSelectedEvents();
return g_test_run();
return 0;
}

234
test/xi2/protocol-xipassivegrabdevice.c Normal file
View File

@ -0,0 +1,234 @@
/**
* Copyright © 2011 Red Hat, Inc.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice (including the next
* paragraph) shall be included in all copies or substantial portions of the
* Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*/
#ifdef HAVE_DIX_CONFIG_H
#include <dix-config.h>
#endif
/*
* Protocol testing for XIPassiveGrab request.
*/
#include <stdint.h>
#include <X11/X.h>
#include <X11/Xproto.h>
#include <X11/extensions/XI2proto.h>
#include "inputstr.h"
#include "windowstr.h"
#include "scrnintstr.h"
#include "xipassivegrab.h"
#include "exevents.h"
#include "protocol-common.h"
static ClientRec client_request;
#define N_MODS 7
static uint32_t modifiers[N_MODS] = {1, 2, 3, 4, 5, 6, 7};
struct test_data {
int num_modifiers;
} testdata;
int __wrap_GrabButton(ClientPtr client, DeviceIntPtr dev, DeviceIntPtr modifier_device,
int button, GrabParameters *param, GrabType grabtype,
GrabMask *mask);
static void reply_XIPassiveGrabDevice_data(ClientPtr client, int len, char *data, void *userdata);
int __wrap_dixLookupWindow(WindowPtr *win, XID id, ClientPtr client, Mask access)
{
if (id == root.drawable.id)
{
*win = &root;
return Success;
} else if (id == window.drawable.id)
{
*win = &window;
return Success;
}
return __real_dixLookupWindow(win, id, client, access);
}
int __wrap_GrabButton(ClientPtr client, DeviceIntPtr dev, DeviceIntPtr modifier_device,
int button, GrabParameters *param, GrabType grabtype,
GrabMask *mask)
{
/* Fail every odd modifier */
if (param->modifiers % 2)
return BadAccess;
return Success;
}
static void reply_XIPassiveGrabDevice(ClientPtr client, int len, char *data, void *userdata)
{
xXIPassiveGrabDeviceReply *rep = (xXIPassiveGrabDeviceReply*)data;
if (client->swapped)
{
char n;
swaps(&rep->sequenceNumber, n);
swapl(&rep->length, n);
swaps(&rep->num_modifiers, n);
testdata.num_modifiers = rep->num_modifiers;
}
reply_check_defaults(rep, len, XIPassiveGrabDevice);
/* ProcXIPassiveGrabDevice sends the data in two batches, let the second
* handler handle the modifier data */
if (rep->num_modifiers > 0)
reply_handler = reply_XIPassiveGrabDevice_data;
}
static void reply_XIPassiveGrabDevice_data(ClientPtr client, int len, char *data, void *userdata)
{
int i;
int n;
xXIGrabModifierInfo *mods = (xXIGrabModifierInfo*)data;
for (i = 0; i < testdata.num_modifiers; i++, mods++)
{
if (client->swapped)
swapl(&mods->modifiers, n);
/* 1 - 7 is the range we use for the global modifiers array
* above */
assert(mods->modifiers > 0);
assert(mods->modifiers <= 7);
assert(mods->modifiers % 2 == 1); /* because we fail odd ones */
assert(mods->status != Success);
assert(mods->pad0 == 0);
assert(mods->pad1 == 0);
}
reply_handler = reply_XIPassiveGrabDevice;
}
static void request_XIPassiveGrabDevice(ClientPtr client, xXIPassiveGrabDeviceReq* req, int error, int errval)
{
char n;
int rc;
int modifiers;
rc = ProcXIPassiveGrabDevice(&client_request);
assert(rc == error);
if (rc != Success)
assert(client_request.errorValue == errval);
client_request.swapped = TRUE;
swaps(&req->length, n);
swapl(&req->time, n);
swapl(&req->grab_window, n);
swapl(&req->cursor, n);
swapl(&req->detail, n);
swaps(&req->deviceid, n);
modifiers = req->num_modifiers;
swaps(&req->num_modifiers, n);
swaps(&req->mask_len, n);
while(modifiers--)
{
CARD32 *mod = ((CARD32*)(req + 1)) + modifiers;
swapl(mod, n);
}
rc = SProcXIPassiveGrabDevice(&client_request);
assert(rc == error);
if (rc != Success)
assert(client_request.errorValue == errval);
}
static unsigned char *data[4096]; /* the request buffer */
static void test_XIPassiveGrabDevice(void)
{
int i;
xXIPassiveGrabDeviceReq *request = (xXIPassiveGrabDeviceReq*)data;
unsigned char *mask;
request_init(request, XIPassiveGrabDevice);
request->grab_window = CLIENT_WINDOW_ID;
reply_handler = reply_XIPassiveGrabDevice;
client_request = init_client(request->length, request);
printf("Testing invalid device\n");
request->deviceid = 12;
request_XIPassiveGrabDevice(&client_request, request, BadDevice, request->deviceid);
request->deviceid = XIAllMasterDevices;
printf("Testing invalid grab types\n");
for (i = XIGrabtypeFocusIn + 1; i < 0xFF; i++)
{
request->grab_type = i;
request_XIPassiveGrabDevice(&client_request, request, BadValue, request->grab_type);
}
printf("Testing invalid grab type + detail combinations\n");
request->grab_type = XIGrabtypeEnter;
request->detail = 1;
request_XIPassiveGrabDevice(&client_request, request, BadValue, request->detail);
request->grab_type = XIGrabtypeFocusIn;
request_XIPassiveGrabDevice(&client_request, request, BadValue, request->detail);
request->detail = 0;
printf("Testing invalid masks\n");
mask = (unsigned char*)&request[1];
request->mask_len = bytes_to_int32(XI2LASTEVENT + 1);
request->length += request->mask_len;
SetBit(mask, XI2LASTEVENT + 1);
request_XIPassiveGrabDevice(&client_request, request, BadValue, XI2LASTEVENT + 1);
ClearBit(mask, XI2LASTEVENT + 1);
/* tested all special cases now, test a few valid cases */
/* no modifiers */
request->deviceid = XIAllDevices;
request->grab_type = XIGrabtypeButton;
request->detail = XIAnyButton;
request_XIPassiveGrabDevice(&client_request, request, Success, 0);
/* some modifiers */
request->num_modifiers = N_MODS;
request->length += N_MODS;
memcpy((uint32_t*)(request + 1) + request->mask_len, modifiers, sizeof(modifiers));
request_XIPassiveGrabDevice(&client_request, request, Success, 0);
}
int main(int argc, char** argv)
{
init_simple();
test_XIPassiveGrabDevice();
return 0;
}

98
test/xi2/protocol-xiquerydevice.c
View File

@ -38,7 +38,6 @@
#include "xiquerydevice.h"
#include "protocol-common.h"
#include <glib.h>
/*
* Protocol testing for XIQueryDevice request and reply.
*
@ -74,11 +73,11 @@ static void reply_XIQueryDevice(ClientPtr client, int len, char* data, void *use
reply_check_defaults(rep, len, XIQueryDevice);
if (querydata->which_device == XIAllDevices)
g_assert(rep->num_devices == devices.num_devices);
assert(rep->num_devices == devices.num_devices);
else if (querydata->which_device == XIAllMasterDevices)
g_assert(rep->num_devices == devices.num_master_devices);
assert(rep->num_devices == devices.num_master_devices);
else
g_assert(rep->num_devices == 1);
assert(rep->num_devices == 1);
querydata->num_devices_in_reply = rep->num_devices;
reply_handler = reply_XIQueryDevice_data;
@ -107,46 +106,46 @@ static void reply_XIQueryDevice_data(ClientPtr client, int len, char *data, void
}
if (querydata->which_device > XIAllMasterDevices)
g_assert(info->deviceid == querydata->which_device);
assert(info->deviceid == querydata->which_device);
g_assert(info->deviceid >= 2); /* 0 and 1 is reserved */
assert(info->deviceid >= 2); /* 0 and 1 is reserved */
switch(info->deviceid)
{
case 2: /* VCP */
dev = devices.vcp;
g_assert(info->use == XIMasterPointer);
g_assert(info->attachment == devices.vck->id);
g_assert(info->num_classes == 3); /* 2 axes + button */
assert(info->use == XIMasterPointer);
assert(info->attachment == devices.vck->id);
assert(info->num_classes == 3); /* 2 axes + button */
break;
case 3: /* VCK */
dev = devices.vck;
g_assert(info->use == XIMasterKeyboard);
g_assert(info->attachment == devices.vcp->id);
g_assert(info->num_classes == 1);
assert(info->use == XIMasterKeyboard);
assert(info->attachment == devices.vcp->id);
assert(info->num_classes == 1);
break;
case 4: /* mouse */
dev = devices.mouse;
g_assert(info->use == XISlavePointer);
g_assert(info->attachment == devices.vcp->id);
g_assert(info->num_classes == 3); /* 2 axes + button */
assert(info->use == XISlavePointer);
assert(info->attachment == devices.vcp->id);
assert(info->num_classes == 3); /* 2 axes + button */
break;
case 5: /* keyboard */
dev = devices.kbd;
g_assert(info->use == XISlaveKeyboard);
g_assert(info->attachment == devices.vck->id);
g_assert(info->num_classes == 1);
assert(info->use == XISlaveKeyboard);
assert(info->attachment == devices.vck->id);
assert(info->num_classes == 1);
break;
default:
/* We shouldn't get here */
g_assert(0);
assert(0);
break;
}
g_assert(info->enabled == dev->enabled);
g_assert(info->name_len == strlen(dev->name));
g_assert(strncmp((char*)&info[1], dev->name, info->name_len) == 0);
assert(info->enabled == dev->enabled);
assert(info->name_len == strlen(dev->name));
assert(strncmp((char*)&info[1], dev->name, info->name_len) == 0);
any = (xXIAnyInfo*)((char*)&info[1] + ((info->name_len + 3)/4) * 4);
for (j = 0; j < info->num_classes; j++)
@ -171,9 +170,9 @@ static void reply_XIQueryDevice_data(ClientPtr client, int len, char *data, void
if (client->swapped)
swaps(&ki->num_keycodes, n);
g_assert(any->type == XIKeyClass);
g_assert(ki->num_keycodes == (xkb->max_key_code - xkb->min_key_code + 1));
g_assert(any->length == (2 + ki->num_keycodes));
assert(any->type == XIKeyClass);
assert(ki->num_keycodes == (xkb->max_key_code - xkb->min_key_code + 1));
assert(any->length == (2 + ki->num_keycodes));
kc = (uint32_t*)&ki[1];
for (k = 0; k < ki->num_keycodes; k++, kc++)
@ -181,15 +180,15 @@ static void reply_XIQueryDevice_data(ClientPtr client, int len, char *data, void
if (client->swapped)
swapl(kc, n);
g_assert(*kc >= xkb->min_key_code);
g_assert(*kc <= xkb->max_key_code);
assert(*kc >= xkb->min_key_code);
assert(*kc <= xkb->max_key_code);
}
break;
}
case 2: /* VCP and mouse have the same properties */
case 4:
{
g_assert(any->type == XIButtonClass ||
assert(any->type == XIButtonClass ||
any->type == XIValuatorClass);
if (any->type == XIButtonClass)
@ -200,10 +199,10 @@ static void reply_XIQueryDevice_data(ClientPtr client, int len, char *data, void
if (client->swapped)
swaps(&bi->num_buttons, n);
g_assert(bi->num_buttons == devices.vcp->button->numButtons);
assert(bi->num_buttons == devices.vcp->button->numButtons);
len = 2 + bi->num_buttons + bytes_to_int32(bits_to_bytes(bi->num_buttons));
g_assert(bi->length == len);
assert(bi->length == len);
} else if (any->type == XIValuatorClass)
{
xXIValuatorInfo *vi = (xXIValuatorInfo*)any;
@ -219,17 +218,17 @@ static void reply_XIQueryDevice_data(ClientPtr client, int len, char *data, void
swapl(&vi->resolution, n);
}
g_assert(vi->length == 11);
g_assert(vi->number == 0 ||
assert(vi->length == 11);
assert(vi->number == 0 ||
vi->number == 1);
g_assert(vi->mode == XIModeRelative);
assert(vi->mode == XIModeRelative);
/* device was set up as relative, so standard
* values here. */
g_assert(vi->min.integral == -1);
g_assert(vi->min.frac == 0);
g_assert(vi->max.integral == -1);
g_assert(vi->max.frac == 0);
g_assert(vi->resolution == 0);
assert(vi->min.integral == -1);
assert(vi->min.frac == 0);
assert(vi->max.integral == -1);
assert(vi->max.frac == 0);
assert(vi->resolution == 0);
}
}
break;
@ -257,10 +256,10 @@ static void request_XIQueryDevice(struct test_data *querydata,
request.deviceid = deviceid;
rc = ProcXIQueryDevice(&client);
g_assert(rc == error);
assert(rc == error);
if (rc != Success)
g_assert(client.errorValue == deviceid);
assert(client.errorValue == deviceid);
reply_handler = reply_XIQueryDevice;
@ -268,10 +267,10 @@ static void request_XIQueryDevice(struct test_data *querydata,
swaps(&request.length, n);
swaps(&request.deviceid, n);
rc = SProcXIQueryDevice(&client);
g_assert(rc == error);
assert(rc == error);
if (rc != Success)
g_assert(client.errorValue == deviceid);
assert(client.errorValue == deviceid);
}
static void test_XIQueryDevice(void)
@ -284,16 +283,16 @@ static void test_XIQueryDevice(void)
userdata = &data;
request_init(&request, XIQueryDevice);
g_test_message("Testing XIAllDevices.");
printf("Testing XIAllDevices.\n");
request_XIQueryDevice(&data, XIAllDevices, Success);
g_test_message("Testing XIAllMasterDevices.");
printf("Testing XIAllMasterDevices.\n");
request_XIQueryDevice(&data, XIAllMasterDevices, Success);
g_test_message("Testing existing device ids.");
printf("Testing existing device ids.\n");
for (i = 2; i < 6; i++)
request_XIQueryDevice(&data, i, Success);
g_test_message("Testing non-existing device ids.");
printf("Testing non-existing device ids.\n");
for (i = 6; i <= 0xFFFF; i++)
request_XIQueryDevice(&data, i, BadDevice);
@ -304,13 +303,10 @@ static void test_XIQueryDevice(void)
int main(int argc, char** argv)
{
g_test_init(&argc, &argv,NULL);
g_test_bug_base("https://bugzilla.freedesktop.org/show_bug.cgi?id=");
init_simple();
g_test_add_func("/dix/xi2protocol/XIQueryDevice", test_XIQueryDevice);
test_XIQueryDevice();
return g_test_run();
return 0;
}

38
test/xi2/protocol-xiquerypointer.c
View File

@ -39,7 +39,6 @@
#include "exevents.h"
#include "protocol-common.h"
#include <glib.h>
static ClientRec client_request;
static void reply_XIQueryPointer_data(ClientPtr client, int len,
@ -96,18 +95,18 @@ static void reply_XIQueryPointer(ClientPtr client, int len, char *data,
reply_check_defaults(rep, len, XIQueryPointer);
g_assert(rep->root == root.drawable.id);
g_assert(rep->same_screen == xTrue);
assert(rep->root == root.drawable.id);
assert(rep->same_screen == xTrue);
sprite = test_data.dev->spriteInfo->sprite;
g_assert((rep->root_x >> 16) == sprite->hot.x);
g_assert((rep->root_y >> 16) == sprite->hot.y);
assert((rep->root_x >> 16) == sprite->hot.x);
assert((rep->root_y >> 16) == sprite->hot.y);
if (test_data.win == &root)
{
g_assert(rep->root_x == rep->win_x);
g_assert(rep->root_y == rep->win_y);
g_assert(rep->child == window.drawable.id);
assert(rep->root_x == rep->win_x);
assert(rep->root_y == rep->win_y);
assert(rep->child == window.drawable.id);
} else
{
int x, y;
@ -115,13 +114,13 @@ static void reply_XIQueryPointer(ClientPtr client, int len, char *data,
x = sprite->hot.x - window.drawable.x;
y = sprite->hot.y - window.drawable.y;
g_assert((rep->win_x >> 16) == x);
g_assert((rep->win_y >> 16) == y);
g_assert(rep->child == None);
assert((rep->win_x >> 16) == x);
assert((rep->win_y >> 16) == y);
assert(rep->child == None);
}
g_assert(rep->same_screen == xTrue);
assert(rep->same_screen == xTrue);
reply_handler = reply_XIQueryPointer_data;
}
@ -137,19 +136,19 @@ static void request_XIQueryPointer(ClientPtr client, xXIQueryPointerReq* req, in
int rc;
rc = ProcXIQueryPointer(&client_request);
g_assert(rc == error);
assert(rc == error);
if (rc == BadDevice)
g_assert(client_request.errorValue == req->deviceid);
assert(client_request.errorValue == req->deviceid);
client_request.swapped = TRUE;
swaps(&req->deviceid, n);
swaps(&req->length, n);
rc = SProcXIQueryPointer(&client_request);
g_assert(rc == error);
assert(rc == error);
if (rc == BadDevice)
g_assert(client_request.errorValue == req->deviceid);
assert(client_request.errorValue == req->deviceid);
}
static void test_XIQueryPointer(void)
@ -209,12 +208,9 @@ static void test_XIQueryPointer(void)
int main(int argc, char** argv)
{
g_test_init(&argc, &argv,NULL);
g_test_bug_base("https://bugzilla.freedesktop.org/show_bug.cgi?id=");
init_simple();
g_test_add_func("/xi2/protocol/XIQueryPointer", test_XIQueryPointer);
test_XIQueryPointer();
return g_test_run();
return 0;
}

28
test/xi2/protocol-xiqueryversion.c
View File

@ -46,7 +46,6 @@
#include "xiqueryversion.h"
#include "protocol-common.h"
#include <glib.h>
extern XExtensionVersion XIVersion;
@ -74,14 +73,14 @@ static void reply_XIQueryVersion(ClientPtr client, int len, char* data, void *us
reply_check_defaults(rep, len, XIQueryVersion);
g_assert(rep->length == 0);
assert(rep->length == 0);
sver = versions->major_server * 1000 + versions->minor_server;
cver = versions->major_client * 1000 + versions->minor_client;
ver = rep->major_version * 1000 + rep->minor_version;
g_assert(ver >= 2000);
g_assert((sver > cver) ? ver == cver : ver == sver);
assert(ver >= 2000);
assert((sver > cver) ? ver == cver : ver == sver);
}
/**
@ -115,7 +114,7 @@ static void request_XIQueryVersion(int smaj, int smin, int cmaj, int cmin, int e
request.major_version = versions.major_client;
request.minor_version = versions.minor_client;
rc = ProcXIQueryVersion(&client);
g_assert(rc == error);
assert(rc == error);
client.swapped = TRUE;
@ -124,7 +123,7 @@ static void request_XIQueryVersion(int smaj, int smin, int cmaj, int cmin, int e
swaps(&request.minor_version, n);
rc = SProcXIQueryVersion(&client);
g_assert(rc == error);
assert(rc == error);
}
/* Client version less than 2.0 must return BadValue, all other combinations
@ -133,23 +132,23 @@ static void test_XIQueryVersion(void)
{
reply_handler = reply_XIQueryVersion;
g_test_message("Server version 2.0 - client versions [1..3].0");
printf("Server version 2.0 - client versions [1..3].0\n");
/* some simple tests to catch common errors quickly */
request_XIQueryVersion(2, 0, 1, 0, BadValue);
request_XIQueryVersion(2, 0, 2, 0, Success);
request_XIQueryVersion(2, 0, 3, 0, Success);
g_test_message("Server version 3.0 - client versions [1..3].0");
printf("Server version 3.0 - client versions [1..3].0\n");
request_XIQueryVersion(3, 0, 1, 0, BadValue);
request_XIQueryVersion(3, 0, 2, 0, Success);
request_XIQueryVersion(3, 0, 3, 0, Success);
g_test_message("Server version 2.0 - client versions [1..3].[1..3]");
printf("Server version 2.0 - client versions [1..3].[1..3]\n");
request_XIQueryVersion(2, 0, 1, 1, BadValue);
request_XIQueryVersion(2, 0, 2, 2, Success);
request_XIQueryVersion(2, 0, 3, 3, Success);
g_test_message("Server version 2.2 - client versions [1..3].0");
printf("Server version 2.2 - client versions [1..3].0\n");
request_XIQueryVersion(2, 2, 1, 0, BadValue);
request_XIQueryVersion(2, 2, 2, 0, Success);
request_XIQueryVersion(2, 2, 3, 0, Success);
@ -158,7 +157,7 @@ static void test_XIQueryVersion(void)
/* this one takes a while */
unsigned int cmin, cmaj, smin, smaj;
g_test_message("Testing all combinations.");
printf("Testing all combinations.\n");
for (smaj = 2; smaj <= 0xFFFF; smaj++)
for (smin = 0; smin <= 0xFFFF; smin++)
for (cmin = 0; cmin <= 0xFFFF; cmin++)
@ -175,12 +174,9 @@ static void test_XIQueryVersion(void)
int main(int argc, char** argv)
{
g_test_init(&argc, &argv,NULL);
g_test_bug_base("https://bugzilla.freedesktop.org/show_bug.cgi?id=");
init_simple();
g_test_add_func("/xi2/protocol/XIQueryVersion", test_XIQueryVersion);
test_XIQueryVersion();
return g_test_run();
return 0;
}

24
test/xi2/protocol-xiselectevents.c
View File

@ -58,7 +58,6 @@
#include "xiselectev.h"
#include "protocol-common.h"
#include <glib.h>
static unsigned char *data[4096 * 20]; /* the request data buffer */
@ -107,7 +106,7 @@ static void request_XISelectEvent(xXISelectEventsReq *req, int error)
client = init_client(req->length, req);
rc = ProcXISelectEvents(&client);
g_assert(rc == error);
assert(rc == error);
client.swapped = TRUE;
@ -124,7 +123,7 @@ static void request_XISelectEvent(xXISelectEventsReq *req, int error)
swaps(&req->length, n);
swaps(&req->num_masks, n);
rc = SProcXISelectEvents(&client);
g_assert(rc == error);
assert(rc == error);
}
static void request_XISelectEvents_masks(xXISelectEventsReq *req)
@ -250,7 +249,7 @@ static void test_XISelectEvents(void)
request_init(req, XISelectEvents);
g_test_message("Testing for BadValue on zero-length masks");
printf("Testing for BadValue on zero-length masks\n");
/* zero masks are BadValue, regardless of the window */
req->num_masks = 0;
@ -263,7 +262,7 @@ static void test_XISelectEvents(void)
req->win = CLIENT_WINDOW_ID;
request_XISelectEvent(req, BadValue);
g_test_message("Testing for BadWindow.");
printf("Testing for BadWindow.\n");
/* None window is BadWindow, regardless of the masks.
* We don't actually need to set the masks here, BadWindow must occur
* before checking the masks.
@ -283,7 +282,7 @@ static void test_XISelectEvents(void)
req->num_masks = 0xFFFC;
request_XISelectEvent(req, BadWindow);
g_test_message("Triggering num_masks/length overflow");
printf("Triggering num_masks/length overflow\n");
req->win = ROOT_WINDOW_ID;
/* Integer overflow - req->length can't hold that much */
req->num_masks = 0xFFFF;
@ -292,14 +291,14 @@ static void test_XISelectEvents(void)
req->win = ROOT_WINDOW_ID;
req->num_masks = 1;
g_test_message("Triggering bogus mask length error");
printf("Triggering bogus mask length error\n");
mask = (xXIEventMask*)&req[1];
mask->deviceid = 0;
mask->mask_len = 0xFFFF;
request_XISelectEvent(req, BadLength);
/* testing various device ids */
g_test_message("Testing existing device ids.");
printf("Testing existing device ids.\n");
for (i = 0; i < 6; i++)
{
mask = (xXIEventMask*)&req[1];
@ -310,7 +309,7 @@ static void test_XISelectEvents(void)
request_XISelectEvent(req, Success);
}
g_test_message("Testing non-existing device ids.");
printf("Testing non-existing device ids.\n");
for (i = 6; i <= 0xFFFF; i++)
{
req->win = ROOT_WINDOW_ID;
@ -326,13 +325,10 @@ static void test_XISelectEvents(void)
int main(int argc, char** argv)
{
g_test_init(&argc, &argv,NULL);
g_test_bug_base("https://bugzilla.freedesktop.org/show_bug.cgi?id=");
init_simple();
g_test_add_func("/xi2/protocol/XISelectEvents", test_XISelectEvents);
test_XISelectEvents();
return g_test_run();
return 0;
}

32
test/xi2/protocol-xisetclientpointer.c
View File

@ -46,7 +46,6 @@
#include "exevents.h"
#include "protocol-common.h"
#include <glib.h>
static ClientRec client_window;
static ClientRec client_request;
@ -72,20 +71,20 @@ static void request_XISetClientPointer(xXISetClientPointerReq* req, int error)
client_request = init_client(req->length, req);
rc = ProcXISetClientPointer(&client_request);
g_assert(rc == error);
assert(rc == error);
if (rc == BadDevice)
g_assert(client_request.errorValue == req->deviceid);
assert(client_request.errorValue == req->deviceid);
client_request.swapped = TRUE;
swapl(&req->win, n);
swaps(&req->length, n);
swaps(&req->deviceid, n);
rc = SProcXISetClientPointer(&client_request);
g_assert(rc == error);
assert(rc == error);
if (rc == BadDevice)
g_assert(client_request.errorValue == req->deviceid);
assert(client_request.errorValue == req->deviceid);
}
@ -98,36 +97,36 @@ static void test_XISetClientPointer(void)
request.win = CLIENT_WINDOW_ID;
g_test_message("Testing BadDevice error for XIAllDevices and XIMasterDevices.");
printf("Testing BadDevice error for XIAllDevices and XIMasterDevices.\n");
request.deviceid = XIAllDevices;
request_XISetClientPointer(&request, BadDevice);
request.deviceid = XIAllMasterDevices;
request_XISetClientPointer(&request, BadDevice);
g_test_message("Testing Success for VCP and VCK.");
printf("Testing Success for VCP and VCK.\n");
request.deviceid = devices.vcp->id; /* 2 */
request_XISetClientPointer(&request, Success);
g_assert(client_window.clientPtr->id == 2);
assert(client_window.clientPtr->id == 2);
request.deviceid = devices.vck->id; /* 3 */
request_XISetClientPointer(&request, Success);
g_assert(client_window.clientPtr->id == 2);
assert(client_window.clientPtr->id == 2);
g_test_message("Testing BadDevice error for all other devices.");
printf("Testing BadDevice error for all other devices.\n");
for (i = 4; i <= 0xFFFF; i++)
{
request.deviceid = i;
request_XISetClientPointer(&request, BadDevice);
}
g_test_message("Testing window None");
printf("Testing window None\n");
request.win = None;
request.deviceid = devices.vcp->id; /* 2 */
request_XISetClientPointer(&request, Success);
g_assert(client_request.clientPtr->id == 2);
assert(client_request.clientPtr->id == 2);
g_test_message("Testing invalid window");
printf("Testing invalid window\n");
request.win = INVALID_WINDOW_ID;
request.deviceid = devices.vcp->id;
request_XISetClientPointer(&request, BadWindow);
@ -137,13 +136,10 @@ static void test_XISetClientPointer(void)
int main(int argc, char** argv)
{
g_test_init(&argc, &argv,NULL);
g_test_bug_base("https://bugzilla.freedesktop.org/show_bug.cgi?id=");
init_simple();
client_window = init_client(0, NULL);
g_test_add_func("/xi2/protocol/XISetClientPointer", test_XISetClientPointer);
test_XISetClientPointer();
return g_test_run();
return 0;
}

24
test/xi2/protocol-xiwarppointer.c
View File

@ -39,7 +39,6 @@
#include "exevents.h"
#include "protocol-common.h"
#include <glib.h>
static int expected_x = SPRITE_X;
static int expected_y = SPRITE_Y;
@ -70,8 +69,8 @@ int __wrap_dixLookupWindow(WindowPtr *win, XID id, ClientPtr client, Mask access
static Bool ScreenSetCursorPosition(DeviceIntPtr dev, ScreenPtr screen,
int x, int y, Bool generateEvent)
{
g_assert(x == expected_x);
g_assert(y == expected_y);
assert(x == expected_x);
assert(y == expected_y);
return TRUE;
}
@ -83,12 +82,12 @@ static void request_XIWarpPointer(ClientPtr client, xXIWarpPointerReq* req,
int rc;
rc = ProcXIWarpPointer(client);
g_assert(rc == error);
assert(rc == error);
if (rc == BadDevice)
g_assert(client->errorValue == req->deviceid);
assert(client->errorValue == req->deviceid);
else if (rc == BadWindow)
g_assert(client->errorValue == req->dst_win ||
assert(client->errorValue == req->dst_win ||
client->errorValue == req->src_win);
@ -105,12 +104,12 @@ static void request_XIWarpPointer(ClientPtr client, xXIWarpPointerReq* req,
swaps(&req->deviceid, n);
rc = SProcXIWarpPointer(client);
g_assert(rc == error);
assert(rc == error);
if (rc == BadDevice)
g_assert(client->errorValue == req->deviceid);
assert(client->errorValue == req->deviceid);
else if (rc == BadWindow)
g_assert(client->errorValue == req->dst_win ||
assert(client->errorValue == req->dst_win ||
client->errorValue == req->src_win);
client->swapped = FALSE;
@ -204,13 +203,10 @@ static void test_XIWarpPointer(void)
int main(int argc, char** argv)
{
g_test_init(&argc, &argv,NULL);
g_test_bug_base("https://bugzilla.freedesktop.org/show_bug.cgi?id=");
init_simple();
screen.SetCursorPosition = ScreenSetCursorPosition;
g_test_add_func("/xi2/protocol/XIWarpPointer", test_XIWarpPointer);
test_XIWarpPointer();
return g_test_run();
return 0;
}

74
test/xkb.c
View File

@ -46,8 +46,7 @@
#include <X11/extensions/XKMformat.h>
#include "xkbfile.h"
#include "../xkb/xkb.h"
#include <glib.h>
#include <assert.h>
/**
* Initialize an empty XkbRMLVOSet.
@ -62,16 +61,16 @@ static void xkb_get_rules_test(void)
XkbGetRulesDflts(&rmlvo);
g_assert(rmlvo.rules);
g_assert(rmlvo.model);
g_assert(rmlvo.layout);
g_assert(rmlvo.variant);
g_assert(rmlvo.options);
g_assert(strcmp(rmlvo.rules, XKB_DFLT_RULES) == 0);
g_assert(strcmp(rmlvo.model, XKB_DFLT_MODEL) == 0);
g_assert(strcmp(rmlvo.layout, XKB_DFLT_LAYOUT) == 0);
g_assert(strcmp(rmlvo.variant, XKB_DFLT_VARIANT) == 0);
g_assert(strcmp(rmlvo.options, XKB_DFLT_OPTIONS) == 0);
assert(rmlvo.rules);
assert(rmlvo.model);
assert(rmlvo.layout);
assert(rmlvo.variant);
assert(rmlvo.options);
assert(strcmp(rmlvo.rules, XKB_DFLT_RULES) == 0);
assert(strcmp(rmlvo.model, XKB_DFLT_MODEL) == 0);
assert(strcmp(rmlvo.layout, XKB_DFLT_LAYOUT) == 0);
assert(strcmp(rmlvo.variant, XKB_DFLT_VARIANT) == 0);
assert(strcmp(rmlvo.options, XKB_DFLT_OPTIONS) == 0);
}
/**
@ -95,17 +94,17 @@ static void xkb_set_rules_test(void)
XkbGetRulesDflts(&rmlvo_new);
/* XkbGetRulesDflts strdups the values */
g_assert(rmlvo.rules != rmlvo_new.rules);
g_assert(rmlvo.model != rmlvo_new.model);
g_assert(rmlvo.layout != rmlvo_new.layout);
g_assert(rmlvo.variant != rmlvo_new.variant);
g_assert(rmlvo.options != rmlvo_new.options);
assert(rmlvo.rules != rmlvo_new.rules);
assert(rmlvo.model != rmlvo_new.model);
assert(rmlvo.layout != rmlvo_new.layout);
assert(rmlvo.variant != rmlvo_new.variant);
assert(rmlvo.options != rmlvo_new.options);
g_assert(strcmp(rmlvo.rules, rmlvo_new.rules) == 0);
g_assert(strcmp(rmlvo.model, rmlvo_new.model) == 0);
g_assert(strcmp(rmlvo.layout, rmlvo_new.layout) == 0);
g_assert(strcmp(rmlvo.variant, rmlvo_new.variant) == 0);
g_assert(strcmp(rmlvo.options, rmlvo_new.options) == 0);
assert(strcmp(rmlvo.rules, rmlvo_new.rules) == 0);
assert(strcmp(rmlvo.model, rmlvo_new.model) == 0);
assert(strcmp(rmlvo.layout, rmlvo_new.layout) == 0);
assert(strcmp(rmlvo.variant, rmlvo_new.variant) == 0);
assert(strcmp(rmlvo.options, rmlvo_new.options) == 0);
}
@ -145,29 +144,26 @@ static void xkb_set_get_rules_test(void)
/* This test is iffy, because strictly we may be comparing against already
* freed memory */
g_assert(strcmp(rmlvo.rules, rmlvo_backup.rules) == 0);
g_assert(strcmp(rmlvo.model, rmlvo_backup.model) == 0);
g_assert(strcmp(rmlvo.layout, rmlvo_backup.layout) == 0);
g_assert(strcmp(rmlvo.variant, rmlvo_backup.variant) == 0);
g_assert(strcmp(rmlvo.options, rmlvo_backup.options) == 0);
assert(strcmp(rmlvo.rules, rmlvo_backup.rules) == 0);
assert(strcmp(rmlvo.model, rmlvo_backup.model) == 0);
assert(strcmp(rmlvo.layout, rmlvo_backup.layout) == 0);
assert(strcmp(rmlvo.variant, rmlvo_backup.variant) == 0);
assert(strcmp(rmlvo.options, rmlvo_backup.options) == 0);
XkbGetRulesDflts(&rmlvo);
g_assert(strcmp(rmlvo.rules, rmlvo_backup.rules) == 0);
g_assert(strcmp(rmlvo.model, rmlvo_backup.model) == 0);
g_assert(strcmp(rmlvo.layout, rmlvo_backup.layout) == 0);
g_assert(strcmp(rmlvo.variant, rmlvo_backup.variant) == 0);
g_assert(strcmp(rmlvo.options, rmlvo_backup.options) == 0);
assert(strcmp(rmlvo.rules, rmlvo_backup.rules) == 0);
assert(strcmp(rmlvo.model, rmlvo_backup.model) == 0);
assert(strcmp(rmlvo.layout, rmlvo_backup.layout) == 0);
assert(strcmp(rmlvo.variant, rmlvo_backup.variant) == 0);
assert(strcmp(rmlvo.options, rmlvo_backup.options) == 0);
}
int main(int argc, char** argv)
{
g_test_init(&argc, &argv,NULL);
g_test_bug_base("https://bugzilla.freedesktop.org/show_bug.cgi?id=");
xkb_set_get_rules_test();
xkb_get_rules_test();
xkb_set_rules_test();
g_test_add_func("/xkb/set-get-rules", xkb_set_get_rules_test);
g_test_add_func("/xkb/get-rules", xkb_get_rules_test);
g_test_add_func("/xkb/set-rules", xkb_set_rules_test);
return g_test_run();
return 0;
}

39
test/xtest.c
View File

@ -33,8 +33,6 @@
#include "xkbsrv.h"
#include "xserver-properties.h"
#include <glib.h>
/**
*/
@ -65,14 +63,14 @@ static void xtest_init_devices(void)
/* this also inits the xtest devices */
InitCoreDevices();
g_assert(xtestpointer);
g_assert(xtestkeyboard);
g_assert(IsXTestDevice(xtestpointer, NULL));
g_assert(IsXTestDevice(xtestkeyboard, NULL));
g_assert(IsXTestDevice(xtestpointer, inputInfo.pointer));
g_assert(IsXTestDevice(xtestkeyboard, inputInfo.keyboard));
g_assert(GetXTestDevice(inputInfo.pointer) == xtestpointer);
g_assert(GetXTestDevice(inputInfo.keyboard) == xtestkeyboard);
assert(xtestpointer);
assert(xtestkeyboard);
assert(IsXTestDevice(xtestpointer, NULL));
assert(IsXTestDevice(xtestkeyboard, NULL));
assert(IsXTestDevice(xtestpointer, inputInfo.pointer));
assert(IsXTestDevice(xtestkeyboard, inputInfo.keyboard));
assert(GetXTestDevice(inputInfo.pointer) == xtestpointer);
assert(GetXTestDevice(inputInfo.keyboard) == xtestkeyboard);
}
/**
@ -87,32 +85,29 @@ static void xtest_properties(void)
Atom xtest_prop = XIGetKnownProperty(XI_PROP_XTEST_DEVICE);
rc = XIGetDeviceProperty(xtestpointer, xtest_prop, &prop);
g_assert(rc == Success);
g_assert(prop);
assert(rc == Success);
assert(prop);
rc = XIGetDeviceProperty(xtestkeyboard, xtest_prop, &prop);
g_assert(rc == Success);
g_assert(prop != NULL);
assert(rc == Success);
assert(prop != NULL);
rc = XIChangeDeviceProperty(xtestpointer, xtest_prop,
XA_INTEGER, 8, PropModeReplace, 1, &value, FALSE);
g_assert(rc == BadAccess);
assert(rc == BadAccess);
rc = XIChangeDeviceProperty(xtestkeyboard, xtest_prop,
XA_INTEGER, 8, PropModeReplace, 1, &value, FALSE);
g_assert(rc == BadAccess);
assert(rc == BadAccess);
}
int main(int argc, char** argv)
{
g_test_init(&argc, &argv,NULL);
g_test_bug_base("https://bugzilla.freedesktop.org/show_bug.cgi?id=");
xtest_init_devices();
xtest_properties();
g_test_add_func("/dix/xtest/init", xtest_init_devices);
g_test_add_func("/dix/xtest/properties", xtest_properties);
return g_test_run();
return 0;
}