test: remove glib dependency

The few features from the glib test suite we used can be replaced with
assert and printf. This patch is a simple replacement for these two
    g_assert → assert
    g_test_message → printf

g_test_init is removed and so is g_test_bug_base. g_test_run replaced with a
simple return 0.

Signed-off-by: Peter Hutterer <peter.hutterer@who-t.net>
Acked-by: Tiago Vignatti <tiago.vignatti@nokia.com>
Acked-by: Gaetan Nadon <memsize@videotron.ca>

1 files changed, 253 insertions, 256 deletions

diff --git a/test/input.c b/test/input.c
index 89cce3f33..ac37d67a1 100644
--- a/test/input.c
+++ b/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,13 +1199,13 @@ 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);
     }
 }
 
@@ -1221,10 +1221,10 @@ static void dix_valuator_alloc(void)
     {
         v = AllocValuatorClass(v, num_axes);
 
-        g_assert(v);
-        g_assert(v->numAxes == num_axes);
-        g_assert(((void*)v->axisVal - (void*)v) % sizeof(double) == 0);
-        g_assert(((void*)v->axes - (void*)v) % sizeof(double) == 0);
+        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 ++;
     }
 
@@ -1233,22 +1233,19 @@ static void dix_valuator_alloc(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=");
-
-    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);
-    g_test_add_func("/dix/input/valuator-alloc", dix_valuator_alloc);
-
-    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;
 }