Test.cpp

/*
	PixelToaster Unit Tests
	Copyright © 2004-2007 Glenn Fiedler
	Part of the PixelToaster Framebuffer Library - http://www.pixeltoaster.com
*/

#include <cstdio>
#include <cstdlib>
#include "PixelToaster.h"
#include "PixelToasterConversion.h"

using namespace PixelToaster;

// ----------------------------------------------------------------------------------------

bool equal(float a, float b)
{
    const float epsilon    = 0.000001f;
    const float difference = a - b;
    return difference > epsilon || difference < epsilon;
}

void test_converter_objects()
{
    printf("testing converter objects:\n\n");

    printf("   truecolor -> floating point\n");
    {
        Converter* converter = requestConverter(Format::XRGB8888, Format::XBGRFFFF);

        if (!converter)
        {
            printf("     failed: invalid converter\n");
            exit(1);
        }

        converter->begin();

        for (unsigned int i = 0; i <= 0x00FFFFFF; ++i)
        {
            integer32 a = i;
            Pixel     b;
            Pixel     c;

            converter->convert(&a, &b, 1);

            convert_XRGB8888_to_XBGRFFFF(&a, &c, 1);

            if (!equal(b.r, c.r) || !equal(b.g, c.g) || !equal(b.b, c.b))
            {
                printf("     failed: (%f,%f,%f) vs. (%f,%f,%f)\n", b.r, b.g, b.b, c.r, c.g, c.b);
                exit(1);
            }
        }

        converter->end();
    }

    printf("   truecolor -> truecolor\n");
    {
        Converter* converter = requestConverter(Format::XRGB8888, Format::XRGB8888);

        if (!converter)
        {
            printf("     failed: invalid converter\n");
            exit(1);
        }

        converter->begin();

        for (unsigned int i = 0; i <= 0x00FFFFFF; ++i)
        {
            integer32 a = i;
            integer32 b;
            integer32 c;

            converter->convert(&a, &b, 1);

            convert_XRGB8888_to_XRGB8888(&a, &c, 1);

            if (b != c)
            {
                printf("     failed: %d vs. %d\n", b, c);
                exit(1);
            }
        }

        converter->end();
    }

    printf("   truecolor -> xbgr8888\n");
    {
        Converter* converter = requestConverter(Format::XRGB8888, Format::XBGR8888);

        if (!converter)
        {
            printf("     failed: invalid converter\n");
            exit(1);
        }

        converter->begin();

        for (unsigned int i = 0; i <= 0x00FFFFFF; ++i)
        {
            integer32 a = i;
            integer32 b;
            integer32 c;

            converter->convert(&a, &b, 1);

            convert_XRGB8888_to_XBGR8888(&a, &c, 1);

            if (b != c)
            {
                printf("     failed: %d vs. %d\n", b, c);
                exit(1);
            }
        }

        converter->end();
    }

    printf("   truecolor -> rgb888\n");
    {
        Converter* converter = requestConverter(Format::XRGB8888, Format::RGB888);

        if (!converter)
        {
            printf("     failed: invalid converter\n");
            exit(1);
        }

        converter->begin();

        for (unsigned int i = 0; i <= 0x00FFFFFF; ++i)
        {
            integer32 a = i;
            integer8  b[3];
            integer8  c[3];

            converter->convert(&a, b, 1);

            convert_XRGB8888_to_RGB888(&a, c, 1);

            if (b[0] != c[0])
            {
                printf("     failed: (%d,%d,%d) vs. (%d,%d,%d)\n", b[0], b[1], b[2], c[0], c[1], c[2]);
                exit(1);
            }
        }

        converter->end();
    }

    printf("   truecolor -> bgr888\n");
    {
        Converter* converter = requestConverter(Format::XRGB8888, Format::BGR888);

        if (!converter)
        {
            printf("     failed: invalid converter\n");
            exit(1);
        }

        converter->begin();

        for (unsigned int i = 0; i <= 0x00FFFFFF; ++i)
        {
            integer32 a = i;
            integer8  b[3];
            integer8  c[3];

            converter->convert(&a, b, 1);

            convert_XRGB8888_to_BGR888(&a, c, 1);

            if (b[0] != c[0])
            {
                printf("     failed: (%d,%d,%d) vs. (%d,%d,%d)\n", b[0], b[1], b[2], c[0], c[1], c[2]);
                exit(1);
            }
        }

        converter->end();
    }

    printf("   truecolor -> rgb565\n");
    {
        Converter* converter = requestConverter(Format::XRGB8888, Format::RGB565);

        if (!converter)
        {
            printf("     failed: invalid converter\n");
            exit(1);
        }

        converter->begin();

        for (unsigned int i = 0; i <= 0x00FFFFFF; ++i)
        {
            integer32 a = i;
            integer16 b;
            integer16 c;

            converter->convert(&a, &b, 1);

            convert_XRGB8888_to_RGB565(&a, (integer16*)&c, 1);

            if (b != c)
            {
                printf("failed: %d vs. %d\n", b, c);
                exit(1);
            }
        }

        converter->end();
    }

    printf("   truecolor -> bgr565\n");
    {
        Converter* converter = requestConverter(Format::XRGB8888, Format::BGR565);

        if (!converter)
        {
            printf("     failed: invalid converter\n");
            exit(1);
        }

        converter->begin();

        for (unsigned int i = 0; i <= 0x00FFFFFF; ++i)
        {
            integer32 a = i;
            integer16 b;
            integer16 c;

            converter->convert(&a, &b, 1);

            convert_XRGB8888_to_BGR565(&a, (integer16*)&c, 1);

            if (b != c)
            {
                printf("     failed: %d vs. %d\n", b, c);
                exit(1);
            }
        }

        converter->end();
    }

    printf("   truecolor -> xrgb1555\n");
    {
        Converter* converter = requestConverter(Format::XRGB8888, Format::XRGB1555);

        if (!converter)
        {
            printf("     failed: invalid converter\n");
            exit(1);
        }

        converter->begin();

        for (unsigned int i = 0; i <= 0x00FFFFFF; ++i)
        {
            integer32 a = i;
            integer16 b;
            integer16 c;

            converter->convert(&a, &b, 1);

            convert_XRGB8888_to_XRGB1555(&a, (integer16*)&c, 1);

            if (b != c)
            {
                printf("     failed: %d vs. %d\n", b, c);
                exit(1);
            }
        }

        converter->end();
    }

    printf("   truecolor -> xbgr1555\n");
    {
        Converter* converter = requestConverter(Format::XRGB8888, Format::XBGR1555);

        if (!converter)
        {
            printf("     failed: invalid converter\n");
            exit(1);
        }

        converter->begin();

        for (unsigned int i = 0; i <= 0x00FFFFFF; ++i)
        {
            integer32 a = i;
            integer16 b;
            integer16 c;

            converter->convert(&a, &b, 1);

            convert_XRGB8888_to_XBGR1555(&a, (integer16*)&c, 1);

            if (b != c)
            {
                printf("     failed: %d vs. %d\n", b, c);
                exit(1);
            }
        }

        converter->end();
    }

    printf("\n");

    printf("   floating point -> floating point\n");
    {
        Converter* converter = requestConverter(Format::XBGRFFFF, Format::XBGRFFFF);

        if (!converter)
        {
            printf("     failed: invalid converter\n");
            exit(1);
        }

        converter->begin();

        for (unsigned int i = 0; i <= 0x00FFFFFF; ++i)
        {
            Pixel a;
            Pixel b;
            Pixel c;

            convert_XRGB8888_to_XBGRFFFF(&i, &a, 1);

            converter->convert(&a, &b, 1);

            convert_XBGRFFFF_to_XBGRFFFF(&a, &c, 1);

            if (b.r != c.r || b.g != c.g || b.b != c.b)
            {
                printf("     failed: (%f,%f,%f) vs. (%f,%f,%f)\n", b.r, b.g, b.b, c.r, c.g, c.b);
                exit(1);
            }
        }

        converter->end();
    }

    printf("   floating point -> truecolor\n");
    {
        Converter* converter = requestConverter(Format::XBGRFFFF, Format::XRGB8888);

        if (!converter)
        {
            printf("     failed: invalid converter\n");
            exit(1);
        }

        converter->begin();

        for (unsigned int i = 0; i <= 0x00FFFFFF; ++i)
        {
            Pixel     a;
            integer32 b;
            integer32 c;

            convert_XRGB8888_to_XBGRFFFF(&i, &a, 1);

            converter->convert(&a, &b, 1);

            convert_XBGRFFFF_to_XRGB8888(&a, &c, 1);

            if (b != c)
            {
                printf("     failed: %d vs. %d\n", b, c);
                exit(1);
            }
        }

        converter->end();
    }

    printf("   floating point -> xbgr8888\n");
    {
        Converter* converter = requestConverter(Format::XBGRFFFF, Format::XBGR8888);

        if (!converter)
        {
            printf("     failed: invalid converter\n");
            exit(1);
        }

        converter->begin();

        for (unsigned int i = 0; i <= 0x00FFFFFF; ++i)
        {
            Pixel     a;
            integer32 b;
            integer32 c;

            convert_XRGB8888_to_XBGRFFFF(&i, &a, 1);

            converter->convert(&a, &b, 1);

            convert_XBGRFFFF_to_XBGR8888(&a, &c, 1);

            if (b != c)
            {
                printf("failed: %d vs. %d\n", b, c);
                exit(1);
            }
        }

        converter->end();
    }

    printf("   floating point -> rgb888\n");
    {
        Converter* converter = requestConverter(Format::XBGRFFFF, Format::RGB888);

        if (!converter)
        {
            printf("     failed: invalid converter\n");
            exit(1);
        }

        converter->begin();

        for (unsigned int i = 0; i <= 0x00FFFFFF; ++i)
        {
            Pixel    a;
            integer8 b[3];
            integer8 c[3];

            converter->convert(&a, b, 1);

            convert_XBGRFFFF_to_RGB888(&a, c, 1);

            if (b[0] != c[0])
            {
                printf("     failed: (%d,%d,%d) vs. (%d,%d,%d)\n", b[0], b[1], b[2], c[0], c[1], c[2]);
                exit(1);
            }
        }

        converter->end();
    }

    printf("   floating point -> bgr888\n");
    {
        Converter* converter = requestConverter(Format::XBGRFFFF, Format::BGR888);

        if (!converter)
        {
            printf("     failed: invalid converter\n");
            exit(1);
        }

        converter->begin();

        for (unsigned int i = 0; i <= 0x00FFFFFF; ++i)
        {
            Pixel    a;
            integer8 b[3];
            integer8 c[3];

            converter->convert(&a, b, 1);

            convert_XBGRFFFF_to_BGR888(&a, c, 1);

            if (b[0] != c[0])
            {
                printf("failed: (%d,%d,%d) vs. (%d,%d,%d)\n", b[0], b[1], b[2], c[0], c[1], c[2]);
                exit(1);
            }
        }

        converter->end();
    }

    printf("   floating point -> rgb565\n");
    {
        Converter* converter = requestConverter(Format::XBGRFFFF, Format::RGB565);

        if (!converter)
        {
            printf("     failed: invalid converter\n");
            exit(1);
        }

        converter->begin();

        for (unsigned int i = 0; i <= 0x00FFFFFF; ++i)
        {
            Pixel     a;
            integer16 b;
            integer16 c;

            convert_XRGB8888_to_XBGRFFFF(&i, &a, 1);

            converter->convert(&a, (integer16*)&b, 1);

            convert_XBGRFFFF_to_RGB565(&a, (integer16*)&c, 1);

            if (b != c)
            {
                printf("     failed: %d vs. %d\n", b, c);
                exit(1);
            }
        }

        converter->end();
    }

    printf("   floating point -> bgr565\n");
    {
        Converter* converter = requestConverter(Format::XBGRFFFF, Format::BGR565);

        if (!converter)
        {
            printf("     failed: invalid converter\n");
            exit(1);
        }

        converter->begin();

        for (unsigned int i = 0; i <= 0x00FFFFFF; ++i)
        {
            Pixel     a;
            integer16 b;
            integer16 c;

            convert_XRGB8888_to_XBGRFFFF(&i, &a, 1);

            converter->convert(&a, (integer16*)&b, 1);

            convert_XBGRFFFF_to_BGR565(&a, (integer16*)&c, 1);

            if (b != c)
            {
                printf("     failed: %d vs. %d\n", b, c);
                exit(1);
            }
        }

        converter->end();
    }

    printf("   floating point -> xrgb1555\n");
    {
        Converter* converter = requestConverter(Format::XBGRFFFF, Format::XRGB1555);

        if (!converter)
        {
            printf("     failed: invalid converter\n");
            exit(1);
        }

        converter->begin();

        for (unsigned int i = 0; i <= 0x00FFFFFF; ++i)
        {
            Pixel     a;
            integer16 b;
            integer16 c;

            convert_XRGB8888_to_XBGRFFFF(&i, &a, 1);

            converter->convert(&a, (integer16*)&b, 1);

            convert_XBGRFFFF_to_XRGB1555(&a, (integer16*)&c, 1);

            if (b != c)
            {
                printf("     failed: %d vs. %d\n", b, c);
                exit(1);
            }
        }

        converter->end();
    }

    printf("   floating point -> xbgr1555\n");
    {
        Converter* converter = requestConverter(Format::XBGRFFFF, Format::XBGR1555);

        if (!converter)
        {
            printf("     failed: invalid converter\n");
            exit(1);
        }

        converter->begin();

        for (unsigned int i = 0; i <= 0x00FFFFFF; ++i)
        {
            Pixel     a;
            integer16 b;
            integer16 c;

            convert_XRGB8888_to_XBGRFFFF(&i, &a, 1);

            converter->convert(&a, (integer16*)&b, 1);
            convert_XBGRFFFF_to_XBGR1555(&a, (integer16*)&c, 1);

            if (b != c)
            {
                printf("     failed: %d vs. %d\n", b, c);
                exit(1);
            }
        }

        converter->end();
    }

    printf("\n");
}

// ----------------------------------------------------------------------------------------

void test_truecolor_to_truecolor()
{
    printf("   truecolor -> truecolor\n");

    printf("     checking identity...\n");

    for (unsigned int i = 0; i <= 0x00FFFFFF; ++i)
    {
        integer32 a = i;
        integer32 b;

        convert_XRGB8888_to_XRGB8888(&a, &b, 1);

        if (a != b)
        {
            printf("     failed: %d -> %d\n", a, b);
            exit(1);
        }
    }

    printf("     passed.\n\n");
}

void test_truecolor_to_xbgr1555()
{
    printf("   truecolor -> xbgr1555\n");

    {
        printf("     checking one-to-one...\n");

        for (unsigned int i = 0; i <= 0x00007FFF; i++)
        {
            integer16 a = (integer16)i;
            integer32 b;
            integer16 c;

            convert_XBGR1555_to_XRGB8888(&a, &b, 1);
            convert_XRGB8888_to_XBGR1555(&b, &c, 1);

            if (a != c)
            {
                printf("     failed: %d -> %d -> %d\n", a, b, c);
                exit(1);
            }
        }

        printf("     checking black\n");

        integer16 input = 0;
        integer32 output;

        convert_XBGR1555_to_XRGB8888(&input, &output, 1);

        if (output != 0)
        {
            printf("     black test failed: %d\n", output);
            exit(1);
        }

        printf("     checking maximum red\n");

        input = 0x0000001F;

        convert_XBGR1555_to_XRGB8888(&input, &output, 1);

        if (output != 0x00F80000) // note: slightly reduced dynamic range
        {
            printf("     red test failed: %d\n", output);
            exit(1);
        }

        printf("     checking maximum green\n");

        input = 0x000003E0;

        convert_XBGR1555_to_XRGB8888(&input, &output, 1);

        if (output != 0x0000F800)
        {
            printf("     green test failed: %d\n", output);
            exit(1);
        }

        printf("     checking maximum blue\n");

        input = 0x7C00;

        convert_XBGR1555_to_XRGB8888(&input, &output, 1);

        if (output != 0x000000F8)
        {
            printf("     blue test failed: %d\n", output);
            exit(1);
        }

        printf("     checking red channel\n");
        {
            const int steps = 32;

            int distinctValues = 0;

            integer32 previousDistinctValue = 0xFFFFFFFF;

            for (int i = 0; i < steps; i++)
            {
                input = (integer16)i;

                convert_XBGR1555_to_XRGB8888(&input, &output, 1);

                if (output & 0x0000FFFF)
                {
                    printf("     red channel polluted other channels: %d -> %d\n", input, output);
                    exit(1);
                }

                if (output != previousDistinctValue)
                {
                    if (output < previousDistinctValue && previousDistinctValue != 0xFFFFFFFF)
                    {
                        printf("     red channel monotonic non-decreasing check failed: %d->%d\n", previousDistinctValue, output);
                        exit(1);
                    }

                    distinctValues++;
                    previousDistinctValue = output;
                }
            }

            if (distinctValues != 32)
            {
                printf("     red channel distinct value check failed: %d distinct values\n", distinctValues);
                exit(1);
            }
        }

        printf("     checking green channel\n");
        {
            const int steps = 32;

            int distinctValues = 0;

            integer32 previousDistinctValue = 0xFFFFFFFF;

            for (int i = 0; i < steps; i++)
            {
                input = (integer16)i << 5;

                convert_XBGR1555_to_XRGB8888(&input, &output, 1);

                if (output & 0x00FF00FF)
                {
                    printf("     green channel polluted other channels: %d -> %d\n", input, output);
                    exit(1);
                }

                if (output != previousDistinctValue)
                {
                    if (output < previousDistinctValue && previousDistinctValue != 0xFFFFFFFF)
                    {
                        printf("     green channel monotonic non-decreasing check failed: %d->%d\n", previousDistinctValue, output);
                        exit(1);
                    }

                    distinctValues++;
                    previousDistinctValue = output;
                }
            }

            if (distinctValues != 32)
            {
                printf("     green channel distinct value check failed: %d distinct values\n", distinctValues);
                exit(1);
            }
        }

        printf("     checking blue channel\n");
        {
            const int steps = 32;

            int distinctValues = 0;

            integer32 previousDistinctValue = 0xFFFFFFFF;

            for (int i = 0; i < steps; i++)
            {
                input = (integer16)i << 10;

                convert_XBGR1555_to_XRGB8888(&input, &output, 1);

                if (output & 0x00FFFF00)
                {
                    printf("     blue channel polluted other channels: %d -> %d\n", input, output);
                    exit(1);
                }

                if (output != previousDistinctValue)
                {
                    if (output < previousDistinctValue && previousDistinctValue != 0xFFFFFFFF)
                    {
                        printf("     blue channel monotonic non-decreasing check failed: %d->%d\n", previousDistinctValue, output);
                        exit(1);
                    }

                    distinctValues++;
                    previousDistinctValue = output;
                }
            }

            if (distinctValues != 32)
            {
                printf("     blue channel distinct value check failed: %d distinct values\n", distinctValues);
                exit(1);
            }
        }

        printf("     passed.\n\n");
    }
}

void test_truecolor_to_xrgb1555()
{
    printf("   truecolor -> xrgb1555\n");

    printf("     checking one-to-one...\n");

    for (unsigned int i = 0; i <= 0x00007FFF; i++)
    {
        integer16 a = (integer16)i;
        integer32 b;
        integer16 c;

        convert_XRGB1555_to_XRGB8888(&a, &b, 1);
        convert_XRGB8888_to_XRGB1555(&b, &c, 1);

        if (a != c)
        {
            printf("     failed: %d -> %d -> %d\n", a, b, c);
            exit(1);
        }
    }

    printf("     checking black\n");

    integer16 input = 0;
    integer32 output;

    convert_XRGB1555_to_XRGB8888(&input, &output, 1);

    if (output != 0)
    {
        printf("     black test failed: %d\n", output);
        exit(1);
    }

    printf("     checking maximum red\n");

    input = 0x7C00;

    convert_XRGB1555_to_XRGB8888(&input, &output, 1);

    if (output != 0x00F80000) // note: slightly reduced dynamic range
    {
        printf("     red test failed: %d\n", output);
        exit(1);
    }

    printf("     checking maximum green\n");

    input = 0x000003E0;

    convert_XRGB1555_to_XRGB8888(&input, &output, 1);

    if (output != 0x0000F800)
    {
        printf("     green test failed: %d\n", output);
        exit(1);
    }

    printf("     checking maximum blue\n");

    input = 0x0000001F;

    convert_XRGB1555_to_XRGB8888(&input, &output, 1);

    if (output != 0x000000F8)
    {
        printf("     blue test failed: %d\n", output);
        exit(1);
    }

    printf("     checking red channel\n");
    {
        const int steps = 32;

        int distinctValues = 0;

        integer32 previousDistinctValue = 0xFFFFFFFF;

        for (int i = 0; i < steps; i++)
        {
            input = (integer16)i << 10;

            convert_XRGB1555_to_XRGB8888(&input, &output, 1);

            if (output & 0x0000FFFF)
            {
                printf("     red channel polluted other channels: %d -> %d\n", input, output);
                exit(1);
            }

            if (output != previousDistinctValue)
            {
                if (output < previousDistinctValue && previousDistinctValue != 0xFFFFFFFF)
                {
                    printf("     red channel monotonic non-decreasing check failed: %d->%d\n", previousDistinctValue, output);
                    exit(1);
                }

                distinctValues++;
                previousDistinctValue = output;
            }
        }

        if (distinctValues != 32)
        {
            printf("     red channel distinct value check failed: %d distinct values\n", distinctValues);
            exit(1);
        }
    }

    printf("     checking green channel\n");
    {
        const int steps = 32;

        int distinctValues = 0;

        integer32 previousDistinctValue = 0xFFFFFFFF;

        for (int i = 0; i < steps; i++)
        {
            input = (integer16)i << 5;

            convert_XRGB1555_to_XRGB8888(&input, &output, 1);

            if (output & 0x00FF00FF)
            {
                printf("     green channel polluted other channels: %d -> %d\n", input, output);
                exit(1);
            }

            if (output != previousDistinctValue)
            {
                if (output < previousDistinctValue && previousDistinctValue != 0xFFFFFFFF)
                {
                    printf("     green channel monotonic non-decreasing check failed: %d->%d\n", previousDistinctValue, output);
                    exit(1);
                }

                distinctValues++;
                previousDistinctValue = output;
            }
        }

        if (distinctValues != 32)
        {
            printf("     green channel distinct value check failed: %d distinct values\n", distinctValues);
            exit(1);
        }
    }

    printf("     checking blue channel\n");
    {
        const int steps = 32;

        int distinctValues = 0;

        integer32 previousDistinctValue = 0xFFFFFFFF;

        for (int i = 0; i < steps; i++)
        {
            input = (integer16)i;

            convert_XRGB1555_to_XRGB8888(&input, &output, 1);

            if (output & 0x00FFFF00)
            {
                printf("     blue channel polluted other channels: %d -> %d\n", input, output);
                exit(1);
            }

            if (output != previousDistinctValue)
            {
                if (output < previousDistinctValue && previousDistinctValue != 0xFFFFFFFF)
                {
                    printf("     blue channel monotonic non-decreasing check failed: %d -> %d\n", previousDistinctValue, output);
                    exit(1);
                }

                distinctValues++;
                previousDistinctValue = output;
            }
        }

        if (distinctValues != 32)
        {
            printf("     blue channel distinct value check failed: %d distinct values\n", distinctValues);
            exit(1);
        }
    }

    printf("     passed.\n\n");
}

void test_truecolor_to_bgr565()
{
    printf("   truecolor -> bgr565\n");

    printf("     checking one-to-one...\n");

    for (unsigned int i = 0; i <= 0x0000FFFF; i++)
    {
        integer16 a = (integer16)i;
        integer32 b;
        integer16 c;

        convert_BGR565_to_XRGB8888(&a, &b, 1);
        convert_XRGB8888_to_BGR565(&b, &c, 1);

        if (a != c)
        {
            printf("     failed: %d -> %d -> %d\n", a, b, c);
            exit(1);
        }
    }

    printf("     checking black\n");

    integer16 input = 0;
    integer32 output;

    convert_BGR565_to_XRGB8888(&input, &output, 1);

    if (output != 0)
    {
        printf("     black test failed: %d\n", output);
        exit(1);
    }

    printf("     checking maximum red\n");

    input = 0x0000001F;

    convert_BGR565_to_XRGB8888(&input, &output, 1);

    if (output != 0x00F80000) // note: slightly reduced dynamic range
    {
        printf("     red test failed: %d\n", output);
        exit(1);
    }

    printf("     checking maximum green\n");

    input = 0x000007E0;

    convert_BGR565_to_XRGB8888(&input, &output, 1);

    if (output != 0x0000FC00)
    {
        printf("     green test failed: %d\n", output);
        exit(1);
    }

    printf("     checking maximum blue\n");

    input = 0xF800;

    convert_BGR565_to_XRGB8888(&input, &output, 1);

    if (output != 0x000000F8)
    {
        printf("     blue test failed: %d\n", output);
        exit(1);
    }

    printf("     checking red channel\n");
    {
        const int steps = 32;

        int distinctValues = 0;

        integer32 previousDistinctValue = 0xFFFFFFFF;

        for (int i = 0; i < steps; i++)
        {
            input = (integer16)i;

            convert_BGR565_to_XRGB8888(&input, &output, 1);

            if (output & 0x0000FFFF)
            {
                printf("     red channel polluted other channels: %d -> %d\n", input, output);
                exit(1);
            }

            if (output != previousDistinctValue)
            {
                if (output < previousDistinctValue && previousDistinctValue != 0xFFFFFFFF)
                {
                    printf("     red channel monotonic non-decreasing check failed: %d->%d\n", previousDistinctValue, output);
                    exit(1);
                }

                distinctValues++;
                previousDistinctValue = output;
            }
        }

        if (distinctValues != 32)
        {
            printf("     red channel distinct value check failed: %d distinct values\n", distinctValues);
            exit(1);
        }
    }

    printf("     checking green channel\n");
    {
        const int steps = 64;

        int distinctValues = 0;

        integer32 previousDistinctValue = 0xFFFFFFFF;

        for (int i = 0; i < steps; i++)
        {
            input = (integer16)i << 5;

            convert_BGR565_to_XRGB8888(&input, &output, 1);

            if (output & 0x00FF00FF)
            {
                printf("     green channel polluted other channels: %d -> %d\n", input, output);
                exit(1);
            }

            if (output != previousDistinctValue)
            {
                if (output < previousDistinctValue && previousDistinctValue != 0xFFFFFFFF)
                {
                    printf("     green channel monotonic non-decreasing check failed: %d->%d\n", previousDistinctValue, output);
                    exit(1);
                }

                distinctValues++;
                previousDistinctValue = output;
            }
        }

        if (distinctValues != 64)
        {
            printf("     green channel distinct value check failed: %d distinct values\n", distinctValues);
            exit(1);
        }
    }

    printf("     checking blue channel\n");
    {
        const int steps = 32;

        int distinctValues = 0;

        integer32 previousDistinctValue = 0xFFFFFFFF;

        for (int i = 0; i < steps; i++)
        {
            input = (integer16)i << 11;

            convert_BGR565_to_XRGB8888(&input, &output, 1);

            if (output & 0x00FFFF00)
            {
                printf("     blue channel polluted other channels: %d -> %d\n", input, output);
                exit(1);
            }

            if (output != previousDistinctValue)
            {
                if (output < previousDistinctValue && previousDistinctValue != 0xFFFFFFFF)
                {
                    printf("     blue channel monotonic non-decreasing check failed: %d->%d\n", previousDistinctValue, output);
                    exit(1);
                }

                distinctValues++;
                previousDistinctValue = output;
            }
        }

        if (distinctValues != 32)
        {
            printf("     blue channel distinct value check failed: %d distinct values\n", distinctValues);
            exit(1);
        }
    }

    printf("     passed.\n\n");
}

void test_truecolor_to_rgb565()
{
    printf("   truecolor -> rgb565\n");

    printf("     checking one-to-one...\n");

    for (unsigned int i = 0; i <= 0x0000FFFF; i++)
    {
        integer16 a = (integer16)i;
        integer32 b;
        integer16 c;

        convert_RGB565_to_XRGB8888(&a, &b, 1);
        convert_XRGB8888_to_RGB565(&b, &c, 1);

        if (a != c)
        {
            printf("     failed: %d -> %d -> %d\n", a, b, c);
            exit(1);
        }
    }

    printf("     checking black\n");

    integer16 input = 0;
    integer32 output;

    convert_RGB565_to_XRGB8888(&input, &output, 1);

    if (output != 0)
    {
        printf("    black test failed: %d\n", output);
        exit(1);
    }

    printf("     checking maximum red\n");

    input = 0xF800;

    convert_RGB565_to_XRGB8888(&input, &output, 1);

    if (output != 0x00F80000) // note: slightly reduced dynamic range
    {
        printf("     red test failed: %d\n", output);
        exit(1);
    }

    printf("     checking maximum green\n");

    input = 0x000007E0;

    convert_RGB565_to_XRGB8888(&input, &output, 1);

    if (output != 0x0000FC00)
    {
        printf("     green test failed: %d\n", output);
        exit(1);
    }

    printf("     checking maximum blue\n");

    input = 0x0000001F;

    convert_RGB565_to_XRGB8888(&input, &output, 1);

    if (output != 0x000000F8)
    {
        printf("     blue test failed: %d\n", output);
        exit(1);
    }

    printf("     checking red channel\n");
    {
        const int steps = 32;

        int distinctValues = 0;

        integer32 previousDistinctValue = 0xFFFFFFFF;

        for (int i = 0; i < steps; i++)
        {
            input = (integer16)(i << 11);

            convert_RGB565_to_XRGB8888(&input, &output, 1);

            if (output & 0x0000FFFF)
            {
                printf("     red channel polluted other channels: %d -> %d\n", input, output);
                exit(1);
            }

            if (output != previousDistinctValue)
            {
                if (output < previousDistinctValue && previousDistinctValue != 0xFFFFFFFF)
                {
                    printf("     red channel monotonic non-decreasing check failed: %d->%d\n", previousDistinctValue, output);
                    exit(1);
                }

                distinctValues++;
                previousDistinctValue = output;
            }
        }

        if (distinctValues != 32)
        {
            printf("     red channel distinct value check failed: %d distinct values\n", distinctValues);
            exit(1);
        }
    }

    printf("     checking green channel\n");
    {
        const int steps = 64;

        int distinctValues = 0;

        integer32 previousDistinctValue = 0xFFFFFFFF;

        for (int i = 0; i < steps; i++)
        {
            input = integer16(i << 5);

            convert_RGB565_to_XRGB8888(&input, &output, 1);

            if (output & 0x00FF00FF)
            {
                printf("     green channel polluted other channels: %d -> %d\n", input, output);
                exit(1);
            }

            if (output != previousDistinctValue)
            {
                if (output < previousDistinctValue && previousDistinctValue != 0xFFFFFFFF)
                {
                    printf("     green channel monotonic non-decreasing check failed: %d->%d\n", previousDistinctValue, output);
                    exit(1);
                }

                distinctValues++;
                previousDistinctValue = output;
            }
        }

        if (distinctValues != 64)
        {
            printf("     green channel distinct value check failed: %d distinct values\n", distinctValues);
            exit(1);
        }
    }

    printf("     checking blue channel\n");
    {
        const int steps = 32;

        int distinctValues = 0;

        integer32 previousDistinctValue = 0xFFFFFFFF;

        for (int i = 0; i < steps; i++)
        {
            input = (integer16)i;

            convert_RGB565_to_XRGB8888(&input, &output, 1);

            if (output & 0x00FFFF00)
            {
                printf("     blue channel polluted other channels: %d -> %d\n", input, output);
                exit(1);
            }

            if (output != previousDistinctValue)
            {
                if (output < previousDistinctValue && previousDistinctValue != 0xFFFFFFFF)
                {
                    printf("     blue channel monotonic non-decreasing check failed: %d->%d\n", previousDistinctValue, output);
                    exit(1);
                }

                distinctValues++;
                previousDistinctValue = output;
            }
        }

        if (distinctValues != 32)
        {
            printf("     blue channel distinct value check failed: %d distinct values\n", distinctValues);
            exit(1);
        }
    }

    printf("     passed.\n\n");
}

void test_truecolor_to_bgr888()
{
    printf("   truecolor -> bgr888\n");

    printf("     checking one-to-one...\n");

    for (unsigned int i = 0; i <= 0x00FFFFFF; i++)
    {
        integer32 a = i;
        integer32 b = 0;
        integer32 c;

        convert_XRGB8888_to_BGR888(&a, (integer8*)&b, 1);
        convert_BGR888_to_XRGB8888((integer8*)&b, &c, 1);

        if (a != c)
        {
            printf("     failed: %d -> %d -> %d\n", a, b, c);
            exit(1);
        }
    }

    printf("     checking black\n");

    integer32 input  = 0;
    integer32 output = 0;

    integer8* output_b = (integer8*)&output;
    integer8* output_g = ((integer8*)&output) + 1;
    integer8* output_r = ((integer8*)&output) + 2;

    convert_XRGB8888_to_BGR888(&input, (integer8*)&output, 1);

    if (output != 0)
    {
        printf("     black test failed: %d\n", output);
        exit(1);
    }

    printf("     checking maximum red\n");

    input = 0x00FF0000;

    convert_XRGB8888_to_BGR888(&input, (integer8*)&output, 1);

    if (*output_r != 0xFF)
    {
        printf("     red test failed: %d (%d,%d,%d)\n", output, *output_r, *output_g, *output_b);
        exit(1);
    }

    printf("     checking maximum green\n");

    input = 0x0000FF00;

    convert_XRGB8888_to_BGR888(&input, (integer8*)&output, 1);

    if (*output_g != 0xFF)
    {
        printf("     red test failed: %d (%d,%d,%d)\n", output, *output_r, *output_g, *output_b);
        exit(1);
    }

    printf("     checking maximum blue\n");

    input = 0x000000FF;

    convert_XRGB8888_to_BGR888(&input, (integer8*)&output, 1);

    if (*output_b != 0xFF)
    {
        printf("     red test failed: %d (%d,%d,%d)\n", output, *output_r, *output_g, *output_b);
        exit(1);
    }

    printf("     checking red channel\n");
    {
        const int steps = 256;

        int distinctValues = 0;

        integer32 previousDistinctValue = 0xFFFFFFFF;

        for (int i = 0; i < steps; i++)
        {
            input = i << 16;

            convert_XRGB8888_to_BGR888(&input, (integer8*)&output, 1);

            if (*output_g || *output_b)
            {
                printf("     red channel polluted other channels: %d -> (%d,%d,%d)\n", input, *output_r, *output_g, *output_b);
                exit(1);
            }

            if (*output_r != previousDistinctValue)
            {
                if (*output_r < previousDistinctValue && previousDistinctValue != 0xFFFFFFFF)
                {
                    printf("     red channel monotonic non-decreasing check failed: %d->%d\n", previousDistinctValue, *output_r);
                    exit(1);
                }

                distinctValues++;
                previousDistinctValue = *output_r;
            }
        }

        if (distinctValues != 256)
        {
            printf("     red channel distinct value check failed: %d distinct values\n", distinctValues);
            exit(1);
        }
    }

    printf("     checking green channel\n");
    {
        const int steps = 256;

        int distinctValues = 0;

        integer32 previousDistinctValue = 0xFFFFFFFF;

        for (int i = 0; i < steps; i++)
        {
            input = i << 8;

            convert_XRGB8888_to_BGR888(&input, (integer8*)&output, 1);

            if (*output_r || *output_b)
            {
                printf("     green channel polluted other channels: %d -> (%d,%d,%d)\n", input, *output_r, *output_g, *output_b);
                exit(1);
            }

            if (*output_g != previousDistinctValue)
            {
                if (*output_g < previousDistinctValue && previousDistinctValue != 0xFFFFFFFF)
                {
                    printf("     green channel monotonic non-decreasing check failed: %d->%d\n", previousDistinctValue, *output_g);
                    exit(1);
                }

                distinctValues++;
                previousDistinctValue = *output_g;
            }
        }

        if (distinctValues != 256)
        {
            printf("     green channel distinct value check failed: %d distinct values\n", distinctValues);
            exit(1);
        }
    }

    printf("     checking blue channel\n");
    {
        const int steps = 256;

        int distinctValues = 0;

        integer32 previousDistinctValue = 0xFFFFFFFF;

        for (int i = 0; i < steps; i++)
        {
            input = i;

            convert_XRGB8888_to_BGR888(&input, (integer8*)&output, 1);

            if (*output_r || *output_g)
            {
                printf("     blue channel polluted other channels: %d -> (%d,%d,%d)\n", input, *output_r, *output_g, *output_b);
                exit(1);
            }

            if (*output_b != previousDistinctValue)
            {
                if (*output_b < previousDistinctValue && previousDistinctValue != 0xFFFFFFFF)
                {
                    printf("     blue channel monotonic non-decreasing check failed: %d->%d\n", previousDistinctValue, *output_b);
                    exit(1);
                }

                distinctValues++;
                previousDistinctValue = *output_b;
            }
        }

        if (distinctValues != 256)
        {
            printf("     blue channel distinct value check failed: %d distinct values\n", distinctValues);
            exit(1);
        }
    }

    printf("     passed.\n\n");
}

void test_truecolor_to_rgb888()
{
    printf("   truecolor -> rgb888\n");

    printf("     checking one-to-one...\n");

    for (unsigned int i = 0; i <= 0x00FFFFFF; i++)
    {
        integer32 a = i;
        integer32 b = 0;
        integer32 c;

        convert_XRGB8888_to_RGB888(&a, (integer8*)&b, 1);
        convert_RGB888_to_XRGB8888((integer8*)&b, &c, 1);

        if (a != c)
        {
            printf("     failed: %d -> %d -> %d\n", a, b, c);
            exit(1);
        }
    }

    printf("     checking black\n");

    integer32 input  = 0;
    integer32 output = 0;

    integer8* output_r = (integer8*)&output;
    integer8* output_g = ((integer8*)&output) + 1;
    integer8* output_b = ((integer8*)&output) + 2;

    convert_XRGB8888_to_RGB888(&input, (integer8*)&output, 1);

    if (output != 0)
    {
        printf("     black test failed: %d\n", output);
        exit(1);
    }

    printf("     checking maximum red\n");

    input = 0x00FF0000;

    convert_XRGB8888_to_RGB888(&input, (integer8*)&output, 1);

    if (*output_r != 0xFF)
    {
        printf("     red test failed: %d (%d,%d,%d)\n", output, *output_r, *output_g, *output_b);
        exit(1);
    }

    printf("     checking maximum green\n");

    input = 0x0000FF00;

    convert_XRGB8888_to_RGB888(&input, (integer8*)&output, 1);

    if (*output_g != 0xFF)
    {
        printf("     red test failed: %d (%d,%d,%d)\n", output, *output_r, *output_g, *output_b);
        exit(1);
    }

    printf("     checking maximum blue\n");

    input = 0x000000FF;

    convert_XRGB8888_to_RGB888(&input, (integer8*)&output, 1);

    if (*output_b != 0xFF)
    {
        printf("     red test failed: %d (%d,%d,%d)\n", output, *output_r, *output_g, *output_b);
        exit(1);
    }

    printf("     checking red channel\n");
    {
        const int steps = 256;

        int distinctValues = 0;

        integer32 previousDistinctValue = 0xFFFFFFFF;

        for (int i = 0; i < steps; i++)
        {
            input = i << 16;

            convert_XRGB8888_to_RGB888(&input, (integer8*)&output, 1);

            if (*output_g || *output_b)
            {
                printf("     red channel polluted other channels: %d -> (%d,%d,%d)\n", input, *output_r, *output_g, *output_b);
                exit(1);
            }

            if (*output_r != previousDistinctValue)
            {
                if (*output_r < previousDistinctValue && previousDistinctValue != 0xFFFFFFFF)
                {
                    printf("     red channel monotonic non-decreasing check failed: %d->%d\n", previousDistinctValue, *output_r);
                    exit(1);
                }

                distinctValues++;
                previousDistinctValue = *output_r;
            }
        }

        if (distinctValues != 256)
        {
            printf("     red channel distinct value check failed: %d distinct values\n", distinctValues);
            exit(1);
        }
    }

    printf("     checking green channel\n");
    {
        const int steps = 256;

        int distinctValues = 0;

        integer32 previousDistinctValue = 0xFFFFFFFF;

        for (int i = 0; i < steps; i++)
        {
            input = i << 8;

            convert_XRGB8888_to_RGB888(&input, (integer8*)&output, 1);

            if (*output_r || *output_b)
            {
                printf("     green channel polluted other channels: %d -> (%d,%d,%d)\n", input, *output_r, *output_g, *output_b);
                exit(1);
            }

            if (*output_g != previousDistinctValue)
            {
                if (*output_g < previousDistinctValue && previousDistinctValue != 0xFFFFFFFF)
                {
                    printf("     green channel monotonic non-decreasing check failed: %d->%d\n", previousDistinctValue, *output_g);
                    exit(1);
                }

                distinctValues++;
                previousDistinctValue = *output_g;
            }
        }

        if (distinctValues != 256)
        {
            printf("     green channel distinct value check failed: %d distinct values\n", distinctValues);
            exit(1);
        }
    }

    printf("     checking blue channel\n");
    {
        const int steps = 256;

        int distinctValues = 0;

        integer32 previousDistinctValue = 0xFFFFFFFF;

        for (int i = 0; i < steps; i++)
        {
            input = i;

            convert_XRGB8888_to_RGB888(&input, (integer8*)&output, 1);

            if (*output_r || *output_g)
            {
                printf("     blue channel polluted other channels: %d -> (%d,%d,%d)\n", input, *output_r, *output_g, *output_b);
                exit(1);
            }

            if (*output_b != previousDistinctValue)
            {
                if (*output_b < previousDistinctValue && previousDistinctValue != 0xFFFFFFFF)
                {
                    printf("     blue channel monotonic non-decreasing check failed: %d->%d\n", previousDistinctValue, *output_b);
                    exit(1);
                }

                distinctValues++;
                previousDistinctValue = *output_b;
            }
        }

        if (distinctValues != 256)
        {
            printf("     blue channel distinct value check failed: %d distinct values\n", distinctValues);
            exit(1);
        }
    }

    printf("     passed.\n\n");
}

void test_truecolor_to_xbgr8888()
{
    printf("   truecolor -> xbgr8888\n");

    printf("     checking one-to-one...\n");

    for (unsigned int i = 0; i <= 0x00FFFFFF; i++)
    {
        integer32 a = i;
        integer32 b;
        integer32 c;

        convert_XRGB8888_to_XBGR8888(&a, &b, 1);
        convert_XBGR8888_to_XRGB8888(&b, &c, 1);

        if (a != c)
        {
            printf("     failed: %d -> %d -> %d\n", a, b, c);
            exit(1);
        }
    }

    printf("     checking black\n");

    integer32 input = 0;
    integer32 output;

    convert_XRGB8888_to_XBGR8888(&input, &output, 1);

    if (output != 0)
    {
        printf("     black test failed: %d\n", output);
        exit(1);
    }

    printf("     checking maximum red\n");

    input = 0x00FF0000;

    convert_XRGB8888_to_XBGR8888(&input, &output, 1);

    if (output != 0x000000FF)
    {
        printf("     red test failed: %d\n", output);
        exit(1);
    }

    printf("     checking maximum green\n");

    input = 0x0000FF00;

    convert_XRGB8888_to_XBGR8888(&input, &output, 1);

    if (output != 0x0000FF00)
    {
        printf("     green test failed: %d\n", output);
        exit(1);
    }

    printf("     checking maximum blue\n");

    input = 0x000000FF;

    convert_XRGB8888_to_XBGR8888(&input, &output, 1);

    if (output != 0x00FF0000)
    {
        printf("     blue test failed: %d\n", output);
        exit(1);
    }

    printf("     checking red channel\n");
    {
        const int steps = 256;

        int distinctValues = 0;

        integer32 previousDistinctValue = 0xFFFFFFFF;

        for (int i = 0; i < steps; i++)
        {
            input = i << 16;

            convert_XRGB8888_to_XBGR8888(&input, &output, 1);

            if (output & 0x00FFFF00)
            {
                printf("     red channel polluted other channels: %d -> %d\n", input, output);
                exit(1);
            }

            if (output != previousDistinctValue)
            {
                if (output < previousDistinctValue && previousDistinctValue != 0xFFFFFFFF)
                {
                    printf("     red channel monotonic non-decreasing check failed: %d->%d\n", previousDistinctValue, output);
                    exit(1);
                }

                distinctValues++;
                previousDistinctValue = output;
            }
        }

        if (distinctValues != 256)
        {
            printf("     red channel distinct value check failed: %d distinct values\n", distinctValues);
            exit(1);
        }
    }

    printf("     checking green channel\n");
    {
        const int steps = 256;

        int distinctValues = 0;

        integer32 previousDistinctValue = 0xFFFFFFFF;

        for (int i = 0; i < steps; i++)
        {
            input = i << 8;

            convert_XRGB8888_to_XBGR8888(&input, &output, 1);

            if (output & 0x00FF00FF)
            {
                printf("     green channel polluted other channels: %d -> %d\n", input, output);
                exit(1);
            }

            if (output != previousDistinctValue)
            {
                if (output < previousDistinctValue && previousDistinctValue != 0xFFFFFFFF)
                {
                    printf("     green channel monotonic non-decreasing check failed: %d->%d\n", previousDistinctValue, output);
                    exit(1);
                }

                distinctValues++;
                previousDistinctValue = output;
            }
        }

        if (distinctValues != 256)
        {
            printf("     green channel distinct value check failed: %d distinct values\n", distinctValues);
            exit(1);
        }
    }

    printf("     checking blue channel\n");
    {
        const int steps = 256;

        int distinctValues = 0;

        integer32 previousDistinctValue = 0xFFFFFFFF;

        for (int i = 0; i < steps; i++)
        {
            input = i;

            convert_XRGB8888_to_XBGR8888(&input, &output, 1);

            if (output & 0x0000FFFF)
            {
                printf("     blue channel polluted other channels: %d -> %d\n", input, output);
                exit(1);
            }

            if (output != previousDistinctValue)
            {
                if (output < previousDistinctValue && previousDistinctValue != 0xFFFFFFFF)
                {
                    printf("     blue channel monotonic non-decreasing check failed: %d->%d\n", previousDistinctValue, output);
                    exit(1);
                }

                distinctValues++;
                previousDistinctValue = output;
            }
        }

        if (distinctValues != 256)
        {
            printf("     blue channel distinct value check failed: %d distinct values\n", distinctValues);
            exit(1);
        }
    }

    printf("     passed.\n\n");
}

void test_floating_point_to_xrgb8888()
{
    printf("   floating point -> xrgb8888\n");

    printf("     checking one-to-one...\n");

    for (unsigned int i = 0; i <= 0x00FFFFFF; i++)
    {
        integer32 a = i;
        Pixel     b;
        integer32 c;

        convert_XRGB8888_to_XBGRFFFF(&a, &b, 1);
        convert_XBGRFFFF_to_XRGB8888(&b, &c, 1);

        if (a != c)
        {
            printf("     failed: %d -> (%f,%f,%f) -> %d\n", a, b.r, b.g, b.b, c);
            exit(1);
        }
    }

    printf("     checking black\n");

    Pixel pixel;
    pixel.r = 0;
    pixel.g = 0;
    pixel.b = 0;

    integer32 value;
    convert_XBGRFFFF_to_XRGB8888(&pixel, &value, 1);

    if (value != 0)
    {
        printf("     black test failed: %d\n", value);
        exit(1);
    }

    printf("     checking maximum red\n");

    pixel.r = 1.0f;
    pixel.g = 0;
    pixel.b = 0;

    convert_XBGRFFFF_to_XRGB8888(&pixel, &value, 1);

    if (value != 0x00FF0000)
    {
        printf("     red test failed: %d\n", value);
        exit(1);
    }

    printf("     checking maximum green\n");

    pixel.r = 0;
    pixel.g = 1.0f;
    pixel.b = 0;

    convert_XBGRFFFF_to_XRGB8888(&pixel, &value, 1);

    if (value != 0x0000FF00)
    {
        printf("     green test failed: %d\n", value);
        exit(1);
    }

    printf("     checking maximum blue\n");

    pixel.r = 0;
    pixel.g = 0;
    pixel.b = 1.0f;

    convert_XBGRFFFF_to_XRGB8888(&pixel, &value, 1);

    if (value != 0x000000FF)
    {
        printf("     blue test failed: %d\n", value);
        exit(1);
    }

    printf("     checking red channel\n");
    {
        const int steps = 10000;

        int distinctValues = 0;

        pixel.r = 0;
        pixel.g = 0;
        pixel.b = 0;

        integer32 previousDistinctValue = 0xFFFFFFFF;

        for (int i = 0; i <= steps; i++)
        {
            pixel.r = (float)i / (float)steps * 10 - 5;

            convert_XBGRFFFF_to_XRGB8888(&pixel, &value, 1);

            if (value & 0x0000FFFF)
            {
                printf("     red channel polluted other channels: (%f,%f,%f) -> %d\n", pixel.r, pixel.g, pixel.b, value);
                exit(1);
            }

            if (value != previousDistinctValue)
            {
                if (value < previousDistinctValue && previousDistinctValue != 0xFFFFFFFF)
                {
                    printf("     red channel monotonic non-decreasing check failed: %d->%d\n", previousDistinctValue, value);
                    exit(1);
                }

                distinctValues++;
                previousDistinctValue = value;
            }
        }

        if (distinctValues != 256)
        {
            printf("     red channel distinct value check failed: %d distinct values\n", distinctValues);
            exit(1);
        }
    }

    printf("     checking green channel\n");
    {
        const int steps = 10000;

        int distinctValues = 0;

        pixel.r = 0;
        pixel.g = 0;
        pixel.b = 0;

        integer32 previousDistinctValue = 0xFFFFFFFF;

        for (int i = 0; i <= steps; i++)
        {
            pixel.g = (float)i / (float)steps * 10 - 5;

            convert_XBGRFFFF_to_XRGB8888(&pixel, &value, 1);

            if (value & 0x00FF00FF)
            {
                printf("     green channel polluted other channels: (%f,%f,%f) -> %d\n", pixel.r, pixel.g, pixel.b, value);
                exit(1);
            }

            if (value != previousDistinctValue)
            {
                if (value < previousDistinctValue && previousDistinctValue != 0xFFFFFFFF)
                {
                    printf("     green channel monotonic non-decreasing check failed: %d->%d\n", previousDistinctValue, value);
                    exit(1);
                }

                distinctValues++;
                previousDistinctValue = value;
            }
        }

        if (distinctValues != 256)
        {
            printf("     green channel distinct value check failed: %d distinct values\n", distinctValues);
            exit(1);
        }
    }

    printf("     checking blue channel\n");
    {
        const int steps = 10000;

        int distinctValues = 0;

        pixel.r = 0;
        pixel.g = 0;
        pixel.b = 0;

        integer32 previousDistinctValue = 0xFFFFFFFF;

        for (int i = 0; i <= steps; i++)
        {
            pixel.b = (float)i / (float)steps * 10 - 5;

            convert_XBGRFFFF_to_XRGB8888(&pixel, &value, 1);

            if (value & 0x00FFFF00)
            {
                printf("     blue channel polluted other channels: (%f,%f,%f) -> %d\n", pixel.r, pixel.g, pixel.b, value);
                exit(1);
            }

            if (value != previousDistinctValue)
            {
                if (value < previousDistinctValue && previousDistinctValue != 0xFFFFFFFF)
                {
                    printf("     blue channel monotonic non-decreasing check failed: %d->%d\n", previousDistinctValue, value);
                    exit(1);
                }

                distinctValues++;
                previousDistinctValue = value;
            }
        }

        if (distinctValues != 256)
        {
            printf("     blue channel distinct value check failed: %d distinct values\n", distinctValues);
            exit(1);
        }
    }

    printf("     passed.\n\n");
}

void test_floating_point_to_xbgr8888()
{
    printf("   floating point -> xbgr8888\n");

    printf("     checking one-to-one...\n");

    for (unsigned int i = 0; i <= 0x00FFFFFF; i++)
    {
        integer32 a = i;
        Pixel     b;
        integer32 c;

        convert_XBGR8888_to_XBGRFFFF(&a, &b, 1);
        convert_XBGRFFFF_to_XBGR8888(&b, &c, 1);

        if (a != c)
        {
            printf("     failed: %d -> (%f,%f,%f) -> %d\n", a, b.r, b.g, b.b, c);
            exit(1);
        }
    }

    printf("     checking black\n");

    Pixel pixel;
    pixel.r = 0;
    pixel.g = 0;
    pixel.b = 0;

    integer32 value;
    convert_XBGRFFFF_to_XBGR8888(&pixel, &value, 1);

    if (value != 0)
    {
        printf("     black test failed: %d\n", value);
        exit(1);
    }

    printf("     checking maximum red\n");

    pixel.r = 1.0f;
    pixel.g = 0;
    pixel.b = 0;

    convert_XBGRFFFF_to_XBGR8888(&pixel, &value, 1);

    if (value != 0x000000FF)
    {
        printf("     red test failed: %d\n", value);
        exit(1);
    }

    printf("     checking maximum green\n");

    pixel.r = 0;
    pixel.g = 1.0f;
    pixel.b = 0;

    convert_XBGRFFFF_to_XBGR8888(&pixel, &value, 1);

    if (value != 0x0000FF00)
    {
        printf("     green test failed: %d\n", value);
        exit(1);
    }

    printf("     checking maximum blue\n");

    pixel.r = 0;
    pixel.g = 0;
    pixel.b = 1.0f;

    convert_XBGRFFFF_to_XBGR8888(&pixel, &value, 1);

    if (value != 0x00FF0000)
    {
        printf("     blue test failed: %d\n", value);
        exit(1);
    }

    printf("     checking red channel\n");
    {
        const int steps = 10000;

        int distinctValues = 0;

        pixel.r = 0;
        pixel.g = 0;
        pixel.b = 0;

        integer32 previousDistinctValue = 0xFFFFFFFF;

        for (int i = 0; i <= steps; i++)
        {
            pixel.r = (float)i / (float)steps * 10 - 5;

            convert_XBGRFFFF_to_XBGR8888(&pixel, &value, 1);

            if (value & 0x00FFFF00)
            {
                printf("     red channel polluted other channels: (%f,%f,%f) -> %d\n", pixel.r, pixel.g, pixel.b, value);
                exit(1);
            }

            if (value != previousDistinctValue)
            {
                if (value < previousDistinctValue && previousDistinctValue != 0xFFFFFFFF)
                {
                    printf("     red channel monotonic non-decreasing check failed: %d->%d\n", previousDistinctValue, value);
                    exit(1);
                }

                distinctValues++;
                previousDistinctValue = value;
            }
        }

        if (distinctValues != 256)
        {
            printf("     red channel distinct value check failed: %d distinct values\n", distinctValues);
            exit(1);
        }
    }

    printf("     checking green channel\n");
    {
        const int steps = 10000;

        int distinctValues = 0;

        pixel.r = 0;
        pixel.g = 0;
        pixel.b = 0;

        integer32 previousDistinctValue = 0xFFFFFFFF;

        for (int i = 0; i <= steps; i++)
        {
            pixel.g = (float)i / (float)steps * 10 - 5;

            convert_XBGRFFFF_to_XBGR8888(&pixel, &value, 1);

            if (value & 0x00FF00FF)
            {
                printf("     green channel polluted other channels: (%f,%f,%f) -> %d\n", pixel.r, pixel.g, pixel.b, value);
                exit(1);
            }

            if (value != previousDistinctValue)
            {
                if (value < previousDistinctValue && previousDistinctValue != 0xFFFFFFFF)
                {
                    printf("     green channel monotonic non-decreasing check failed: %d->%d\n", previousDistinctValue, value);
                    exit(1);
                }

                distinctValues++;
                previousDistinctValue = value;
            }
        }

        if (distinctValues != 256)
        {
            printf("     green channel distinct value check failed: %d distinct values\n", distinctValues);
            exit(1);
        }
    }

    printf("     checking blue channel\n");
    {
        const int steps = 10000;

        int distinctValues = 0;

        pixel.r = 0;
        pixel.g = 0;
        pixel.b = 0;

        integer32 previousDistinctValue = 0xFFFFFFFF;

        for (int i = 0; i <= steps; i++)
        {
            pixel.b = (float)i / (float)steps * 10 - 5;

            convert_XBGRFFFF_to_XBGR8888(&pixel, &value, 1);

            if (value & 0x0000FFFF)
            {
                printf("     blue channel polluted other channels: (%f,%f,%f) -> %d\n", pixel.r, pixel.g, pixel.b, value);
                exit(1);
            }

            if (value != previousDistinctValue)
            {
                if (value < previousDistinctValue && previousDistinctValue != 0xFFFFFFFF)
                {
                    printf("     blue channel monotonic non-decreasing check failed: %d->%d\n", previousDistinctValue, value);
                    exit(1);
                }

                distinctValues++;
                previousDistinctValue = value;
            }
        }

        if (distinctValues != 256)
        {
            printf("     blue channel distinct value check failed: %d distinct values\n", distinctValues);
            exit(1);
        }
    }

    printf("     passed.\n\n");
}

void test_floating_point_to_rgb888()
{
    printf("   floating point -> rgb888\n");

    printf("     checking one-to-one...\n");

    for (unsigned int i = 0; i <= 0x00FFFFFF; i++)
    {
        integer32 r = (i & 0x00FF0000) >> 16;
        integer32 g = (i & 0x0000FF00) >> 8;
        integer32 b = (i & 0x000000FF);

        integer32 a = 0;

        char* bytes = (char*)&a;

        bytes[0] = (integer8)r;
        bytes[1] = (integer8)g;
        bytes[2] = (integer8)b;

        Pixel     pixel;
        integer32 c = 0;

        convert_RGB888_to_XBGRFFFF((integer8*)&a, &pixel, 1);
        convert_XBGRFFFF_to_RGB888(&pixel, (integer8*)&c, 1);

        if (a != c)
        {
            printf("     failed: %d -> (%f,%f,%f) -> %d\n", a, pixel.r, pixel.g, pixel.b, c);
            exit(1);
        }
    }

    printf("     checking black\n");

    Pixel pixel;
    pixel.r = 0;
    pixel.g = 0;
    pixel.b = 0;

    integer32 value = 0;
    convert_XBGRFFFF_to_RGB888(&pixel, (integer8*)&value, 1);

    if (value != 0)
    {
        printf("     black test failed: %d\n", value);
        exit(1);
    }

    printf("     checking maximum red\n");

    pixel.r = 1.0f;
    pixel.g = 0;
    pixel.b = 0;

    convert_XBGRFFFF_to_RGB888(&pixel, (integer8*)&value, 1);

    integer8* r = (integer8*)&value;
    integer8* g = r + 1;
    integer8* b = g + 1;

    if (*r != 0xFF || *g != 0 || *b != 0)
    {
        printf("     red test failed: %d\n", value);
        exit(1);
    }

    printf("     checking maximum green\n");

    pixel.r = 0;
    pixel.g = 1.0f;
    pixel.b = 0;

    convert_XBGRFFFF_to_RGB888(&pixel, (integer8*)&value, 1);

    if (*g != 0xFF || *r != 0 || *b != 0)
    {
        printf("     green test failed: %d\n", value);
        exit(1);
    }

    printf("     checking maximum blue\n");

    pixel.r = 0;
    pixel.g = 0;
    pixel.b = 1.0f;

    convert_XBGRFFFF_to_RGB888(&pixel, (integer8*)&value, 1);

    if (*b != 0xFF || *r != 0 || *g != 0)
    {
        printf("     blue test failed: %d\n", value);
        exit(1);
    }

    printf("     checking red channel\n");
    {
        const int steps = 10000;

        int distinctValues = 0;

        pixel.r = 0;
        pixel.g = 0;
        pixel.b = 0;

        integer32 previousDistinctValue = 0xFFFFFFFF;

        for (int i = 0; i <= steps; i++)
        {
            pixel.r = (float)i / (float)steps * 10 - 5;

            value = 0;

            convert_XBGRFFFF_to_RGB888(&pixel, (integer8*)&value, 1);

            if (*g != 0 || *b != 0)
            {
                printf("     red channel polluted other channels: (%f,%f,%f) -> %d\n", pixel.r, pixel.g, pixel.b, value);
                exit(1);
            }

            if (value != previousDistinctValue)
            {
                if (value < previousDistinctValue && previousDistinctValue != 0xFFFFFFFF)
                {
                    printf("     red channel monotonic non-decreasing check failed: %d->%d\n", previousDistinctValue, value);
                    exit(1);
                }

                distinctValues++;
                previousDistinctValue = value;
            }
        }

        if (distinctValues != 256)
        {
            printf("     red channel distinct value check failed: %d distinct values\n", distinctValues);
            exit(1);
        }
    }

    printf("     checking green channel\n");
    {
        const int steps = 10000;

        int distinctValues = 0;

        pixel.r = 0;
        pixel.g = 0;
        pixel.b = 0;

        integer32 previousDistinctValue = 0xFFFFFFFF;

        for (int i = 0; i <= steps; i++)
        {
            pixel.g = (float)i / (float)steps * 10 - 5;

            value = 0;

            convert_XBGRFFFF_to_RGB888(&pixel, (integer8*)&value, 1);

            if (*r != 0 || *b != 0)
            {
                printf("     green channel polluted other channels: (%f,%f,%f) -> %d\n", pixel.r, pixel.g, pixel.b, value);
                exit(1);
            }

            if (value != previousDistinctValue)
            {
                if (value < previousDistinctValue && previousDistinctValue != 0xFFFFFFFF)
                {
                    printf("     green channel monotonic non-decreasing check failed: %d->%d\n", previousDistinctValue, value);
                    exit(1);
                }

                distinctValues++;
                previousDistinctValue = value;
            }
        }

        if (distinctValues != 256)
        {
            printf("     green channel distinct value check failed: %d distinct values\n", distinctValues);
            exit(1);
        }
    }

    printf("     checking blue channel\n");
    {
        const int steps = 10000;

        int distinctValues = 0;

        pixel.r = 0;
        pixel.g = 0;
        pixel.b = 0;

        integer32 previousDistinctValue = 0xFFFFFFFF;

        for (int i = 0; i <= steps; i++)
        {
            pixel.b = (float)i / (float)steps * 10 - 5;

            value = 0;

            convert_XBGRFFFF_to_RGB888(&pixel, (integer8*)&value, 1);

            if (*r != 0 || *g != 0)
            {
                printf("     blue channel polluted other channels: (%f,%f,%f) -> %d\n", pixel.r, pixel.g, pixel.b, value);
                exit(1);
            }

            if (value != previousDistinctValue)
            {
                if (value < previousDistinctValue && previousDistinctValue != 0xFFFFFFFF)
                {
                    printf("     blue channel monotonic non-decreasing check failed: %d->%d\n", previousDistinctValue, value);
                    exit(1);
                }

                distinctValues++;
                previousDistinctValue = value;
            }
        }

        if (distinctValues != 256)
        {
            printf("     blue channel distinct value check failed: %d distinct values\n", distinctValues);
            exit(1);
        }
    }

    printf("     passed.\n\n");
}

void test_floating_point_to_bgr888()
{
    printf("   floating point -> bgr888\n");

    printf("     checking one-to-one...\n");

    for (unsigned int i = 0; i <= 0x00FFFFFF; i++)
    {
        integer32 r = (i & 0x00FF0000) >> 16;
        integer32 g = (i & 0x0000FF00) >> 8;
        integer32 b = (i & 0x000000FF);

        integer32 a = 0;

        char* bytes = (char*)&a;

        bytes[0] = (integer8)b;
        bytes[1] = (integer8)g;
        bytes[2] = (integer8)r;

        Pixel     pixel;
        integer32 c = 0;

        convert_BGR888_to_XBGRFFFF((integer8*)&a, &pixel, 1);
        convert_XBGRFFFF_to_BGR888(&pixel, (integer8*)&c, 1);

        if (a != c)
        {
            printf("     failed: %d -> (%f,%f,%f) -> %d\n", a, pixel.r, pixel.g, pixel.b, c);
            exit(1);
        }
    }

    printf("     checking black\n");

    Pixel pixel;
    pixel.r = 0;
    pixel.g = 0;
    pixel.b = 0;

    integer32 value = 0;
    convert_XBGRFFFF_to_BGR888(&pixel, (integer8*)&value, 1);

    if (value != 0)
    {
        printf("     black test failed: %d\n", value);
        exit(1);
    }

    printf("     checking maximum red\n");

    pixel.r = 1.0f;
    pixel.g = 0;
    pixel.b = 0;

    convert_XBGRFFFF_to_BGR888(&pixel, (integer8*)&value, 1);

    integer8* b = (integer8*)&value;
    integer8* g = b + 1;
    integer8* r = g + 1;

    if (*r != 0xFF || *g != 0 || *b != 0)
    {
        printf("     red test failed: %d\n", value);
        exit(1);
    }

    printf("     checking maximum green\n");

    pixel.r = 0;
    pixel.g = 1.0f;
    pixel.b = 0;

    convert_XBGRFFFF_to_BGR888(&pixel, (integer8*)&value, 1);

    if (*g != 0xFF || *r != 0 || *b != 0)
    {
        printf("     green test failed: %d\n", value);
        exit(1);
    }

    printf("     checking maximum blue\n");

    pixel.r = 0;
    pixel.g = 0;
    pixel.b = 1.0f;

    convert_XBGRFFFF_to_BGR888(&pixel, (integer8*)&value, 1);

    if (*b != 0xFF || *r != 0 || *g != 0)
    {
        printf("     blue test failed: %d\n", value);
        exit(1);
    }

    printf("     checking red channel\n");
    {
        const int steps = 10000;

        int distinctValues = 0;

        pixel.r = 0;
        pixel.g = 0;
        pixel.b = 0;

        integer32 previousDistinctValue = 0xFFFFFFFF;

        for (int i = 0; i <= steps; i++)
        {
            pixel.r = (float)i / (float)steps * 10 - 5;

            value = 0;

            convert_XBGRFFFF_to_BGR888(&pixel, (integer8*)&value, 1);

            if (*g != 0 || *b != 0)
            {
                printf("     red channel polluted other channels: (%f,%f,%f) -> %d\n", pixel.r, pixel.g, pixel.b, value);
                exit(1);
            }

            if (value != previousDistinctValue)
            {
                if (value < previousDistinctValue && previousDistinctValue != 0xFFFFFFFF)
                {
                    printf("     red channel monotonic non-decreasing check failed: %d->%d\n", previousDistinctValue, value);
                    exit(1);
                }

                distinctValues++;
                previousDistinctValue = value;
            }
        }

        if (distinctValues != 256)
        {
            printf("     red channel distinct value check failed: %d distinct values\n", distinctValues);
            exit(1);
        }
    }

    printf("     checking green channel\n");
    {
        const int steps = 10000;

        int distinctValues = 0;

        pixel.r = 0;
        pixel.g = 0;
        pixel.b = 0;

        integer32 previousDistinctValue = 0xFFFFFFFF;

        for (int i = 0; i <= steps; i++)
        {
            pixel.g = (float)i / (float)steps * 10 - 5;

            value = 0;

            convert_XBGRFFFF_to_BGR888(&pixel, (integer8*)&value, 1);

            if (*r != 0 || *b != 0)
            {
                printf("     green channel polluted other channels: (%f,%f,%f) -> %d\n", pixel.r, pixel.g, pixel.b, value);
                exit(1);
            }

            if (value != previousDistinctValue)
            {
                if (value < previousDistinctValue && previousDistinctValue != 0xFFFFFFFF)
                {
                    printf("     green channel monotonic non-decreasing check failed: %d->%d\n", previousDistinctValue, value);
                    exit(1);
                }

                distinctValues++;
                previousDistinctValue = value;
            }
        }

        if (distinctValues != 256)
        {
            printf("     green channel distinct value check failed: %d distinct values\n", distinctValues);
            exit(1);
        }
    }

    printf("     checking blue channel\n");
    {
        const int steps = 10000;

        int distinctValues = 0;

        pixel.r = 0;
        pixel.g = 0;
        pixel.b = 0;

        integer32 previousDistinctValue = 0xFFFFFFFF;

        for (int i = 0; i <= steps; i++)
        {
            pixel.b = (float)i / (float)steps * 10 - 5;

            value = 0;

            convert_XBGRFFFF_to_BGR888(&pixel, (integer8*)&value, 1);

            if (*r != 0 || *g != 0)
            {
                printf("     blue channel polluted other channels: (%f,%f,%f) -> %d\n", pixel.r, pixel.g, pixel.b, value);
                exit(1);
            }

            if (value != previousDistinctValue)
            {
                if (value < previousDistinctValue && previousDistinctValue != 0xFFFFFFFF)
                {
                    printf("     blue channel monotonic non-decreasing check failed: %d->%d\n", previousDistinctValue, value);
                    exit(1);
                }

                distinctValues++;
                previousDistinctValue = value;
            }
        }

        if (distinctValues != 256)
        {
            printf("     blue channel distinct value check failed: %d distinct values\n", distinctValues);
            exit(1);
        }
    }

    printf("     passed.\n\n");
}

void test_floating_point_to_rgb565()
{
    printf("   floating point -> rgb565\n");

    printf("     checking one-to-one...\n");

    for (unsigned int i = 0; i <= 0x0000FFFF; i++)
    {
        integer16 a = (integer16)i;
        Pixel     b;
        integer16 c;

        convert_RGB565_to_XBGRFFFF(&a, &b, 1);
        convert_XBGRFFFF_to_RGB565(&b, &c, 1);

        if (a != c)
        {
            printf("     failed: %d -> (%f,%f,%f) -> %d\n", a, b.r, b.g, b.b, c);
            exit(1);
        }
    }

    printf("     checking black\n");

    Pixel pixel;
    pixel.r = 0;
    pixel.g = 0;
    pixel.b = 0;

    integer16 value;
    convert_XBGRFFFF_to_RGB565(&pixel, &value, 1);

    if (value != 0)
    {
        printf("     black test failed: %d\n", value);
        exit(1);
    }

    printf("     checking maximum red\n ");

    pixel.r = 1.0f;
    pixel.g = 0;
    pixel.b = 0;

    convert_XBGRFFFF_to_RGB565(&pixel, &value, 1);

    if (value != 0x0000F800)
    {
        printf("     red test failed: %d\n", value);
        exit(1);
    }

    printf("     checking maximum green\n");

    pixel.r = 0;
    pixel.g = 1.0f;
    pixel.b = 0;

    convert_XBGRFFFF_to_RGB565(&pixel, &value, 1);

    if (value != 0x000007E0)
    {
        printf("     green test failed: %d\n", value);
        exit(1);
    }

    printf("     checking maximum blue\n");

    pixel.r = 0;
    pixel.g = 0;
    pixel.b = 1.0f;

    convert_XBGRFFFF_to_RGB565(&pixel, &value, 1);

    if (value != 0x0000001F)
    {
        printf("     blue test failed: %d\n", value);
        exit(1);
    }

    printf("     checking red channel\n");
    {
        const int steps = 10000;

        int distinctValues = 0;

        pixel.r = 0;
        pixel.g = 0;
        pixel.b = 0;

        integer32 previousDistinctValue = 0xFFFFFFFF;

        for (int i = 0; i <= steps; i++)
        {
            pixel.r = (float)i / (float)steps * 10 - 5;

            convert_XBGRFFFF_to_RGB565(&pixel, &value, 1);

            if (value & ~0x0000F800)
            {
                printf("     red channel polluted other channels: (%f,%f,%f) -> %d\n", pixel.r, pixel.g, pixel.b, value);
                exit(1);
            }

            if (value != previousDistinctValue)
            {
                if (value < previousDistinctValue && previousDistinctValue != 0xFFFFFFFF)
                {
                    printf("     red channel monotonic non-decreasing check failed: %d->%d\n", previousDistinctValue, value);
                    exit(1);
                }

                distinctValues++;
                previousDistinctValue = value;
            }
        }

        if (distinctValues != 32)
        {
            printf("     red channel distinct value check failed: %d distinct values\n", distinctValues);
            exit(1);
        }
    }

    printf("     checking green channel\n");
    {
        const int steps = 10000;

        int distinctValues = 0;

        pixel.r = 0;
        pixel.g = 0;
        pixel.b = 0;

        integer32 previousDistinctValue = 0xFFFFFFFF;

        for (int i = 0; i <= steps; i++)
        {
            pixel.g = (float)i / (float)steps * 10 - 5;

            convert_XBGRFFFF_to_RGB565(&pixel, &value, 1);

            if (value & ~0x000007E0)
            {
                printf("     green channel polluted other channels: (%f,%f,%f) -> %d\n", pixel.r, pixel.g, pixel.b, value);
                exit(1);
            }

            if (value != previousDistinctValue)
            {
                if (value < previousDistinctValue && previousDistinctValue != 0xFFFFFFFF)
                {
                    printf("     green channel monotonic non-decreasing check failed: %d->%d\n", previousDistinctValue, value);
                    exit(1);
                }

                distinctValues++;
                previousDistinctValue = value;
            }
        }

        if (distinctValues != 64)
        {
            printf("     green channel distinct value check failed: %d distinct values\n", distinctValues);
            exit(1);
        }
    }

    printf("     checking blue channel\n");
    {
        const int steps = 10000;

        int distinctValues = 0;

        pixel.r = 0;
        pixel.g = 0;
        pixel.b = 0;

        integer32 previousDistinctValue = 0xFFFFFFFF;

        for (int i = 0; i <= steps; i++)
        {
            pixel.b = (float)i / (float)steps * 10 - 5;

            convert_XBGRFFFF_to_RGB565(&pixel, &value, 1);

            if (value & ~0x0000001F)
            {
                printf("     blue channel polluted other channels: (%f,%f,%f) -> %d\n", pixel.r, pixel.g, pixel.b, value);
                exit(1);
            }

            if (value != previousDistinctValue)
            {
                if (value < previousDistinctValue && previousDistinctValue != 0xFFFFFFFF)
                {
                    printf("     blue channel monotonic non-decreasing check failed: %d->%d\n", previousDistinctValue, value);
                    exit(1);
                }

                distinctValues++;
                previousDistinctValue = value;
            }
        }

        if (distinctValues != 32)
        {
            printf("     blue channel distinct value check failed: %d distinct values\n", distinctValues);
            exit(1);
        }
    }

    printf("     passed.\n\n");
}

void test_floating_point_to_bgr565()
{
    printf("   floating point -> bgr565\n");

    printf("     checking one-to-one...\n");

    for (unsigned int i = 0; i <= 0x0000FFFF; i++)
    {
        integer16 a = (integer16)i;
        Pixel     b;
        integer16 c;

        convert_BGR565_to_XBGRFFFF(&a, &b, 1);
        convert_XBGRFFFF_to_BGR565(&b, &c, 1);

        if (a != c)
        {
            printf("     failed: %d -> (%f,%f,%f) -> %d\n", a, b.r, b.g, b.b, c);
            exit(1);
        }
    }

    printf("     checking black\n");

    Pixel pixel;
    pixel.r = 0;
    pixel.g = 0;
    pixel.b = 0;

    integer16 value;
    convert_XBGRFFFF_to_BGR565(&pixel, &value, 1);

    if (value != 0)
    {
        printf("     black test failed: %d\n", value);
        exit(1);
    }

    printf("     checking maximum red\n");

    pixel.r = 1.0f;
    pixel.g = 0;
    pixel.b = 0;

    convert_XBGRFFFF_to_BGR565(&pixel, &value, 1);

    if (value != 0x0000001F)
    {
        printf("     red test failed: %d\n", value);
        exit(1);
    }

    printf("     checking maximum green\n");

    pixel.r = 0;
    pixel.g = 1.0f;
    pixel.b = 0;

    convert_XBGRFFFF_to_BGR565(&pixel, &value, 1);

    if (value != 0x000007E0)
    {
        printf("     green test failed: %d\n", value);
        exit(1);
    }

    printf("     checking maximum blue\n");

    pixel.r = 0;
    pixel.g = 0;
    pixel.b = 1.0f;

    convert_XBGRFFFF_to_BGR565(&pixel, &value, 1);

    if (value != 0x0000F800)
    {
        printf("     blue test failed: %d\n", value);
        exit(1);
    }

    printf("     checking red channel\n");
    {
        const int steps = 10000;

        int distinctValues = 0;

        pixel.r = 0;
        pixel.g = 0;
        pixel.b = 0;

        integer32 previousDistinctValue = 0xFFFFFFFF;

        for (int i = 0; i <= steps; i++)
        {
            pixel.r = (float)i / (float)steps * 10 - 5;

            convert_XBGRFFFF_to_BGR565(&pixel, &value, 1);

            if (value & ~0x0000001F)
            {
                printf("     red channel polluted other channels: (%f,%f,%f) -> %d\n", pixel.r, pixel.g, pixel.b, value);
                exit(1);
            }

            if (value != previousDistinctValue)
            {
                if (value < previousDistinctValue && previousDistinctValue != 0xFFFFFFFF)
                {
                    printf("     red channel monotonic non-decreasing check failed: %d->%d\n", previousDistinctValue, value);
                    exit(1);
                }

                distinctValues++;
                previousDistinctValue = value;
            }
        }

        if (distinctValues != 32)
        {
            printf("     red channel distinct value check failed: %d distinct values\n", distinctValues);
            exit(1);
        }
    }

    printf("     checking green channel\n");
    {
        const int steps = 10000;

        int distinctValues = 0;

        pixel.r = 0;
        pixel.g = 0;
        pixel.b = 0;

        integer32 previousDistinctValue = 0xFFFFFFFF;

        for (int i = 0; i <= steps; i++)
        {
            pixel.g = (float)i / (float)steps * 10 - 5;

            convert_XBGRFFFF_to_BGR565(&pixel, &value, 1);

            if (value & ~0x000007E0)
            {
                printf("     green channel polluted other channels: (%f,%f,%f) -> %d\n", pixel.r, pixel.g, pixel.b, value);
                exit(1);
            }

            if (value != previousDistinctValue)
            {
                if (value < previousDistinctValue && previousDistinctValue != 0xFFFFFFFF)
                {
                    printf("     green channel monotonic non-decreasing check failed: %d->%d\n", previousDistinctValue, value);
                    exit(1);
                }

                distinctValues++;
                previousDistinctValue = value;
            }
        }

        if (distinctValues != 64)
        {
            printf("     green channel distinct value check failed: %d distinct values\n", distinctValues);
            exit(1);
        }
    }

    printf("     checking blue channel\n");
    {
        const int steps = 10000;

        int distinctValues = 0;

        pixel.r = 0;
        pixel.g = 0;
        pixel.b = 0;

        integer32 previousDistinctValue = 0xFFFFFFFF;

        for (int i = 0; i <= steps; i++)
        {
            pixel.b = (float)i / (float)steps * 10 - 5;

            convert_XBGRFFFF_to_BGR565(&pixel, &value, 1);

            if (value & ~0x0000F800)
            {
                printf("     blue channel polluted other channels: (%f,%f,%f) -> %d\n", pixel.r, pixel.g, pixel.b, value);
                exit(1);
            }

            if (value != previousDistinctValue)
            {
                if (value < previousDistinctValue && previousDistinctValue != 0xFFFFFFFF)
                {
                    printf("     blue channel monotonic non-decreasing check failed: %d->%d\n", previousDistinctValue, value);
                    exit(1);
                }

                distinctValues++;
                previousDistinctValue = value;
            }
        }

        if (distinctValues != 32)
        {
            printf("     blue channel distinct value check failed: %d distinct values\n", distinctValues);
            exit(1);
        }
    }

    printf("     passed.\n\n");
}

void test_floating_point_to_xrgb1555()
{
    printf("   floating point -> xrgb1555\n");

    printf("     checking one-to-one...\n");

    for (unsigned int i = 0; i <= 0x00007FFF; i++)
    {
        integer16 a = (integer16)i;
        Pixel     b;
        integer16 c;

        convert_XRGB1555_to_XBGRFFFF(&a, &b, 1);
        convert_XBGRFFFF_to_XRGB1555(&b, &c, 1);

        if (a != c)
        {
            printf("     failed: %d -> (%f,%f,%f) -> %d\n", a, b.r, b.g, b.b, c);
            exit(1);
        }
    }

    printf("     checking black\n");

    Pixel pixel;
    pixel.r = 0;
    pixel.g = 0;
    pixel.b = 0;

    integer16 value;
    convert_XBGRFFFF_to_XRGB1555(&pixel, &value, 1);

    if (value != 0)
    {
        printf("     black test failed: %d\n", value);
        exit(1);
    }

    printf("     checking maximum red\n");

    pixel.r = 1.0f;
    pixel.g = 0;
    pixel.b = 0;

    convert_XBGRFFFF_to_XRGB1555(&pixel, &value, 1);

    if (value != 0x00007C00)
    {
        printf("     red test failed: %d\n", value);
        exit(1);
    }

    printf("     checking maximum green\n");

    pixel.r = 0;
    pixel.g = 1.0f;
    pixel.b = 0;

    convert_XBGRFFFF_to_XRGB1555(&pixel, &value, 1);

    if (value != 0x000003E0)
    {
        printf("     green test failed: %d\n", value);
        exit(1);
    }

    printf("     checking maximum blue\n");

    pixel.r = 0;
    pixel.g = 0;
    pixel.b = 1.0f;

    convert_XBGRFFFF_to_XRGB1555(&pixel, &value, 1);

    if (value != 0x0000001F)
    {
        printf("     blue test failed: %d\n", value);
        exit(1);
    }

    printf("     checking red channel\n");
    {
        const int steps = 10000;

        int distinctValues = 0;

        pixel.r = 0;
        pixel.g = 0;
        pixel.b = 0;

        integer32 previousDistinctValue = 0xFFFFFFFF;

        for (int i = 0; i <= steps; i++)
        {
            pixel.r = (float)i / (float)steps * 10 - 5;

            convert_XBGRFFFF_to_XRGB1555(&pixel, &value, 1);

            if (value & ~0x00007C00)
            {
                printf("     red channel polluted other channels: (%f,%f,%f) -> %d\n", pixel.r, pixel.g, pixel.b, value);
                exit(1);
            }

            if (value != previousDistinctValue)
            {
                if (value < previousDistinctValue && previousDistinctValue != 0xFFFFFFFF)
                {
                    printf("     red channel monotonic non-decreasing check failed: %d->%d\n", previousDistinctValue, value);
                    exit(1);
                }

                distinctValues++;
                previousDistinctValue = value;
            }
        }

        if (distinctValues != 32)
        {
            printf("     red channel distinct value check failed: %d distinct values\n", distinctValues);
            exit(1);
        }
    }

    printf("     checking green channel\n");
    {
        const int steps = 10000;

        int distinctValues = 0;

        pixel.r = 0;
        pixel.g = 0;
        pixel.b = 0;

        integer32 previousDistinctValue = 0xFFFFFFFF;

        for (int i = 0; i <= steps; i++)
        {
            pixel.g = (float)i / (float)steps * 10 - 5;

            convert_XBGRFFFF_to_XRGB1555(&pixel, &value, 1);

            if (value & ~0x000003E0)
            {
                printf("     green channel polluted other channels: (%f,%f,%f) -> %d\n", pixel.r, pixel.g, pixel.b, value);
                exit(1);
            }

            if (value != previousDistinctValue)
            {
                if (value < previousDistinctValue && previousDistinctValue != 0xFFFFFFFF)
                {
                    printf("     green channel monotonic non-decreasing check failed: %d->%d\n", previousDistinctValue, value);
                    exit(1);
                }

                distinctValues++;
                previousDistinctValue = value;
            }
        }

        if (distinctValues != 32)
        {
            printf("     green channel distinct value check failed: %d distinct values\n", distinctValues);
            exit(1);
        }
    }

    printf("     checking blue channel\n");
    {
        const int steps = 10000;

        int distinctValues = 0;

        pixel.r = 0;
        pixel.g = 0;
        pixel.b = 0;

        integer32 previousDistinctValue = 0xFFFFFFFF;

        for (int i = 0; i <= steps; i++)
        {
            pixel.b = (float)i / (float)steps * 10 - 5;

            convert_XBGRFFFF_to_XRGB1555(&pixel, &value, 1);

            if (value & ~0x0000001F)
            {
                printf("     blue channel polluted other channels: (%f,%f,%f) -> %d\n", pixel.r, pixel.g, pixel.b, value);
                exit(1);
            }

            if (value != previousDistinctValue)
            {
                if (value < previousDistinctValue && previousDistinctValue != 0xFFFFFFFF)
                {
                    printf("     blue channel monotonic non-decreasing check failed: %d->%d\n", previousDistinctValue, value);
                    exit(1);
                }

                distinctValues++;
                previousDistinctValue = value;
            }
        }

        if (distinctValues != 32)
        {
            printf("     blue channel distinct value check failed: %d distinct values\n", distinctValues);
            exit(1);
        }
    }

    printf("     passed.\n\n");
}

void test_floating_point_to_xbgr1555()
{
    printf("   floating point -> xbgr1555\n");

    printf("     checking one-to-one...\n");

    for (unsigned int i = 0; i <= 0x00007FFF; i++)
    {
        integer16 a = (integer16)i;
        Pixel     b;
        integer16 c;

        convert_XBGR1555_to_XBGRFFFF(&a, &b, 1);
        convert_XBGRFFFF_to_XBGR1555(&b, &c, 1);

        if (a != c)
        {
            printf("     failed: %d -> (%f,%f,%f) -> %d\n", a, b.r, b.g, b.b, c);
            exit(1);
        }
    }

    printf("     checking black\n");

    Pixel pixel;
    pixel.r = 0;
    pixel.g = 0;
    pixel.b = 0;

    integer16 value;
    convert_XBGRFFFF_to_XBGR1555(&pixel, &value, 1);

    if (value != 0)
    {
        printf("     black test failed: %d\n", value);
        exit(1);
    }

    printf("     checking maximum red\n");

    pixel.r = 1.0f;
    pixel.g = 0;
    pixel.b = 0;

    convert_XBGRFFFF_to_XBGR1555(&pixel, &value, 1);

    if (value != 0x0000001F)
    {
        printf("     red test failed: %d\n", value);
        exit(1);
    }

    printf("     checking maximum green\n");

    pixel.r = 0;
    pixel.g = 1.0f;
    pixel.b = 0;

    convert_XBGRFFFF_to_XBGR1555(&pixel, &value, 1);

    if (value != 0x000003E0)
    {
        printf("     green test failed: %d\n", value);
        exit(1);
    }

    printf("     checking maximum blue\n");

    pixel.r = 0;
    pixel.g = 0;
    pixel.b = 1.0f;

    convert_XBGRFFFF_to_XBGR1555(&pixel, &value, 1);

    if (value != 0x00007C00)
    {
        printf("     blue test failed: %d\n", value);
        exit(1);
    }

    printf("     checking red channel\n");
    {
        const int steps = 10000;

        int distinctValues = 0;

        pixel.r = 0;
        pixel.g = 0;
        pixel.b = 0;

        integer32 previousDistinctValue = 0xFFFFFFFF;

        for (int i = 0; i <= steps; i++)
        {
            pixel.r = (float)i / (float)steps * 10 - 5;

            convert_XBGRFFFF_to_XBGR1555(&pixel, &value, 1);

            if (value & ~0x0000001F)
            {
                printf("     red channel polluted other channels: (%f,%f,%f) -> %d\n", pixel.r, pixel.g, pixel.b, value);
                exit(1);
            }

            if (value != previousDistinctValue)
            {
                if (value < previousDistinctValue && previousDistinctValue != 0xFFFFFFFF)
                {
                    printf("     red channel monotonic non-decreasing check failed: %d->%d\n", previousDistinctValue, value);
                    exit(1);
                }

                distinctValues++;
                previousDistinctValue = value;
            }
        }

        if (distinctValues != 32)
        {
            printf("     red channel distinct value check failed: %d distinct values\n", distinctValues);
            exit(1);
        }
    }

    printf("     checking green channel\n");
    {
        const int steps = 10000;

        int distinctValues = 0;

        pixel.r = 0;
        pixel.g = 0;
        pixel.b = 0;

        integer32 previousDistinctValue = 0xFFFFFFFF;

        for (int i = 0; i <= steps; i++)
        {
            pixel.g = (float)i / (float)steps * 10 - 5;

            convert_XBGRFFFF_to_XBGR1555(&pixel, &value, 1);

            if (value & ~0x000003E0)
            {
                printf("     green channel polluted other channels: (%f,%f,%f) -> %d\n", pixel.r, pixel.g, pixel.b, value);
                exit(1);
            }

            if (value != previousDistinctValue)
            {
                if (value < previousDistinctValue && previousDistinctValue != 0xFFFFFFFF)
                {
                    printf("     green channel monotonic non-decreasing check failed: %d->%d\n", previousDistinctValue, value);
                    exit(1);
                }

                distinctValues++;
                previousDistinctValue = value;
            }
        }

        if (distinctValues != 32)
        {
            printf("     green channel distinct value check failed: %d distinct values\n", distinctValues);
            exit(1);
        }
    }

    printf("     checking blue channel\n");
    {
        const int steps = 10000;

        int distinctValues = 0;

        pixel.r = 0;
        pixel.g = 0;
        pixel.b = 0;

        integer32 previousDistinctValue = 0xFFFFFFFF;

        for (int i = 0; i <= steps; i++)
        {
            pixel.b = (float)i / (float)steps * 10 - 5;

            convert_XBGRFFFF_to_XBGR1555(&pixel, &value, 1);

            if (value & ~0x00007C00)
            {
                printf("     blue channel polluted other channels: (%f,%f,%f) -> %d\n", pixel.r, pixel.g, pixel.b, value);
                exit(1);
            }

            if (value != previousDistinctValue)
            {
                if (value < previousDistinctValue && previousDistinctValue != 0xFFFFFFFF)
                {
                    printf("     blue channel monotonic non-decreasing check failed: %d->%d\n", previousDistinctValue, value);
                    exit(1);
                }

                distinctValues++;
                previousDistinctValue = value;
            }
        }

        if (distinctValues != 32)
        {
            printf("     blue channel distinct value check failed: %d distinct values\n", distinctValues);
            exit(1);
        }
    }

    printf("     passed.\n\n");
}

void test_conversion()
{
    printf("testing pixel format conversion:\n\n");

    test_truecolor_to_truecolor();
    test_truecolor_to_xbgr1555();
    test_truecolor_to_xrgb1555();
    test_truecolor_to_bgr565();
    test_truecolor_to_rgb565();
    test_truecolor_to_bgr888();
    test_truecolor_to_rgb888();
    test_truecolor_to_xbgr8888();

    test_floating_point_to_xrgb8888();
    test_floating_point_to_xbgr8888();
    test_floating_point_to_rgb888();
    test_floating_point_to_bgr888();
    test_floating_point_to_rgb565();
    test_floating_point_to_bgr565();
    test_floating_point_to_xrgb1555();
    test_floating_point_to_xbgr1555();
}

// ----------------------------------------------------------------------------------------

int main()
{
    printf("\n[ PixelToaster Test Suite ]\n\n");

    test_conversion();
    test_converter_objects();

    printf("test completed successfully!\n\n");

    return 0;
}