Open source Star Ruler 2 source code!

source/glfw/tests/CMakeLists.txt

@@ -0,0 +1,71 @@
+
+link_libraries(glfw ${OPENGL_glu_LIBRARY})
+
+if (BUILD_SHARED_LIBS)
+    add_definitions(-DGLFW_DLL)
+    link_libraries(${OPENGL_gl_LIBRARY} ${MATH_LIBRARY})
+else()
+    link_libraries(${glfw_LIBRARIES})
+endif()
+
+include_directories(${GLFW_SOURCE_DIR}/include
+                    ${GLFW_SOURCE_DIR}/deps)
+
+if (NOT APPLE)
+    # HACK: This is NOTFOUND on OS X 10.8
+    include_directories(${OPENGL_INCLUDE_DIR})
+endif()
+
+set(GETOPT ${GLFW_SOURCE_DIR}/deps/getopt.h
+           ${GLFW_SOURCE_DIR}/deps/getopt.c)
+set(TINYCTHREAD ${GLFW_SOURCE_DIR}/deps/tinycthread.h
+                ${GLFW_SOURCE_DIR}/deps/tinycthread.c)
+
+add_executable(clipboard clipboard.c ${GETOPT})
+add_executable(defaults defaults.c)
+add_executable(events events.c)
+add_executable(fsaa fsaa.c ${GETOPT})
+add_executable(gamma gamma.c ${GETOPT})
+add_executable(glfwinfo glfwinfo.c ${GETOPT})
+add_executable(iconify iconify.c ${GETOPT})
+add_executable(joysticks joysticks.c)
+add_executable(modes modes.c ${GETOPT})
+add_executable(peter peter.c)
+add_executable(reopen reopen.c)
+
+add_executable(accuracy WIN32 MACOSX_BUNDLE accuracy.c)
+set_target_properties(accuracy PROPERTIES MACOSX_BUNDLE_BUNDLE_NAME "Accuracy")
+
+add_executable(sharing WIN32 MACOSX_BUNDLE sharing.c)
+set_target_properties(sharing PROPERTIES MACOSX_BUNDLE_BUNDLE_NAME "Sharing")
+
+add_executable(tearing WIN32 MACOSX_BUNDLE tearing.c)
+set_target_properties(tearing PROPERTIES MACOSX_BUNDLE_BUNDLE_NAME "Tearing")
+
+add_executable(threads WIN32 MACOSX_BUNDLE threads.c ${TINYCTHREAD})
+set_target_properties(threads PROPERTIES MACOSX_BUNDLE_BUNDLE_NAME "Threads")
+
+add_executable(title WIN32 MACOSX_BUNDLE title.c)
+set_target_properties(title PROPERTIES MACOSX_BUNDLE_BUNDLE_NAME "Title")
+
+add_executable(windows WIN32 MACOSX_BUNDLE windows.c)
+set_target_properties(windows PROPERTIES MACOSX_BUNDLE_BUNDLE_NAME "Windows")
+
+target_link_libraries(threads ${CMAKE_THREAD_LIBS_INIT} ${RT_LIBRARY})
+
+set(WINDOWS_BINARIES accuracy sharing tearing threads title windows)
+set(CONSOLE_BINARIES clipboard defaults events fsaa gamma glfwinfo
+                     iconify joysticks modes peter reopen)
+
+if (MSVC)
+    # Tell MSVC to use main instead of WinMain for Windows subsystem executables
+    set_target_properties(${WINDOWS_BINARIES} ${CONSOLE_BINARIES} PROPERTIES
+                          LINK_FLAGS "/ENTRY:mainCRTStartup")
+endif()
+
+if (APPLE)
+    set_target_properties(${WINDOWS_BINARIES} ${CONSOLE_BINARIES} PROPERTIES
+                          MACOSX_BUNDLE_SHORT_VERSION_STRING ${GLFW_VERSION}
+                          MACOSX_BUNDLE_LONG_VERSION_STRING ${GLFW_VERSION_FULL})
+endif()
+

source/glfw/tests/accuracy.c

@@ -0,0 +1,129 @@
+//========================================================================
+// Mouse cursor accuracy test
+// Copyright (c) Camilla Berglund <elmindreda@elmindreda.org>
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+//    claim that you wrote the original software. If you use this software
+//    in a product, an acknowledgment in the product documentation would
+//    be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such, and must not
+//    be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source
+//    distribution.
+//
+//========================================================================
+//
+// This test came about as the result of bug #1867804
+//
+// No sign of said bug has so far been detected
+//
+//========================================================================
+
+#define GLFW_INCLUDE_GLU
+#include <GLFW/glfw3.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+
+static double cursor_x = 0.0, cursor_y = 0.0;
+static int window_width = 640, window_height = 480;
+static int swap_interval = 1;
+
+static void set_swap_interval(GLFWwindow* window, int interval)
+{
+    char title[256];
+
+    swap_interval = interval;
+    glfwSwapInterval(swap_interval);
+
+    sprintf(title, "Cursor Inaccuracy Detector (interval %i)", swap_interval);
+
+    glfwSetWindowTitle(window, title);
+}
+
+static void error_callback(int error, const char* description)
+{
+    fprintf(stderr, "Error: %s\n", description);
+}
+
+static void framebuffer_size_callback(GLFWwindow* window, int width, int height)
+{
+    window_width = width;
+    window_height = height;
+
+    glViewport(0, 0, window_width, window_height);
+
+    glMatrixMode(GL_PROJECTION);
+    glLoadIdentity();
+    gluOrtho2D(0.f, window_width, 0.f, window_height);
+}
+
+static void cursor_position_callback(GLFWwindow* window, double x, double y)
+{
+    cursor_x = x;
+    cursor_y = y;
+}
+
+static void key_callback(GLFWwindow* window, int key, int scancode, int action, int mods)
+{
+    if (key == GLFW_KEY_SPACE && action == GLFW_PRESS)
+        set_swap_interval(window, 1 - swap_interval);
+}
+
+int main(void)
+{
+    GLFWwindow* window;
+    int width, height;
+
+    glfwSetErrorCallback(error_callback);
+
+    if (!glfwInit())
+        exit(EXIT_FAILURE);
+
+    window = glfwCreateWindow(window_width, window_height, "", NULL, NULL);
+    if (!window)
+    {
+        glfwTerminate();
+        exit(EXIT_FAILURE);
+    }
+
+    glfwSetCursorPosCallback(window, cursor_position_callback);
+    glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
+    glfwSetKeyCallback(window, key_callback);
+
+    glfwMakeContextCurrent(window);
+
+    glfwGetFramebufferSize(window, &width, &height);
+    framebuffer_size_callback(window, width, height);
+
+    set_swap_interval(window, swap_interval);
+
+    while (!glfwWindowShouldClose(window))
+    {
+        glClear(GL_COLOR_BUFFER_BIT);
+
+        glBegin(GL_LINES);
+        glVertex2f(0.f, (GLfloat) (window_height - cursor_y));
+        glVertex2f((GLfloat) window_width, (GLfloat) (window_height - cursor_y));
+        glVertex2f((GLfloat) cursor_x, 0.f);
+        glVertex2f((GLfloat) cursor_x, (GLfloat) window_height);
+        glEnd();
+
+        glfwSwapBuffers(window);
+        glfwPollEvents();
+    }
+
+    glfwTerminate();
+    exit(EXIT_SUCCESS);
+}
+

source/glfw/tests/clipboard.c

@@ -0,0 +1,149 @@
+//========================================================================
+// Clipboard test program
+// Copyright (c) Camilla Berglund <elmindreda@elmindreda.org>
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+//    claim that you wrote the original software. If you use this software
+//    in a product, an acknowledgment in the product documentation would
+//    be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such, and must not
+//    be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source
+//    distribution.
+//
+//========================================================================
+//
+// This program is used to test the clipboard functionality.
+//
+//========================================================================
+
+#include <GLFW/glfw3.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "getopt.h"
+
+static void usage(void)
+{
+    printf("Usage: clipboard [-h]\n");
+}
+
+static void error_callback(int error, const char* description)
+{
+    fprintf(stderr, "Error: %s\n", description);
+}
+
+static void key_callback(GLFWwindow* window, int key, int scancode, int action, int mods)
+{
+    if (action != GLFW_PRESS)
+        return;
+
+    switch (key)
+    {
+        case GLFW_KEY_ESCAPE:
+            glfwSetWindowShouldClose(window, GL_TRUE);
+            break;
+
+        case GLFW_KEY_V:
+            if (mods == GLFW_MOD_CONTROL)
+            {
+                const char* string;
+
+                string = glfwGetClipboardString(window);
+                if (string)
+                    printf("Clipboard contains \"%s\"\n", string);
+                else
+                    printf("Clipboard does not contain a string\n");
+            }
+            break;
+
+        case GLFW_KEY_C:
+            if (mods == GLFW_MOD_CONTROL)
+            {
+                const char* string = "Hello GLFW World!";
+                glfwSetClipboardString(window, string);
+                printf("Setting clipboard to \"%s\"\n", string);
+            }
+            break;
+    }
+}
+
+static void framebuffer_size_callback(GLFWwindow* window, int width, int height)
+{
+    glViewport(0, 0, width, height);
+}
+
+int main(int argc, char** argv)
+{
+    int ch;
+    GLFWwindow* window;
+
+    while ((ch = getopt(argc, argv, "h")) != -1)
+    {
+        switch (ch)
+        {
+            case 'h':
+                usage();
+                exit(EXIT_SUCCESS);
+
+            default:
+                usage();
+                exit(EXIT_FAILURE);
+        }
+    }
+
+    glfwSetErrorCallback(error_callback);
+
+    if (!glfwInit())
+    {
+        fprintf(stderr, "Failed to initialize GLFW\n");
+        exit(EXIT_FAILURE);
+    }
+
+    window = glfwCreateWindow(200, 200, "Clipboard Test", NULL, NULL);
+    if (!window)
+    {
+        glfwTerminate();
+
+        fprintf(stderr, "Failed to open GLFW window\n");
+        exit(EXIT_FAILURE);
+    }
+
+    glfwMakeContextCurrent(window);
+    glfwSwapInterval(1);
+
+    glfwSetKeyCallback(window, key_callback);
+    glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
+
+    glMatrixMode(GL_PROJECTION);
+    glOrtho(-1.f, 1.f, -1.f, 1.f, -1.f, 1.f);
+    glMatrixMode(GL_MODELVIEW);
+
+    glClearColor(0.5f, 0.5f, 0.5f, 0);
+
+    while (!glfwWindowShouldClose(window))
+    {
+        glClear(GL_COLOR_BUFFER_BIT);
+
+        glColor3f(0.8f, 0.2f, 0.4f);
+        glRectf(-0.5f, -0.5f, 0.5f, 0.5f);
+
+        glfwSwapBuffers(window);
+        glfwWaitEvents();
+    }
+
+    glfwTerminate();
+    exit(EXIT_SUCCESS);
+}
+

source/glfw/tests/defaults.c

@@ -0,0 +1,131 @@
+//========================================================================
+// Default window/context test
+// Copyright (c) Camilla Berglund <elmindreda@elmindreda.org>
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+//    claim that you wrote the original software. If you use this software
+//    in a product, an acknowledgment in the product documentation would
+//    be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such, and must not
+//    be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source
+//    distribution.
+//
+//========================================================================
+//
+// This test creates a windowed mode window with all window hints set to
+// default values and then reports the actual attributes of the created
+// window and context
+//
+//========================================================================
+
+#include <GLFW/glfw3.h>
+#include <GL/glext.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+
+typedef struct
+{
+    int attrib;
+    const char* ext;
+    const char* name;
+} AttribGL;
+
+typedef struct
+{
+    int attrib;
+    const char* name;
+} AttribGLFW;
+
+static AttribGL gl_attribs[] =
+{
+    { GL_RED_BITS, NULL, "red bits" },
+    { GL_GREEN_BITS, NULL, "green bits" },
+    { GL_BLUE_BITS, NULL, "blue bits" },
+    { GL_ALPHA_BITS, NULL, "alpha bits" },
+    { GL_DEPTH_BITS, NULL, "depth bits" },
+    { GL_STENCIL_BITS, NULL, "stencil bits" },
+    { GL_STEREO, NULL, "stereo" },
+    { GL_SAMPLES_ARB, "GL_ARB_multisample", "FSAA samples" },
+    { 0, NULL, NULL }
+};
+
+static AttribGLFW glfw_attribs[] =
+{
+    { GLFW_CONTEXT_VERSION_MAJOR, "Context version major" },
+    { GLFW_CONTEXT_VERSION_MINOR, "Context version minor" },
+    { GLFW_OPENGL_FORWARD_COMPAT, "OpenGL forward compatible" },
+    { GLFW_OPENGL_DEBUG_CONTEXT, "OpenGL debug context" },
+    { GLFW_OPENGL_PROFILE, "OpenGL profile" },
+    { 0, NULL }
+};
+
+static void error_callback(int error, const char* description)
+{
+    fprintf(stderr, "Error: %s\n", description);
+}
+
+int main(void)
+{
+    int i, width, height;
+    GLFWwindow* window;
+
+    glfwSetErrorCallback(error_callback);
+
+    if (!glfwInit())
+        exit(EXIT_FAILURE);
+
+    glfwWindowHint(GLFW_VISIBLE, GL_FALSE);
+
+    window = glfwCreateWindow(640, 480, "Defaults", NULL, NULL);
+    if (!window)
+    {
+        glfwTerminate();
+        exit(EXIT_FAILURE);
+    }
+
+    glfwMakeContextCurrent(window);
+    glfwGetFramebufferSize(window, &width, &height);
+
+    printf("framebuffer size: %ix%i\n", width, height);
+
+    for (i = 0;  glfw_attribs[i].name;   i++)
+    {
+        printf("%s: %i\n",
+               glfw_attribs[i].name,
+               glfwGetWindowAttrib(window, glfw_attribs[i].attrib));
+    }
+
+    for (i = 0;  gl_attribs[i].name;   i++)
+    {
+        GLint value = 0;
+
+        if (gl_attribs[i].ext)
+        {
+            if (!glfwExtensionSupported(gl_attribs[i].ext))
+                continue;
+        }
+
+        glGetIntegerv(gl_attribs[i].attrib, &value);
+
+        printf("%s: %i\n", gl_attribs[i].name, value);
+    }
+
+    glfwDestroyWindow(window);
+    window = NULL;
+
+    glfwTerminate();
+    exit(EXIT_SUCCESS);
+}
+

source/glfw/tests/events.c

@@ -0,0 +1,467 @@
+//========================================================================
+// Event linter (event spewer)
+// Copyright (c) Camilla Berglund <elmindreda@elmindreda.org>
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+//    claim that you wrote the original software. If you use this software
+//    in a product, an acknowledgment in the product documentation would
+//    be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such, and must not
+//    be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source
+//    distribution.
+//
+//========================================================================
+//
+// This test hooks every available callback and outputs their arguments
+//
+// Log messages go to stdout, error messages to stderr
+//
+// Every event also gets a (sequential) number to aid discussion of logs
+//
+//========================================================================
+
+#include <GLFW/glfw3.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <string.h>
+#include <locale.h>
+
+// These must match the input mode defaults
+static GLboolean closeable = GL_TRUE;
+
+// Event index
+static unsigned int counter = 0;
+
+static const char* get_key_name(int key)
+{
+    switch (key)
+    {
+        // Printable keys
+        case GLFW_KEY_A:            return "A";
+        case GLFW_KEY_B:            return "B";
+        case GLFW_KEY_C:            return "C";
+        case GLFW_KEY_D:            return "D";
+        case GLFW_KEY_E:            return "E";
+        case GLFW_KEY_F:            return "F";
+        case GLFW_KEY_G:            return "G";
+        case GLFW_KEY_H:            return "H";
+        case GLFW_KEY_I:            return "I";
+        case GLFW_KEY_J:            return "J";
+        case GLFW_KEY_K:            return "K";
+        case GLFW_KEY_L:            return "L";
+        case GLFW_KEY_M:            return "M";
+        case GLFW_KEY_N:            return "N";
+        case GLFW_KEY_O:            return "O";
+        case GLFW_KEY_P:            return "P";
+        case GLFW_KEY_Q:            return "Q";
+        case GLFW_KEY_R:            return "R";
+        case GLFW_KEY_S:            return "S";
+        case GLFW_KEY_T:            return "T";
+        case GLFW_KEY_U:            return "U";
+        case GLFW_KEY_V:            return "V";
+        case GLFW_KEY_W:            return "W";
+        case GLFW_KEY_X:            return "X";
+        case GLFW_KEY_Y:            return "Y";
+        case GLFW_KEY_Z:            return "Z";
+        case GLFW_KEY_1:            return "1";
+        case GLFW_KEY_2:            return "2";
+        case GLFW_KEY_3:            return "3";
+        case GLFW_KEY_4:            return "4";
+        case GLFW_KEY_5:            return "5";
+        case GLFW_KEY_6:            return "6";
+        case GLFW_KEY_7:            return "7";
+        case GLFW_KEY_8:            return "8";
+        case GLFW_KEY_9:            return "9";
+        case GLFW_KEY_0:            return "0";
+        case GLFW_KEY_SPACE:        return "SPACE";
+        case GLFW_KEY_MINUS:        return "MINUS";
+        case GLFW_KEY_EQUAL:        return "EQUAL";
+        case GLFW_KEY_LEFT_BRACKET: return "LEFT BRACKET";
+        case GLFW_KEY_RIGHT_BRACKET: return "RIGHT BRACKET";
+        case GLFW_KEY_BACKSLASH:    return "BACKSLASH";
+        case GLFW_KEY_SEMICOLON:    return "SEMICOLON";
+        case GLFW_KEY_APOSTROPHE:   return "APOSTROPHE";
+        case GLFW_KEY_GRAVE_ACCENT: return "GRAVE ACCENT";
+        case GLFW_KEY_COMMA:        return "COMMA";
+        case GLFW_KEY_PERIOD:       return "PERIOD";
+        case GLFW_KEY_SLASH:        return "SLASH";
+        case GLFW_KEY_WORLD_1:      return "WORLD 1";
+        case GLFW_KEY_WORLD_2:      return "WORLD 2";
+
+        // Function keys
+        case GLFW_KEY_ESCAPE:       return "ESCAPE";
+        case GLFW_KEY_F1:           return "F1";
+        case GLFW_KEY_F2:           return "F2";
+        case GLFW_KEY_F3:           return "F3";
+        case GLFW_KEY_F4:           return "F4";
+        case GLFW_KEY_F5:           return "F5";
+        case GLFW_KEY_F6:           return "F6";
+        case GLFW_KEY_F7:           return "F7";
+        case GLFW_KEY_F8:           return "F8";
+        case GLFW_KEY_F9:           return "F9";
+        case GLFW_KEY_F10:          return "F10";
+        case GLFW_KEY_F11:          return "F11";
+        case GLFW_KEY_F12:          return "F12";
+        case GLFW_KEY_F13:          return "F13";
+        case GLFW_KEY_F14:          return "F14";
+        case GLFW_KEY_F15:          return "F15";
+        case GLFW_KEY_F16:          return "F16";
+        case GLFW_KEY_F17:          return "F17";
+        case GLFW_KEY_F18:          return "F18";
+        case GLFW_KEY_F19:          return "F19";
+        case GLFW_KEY_F20:          return "F20";
+        case GLFW_KEY_F21:          return "F21";
+        case GLFW_KEY_F22:          return "F22";
+        case GLFW_KEY_F23:          return "F23";
+        case GLFW_KEY_F24:          return "F24";
+        case GLFW_KEY_F25:          return "F25";
+        case GLFW_KEY_UP:           return "UP";
+        case GLFW_KEY_DOWN:         return "DOWN";
+        case GLFW_KEY_LEFT:         return "LEFT";
+        case GLFW_KEY_RIGHT:        return "RIGHT";
+        case GLFW_KEY_LEFT_SHIFT:   return "LEFT SHIFT";
+        case GLFW_KEY_RIGHT_SHIFT:  return "RIGHT SHIFT";
+        case GLFW_KEY_LEFT_CONTROL: return "LEFT CONTROL";
+        case GLFW_KEY_RIGHT_CONTROL: return "RIGHT CONTROL";
+        case GLFW_KEY_LEFT_ALT:     return "LEFT ALT";
+        case GLFW_KEY_RIGHT_ALT:    return "RIGHT ALT";
+        case GLFW_KEY_TAB:          return "TAB";
+        case GLFW_KEY_ENTER:        return "ENTER";
+        case GLFW_KEY_BACKSPACE:    return "BACKSPACE";
+        case GLFW_KEY_INSERT:       return "INSERT";
+        case GLFW_KEY_DELETE:       return "DELETE";
+        case GLFW_KEY_PAGE_UP:      return "PAGE UP";
+        case GLFW_KEY_PAGE_DOWN:    return "PAGE DOWN";
+        case GLFW_KEY_HOME:         return "HOME";
+        case GLFW_KEY_END:          return "END";
+        case GLFW_KEY_KP_0:         return "KEYPAD 0";
+        case GLFW_KEY_KP_1:         return "KEYPAD 1";
+        case GLFW_KEY_KP_2:         return "KEYPAD 2";
+        case GLFW_KEY_KP_3:         return "KEYPAD 3";
+        case GLFW_KEY_KP_4:         return "KEYPAD 4";
+        case GLFW_KEY_KP_5:         return "KEYPAD 5";
+        case GLFW_KEY_KP_6:         return "KEYPAD 6";
+        case GLFW_KEY_KP_7:         return "KEYPAD 7";
+        case GLFW_KEY_KP_8:         return "KEYPAD 8";
+        case GLFW_KEY_KP_9:         return "KEYPAD 9";
+        case GLFW_KEY_KP_DIVIDE:    return "KEYPAD DIVIDE";
+        case GLFW_KEY_KP_MULTIPLY:  return "KEYPAD MULTPLY";
+        case GLFW_KEY_KP_SUBTRACT:  return "KEYPAD SUBTRACT";
+        case GLFW_KEY_KP_ADD:       return "KEYPAD ADD";
+        case GLFW_KEY_KP_DECIMAL:   return "KEYPAD DECIMAL";
+        case GLFW_KEY_KP_EQUAL:     return "KEYPAD EQUAL";
+        case GLFW_KEY_KP_ENTER:     return "KEYPAD ENTER";
+        case GLFW_KEY_PRINT_SCREEN: return "PRINT SCREEN";
+        case GLFW_KEY_NUM_LOCK:     return "NUM LOCK";
+        case GLFW_KEY_CAPS_LOCK:    return "CAPS LOCK";
+        case GLFW_KEY_SCROLL_LOCK:  return "SCROLL LOCK";
+        case GLFW_KEY_PAUSE:        return "PAUSE";
+        case GLFW_KEY_LEFT_SUPER:   return "LEFT SUPER";
+        case GLFW_KEY_RIGHT_SUPER:  return "RIGHT SUPER";
+        case GLFW_KEY_MENU:         return "MENU";
+        case GLFW_KEY_UNKNOWN:      return "UNKNOWN";
+
+        default:                    return NULL;
+    }
+}
+
+static const char* get_action_name(int action)
+{
+    switch (action)
+    {
+        case GLFW_PRESS:
+            return "pressed";
+        case GLFW_RELEASE:
+            return "released";
+        case GLFW_REPEAT:
+            return "repeated";
+    }
+
+    return "caused unknown action";
+}
+
+static const char* get_button_name(int button)
+{
+    switch (button)
+    {
+        case GLFW_MOUSE_BUTTON_LEFT:
+            return "left";
+        case GLFW_MOUSE_BUTTON_RIGHT:
+            return "right";
+        case GLFW_MOUSE_BUTTON_MIDDLE:
+            return "middle";
+    }
+
+    return NULL;
+}
+
+static const char* get_mods_name(int mods)
+{
+    static char name[512];
+
+    name[0] = '\0';
+
+    if (mods & GLFW_MOD_SHIFT)
+        strcat(name, " shift");
+    if (mods & GLFW_MOD_CONTROL)
+        strcat(name, " control");
+    if (mods & GLFW_MOD_ALT)
+        strcat(name, " alt");
+    if (mods & GLFW_MOD_SUPER)
+        strcat(name, " super");
+
+    return name;
+}
+
+static const char* get_character_string(int character)
+{
+    // This assumes UTF-8, which is stupid
+    static char result[6 + 1];
+
+    int length = wctomb(result, character);
+    if (length == -1)
+        length = 0;
+
+    result[length] = '\0';
+    return result;
+}
+
+static void error_callback(int error, const char* description)
+{
+    fprintf(stderr, "Error: %s\n", description);
+}
+
+static void window_pos_callback(GLFWwindow* window, int x, int y)
+{
+    printf("%08x at %0.3f: Window position: %i %i\n",
+           counter++,
+           glfwGetTime(),
+           x,
+           y);
+}
+
+static void window_size_callback(GLFWwindow* window, int width, int height)
+{
+    printf("%08x at %0.3f: Window size: %i %i\n",
+           counter++,
+           glfwGetTime(),
+           width,
+           height);
+}
+
+static void framebuffer_size_callback(GLFWwindow* window, int width, int height)
+{
+    printf("%08x at %0.3f: Framebuffer size: %i %i\n",
+           counter++,
+           glfwGetTime(),
+           width,
+           height);
+
+    glViewport(0, 0, width, height);
+}
+
+static void window_close_callback(GLFWwindow* window)
+{
+    printf("%08x at %0.3f: Window close\n", counter++, glfwGetTime());
+
+    glfwSetWindowShouldClose(window, closeable);
+}
+
+static void window_refresh_callback(GLFWwindow* window)
+{
+    printf("%08x at %0.3f: Window refresh\n", counter++, glfwGetTime());
+
+    if (glfwGetCurrentContext())
+    {
+        glClear(GL_COLOR_BUFFER_BIT);
+        glfwSwapBuffers(window);
+    }
+}
+
+static void window_focus_callback(GLFWwindow* window, int focused)
+{
+    printf("%08x at %0.3f: Window %s\n",
+           counter++,
+           glfwGetTime(),
+           focused ? "focused" : "defocused");
+}
+
+static void window_iconify_callback(GLFWwindow* window, int iconified)
+{
+    printf("%08x at %0.3f: Window was %s\n",
+           counter++,
+           glfwGetTime(),
+           iconified ? "iconified" : "restored");
+}
+
+static void mouse_button_callback(GLFWwindow* window, int button, int action, int mods)
+{
+    const char* name = get_button_name(button);
+
+    printf("%08x at %0.3f: Mouse button %i", counter++, glfwGetTime(), button);
+
+    if (name)
+        printf(" (%s)", name);
+
+    if (mods)
+        printf(" (with%s)", get_mods_name(mods));
+
+    printf(" was %s\n", get_action_name(action));
+}
+
+static void cursor_position_callback(GLFWwindow* window, double x, double y)
+{
+    printf("%08x at %0.3f: Cursor position: %f %f\n", counter++, glfwGetTime(), x, y);
+}
+
+static void cursor_enter_callback(GLFWwindow* window, int entered)
+{
+    printf("%08x at %0.3f: Cursor %s window\n",
+           counter++,
+           glfwGetTime(),
+           entered ? "entered" : "left");
+}
+
+static void scroll_callback(GLFWwindow* window, double x, double y)
+{
+    printf("%08x at %0.3f: Scroll: %0.3f %0.3f\n", counter++, glfwGetTime(), x, y);
+}
+
+static void key_callback(GLFWwindow* window, int key, int scancode, int action, int mods)
+{
+    const char* name = get_key_name(key);
+
+    printf("%08x at %0.3f: Key 0x%04x Scancode 0x%04x",
+           counter++, glfwGetTime(), key, scancode);
+
+    if (name)
+        printf(" (%s)", name);
+
+    if (mods)
+        printf(" (with%s)", get_mods_name(mods));
+
+    printf(" was %s\n", get_action_name(action));
+
+    if (action != GLFW_PRESS)
+        return;
+
+    switch (key)
+    {
+        case GLFW_KEY_C:
+        {
+            closeable = !closeable;
+
+            printf("(( closing %s ))\n", closeable ? "enabled" : "disabled");
+            break;
+        }
+    }
+}
+
+static void char_callback(GLFWwindow* window, unsigned int character)
+{
+    printf("%08x at %0.3f: Character 0x%08x (%s) input\n",
+           counter++,
+           glfwGetTime(),
+           character,
+           get_character_string(character));
+}
+
+void monitor_callback(GLFWmonitor* monitor, int event)
+{
+    if (event == GLFW_CONNECTED)
+    {
+        int x, y, widthMM, heightMM;
+        const GLFWvidmode* mode = glfwGetVideoMode(monitor);
+
+        glfwGetMonitorPos(monitor, &x, &y);
+        glfwGetMonitorPhysicalSize(monitor, &widthMM, &heightMM);
+
+        printf("%08x at %0.3f: Monitor %s (%ix%i at %ix%i, %ix%i mm) was connected\n",
+               counter++,
+               glfwGetTime(),
+               glfwGetMonitorName(monitor),
+               mode->width, mode->height,
+               x, y,
+               widthMM, heightMM);
+    }
+    else
+    {
+        printf("%08x at %0.3f: Monitor %s was disconnected\n",
+               counter++,
+               glfwGetTime(),
+               glfwGetMonitorName(monitor));
+    }
+}
+
+int main(void)
+{
+    GLFWwindow* window;
+    int width, height;
+
+    setlocale(LC_ALL, "");
+
+    glfwSetErrorCallback(error_callback);
+
+    if (!glfwInit())
+        exit(EXIT_FAILURE);
+
+    printf("Library initialized\n");
+
+    window = glfwCreateWindow(640, 480, "Event Linter", NULL, NULL);
+    if (!window)
+    {
+        glfwTerminate();
+        exit(EXIT_FAILURE);
+    }
+
+    printf("Window opened\n");
+
+    glfwSetMonitorCallback(monitor_callback);
+
+    glfwSetWindowPosCallback(window, window_pos_callback);
+    glfwSetWindowSizeCallback(window, window_size_callback);
+    glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
+    glfwSetWindowCloseCallback(window, window_close_callback);
+    glfwSetWindowRefreshCallback(window, window_refresh_callback);
+    glfwSetWindowFocusCallback(window, window_focus_callback);
+    glfwSetWindowIconifyCallback(window, window_iconify_callback);
+    glfwSetMouseButtonCallback(window, mouse_button_callback);
+    glfwSetCursorPosCallback(window, cursor_position_callback);
+    glfwSetCursorEnterCallback(window, cursor_enter_callback);
+    glfwSetScrollCallback(window, scroll_callback);
+    glfwSetKeyCallback(window, key_callback);
+    glfwSetCharCallback(window, char_callback);
+
+    glfwMakeContextCurrent(window);
+    glfwSwapInterval(1);
+
+    glfwGetWindowSize(window, &width, &height);
+    printf("Window size should be %ix%i\n", width, height);
+
+    printf("Main loop starting\n");
+
+    while (!glfwWindowShouldClose(window))
+    {
+        glfwWaitEvents();
+
+        // Workaround for an issue with msvcrt and mintty
+        fflush(stdout);
+    }
+
+    glfwTerminate();
+    exit(EXIT_SUCCESS);
+}
+

source/glfw/tests/fsaa.c

@@ -0,0 +1,158 @@
+//========================================================================
+// Fullscreen anti-aliasing test
+// Copyright (c) Camilla Berglund <elmindreda@elmindreda.org>
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+//    claim that you wrote the original software. If you use this software
+//    in a product, an acknowledgment in the product documentation would
+//    be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such, and must not
+//    be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source
+//    distribution.
+//
+//========================================================================
+//
+// This test renders two high contrast, slowly rotating quads, one aliased
+// and one (hopefully) anti-aliased, thus allowing for visual verification
+// of whether FSAA is indeed enabled
+//
+//========================================================================
+
+#define GLFW_INCLUDE_GLU
+#include <GLFW/glfw3.h>
+#include <GL/glext.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "getopt.h"
+
+static void error_callback(int error, const char* description)
+{
+    fprintf(stderr, "Error: %s\n", description);
+}
+
+static void framebuffer_size_callback(GLFWwindow* window, int width, int height)
+{
+    glViewport(0, 0, width, height);
+}
+
+static void key_callback(GLFWwindow* window, int key, int scancode, int action, int mods)
+{
+    if (action != GLFW_PRESS)
+        return;
+
+    switch (key)
+    {
+        case GLFW_KEY_SPACE:
+            glfwSetTime(0.0);
+            break;
+    }
+}
+
+static void usage(void)
+{
+    printf("Usage: fsaa [-h] [-s SAMPLES]\n");
+}
+
+int main(int argc, char** argv)
+{
+    int ch, samples = 4;
+    GLFWwindow* window;
+
+    while ((ch = getopt(argc, argv, "hs:")) != -1)
+    {
+        switch (ch)
+        {
+            case 'h':
+                usage();
+                exit(EXIT_SUCCESS);
+            case 's':
+                samples = atoi(optarg);
+                break;
+            default:
+                usage();
+                exit(EXIT_FAILURE);
+        }
+    }
+
+    glfwSetErrorCallback(error_callback);
+
+    if (!glfwInit())
+        exit(EXIT_FAILURE);
+
+    if (samples)
+        printf("Requesting FSAA with %i samples\n", samples);
+    else
+        printf("Requesting that FSAA not be available\n");
+
+    glfwWindowHint(GLFW_SAMPLES, samples);
+
+    window = glfwCreateWindow(800, 400, "Aliasing Detector", NULL, NULL);
+    if (!window)
+    {
+        glfwTerminate();
+        exit(EXIT_FAILURE);
+    }
+
+    glfwSetKeyCallback(window, key_callback);
+    glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
+
+    glfwMakeContextCurrent(window);
+    glfwSwapInterval(1);
+
+    if (!glfwExtensionSupported("GL_ARB_multisample"))
+    {
+        glfwTerminate();
+        exit(EXIT_FAILURE);
+    }
+
+    glGetIntegerv(GL_SAMPLES_ARB, &samples);
+    if (samples)
+        printf("Context reports FSAA is available with %i samples\n", samples);
+    else
+        printf("Context reports FSAA is unavailable\n");
+
+    glMatrixMode(GL_PROJECTION);
+    gluOrtho2D(0.f, 1.f, 0.f, 0.5f);
+    glMatrixMode(GL_MODELVIEW);
+
+    while (!glfwWindowShouldClose(window))
+    {
+        GLfloat time = (GLfloat) glfwGetTime();
+
+        glClear(GL_COLOR_BUFFER_BIT);
+
+        glLoadIdentity();
+        glTranslatef(0.25f, 0.25f, 0.f);
+        glRotatef(time, 0.f, 0.f, 1.f);
+
+        glDisable(GL_MULTISAMPLE_ARB);
+        glRectf(-0.15f, -0.15f, 0.15f, 0.15f);
+
+        glLoadIdentity();
+        glTranslatef(0.75f, 0.25f, 0.f);
+        glRotatef(time, 0.f, 0.f, 1.f);
+
+        glEnable(GL_MULTISAMPLE_ARB);
+        glRectf(-0.15f, -0.15f, 0.15f, 0.15f);
+
+        glfwSwapBuffers(window);
+        glfwPollEvents();
+    }
+
+    glfwTerminate();
+    exit(EXIT_SUCCESS);
+}
+

source/glfw/tests/gamma.c

@@ -0,0 +1,175 @@
+//========================================================================
+// Gamma correction test program
+// Copyright (c) Camilla Berglund <elmindreda@elmindreda.org>
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+//    claim that you wrote the original software. If you use this software
+//    in a product, an acknowledgment in the product documentation would
+//    be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such, and must not
+//    be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source
+//    distribution.
+//
+//========================================================================
+//
+// This program is used to test the gamma correction functionality for
+// both fullscreen and windowed mode windows
+//
+//========================================================================
+
+#include <GLFW/glfw3.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "getopt.h"
+
+#define STEP_SIZE 0.1f
+
+static GLfloat gamma_value = 1.0f;
+
+static void usage(void)
+{
+    printf("Usage: gamma [-h] [-f]\n");
+}
+
+static void set_gamma(GLFWwindow* window, float value)
+{
+    GLFWmonitor* monitor = glfwGetWindowMonitor(window);
+    if (!monitor)
+        monitor = glfwGetPrimaryMonitor();
+
+    gamma_value = value;
+    printf("Gamma: %f\n", gamma_value);
+    glfwSetGamma(monitor, gamma_value);
+}
+
+static void error_callback(int error, const char* description)
+{
+    fprintf(stderr, "Error: %s\n", description);
+}
+
+static void key_callback(GLFWwindow* window, int key, int scancode, int action, int mods)
+{
+    if (action != GLFW_PRESS)
+        return;
+
+    switch (key)
+    {
+        case GLFW_KEY_ESCAPE:
+        {
+            glfwSetWindowShouldClose(window, GL_TRUE);
+            break;
+        }
+
+        case GLFW_KEY_KP_ADD:
+        case GLFW_KEY_Q:
+        {
+            set_gamma(window, gamma_value + STEP_SIZE);
+            break;
+        }
+
+        case GLFW_KEY_KP_SUBTRACT:
+        case GLFW_KEY_W:
+        {
+            if (gamma_value - STEP_SIZE > 0.f)
+                set_gamma(window, gamma_value - STEP_SIZE);
+
+            break;
+        }
+    }
+}
+
+static void framebuffer_size_callback(GLFWwindow* window, int width, int height)
+{
+    glViewport(0, 0, width, height);
+}
+
+int main(int argc, char** argv)
+{
+    int width, height, ch;
+    GLFWmonitor* monitor = NULL;
+    GLFWwindow* window;
+
+    glfwSetErrorCallback(error_callback);
+
+    if (!glfwInit())
+        exit(EXIT_FAILURE);
+
+    while ((ch = getopt(argc, argv, "fh")) != -1)
+    {
+        switch (ch)
+        {
+            case 'h':
+                usage();
+                exit(EXIT_SUCCESS);
+
+            case 'f':
+                monitor = glfwGetPrimaryMonitor();
+                break;
+
+            default:
+                usage();
+                exit(EXIT_FAILURE);
+        }
+    }
+
+    if (monitor)
+    {
+        const GLFWvidmode* mode = glfwGetVideoMode(monitor);
+        width = mode->width;
+        height = mode->height;
+    }
+    else
+    {
+        width = 200;
+        height = 200;
+    }
+
+    window = glfwCreateWindow(width, height, "Gamma Test", monitor, NULL);
+    if (!window)
+    {
+        glfwTerminate();
+        exit(EXIT_FAILURE);
+    }
+
+    set_gamma(window, 1.f);
+
+    glfwMakeContextCurrent(window);
+    glfwSwapInterval(1);
+
+    glfwSetKeyCallback(window, key_callback);
+    glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
+
+    glMatrixMode(GL_PROJECTION);
+    glOrtho(-1.f, 1.f, -1.f, 1.f, -1.f, 1.f);
+    glMatrixMode(GL_MODELVIEW);
+
+    glClearColor(0.5f, 0.5f, 0.5f, 0);
+
+    while (!glfwWindowShouldClose(window))
+    {
+        glClear(GL_COLOR_BUFFER_BIT);
+
+        glColor3f(0.8f, 0.2f, 0.4f);
+        glRectf(-0.5f, -0.5f, 0.5f, 0.5f);
+
+        glfwSwapBuffers(window);
+        glfwWaitEvents();
+    }
+
+    glfwTerminate();
+    exit(EXIT_SUCCESS);
+}
+

source/glfw/tests/glfwinfo.c

@@ -0,0 +1,392 @@
+//========================================================================
+// Version information dumper
+// Copyright (c) Camilla Berglund <elmindreda@elmindreda.org>
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+//    claim that you wrote the original software. If you use this software
+//    in a product, an acknowledgment in the product documentation would
+//    be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such, and must not
+//    be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source
+//    distribution.
+//
+//========================================================================
+//
+// This test is a pale imitation of glxinfo(1), except not really
+//
+// It dumps GLFW and OpenGL version information
+//
+//========================================================================
+
+#include <GLFW/glfw3.h>
+#include <GL/glext.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "getopt.h"
+
+#ifdef _MSC_VER
+#define strcasecmp(x, y) _stricmp(x, y)
+#endif
+
+#define API_OPENGL          "gl"
+#define API_OPENGL_ES       "es"
+
+#define PROFILE_NAME_CORE   "core"
+#define PROFILE_NAME_COMPAT "compat"
+
+#define STRATEGY_NAME_NONE "none"
+#define STRATEGY_NAME_LOSE "lose"
+
+static void usage(void)
+{
+    printf("Usage: glfwinfo [-h] [-a API] [-m MAJOR] [-n MINOR] [-d] [-l] [-f] [-p PROFILE] [-r STRATEGY]\n");
+    printf("available APIs: " API_OPENGL " " API_OPENGL_ES "\n");
+    printf("available profiles: " PROFILE_NAME_CORE " " PROFILE_NAME_COMPAT "\n");
+    printf("available strategies: " STRATEGY_NAME_NONE " " STRATEGY_NAME_LOSE "\n");
+}
+
+static void error_callback(int error, const char* description)
+{
+    fprintf(stderr, "Error: %s\n", description);
+}
+
+static const char* get_client_api_name(int api)
+{
+    if (api == GLFW_OPENGL_API)
+        return "OpenGL";
+    else if (api == GLFW_OPENGL_ES_API)
+        return "OpenGL ES";
+
+    return "Unknown API";
+}
+
+static const char* get_profile_name_gl(GLint mask)
+{
+    if (mask & GL_CONTEXT_COMPATIBILITY_PROFILE_BIT)
+        return PROFILE_NAME_COMPAT;
+    if (mask & GL_CONTEXT_CORE_PROFILE_BIT)
+        return PROFILE_NAME_CORE;
+
+    return "unknown";
+}
+
+static const char* get_profile_name_glfw(int profile)
+{
+    if (profile == GLFW_OPENGL_COMPAT_PROFILE)
+        return PROFILE_NAME_COMPAT;
+    if (profile == GLFW_OPENGL_CORE_PROFILE)
+        return PROFILE_NAME_CORE;
+
+    return "unknown";
+}
+
+static const char* get_strategy_name_gl(GLint strategy)
+{
+    if (strategy == GL_LOSE_CONTEXT_ON_RESET_ARB)
+        return STRATEGY_NAME_LOSE;
+    if (strategy == GL_NO_RESET_NOTIFICATION_ARB)
+        return STRATEGY_NAME_NONE;
+
+    return "unknown";
+}
+
+static const char* get_strategy_name_glfw(int strategy)
+{
+    if (strategy == GLFW_LOSE_CONTEXT_ON_RESET)
+        return STRATEGY_NAME_LOSE;
+    if (strategy == GLFW_NO_RESET_NOTIFICATION)
+        return STRATEGY_NAME_NONE;
+
+    return "unknown";
+}
+
+static void list_extensions(int api, int major, int minor)
+{
+    int i;
+    GLint count;
+    const GLubyte* extensions;
+
+    printf("%s context supported extensions:\n", get_client_api_name(api));
+
+    if (api == GLFW_OPENGL_API && major > 2)
+    {
+        PFNGLGETSTRINGIPROC glGetStringi = (PFNGLGETSTRINGIPROC) glfwGetProcAddress("glGetStringi");
+        if (!glGetStringi)
+        {
+            glfwTerminate();
+            exit(EXIT_FAILURE);
+        }
+
+        glGetIntegerv(GL_NUM_EXTENSIONS, &count);
+
+        for (i = 0;  i < count;  i++)
+            puts((const char*) glGetStringi(GL_EXTENSIONS, i));
+    }
+    else
+    {
+        extensions = glGetString(GL_EXTENSIONS);
+        while (*extensions != '\0')
+        {
+            if (*extensions == ' ')
+                putchar('\n');
+            else
+                putchar(*extensions);
+
+            extensions++;
+        }
+    }
+
+    putchar('\n');
+}
+
+static GLboolean valid_version(void)
+{
+    int major, minor, revision;
+
+    glfwGetVersion(&major, &minor, &revision);
+
+    printf("GLFW header version: %u.%u.%u\n",
+           GLFW_VERSION_MAJOR,
+           GLFW_VERSION_MINOR,
+           GLFW_VERSION_REVISION);
+
+    printf("GLFW library version: %u.%u.%u\n", major, minor, revision);
+
+    if (major != GLFW_VERSION_MAJOR)
+    {
+        printf("*** ERROR: GLFW major version mismatch! ***\n");
+        return GL_FALSE;
+    }
+
+    if (minor != GLFW_VERSION_MINOR || revision != GLFW_VERSION_REVISION)
+        printf("*** WARNING: GLFW version mismatch! ***\n");
+
+    printf("GLFW library version string: \"%s\"\n", glfwGetVersionString());
+    return GL_TRUE;
+}
+
+int main(int argc, char** argv)
+{
+    int ch, api = 0, profile = 0, strategy = 0, major = 1, minor = 0, revision;
+    GLboolean debug = GL_FALSE, forward = GL_FALSE, list = GL_FALSE;
+    GLint flags, mask;
+    GLFWwindow* window;
+
+    if (!valid_version())
+        exit(EXIT_FAILURE);
+
+    while ((ch = getopt(argc, argv, "a:dfhlm:n:p:r:")) != -1)
+    {
+        switch (ch)
+        {
+            case 'a':
+                if (strcasecmp(optarg, API_OPENGL) == 0)
+                    api = GLFW_OPENGL_API;
+                else if (strcasecmp(optarg, API_OPENGL_ES) == 0)
+                    api = GLFW_OPENGL_ES_API;
+                else
+                {
+                    usage();
+                    exit(EXIT_FAILURE);
+                }
+            case 'd':
+                debug = GL_TRUE;
+                break;
+            case 'f':
+                forward = GL_TRUE;
+                break;
+            case 'h':
+                usage();
+                exit(EXIT_SUCCESS);
+            case 'l':
+                list = GL_TRUE;
+                break;
+            case 'm':
+                major = atoi(optarg);
+                break;
+            case 'n':
+                minor = atoi(optarg);
+                break;
+            case 'p':
+                if (strcasecmp(optarg, PROFILE_NAME_CORE) == 0)
+                    profile = GLFW_OPENGL_CORE_PROFILE;
+                else if (strcasecmp(optarg, PROFILE_NAME_COMPAT) == 0)
+                    profile = GLFW_OPENGL_COMPAT_PROFILE;
+                else
+                {
+                    usage();
+                    exit(EXIT_FAILURE);
+                }
+                break;
+            case 'r':
+                if (strcasecmp(optarg, STRATEGY_NAME_NONE) == 0)
+                    strategy = GLFW_NO_RESET_NOTIFICATION;
+                else if (strcasecmp(optarg, STRATEGY_NAME_LOSE) == 0)
+                    strategy = GLFW_LOSE_CONTEXT_ON_RESET;
+                else
+                {
+                    usage();
+                    exit(EXIT_FAILURE);
+                }
+                break;
+            default:
+                usage();
+                exit(EXIT_FAILURE);
+        }
+    }
+
+    argc -= optind;
+    argv += optind;
+
+    // Initialize GLFW and create window
+
+    glfwSetErrorCallback(error_callback);
+
+    if (!glfwInit())
+        exit(EXIT_FAILURE);
+
+    if (major != 1 || minor != 0)
+    {
+        glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, major);
+        glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, minor);
+    }
+
+    if (api != 0)
+        glfwWindowHint(GLFW_CLIENT_API, api);
+
+    if (debug)
+        glfwWindowHint(GLFW_OPENGL_DEBUG_CONTEXT, GL_TRUE);
+
+    if (forward)
+        glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
+
+    if (profile != 0)
+        glfwWindowHint(GLFW_OPENGL_PROFILE, profile);
+
+    if (strategy)
+        glfwWindowHint(GLFW_CONTEXT_ROBUSTNESS, strategy);
+
+    glfwWindowHint(GLFW_VISIBLE, GL_FALSE);
+
+    window = glfwCreateWindow(200, 200, "Version", NULL, NULL);
+    if (!window)
+    {
+        glfwTerminate();
+        exit(EXIT_FAILURE);
+    }
+
+    glfwMakeContextCurrent(window);
+
+    // Report client API version
+
+    api = glfwGetWindowAttrib(window, GLFW_CLIENT_API);
+    major = glfwGetWindowAttrib(window, GLFW_CONTEXT_VERSION_MAJOR);
+    minor = glfwGetWindowAttrib(window, GLFW_CONTEXT_VERSION_MINOR);
+    revision = glfwGetWindowAttrib(window, GLFW_CONTEXT_REVISION);
+
+    printf("%s context version string: \"%s\"\n",
+           get_client_api_name(api),
+           glGetString(GL_VERSION));
+
+    printf("%s context version parsed by GLFW: %u.%u.%u\n",
+           get_client_api_name(api),
+           major, minor, revision);
+
+    // Report client API context properties
+
+    if (api == GLFW_OPENGL_API)
+    {
+        if (major >= 3)
+        {
+            glGetIntegerv(GL_CONTEXT_FLAGS, &flags);
+            printf("%s context flags (0x%08x):", get_client_api_name(api), flags);
+
+            if (flags & GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT)
+                printf(" forward-compatible");
+            if (flags & GL_CONTEXT_FLAG_DEBUG_BIT)
+                printf(" debug");
+            if (flags & GL_CONTEXT_FLAG_ROBUST_ACCESS_BIT_ARB)
+                printf(" robustness");
+            putchar('\n');
+
+            printf("%s context flags parsed by GLFW:", get_client_api_name(api));
+
+            if (glfwGetWindowAttrib(window, GLFW_OPENGL_FORWARD_COMPAT))
+                printf(" forward-compatible");
+            if (glfwGetWindowAttrib(window, GLFW_OPENGL_DEBUG_CONTEXT))
+                printf(" debug");
+            if (glfwGetWindowAttrib(window, GLFW_CONTEXT_ROBUSTNESS) != GLFW_NO_ROBUSTNESS)
+                printf(" robustness");
+            putchar('\n');
+        }
+
+        if (major > 3 || (major == 3 && minor >= 2))
+        {
+            int profile = glfwGetWindowAttrib(window, GLFW_OPENGL_PROFILE);
+
+            glGetIntegerv(GL_CONTEXT_PROFILE_MASK, &mask);
+            printf("%s profile mask (0x%08x): %s\n",
+                   get_client_api_name(api),
+                   mask,
+                   get_profile_name_gl(mask));
+
+            printf("%s profile mask parsed by GLFW: %s\n",
+                   get_client_api_name(api),
+                   get_profile_name_glfw(profile));
+        }
+
+        if (glfwExtensionSupported("GL_ARB_robustness"))
+        {
+            int robustness;
+            GLint strategy;
+            glGetIntegerv(GL_RESET_NOTIFICATION_STRATEGY_ARB, &strategy);
+
+            printf("%s robustness strategy (0x%08x): %s\n",
+                   get_client_api_name(api),
+                   strategy,
+                   get_strategy_name_gl(strategy));
+
+            robustness = glfwGetWindowAttrib(window, GLFW_CONTEXT_ROBUSTNESS);
+
+            printf("%s robustness strategy parsed by GLFW: %s\n",
+                   get_client_api_name(api),
+                   get_strategy_name_glfw(robustness));
+        }
+    }
+
+    printf("%s context renderer string: \"%s\"\n",
+           get_client_api_name(api),
+           glGetString(GL_RENDERER));
+    printf("%s context vendor string: \"%s\"\n",
+           get_client_api_name(api),
+           glGetString(GL_VENDOR));
+
+    if (major > 1)
+    {
+        printf("%s context shading language version: \"%s\"\n",
+               get_client_api_name(api),
+               glGetString(GL_SHADING_LANGUAGE_VERSION));
+    }
+
+    // Report client API extensions
+    if (list)
+        list_extensions(api, major, minor);
+
+    glfwTerminate();
+    exit(EXIT_SUCCESS);
+}
+

source/glfw/tests/iconify.c

@@ -0,0 +1,176 @@
+//========================================================================
+// Iconify/restore test program
+// Copyright (c) Camilla Berglund <elmindreda@elmindreda.org>
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+//    claim that you wrote the original software. If you use this software
+//    in a product, an acknowledgment in the product documentation would
+//    be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such, and must not
+//    be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source
+//    distribution.
+//
+//========================================================================
+//
+// This program is used to test the iconify/restore functionality for
+// both fullscreen and windowed mode windows
+//
+//========================================================================
+
+#include <GLFW/glfw3.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "getopt.h"
+
+static void usage(void)
+{
+    printf("Usage: iconify [-h] [-f]\n");
+}
+
+static void error_callback(int error, const char* description)
+{
+    fprintf(stderr, "Error: %s\n", description);
+}
+
+static void key_callback(GLFWwindow* window, int key, int scancode, int action, int mods)
+{
+    printf("%0.2f Key %s\n",
+           glfwGetTime(),
+           action == GLFW_PRESS ? "pressed" : "released");
+
+    if (action != GLFW_PRESS)
+        return;
+
+    switch (key)
+    {
+        case GLFW_KEY_SPACE:
+            glfwIconifyWindow(window);
+            break;
+        case GLFW_KEY_ESCAPE:
+            glfwSetWindowShouldClose(window, GL_TRUE);
+            break;
+    }
+}
+
+static void window_size_callback(GLFWwindow* window, int width, int height)
+{
+    printf("%0.2f Window resized to %ix%i\n", glfwGetTime(), width, height);
+}
+
+static void framebuffer_size_callback(GLFWwindow* window, int width, int height)
+{
+    printf("%0.2f Framebuffer resized to %ix%i\n", glfwGetTime(), width, height);
+
+    glViewport(0, 0, width, height);
+}
+
+static void window_focus_callback(GLFWwindow* window, int focused)
+{
+    printf("%0.2f Window %s\n",
+           glfwGetTime(),
+           focused ? "focused" : "defocused");
+}
+
+static void window_iconify_callback(GLFWwindow* window, int iconified)
+{
+    printf("%0.2f Window %s\n",
+           glfwGetTime(),
+           iconified ? "iconified" : "restored");
+}
+
+int main(int argc, char** argv)
+{
+    int width, height, ch;
+    GLFWmonitor* monitor = NULL;
+    GLFWwindow* window;
+
+    glfwSetErrorCallback(error_callback);
+
+    if (!glfwInit())
+        exit(EXIT_FAILURE);
+
+    while ((ch = getopt(argc, argv, "fh")) != -1)
+    {
+        switch (ch)
+        {
+            case 'h':
+                usage();
+                exit(EXIT_SUCCESS);
+
+            case 'f':
+                monitor = glfwGetPrimaryMonitor();
+                break;
+
+            default:
+                usage();
+                exit(EXIT_FAILURE);
+        }
+    }
+
+    if (monitor)
+    {
+        const GLFWvidmode* mode = glfwGetVideoMode(monitor);
+        width = mode->width;
+        height = mode->height;
+    }
+    else
+    {
+        width = 640;
+        height = 480;
+    }
+
+    window = glfwCreateWindow(width, height, "Iconify", monitor, NULL);
+    if (!window)
+    {
+        glfwTerminate();
+        exit(EXIT_FAILURE);
+    }
+
+    glfwMakeContextCurrent(window);
+    glfwSwapInterval(1);
+
+    glfwSetKeyCallback(window, key_callback);
+    glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
+    glfwSetWindowSizeCallback(window, window_size_callback);
+    glfwSetWindowFocusCallback(window, window_focus_callback);
+    glfwSetWindowIconifyCallback(window, window_iconify_callback);
+
+    printf("Window is %s and %s\n",
+           glfwGetWindowAttrib(window, GLFW_ICONIFIED) ? "iconified" : "restored",
+           glfwGetWindowAttrib(window, GLFW_FOCUSED) ? "focused" : "defocused");
+
+    glEnable(GL_SCISSOR_TEST);
+
+    while (!glfwWindowShouldClose(window))
+    {
+        glfwGetFramebufferSize(window, &width, &height);
+
+        glScissor(0, 0, width, height);
+        glClearColor(0, 0, 0, 0);
+        glClear(GL_COLOR_BUFFER_BIT);
+
+        glScissor(0, 0, 640, 480);
+        glClearColor(1, 1, 1, 0);
+        glClear(GL_COLOR_BUFFER_BIT);
+
+        glfwSwapBuffers(window);
+        glfwPollEvents();
+    }
+
+    glfwTerminate();
+    exit(EXIT_SUCCESS);
+}
+

source/glfw/tests/joysticks.c

@@ -0,0 +1,230 @@
+//========================================================================
+// Joystick input test
+// Copyright (c) Camilla Berglund <elmindreda@elmindreda.org>
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+//    claim that you wrote the original software. If you use this software
+//    in a product, an acknowledgment in the product documentation would
+//    be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such, and must not
+//    be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source
+//    distribution.
+//
+//========================================================================
+//
+// This test displays the state of every button and axis of every connected
+// joystick and/or gamepad
+//
+//========================================================================
+
+#include <GLFW/glfw3.h>
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+#ifdef _MSC_VER
+#define strdup(x) _strdup(x)
+#endif
+
+typedef struct Joystick
+{
+    GLboolean present;
+    char* name;
+    float* axes;
+    unsigned char* buttons;
+    int axis_count;
+    int button_count;
+} Joystick;
+
+static Joystick joysticks[GLFW_JOYSTICK_LAST - GLFW_JOYSTICK_1 + 1];
+static int joystick_count = 0;
+
+static void error_callback(int error, const char* description)
+{
+    fprintf(stderr, "Error: %s\n", description);
+}
+
+static void framebuffer_size_callback(GLFWwindow* window, int width, int height)
+{
+    glViewport(0, 0, width, height);
+}
+
+static void draw_joystick(Joystick* j, int x, int y, int width, int height)
+{
+    int i;
+    int axis_width, axis_height;
+    int button_width, button_height;
+
+    axis_width = width / j->axis_count;
+    axis_height = 3 * height / 4;
+
+    button_width = width / j->button_count;
+    button_height = height / 4;
+
+    for (i = 0;  i < j->axis_count;  i++)
+    {
+        float value = j->axes[i] / 2.f + 0.5f;
+
+        glColor3f(0.3f, 0.3f, 0.3f);
+        glRecti(x + i * axis_width,
+                y,
+                x + (i + 1) * axis_width,
+                y + axis_height);
+
+        glColor3f(1.f, 1.f, 1.f);
+        glRecti(x + i * axis_width,
+                y + (int) (value * (axis_height - 5)),
+                x + (i + 1) * axis_width,
+                y + 5 + (int) (value * (axis_height - 5)));
+    }
+
+    for (i = 0;  i < j->button_count;  i++)
+    {
+        if (j->buttons[i])
+            glColor3f(1.f, 1.f, 1.f);
+        else
+            glColor3f(0.3f, 0.3f, 0.3f);
+
+        glRecti(x + i * button_width,
+                y + axis_height,
+                x + (i + 1) * button_width,
+                y + axis_height + button_height);
+    }
+}
+
+static void draw_joysticks(GLFWwindow* window)
+{
+    int i, width, height;
+
+    glfwGetFramebufferSize(window, &width, &height);
+
+    glMatrixMode(GL_PROJECTION);
+    glLoadIdentity();
+    glOrtho(0.f, width, height, 0.f, 1.f, -1.f);
+    glMatrixMode(GL_MODELVIEW);
+
+    for (i = 0;  i < sizeof(joysticks) / sizeof(Joystick);  i++)
+    {
+        Joystick* j = joysticks + i;
+
+        if (j->present)
+        {
+            draw_joystick(j,
+                          0, i * height / joystick_count,
+                          width, height / joystick_count);
+        }
+    }
+}
+
+static void refresh_joysticks(void)
+{
+    int i;
+
+    for (i = 0;  i < sizeof(joysticks) / sizeof(Joystick);  i++)
+    {
+        Joystick* j = joysticks + i;
+
+        if (glfwJoystickPresent(GLFW_JOYSTICK_1 + i))
+        {
+            const float* axes;
+            const unsigned char* buttons;
+            int axis_count, button_count;
+
+            free(j->name);
+            j->name = strdup(glfwGetJoystickName(GLFW_JOYSTICK_1 + i));
+
+            axes = glfwGetJoystickAxes(GLFW_JOYSTICK_1 + i, &axis_count);
+            if (axis_count != j->axis_count)
+            {
+                j->axis_count = axis_count;
+                j->axes = realloc(j->axes, j->axis_count * sizeof(float));
+            }
+
+            memcpy(j->axes, axes, axis_count * sizeof(float));
+
+            buttons = glfwGetJoystickButtons(GLFW_JOYSTICK_1 + i, &button_count);
+            if (button_count != j->button_count)
+            {
+                j->button_count = button_count;
+                j->buttons = realloc(j->buttons, j->button_count);
+            }
+
+            memcpy(j->buttons, buttons, button_count * sizeof(unsigned char));
+
+            if (!j->present)
+            {
+                printf("Found joystick %i named \'%s\' with %i axes, %i buttons\n",
+                       i + 1, j->name, j->axis_count, j->button_count);
+
+                joystick_count++;
+            }
+
+            j->present = GL_TRUE;
+        }
+        else
+        {
+            if (j->present)
+            {
+                printf("Lost joystick %i named \'%s\'\n", i + 1, j->name);
+
+                free(j->name);
+                free(j->axes);
+                free(j->buttons);
+                memset(j, 0, sizeof(Joystick));
+
+                joystick_count--;
+            }
+        }
+    }
+}
+
+int main(void)
+{
+    GLFWwindow* window;
+
+    memset(joysticks, 0, sizeof(joysticks));
+
+    glfwSetErrorCallback(error_callback);
+
+    if (!glfwInit())
+        exit(EXIT_FAILURE);
+
+    window = glfwCreateWindow(640, 480, "Joystick Test", NULL, NULL);
+    if (!window)
+    {
+        glfwTerminate();
+        exit(EXIT_FAILURE);
+    }
+
+    glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
+
+    glfwMakeContextCurrent(window);
+    glfwSwapInterval(1);
+
+    while (!glfwWindowShouldClose(window))
+    {
+        glClear(GL_COLOR_BUFFER_BIT);
+
+        refresh_joysticks();
+        draw_joysticks(window);
+
+        glfwSwapBuffers(window);
+        glfwPollEvents();
+    }
+
+    glfwTerminate();
+    exit(EXIT_SUCCESS);
+}
+

source/glfw/tests/modes.c

@@ -0,0 +1,242 @@
+//========================================================================
+// Video mode test
+// Copyright (c) Camilla Berglund <elmindreda@elmindreda.org>
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+//    claim that you wrote the original software. If you use this software
+//    in a product, an acknowledgment in the product documentation would
+//    be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such, and must not
+//    be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source
+//    distribution.
+//
+//========================================================================
+//
+// This test enumerates or verifies video modes
+//
+//========================================================================
+
+#include <GLFW/glfw3.h>
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+#include "getopt.h"
+
+enum Mode
+{
+    LIST_MODE,
+    TEST_MODE
+};
+
+static void usage(void)
+{
+    printf("Usage: modes [-t]\n");
+    printf("       modes -h\n");
+}
+
+static const char* format_mode(const GLFWvidmode* mode)
+{
+    static char buffer[512];
+
+    sprintf(buffer,
+            "%i x %i x %i (%i %i %i) %i Hz",
+            mode->width, mode->height,
+            mode->redBits + mode->greenBits + mode->blueBits,
+            mode->redBits, mode->greenBits, mode->blueBits,
+            mode->refreshRate);
+
+    buffer[sizeof(buffer) - 1] = '\0';
+    return buffer;
+}
+
+static void error_callback(int error, const char* description)
+{
+    fprintf(stderr, "Error: %s\n", description);
+}
+
+static void framebuffer_size_callback(GLFWwindow* window, int width, int height)
+{
+    printf("Framebuffer resized to %ix%i\n", width, height);
+
+    glViewport(0, 0, width, height);
+}
+
+static void key_callback(GLFWwindow* window, int key, int scancode, int action, int mods)
+{
+    if (key == GLFW_KEY_ESCAPE)
+        glfwSetWindowShouldClose(window, GL_TRUE);
+}
+
+static void list_modes(GLFWmonitor* monitor)
+{
+    int count, x, y, widthMM, heightMM, dpi, i;
+    const GLFWvidmode* mode = glfwGetVideoMode(monitor);
+    const GLFWvidmode* modes = glfwGetVideoModes(monitor, &count);
+
+    glfwGetMonitorPos(monitor, &x, &y);
+    glfwGetMonitorPhysicalSize(monitor, &widthMM, &heightMM);
+
+    printf("Name: %s (%s)\n",
+           glfwGetMonitorName(monitor),
+           glfwGetPrimaryMonitor() == monitor ? "primary" : "secondary");
+    printf("Current mode: %s\n", format_mode(mode));
+    printf("Virtual position: %i %i\n", x, y);
+
+    dpi = (int) ((float) mode->width * 25.4f / (float) widthMM);
+    printf("Physical size: %i x %i mm (%i dpi)\n", widthMM, heightMM, dpi);
+
+    printf("Modes:\n");
+
+    for (i = 0;  i < count;  i++)
+    {
+        printf("%3u: %s", (unsigned int) i, format_mode(modes + i));
+
+        if (memcmp(mode, modes + i, sizeof(GLFWvidmode)) == 0)
+            printf(" (current mode)");
+
+        putchar('\n');
+    }
+}
+
+static void test_modes(GLFWmonitor* monitor)
+{
+    int i, count;
+    GLFWwindow* window;
+    const GLFWvidmode* modes = glfwGetVideoModes(monitor, &count);
+
+    for (i = 0;  i < count;  i++)
+    {
+        const GLFWvidmode* mode = modes + i;
+        GLFWvidmode current;
+
+        glfwWindowHint(GLFW_RED_BITS, mode->redBits);
+        glfwWindowHint(GLFW_GREEN_BITS, mode->greenBits);
+        glfwWindowHint(GLFW_BLUE_BITS, mode->blueBits);
+
+        printf("Testing mode %u on monitor %s: %s\n",
+               (unsigned int) i,
+               glfwGetMonitorName(monitor),
+               format_mode(mode));
+
+        window = glfwCreateWindow(mode->width, mode->height,
+                                  "Video Mode Test",
+                                  glfwGetPrimaryMonitor(),
+                                  NULL);
+        if (!window)
+        {
+            printf("Failed to enter mode %u: %s\n",
+                   (unsigned int) i,
+                   format_mode(mode));
+            continue;
+        }
+
+        glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
+        glfwSetKeyCallback(window, key_callback);
+
+        glfwMakeContextCurrent(window);
+        glfwSwapInterval(1);
+
+        glfwSetTime(0.0);
+
+        while (glfwGetTime() < 5.0)
+        {
+            glClear(GL_COLOR_BUFFER_BIT);
+            glfwSwapBuffers(window);
+            glfwPollEvents();
+
+            if (glfwWindowShouldClose(window))
+            {
+                printf("User terminated program\n");
+
+                glfwTerminate();
+                exit(EXIT_SUCCESS);
+            }
+        }
+
+        glGetIntegerv(GL_RED_BITS, &current.redBits);
+        glGetIntegerv(GL_GREEN_BITS, &current.greenBits);
+        glGetIntegerv(GL_BLUE_BITS, &current.blueBits);
+
+        glfwGetWindowSize(window, &current.width, &current.height);
+
+        if (current.redBits != mode->redBits ||
+            current.greenBits != mode->greenBits ||
+            current.blueBits != mode->blueBits)
+        {
+            printf("*** Color bit mismatch: (%i %i %i) instead of (%i %i %i)\n",
+                   current.redBits, current.greenBits, current.blueBits,
+                   mode->redBits, mode->greenBits, mode->blueBits);
+        }
+
+        if (current.width != mode->width || current.height != mode->height)
+        {
+            printf("*** Size mismatch: %ix%i instead of %ix%i\n",
+                   current.width, current.height,
+                   mode->width, mode->height);
+        }
+
+        printf("Closing window\n");
+
+        glfwDestroyWindow(window);
+        window = NULL;
+
+        glfwPollEvents();
+    }
+}
+
+int main(int argc, char** argv)
+{
+    int ch, i, count, mode = LIST_MODE;
+    GLFWmonitor** monitors;
+
+    while ((ch = getopt(argc, argv, "th")) != -1)
+    {
+        switch (ch)
+        {
+            case 'h':
+                usage();
+                exit(EXIT_SUCCESS);
+            case 't':
+                mode = TEST_MODE;
+                break;
+            default:
+                usage();
+                exit(EXIT_FAILURE);
+        }
+    }
+
+    argc -= optind;
+    argv += optind;
+
+    glfwSetErrorCallback(error_callback);
+
+    if (!glfwInit())
+        exit(EXIT_FAILURE);
+
+    monitors = glfwGetMonitors(&count);
+
+    for (i = 0;  i < count;  i++)
+    {
+        if (mode == LIST_MODE)
+            list_modes(monitors[i]);
+        else if (mode == TEST_MODE)
+            test_modes(monitors[i]);
+    }
+
+    glfwTerminate();
+    exit(EXIT_SUCCESS);
+}
+

source/glfw/tests/peter.c

@@ -0,0 +1,156 @@
+//========================================================================
+// Cursor input bug test
+// Copyright (c) Camilla Berglund <elmindreda@elmindreda.org>
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+//    claim that you wrote the original software. If you use this software
+//    in a product, an acknowledgment in the product documentation would
+//    be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such, and must not
+//    be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source
+//    distribution.
+//
+//========================================================================
+//
+// This test came about as the result of bugs #1262764, #1726540 and
+// #1726592, all reported by the user peterpp, hence the name
+//
+// The utility of this test outside of these bugs is uncertain
+//
+//========================================================================
+
+#include <GLFW/glfw3.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+
+static GLboolean reopen = GL_FALSE;
+static double cursor_x;
+static double cursor_y;
+
+static void toggle_cursor(GLFWwindow* window)
+{
+    if (glfwGetInputMode(window, GLFW_CURSOR) == GLFW_CURSOR_DISABLED)
+    {
+        printf("Released cursor\n");
+        glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_NORMAL);
+    }
+    else
+    {
+        printf("Captured cursor\n");
+        glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
+    }
+}
+
+static void error_callback(int error, const char* description)
+{
+    fprintf(stderr, "Error: %s\n", description);
+}
+
+static void cursor_position_callback(GLFWwindow* window, double x, double y)
+{
+    printf("Cursor moved to: %f %f (%f %f)\n", x, y, x - cursor_x, y - cursor_y);
+    cursor_x = x;
+    cursor_y = y;
+}
+
+static void key_callback(GLFWwindow* window, int key, int scancode, int action, int mods)
+{
+    switch (key)
+    {
+        case GLFW_KEY_SPACE:
+        {
+            if (action == GLFW_PRESS)
+                toggle_cursor(window);
+
+            break;
+        }
+
+        case GLFW_KEY_R:
+        {
+            if (action == GLFW_PRESS)
+                reopen = GL_TRUE;
+
+            break;
+        }
+    }
+}
+
+static void framebuffer_size_callback(GLFWwindow* window, int width, int height)
+{
+    glViewport(0, 0, width, height);
+}
+
+static GLFWwindow* open_window(void)
+{
+    GLFWwindow* window = glfwCreateWindow(640, 480, "Peter Detector", NULL, NULL);
+    if (!window)
+        return NULL;
+
+    glfwMakeContextCurrent(window);
+    glfwSwapInterval(1);
+
+    glfwGetCursorPos(window, &cursor_x, &cursor_y);
+    printf("Cursor position: %f %f\n", cursor_x, cursor_y);
+
+    glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
+    glfwSetCursorPosCallback(window, cursor_position_callback);
+    glfwSetKeyCallback(window, key_callback);
+
+    return window;
+}
+
+int main(void)
+{
+    GLFWwindow* window;
+
+    glfwSetErrorCallback(error_callback);
+
+    if (!glfwInit())
+        exit(EXIT_FAILURE);
+
+    window = open_window();
+    if (!window)
+    {
+        glfwTerminate();
+        exit(EXIT_FAILURE);
+    }
+
+    glClearColor(0.f, 0.f, 0.f, 0.f);
+
+    while (!glfwWindowShouldClose(window))
+    {
+        glClear(GL_COLOR_BUFFER_BIT);
+
+        glfwSwapBuffers(window);
+        glfwWaitEvents();
+
+        if (reopen)
+        {
+            glfwDestroyWindow(window);
+            window = open_window();
+            if (!window)
+            {
+                glfwTerminate();
+                exit(EXIT_FAILURE);
+            }
+
+            reopen = GL_FALSE;
+        }
+    }
+
+    glfwTerminate();
+    exit(EXIT_SUCCESS);
+}
+

source/glfw/tests/reopen.c

@@ -0,0 +1,177 @@
+//========================================================================
+// Window re-opener (open/close stress test)
+// Copyright (c) Camilla Berglund <elmindreda@elmindreda.org>
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+//    claim that you wrote the original software. If you use this software
+//    in a product, an acknowledgment in the product documentation would
+//    be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such, and must not
+//    be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source
+//    distribution.
+//
+//========================================================================
+//
+// This test came about as the result of bug #1262773
+//
+// It closes and re-opens the GLFW window every five seconds, alternating
+// between windowed and fullscreen mode
+//
+// It also times and logs opening and closing actions and attempts to separate
+// user initiated window closing from its own
+//
+//========================================================================
+
+#include <GLFW/glfw3.h>
+
+#include <time.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+static void error_callback(int error, const char* description)
+{
+    fprintf(stderr, "Error: %s\n", description);
+}
+
+static void framebuffer_size_callback(GLFWwindow* window, int width, int height)
+{
+    glViewport(0, 0, width, height);
+}
+
+static void window_close_callback(GLFWwindow* window)
+{
+    printf("Close callback triggered\n");
+}
+
+static void key_callback(GLFWwindow* window, int key, int scancode, int action, int mods)
+{
+    if (action != GLFW_PRESS)
+        return;
+
+    switch (key)
+    {
+        case GLFW_KEY_Q:
+        case GLFW_KEY_ESCAPE:
+            glfwSetWindowShouldClose(window, GL_TRUE);
+            break;
+    }
+}
+
+static GLFWwindow* open_window(int width, int height, GLFWmonitor* monitor)
+{
+    double base;
+    GLFWwindow* window;
+
+    base = glfwGetTime();
+
+    window = glfwCreateWindow(width, height, "Window Re-opener", monitor, NULL);
+    if (!window)
+        return NULL;
+
+    glfwMakeContextCurrent(window);
+    glfwSwapInterval(1);
+
+    glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
+    glfwSetWindowCloseCallback(window, window_close_callback);
+    glfwSetKeyCallback(window, key_callback);
+
+    if (monitor)
+    {
+        printf("Opening full screen window on monitor %s took %0.3f seconds\n",
+               glfwGetMonitorName(monitor),
+               glfwGetTime() - base);
+    }
+    else
+    {
+        printf("Opening regular window took %0.3f seconds\n",
+               glfwGetTime() - base);
+    }
+
+    return window;
+}
+
+static void close_window(GLFWwindow* window)
+{
+    double base = glfwGetTime();
+    glfwDestroyWindow(window);
+    printf("Closing window took %0.3f seconds\n", glfwGetTime() - base);
+}
+
+int main(int argc, char** argv)
+{
+    int count = 0;
+    GLFWwindow* window;
+
+    srand((unsigned int) time(NULL));
+
+    glfwSetErrorCallback(error_callback);
+
+    if (!glfwInit())
+        exit(EXIT_FAILURE);
+
+    for (;;)
+    {
+        GLFWmonitor* monitor = NULL;
+
+        if (count & 1)
+        {
+            int monitorCount;
+            GLFWmonitor** monitors = glfwGetMonitors(&monitorCount);
+            monitor = monitors[rand() % monitorCount];
+        }
+
+        window = open_window(640, 480, monitor);
+        if (!window)
+        {
+            glfwTerminate();
+            exit(EXIT_FAILURE);
+        }
+
+        glMatrixMode(GL_PROJECTION);
+        glOrtho(-1.f, 1.f, -1.f, 1.f, 1.f, -1.f);
+        glMatrixMode(GL_MODELVIEW);
+
+        glfwSetTime(0.0);
+
+        while (glfwGetTime() < 5.0)
+        {
+            glClear(GL_COLOR_BUFFER_BIT);
+
+            glPushMatrix();
+            glRotatef((GLfloat) glfwGetTime() * 100.f, 0.f, 0.f, 1.f);
+            glRectf(-0.5f, -0.5f, 1.f, 1.f);
+            glPopMatrix();
+
+            glfwSwapBuffers(window);
+            glfwPollEvents();
+
+            if (glfwWindowShouldClose(window))
+            {
+                close_window(window);
+                printf("User closed window\n");
+
+                glfwTerminate();
+                exit(EXIT_SUCCESS);
+            }
+        }
+
+        printf("Closing window\n");
+        close_window(window);
+
+        count++;
+    }
+
+    glfwTerminate();
+}
+

source/glfw/tests/sharing.c

@@ -0,0 +1,185 @@
+//========================================================================
+// Context sharing test program
+// Copyright (c) Camilla Berglund <elmindreda@elmindreda.org>
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+//    claim that you wrote the original software. If you use this software
+//    in a product, an acknowledgment in the product documentation would
+//    be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such, and must not
+//    be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source
+//    distribution.
+//
+//========================================================================
+//
+// This program is used to test sharing of objects between contexts
+//
+//========================================================================
+
+#define GLFW_INCLUDE_GLU
+#include <GLFW/glfw3.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#define WIDTH  400
+#define HEIGHT 400
+#define OFFSET 50
+
+static GLFWwindow* windows[2];
+
+static void error_callback(int error, const char* description)
+{
+    fprintf(stderr, "Error: %s\n", description);
+}
+
+static void key_callback(GLFWwindow* window, int key, int scancode, int action, int mods)
+{
+    if (action == GLFW_PRESS && key == GLFW_KEY_ESCAPE)
+        glfwSetWindowShouldClose(window, GL_TRUE);
+}
+
+static GLFWwindow* open_window(const char* title, GLFWwindow* share, int posX, int posY)
+{
+    GLFWwindow* window;
+
+    glfwWindowHint(GLFW_VISIBLE, GL_FALSE);
+    window = glfwCreateWindow(WIDTH, HEIGHT, title, NULL, share);
+    if (!window)
+        return NULL;
+
+    glfwMakeContextCurrent(window);
+    glfwSwapInterval(1);
+    glfwSetWindowPos(window, posX, posY);
+    glfwShowWindow(window);
+
+    glfwSetKeyCallback(window, key_callback);
+
+    return window;
+}
+
+static GLuint create_texture(void)
+{
+    int x, y;
+    char pixels[256 * 256];
+    GLuint texture;
+
+    glGenTextures(1, &texture);
+    glBindTexture(GL_TEXTURE_2D, texture);
+
+    for (y = 0;  y < 256;  y++)
+    {
+        for (x = 0;  x < 256;  x++)
+            pixels[y * 256 + x] = rand() % 256;
+    }
+
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE, 256, 256, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, pixels);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+
+    return texture;
+}
+
+static void draw_quad(GLuint texture)
+{
+    int width, height;
+    glfwGetFramebufferSize(glfwGetCurrentContext(), &width, &height);
+
+    glViewport(0, 0, width, height);
+
+    glMatrixMode(GL_PROJECTION);
+    glLoadIdentity();
+    gluOrtho2D(0.f, 1.f, 0.f, 1.f);
+
+    glEnable(GL_TEXTURE_2D);
+    glBindTexture(GL_TEXTURE_2D, texture);
+    glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
+
+    glBegin(GL_QUADS);
+
+    glTexCoord2f(0.f, 0.f);
+    glVertex2f(0.f, 0.f);
+
+    glTexCoord2f(1.f, 0.f);
+    glVertex2f(1.f, 0.f);
+
+    glTexCoord2f(1.f, 1.f);
+    glVertex2f(1.f, 1.f);
+
+    glTexCoord2f(0.f, 1.f);
+    glVertex2f(0.f, 1.f);
+
+    glEnd();
+}
+
+int main(int argc, char** argv)
+{
+    int x, y, width;
+    GLuint texture;
+
+    glfwSetErrorCallback(error_callback);
+
+    if (!glfwInit())
+        exit(EXIT_FAILURE);
+
+    windows[0] = open_window("First", NULL, OFFSET, OFFSET);
+    if (!windows[0])
+    {
+        glfwTerminate();
+        exit(EXIT_FAILURE);
+    }
+
+    // This is the one and only time we create a texture
+    // It is created inside the first context, created above
+    // It will then be shared with the second context, created below
+    texture = create_texture();
+
+    glfwGetWindowPos(windows[0], &x, &y);
+    glfwGetWindowSize(windows[0], &width, NULL);
+
+    // Put the second window to the right of the first one
+    windows[1] = open_window("Second", windows[0], x + width + OFFSET, y);
+    if (!windows[1])
+    {
+        glfwTerminate();
+        exit(EXIT_FAILURE);
+    }
+
+    // Set drawing color for both contexts
+    glfwMakeContextCurrent(windows[0]);
+    glColor3f(0.6f, 0.f, 0.6f);
+    glfwMakeContextCurrent(windows[1]);
+    glColor3f(0.6f, 0.6f, 0.f);
+
+    glfwMakeContextCurrent(windows[0]);
+
+    while (!glfwWindowShouldClose(windows[0]) &&
+           !glfwWindowShouldClose(windows[1]))
+    {
+        glfwMakeContextCurrent(windows[0]);
+        draw_quad(texture);
+
+        glfwMakeContextCurrent(windows[1]);
+        draw_quad(texture);
+
+        glfwSwapBuffers(windows[0]);
+        glfwSwapBuffers(windows[1]);
+
+        glfwWaitEvents();
+    }
+
+    glfwTerminate();
+    exit(EXIT_SUCCESS);
+}
+

source/glfw/tests/tearing.c

@@ -0,0 +1,130 @@
+//========================================================================
+// Vsync enabling test
+// Copyright (c) Camilla Berglund <elmindreda@elmindreda.org>
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+//    claim that you wrote the original software. If you use this software
+//    in a product, an acknowledgment in the product documentation would
+//    be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such, and must not
+//    be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source
+//    distribution.
+//
+//========================================================================
+//
+// This test renders a high contrast, horizontally moving bar, allowing for
+// visual verification of whether the set swap interval is indeed obeyed
+//
+//========================================================================
+
+#include <GLFW/glfw3.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+
+static int swap_interval;
+static double frame_rate;
+
+static void update_window_title(GLFWwindow* window)
+{
+    char title[256];
+
+    sprintf(title, "Tearing detector (interval %i, %0.1f Hz)",
+            swap_interval, frame_rate);
+
+    glfwSetWindowTitle(window, title);
+}
+
+static void set_swap_interval(GLFWwindow* window, int interval)
+{
+    swap_interval = interval;
+    glfwSwapInterval(swap_interval);
+    update_window_title(window);
+}
+
+static void error_callback(int error, const char* description)
+{
+    fprintf(stderr, "Error: %s\n", description);
+}
+
+static void framebuffer_size_callback(GLFWwindow* window, int width, int height)
+{
+    glViewport(0, 0, width, height);
+}
+
+static void key_callback(GLFWwindow* window, int key, int scancode, int action, int mods)
+{
+    if (key == GLFW_KEY_SPACE && action == GLFW_PRESS)
+        set_swap_interval(window, 1 - swap_interval);
+}
+
+int main(void)
+{
+    float position;
+    unsigned long frame_count = 0;
+    double last_time, current_time;
+    GLFWwindow* window;
+
+    glfwSetErrorCallback(error_callback);
+
+    if (!glfwInit())
+        exit(EXIT_FAILURE);
+
+    window = glfwCreateWindow(640, 480, "", NULL, NULL);
+    if (!window)
+    {
+        glfwTerminate();
+        exit(EXIT_FAILURE);
+    }
+
+    glfwMakeContextCurrent(window);
+    set_swap_interval(window, 0);
+
+    last_time = glfwGetTime();
+    frame_rate = 0.0;
+
+    glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
+    glfwSetKeyCallback(window, key_callback);
+
+    glMatrixMode(GL_PROJECTION);
+    glOrtho(-1.f, 1.f, -1.f, 1.f, 1.f, -1.f);
+    glMatrixMode(GL_MODELVIEW);
+
+    while (!glfwWindowShouldClose(window))
+    {
+        glClear(GL_COLOR_BUFFER_BIT);
+
+        position = cosf((float) glfwGetTime() * 4.f) * 0.75f;
+        glRectf(position - 0.25f, -1.f, position + 0.25f, 1.f);
+
+        glfwSwapBuffers(window);
+        glfwPollEvents();
+
+        frame_count++;
+
+        current_time = glfwGetTime();
+        if (current_time - last_time > 1.0)
+        {
+            frame_rate = frame_count / (current_time - last_time);
+            frame_count = 0;
+            last_time = current_time;
+            update_window_title(window);
+        }
+    }
+
+    glfwTerminate();
+    exit(EXIT_SUCCESS);
+}
+

source/glfw/tests/threads.c

@@ -0,0 +1,137 @@
+//========================================================================
+// Multithreading test
+// Copyright (c) Camilla Berglund <elmindreda@elmindreda.org>
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+//    claim that you wrote the original software. If you use this software
+//    in a product, an acknowledgment in the product documentation would
+//    be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such, and must not
+//    be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source
+//    distribution.
+//
+//========================================================================
+//
+// This test is intended to verify whether the OpenGL context part of
+// the GLFW API is able to be used from multiple threads
+//
+//========================================================================
+
+#include "tinycthread.h"
+
+#include <GLFW/glfw3.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+#include <assert.h>
+
+typedef struct
+{
+    GLFWwindow* window;
+    const char* title;
+    float r, g, b;
+    thrd_t id;
+} Thread;
+
+static volatile GLboolean running = GL_TRUE;
+
+static void error_callback(int error, const char* description)
+{
+    fprintf(stderr, "Error: %s\n", description);
+}
+
+static int thread_main(void* data)
+{
+    const Thread* thread = (const Thread*) data;
+
+    glfwMakeContextCurrent(thread->window);
+    assert(glfwGetCurrentContext() == thread->window);
+
+    glfwSwapInterval(1);
+
+    while (running)
+    {
+        const float v = (float) fabs(sin(glfwGetTime() * 2.f));
+        glClearColor(thread->r * v, thread->g * v, thread->b * v, 0.f);
+
+        glClear(GL_COLOR_BUFFER_BIT);
+        glfwSwapBuffers(thread->window);
+    }
+
+    glfwMakeContextCurrent(NULL);
+    return 0;
+}
+
+int main(void)
+{
+    int i, result;
+    Thread threads[] =
+    {
+        { NULL, "Red", 1.f, 0.f, 0.f, 0 },
+        { NULL, "Green", 0.f, 1.f, 0.f, 0 },
+        { NULL, "Blue", 0.f, 0.f, 1.f, 0 }
+    };
+    const int count = sizeof(threads) / sizeof(Thread);
+
+    glfwSetErrorCallback(error_callback);
+
+    if (!glfwInit())
+        exit(EXIT_FAILURE);
+
+    glfwWindowHint(GLFW_VISIBLE, GL_FALSE);
+
+    for (i = 0;  i < count;  i++)
+    {
+        threads[i].window = glfwCreateWindow(200, 200,
+                                             threads[i].title,
+                                             NULL, NULL);
+        if (!threads[i].window)
+        {
+            glfwTerminate();
+            exit(EXIT_FAILURE);
+        }
+
+        glfwSetWindowPos(threads[i].window, 200 + 250 * i, 200);
+        glfwShowWindow(threads[i].window);
+
+        if (thrd_create(&threads[i].id, thread_main, threads + i) !=
+            thrd_success)
+        {
+            fprintf(stderr, "Failed to create secondary thread\n");
+
+            glfwTerminate();
+            exit(EXIT_FAILURE);
+        }
+    }
+
+    while (running)
+    {
+        assert(glfwGetCurrentContext() == NULL);
+
+        glfwWaitEvents();
+
+        for (i = 0;  i < count;  i++)
+        {
+            if (glfwWindowShouldClose(threads[i].window))
+                running = GL_FALSE;
+        }
+    }
+
+    for (i = 0;  i < count;  i++)
+        thrd_join(threads[i].id, &result);
+
+    exit(EXIT_SUCCESS);
+}
+

source/glfw/tests/title.c

@@ -0,0 +1,76 @@
+//========================================================================
+// UTF-8 window title test
+// Copyright (c) Camilla Berglund <elmindreda@elmindreda.org>
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+//    claim that you wrote the original software. If you use this software
+//    in a product, an acknowledgment in the product documentation would
+//    be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such, and must not
+//    be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source
+//    distribution.
+//
+//========================================================================
+//
+// This test sets a UTF-8 window title
+//
+//========================================================================
+
+#include <GLFW/glfw3.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+
+static void error_callback(int error, const char* description)
+{
+    fprintf(stderr, "Error: %s\n", description);
+}
+
+static void framebuffer_size_callback(GLFWwindow* window, int width, int height)
+{
+    glViewport(0, 0, width, height);
+}
+
+int main(void)
+{
+    GLFWwindow* window;
+
+    glfwSetErrorCallback(error_callback);
+
+    if (!glfwInit())
+        exit(EXIT_FAILURE);
+
+    window = glfwCreateWindow(400, 400, "English 日本語 русский язык 官話", NULL, NULL);
+    if (!window)
+    {
+        glfwTerminate();
+        exit(EXIT_FAILURE);
+    }
+
+    glfwMakeContextCurrent(window);
+    glfwSwapInterval(1);
+
+    glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
+
+    while (!glfwWindowShouldClose(window))
+    {
+        glClear(GL_COLOR_BUFFER_BIT);
+        glfwSwapBuffers(window);
+        glfwWaitEvents();
+    }
+
+    glfwTerminate();
+    exit(EXIT_SUCCESS);
+}
+

source/glfw/tests/windows.c

@@ -0,0 +1,98 @@
+//========================================================================
+// Simple multi-window test
+// Copyright (c) Camilla Berglund <elmindreda@elmindreda.org>
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+//    claim that you wrote the original software. If you use this software
+//    in a product, an acknowledgment in the product documentation would
+//    be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such, and must not
+//    be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source
+//    distribution.
+//
+//========================================================================
+//
+// This test creates four windows and clears each in a different color
+//
+//========================================================================
+
+#include <GLFW/glfw3.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+
+static const char* titles[] =
+{
+    "Foo",
+    "Bar",
+    "Baz",
+    "Quux"
+};
+
+static void error_callback(int error, const char* description)
+{
+    fprintf(stderr, "Error: %s\n", description);
+}
+
+int main(void)
+{
+    int i;
+    GLboolean running = GL_TRUE;
+    GLFWwindow* windows[4];
+
+    glfwSetErrorCallback(error_callback);
+
+    if (!glfwInit())
+        exit(EXIT_FAILURE);
+
+    glfwWindowHint(GLFW_VISIBLE, GL_FALSE);
+
+    for (i = 0;  i < 4;  i++)
+    {
+        windows[i] = glfwCreateWindow(200, 200, titles[i], NULL, NULL);
+        if (!windows[i])
+        {
+            glfwTerminate();
+            exit(EXIT_FAILURE);
+        }
+
+        glfwMakeContextCurrent(windows[i]);
+        glClearColor((GLclampf) (i & 1),
+                     (GLclampf) (i >> 1),
+                     i ? 0.f : 1.f,
+                     0.f);
+
+        glfwSetWindowPos(windows[i], 100 + (i & 1) * 300, 100 + (i >> 1) * 300);
+        glfwShowWindow(windows[i]);
+    }
+
+    while (running)
+    {
+        for (i = 0;  i < 4;  i++)
+        {
+            glfwMakeContextCurrent(windows[i]);
+            glClear(GL_COLOR_BUFFER_BIT);
+            glfwSwapBuffers(windows[i]);
+
+            if (glfwWindowShouldClose(windows[i]))
+                running = GL_FALSE;
+        }
+
+        glfwPollEvents();
+    }
+
+    glfwTerminate();
+    exit(EXIT_SUCCESS);
+}
+