svn merge ^/branches/released .

1 files changed, 271 insertions, 252 deletions

diff --git a/xorg-server/test/input.c b/xorg-server/test/input.c
index 9a1ac632e..a54feffec 100644
--- a/xorg-server/test/input.c
+++ b/xorg-server/test/input.c
@@ -40,7 +40,7 @@
 #include "dixgrabs.h"

 #include "eventstr.h"

 #include "inpututils.h"

-#include <glib.h>

+#include "assert.h"

 

 /**

  * Init a device with axes.

@@ -60,24 +60,24 @@ static void dix_init_valuators(void)
     memset(&dev, 0, sizeof(DeviceIntRec));

     dev.type = MASTER_POINTER; /* claim it's a master to stop ptracccel */

 

-    g_assert(InitValuatorClassDeviceStruct(NULL, 0, atoms, 0, 0) == FALSE);

-    g_assert(InitValuatorClassDeviceStruct(&dev, num_axes, atoms, 0, Absolute));

+    assert(InitValuatorClassDeviceStruct(NULL, 0, atoms, 0, 0) == FALSE);

+    assert(InitValuatorClassDeviceStruct(&dev, num_axes, atoms, 0, Absolute));

 

     val = dev.valuator;

-    g_assert(val);

-    g_assert(val->numAxes == num_axes);

-    g_assert(val->numMotionEvents == 0);

-    g_assert(val->axisVal);

+    assert(val);

+    assert(val->numAxes == num_axes);

+    assert(val->numMotionEvents == 0);

+    assert(val->axisVal);

 

     for (i = 0; i < num_axes; i++)

     {

-        g_assert(val->axisVal[i] == 0);

-        g_assert(val->axes->min_value == NO_AXIS_LIMITS);

-        g_assert(val->axes->max_value == NO_AXIS_LIMITS);

-        g_assert(val->axes->mode == Absolute);

+        assert(val->axisVal[i] == 0);

+        assert(val->axes->min_value == NO_AXIS_LIMITS);

+        assert(val->axes->max_value == NO_AXIS_LIMITS);

+        assert(val->axes->mode == Absolute);

     }

 

-    g_assert(dev.last.numValuators == num_axes);

+    assert(dev.last.numValuators == num_axes);

 }

 

 /* just check the known success cases, and that error cases set the client's

@@ -97,48 +97,48 @@ static void dix_check_grab_values(void)
     param.ownerEvents = FALSE;

 

     rc = CheckGrabValues(&client, &param);

-    g_assert(rc == Success);

+    assert(rc == Success);

 

     param.this_device_mode = GrabModeAsync;

     rc = CheckGrabValues(&client, &param);

-    g_assert(rc == Success);

+    assert(rc == Success);

 

     param.this_device_mode = GrabModeAsync + 1;

     rc = CheckGrabValues(&client, &param);

-    g_assert(rc == BadValue);

-    g_assert(client.errorValue == param.this_device_mode);

-    g_assert(client.errorValue == GrabModeAsync + 1);

+    assert(rc == BadValue);

+    assert(client.errorValue == param.this_device_mode);

+    assert(client.errorValue == GrabModeAsync + 1);

 

     param.this_device_mode = GrabModeSync;

     param.other_devices_mode = GrabModeAsync;

     rc = CheckGrabValues(&client, &param);

-    g_assert(rc == Success);

+    assert(rc == Success);

 

     param.other_devices_mode = GrabModeAsync + 1;

     rc = CheckGrabValues(&client, &param);

-    g_assert(rc == BadValue);

-    g_assert(client.errorValue == param.other_devices_mode);

-    g_assert(client.errorValue == GrabModeAsync + 1);

+    assert(rc == BadValue);

+    assert(client.errorValue == param.other_devices_mode);

+    assert(client.errorValue == GrabModeAsync + 1);

 

     param.other_devices_mode = GrabModeSync;

 

     param.modifiers = 1 << 13;

     rc = CheckGrabValues(&client, &param);

-    g_assert(rc == BadValue);

-    g_assert(client.errorValue == param.modifiers);

-    g_assert(client.errorValue == (1 << 13));

+    assert(rc == BadValue);

+    assert(client.errorValue == param.modifiers);

+    assert(client.errorValue == (1 << 13));

 

 

     param.modifiers = AnyModifier;

     param.ownerEvents = TRUE;

     rc = CheckGrabValues(&client, &param);

-    g_assert(rc == Success);

+    assert(rc == Success);

 

     param.ownerEvents = 3;

     rc = CheckGrabValues(&client, &param);

-    g_assert(rc == BadValue);

-    g_assert(client.errorValue == param.ownerEvents);

-    g_assert(client.errorValue == 3);

+    assert(rc == BadValue);

+    assert(client.errorValue == param.ownerEvents);

+    assert(client.errorValue == 3);

 }

 

 

@@ -160,21 +160,21 @@ static void dix_event_to_core(int type)
 

     /* EventToCore memsets the event to 0 */

 #define test_event() \

-    g_assert(rc == Success); \

-    g_assert(core); \

-    g_assert(count == 1); \

-    g_assert(core->u.u.type == type); \

-    g_assert(core->u.u.detail == detail); \

-    g_assert(core->u.keyButtonPointer.time == time); \

-    g_assert(core->u.keyButtonPointer.rootX == x); \

-    g_assert(core->u.keyButtonPointer.rootY == y); \

-    g_assert(core->u.keyButtonPointer.state == state); \

-    g_assert(core->u.keyButtonPointer.eventX == 0); \

-    g_assert(core->u.keyButtonPointer.eventY == 0); \

-    g_assert(core->u.keyButtonPointer.root == ROOT_WINDOW_ID); \

-    g_assert(core->u.keyButtonPointer.event == 0); \

-    g_assert(core->u.keyButtonPointer.child == 0); \

-    g_assert(core->u.keyButtonPointer.sameScreen == FALSE);

+    assert(rc == Success); \

+    assert(core); \

+    assert(count == 1); \

+    assert(core->u.u.type == type); \

+    assert(core->u.u.detail == detail); \

+    assert(core->u.keyButtonPointer.time == time); \

+    assert(core->u.keyButtonPointer.rootX == x); \

+    assert(core->u.keyButtonPointer.rootY == y); \

+    assert(core->u.keyButtonPointer.state == state); \

+    assert(core->u.keyButtonPointer.eventX == 0); \

+    assert(core->u.keyButtonPointer.eventY == 0); \

+    assert(core->u.keyButtonPointer.root == ROOT_WINDOW_ID); \

+    assert(core->u.keyButtonPointer.event == 0); \

+    assert(core->u.keyButtonPointer.child == 0); \

+    assert(core->u.keyButtonPointer.sameScreen == FALSE);

 

     x = 0;

     y = 0;

@@ -217,11 +217,11 @@ static void dix_event_to_core(int type)
     ev.root_x = x;

     ev.root_y = y;

     rc = EventToCore((InternalEvent*)&ev, &core, &count);

-    g_assert(rc == Success);

-    g_assert(core);

-    g_assert(count == 1);

-    g_assert(core->u.keyButtonPointer.rootX != x);

-    g_assert(core->u.keyButtonPointer.rootY != y);

+    assert(rc == Success);

+    assert(core);

+    assert(count == 1);

+    assert(core->u.keyButtonPointer.rootX != x);

+    assert(core->u.keyButtonPointer.rootY != y);

 

     x = 0x7FFF;

     y = 0x7FFF;

@@ -245,7 +245,7 @@ static void dix_event_to_core(int type)
     detail = 0xFFF; /* too big */

     ev.detail.key = detail;

     rc = EventToCore((InternalEvent*)&ev, &core, &count);

-    g_assert(rc == BadMatch);

+    assert(rc == BadMatch);

 

     detail = 0xFF; /* too big */

     ev.detail.key = detail;

@@ -257,11 +257,11 @@ static void dix_event_to_core(int type)
     state = 0x10000; /* too big */

     ev.corestate = state;

     rc = EventToCore((InternalEvent*)&ev, &core, &count);

-    g_assert(rc == Success);

-    g_assert(core);

-    g_assert(count == 1);

-    g_assert(core->u.keyButtonPointer.state != state);

-    g_assert(core->u.keyButtonPointer.state == (state & 0xFFFF));

+    assert(rc == Success);

+    assert(core);

+    assert(count == 1);

+    assert(core->u.keyButtonPointer.state != state);

+    assert(core->u.keyButtonPointer.state == (state & 0xFFFF));

 

 #undef test_event

 }

@@ -278,7 +278,7 @@ static void dix_event_to_core_fail(int evtype, int expected_rc)
 

     ev.type     = evtype;

     rc = EventToCore((InternalEvent*)&ev, &core, &count);

-    g_assert(rc == expected_rc);

+    assert(rc == expected_rc);

 }

 

 static void dix_event_to_core_conversion(void)

@@ -304,28 +304,28 @@ _dix_test_xi_convert(DeviceEvent *ev, int expected_rc, int expected_count)
     int rc;

 

     rc = EventToXI((InternalEvent*)ev, &xi, &count);

-    g_assert(rc == expected_rc);

-    g_assert(count >= expected_count);

+    assert(rc == expected_rc);

+    assert(count >= expected_count);

     if (count > 0){

         deviceKeyButtonPointer *kbp = (deviceKeyButtonPointer*)xi;

-        g_assert(kbp->type == IEventBase + ev->type);

-        g_assert(kbp->detail == ev->detail.key);

-        g_assert(kbp->time == ev->time);

-        g_assert((kbp->deviceid & ~MORE_EVENTS) == ev->deviceid);

-        g_assert(kbp->root_x == ev->root_x);

-        g_assert(kbp->root_y == ev->root_y);

-        g_assert(kbp->state == ev->corestate);

-        g_assert(kbp->event_x == 0);

-        g_assert(kbp->event_y == 0);

-        g_assert(kbp->root == ev->root);

-        g_assert(kbp->event == 0);

-        g_assert(kbp->child == 0);

-        g_assert(kbp->same_screen == FALSE);

+        assert(kbp->type == IEventBase + ev->type);

+        assert(kbp->detail == ev->detail.key);

+        assert(kbp->time == ev->time);

+        assert((kbp->deviceid & ~MORE_EVENTS) == ev->deviceid);

+        assert(kbp->root_x == ev->root_x);

+        assert(kbp->root_y == ev->root_y);

+        assert(kbp->state == ev->corestate);

+        assert(kbp->event_x == 0);

+        assert(kbp->event_y == 0);

+        assert(kbp->root == ev->root);

+        assert(kbp->event == 0);

+        assert(kbp->child == 0);

+        assert(kbp->same_screen == FALSE);

 

         while (--count > 0) {

             deviceValuator *v = (deviceValuator*)&xi[count];

-            g_assert(v->type == DeviceValuator);

-            g_assert(v->num_valuators <= 6);

+            assert(v->type == DeviceValuator);

+            assert(v->num_valuators <= 6);

         }

 

 

@@ -436,7 +436,7 @@ static void dix_event_to_xi1_conversion(void)
 static void xi2_struct_sizes(void)

 {

 #define compare(req) \

-    g_assert(sizeof(req) == sz_##req);

+    assert(sizeof(req) == sz_##req);

 

     compare(xXIQueryVersionReq);

     compare(xXIWarpPointerReq);

@@ -476,23 +476,23 @@ static void dix_grab_matching(void)
     a.grabtype = GRABTYPE_CORE;

     b.grabtype = GRABTYPE_XI2;

     rc = GrabMatchesSecond(&a, &b, FALSE);

-    g_assert(rc == FALSE);

+    assert(rc == FALSE);

     rc = GrabMatchesSecond(&b, &a, FALSE);

-    g_assert(rc == FALSE);

+    assert(rc == FALSE);

 

     a.grabtype = GRABTYPE_XI;

     b.grabtype = GRABTYPE_XI2;

     rc = GrabMatchesSecond(&a, &b, FALSE);

-    g_assert(rc == FALSE);

+    assert(rc == FALSE);

     rc = GrabMatchesSecond(&b, &a, FALSE);

-    g_assert(rc == FALSE);

+    assert(rc == FALSE);

 

     a.grabtype = GRABTYPE_XI;

     b.grabtype = GRABTYPE_CORE;

     rc = GrabMatchesSecond(&a, &b, FALSE);

-    g_assert(rc == FALSE);

+    assert(rc == FALSE);

     rc = GrabMatchesSecond(&b, &a, FALSE);

-    g_assert(rc == FALSE);

+    assert(rc == FALSE);

 

     /* XI2 grabs for different devices must fail, regardless of ignoreDevice

      * XI2 grabs for master devices must fail against a slave */

@@ -516,28 +516,28 @@ static void dix_grab_matching(void)
     b.device = &dev2;

 

     rc = GrabMatchesSecond(&a, &b, FALSE);

-    g_assert(rc == FALSE);

+    assert(rc == FALSE);

 

     a.device = &dev2;

     b.device = &dev1;

     rc = GrabMatchesSecond(&a, &b, FALSE);

-    g_assert(rc == FALSE);

+    assert(rc == FALSE);

     rc = GrabMatchesSecond(&a, &b, TRUE);

-    g_assert(rc == FALSE);

+    assert(rc == FALSE);

 

     a.device = inputInfo.all_master_devices;

     b.device = &dev1;

     rc = GrabMatchesSecond(&a, &b, FALSE);

-    g_assert(rc == FALSE);

+    assert(rc == FALSE);

     rc = GrabMatchesSecond(&a, &b, TRUE);

-    g_assert(rc == FALSE);

+    assert(rc == FALSE);

 

     a.device = &dev1;

     b.device = inputInfo.all_master_devices;

     rc = GrabMatchesSecond(&a, &b, FALSE);

-    g_assert(rc == FALSE);

+    assert(rc == FALSE);

     rc = GrabMatchesSecond(&a, &b, TRUE);

-    g_assert(rc == FALSE);

+    assert(rc == FALSE);

 

     /* ignoreDevice FALSE must fail for different devices for CORE and XI */

     a.grabtype = GRABTYPE_XI;

@@ -547,7 +547,7 @@ static void dix_grab_matching(void)
     a.modifierDevice = &dev1;

     b.modifierDevice = &dev1;

     rc = GrabMatchesSecond(&a, &b, FALSE);

-    g_assert(rc == FALSE);

+    assert(rc == FALSE);

 

     a.grabtype = GRABTYPE_CORE;

     b.grabtype = GRABTYPE_CORE;

@@ -556,7 +556,7 @@ static void dix_grab_matching(void)
     a.modifierDevice = &dev1;

     b.modifierDevice = &dev1;

     rc = GrabMatchesSecond(&a, &b, FALSE);

-    g_assert(rc == FALSE);

+    assert(rc == FALSE);

 

     /* ignoreDevice FALSE must fail for different modifier devices for CORE

      * and XI */

@@ -567,7 +567,7 @@ static void dix_grab_matching(void)
     a.modifierDevice = &dev1;

     b.modifierDevice = &dev2;

     rc = GrabMatchesSecond(&a, &b, FALSE);

-    g_assert(rc == FALSE);

+    assert(rc == FALSE);

 

     a.grabtype = GRABTYPE_CORE;

     b.grabtype = GRABTYPE_CORE;

@@ -576,7 +576,7 @@ static void dix_grab_matching(void)
     a.modifierDevice = &dev1;

     b.modifierDevice = &dev2;

     rc = GrabMatchesSecond(&a, &b, FALSE);

-    g_assert(rc == FALSE);

+    assert(rc == FALSE);

 

     /* different event type must fail */

     a.grabtype = GRABTYPE_XI2;

@@ -588,9 +588,9 @@ static void dix_grab_matching(void)
     a.type = XI_KeyPress;

     b.type = XI_KeyRelease;

     rc = GrabMatchesSecond(&a, &b, FALSE);

-    g_assert(rc == FALSE);

+    assert(rc == FALSE);

     rc = GrabMatchesSecond(&a, &b, TRUE);

-    g_assert(rc == FALSE);

+    assert(rc == FALSE);

 

     a.grabtype = GRABTYPE_CORE;

     b.grabtype = GRABTYPE_CORE;

@@ -601,9 +601,9 @@ static void dix_grab_matching(void)
     a.type = XI_KeyPress;

     b.type = XI_KeyRelease;

     rc = GrabMatchesSecond(&a, &b, FALSE);

-    g_assert(rc == FALSE);

+    assert(rc == FALSE);

     rc = GrabMatchesSecond(&a, &b, TRUE);

-    g_assert(rc == FALSE);

+    assert(rc == FALSE);

 

     a.grabtype = GRABTYPE_XI;

     b.grabtype = GRABTYPE_XI;

@@ -614,9 +614,9 @@ static void dix_grab_matching(void)
     a.type = XI_KeyPress;

     b.type = XI_KeyRelease;

     rc = GrabMatchesSecond(&a, &b, FALSE);

-    g_assert(rc == FALSE);

+    assert(rc == FALSE);

     rc = GrabMatchesSecond(&a, &b, TRUE);

-    g_assert(rc == FALSE);

+    assert(rc == FALSE);

 

     /* different modifiers must fail */

     a.grabtype = GRABTYPE_XI2;

@@ -630,23 +630,23 @@ static void dix_grab_matching(void)
     a.modifiersDetail.exact = 1;

     b.modifiersDetail.exact = 2;

     rc = GrabMatchesSecond(&a, &b, FALSE);

-    g_assert(rc == FALSE);

+    assert(rc == FALSE);

     rc = GrabMatchesSecond(&b, &a, FALSE);

-    g_assert(rc == FALSE);

+    assert(rc == FALSE);

 

     a.grabtype = GRABTYPE_CORE;

     b.grabtype = GRABTYPE_CORE;

     rc = GrabMatchesSecond(&a, &b, FALSE);

-    g_assert(rc == FALSE);

+    assert(rc == FALSE);

     rc = GrabMatchesSecond(&b, &a, FALSE);

-    g_assert(rc == FALSE);

+    assert(rc == FALSE);

 

     a.grabtype = GRABTYPE_XI;

     b.grabtype = GRABTYPE_XI;

     rc = GrabMatchesSecond(&a, &b, FALSE);

-    g_assert(rc == FALSE);

+    assert(rc == FALSE);

     rc = GrabMatchesSecond(&b, &a, FALSE);

-    g_assert(rc == FALSE);

+    assert(rc == FALSE);

 

     /* AnyModifier must fail for XI2 */

     a.grabtype = GRABTYPE_XI2;

@@ -654,9 +654,9 @@ static void dix_grab_matching(void)
     a.modifiersDetail.exact = AnyModifier;

     b.modifiersDetail.exact = 1;

     rc = GrabMatchesSecond(&a, &b, FALSE);

-    g_assert(rc == FALSE);

+    assert(rc == FALSE);

     rc = GrabMatchesSecond(&b, &a, FALSE);

-    g_assert(rc == FALSE);

+    assert(rc == FALSE);

 

     /* XIAnyModifier must fail for CORE and XI */

     a.grabtype = GRABTYPE_XI;

@@ -664,18 +664,18 @@ static void dix_grab_matching(void)
     a.modifiersDetail.exact = XIAnyModifier;

     b.modifiersDetail.exact = 1;

     rc = GrabMatchesSecond(&a, &b, FALSE);

-    g_assert(rc == FALSE);

+    assert(rc == FALSE);

     rc = GrabMatchesSecond(&b, &a, FALSE);

-    g_assert(rc == FALSE);

+    assert(rc == FALSE);

 

     a.grabtype = GRABTYPE_CORE;

     b.grabtype = GRABTYPE_CORE;

     a.modifiersDetail.exact = XIAnyModifier;

     b.modifiersDetail.exact = 1;

     rc = GrabMatchesSecond(&a, &b, FALSE);

-    g_assert(rc == FALSE);

+    assert(rc == FALSE);

     rc = GrabMatchesSecond(&b, &a, FALSE);

-    g_assert(rc == FALSE);

+    assert(rc == FALSE);

 

     /* different detail must fail */

     a.grabtype = GRABTYPE_XI2;

@@ -685,23 +685,23 @@ static void dix_grab_matching(void)
     a.modifiersDetail.exact = 1;

     b.modifiersDetail.exact = 1;

     rc = GrabMatchesSecond(&a, &b, FALSE);

-    g_assert(rc == FALSE);

+    assert(rc == FALSE);

     rc = GrabMatchesSecond(&b, &a, FALSE);

-    g_assert(rc == FALSE);

+    assert(rc == FALSE);

 

     a.grabtype = GRABTYPE_XI;

     b.grabtype = GRABTYPE_XI;

     rc = GrabMatchesSecond(&a, &b, FALSE);

-    g_assert(rc == FALSE);

+    assert(rc == FALSE);

     rc = GrabMatchesSecond(&b, &a, FALSE);

-    g_assert(rc == FALSE);

+    assert(rc == FALSE);

 

     a.grabtype = GRABTYPE_CORE;

     b.grabtype = GRABTYPE_CORE;

     rc = GrabMatchesSecond(&a, &b, FALSE);

-    g_assert(rc == FALSE);

+    assert(rc == FALSE);

     rc = GrabMatchesSecond(&b, &a, FALSE);

-    g_assert(rc == FALSE);

+    assert(rc == FALSE);

 

     /* detail of AnyModifier must fail */

     a.grabtype = GRABTYPE_XI2;

@@ -711,23 +711,23 @@ static void dix_grab_matching(void)
     a.modifiersDetail.exact = 1;

     b.modifiersDetail.exact = 1;

     rc = GrabMatchesSecond(&a, &b, FALSE);

-    g_assert(rc == FALSE);

+    assert(rc == FALSE);

     rc = GrabMatchesSecond(&b, &a, FALSE);

-    g_assert(rc == FALSE);

+    assert(rc == FALSE);

 

     a.grabtype = GRABTYPE_CORE;

     b.grabtype = GRABTYPE_CORE;

     rc = GrabMatchesSecond(&a, &b, FALSE);

-    g_assert(rc == FALSE);

+    assert(rc == FALSE);

     rc = GrabMatchesSecond(&b, &a, FALSE);

-    g_assert(rc == FALSE);

+    assert(rc == FALSE);

 

     a.grabtype = GRABTYPE_XI;

     b.grabtype = GRABTYPE_XI;

     rc = GrabMatchesSecond(&a, &b, FALSE);

-    g_assert(rc == FALSE);

+    assert(rc == FALSE);

     rc = GrabMatchesSecond(&b, &a, FALSE);

-    g_assert(rc == FALSE);

+    assert(rc == FALSE);

 

     /* detail of XIAnyModifier must fail */

     a.grabtype = GRABTYPE_XI2;

@@ -737,23 +737,23 @@ static void dix_grab_matching(void)
     a.modifiersDetail.exact = 1;

     b.modifiersDetail.exact = 1;

     rc = GrabMatchesSecond(&a, &b, FALSE);

-    g_assert(rc == FALSE);

+    assert(rc == FALSE);

     rc = GrabMatchesSecond(&b, &a, FALSE);

-    g_assert(rc == FALSE);

+    assert(rc == FALSE);

 

     a.grabtype = GRABTYPE_CORE;

     b.grabtype = GRABTYPE_CORE;

     rc = GrabMatchesSecond(&a, &b, FALSE);

-    g_assert(rc == FALSE);

+    assert(rc == FALSE);

     rc = GrabMatchesSecond(&b, &a, FALSE);

-    g_assert(rc == FALSE);

+    assert(rc == FALSE);

 

     a.grabtype = GRABTYPE_XI;

     b.grabtype = GRABTYPE_XI;

     rc = GrabMatchesSecond(&a, &b, FALSE);

-    g_assert(rc == FALSE);

+    assert(rc == FALSE);

     rc = GrabMatchesSecond(&b, &a, FALSE);

-    g_assert(rc == FALSE);

+    assert(rc == FALSE);

 

     /* XIAnyModifier or AnyModifer must succeed */

     a.grabtype = GRABTYPE_XI2;

@@ -763,9 +763,9 @@ static void dix_grab_matching(void)
     a.modifiersDetail.exact = XIAnyModifier;

     b.modifiersDetail.exact = 1;

     rc = GrabMatchesSecond(&a, &b, FALSE);

-    g_assert(rc == TRUE);

+    assert(rc == TRUE);

     rc = GrabMatchesSecond(&b, &a, FALSE);

-    g_assert(rc == TRUE);

+    assert(rc == TRUE);

 

     a.grabtype = GRABTYPE_CORE;

     b.grabtype = GRABTYPE_CORE;

@@ -774,9 +774,9 @@ static void dix_grab_matching(void)
     a.modifiersDetail.exact = AnyModifier;

     b.modifiersDetail.exact = 1;

     rc = GrabMatchesSecond(&a, &b, FALSE);

-    g_assert(rc == TRUE);

+    assert(rc == TRUE);

     rc = GrabMatchesSecond(&b, &a, FALSE);

-    g_assert(rc == TRUE);

+    assert(rc == TRUE);

 

     a.grabtype = GRABTYPE_XI;

     b.grabtype = GRABTYPE_XI;

@@ -785,9 +785,9 @@ static void dix_grab_matching(void)
     a.modifiersDetail.exact = AnyModifier;

     b.modifiersDetail.exact = 1;

     rc = GrabMatchesSecond(&a, &b, FALSE);

-    g_assert(rc == TRUE);

+    assert(rc == TRUE);

     rc = GrabMatchesSecond(&b, &a, FALSE);

-    g_assert(rc == TRUE);

+    assert(rc == TRUE);

 

     /* AnyKey or XIAnyKeycode must succeed */

     a.grabtype = GRABTYPE_XI2;

@@ -797,9 +797,9 @@ static void dix_grab_matching(void)
     a.modifiersDetail.exact = 1;

     b.modifiersDetail.exact = 1;

     rc = GrabMatchesSecond(&a, &b, FALSE);

-    g_assert(rc == TRUE);

+    assert(rc == TRUE);

     rc = GrabMatchesSecond(&b, &a, FALSE);

-    g_assert(rc == TRUE);

+    assert(rc == TRUE);

 

     a.grabtype = GRABTYPE_CORE;

     b.grabtype = GRABTYPE_CORE;

@@ -808,9 +808,9 @@ static void dix_grab_matching(void)
     a.modifiersDetail.exact = 1;

     b.modifiersDetail.exact = 1;

     rc = GrabMatchesSecond(&a, &b, FALSE);

-    g_assert(rc == TRUE);

+    assert(rc == TRUE);

     rc = GrabMatchesSecond(&b, &a, FALSE);

-    g_assert(rc == TRUE);

+    assert(rc == TRUE);

 

     a.grabtype = GRABTYPE_XI;

     b.grabtype = GRABTYPE_XI;

@@ -819,9 +819,9 @@ static void dix_grab_matching(void)
     a.modifiersDetail.exact = 1;

     b.modifiersDetail.exact = 1;

     rc = GrabMatchesSecond(&a, &b, FALSE);

-    g_assert(rc == TRUE);

+    assert(rc == TRUE);

     rc = GrabMatchesSecond(&b, &a, FALSE);

-    g_assert(rc == TRUE);

+    assert(rc == TRUE);

 }

 

 static void test_bits_to_byte(int i)

@@ -829,9 +829,9 @@ static void test_bits_to_byte(int i)
         int expected_bytes;

         expected_bytes = (i + 7)/8;

 

-        g_assert(bits_to_bytes(i) >= i/8);

-        g_assert((bits_to_bytes(i) * 8) - i <= 7);

-        g_assert(expected_bytes == bits_to_bytes(i));

+        assert(bits_to_bytes(i) >= i/8);

+        assert((bits_to_bytes(i) * 8) - i <= 7);

+        assert(expected_bytes == bits_to_bytes(i));

 }

 

 static void test_bytes_to_int32(int i)

@@ -839,9 +839,9 @@ static void test_bytes_to_int32(int i)
         int expected_4byte;

         expected_4byte = (i + 3)/4;

 

-        g_assert(bytes_to_int32(i) <= i);

-        g_assert((bytes_to_int32(i) * 4) - i <= 3);

-        g_assert(expected_4byte == bytes_to_int32(i));

+        assert(bytes_to_int32(i) <= i);

+        assert((bytes_to_int32(i) * 4) - i <= 3);

+        assert(expected_4byte == bytes_to_int32(i));

 }

 

 static void test_pad_to_int32(int i)

@@ -849,13 +849,13 @@ static void test_pad_to_int32(int i)
         int expected_bytes;

         expected_bytes = ((i + 3)/4) * 4;

 

-        g_assert(pad_to_int32(i) >= i);

-        g_assert(pad_to_int32(i) - i <= 3);

-        g_assert(expected_bytes == pad_to_int32(i));

+        assert(pad_to_int32(i) >= i);

+        assert(pad_to_int32(i) - i <= 3);

+        assert(expected_bytes == pad_to_int32(i));

 }

 static void include_byte_padding_macros(void)

 {

-    g_test_message("Testing bits_to_bytes()");

+    printf("Testing bits_to_bytes()\n");

 

     /* the macros don't provide overflow protection */

     test_bits_to_byte(0);

@@ -868,7 +868,7 @@ static void include_byte_padding_macros(void)
     test_bits_to_byte(INT_MAX - 9);

     test_bits_to_byte(INT_MAX - 8);

 

-    g_test_message("Testing bytes_to_int32()");

+    printf("Testing bytes_to_int32()\n");

 

     test_bytes_to_int32(0);

     test_bytes_to_int32(1);

@@ -884,7 +884,7 @@ static void include_byte_padding_macros(void)
     test_bytes_to_int32(INT_MAX - 4);

     test_bytes_to_int32(INT_MAX - 3);

 

-    g_test_message("Testing pad_to_int32");

+    printf("Testing pad_to_int32\n");

 

     test_pad_to_int32(0);

     test_pad_to_int32(0);

@@ -910,47 +910,47 @@ static void xi_unregister_handlers(void)
     memset(&dev, 0, sizeof(dev));

 

     handler = XIRegisterPropertyHandler(&dev, NULL, NULL, NULL);

-    g_assert(handler == 1);

+    assert(handler == 1);

     handler = XIRegisterPropertyHandler(&dev, NULL, NULL, NULL);

-    g_assert(handler == 2);

+    assert(handler == 2);

     handler = XIRegisterPropertyHandler(&dev, NULL, NULL, NULL);

-    g_assert(handler == 3);

+    assert(handler == 3);

 

-    g_test_message("Unlinking from front.");

+    printf("Unlinking from front.\n");

 

     XIUnregisterPropertyHandler(&dev, 4); /* NOOP */

-    g_assert(dev.properties.handlers->id == 3);

+    assert(dev.properties.handlers->id == 3);

     XIUnregisterPropertyHandler(&dev, 3);

-    g_assert(dev.properties.handlers->id == 2);

+    assert(dev.properties.handlers->id == 2);

     XIUnregisterPropertyHandler(&dev, 2);

-    g_assert(dev.properties.handlers->id == 1);

+    assert(dev.properties.handlers->id == 1);

     XIUnregisterPropertyHandler(&dev, 1);

-    g_assert(dev.properties.handlers == NULL);

+    assert(dev.properties.handlers == NULL);

 

     handler = XIRegisterPropertyHandler(&dev, NULL, NULL, NULL);

-    g_assert(handler == 4);

+    assert(handler == 4);

     handler = XIRegisterPropertyHandler(&dev, NULL, NULL, NULL);

-    g_assert(handler == 5);

+    assert(handler == 5);

     handler = XIRegisterPropertyHandler(&dev, NULL, NULL, NULL);

-    g_assert(handler == 6);

+    assert(handler == 6);

     XIUnregisterPropertyHandler(&dev, 3); /* NOOP */

-    g_assert(dev.properties.handlers->next->next->next == NULL);

+    assert(dev.properties.handlers->next->next->next == NULL);

     XIUnregisterPropertyHandler(&dev, 4);

-    g_assert(dev.properties.handlers->next->next == NULL);

+    assert(dev.properties.handlers->next->next == NULL);

     XIUnregisterPropertyHandler(&dev, 5);

-    g_assert(dev.properties.handlers->next == NULL);

+    assert(dev.properties.handlers->next == NULL);

     XIUnregisterPropertyHandler(&dev, 6);

-    g_assert(dev.properties.handlers == NULL);

+    assert(dev.properties.handlers == NULL);

 

     handler = XIRegisterPropertyHandler(&dev, NULL, NULL, NULL);

-    g_assert(handler == 7);

+    assert(handler == 7);

     handler = XIRegisterPropertyHandler(&dev, NULL, NULL, NULL);

-    g_assert(handler == 8);

+    assert(handler == 8);

     handler = XIRegisterPropertyHandler(&dev, NULL, NULL, NULL);

-    g_assert(handler == 9);

+    assert(handler == 9);

 

     XIDeleteAllDeviceProperties(&dev);

-    g_assert(dev.properties.handlers == NULL);

+    assert(dev.properties.handlers == NULL);

     XIUnregisterPropertyHandler(&dev, 7); /* NOOP */

 

 }

@@ -960,44 +960,44 @@ static void cmp_attr_fields(InputAttributes *attr1,
 {

     char **tags1, **tags2;

 

-    g_assert(attr1 && attr2);

-    g_assert(attr1 != attr2);

-    g_assert(attr1->flags == attr2->flags);

+    assert(attr1 && attr2);

+    assert(attr1 != attr2);

+    assert(attr1->flags == attr2->flags);

 

     if (attr1->product != NULL)

     {

-        g_assert(attr1->product != attr2->product);

-        g_assert(strcmp(attr1->product, attr2->product) == 0);

+        assert(attr1->product != attr2->product);

+        assert(strcmp(attr1->product, attr2->product) == 0);

     } else

-        g_assert(attr2->product == NULL);

+        assert(attr2->product == NULL);

 

     if (attr1->vendor != NULL)

     {

-        g_assert(attr1->vendor != attr2->vendor);

-        g_assert(strcmp(attr1->vendor, attr2->vendor) == 0);

+        assert(attr1->vendor != attr2->vendor);

+        assert(strcmp(attr1->vendor, attr2->vendor) == 0);

     } else

-        g_assert(attr2->vendor == NULL);

+        assert(attr2->vendor == NULL);

 

     if (attr1->device != NULL)

     {

-        g_assert(attr1->device != attr2->device);

-        g_assert(strcmp(attr1->device, attr2->device) == 0);

+        assert(attr1->device != attr2->device);

+        assert(strcmp(attr1->device, attr2->device) == 0);

     } else

-        g_assert(attr2->device == NULL);

+        assert(attr2->device == NULL);

 

     if (attr1->pnp_id != NULL)

     {

-        g_assert(attr1->pnp_id != attr2->pnp_id);

-        g_assert(strcmp(attr1->pnp_id, attr2->pnp_id) == 0);

+        assert(attr1->pnp_id != attr2->pnp_id);

+        assert(strcmp(attr1->pnp_id, attr2->pnp_id) == 0);

     } else

-        g_assert(attr2->pnp_id == NULL);

+        assert(attr2->pnp_id == NULL);

 

     if (attr1->usb_id != NULL)

     {

-        g_assert(attr1->usb_id != attr2->usb_id);

-        g_assert(strcmp(attr1->usb_id, attr2->usb_id) == 0);

+        assert(attr1->usb_id != attr2->usb_id);

+        assert(strcmp(attr1->usb_id, attr2->usb_id) == 0);

     } else

-        g_assert(attr2->usb_id == NULL);

+        assert(attr2->usb_id == NULL);

 

     tags1 = attr1->tags;

     tags2 = attr2->tags;

@@ -1005,25 +1005,25 @@ static void cmp_attr_fields(InputAttributes *attr1,
     /* if we don't have any tags, skip the tag checking bits */

     if (!tags1)

     {

-        g_assert(!tags2);

+        assert(!tags2);

         return;

     }

 

     /* Don't lug around empty arrays */

-    g_assert(*tags1);

-    g_assert(*tags2);

+    assert(*tags1);

+    assert(*tags2);

 

     /* check for identical content, but duplicated */

     while (*tags1)

     {

-        g_assert(*tags1 != *tags2);

-        g_assert(strcmp(*tags1, *tags2) == 0);

+        assert(*tags1 != *tags2);

+        assert(strcmp(*tags1, *tags2) == 0);

         tags1++;

         tags2++;

     }

 

     /* ensure tags1 and tags2 have the same no of elements */

-    g_assert(!*tags2);

+    assert(!*tags2);

 

     /* check for not sharing memory */

     tags1 = attr1->tags;

@@ -1031,7 +1031,7 @@ static void cmp_attr_fields(InputAttributes *attr1,
     {

         tags2 = attr2->tags;

         while (*tags2)

-            g_assert(*tags1 != *tags2++);

+            assert(*tags1 != *tags2++);

 

         tags1++;

     }

@@ -1044,10 +1044,10 @@ static void dix_input_attributes(void)
     char *tags[4] = {"tag1", "tag2", "tag2", NULL};

 

     new = DuplicateInputAttributes(NULL);

-    g_assert(!new);

+    assert(!new);

 

     new = DuplicateInputAttributes(&orig);

-    g_assert(memcmp(&orig, new, sizeof(InputAttributes)) == 0);

+    assert(memcmp(&orig, new, sizeof(InputAttributes)) == 0);

 

     orig.product = "product name";

     new = DuplicateInputAttributes(&orig);

@@ -1097,69 +1097,69 @@ static void dix_input_valuator_masks(void)
         valuators[i] = i;

 

     mask = valuator_mask_new(nvaluators);

-    g_assert(mask != NULL);

-    g_assert(valuator_mask_size(mask) == 0);

-    g_assert(valuator_mask_num_valuators(mask) == 0);

+    assert(mask != NULL);

+    assert(valuator_mask_size(mask) == 0);

+    assert(valuator_mask_num_valuators(mask) == 0);

 

     for (i = 0; i < nvaluators; i++)

     {

-        g_assert(!valuator_mask_isset(mask, i));

+        assert(!valuator_mask_isset(mask, i));

         valuator_mask_set(mask, i, valuators[i]);

-        g_assert(valuator_mask_isset(mask, i));

-        g_assert(valuator_mask_get(mask, i) == valuators[i]);

-        g_assert(valuator_mask_size(mask) == i + 1);

-        g_assert(valuator_mask_num_valuators(mask) == i + 1);

+        assert(valuator_mask_isset(mask, i));

+        assert(valuator_mask_get(mask, i) == valuators[i]);

+        assert(valuator_mask_size(mask) == i + 1);

+        assert(valuator_mask_num_valuators(mask) == i + 1);

     }

 

     for (i = 0; i < nvaluators; i++)

     {

-        g_assert(valuator_mask_isset(mask, i));

+        assert(valuator_mask_isset(mask, i));

         valuator_mask_unset(mask, i);

         /* we're removing valuators from the front, so size should stay the

          * same until the last bit is removed */

         if (i < nvaluators - 1)

-            g_assert(valuator_mask_size(mask) == nvaluators);

-        g_assert(!valuator_mask_isset(mask, i));

+            assert(valuator_mask_size(mask) == nvaluators);

+        assert(!valuator_mask_isset(mask, i));

     }

 

-    g_assert(valuator_mask_size(mask) == 0);

+    assert(valuator_mask_size(mask) == 0);

     valuator_mask_zero(mask);

-    g_assert(valuator_mask_size(mask) == 0);

-    g_assert(valuator_mask_num_valuators(mask) == 0);

+    assert(valuator_mask_size(mask) == 0);

+    assert(valuator_mask_num_valuators(mask) == 0);

     for (i = 0; i < nvaluators; i++)

-        g_assert(!valuator_mask_isset(mask, i));

+        assert(!valuator_mask_isset(mask, i));

 

     first_val = 5;

     num_vals = 6;

 

     valuator_mask_set_range(mask, first_val, num_vals, valuators);

-    g_assert(valuator_mask_size(mask) == first_val + num_vals);

-    g_assert(valuator_mask_num_valuators(mask) == num_vals);

+    assert(valuator_mask_size(mask) == first_val + num_vals);

+    assert(valuator_mask_num_valuators(mask) == num_vals);

     for (i = 0; i < nvaluators; i++)

     {

         if (i < first_val || i >= first_val + num_vals)

-            g_assert(!valuator_mask_isset(mask, i));

+            assert(!valuator_mask_isset(mask, i));

         else

         {

-            g_assert(valuator_mask_isset(mask, i));

-            g_assert(valuator_mask_get(mask, i) == valuators[i - first_val]);

+            assert(valuator_mask_isset(mask, i));

+            assert(valuator_mask_get(mask, i) == valuators[i - first_val]);

         }

     }

 

     copy = valuator_mask_new(nvaluators);

     valuator_mask_copy(copy, mask);

-    g_assert(mask != copy);

-    g_assert(valuator_mask_size(mask) == valuator_mask_size(copy));

-    g_assert(valuator_mask_num_valuators(mask) == valuator_mask_num_valuators(copy));

+    assert(mask != copy);

+    assert(valuator_mask_size(mask) == valuator_mask_size(copy));

+    assert(valuator_mask_num_valuators(mask) == valuator_mask_num_valuators(copy));

 

     for (i = 0; i < nvaluators; i++)

     {

-        g_assert(valuator_mask_isset(mask, i) == valuator_mask_isset(copy, i));

-        g_assert(valuator_mask_get(mask, i) == valuator_mask_get(copy, i));

+        assert(valuator_mask_isset(mask, i) == valuator_mask_isset(copy, i));

+        assert(valuator_mask_get(mask, i) == valuator_mask_get(copy, i));

     }

 

     valuator_mask_free(&mask);

-    g_assert(mask == NULL);

+    assert(mask == NULL);

 }

 

 static void dix_valuator_mode(void)

@@ -1172,24 +1172,24 @@ static void dix_valuator_mode(void)
     memset(&dev, 0, sizeof(DeviceIntRec));

     dev.type = MASTER_POINTER; /* claim it's a master to stop ptracccel */

 

-    g_assert(InitValuatorClassDeviceStruct(NULL, 0, atoms, 0, 0) == FALSE);

-    g_assert(InitValuatorClassDeviceStruct(&dev, num_axes, atoms, 0, Absolute));

+    assert(InitValuatorClassDeviceStruct(NULL, 0, atoms, 0, 0) == FALSE);

+    assert(InitValuatorClassDeviceStruct(&dev, num_axes, atoms, 0, Absolute));

 

     for (i = 0; i < num_axes; i++)

     {

-        g_assert(valuator_get_mode(&dev, i) == Absolute);

+        assert(valuator_get_mode(&dev, i) == Absolute);

         valuator_set_mode(&dev, i, Relative);

-        g_assert(dev.valuator->axes[i].mode == Relative);

-        g_assert(valuator_get_mode(&dev, i) == Relative);

+        assert(dev.valuator->axes[i].mode == Relative);

+        assert(valuator_get_mode(&dev, i) == Relative);

     }

 

     valuator_set_mode(&dev, VALUATOR_MODE_ALL_AXES, Absolute);

     for (i = 0; i < num_axes; i++)

-        g_assert(valuator_get_mode(&dev, i) == Absolute);

+        assert(valuator_get_mode(&dev, i) == Absolute);

 

     valuator_set_mode(&dev, VALUATOR_MODE_ALL_AXES, Relative);

     for (i = 0; i < num_axes; i++)

-        g_assert(valuator_get_mode(&dev, i) == Relative);

+        assert(valuator_get_mode(&dev, i) == Relative);

 }

 

 static void include_bit_test_macros(void)

@@ -1199,34 +1199,53 @@ static void include_bit_test_macros(void)
 

     for (i = 0; i < sizeof(mask)/sizeof(mask[0]); i++)

     {

-        g_assert(BitIsOn(mask, i) == 0);

+        assert(BitIsOn(mask, i) == 0);

         SetBit(mask, i);

-        g_assert(BitIsOn(mask, i) == 1);

-        g_assert(!!(mask[i/8] & (1 << (i % 8))));

-        g_assert(CountBits(mask, sizeof(mask)) == 1);

+        assert(BitIsOn(mask, i) == 1);

+        assert(!!(mask[i/8] & (1 << (i % 8))));

+        assert(CountBits(mask, sizeof(mask)) == 1);

         ClearBit(mask, i);

-        g_assert(BitIsOn(mask, i) == 0);

+        assert(BitIsOn(mask, i) == 0);

     }

 }

 

+/**

+ * Ensure that val->axisVal and val->axes are aligned on doubles.

+ */

+static void dix_valuator_alloc(void)

+{

+    ValuatorClassPtr v = NULL;

+    int num_axes = 0;

+

+    while (num_axes < 5)

+    {

+        v = AllocValuatorClass(v, num_axes);

+

+        assert(v);

+        assert(v->numAxes == num_axes);

+        assert(((void*)v->axisVal - (void*)v) % sizeof(double) == 0);

+        assert(((void*)v->axes - (void*)v) % sizeof(double) == 0);

+        num_axes ++;

+    }

+

+    free(v);

+}

+

 int main(int argc, char** argv)

 {

-    g_test_init(&argc, &argv,NULL);

-    g_test_bug_base("https://bugzilla.freedesktop.org/show_bug.cgi?id=");

-

-    g_test_add_func("/dix/input/valuator-masks", dix_input_valuator_masks);

-    g_test_add_func("/dix/input/attributes", dix_input_attributes);

-    g_test_add_func("/dix/input/init-valuators", dix_init_valuators);

-    g_test_add_func("/dix/input/event-core-conversion", dix_event_to_core_conversion);

-    g_test_add_func("/dix/input/event-xi1-conversion", dix_event_to_xi1_conversion);

-    g_test_add_func("/dix/input/check-grab-values", dix_check_grab_values);

-    g_test_add_func("/dix/input/xi2-struct-sizes", xi2_struct_sizes);

-    g_test_add_func("/dix/input/grab_matching", dix_grab_matching);

-    g_test_add_func("/dix/input/valuator_mode", dix_valuator_mode);

-    g_test_add_func("/include/byte_padding_macros", include_byte_padding_macros);

-    g_test_add_func("/include/bit_test_macros", include_bit_test_macros);

-    g_test_add_func("/Xi/xiproperty/register-unregister", xi_unregister_handlers);

-

-

-    return g_test_run();

+    dix_input_valuator_masks();

+    dix_input_attributes();

+    dix_init_valuators();

+    dix_event_to_core_conversion();

+    dix_event_to_xi1_conversion();

+    dix_check_grab_values();

+    xi2_struct_sizes();

+    dix_grab_matching();

+    dix_valuator_mode();

+    include_byte_padding_macros();

+    include_bit_test_macros();

+    xi_unregister_handlers();

+    dix_valuator_alloc();

+

+    return 0;

 }