aboutsummaryrefslogtreecommitdiff
path: root/pugl/test
diff options
context:
space:
mode:
Diffstat (limited to 'pugl/test')
-rw-r--r--pugl/test/.clang-tidy2
-rw-r--r--pugl/test/test_build.c2
-rw-r--r--pugl/test/test_build.cpp2
-rw-r--r--pugl/test/test_clipboard.c117
-rw-r--r--pugl/test/test_gl_hints.c100
-rw-r--r--pugl/test/test_realize.c100
-rw-r--r--pugl/test/test_redisplay.c170
-rw-r--r--pugl/test/test_show_hide.c186
-rw-r--r--pugl/test/test_stub_hints.c82
-rw-r--r--pugl/test/test_timer.c168
-rw-r--r--pugl/test/test_update.c144
-rw-r--r--pugl/test/test_utils.h512
12 files changed, 793 insertions, 792 deletions
diff --git a/pugl/test/.clang-tidy b/pugl/test/.clang-tidy
index e7c1e2c..8014e6a 100644
--- a/pugl/test/.clang-tidy
+++ b/pugl/test/.clang-tidy
@@ -5,6 +5,8 @@ Checks: >
-bugprone-reserved-identifier,
-cert-dcl37-c,
-cert-dcl51-cpp,
+ -cppcoreguidelines-pro-type-static-cast-downcast,
+ -google-runtime-references,
-hicpp-multiway-paths-covered,
-hicpp-signed-bitwise,
-llvm-header-guard,
diff --git a/pugl/test/test_build.c b/pugl/test/test_build.c
index 5259c7c..957e0bd 100644
--- a/pugl/test/test_build.c
+++ b/pugl/test/test_build.c
@@ -28,5 +28,5 @@
int
main(void)
{
- return 0;
+ return 0;
}
diff --git a/pugl/test/test_build.cpp b/pugl/test/test_build.cpp
index 5beb4c3..20235e8 100644
--- a/pugl/test/test_build.cpp
+++ b/pugl/test/test_build.cpp
@@ -29,5 +29,5 @@
int
main()
{
- return 0;
+ return 0;
}
diff --git a/pugl/test/test_clipboard.c b/pugl/test/test_clipboard.c
index c1180b0..a458d00 100644
--- a/pugl/test/test_clipboard.c
+++ b/pugl/test/test_clipboard.c
@@ -28,77 +28,78 @@
#include <assert.h>
#include <stdbool.h>
#include <stddef.h>
+#include <string.h>
typedef struct {
- PuglWorld* world;
- PuglView* views[2];
- PuglTestOptions opts;
- bool exposed;
+ PuglWorld* world;
+ PuglView* views[2];
+ PuglTestOptions opts;
+ bool exposed;
} PuglTest;
static PuglStatus
onEvent(PuglView* view, const PuglEvent* event)
{
- PuglTest* test = (PuglTest*)puglGetHandle(view);
+ PuglTest* test = (PuglTest*)puglGetHandle(view);
- if (event->type == PUGL_EXPOSE) {
- test->exposed = true;
- }
+ if (event->type == PUGL_EXPOSE) {
+ test->exposed = true;
+ }
- if (test->opts.verbose) {
- printEvent(event, "Event: ", true);
- }
+ if (test->opts.verbose) {
+ printEvent(event, "Event: ", true);
+ }
- return PUGL_SUCCESS;
+ return PUGL_SUCCESS;
}
int
main(int argc, char** argv)
{
- PuglTest test = {puglNewWorld(PUGL_PROGRAM, 0),
- {NULL, NULL},
- puglParseTestOptions(&argc, &argv),
- false};
-
- puglSetClassName(test.world, "Pugl Test");
-
- // Set up views
- for (unsigned i = 0u; i < 2; ++i) {
- test.views[i] = puglNewView(test.world);
- puglSetBackend(test.views[i], puglStubBackend());
- puglSetHandle(test.views[i], &test);
- puglSetEventFunc(test.views[i], onEvent);
- puglSetDefaultSize(test.views[i], 512, 512);
-
- assert(!puglShow(test.views[i]));
- }
-
- // Update until view is exposed
- while (!test.exposed) {
- assert(!puglUpdate(test.world, 0.0));
- }
-
- // Set clipboard text via the first view
- puglSetClipboard(test.views[0], NULL, "Text", 5);
-
- // Get clipboard contents via the second view
- const char* type = NULL;
- size_t len = 0;
- const void* const contents = puglGetClipboard(test.views[1], &type, &len);
-
- // Check that the data made it over
- assert(!strcmp(type, "text/plain"));
- assert(len == 5);
- assert(contents);
- assert(!strcmp((const char*)contents, "Text"));
-
- // Try setting the clipboard to an unsupported type
- assert(puglSetClipboard(test.views[0], "text/csv", "a,b,c", 6));
-
- // Tear down
- puglFreeView(test.views[0]);
- puglFreeView(test.views[1]);
- puglFreeWorld(test.world);
-
- return 0;
+ PuglTest test = {puglNewWorld(PUGL_PROGRAM, 0),
+ {NULL, NULL},
+ puglParseTestOptions(&argc, &argv),
+ false};
+
+ puglSetClassName(test.world, "Pugl Test");
+
+ // Set up views
+ for (unsigned i = 0u; i < 2; ++i) {
+ test.views[i] = puglNewView(test.world);
+ puglSetBackend(test.views[i], puglStubBackend());
+ puglSetHandle(test.views[i], &test);
+ puglSetEventFunc(test.views[i], onEvent);
+ puglSetDefaultSize(test.views[i], 512, 512);
+
+ assert(!puglShow(test.views[i]));
+ }
+
+ // Update until view is exposed
+ while (!test.exposed) {
+ assert(!puglUpdate(test.world, 0.0));
+ }
+
+ // Set clipboard text via the first view
+ puglSetClipboard(test.views[0], NULL, "Text", 5);
+
+ // Get clipboard contents via the second view
+ const char* type = NULL;
+ size_t len = 0;
+ const void* const contents = puglGetClipboard(test.views[1], &type, &len);
+
+ // Check that the data made it over
+ assert(!strcmp(type, "text/plain"));
+ assert(len == 5);
+ assert(contents);
+ assert(!strcmp((const char*)contents, "Text"));
+
+ // Try setting the clipboard to an unsupported type
+ assert(puglSetClipboard(test.views[0], "text/csv", "a,b,c", 6));
+
+ // Tear down
+ puglFreeView(test.views[0]);
+ puglFreeView(test.views[1]);
+ puglFreeWorld(test.world);
+
+ return 0;
}
diff --git a/pugl/test/test_gl_hints.c b/pugl/test/test_gl_hints.c
index c30d0ed..3be3651 100644
--- a/pugl/test/test_gl_hints.c
+++ b/pugl/test/test_gl_hints.c
@@ -30,60 +30,60 @@
static PuglStatus
onEvent(PuglView* view, const PuglEvent* event)
{
- (void)view;
- (void)event;
+ (void)view;
+ (void)event;
- return PUGL_SUCCESS;
+ return PUGL_SUCCESS;
}
int
main(void)
{
- PuglWorld* const world = puglNewWorld(PUGL_PROGRAM, 0);
- PuglView* const view = puglNewView(world);
-
- // Set up view
- puglSetClassName(world, "Pugl Test");
- puglSetBackend(view, puglGlBackend());
- puglSetEventFunc(view, onEvent);
- puglSetDefaultSize(view, 512, 512);
-
- // Set all hints that support it to PUGL_DONT_CARE
- assert(!puglSetViewHint(view, PUGL_RED_BITS, PUGL_DONT_CARE));
- assert(!puglSetViewHint(view, PUGL_GREEN_BITS, PUGL_DONT_CARE));
- assert(!puglSetViewHint(view, PUGL_BLUE_BITS, PUGL_DONT_CARE));
- assert(!puglSetViewHint(view, PUGL_ALPHA_BITS, PUGL_DONT_CARE));
- assert(!puglSetViewHint(view, PUGL_DEPTH_BITS, PUGL_DONT_CARE));
- assert(!puglSetViewHint(view, PUGL_STENCIL_BITS, PUGL_DONT_CARE));
- assert(!puglSetViewHint(view, PUGL_SAMPLES, PUGL_DONT_CARE));
- assert(!puglSetViewHint(view, PUGL_DOUBLE_BUFFER, PUGL_DONT_CARE));
- assert(!puglSetViewHint(view, PUGL_REFRESH_RATE, PUGL_DONT_CARE));
-
- // Realize view and print all hints for debugging convenience
- assert(!puglRealize(view));
- printViewHints(view);
-
- // Check that no hints are set to PUGL_DONT_CARE
- assert(puglGetViewHint(view, PUGL_USE_COMPAT_PROFILE) != PUGL_DONT_CARE);
- assert(puglGetViewHint(view, PUGL_USE_DEBUG_CONTEXT) != PUGL_DONT_CARE);
- assert(puglGetViewHint(view, PUGL_CONTEXT_VERSION_MAJOR) != PUGL_DONT_CARE);
- assert(puglGetViewHint(view, PUGL_CONTEXT_VERSION_MINOR) != PUGL_DONT_CARE);
- assert(puglGetViewHint(view, PUGL_RED_BITS) != PUGL_DONT_CARE);
- assert(puglGetViewHint(view, PUGL_GREEN_BITS) != PUGL_DONT_CARE);
- assert(puglGetViewHint(view, PUGL_BLUE_BITS) != PUGL_DONT_CARE);
- assert(puglGetViewHint(view, PUGL_ALPHA_BITS) != PUGL_DONT_CARE);
- assert(puglGetViewHint(view, PUGL_DEPTH_BITS) != PUGL_DONT_CARE);
- assert(puglGetViewHint(view, PUGL_STENCIL_BITS) != PUGL_DONT_CARE);
- assert(puglGetViewHint(view, PUGL_SAMPLES) != PUGL_DONT_CARE);
- assert(puglGetViewHint(view, PUGL_DOUBLE_BUFFER) != PUGL_DONT_CARE);
- assert(puglGetViewHint(view, PUGL_SWAP_INTERVAL) != PUGL_DONT_CARE);
- assert(puglGetViewHint(view, PUGL_RESIZABLE) != PUGL_DONT_CARE);
- assert(puglGetViewHint(view, PUGL_IGNORE_KEY_REPEAT) != PUGL_DONT_CARE);
- assert(puglGetViewHint(view, PUGL_REFRESH_RATE) != PUGL_DONT_CARE);
-
- // Tear down
- puglFreeView(view);
- puglFreeWorld(world);
-
- return 0;
+ PuglWorld* const world = puglNewWorld(PUGL_PROGRAM, 0);
+ PuglView* const view = puglNewView(world);
+
+ // Set up view
+ puglSetClassName(world, "Pugl Test");
+ puglSetBackend(view, puglGlBackend());
+ puglSetEventFunc(view, onEvent);
+ puglSetDefaultSize(view, 512, 512);
+
+ // Set all hints that support it to PUGL_DONT_CARE
+ assert(!puglSetViewHint(view, PUGL_RED_BITS, PUGL_DONT_CARE));
+ assert(!puglSetViewHint(view, PUGL_GREEN_BITS, PUGL_DONT_CARE));
+ assert(!puglSetViewHint(view, PUGL_BLUE_BITS, PUGL_DONT_CARE));
+ assert(!puglSetViewHint(view, PUGL_ALPHA_BITS, PUGL_DONT_CARE));
+ assert(!puglSetViewHint(view, PUGL_DEPTH_BITS, PUGL_DONT_CARE));
+ assert(!puglSetViewHint(view, PUGL_STENCIL_BITS, PUGL_DONT_CARE));
+ assert(!puglSetViewHint(view, PUGL_SAMPLES, PUGL_DONT_CARE));
+ assert(!puglSetViewHint(view, PUGL_DOUBLE_BUFFER, PUGL_DONT_CARE));
+ assert(!puglSetViewHint(view, PUGL_REFRESH_RATE, PUGL_DONT_CARE));
+
+ // Realize view and print all hints for debugging convenience
+ assert(!puglRealize(view));
+ printViewHints(view);
+
+ // Check that no hints are set to PUGL_DONT_CARE
+ assert(puglGetViewHint(view, PUGL_USE_COMPAT_PROFILE) != PUGL_DONT_CARE);
+ assert(puglGetViewHint(view, PUGL_USE_DEBUG_CONTEXT) != PUGL_DONT_CARE);
+ assert(puglGetViewHint(view, PUGL_CONTEXT_VERSION_MAJOR) != PUGL_DONT_CARE);
+ assert(puglGetViewHint(view, PUGL_CONTEXT_VERSION_MINOR) != PUGL_DONT_CARE);
+ assert(puglGetViewHint(view, PUGL_RED_BITS) != PUGL_DONT_CARE);
+ assert(puglGetViewHint(view, PUGL_GREEN_BITS) != PUGL_DONT_CARE);
+ assert(puglGetViewHint(view, PUGL_BLUE_BITS) != PUGL_DONT_CARE);
+ assert(puglGetViewHint(view, PUGL_ALPHA_BITS) != PUGL_DONT_CARE);
+ assert(puglGetViewHint(view, PUGL_DEPTH_BITS) != PUGL_DONT_CARE);
+ assert(puglGetViewHint(view, PUGL_STENCIL_BITS) != PUGL_DONT_CARE);
+ assert(puglGetViewHint(view, PUGL_SAMPLES) != PUGL_DONT_CARE);
+ assert(puglGetViewHint(view, PUGL_DOUBLE_BUFFER) != PUGL_DONT_CARE);
+ assert(puglGetViewHint(view, PUGL_SWAP_INTERVAL) != PUGL_DONT_CARE);
+ assert(puglGetViewHint(view, PUGL_RESIZABLE) != PUGL_DONT_CARE);
+ assert(puglGetViewHint(view, PUGL_IGNORE_KEY_REPEAT) != PUGL_DONT_CARE);
+ assert(puglGetViewHint(view, PUGL_REFRESH_RATE) != PUGL_DONT_CARE);
+
+ // Tear down
+ puglFreeView(view);
+ puglFreeWorld(world);
+
+ return 0;
}
diff --git a/pugl/test/test_realize.c b/pugl/test/test_realize.c
index bb0b327..3c4e09a 100644
--- a/pugl/test/test_realize.c
+++ b/pugl/test/test_realize.c
@@ -34,67 +34,67 @@
#include <stddef.h>
typedef enum {
- START,
- CREATED,
+ START,
+ CREATED,
} State;
typedef struct {
- PuglWorld* world;
- PuglView* view;
- PuglTestOptions opts;
- State state;
+ PuglWorld* world;
+ PuglView* view;
+ PuglTestOptions opts;
+ State state;
} PuglTest;
static PuglStatus
onEvent(PuglView* view, const PuglEvent* event)
{
- PuglTest* test = (PuglTest*)puglGetHandle(view);
-
- if (test->opts.verbose) {
- printEvent(event, "Event: ", true);
- }
-
- switch (event->type) {
- case PUGL_CREATE:
- assert(test->state == START);
- test->state = CREATED;
- break;
- default:
- break;
- }
-
- return PUGL_SUCCESS;
+ PuglTest* test = (PuglTest*)puglGetHandle(view);
+
+ if (test->opts.verbose) {
+ printEvent(event, "Event: ", true);
+ }
+
+ switch (event->type) {
+ case PUGL_CREATE:
+ assert(test->state == START);
+ test->state = CREATED;
+ break;
+ default:
+ break;
+ }
+
+ return PUGL_SUCCESS;
}
int
main(int argc, char** argv)
{
- PuglTest test = {puglNewWorld(PUGL_PROGRAM, 0),
- NULL,
- puglParseTestOptions(&argc, &argv),
- START};
-
- // Set up view
- test.view = puglNewView(test.world);
- puglSetClassName(test.world, "Pugl Test");
- puglSetBackend(test.view, puglStubBackend());
- puglSetHandle(test.view, &test);
- puglSetEventFunc(test.view, onEvent);
- puglSetDefaultSize(test.view, 512, 512);
-
- // Create initially invisible window
- assert(!puglRealize(test.view));
- assert(!puglGetVisible(test.view));
- while (test.state < CREATED) {
- assert(!puglUpdate(test.world, -1.0));
- }
-
- // Check that calling realize() again is okay
- assert(puglRealize(test.view) == PUGL_FAILURE);
-
- // Tear down
- puglFreeView(test.view);
- puglFreeWorld(test.world);
-
- return 0;
+ PuglTest test = {puglNewWorld(PUGL_PROGRAM, 0),
+ NULL,
+ puglParseTestOptions(&argc, &argv),
+ START};
+
+ // Set up view
+ test.view = puglNewView(test.world);
+ puglSetClassName(test.world, "Pugl Test");
+ puglSetBackend(test.view, puglStubBackend());
+ puglSetHandle(test.view, &test);
+ puglSetEventFunc(test.view, onEvent);
+ puglSetDefaultSize(test.view, 512, 512);
+
+ // Create initially invisible window
+ assert(!puglRealize(test.view));
+ assert(!puglGetVisible(test.view));
+ while (test.state < CREATED) {
+ assert(!puglUpdate(test.world, -1.0));
+ }
+
+ // Check that calling realize() again is okay
+ assert(puglRealize(test.view) == PUGL_FAILURE);
+
+ // Tear down
+ puglFreeView(test.view);
+ puglFreeWorld(test.world);
+
+ return 0;
}
diff --git a/pugl/test/test_redisplay.c b/pugl/test/test_redisplay.c
index 1d5b084..c5b9887 100644
--- a/pugl/test/test_redisplay.c
+++ b/pugl/test/test_redisplay.c
@@ -38,19 +38,18 @@ static const double timeout = -1.0;
#endif
typedef enum {
- START,
- EXPOSED,
- SHOULD_REDISPLAY,
- POSTED_REDISPLAY,
- REDISPLAYED,
+ START,
+ EXPOSED,
+ SHOULD_REDISPLAY,
+ POSTED_REDISPLAY,
+ REDISPLAYED,
} State;
-typedef struct
-{
- PuglWorld* world;
- PuglView* view;
- PuglTestOptions opts;
- State state;
+typedef struct {
+ PuglWorld* world;
+ PuglView* view;
+ PuglTestOptions opts;
+ State state;
} PuglTest;
static const PuglRect redisplayRect = {2, 4, 8, 16};
@@ -59,83 +58,84 @@ static const uintptr_t postRedisplayId = 42;
static PuglStatus
onEvent(PuglView* view, const PuglEvent* event)
{
- PuglTest* test = (PuglTest*)puglGetHandle(view);
-
- if (test->opts.verbose) {
- printEvent(event, "Event: ", true);
- }
-
- switch (event->type) {
- case PUGL_UPDATE:
- if (test->state == SHOULD_REDISPLAY) {
- puglPostRedisplayRect(view, redisplayRect);
- test->state = POSTED_REDISPLAY;
- }
- break;
-
- case PUGL_EXPOSE:
- if (test->state == START) {
- test->state = EXPOSED;
- } else if (test->state == POSTED_REDISPLAY &&
- event->expose.x == redisplayRect.x &&
- event->expose.y == redisplayRect.y &&
- event->expose.width == redisplayRect.width &&
- event->expose.height == redisplayRect.height) {
- test->state = REDISPLAYED;
- }
- break;
-
- case PUGL_CLIENT:
- if (event->client.data1 == postRedisplayId) {
- test->state = SHOULD_REDISPLAY;
- }
- break;
-
- default: break;
- }
-
- return PUGL_SUCCESS;
+ PuglTest* test = (PuglTest*)puglGetHandle(view);
+
+ if (test->opts.verbose) {
+ printEvent(event, "Event: ", true);
+ }
+
+ switch (event->type) {
+ case PUGL_UPDATE:
+ if (test->state == SHOULD_REDISPLAY) {
+ puglPostRedisplayRect(view, redisplayRect);
+ test->state = POSTED_REDISPLAY;
+ }
+ break;
+
+ case PUGL_EXPOSE:
+ if (test->state == START) {
+ test->state = EXPOSED;
+ } else if (test->state == POSTED_REDISPLAY &&
+ event->expose.x == redisplayRect.x &&
+ event->expose.y == redisplayRect.y &&
+ event->expose.width == redisplayRect.width &&
+ event->expose.height == redisplayRect.height) {
+ test->state = REDISPLAYED;
+ }
+ break;
+
+ case PUGL_CLIENT:
+ if (event->client.data1 == postRedisplayId) {
+ test->state = SHOULD_REDISPLAY;
+ }
+ break;
+
+ default:
+ break;
+ }
+
+ return PUGL_SUCCESS;
}
int
main(int argc, char** argv)
{
- PuglTest app = {puglNewWorld(PUGL_PROGRAM, 0),
- NULL,
- puglParseTestOptions(&argc, &argv),
- START};
-
- // Set up view
- app.view = puglNewView(app.world);
- puglSetClassName(app.world, "Pugl Test");
- puglSetBackend(app.view, puglStubBackend());
- puglSetHandle(app.view, &app);
- puglSetEventFunc(app.view, onEvent);
- puglSetDefaultSize(app.view, 512, 512);
-
- // Create and show window
- assert(!puglRealize(app.view));
- assert(!puglShow(app.view));
- while (app.state != EXPOSED) {
- assert(!puglUpdate(app.world, timeout));
- }
-
- // Send a custom event to trigger a redisplay in the event loop
- PuglEvent client_event = {{PUGL_CLIENT, 0}};
- client_event.client.data1 = postRedisplayId;
- client_event.client.data2 = 0;
- assert(!puglSendEvent(app.view, &client_event));
-
- // Loop until an expose happens in the same iteration as the redisplay
- app.state = SHOULD_REDISPLAY;
- while (app.state != REDISPLAYED) {
- assert(!puglUpdate(app.world, timeout));
- assert(app.state != POSTED_REDISPLAY);
- }
-
- // Tear down
- puglFreeView(app.view);
- puglFreeWorld(app.world);
-
- return 0;
+ PuglTest app = {puglNewWorld(PUGL_PROGRAM, 0),
+ NULL,
+ puglParseTestOptions(&argc, &argv),
+ START};
+
+ // Set up view
+ app.view = puglNewView(app.world);
+ puglSetClassName(app.world, "Pugl Test");
+ puglSetBackend(app.view, puglStubBackend());
+ puglSetHandle(app.view, &app);
+ puglSetEventFunc(app.view, onEvent);
+ puglSetDefaultSize(app.view, 512, 512);
+
+ // Create and show window
+ assert(!puglRealize(app.view));
+ assert(!puglShow(app.view));
+ while (app.state != EXPOSED) {
+ assert(!puglUpdate(app.world, timeout));
+ }
+
+ // Send a custom event to trigger a redisplay in the event loop
+ PuglEvent client_event = {{PUGL_CLIENT, 0}};
+ client_event.client.data1 = postRedisplayId;
+ client_event.client.data2 = 0;
+ assert(!puglSendEvent(app.view, &client_event));
+
+ // Loop until an expose happens in the same iteration as the redisplay
+ app.state = SHOULD_REDISPLAY;
+ while (app.state != REDISPLAYED) {
+ assert(!puglUpdate(app.world, timeout));
+ assert(app.state != POSTED_REDISPLAY);
+ }
+
+ // Tear down
+ puglFreeView(app.view);
+ puglFreeWorld(app.world);
+
+ return 0;
}
diff --git a/pugl/test/test_show_hide.c b/pugl/test/test_show_hide.c
index 4280408..584448c 100644
--- a/pugl/test/test_show_hide.c
+++ b/pugl/test/test_show_hide.c
@@ -31,118 +31,118 @@
#include <stddef.h>
typedef enum {
- START,
- CREATED,
- CONFIGURED,
- MAPPED,
- EXPOSED,
- UNMAPPED,
- DESTROYED,
+ START,
+ CREATED,
+ CONFIGURED,
+ MAPPED,
+ EXPOSED,
+ UNMAPPED,
+ DESTROYED,
} State;
typedef struct {
- PuglWorld* world;
- PuglView* view;
- PuglTestOptions opts;
- State state;
+ PuglWorld* world;
+ PuglView* view;
+ PuglTestOptions opts;
+ State state;
} PuglTest;
static PuglStatus
onEvent(PuglView* view, const PuglEvent* event)
{
- PuglTest* test = (PuglTest*)puglGetHandle(view);
-
- if (test->opts.verbose) {
- printEvent(event, "Event: ", true);
- }
-
- switch (event->type) {
- case PUGL_CREATE:
- assert(test->state == START);
- test->state = CREATED;
- break;
- case PUGL_CONFIGURE:
- if (test->state == CREATED) {
- test->state = CONFIGURED;
- }
- break;
- case PUGL_MAP:
- assert(test->state == CONFIGURED || test->state == UNMAPPED);
- test->state = MAPPED;
- break;
- case PUGL_EXPOSE:
- assert(test->state == MAPPED || test->state == EXPOSED);
- test->state = EXPOSED;
- break;
- case PUGL_UNMAP:
- assert(test->state == EXPOSED);
- test->state = UNMAPPED;
- break;
- case PUGL_DESTROY:
- assert(test->state == UNMAPPED);
- test->state = DESTROYED;
- break;
- default:
- break;
- }
-
- return PUGL_SUCCESS;
+ PuglTest* test = (PuglTest*)puglGetHandle(view);
+
+ if (test->opts.verbose) {
+ printEvent(event, "Event: ", true);
+ }
+
+ switch (event->type) {
+ case PUGL_CREATE:
+ assert(test->state == START);
+ test->state = CREATED;
+ break;
+ case PUGL_CONFIGURE:
+ if (test->state == CREATED) {
+ test->state = CONFIGURED;
+ }
+ break;
+ case PUGL_MAP:
+ assert(test->state == CONFIGURED || test->state == UNMAPPED);
+ test->state = MAPPED;
+ break;
+ case PUGL_EXPOSE:
+ assert(test->state == MAPPED || test->state == EXPOSED);
+ test->state = EXPOSED;
+ break;
+ case PUGL_UNMAP:
+ assert(test->state == EXPOSED);
+ test->state = UNMAPPED;
+ break;
+ case PUGL_DESTROY:
+ assert(test->state == UNMAPPED);
+ test->state = DESTROYED;
+ break;
+ default:
+ break;
+ }
+
+ return PUGL_SUCCESS;
}
static void
tick(PuglWorld* world)
{
#ifdef __APPLE__
- // FIXME: Expose events are not events on MacOS, so we can't block
- // indefinitely here since it will block forever
- assert(!puglUpdate(world, 1 / 30.0));
+ // FIXME: Expose events are not events on MacOS, so we can't block
+ // indefinitely here since it will block forever
+ assert(!puglUpdate(world, 1 / 30.0));
#else
- assert(!puglUpdate(world, -1));
+ assert(!puglUpdate(world, -1));
#endif
}
int
main(int argc, char** argv)
{
- PuglTest test = {puglNewWorld(PUGL_PROGRAM, 0),
- NULL,
- puglParseTestOptions(&argc, &argv),
- START};
-
- // Set up view
- test.view = puglNewView(test.world);
- puglSetClassName(test.world, "Pugl Test");
- puglSetBackend(test.view, puglStubBackend());
- puglSetHandle(test.view, &test);
- puglSetEventFunc(test.view, onEvent);
- puglSetDefaultSize(test.view, 512, 512);
-
- // Create initially invisible window
- assert(!puglRealize(test.view));
- assert(!puglGetVisible(test.view));
- while (test.state < CREATED) {
- tick(test.world);
- }
-
- // Show and hide window a couple of times
- for (unsigned i = 0u; i < 2u; ++i) {
- assert(!puglShow(test.view));
- while (test.state != EXPOSED) {
- tick(test.world);
- }
-
- assert(puglGetVisible(test.view));
- assert(!puglHide(test.view));
- while (test.state != UNMAPPED) {
- tick(test.world);
- }
- }
-
- // Tear down
- assert(!puglGetVisible(test.view));
- puglFreeView(test.view);
- assert(test.state == DESTROYED);
- puglFreeWorld(test.world);
-
- return 0;
+ PuglTest test = {puglNewWorld(PUGL_PROGRAM, 0),
+ NULL,
+ puglParseTestOptions(&argc, &argv),
+ START};
+
+ // Set up view
+ test.view = puglNewView(test.world);
+ puglSetClassName(test.world, "Pugl Test");
+ puglSetBackend(test.view, puglStubBackend());
+ puglSetHandle(test.view, &test);
+ puglSetEventFunc(test.view, onEvent);
+ puglSetDefaultSize(test.view, 512, 512);
+
+ // Create initially invisible window
+ assert(!puglRealize(test.view));
+ assert(!puglGetVisible(test.view));
+ while (test.state < CREATED) {
+ tick(test.world);
+ }
+
+ // Show and hide window a couple of times
+ for (unsigned i = 0u; i < 2u; ++i) {
+ assert(!puglShow(test.view));
+ while (test.state != EXPOSED) {
+ tick(test.world);
+ }
+
+ assert(puglGetVisible(test.view));
+ assert(!puglHide(test.view));
+ while (test.state != UNMAPPED) {
+ tick(test.world);
+ }
+ }
+
+ // Tear down
+ assert(!puglGetVisible(test.view));
+ puglFreeView(test.view);
+ assert(test.state == DESTROYED);
+ puglFreeWorld(test.world);
+
+ return 0;
}
diff --git a/pugl/test/test_stub_hints.c b/pugl/test/test_stub_hints.c
index 2bfc86c..1cc1180 100644
--- a/pugl/test/test_stub_hints.c
+++ b/pugl/test/test_stub_hints.c
@@ -30,51 +30,51 @@
static PuglStatus
onEvent(PuglView* view, const PuglEvent* event)
{
- (void)view;
- (void)event;
+ (void)view;
+ (void)event;
- return PUGL_SUCCESS;
+ return PUGL_SUCCESS;
}
int
main(void)
{
- PuglWorld* const world = puglNewWorld(PUGL_PROGRAM, 0);
- PuglView* const view = puglNewView(world);
-
- // Set up view
- puglSetClassName(world, "Pugl Test");
- puglSetBackend(view, puglStubBackend());
- puglSetEventFunc(view, onEvent);
- puglSetDefaultSize(view, 512, 512);
-
- // Set all relevant hints that support it to PUGL_DONT_CARE
- assert(!puglSetViewHint(view, PUGL_RED_BITS, PUGL_DONT_CARE));
- assert(!puglSetViewHint(view, PUGL_GREEN_BITS, PUGL_DONT_CARE));
- assert(!puglSetViewHint(view, PUGL_BLUE_BITS, PUGL_DONT_CARE));
- assert(!puglSetViewHint(view, PUGL_ALPHA_BITS, PUGL_DONT_CARE));
- assert(!puglSetViewHint(view, PUGL_REFRESH_RATE, PUGL_DONT_CARE));
-
- // Realize view and print all hints for debugging convenience
- assert(!puglRealize(view));
- printViewHints(view);
-
- // Check that no relevant hints are set to PUGL_DONT_CARE
- assert(puglGetViewHint(view, PUGL_USE_COMPAT_PROFILE) != PUGL_DONT_CARE);
- assert(puglGetViewHint(view, PUGL_USE_DEBUG_CONTEXT) != PUGL_DONT_CARE);
- assert(puglGetViewHint(view, PUGL_CONTEXT_VERSION_MAJOR) != PUGL_DONT_CARE);
- assert(puglGetViewHint(view, PUGL_CONTEXT_VERSION_MINOR) != PUGL_DONT_CARE);
- assert(puglGetViewHint(view, PUGL_RED_BITS) != PUGL_DONT_CARE);
- assert(puglGetViewHint(view, PUGL_GREEN_BITS) != PUGL_DONT_CARE);
- assert(puglGetViewHint(view, PUGL_BLUE_BITS) != PUGL_DONT_CARE);
- assert(puglGetViewHint(view, PUGL_ALPHA_BITS) != PUGL_DONT_CARE);
- assert(puglGetViewHint(view, PUGL_RESIZABLE) != PUGL_DONT_CARE);
- assert(puglGetViewHint(view, PUGL_IGNORE_KEY_REPEAT) != PUGL_DONT_CARE);
- assert(puglGetViewHint(view, PUGL_REFRESH_RATE) != PUGL_DONT_CARE);
-
- // Tear down
- puglFreeView(view);
- puglFreeWorld(world);
-
- return 0;
+ PuglWorld* const world = puglNewWorld(PUGL_PROGRAM, 0);
+ PuglView* const view = puglNewView(world);
+
+ // Set up view
+ puglSetClassName(world, "Pugl Test");
+ puglSetBackend(view, puglStubBackend());
+ puglSetEventFunc(view, onEvent);
+ puglSetDefaultSize(view, 512, 512);
+
+ // Set all relevant hints that support it to PUGL_DONT_CARE
+ assert(!puglSetViewHint(view, PUGL_RED_BITS, PUGL_DONT_CARE));
+ assert(!puglSetViewHint(view, PUGL_GREEN_BITS, PUGL_DONT_CARE));
+ assert(!puglSetViewHint(view, PUGL_BLUE_BITS, PUGL_DONT_CARE));
+ assert(!puglSetViewHint(view, PUGL_ALPHA_BITS, PUGL_DONT_CARE));
+ assert(!puglSetViewHint(view, PUGL_REFRESH_RATE, PUGL_DONT_CARE));
+
+ // Realize view and print all hints for debugging convenience
+ assert(!puglRealize(view));
+ printViewHints(view);
+
+ // Check that no relevant hints are set to PUGL_DONT_CARE
+ assert(puglGetViewHint(view, PUGL_USE_COMPAT_PROFILE) != PUGL_DONT_CARE);
+ assert(puglGetViewHint(view, PUGL_USE_DEBUG_CONTEXT) != PUGL_DONT_CARE);
+ assert(puglGetViewHint(view, PUGL_CONTEXT_VERSION_MAJOR) != PUGL_DONT_CARE);
+ assert(puglGetViewHint(view, PUGL_CONTEXT_VERSION_MINOR) != PUGL_DONT_CARE);
+ assert(puglGetViewHint(view, PUGL_RED_BITS) != PUGL_DONT_CARE);
+ assert(puglGetViewHint(view, PUGL_GREEN_BITS) != PUGL_DONT_CARE);
+ assert(puglGetViewHint(view, PUGL_BLUE_BITS) != PUGL_DONT_CARE);
+ assert(puglGetViewHint(view, PUGL_ALPHA_BITS) != PUGL_DONT_CARE);
+ assert(puglGetViewHint(view, PUGL_RESIZABLE) != PUGL_DONT_CARE);
+ assert(puglGetViewHint(view, PUGL_IGNORE_KEY_REPEAT) != PUGL_DONT_CARE);
+ assert(puglGetViewHint(view, PUGL_REFRESH_RATE) != PUGL_DONT_CARE);
+
+ // Tear down
+ puglFreeView(view);
+ puglFreeWorld(world);
+
+ return 0;
}
diff --git a/pugl/test/test_timer.c b/pugl/test/test_timer.c
index 0b77396..18518ec 100644
--- a/pugl/test/test_timer.c
+++ b/pugl/test/test_timer.c
@@ -50,112 +50,110 @@ static const uintptr_t timerId = 1u;
static const double timerPeriod = 1 / 60.0;
typedef enum {
- START,
- EXPOSED,
+ START,
+ EXPOSED,
} State;
typedef struct {
- PuglWorld* world;
- PuglView* view;
- PuglTestOptions opts;
- size_t numAlarms;
- State state;
+ PuglWorld* world;
+ PuglView* view;
+ PuglTestOptions opts;
+ size_t numAlarms;
+ State state;
} PuglTest;
static PuglStatus
onEvent(PuglView* view, const PuglEvent* event)
{
- PuglTest* test = (PuglTest*)puglGetHandle(view);
+ PuglTest* test = (PuglTest*)puglGetHandle(view);
- if (test->opts.verbose) {
- printEvent(event, "Event: ", true);
- }
+ if (test->opts.verbose) {
+ printEvent(event, "Event: ", true);
+ }
- switch (event->type) {
- case PUGL_EXPOSE:
- test->state = EXPOSED;
- break;
+ switch (event->type) {
+ case PUGL_EXPOSE:
+ test->state = EXPOSED;
+ break;
- case PUGL_TIMER:
- assert(event->timer.id == timerId);
- ++test->numAlarms;
- break;
+ case PUGL_TIMER:
+ assert(event->timer.id == timerId);
+ ++test->numAlarms;
+ break;
- default:
- break;
- }
+ default:
+ break;
+ }
- return PUGL_SUCCESS;
+ return PUGL_SUCCESS;
}
static double
roundPeriod(const double period)
{
- return floor(period * 1000.0) / 1000.0; // Round down to milliseconds
+ return floor(period * 1000.0) / 1000.0; // Round down to milliseconds
}
int
main(int argc, char** argv)
{
- PuglTest app = {puglNewWorld(PUGL_PROGRAM, 0),
- NULL,
- puglParseTestOptions(&argc, &argv),
- 0,
- START};
-
- // Set up view
- app.view = puglNewView(app.world);
- puglSetClassName(app.world, "Pugl Test");
- puglSetBackend(app.view, puglStubBackend());
- puglSetHandle(app.view, &app);
- puglSetEventFunc(app.view, onEvent);
- puglSetDefaultSize(app.view, 512, 512);
-
- // Create and show window
- assert(!puglRealize(app.view));
- assert(!puglShow(app.view));
- while (app.state != EXPOSED) {
- assert(!puglUpdate(app.world, timeout));
- }
-
- // Register a timer with a longer period first
- assert(!puglStartTimer(app.view, timerId, timerPeriod * 2.0));
-
- // Replace it with the one we want (to ensure timers are replaced)
- assert(!puglStartTimer(app.view, timerId, timerPeriod));
-
- const double startTime = puglGetTime(app.world);
-
- puglUpdate(app.world, 1.0);
-
- // Calculate the actual period of the timer
- const double endTime = puglGetTime(app.world);
- const double duration = endTime - startTime;
- const double expectedPeriod = roundPeriod(timerPeriod);
- const double actualPeriod = roundPeriod(duration / (double)app.numAlarms);
- const double difference = fabs(actualPeriod - expectedPeriod);
-
- if (difference > tolerance) {
- fprintf(stderr,
- "error: Period not within %f of %f\n",
- tolerance,
- expectedPeriod);
- fprintf(stderr, "note: Actual period %f\n", actualPeriod);
- }
-
- assert(difference <= tolerance);
-
- // Deregister timer and tick once to synchronize
- assert(!puglStopTimer(app.view, timerId));
- puglUpdate(app.world, 0.0);
-
- // Update for a half second and check that we receive no more alarms
- app.numAlarms = 0;
- puglUpdate(app.world, 0.5);
- assert(app.numAlarms == 0);
-
- puglFreeView(app.view);
- puglFreeWorld(app.world);
-
- return 0;
+ PuglTest app = {puglNewWorld(PUGL_PROGRAM, 0),
+ NULL,
+ puglParseTestOptions(&argc, &argv),
+ 0,
+ START};
+
+ // Set up view
+ app.view = puglNewView(app.world);
+ puglSetClassName(app.world, "Pugl Test");
+ puglSetBackend(app.view, puglStubBackend());
+ puglSetHandle(app.view, &app);
+ puglSetEventFunc(app.view, onEvent);
+ puglSetDefaultSize(app.view, 512, 512);
+
+ // Create and show window
+ assert(!puglRealize(app.view));
+ assert(!puglShow(app.view));
+ while (app.state != EXPOSED) {
+ assert(!puglUpdate(app.world, timeout));
+ }
+
+ // Register a timer with a longer period first
+ assert(!puglStartTimer(app.view, timerId, timerPeriod * 2.0));
+
+ // Replace it with the one we want (to ensure timers are replaced)
+ assert(!puglStartTimer(app.view, timerId, timerPeriod));
+
+ const double startTime = puglGetTime(app.world);
+
+ puglUpdate(app.world, 1.0);
+
+ // Calculate the actual period of the timer
+ const double endTime = puglGetTime(app.world);
+ const double duration = endTime - startTime;
+ const double expectedPeriod = roundPeriod(timerPeriod);
+ const double actualPeriod = roundPeriod(duration / (double)app.numAlarms);
+ const double difference = fabs(actualPeriod - expectedPeriod);
+
+ if (difference > tolerance) {
+ fprintf(
+ stderr, "error: Period not within %f of %f\n", tolerance, expectedPeriod);
+ fprintf(stderr, "note: Actual period %f\n", actualPeriod);
+ }
+
+ assert(difference <= tolerance);
+
+ // Deregister timer and tick once to synchronize
+ assert(!puglStopTimer(app.view, timerId));
+ puglUpdate(app.world, 0.0);
+
+ // Update for a half second and check that we receive no more alarms
+ app.numAlarms = 0;
+ puglUpdate(app.world, 0.5);
+ assert(app.numAlarms == 0);
+
+ puglFreeView(app.view);
+ puglFreeWorld(app.world);
+
+ return 0;
}
diff --git a/pugl/test/test_update.c b/pugl/test/test_update.c
index b35e96e..89de0b6 100644
--- a/pugl/test/test_update.c
+++ b/pugl/test/test_update.c
@@ -37,89 +37,89 @@ static const double timeout = -1.0;
#endif
typedef enum {
- START,
- EXPOSED1,
- UPDATED,
- EXPOSED2,
+ START,
+ EXPOSED1,
+ UPDATED,
+ EXPOSED2,
} State;
typedef struct {
- PuglWorld* world;
- PuglView* view;
- PuglTestOptions opts;
- State state;
+ PuglWorld* world;
+ PuglView* view;
+ PuglTestOptions opts;
+ State state;
} PuglTest;
static PuglStatus
onEvent(PuglView* view, const PuglEvent* event)
{
- PuglTest* test = (PuglTest*)puglGetHandle(view);
-
- if (test->opts.verbose) {
- printEvent(event, "Event: ", true);
- }
-
- switch (event->type) {
- case PUGL_EXPOSE:
- switch (test->state) {
- case START:
- test->state = EXPOSED1;
- break;
- case UPDATED:
- test->state = EXPOSED2;
- break;
- default:
- break;
- }
- break;
-
- case PUGL_UPDATE:
- if (test->state == EXPOSED1) {
- puglPostRedisplay(view);
- test->state = UPDATED;
- }
- break;
-
- default:
- break;
- }
-
- return PUGL_SUCCESS;
+ PuglTest* test = (PuglTest*)puglGetHandle(view);
+
+ if (test->opts.verbose) {
+ printEvent(event, "Event: ", true);
+ }
+
+ switch (event->type) {
+ case PUGL_EXPOSE:
+ switch (test->state) {
+ case START:
+ test->state = EXPOSED1;
+ break;
+ case UPDATED:
+ test->state = EXPOSED2;
+ break;
+ default:
+ break;
+ }
+ break;
+
+ case PUGL_UPDATE:
+ if (test->state == EXPOSED1) {
+ puglPostRedisplay(view);
+ test->state = UPDATED;
+ }
+ break;
+
+ default:
+ break;
+ }
+
+ return PUGL_SUCCESS;
}
int
main(int argc, char** argv)
{
- PuglTest app = {puglNewWorld(PUGL_PROGRAM, 0),
- NULL,
- puglParseTestOptions(&argc, &argv),
- START};
-
- // Set up view
- app.view = puglNewView(app.world);
- puglSetClassName(app.world, "Pugl Test");
- puglSetBackend(app.view, puglStubBackend());
- puglSetHandle(app.view, &app);
- puglSetEventFunc(app.view, onEvent);
- puglSetDefaultSize(app.view, 512, 512);
-
- // Create and show window
- assert(!puglRealize(app.view));
- assert(!puglShow(app.view));
-
- // Tick until an expose happens
- while (app.state < EXPOSED1) {
- assert(!puglUpdate(app.world, timeout));
- assert(app.state != UPDATED);
- }
-
- // Tick once and ensure the update and the expose it posted both happened
- assert(!puglUpdate(app.world, 0.0));
- assert(app.state == EXPOSED2);
-
- // Tear down
- puglFreeView(app.view);
- puglFreeWorld(app.world);
-
- return 0;
+ PuglTest app = {puglNewWorld(PUGL_PROGRAM, 0),
+ NULL,
+ puglParseTestOptions(&argc, &argv),
+ START};
+
+ // Set up view
+ app.view = puglNewView(app.world);
+ puglSetClassName(app.world, "Pugl Test");
+ puglSetBackend(app.view, puglStubBackend());
+ puglSetHandle(app.view, &app);
+ puglSetEventFunc(app.view, onEvent);
+ puglSetDefaultSize(app.view, 512, 512);
+
+ // Create and show window
+ assert(!puglRealize(app.view));
+ assert(!puglShow(app.view));
+
+ // Tick until an expose happens
+ while (app.state < EXPOSED1) {
+ assert(!puglUpdate(app.world, timeout));
+ assert(app.state != UPDATED);
+ }
+
+ // Tick once and ensure the update and the expose it posted both happened
+ assert(!puglUpdate(app.world, 0.0));
+ assert(app.state == EXPOSED2);
+
+ // Tear down
+ puglFreeView(app.view);
+ puglFreeWorld(app.world);
+
+ return 0;
}
diff --git a/pugl/test/test_utils.h b/pugl/test/test_utils.h
index 7a91535..2464737 100644
--- a/pugl/test/test_utils.h
+++ b/pugl/test/test_utils.h
@@ -29,328 +29,328 @@
#include <string.h>
#ifdef __GNUC__
-# define PUGL_LOG_FUNC(fmt, arg1) __attribute__((format(printf, fmt, arg1)))
+# define PUGL_LOG_FUNC(fmt, arg1) __attribute__((format(printf, fmt, arg1)))
#else
-# define PUGL_LOG_FUNC(fmt, arg1)
+# define PUGL_LOG_FUNC(fmt, arg1)
#endif
typedef struct {
- int samples;
- int doubleBuffer;
- int sync;
- bool continuous;
- bool help;
- bool ignoreKeyRepeat;
- bool resizable;
- bool verbose;
- bool errorChecking;
+ int samples;
+ int doubleBuffer;
+ int sync;
+ bool continuous;
+ bool help;
+ bool ignoreKeyRepeat;
+ bool resizable;
+ bool verbose;
+ bool errorChecking;
} PuglTestOptions;
PUGL_LOG_FUNC(1, 2)
static int
logError(const char* fmt, ...)
{
- fprintf(stderr, "error: ");
+ fprintf(stderr, "error: ");
- va_list args; // NOLINT
- va_start(args, fmt);
- vfprintf(stderr, fmt, args);
- va_end(args);
+ va_list args; // NOLINT
+ va_start(args, fmt);
+ vfprintf(stderr, fmt, args);
+ va_end(args);
- return 1;
+ return 1;
}
static inline int
printModifiers(const uint32_t mods)
{
- return fprintf(stderr, "Modifiers:%s%s%s%s\n",
- (mods & PUGL_MOD_SHIFT) ? " Shift" : "",
- (mods & PUGL_MOD_CTRL) ? " Ctrl" : "",
- (mods & PUGL_MOD_ALT) ? " Alt" : "",
- (mods & PUGL_MOD_SUPER) ? " Super" : "");
+ return fprintf(stderr,
+ "Modifiers:%s%s%s%s\n",
+ (mods & PUGL_MOD_SHIFT) ? " Shift" : "",
+ (mods & PUGL_MOD_CTRL) ? " Ctrl" : "",
+ (mods & PUGL_MOD_ALT) ? " Alt" : "",
+ (mods & PUGL_MOD_SUPER) ? " Super" : "");
}
static inline const char*
crossingModeString(const PuglCrossingMode mode)
{
- switch (mode) {
- case PUGL_CROSSING_NORMAL:
- return "normal";
- case PUGL_CROSSING_GRAB:
- return "grab";
- case PUGL_CROSSING_UNGRAB:
- return "ungrab";
- }
+ switch (mode) {
+ case PUGL_CROSSING_NORMAL:
+ return "normal";
+ case PUGL_CROSSING_GRAB:
+ return "grab";
+ case PUGL_CROSSING_UNGRAB:
+ return "ungrab";
+ }
- return "unknown";
+ return "unknown";
}
static inline const char*
scrollDirectionString(const PuglScrollDirection direction)
{
- switch (direction) {
- case PUGL_SCROLL_UP:
- return "up";
- case PUGL_SCROLL_DOWN:
- return "down";
- case PUGL_SCROLL_LEFT:
- return "left";
- case PUGL_SCROLL_RIGHT:
- return "right";
- case PUGL_SCROLL_SMOOTH:
- return "smooth";
- }
+ switch (direction) {
+ case PUGL_SCROLL_UP:
+ return "up";
+ case PUGL_SCROLL_DOWN:
+ return "down";
+ case PUGL_SCROLL_LEFT:
+ return "left";
+ case PUGL_SCROLL_RIGHT:
+ return "right";
+ case PUGL_SCROLL_SMOOTH:
+ return "smooth";
+ }
- return "unknown";
+ return "unknown";
}
static inline int
printEvent(const PuglEvent* event, const char* prefix, const bool verbose)
{
-#define FFMT "%6.1f"
-#define PFMT FFMT " " FFMT
+#define FFMT "%6.1f"
+#define PFMT FFMT " " FFMT
#define PRINT(fmt, ...) fprintf(stderr, fmt, __VA_ARGS__)
- switch (event->type) {
- case PUGL_NOTHING:
- return 0;
- case PUGL_KEY_PRESS:
- return PRINT("%sKey press code %3u key U+%04X\n",
- prefix,
- event->key.keycode,
- event->key.key);
- case PUGL_KEY_RELEASE:
- return PRINT("%sKey release code %3u key U+%04X\n",
- prefix,
- event->key.keycode,
- event->key.key);
- case PUGL_TEXT:
- return PRINT("%sText entry code %3u char U+%04X (%s)\n",
- prefix,
- event->text.keycode,
- event->text.character,
- event->text.string);
- case PUGL_BUTTON_PRESS:
- case PUGL_BUTTON_RELEASE:
- return (PRINT("%sMouse %u %s at " PFMT " ",
- prefix,
- event->button.button,
- (event->type == PUGL_BUTTON_PRESS) ? "down" : "up ",
- event->button.x,
- event->button.y) +
- printModifiers(event->scroll.state));
- case PUGL_SCROLL:
- return (PRINT("%sScroll %5.1f %5.1f (%s) at " PFMT " ",
- prefix,
- event->scroll.dx,
- event->scroll.dy,
- scrollDirectionString(event->scroll.direction),
- event->scroll.x,
- event->scroll.y) +
- printModifiers(event->scroll.state));
- case PUGL_POINTER_IN:
- return PRINT("%sMouse enter at " PFMT " (%s)\n",
- prefix,
- event->crossing.x,
- event->crossing.y,
- crossingModeString(event->crossing.mode));
- case PUGL_POINTER_OUT:
- return PRINT("%sMouse leave at " PFMT " (%s)\n",
- prefix,
- event->crossing.x,
- event->crossing.y,
- crossingModeString(event->crossing.mode));
- case PUGL_FOCUS_IN:
- return PRINT("%sFocus in (%s)\n",
- prefix,
- crossingModeString(event->crossing.mode));
- case PUGL_FOCUS_OUT:
- return PRINT("%sFocus out (%s)\n",
- prefix,
- crossingModeString(event->crossing.mode));
- case PUGL_CLIENT:
- return PRINT("%sClient %" PRIXPTR " %" PRIXPTR "\n",
- prefix,
- event->client.data1,
- event->client.data2);
- case PUGL_LOOP_ENTER:
- return PRINT("%sLoop enter\n", prefix);
- case PUGL_LOOP_LEAVE:
- return PRINT("%sLoop leave\n", prefix);
- default:
- break;
- }
+ switch (event->type) {
+ case PUGL_NOTHING:
+ return 0;
+ case PUGL_KEY_PRESS:
+ return PRINT("%sKey press code %3u key U+%04X\n",
+ prefix,
+ event->key.keycode,
+ event->key.key);
+ case PUGL_KEY_RELEASE:
+ return PRINT("%sKey release code %3u key U+%04X\n",
+ prefix,
+ event->key.keycode,
+ event->key.key);
+ case PUGL_TEXT:
+ return PRINT("%sText entry code %3u char U+%04X (%s)\n",
+ prefix,
+ event->text.keycode,
+ event->text.character,
+ event->text.string);
+ case PUGL_BUTTON_PRESS:
+ case PUGL_BUTTON_RELEASE:
+ return (PRINT("%sMouse %u %s at " PFMT " ",
+ prefix,
+ event->button.button,
+ (event->type == PUGL_BUTTON_PRESS) ? "down" : "up ",
+ event->button.x,
+ event->button.y) +
+ printModifiers(event->scroll.state));
+ case PUGL_SCROLL:
+ return (PRINT("%sScroll %5.1f %5.1f (%s) at " PFMT " ",
+ prefix,
+ event->scroll.dx,
+ event->scroll.dy,
+ scrollDirectionString(event->scroll.direction),
+ event->scroll.x,
+ event->scroll.y) +
+ printModifiers(event->scroll.state));
+ case PUGL_POINTER_IN:
+ return PRINT("%sMouse enter at " PFMT " (%s)\n",
+ prefix,
+ event->crossing.x,
+ event->crossing.y,
+ crossingModeString(event->crossing.mode));
+ case PUGL_POINTER_OUT:
+ return PRINT("%sMouse leave at " PFMT " (%s)\n",
+ prefix,
+ event->crossing.x,
+ event->crossing.y,
+ crossingModeString(event->crossing.mode));
+ case PUGL_FOCUS_IN:
+ return PRINT(
+ "%sFocus in (%s)\n", prefix, crossingModeString(event->crossing.mode));
+ case PUGL_FOCUS_OUT:
+ return PRINT(
+ "%sFocus out (%s)\n", prefix, crossingModeString(event->crossing.mode));
+ case PUGL_CLIENT:
+ return PRINT("%sClient %" PRIXPTR " %" PRIXPTR "\n",
+ prefix,
+ event->client.data1,
+ event->client.data2);
+ case PUGL_LOOP_ENTER:
+ return PRINT("%sLoop enter\n", prefix);
+ case PUGL_LOOP_LEAVE:
+ return PRINT("%sLoop leave\n", prefix);
+ default:
+ break;
+ }
- if (verbose) {
- switch (event->type) {
- case PUGL_CREATE:
- return fprintf(stderr, "%sCreate\n", prefix);
- case PUGL_DESTROY:
- return fprintf(stderr, "%sDestroy\n", prefix);
- case PUGL_MAP:
- return fprintf(stderr, "%sMap\n", prefix);
- case PUGL_UNMAP:
- return fprintf(stderr, "%sUnmap\n", prefix);
- case PUGL_UPDATE:
- return fprintf(stderr, "%sUpdate\n", prefix);
- case PUGL_CONFIGURE:
- return PRINT("%sConfigure " PFMT " " PFMT "\n",
- prefix,
- event->configure.x,
- event->configure.y,
- event->configure.width,
- event->configure.height);
- case PUGL_EXPOSE:
- return PRINT("%sExpose " PFMT " " PFMT "\n",
- prefix,
- event->expose.x,
- event->expose.y,
- event->expose.width,
- event->expose.height);
- case PUGL_CLOSE:
- return PRINT("%sClose\n", prefix);
- case PUGL_MOTION:
- return PRINT("%sMouse motion at " PFMT "\n",
- prefix,
- event->motion.x,
- event->motion.y);
- case PUGL_TIMER:
- return PRINT("%sTimer %" PRIuPTR "\n", prefix, event->timer.id);
- default:
- return PRINT("%sUnknown event type %d\n", prefix, (int)event->type);
- }
- }
+ if (verbose) {
+ switch (event->type) {
+ case PUGL_CREATE:
+ return fprintf(stderr, "%sCreate\n", prefix);
+ case PUGL_DESTROY:
+ return fprintf(stderr, "%sDestroy\n", prefix);
+ case PUGL_MAP:
+ return fprintf(stderr, "%sMap\n", prefix);
+ case PUGL_UNMAP:
+ return fprintf(stderr, "%sUnmap\n", prefix);
+ case PUGL_UPDATE:
+ return fprintf(stderr, "%sUpdate\n", prefix);
+ case PUGL_CONFIGURE:
+ return PRINT("%sConfigure " PFMT " " PFMT "\n",
+ prefix,
+ event->configure.x,
+ event->configure.y,
+ event->configure.width,
+ event->configure.height);
+ case PUGL_EXPOSE:
+ return PRINT("%sExpose " PFMT " " PFMT "\n",
+ prefix,
+ event->expose.x,
+ event->expose.y,
+ event->expose.width,
+ event->expose.height);
+ case PUGL_CLOSE:
+ return PRINT("%sClose\n", prefix);
+ case PUGL_MOTION:
+ return PRINT("%sMouse motion at " PFMT "\n",
+ prefix,
+ event->motion.x,
+ event->motion.y);
+ case PUGL_TIMER:
+ return PRINT("%sTimer %" PRIuPTR "\n", prefix, event->timer.id);
+ default:
+ return PRINT("%sUnknown event type %d\n", prefix, (int)event->type);
+ }
+ }
#undef PRINT
#undef PFMT
#undef FFMT
- return 0;
+ return 0;
}
static inline const char*
puglViewHintString(const PuglViewHint hint)
{
- switch (hint) {
- case PUGL_USE_COMPAT_PROFILE:
- return "Use compatible profile";
- case PUGL_USE_DEBUG_CONTEXT:
- return "Use debug context";
- case PUGL_CONTEXT_VERSION_MAJOR:
- return "Context major version";
- case PUGL_CONTEXT_VERSION_MINOR:
- return "Context minor version";
- case PUGL_RED_BITS:
- return "Red bits";
- case PUGL_GREEN_BITS:
- return "Green bits";
- case PUGL_BLUE_BITS:
- return "Blue bits";
- case PUGL_ALPHA_BITS:
- return "Alpha bits";
- case PUGL_DEPTH_BITS:
- return "Depth bits";
- case PUGL_STENCIL_BITS:
- return "Stencil bits";
- case PUGL_SAMPLES:
- return "Samples";
- case PUGL_DOUBLE_BUFFER:
- return "Double buffer";
- case PUGL_SWAP_INTERVAL:
- return "Swap interval";
- case PUGL_RESIZABLE:
- return "Resizable";
- case PUGL_IGNORE_KEY_REPEAT:
- return "Ignore key repeat";
- case PUGL_REFRESH_RATE:
- return "Refresh rate";
- case PUGL_NUM_VIEW_HINTS:
- return "Unknown";
- }
+ switch (hint) {
+ case PUGL_USE_COMPAT_PROFILE:
+ return "Use compatible profile";
+ case PUGL_USE_DEBUG_CONTEXT:
+ return "Use debug context";
+ case PUGL_CONTEXT_VERSION_MAJOR:
+ return "Context major version";
+ case PUGL_CONTEXT_VERSION_MINOR:
+ return "Context minor version";
+ case PUGL_RED_BITS:
+ return "Red bits";
+ case PUGL_GREEN_BITS:
+ return "Green bits";
+ case PUGL_BLUE_BITS:
+ return "Blue bits";
+ case PUGL_ALPHA_BITS:
+ return "Alpha bits";
+ case PUGL_DEPTH_BITS:
+ return "Depth bits";
+ case PUGL_STENCIL_BITS:
+ return "Stencil bits";
+ case PUGL_SAMPLES:
+ return "Samples";
+ case PUGL_DOUBLE_BUFFER:
+ return "Double buffer";
+ case PUGL_SWAP_INTERVAL:
+ return "Swap interval";
+ case PUGL_RESIZABLE:
+ return "Resizable";
+ case PUGL_IGNORE_KEY_REPEAT:
+ return "Ignore key repeat";
+ case PUGL_REFRESH_RATE:
+ return "Refresh rate";
+ case PUGL_NUM_VIEW_HINTS:
+ return "Unknown";
+ }
- return "Unknown";
+ return "Unknown";
}
static inline void
printViewHints(const PuglView* view)
{
- for (int i = 0; i < PUGL_NUM_VIEW_HINTS; ++i) {
- const PuglViewHint hint = (PuglViewHint)i;
- fprintf(stderr,
- "%s: %d\n",
- puglViewHintString(hint),
- puglGetViewHint(view, hint));
- }
+ for (int i = 0; i < PUGL_NUM_VIEW_HINTS; ++i) {
+ const PuglViewHint hint = (PuglViewHint)i;
+ fprintf(stderr,
+ "%s: %d\n",
+ puglViewHintString(hint),
+ puglGetViewHint(view, hint));
+ }
}
static inline void
puglPrintTestUsage(const char* prog, const char* posHelp)
{
- printf("Usage: %s [OPTION]... %s\n\n"
- " -a Enable anti-aliasing\n"
- " -c Continuously animate and draw\n"
- " -d Directly draw to window (no double-buffering)\n"
- " -e Enable platform error-checking\n"
- " -f Fast drawing, explicitly disable vertical sync\n"
- " -h Display this help\n"
- " -i Ignore key repeat\n"
- " -v Print verbose output\n"
- " -r Resizable window\n"
- " -s Explicitly enable vertical sync\n",
- prog, posHelp);
+ printf("Usage: %s [OPTION]... %s\n\n"
+ " -a Enable anti-aliasing\n"
+ " -c Continuously animate and draw\n"
+ " -d Directly draw to window (no double-buffering)\n"
+ " -e Enable platform error-checking\n"
+ " -f Fast drawing, explicitly disable vertical sync\n"
+ " -h Display this help\n"
+ " -i Ignore key repeat\n"
+ " -v Print verbose output\n"
+ " -r Resizable window\n"
+ " -s Explicitly enable vertical sync\n",
+ prog,
+ posHelp);
}
static inline PuglTestOptions
puglParseTestOptions(int* pargc, char*** pargv)
{
- PuglTestOptions opts = {
- 0,
- PUGL_TRUE,
- PUGL_DONT_CARE,
- false,
- false,
- false,
- false,
- false,
- false,
- };
+ PuglTestOptions opts = {
+ 0,
+ PUGL_TRUE,
+ PUGL_DONT_CARE,
+ false,
+ false,
+ false,
+ false,
+ false,
+ false,
+ };
- char** const argv = *pargv;
- int i = 1;
- for (; i < *pargc; ++i) {
- if (!strcmp(argv[i], "-a")) {
- opts.samples = 4;
- } else if (!strcmp(argv[i], "-c")) {
- opts.continuous = true;
- } else if (!strcmp(argv[i], "-d")) {
- opts.doubleBuffer = PUGL_FALSE;
- } else if (!strcmp(argv[i], "-e")) {
- opts.errorChecking = PUGL_TRUE;
- } else if (!strcmp(argv[i], "-f")) {
- opts.sync = PUGL_FALSE;
- } else if (!strcmp(argv[i], "-h")) {
- opts.help = true;
- return opts;
- } else if (!strcmp(argv[i], "-i")) {
- opts.ignoreKeyRepeat = true;
- } else if (!strcmp(argv[i], "-r")) {
- opts.resizable = true;
- } else if (!strcmp(argv[i], "-s")) {
- opts.sync = PUGL_TRUE;
- } else if (!strcmp(argv[i], "-v")) {
- opts.verbose = true;
- } else if (argv[i][0] != '-') {
- break;
- } else {
- opts.help = true;
- logError("Unknown option: %s\n", argv[i]);
- }
- }
+ char** const argv = *pargv;
+ int i = 1;
+ for (; i < *pargc; ++i) {
+ if (!strcmp(argv[i], "-a")) {
+ opts.samples = 4;
+ } else if (!strcmp(argv[i], "-c")) {
+ opts.continuous = true;
+ } else if (!strcmp(argv[i], "-d")) {
+ opts.doubleBuffer = PUGL_FALSE;
+ } else if (!strcmp(argv[i], "-e")) {
+ opts.errorChecking = PUGL_TRUE;
+ } else if (!strcmp(argv[i], "-f")) {
+ opts.sync = PUGL_FALSE;
+ } else if (!strcmp(argv[i], "-h")) {
+ opts.help = true;
+ return opts;
+ } else if (!strcmp(argv[i], "-i")) {
+ opts.ignoreKeyRepeat = true;
+ } else if (!strcmp(argv[i], "-r")) {
+ opts.resizable = true;
+ } else if (!strcmp(argv[i], "-s")) {
+ opts.sync = PUGL_TRUE;
+ } else if (!strcmp(argv[i], "-v")) {
+ opts.verbose = true;
+ } else if (argv[i][0] != '-') {
+ break;
+ } else {
+ opts.help = true;
+ logError("Unknown option: %s\n", argv[i]);
+ }
+ }
- *pargc -= i;
- *pargv += i;
+ *pargc -= i;
+ *pargv += i;
- return opts;
+ return opts;
}
#endif // TEST_TEST_UTILS_H