///////////////////////////////////////////////////////////////////////////////
// Name:        tests/image/image.cpp
// Purpose:     Test wxImage
// Author:      Francesco Montorsi
// Created:     2009-05-31
// Copyright:   (c) 2009 Francesco Montorsi
// Licence:     wxWindows licence
///////////////////////////////////////////////////////////////////////////////

// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------

#include "testprec.h"

#if wxUSE_IMAGE


#ifndef WX_PRECOMP
#endif // WX_PRECOMP

#include "wx/anidecod.h" // wxImageArray
#include "wx/gifdecod.h"
#include "wx/bitmap.h"
#include "wx/cursor.h"
#include "wx/icon.h"
#include "wx/palette.h"
#include "wx/url.h"
#include "wx/log.h"
#include "wx/mstream.h"
#include "wx/zstream.h"
#include "wx/wfstream.h"
#include "wx/clipbrd.h"
#include "wx/dataobj.h"
#include "wx/utils.h"

// Check if we can use wxDIB::ConvertToBitmap(), which only exists for MSW and
// which assumes the target is little-endian (matching the file format)
#if defined(__WXMSW__) && wxUSE_WXDIB && wxBYTE_ORDER == wxLITTLE_ENDIAN
    #define CAN_LOAD_BITMAP_DIRECTLY

    #include "wx/msw/dib.h"
#endif

#include "testimage.h"

#include <memory>

#define CHECK_EQUAL_COLOUR_RGB(c1, c2) \
    CHECK( (int)c1.Red()   == (int)c2.Red() ); \
    CHECK( (int)c1.Green() == (int)c2.Green() ); \
    CHECK( (int)c1.Blue()  == (int)c2.Blue() )

#define CHECK_EQUAL_COLOUR_RGBA(c1, c2) \
    CHECK( (int)c1.Red()   == (int)c2.Red() ); \
    CHECK( (int)c1.Green() == (int)c2.Green() ); \
    CHECK( (int)c1.Blue()  == (int)c2.Blue() ); \
    CHECK( (int)c1.Alpha() == (int)c2.Alpha() )

struct testData {
    const char* file;
    wxBitmapType type;
    unsigned bitDepth;
} g_testfiles[] =
{
#if wxUSE_LIBWEBP
    { "horse.webp", wxBITMAP_TYPE_WEBP, 24 },
#endif // wxUSE_LIBWEBP
    { "horse.ico", wxBITMAP_TYPE_ICO, 4 },
    { "horse.xpm", wxBITMAP_TYPE_XPM, 8 },
    { "horse.png", wxBITMAP_TYPE_PNG, 24 },
    { "horse.ani", wxBITMAP_TYPE_ANI, 24 },
    { "horse.bmp", wxBITMAP_TYPE_BMP, 8 },
    { "horse.cur", wxBITMAP_TYPE_CUR, 1 },
    { "horse.gif", wxBITMAP_TYPE_GIF, 8 },
    { "horse.jpg", wxBITMAP_TYPE_JPEG, 24 },
    { "horse.pcx", wxBITMAP_TYPE_PCX, 8 },
    { "horse.pnm", wxBITMAP_TYPE_PNM, 24 },
    { "horse.tga", wxBITMAP_TYPE_TGA, 8 },
    { "horse.tif", wxBITMAP_TYPE_TIFF, 8 }
};


class ImageHandlersInit
{
public:
    ImageHandlersInit();

private:
    static bool ms_initialized;

    wxDECLARE_NO_COPY_CLASS(ImageHandlersInit);
};

bool ImageHandlersInit::ms_initialized = false;

ImageHandlersInit::ImageHandlersInit()
{
    if ( ms_initialized )
        return;

    ms_initialized = true;

    // the formats we're going to test:
#if wxUSE_LIBWEBP
    wxImage::AddHandler(new wxWEBPHandler);
#endif // wxUSE_LIBWEBP
    wxImage::AddHandler(new wxICOHandler);
    wxImage::AddHandler(new wxXPMHandler);
    wxImage::AddHandler(new wxPNGHandler);
    wxImage::AddHandler(new wxANIHandler);
    wxImage::AddHandler(new wxBMPHandler);
    wxImage::AddHandler(new wxCURHandler);
#if wxUSE_GIF
    wxImage::AddHandler(new wxGIFHandler);
#endif // wxUSE_GIF
    wxImage::AddHandler(new wxJPEGHandler);
    wxImage::AddHandler(new wxPCXHandler);
    wxImage::AddHandler(new wxPNMHandler);
    wxImage::AddHandler(new wxTGAHandler);
#if wxUSE_LIBTIFF
    wxImage::AddHandler(new wxTIFFHandler);
#endif // wxUSE_LIBTIFF
}

TEST_CASE_METHOD(ImageHandlersInit, "wxImage::LoadFromFile", "[image]")
{
    wxImage img;
    for (unsigned int i=0; i<WXSIZEOF(g_testfiles); i++)
    {
        const wxString file(g_testfiles[i].file);
        INFO("Loading " << file);
        CHECK(img.LoadFile(file));
    }

    CHECK(img.LoadFile("image/bitfields.bmp", wxBITMAP_TYPE_BMP));
}

#if wxUSE_URL

TEST_CASE_METHOD(ImageHandlersInit, "wxImage::LoadFromSocketStream", "[image]")
{
    // This test doesn't work any more even using the IP address below as the
    // HTTP server now redirects everything to HTTPs, so skip it for now unless
    // a test URL pointing to a PNG image is defined.
    wxString urlStr;
    if ( !wxGetEnv("WX_TEST_IMAGE_URL_PNG", &urlStr) )
        return;

    wxSocketInitializer socketInit;

    wxURL url(urlStr);
    REQUIRE( url.GetError() == wxURL_NOERR );

    std::unique_ptr<wxInputStream> in_stream(url.GetInputStream());
    REQUIRE( in_stream );
    REQUIRE( in_stream->IsOk() );

    wxImage img;

    // NOTE: it's important to inform wxImage about the type of the image being
    //       loaded otherwise it will try to autodetect the format, but that
    //       requires a seekable stream!
    CHECK( img.LoadFile(*in_stream, wxBITMAP_TYPE_PNG) );
}

#endif // wxUSE_URL

TEST_CASE_METHOD(ImageHandlersInit, "wxImage::LoadFromZipStream", "[image]")
{
    for (unsigned int i=0; i<WXSIZEOF(g_testfiles); i++)
    {
        SECTION(std::string("Testing file ") + g_testfiles[i].file)
        {
            switch (g_testfiles[i].type)
            {
                case wxBITMAP_TYPE_XPM:
                case wxBITMAP_TYPE_GIF:
                case wxBITMAP_TYPE_PCX:
                case wxBITMAP_TYPE_TGA:
                case wxBITMAP_TYPE_TIFF:
                continue;       // skip testing those wxImageHandlers which cannot
                                // load data from non-seekable streams

                default:
                    ; // proceed
            }

            // compress the test file on the fly:
            wxMemoryOutputStream memOut;
            {
                wxFileInputStream file(g_testfiles[i].file);
                REQUIRE(file.IsOk());

                wxZlibOutputStream compressFilter(memOut, 5, wxZLIB_GZIP);
                REQUIRE(compressFilter.IsOk());

                file.Read(compressFilter);
                REQUIRE(file.GetLastError() == wxSTREAM_EOF);
            }

            // now fetch the compressed memory to wxImage, decompressing it on the fly; this
            // allows us to test loading images from non-seekable streams other than socket streams
            wxMemoryInputStream memIn(memOut);
            REQUIRE(memIn.IsOk());
            wxZlibInputStream decompressFilter(memIn, wxZLIB_GZIP);
            REQUIRE(decompressFilter.IsOk());

            wxImage img;

            // NOTE: it's important to inform wxImage about the type of the image being
            //       loaded otherwise it will try to autodetect the format, but that
            //       requires a seekable stream!
            CHECK( img.LoadFile(decompressFilter, g_testfiles[i].type) );
        }
    }
}

TEST_CASE_METHOD(ImageHandlersInit, "wxImage::SizeImage", "[image]")
{
   // Test the wxImage::Size() function which takes a rectangle from source and
   // places it in a new image at a given position. This test checks, if the
   // correct areas are chosen, and clipping is done correctly.

   // our test image:
   static const char * xpm_orig[] = {
      "10 10 5 1", "B c Black", "  c #00ff00", ". c #0000ff", "+ c #7f7f7f", "@ c #FF0000",
      "     .....",
      " ++++@@@@.",
      " +...   @.",
      " +.@@++ @.",
      " +.@ .+ @.",
      ".@ +. @.+ ",
      ".@ ++@@.+ ",
      ".@   ...+ ",
      ".@@@@++++ ",
      ".....     "
   };
   // the expected results for all tests:
   static const char * xpm_l_t[] = {
      "10 10 5 1", "B c Black", "  c #00ff00", ". c #0000ff", "+ c #7f7f7f", "@ c #FF0000",
      "...   @.BB",
      ".@@++ @.BB",
      ".@ .+ @.BB",
      " +. @.+ BB",
      " ++@@.+ BB",
      "   ...+ BB",
      "@@@++++ BB",
      "...     BB",
      "BBBBBBBBBB",
      "BBBBBBBBBB"
   };
   static const char * xpm_t[] = {
      "10 10 5 1", "B c Black", "  c #00ff00", ". c #0000ff", "+ c #7f7f7f", "@ c #FF0000",
      " +...   @.",
      " +.@@++ @.",
      " +.@ .+ @.",
      ".@ +. @.+ ",
      ".@ ++@@.+ ",
      ".@   ...+ ",
      ".@@@@++++ ",
      ".....     ",
      "BBBBBBBBBB",
      "BBBBBBBBBB"
   };
   static const char * xpm_r_t[] = {
      "10 10 5 1", "B c Black", "  c #00ff00", ". c #0000ff", "+ c #7f7f7f", "@ c #FF0000",
      "BB +...   ",
      "BB +.@@++ ",
      "BB +.@ .+ ",
      "BB.@ +. @.",
      "BB.@ ++@@.",
      "BB.@   ...",
      "BB.@@@@+++",
      "BB.....   ",
      "BBBBBBBBBB",
      "BBBBBBBBBB"
   };
   static const char * xpm_l[] = {
      "10 10 5 1", "B c Black", "  c #00ff00", ". c #0000ff", "+ c #7f7f7f", "@ c #FF0000",
      "   .....BB",
      "+++@@@@.BB",
      "...   @.BB",
      ".@@++ @.BB",
      ".@ .+ @.BB",
      " +. @.+ BB",
      " ++@@.+ BB",
      "   ...+ BB",
      "@@@++++ BB",
      "...     BB"
   };
   static const char * xpm_r[] = {
      "10 10 5 1", "B c Black", "  c #00ff00", ". c #0000ff", "+ c #7f7f7f", "@ c #FF0000",
      "BB     ...",
      "BB ++++@@@",
      "BB +...   ",
      "BB +.@@++ ",
      "BB +.@ .+ ",
      "BB.@ +. @.",
      "BB.@ ++@@.",
      "BB.@   ...",
      "BB.@@@@+++",
      "BB.....   "
   };
   static const char * xpm_l_b[] = {
      "10 10 5 1", "B c Black", "  c #00ff00", ". c #0000ff", "+ c #7f7f7f", "@ c #FF0000",
      "BBBBBBBBBB",
      "BBBBBBBBBB",
      "   .....BB",
      "+++@@@@.BB",
      "...   @.BB",
      ".@@++ @.BB",
      ".@ .+ @.BB",
      " +. @.+ BB",
      " ++@@.+ BB",
      "   ...+ BB"
   };
   static const char * xpm_b[] = {
      "10 10 5 1", "B c Black", "  c #00ff00", ". c #0000ff", "+ c #7f7f7f", "@ c #FF0000",
      "BBBBBBBBBB",
      "BBBBBBBBBB",
      "     .....",
      " ++++@@@@.",
      " +...   @.",
      " +.@@++ @.",
      " +.@ .+ @.",
      ".@ +. @.+ ",
      ".@ ++@@.+ ",
      ".@   ...+ "
   };
   static const char * xpm_r_b[] = {
      "10 10 5 1", "B c Black", "  c #00ff00", ". c #0000ff", "+ c #7f7f7f", "@ c #FF0000",
      "BBBBBBBBBB",
      "BBBBBBBBBB",
      "BB     ...",
      "BB ++++@@@",
      "BB +...   ",
      "BB +.@@++ ",
      "BB +.@ .+ ",
      "BB.@ +. @.",
      "BB.@ ++@@.",
      "BB.@   ..."
   };
   static const char * xpm_sm[] = {
      "8 8 5 1", "B c Black", "  c #00ff00", ". c #0000ff", "+ c #7f7f7f", "@ c #FF0000",
      "     .....",
      " ++++@@@",
      " +...   ",
      " +.@@++ ",
      " +.@ .+ ",
      ".@ +. @.",
      ".@ ++@@.",
      ".@   ..."
   };
   static const char * xpm_gt[] = {
      "12 12 5 1", "B c Black", "  c #00ff00", ". c #0000ff", "+ c #7f7f7f", "@ c #FF0000",
      "     .....BB",
      " ++++@@@@.BB",
      " +...   @.BB",
      " +.@@++ @.BB",
      " +.@ .+ @.BB",
      ".@ +. @.+ BB",
      ".@ ++@@.+ BB",
      ".@   ...+ BB",
      ".@@@@++++ BB",
      ".....     BB",
      "BBBBBBBBBBBB",
      "BBBBBBBBBBBB"
   };
   static const char * xpm_gt_l_t[] = {
      "12 12 5 1", "B c Black", "  c #00ff00", ". c #0000ff", "+ c #7f7f7f", "@ c #FF0000",
      "...   @.BBBB",
      ".@@++ @.BBBB",
      ".@ .+ @.BBBB",
      " +. @.+ BBBB",
      " ++@@.+ BBBB",
      "   ...+ BBBB",
      "@@@++++ BBBB",
      "...     BBBB",
      "BBBBBBBBBBBB",
      "BBBBBBBBBBBB",
      "BBBBBBBBBBBB",
      "BBBBBBBBBBBB"
   };
   static const char * xpm_gt_l[] = {
      "12 12 5 1", "B c Black", "  c #00ff00", ". c #0000ff", "+ c #7f7f7f", "@ c #FF0000",
      "   .....BBBB",
      "+++@@@@.BBBB",
      "...   @.BBBB",
      ".@@++ @.BBBB",
      ".@ .+ @.BBBB",
      " +. @.+ BBBB",
      " ++@@.+ BBBB",
      "   ...+ BBBB",
      "@@@++++ BBBB",
      "...     BBBB",
      "BBBBBBBBBBBB",
      "BBBBBBBBBBBB"
   };
   static const char * xpm_gt_l_b[] = {
      "12 12 5 1", "B c Black", "  c #00ff00", ". c #0000ff", "+ c #7f7f7f", "@ c #FF0000",
      "BBBBBBBBBBBB",
      "BBBBBBBBBBBB",
      "   .....BBBB",
      "+++@@@@.BBBB",
      "...   @.BBBB",
      ".@@++ @.BBBB",
      ".@ .+ @.BBBB",
      " +. @.+ BBBB",
      " ++@@.+ BBBB",
      "   ...+ BBBB",
      "@@@++++ BBBB",
      "...     BBBB"
   };
   static const char * xpm_gt_l_bb[] = {
      "12 12 5 1", "B c Black", "  c #00ff00", ". c #0000ff", "+ c #7f7f7f", "@ c #FF0000",
      "BBBBBBBBBBBB",
      "BBBBBBBBBBBB",
      "BBBBBBBBBBBB",
      "BBBBBBBBBBBB",
      "   .....BBBB",
      "+++@@@@.BBBB",
      "...   @.BBBB",
      ".@@++ @.BBBB",
      ".@ .+ @.BBBB",
      " +. @.+ BBBB",
      " ++@@.+ BBBB",
      "   ...+ BBBB"
   };
   static const char * xpm_gt_t[] = {
      "12 12 5 1", "B c Black", "  c #00ff00", ". c #0000ff", "+ c #7f7f7f", "@ c #FF0000",
      " +...   @.BB",
      " +.@@++ @.BB",
      " +.@ .+ @.BB",
      ".@ +. @.+ BB",
      ".@ ++@@.+ BB",
      ".@   ...+ BB",
      ".@@@@++++ BB",
      ".....     BB",
      "BBBBBBBBBBBB",
      "BBBBBBBBBBBB",
      "BBBBBBBBBBBB",
      "BBBBBBBBBBBB"
   };
   static const char * xpm_gt_b[] = {
      "12 12 5 1", "B c Black", "  c #00ff00", ". c #0000ff", "+ c #7f7f7f", "@ c #FF0000",
      "BBBBBBBBBBBB",
      "BBBBBBBBBBBB",
      "     .....BB",
      " ++++@@@@.BB",
      " +...   @.BB",
      " +.@@++ @.BB",
      " +.@ .+ @.BB",
      ".@ +. @.+ BB",
      ".@ ++@@.+ BB",
      ".@   ...+ BB",
      ".@@@@++++ BB",
      ".....     BB"
   };
   static const char * xpm_gt_bb[] = {
      "12 12 5 1", "B c Black", "  c #00ff00", ". c #0000ff", "+ c #7f7f7f", "@ c #FF0000",
      "BBBBBBBBBBBB",
      "BBBBBBBBBBBB",
      "BBBBBBBBBBBB",
      "BBBBBBBBBBBB",
      "     .....BB",
      " ++++@@@@.BB",
      " +...   @.BB",
      " +.@@++ @.BB",
      " +.@ .+ @.BB",
      ".@ +. @.+ BB",
      ".@ ++@@.+ BB",
      ".@   ...+ BB"
   };
   static const char * xpm_gt_r_t[] = {
      "12 12 5 1", "B c Black", "  c #00ff00", ". c #0000ff", "+ c #7f7f7f", "@ c #FF0000",
      "BB +...   @.",
      "BB +.@@++ @.",
      "BB +.@ .+ @.",
      "BB.@ +. @.+ ",
      "BB.@ ++@@.+ ",
      "BB.@   ...+ ",
      "BB.@@@@++++ ",
      "BB.....     ",
      "BBBBBBBBBBBB",
      "BBBBBBBBBBBB",
      "BBBBBBBBBBBB",
      "BBBBBBBBBBBB"
   };
   static const char * xpm_gt_r[] = {
      "12 12 5 1", "B c Black", "  c #00ff00", ". c #0000ff", "+ c #7f7f7f", "@ c #FF0000",
      "BB     .....",
      "BB ++++@@@@.",
      "BB +...   @.",
      "BB +.@@++ @.",
      "BB +.@ .+ @.",
      "BB.@ +. @.+ ",
      "BB.@ ++@@.+ ",
      "BB.@   ...+ ",
      "BB.@@@@++++ ",
      "BB.....     ",
      "BBBBBBBBBBBB",
      "BBBBBBBBBBBB"
   };
   static const char * xpm_gt_r_b[] = {
      "12 12 5 1", "B c Black", "  c #00ff00", ". c #0000ff", "+ c #7f7f7f", "@ c #FF0000",
      "BBBBBBBBBBBB",
      "BBBBBBBBBBBB",
      "BB     .....",
      "BB ++++@@@@.",
      "BB +...   @.",
      "BB +.@@++ @.",
      "BB +.@ .+ @.",
      "BB.@ +. @.+ ",
      "BB.@ ++@@.+ ",
      "BB.@   ...+ ",
      "BB.@@@@++++ ",
      "BB.....     "
   };
   static const char * xpm_gt_r_bb[] = {
      "12 12 5 1", "B c Black", "  c #00ff00", ". c #0000ff", "+ c #7f7f7f", "@ c #FF0000",
      "BBBBBBBBBBBB",
      "BBBBBBBBBBBB",
      "BBBBBBBBBBBB",
      "BBBBBBBBBBBB",
      "BB     .....",
      "BB ++++@@@@.",
      "BB +...   @.",
      "BB +.@@++ @.",
      "BB +.@ .+ @.",
      "BB.@ +. @.+ ",
      "BB.@ ++@@.+ ",
      "BB.@   ...+ "
   };
   static const char * xpm_gt_rr_t[] = {
      "12 12 5 1", "B c Black", "  c #00ff00", ". c #0000ff", "+ c #7f7f7f", "@ c #FF0000",
      "BBBB +...   ",
      "BBBB +.@@++ ",
      "BBBB +.@ .+ ",
      "BBBB.@ +. @.",
      "BBBB.@ ++@@.",
      "BBBB.@   ...",
      "BBBB.@@@@+++",
      "BBBB.....   ",
      "BBBBBBBBBBBB",
      "BBBBBBBBBBBB",
      "BBBBBBBBBBBB",
      "BBBBBBBBBBBB"
   };
   static const char * xpm_gt_rr[] = {
      "12 12 5 1", "B c Black", "  c #00ff00", ". c #0000ff", "+ c #7f7f7f", "@ c #FF0000",
      "BBBB     ...",
      "BBBB ++++@@@",
      "BBBB +...   ",
      "BBBB +.@@++ ",
      "BBBB +.@ .+ ",
      "BBBB.@ +. @.",
      "BBBB.@ ++@@.",
      "BBBB.@   ...",
      "BBBB.@@@@+++",
      "BBBB.....   ",
      "BBBBBBBBBBBB",
      "BBBBBBBBBBBB"
   };
   static const char * xpm_gt_rr_b[] = {
      "12 12 5 1", "B c Black", "  c #00ff00", ". c #0000ff", "+ c #7f7f7f", "@ c #FF0000",
      "BBBBBBBBBBBB",
      "BBBBBBBBBBBB",
      "BBBB     ...",
      "BBBB ++++@@@",
      "BBBB +...   ",
      "BBBB +.@@++ ",
      "BBBB +.@ .+ ",
      "BBBB.@ +. @.",
      "BBBB.@ ++@@.",
      "BBBB.@   ...",
      "BBBB.@@@@+++",
      "BBBB.....   "
   };
   static const char * xpm_gt_rr_bb[] = {
      "12 12 5 1", "B c Black", "  c #00ff00", ". c #0000ff", "+ c #7f7f7f", "@ c #FF0000",
      "BBBBBBBBBBBB",
      "BBBBBBBBBBBB",
      "BBBBBBBBBBBB",
      "BBBBBBBBBBBB",
      "BBBB     ...",
      "BBBB ++++@@@",
      "BBBB +...   ",
      "BBBB +.@@++ ",
      "BBBB +.@ .+ ",
      "BBBB.@ +. @.",
      "BBBB.@ ++@@.",
      "BBBB.@   ..."
   };
   static const char * xpm_sm_ll_tt[] = {
      "8 8 5 1", "B c Black", "  c #00ff00", ". c #0000ff", "+ c #7f7f7f", "@ c #FF0000",
      " .+ @.BB",
      ". @.+ BB",
      "+@@.+ BB",
      " ...+ BB",
      "@++++ BB",
      ".     BB",
      "BBBBBBBB",
      "BBBBBBBB"
   };
   static const char * xpm_sm_ll_t[] = {
      "8 8 5 1", "B c Black", "  c #00ff00", ". c #0000ff", "+ c #7f7f7f", "@ c #FF0000",
      ".   @.BB",
      "@++ @.BB",
      " .+ @.BB",
      ". @.+ BB",
      "+@@.+ BB",
      " ...+ BB",
      "@++++ BB",
      ".     BB"
   };
   static const char * xpm_sm_ll[] = {
      "8 8 5 1", "B c Black", "  c #00ff00", ". c #0000ff", "+ c #7f7f7f", "@ c #FF0000",
      " .....BB",
      "+@@@@.BB",
      ".   @.BB",
      "@++ @.BB",
      " .+ @.BB",
      ". @.+ BB",
      "+@@.+ BB",
      " ...+ BB"
   };
   static const char * xpm_sm_ll_b[] = {
      "8 8 5 1", "B c Black", "  c #00ff00", ". c #0000ff", "+ c #7f7f7f", "@ c #FF0000",
      "BBBBBBBB",
      "BBBBBBBB",
      " .....BB",
      "+@@@@.BB",
      ".   @.BB",
      "@++ @.BB",
      " .+ @.BB",
      ". @.+ BB"
   };
   static const char * xpm_sm_l_tt[] = {
      "8 8 5 1", "B c Black", "  c #00ff00", ". c #0000ff", "+ c #7f7f7f", "@ c #FF0000",
      ".@ .+ @.",
      " +. @.+ ",
      " ++@@.+ ",
      "   ...+ ",
      "@@@++++ ",
      "...     ",
      "BBBBBBBB",
      "BBBBBBBB"
   };
   static const char * xpm_sm_l_t[] = {
      "8 8 5 1", "B c Black", "  c #00ff00", ". c #0000ff", "+ c #7f7f7f", "@ c #FF0000",
      "...   @.",
      ".@@++ @.",
      ".@ .+ @.",
      " +. @.+ ",
      " ++@@.+ ",
      "   ...+ ",
      "@@@++++ ",
      "...     "
   };
   static const char * xpm_sm_l[] = {
      "8 8 5 1", "B c Black", "  c #00ff00", ". c #0000ff", "+ c #7f7f7f", "@ c #FF0000",
      "   .....",
      "+++@@@@.",
      "...   @.",
      ".@@++ @.",
      ".@ .+ @.",
      " +. @.+ ",
      " ++@@.+ ",
      "   ...+ "
   };
   static const char * xpm_sm_l_b[] = {
      "8 8 5 1", "B c Black", "  c #00ff00", ". c #0000ff", "+ c #7f7f7f", "@ c #FF0000",
      "BBBBBBBB",
      "BBBBBBBB",
      "   .....",
      "+++@@@@.",
      "...   @.",
      ".@@++ @.",
      ".@ .+ @.",
      " +. @.+ "
   };
   static const char * xpm_sm_tt[] = {
      "8 8 5 1", "B c Black", "  c #00ff00", ". c #0000ff", "+ c #7f7f7f", "@ c #FF0000",
      " +.@ .+ ",
      ".@ +. @.",
      ".@ ++@@.",
      ".@   ...",
      ".@@@@+++",
      ".....   ",
      "BBBBBBBB",
      "BBBBBBBB"
   };
   static const char * xpm_sm_t[] = {
      "8 8 5 1", "B c Black", "  c #00ff00", ". c #0000ff", "+ c #7f7f7f", "@ c #FF0000",
      " +...   ",
      " +.@@++ ",
      " +.@ .+ ",
      ".@ +. @.",
      ".@ ++@@.",
      ".@   ...",
      ".@@@@+++",
      ".....   "
   };
   static const char * xpm_sm_b[] = {
      "8 8 5 1", "B c Black", "  c #00ff00", ". c #0000ff", "+ c #7f7f7f", "@ c #FF0000",
      "BBBBBBBB",
      "BBBBBBBB",
      "     ...",
      " ++++@@@",
      " +...   ",
      " +.@@++ ",
      " +.@ .+ ",
      ".@ +. @."
   };
   static const char * xpm_sm_r_tt[] = {
      "8 8 5 1", "B c Black", "  c #00ff00", ". c #0000ff", "+ c #7f7f7f", "@ c #FF0000",
      "BB +.@ .",
      "BB.@ +. ",
      "BB.@ ++@",
      "BB.@   .",
      "BB.@@@@+",
      "BB..... ",
      "BBBBBBBB",
      "BBBBBBBB"
   };
   static const char * xpm_sm_r_t[] = {
      "8 8 5 1", "B c Black", "  c #00ff00", ". c #0000ff", "+ c #7f7f7f", "@ c #FF0000",
      "BB +... ",
      "BB +.@@+",
      "BB +.@ .",
      "BB.@ +. ",
      "BB.@ ++@",
      "BB.@   .",
      "BB.@@@@+",
      "BB..... "
   };
   static const char * xpm_sm_r[] = {
      "8 8 5 1", "B c Black", "  c #00ff00", ". c #0000ff", "+ c #7f7f7f", "@ c #FF0000",
      "BB     .",
      "BB ++++@",
      "BB +... ",
      "BB +.@@+",
      "BB +.@ .",
      "BB.@ +. ",
      "BB.@ ++@",
      "BB.@   ."
   };
   static const char * xpm_sm_r_b[] = {
      "8 8 5 1", "B c Black", "  c #00ff00", ". c #0000ff", "+ c #7f7f7f", "@ c #FF0000",
      "BBBBBBBB",
      "BBBBBBBB",
      "BB     .",
      "BB ++++@",
      "BB +... ",
      "BB +.@@+",
      "BB +.@ .",
      "BB.@ +. "
   };

   // this table defines all tests
   struct SizeTestData
   {
      int w, h, dx, dy;                // first parameters for Size()
      const char **ref_xpm;            // expected result
   } sizeTestData[] =
   {
      { 10, 10,  0,  0, xpm_orig},      // same size, same position
      { 12, 12,  0,  0, xpm_gt},       // target larger, same position
      {  8,  8,  0,  0, xpm_sm},       // target smaller, same position
      { 10, 10, -2, -2, xpm_l_t},      // same size, move left up
      { 10, 10, -2,  0, xpm_l},        // same size, move left
      { 10, 10, -2,  2, xpm_l_b},      // same size, move left down
      { 10, 10,  0, -2, xpm_t},        // same size, move up
      { 10, 10,  0,  2, xpm_b},        // same size, move down
      { 10, 10,  2, -2, xpm_r_t},      // same size, move right up
      { 10, 10,  2,  0, xpm_r},        // same size, move right
      { 10, 10,  2,  2, xpm_r_b},      // same size, move right down
      { 12, 12, -2, -2, xpm_gt_l_t},   // target larger, move left up
      { 12, 12, -2,  0, xpm_gt_l},     // target larger, move left
      { 12, 12, -2,  2, xpm_gt_l_b},   // target larger, move left down
      { 12, 12, -2,  4, xpm_gt_l_bb},  // target larger, move left down
      { 12, 12,  0, -2, xpm_gt_t},     // target larger, move up
      { 12, 12,  0,  2, xpm_gt_b},     // target larger, move down
      { 12, 12,  0,  4, xpm_gt_bb},    // target larger, move down
      { 12, 12,  2, -2, xpm_gt_r_t},   // target larger, move right up
      { 12, 12,  2,  0, xpm_gt_r},     // target larger, move right
      { 12, 12,  2,  2, xpm_gt_r_b},   // target larger, move right down
      { 12, 12,  2,  4, xpm_gt_r_bb},  // target larger, move right down
      { 12, 12,  4, -2, xpm_gt_rr_t},  // target larger, move right up
      { 12, 12,  4,  0, xpm_gt_rr},    // target larger, move right
      { 12, 12,  4,  2, xpm_gt_rr_b},  // target larger, move right down
      { 12, 12,  4,  4, xpm_gt_rr_bb}, // target larger, move right down
      {  8,  8, -4, -4, xpm_sm_ll_tt}, // target smaller, move left up
      {  8,  8, -4, -2, xpm_sm_ll_t},  // target smaller, move left up
      {  8,  8, -4,  0, xpm_sm_ll},    // target smaller, move left
      {  8,  8, -4,  2, xpm_sm_ll_b},  // target smaller, move left down
      {  8,  8, -2, -4, xpm_sm_l_tt},  // target smaller, move left up
      {  8,  8, -2, -2, xpm_sm_l_t},   // target smaller, move left up
      {  8,  8, -2,  0, xpm_sm_l},     // target smaller, move left
      {  8,  8, -2,  2, xpm_sm_l_b},   // target smaller, move left down
      {  8,  8,  0, -4, xpm_sm_tt},    // target smaller, move up
      {  8,  8,  0, -2, xpm_sm_t},     // target smaller, move up
      {  8,  8,  0,  2, xpm_sm_b},     // target smaller, move down
      {  8,  8,  2, -4, xpm_sm_r_tt},  // target smaller, move right up
      {  8,  8,  2, -2, xpm_sm_r_t},   // target smaller, move right up
      {  8,  8,  2,  0, xpm_sm_r},     // target smaller, move right
      {  8,  8,  2,  2, xpm_sm_r_b},   // target smaller, move right down
   };

   const wxImage src_img(xpm_orig);
   for ( unsigned i = 0; i < WXSIZEOF(sizeTestData); i++ )
   {
       SizeTestData& st = sizeTestData[i];
       wxImage
           actual(src_img.Size(wxSize(st.w, st.h), wxPoint(st.dx, st.dy), 0, 0, 0)),
           expected(st.ref_xpm);

       // to check results with an image viewer uncomment this:
       //actual.SaveFile(wxString::Format("imagetest-%02d-actual.png", i), wxBITMAP_TYPE_PNG);
       //expected.SaveFile(wxString::Format("imagetest-%02d-exp.png", i), wxBITMAP_TYPE_PNG);

       wxINFO_FMT("Resize test #%u: (%d, %d), (%d, %d)",
                   i, st.w, st.h, st.dx, st.dy);
       CHECK_THAT( actual, RGBSameAs(expected) );
   }
}

TEST_CASE_METHOD(ImageHandlersInit, "wxImage::CompareLoadedImage", "[image]")
{
    wxImage expected8("horse.xpm");
    REQUIRE( expected8.IsOk() );

    wxImage expected24("horse.png");
    REQUIRE( expected24.IsOk() );

    for (size_t i=0; i<WXSIZEOF(g_testfiles); i++)
    {
        if ( !(g_testfiles[i].bitDepth == 8 || g_testfiles[i].bitDepth == 24))
        {
            continue;
        }

        wxImage actual(g_testfiles[i].file);

        if ( actual.GetSize() != expected8.GetSize() )
        {
            continue;
        }


        wxINFO_FMT("Compare test '%s' for loading", g_testfiles[i].file);
        wxImage & expected = g_testfiles[i].bitDepth == 8 ? expected8 : expected24;
        int tolerance = 0;
        switch (g_testfiles[i].type)
        {
            case wxBITMAP_TYPE_JPEG:
            case wxBITMAP_TYPE_WEBP:
                tolerance = 42; // lossy formats can have a substantial difference
                // this value has been chosen to be okay for the existing JPEG sample
                break;
            default:
                tolerance = 0; // all other formats must match exactly
        }
        CHECK_THAT( actual, RGBSimilarTo( expected, tolerance ) );
    }

}

enum
{
    wxIMAGE_HAVE_ALPHA = (1 << 0),
    wxIMAGE_HAVE_PALETTE = (1 << 1),
    wxIMAGE_HAVE_DELTA_RLE_BITMAP = (1 << 2)
};

static
void CompareImage(const wxImageHandler& handler, const wxImage& image,
    int properties = 0, const wxImage *compareTo = nullptr)
{
    wxBitmapType type = handler.GetType();

    const bool testPalette = (properties & wxIMAGE_HAVE_PALETTE) != 0;
    /*
    This is getting messy and should probably be transformed into a table
    with image format features before it gets hairier.
    */
    if ( testPalette
        && ( !(type == wxBITMAP_TYPE_BMP
                || type == wxBITMAP_TYPE_GIF
                || type == wxBITMAP_TYPE_ICO
                || type == wxBITMAP_TYPE_PNG)
            || type == wxBITMAP_TYPE_XPM) )
    {
        return;
    }

    const bool testAlpha = (properties & wxIMAGE_HAVE_ALPHA) != 0;
    if (testAlpha
        && !(type == wxBITMAP_TYPE_PNG || type == wxBITMAP_TYPE_TGA
            || type == wxBITMAP_TYPE_TIFF) )
    {
        // don't test images with alpha if this handler doesn't support alpha
        return;
    }

    if (type == wxBITMAP_TYPE_JPEG /* skip lossy JPEG */
        || type == wxBITMAP_TYPE_WEBP /* skip lossy WebP */)
    {
        return;
    }

    wxMemoryOutputStream memOut;
    if ( !image.SaveFile(memOut, type) )
    {
        // Unfortunately we can't know if the handler just doesn't support
        // saving images, or if it failed to save.
        return;
    }

    unsigned bitsPerPixel = testPalette ? 8 : (testAlpha ? 32 : 24);
    wxINFO_FMT("Compare test '%s (%d-bit)' for saving",
               handler.GetExtension(), bitsPerPixel);

    wxMemoryInputStream memIn(memOut);
    REQUIRE(memIn.IsOk());

    wxImage actual(memIn);
    REQUIRE(actual.IsOk());

    const wxImage *expected = compareTo ? compareTo : &image;
    CHECK_THAT(actual, RGBSameAs(*expected));

#if wxUSE_PALETTE
    REQUIRE(actual.HasPalette()
        == (testPalette || type == wxBITMAP_TYPE_XPM));
#endif

    REQUIRE( actual.HasAlpha() == testAlpha);

    if (!testAlpha)
    {
        return;
    }

    wxINFO_FMT("Compare alpha test '%s' for saving", handler.GetExtension());
    CHECK_THAT(actual, RGBSameAs(*expected));
}

static void SetAlpha(wxImage *image)
{
    image->SetAlpha();

    unsigned char *ptr = image->GetAlpha();
    const int width = image->GetWidth();
    const int height = image->GetHeight();
    for (int y = 0; y < height; ++y)
    {
        for (int x = 0; x < width; ++x)
        {
            ptr[y*width + x] = (x*y) & wxIMAGE_ALPHA_OPAQUE;
        }
    }
}

TEST_CASE_METHOD(ImageHandlersInit, "wxImage::CompareSavedImage", "[image]")
{
    wxImage expected24("horse.png");
    REQUIRE( expected24.IsOk() );
    REQUIRE( !expected24.HasAlpha() );

    wxImage expected8 = expected24.ConvertToGreyscale();

#if wxUSE_PALETTE
    unsigned char greys[256];
    for (int i = 0; i < 256; ++i)
    {
        greys[i] = i;
    }
    wxPalette palette(256, greys, greys, greys);
    expected8.SetPalette(palette);
#endif // #if wxUSE_PALETTE

    expected8.SetOption(wxIMAGE_OPTION_BMP_FORMAT, wxBMP_8BPP_PALETTE);

    // Create an image with alpha based on the loaded image
    wxImage expected32(expected24);

    SetAlpha(&expected32);

    const wxList& list = wxImage::GetHandlers();
    for ( wxList::compatibility_iterator node = list.GetFirst();
        node; node = node->GetNext() )
    {
        wxImageHandler *handler = (wxImageHandler *) node->GetData();

#if wxUSE_PALETTE
        CompareImage(*handler, expected8, wxIMAGE_HAVE_PALETTE);
#endif
        CompareImage(*handler, expected24);
        CompareImage(*handler, expected32, wxIMAGE_HAVE_ALPHA);
    }
}

TEST_CASE_METHOD(ImageHandlersInit, "wxImage::SavePNG", "[image]")
{
    wxImage expected24("horse.png");
    REQUIRE( expected24.IsOk() );
#if wxUSE_PALETTE
    REQUIRE( !expected24.HasPalette() );
#endif // #if wxUSE_PALETTE

    wxImage expected8 = expected24.ConvertToGreyscale();

    /*
    horse.png converted to greyscale should be saved without a palette.
    */
    CompareImage(*wxImage::FindHandler(wxBITMAP_TYPE_PNG), expected8);

    /*
    But if we explicitly ask for trying to save with a palette, it should work.
    */
    expected8.SetOption(wxIMAGE_OPTION_PNG_FORMAT, wxPNG_TYPE_PALETTE);

    CompareImage(*wxImage::FindHandler(wxBITMAP_TYPE_PNG),
        expected8, wxIMAGE_HAVE_PALETTE);


    REQUIRE( expected8.LoadFile("horse.gif") );
#if wxUSE_PALETTE
    REQUIRE( expected8.HasPalette() );
#endif // #if wxUSE_PALETTE

    CompareImage(*wxImage::FindHandler(wxBITMAP_TYPE_PNG),
        expected8, wxIMAGE_HAVE_PALETTE);

    /*
    Add alpha to the image in such a way that there will still be a maximum
    of 256 unique RGBA combinations. This should result in a saved
    PNG image still being palettised and having alpha.
    */
    expected8.SetAlpha();

    int x, y;
    const int width = expected8.GetWidth();
    const int height = expected8.GetHeight();
    for (y = 0; y < height; ++y)
    {
        for (x = 0; x < width; ++x)
        {
            expected8.SetAlpha(x, y, expected8.GetRed(x, y));
        }
    }

    CompareImage(*wxImage::FindHandler(wxBITMAP_TYPE_PNG),
        expected8, wxIMAGE_HAVE_ALPHA|wxIMAGE_HAVE_PALETTE);

    /*
    Now change the alpha of the first pixel so that we can't save palettised
    anymore because there will be 256+1 entries which is beyond PNGs limit
    of 256 entries.
    */
    expected8.SetAlpha(0, 0, 1);

    CompareImage(*wxImage::FindHandler(wxBITMAP_TYPE_PNG),
        expected8, wxIMAGE_HAVE_ALPHA);

    /*
    Even if we explicitly ask for saving palettised it should not be done.
    */
    expected8.SetOption(wxIMAGE_OPTION_PNG_FORMAT, wxPNG_TYPE_PALETTE);
    CompareImage(*wxImage::FindHandler(wxBITMAP_TYPE_PNG),
        expected8, wxIMAGE_HAVE_ALPHA);

}

static void TestPNGDescription(const wxString& description)
{
    wxImage image("horse.png");

    image.SetOption(wxIMAGE_OPTION_PNG_DESCRIPTION, description);
    wxMemoryOutputStream memOut;
    REQUIRE(image.SaveFile(memOut, wxBITMAP_TYPE_PNG));

    wxMemoryInputStream memIn(memOut);
    REQUIRE(image.LoadFile(memIn));

    CHECK(image.GetOption(wxIMAGE_OPTION_PNG_DESCRIPTION) == description);
}

TEST_CASE_METHOD(ImageHandlersInit, "wxImage::PNGDescription", "[image]")
{
    // Test writing a description and reading it back.
    TestPNGDescription("Providing the PNG a pneumatic puma as a present");

    // Test writing and reading a description again but with non-ASCII characters.
    TestPNGDescription("Тестирование 테스트 一 二 三");

    // Test writing and reading a description again but with a long description.
    TestPNGDescription(wxString(wxT('a'), 256)
        + wxString(wxT('b'), 256)
        + wxString(wxT('c'), 256));
}

#if wxUSE_LIBTIFF
static void TestTIFFImage(const wxString& option, int value,
    const wxImage *compareImage = nullptr)
{
    INFO("Using option " << option << "=" << value);

    wxImage image;
    if (compareImage)
    {
        image = *compareImage;
    }
    else
    {
        (void) image.LoadFile("horse.png");
    }
    REQUIRE( image.IsOk() );

    wxMemoryOutputStream memOut;
    image.SetOption(option, value);

    REQUIRE(image.SaveFile(memOut, wxBITMAP_TYPE_TIFF));

    wxMemoryInputStream memIn(memOut);
    REQUIRE(memIn.IsOk());

    wxImage savedImage(memIn);
    REQUIRE(savedImage.IsOk());

    CHECK( savedImage.HasOption(option) );
    CHECK( savedImage.GetOptionInt(option) == value );
    CHECK( savedImage.HasAlpha() == image.HasAlpha() );
}

TEST_CASE_METHOD(ImageHandlersInit, "wxImage::SaveTIFF", "[image]")
{
    TestTIFFImage(wxIMAGE_OPTION_TIFF_BITSPERSAMPLE, 1);
    TestTIFFImage(wxIMAGE_OPTION_TIFF_SAMPLESPERPIXEL, 1);
    TestTIFFImage(wxIMAGE_OPTION_TIFF_PHOTOMETRIC, 0/*PHOTOMETRIC_MINISWHITE*/);
    TestTIFFImage(wxIMAGE_OPTION_TIFF_PHOTOMETRIC, 1/*PHOTOMETRIC_MINISBLACK*/);

    wxImage alphaImage("horse.png");
    REQUIRE( alphaImage.IsOk() );
    SetAlpha(&alphaImage);

    // RGB with alpha
    TestTIFFImage(wxIMAGE_OPTION_TIFF_SAMPLESPERPIXEL, 4, &alphaImage);

    // Grey with alpha
    TestTIFFImage(wxIMAGE_OPTION_TIFF_SAMPLESPERPIXEL, 2, &alphaImage);

    // B/W with alpha
    alphaImage.SetOption(wxIMAGE_OPTION_TIFF_BITSPERSAMPLE, 1);
    TestTIFFImage(wxIMAGE_OPTION_TIFF_SAMPLESPERPIXEL, 2, &alphaImage);
}
#endif // wxUSE_LIBTIFF

TEST_CASE_METHOD(ImageHandlersInit, "wxImage::ReadCorruptedTGA", "[image]")
{
    static unsigned char corruptTGA[18+1+3] =
    {
        0,
        0,
        10, // RLE compressed image.
        0, 0,
        0, 0,
        0,
        0, 0,
        0, 0,
        1, 0, // Width is 1.
        1, 0, // Height is 1.
        24, // Bits per pixel.
        0,

        0xff, // Run length (repeat next pixel 127+1 times).
        0xff, 0xff, 0xff // One 24-bit pixel.
    };

    wxMemoryInputStream memIn(corruptTGA, WXSIZEOF(corruptTGA));
    REQUIRE(memIn.IsOk());

    wxImage tgaImage;
    REQUIRE( !tgaImage.LoadFile(memIn) );


    /*
    Instead of repeating a pixel 127+1 times, now tell it there will
    follow 127+1 uncompressed pixels (while we only should have 1 in total).
    */
    corruptTGA[18] = 0x7f;
    REQUIRE( !tgaImage.LoadFile(memIn) );

    /*
    A colour-mapped TGA with a non-zero colour-map origin.
    Older code allocated the palette using paletteLength only, but
    indexed it using paletteStart + i, leading to OOB writes.
    */
    static const unsigned char badPaletteTGA[] =
    {
        0,          // ID length
        1,          // Color map type
        1,          // Image type = color mapped

        1, 0,       // Color map origin (paletteStart = 1)
        1, 0,       // Color map length = 1 entry
        24,         // Color map entry size

        0, 0,       // X-origin
        0, 0,       // Y-origin

        1, 0,       // Width = 1
        1, 0,       // Height = 1

        8,          // Bits per pixel
        0,          // Image descriptor

        // One palette entry (BGR)
        0xff, 0x00, 0x00,

        // One pixel index
        0x00
    };

    wxMemoryInputStream badPaletteStream(
        badPaletteTGA,
        WXSIZEOF(badPaletteTGA)
    );

    REQUIRE( badPaletteStream.IsOk() );

    REQUIRE(
        !tgaImage.LoadFile(badPaletteStream, wxBITMAP_TYPE_TGA)
    );
}

TEST_CASE_METHOD(ImageHandlersInit, "wxImage::BadBMPPaletteIndex", "[image][bmp][error]")
{
    // A 4-bit BMP that declares only a single palette entry (biClrUsed = 1)
    // but uses a higher nibble value as the pixel index. The 8-bit decode
    // path rejects indices >= ncolors, but the 4-bit path used to read
    // cmap[index] for any 0..15 nibble, running past the palette array.
    static const unsigned char data[] =
    {
        'B','M',
        0x3e,0,0,0,         // file size = 62
        0,0,0,0,            // reserved
        0x3a,0,0,0,         // pixel data offset = 58

        0x28,0,0,0,         // DIB header size = 40
        1,0,0,0,            // width = 1
        1,0,0,0,            // height = 1
        1,0,                // planes
        4,0,                // bpp = 4
        0,0,0,0,            // compression = BI_RGB
        0,0,0,0,            // image size
        0,0,0,0,            // x ppm
        0,0,0,0,            // y ppm
        1,0,0,0,            // biClrUsed = 1
        0,0,0,0,            // biClrImportant

        0,0,0,0,            // single palette entry (BGRA)

        0xf0,0,0,0          // one scanline, high nibble = 15
    };

    wxMemoryInputStream mis(data, WXSIZEOF(data));
    wxImage img;
    REQUIRE( !img.LoadFile(mis, wxBITMAP_TYPE_BMP) );
}

#if wxUSE_GIF

TEST_CASE_METHOD(ImageHandlersInit, "wxImage::SaveAnimatedGIF", "[image]")
{
#if wxUSE_PALETTE
    wxImage image("horse.gif");
    REQUIRE( image.IsOk() );

    wxImageArray images;
    images.push_back(image);
    for (int i = 0; i < 4-1; ++i)
    {
        images.push_back( images[i].Rotate90() );

        images[i+1].SetPalette(images[0].GetPalette());
    }

    wxMemoryOutputStream memOut;
    REQUIRE( wxGIFHandler().SaveAnimation(images, &memOut) );

    wxGIFHandler handler;
    wxMemoryInputStream memIn(memOut);
    REQUIRE(memIn.IsOk());
    const int imageCount = handler.GetImageCount(memIn);
    CHECK( imageCount == 4 );

    for (int i = 0; i < imageCount; ++i)
    {
        wxFileOffset pos = memIn.TellI();
        REQUIRE( handler.LoadFile(&image, memIn, true, i) );
        memIn.SeekI(pos);

        wxINFO_FMT("Compare test for GIF frame number %d failed", i);
        CHECK_THAT(image, RGBSameAs(images[i]));
    }
#endif // #if wxUSE_PALETTE
}

TEST_CASE_METHOD(ImageHandlersInit, "wxImage::SaveGIFBigPalette", "[image][gif][error]")
{
#if wxUSE_PALETTE
    // An image palette can have more than the 256 entries a GIF supports, for
    // instance when the image was loaded from an XPM declaring a larger colour
    // count. Saving such an image as GIF must not overflow the fixed 256-entry
    // palette buffer used by the encoder; instead the save should fail cleanly.
    const int numColours = 300;
    unsigned char r[numColours], g[numColours], b[numColours];
    for (int i = 0; i < numColours; ++i)
    {
        r[i] = g[i] = b[i] = static_cast<unsigned char>(i);
    }

    wxImage image(1, 1);
    image.SetRGB(0, 0, 0, 0, 0);
    image.SetPalette(wxPalette(numColours, r, g, b));

    wxMemoryOutputStream memOut;
    wxLogNull noLog;
    CHECK( !image.SaveFile(memOut, wxBITMAP_TYPE_GIF) );
#endif // wxUSE_PALETTE
}

static void TestGIFComment(const wxString& comment)
{
    wxImage image("horse.gif");

    image.SetOption(wxIMAGE_OPTION_GIF_COMMENT, comment);
    wxMemoryOutputStream memOut;
    REQUIRE(image.SaveFile(memOut, wxBITMAP_TYPE_GIF));

    wxMemoryInputStream memIn(memOut);
    REQUIRE( image.LoadFile(memIn) );

    CHECK( image.GetOption(wxIMAGE_OPTION_GIF_COMMENT) == comment );
}

TEST_CASE_METHOD(ImageHandlersInit, "wxImage::GIFComment", "[image]")
{
    // Test reading a comment.
    wxImage image("horse.gif");
    CHECK( image.GetOption(wxIMAGE_OPTION_GIF_COMMENT) ==
           "  Imported from GRADATION image: gray" );


    // Test writing a comment and reading it back.
    TestGIFComment("Giving the GIF a gifted giraffe as a gift");


    // Test writing and reading a comment again but with a long comment.
    TestGIFComment(wxString(wxT('a'), 256)
        + wxString(wxT('b'), 256)
        + wxString(wxT('c'), 256));


    // Test writing comments in an animated GIF and reading them back.
    REQUIRE( image.LoadFile("horse.gif") );

#if wxUSE_PALETTE
    wxImageArray images;
    int i;
    for (i = 0; i < 4; ++i)
    {
        if (i)
        {
            images.push_back( images[i-1].Rotate90() );
            images[i].SetPalette(images[0].GetPalette());
        }
        else
        {
            images.push_back(image);
        }

        images[i].SetOption(wxIMAGE_OPTION_GIF_COMMENT,
            wxString::Format("GIF comment for frame #%d", i+1));

    }


    wxMemoryOutputStream memOut;
    REQUIRE( wxGIFHandler().SaveAnimation(images, &memOut) );

    wxGIFHandler handler;
    wxMemoryInputStream memIn(memOut);
    REQUIRE(memIn.IsOk());
    const int imageCount = handler.GetImageCount(memIn);
    for (i = 0; i < imageCount; ++i)
    {
        wxFileOffset pos = memIn.TellI();
        REQUIRE( handler.LoadFile(&image, memIn, true /*verbose?*/, i) );

        CHECK( image.GetOption(wxIMAGE_OPTION_GIF_COMMENT) ==
               wxString::Format("GIF comment for frame #%d", i+1) );
        memIn.SeekI(pos);
    }
#endif //wxUSE_PALETTE
}

TEST_CASE_METHOD(ImageHandlersInit, "wxImage::BadGIF", "[image][gif][error]")
{
    wxImage image("image/bad_truncated.gif");
    REQUIRE( image.IsOk() );

    CHECK( image.GetSize() == wxSize(1200, 800) );
}

TEST_CASE_METHOD(ImageHandlersInit, "wxImage::BadGIFLZWMinCodeSize",
                 "[image][gif][error]")
{
    // The LZW minimum code size byte that follows the local colour table is
    // not validated. dgif() sizes ab_prefix/ab_tail for codes up to 12 bits
    // (allocSize == 4096+1), so a code size of 12 makes ab_free start at 4098
    // and the first alphabet update then writes one entry past the end of
    // both arrays. The 2x1 image below is the minimum needed to exercise the
    // second LZW iteration where the alphabet update happens.
    static const unsigned char data[] =
    {
        0x47, 0x49, 0x46, 0x38, 0x39, 0x61,             // "GIF89a"
        0x02, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,       // LSDB: 2x1, no GCT
        0x2c,                                           // image separator
        0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x01, 0x00, // 2x1 frame at 0,0
        0x80,                                           // LCT, depth=0 (2 col)
        0x00, 0x00, 0x00, 0xff, 0xff, 0xff,             // LCT entries
        0x0c,                                           // LZW min code size=12
        0x04, 0x00, 0x20, 0x00, 0x00,                   // sub-block: codes 0,1
        0x00,                                           // sub-block terminator
        0x3b,                                           // trailer
    };
    wxMemoryInputStream mis(data, WXSIZEOF(data));
    wxImage img;
    REQUIRE( !img.LoadFile(mis, wxBITMAP_TYPE_GIF) );
}

TEST_CASE_METHOD(ImageHandlersInit, "wxImage::BadGIFPaletteIndex",
                 "[image][gif][error]")
{
    // A 1x1 GIF whose LSDB declares a 2-entry global colour table but whose
    // LZW minimum code size is 3, giving an 8-literal alphabet. The frame's
    // LZW data emits CLEAR, literal 2, EOI -- pixel value 2 is a valid LZW
    // literal but past the end of the 2-entry palette, so the
    // pal[3*(*src) + ...] reads in wxGIFDecoder::ConvertToImage() previously
    // pulled uninitialised bytes from the unpopulated tail of the 768-byte
    // pimg->pal buffer into the decoded image. The index stays inside the
    // buffer (a pixel byte is at most 255) so ASAN won't flag it, but it is
    // an uninitialised read that MSAN catches and leaks junk into the pixels.
    static const unsigned char data[] =
    {
        0x47, 0x49, 0x46, 0x38, 0x39, 0x61,             // "GIF89a"
        0x01, 0x00, 0x01, 0x00, 0x80, 0x00, 0x00,       // LSDB: 1x1, GCT, 2col
        0x00, 0x00, 0x00, 0xff, 0xff, 0xff,             // GCT entries
        0x2c,                                           // image separator
        0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, // 1x1 frame at 0,0
        0x00,                                           // no LCT
        0x03,                                           // LZW min code size=3
        0x02, 0x28, 0x09,                               // sub-block: CLEAR,2,EOI
        0x00,                                           // sub-block terminator
        0x3b,                                           // trailer
    };
    wxMemoryInputStream mis(data, WXSIZEOF(data));
    wxImage img;
    REQUIRE( !img.LoadFile(mis, wxBITMAP_TYPE_GIF) );
}

TEST_CASE_METHOD(ImageHandlersInit, "wxImage::GIFBadBackgroundIndex",
                 "[image][gif][error]")
{
    // The logical screen descriptor's background colour index is read straight
    // from the file and used to index the global colour table, but only the
    // first 3*global_ncolors bytes of the 768-byte palette buffer are populated
    // from the stream. This GIF declares a 2-entry global colour table and a
    // background index of 255, so wxGIFDecoder::LoadGIF() used to take the
    // background colour from the uninitialised tail of the buffer and expose it
    // via GetBackgroundColour(). The frame itself is valid so loading still
    // succeeds; the background should simply be left unset.
    static const unsigned char data[] =
    {
        0x47, 0x49, 0x46, 0x38, 0x39, 0x61,             // "GIF89a"
        0x01, 0x00, 0x01, 0x00, 0x80, 0xff, 0x00,       // LSD 1x1, GCT 2col, bg=255
        0x00, 0x00, 0x00, 0xff, 0xff, 0xff,             // GCT entries
        0x2c,                                           // image separator
        0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, // 1x1 frame at 0,0
        0x00,                                           // no LCT
        0x02,                                           // LZW min code size=2
        0x02, 0x44, 0x01,                               // sub-block CLEAR,0,EOI
        0x00,                                           // sub-block terminator
        0x3b,                                           // trailer
    };
    wxMemoryInputStream mis(data, WXSIZEOF(data));
    wxGIFDecoder decoder;
    REQUIRE( decoder.LoadGIF(mis) == wxGIF_OK );
    CHECK( !decoder.GetBackgroundColour().IsOk() );
}

TEST_CASE_METHOD(ImageHandlersInit, "wxImage::BadGIFZeroFrameSize",
                 "[image][gif][error]")
{
    // Per-frame width/height are read from the image descriptor without
    // checking for zero. When either dimension is zero, pimg->w * pimg->h
    // is 0 and the subsequent malloc(0) leaves an empty buffer that dgif()
    // still writes into as soon as the LZW stream emits a literal code,
    // overflowing the heap allocation. The existing zero-size check only
    // covers the second and later frames of an animation; the first frame
    // of an animation, and any GIF87a frame, both reach the allocation
    // unchecked.
    static const unsigned char data[] =
    {
        0x47, 0x49, 0x46, 0x38, 0x37, 0x61,             // "GIF87a"
        0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,       // LSDB: 1x1, no GCT
        0x2c,                                           // image separator
        0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, // frame at 0,0, w=1 h=0
        0x80,                                           // LCT, depth=0 (2 col)
        0x00, 0x00, 0x00, 0xff, 0xff, 0xff,             // LCT entries
        0x02,                                           // LZW min code size=2
        0x02, 0x44, 0x01,                               // sub-block: CLR/lit/EOI
        0x00,                                           // sub-block terminator
        0x3b,                                           // trailer
    };
    wxMemoryInputStream mis(data, WXSIZEOF(data));
    wxImage img;
    REQUIRE( !img.LoadFile(mis, wxBITMAP_TYPE_GIF) );
}

#endif // wxUSE_GIF

#if wxUSE_PCX

TEST_CASE_METHOD(ImageHandlersInit, "wxImage::BadPCX", "[image][pcx][error]")
{
    // A PCX header where width (read from xmin/xmax) exceeds
    // bytesperline*nplanes (the per-line buffer size). The decode loop
    // used to read past the buffer end.
    static const unsigned char data[] =
    {
        0x0a,0x05,0x01,0x08,0x00,0x00,0x00,0x00,0x08,0x00,0x00,0x00,
        0x48,0x00,0x48,0x00,0x00,0x00,0x00,0x00,0x00,0xf3,0x00,0x00,
        0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
        0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
        0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
        0x00,0x00,0x01,0x02,0x00,0x01,0x00,0x00,0x0a,0x97,0x00,0x00,
        0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
        0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
        0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
        0x00,0x00,0x00,0x00,0x0a,0x97,0x00,0x00,0x00,0x04,0x00,0x00,
        0x00,0x00,0x00,0x00,0x00,0xc1,0x00,0x00,
    };
    wxMemoryInputStream mis(data, WXSIZEOF(data));
    wxImage img;
    REQUIRE( !img.LoadFile(mis, wxBITMAP_TYPE_PCX) );
}

TEST_CASE_METHOD(ImageHandlersInit, "wxImage::TruncatedPCXPalette", "[image][pcx][error]")
{
    // A 1x1 8-bit PCX whose 256-colour palette (which follows the 0x0c
    // marker at the very end of the file) is truncated. ReadPCX() used to
    // read the fixed 768-byte palette without checking how many bytes were
    // actually present, so the unread tail of the buffer stayed
    // uninitialised and was then copied into the image data and the
    // wxImage palette.
    unsigned char data[128 + 2 + 1 + 10] = { 0 };
    data[0] = 0x0a;   // manufacturer
    data[1] = 0x05;   // version
    data[2] = 0x01;   // RLE encoding
    data[3] = 0x08;   // bits per pixel
    // xmin/ymin/xmax/ymax all zero gives a 1x1 image
    data[65] = 0x01;  // one plane
    data[66] = 0x01;  // bytes per line
    // a single RLE run for one pixel with palette index 255
    data[128] = 0xc1;
    data[129] = 0xff;
    // palette marker followed by only 10 of the expected 768 palette bytes
    data[130] = 0x0c;

    wxMemoryInputStream mis(data, WXSIZEOF(data));
    wxImage img;
    REQUIRE( !img.LoadFile(mis, wxBITMAP_TYPE_PCX) );
}

#endif // wxUSE_PCX

TEST_CASE_METHOD(ImageHandlersInit, "wxImage::BadANI", "[image][ani][error]")
{
    static const unsigned char data[] =
    {
        'R','I','F','F',
        0x74,0x43,0x00,0x00,
        'A','C','O','N',

        'a','n','i','h',
        0x24,0x00,0x00,0x00,

        0x24,0x00,0x00,0x00,

        // nFrames = 4
        0x04,0x00,0x00,0x00,

        // nSteps = 4
        0x04,0x00,0x00,0x00,

        0,0,0,0,
        0,0,0,0,
        0,0,0,0,
        0,0,0,0,
        0x0A,0x00,0x00,0x00,
        0x01,0x00,0x00,0x00,

        // rate chunk
        'r','a','t','e',
        0x10,0x00,0x00,0x00,

        0x0A,0x00,0x00,0x00,
        0x09,0x00,0x00,0x00,
        0x09,0x00,0x00,0x00,
        0x09,0x00,0x00,0x00,

        // seq chunk
        's','e','q',' ',
        0x10,0x00,0x00,0x00,

        0x00,0x00,0x00,0x00,
        0x01,0x00,0x00,0x00,
        0x02,0x00,0x00,0x00,

        // invalid index 999
        0xE7,0x03,0x00,0x00,

        // LIST chunk copied from horse.ani
        'L','I','S','T',
        0x1C,0x43,0x00,0x00,
        'f','r','a','m',

        // copy remaining bytes from horse.ani...
    };

    wxMemoryInputStream mis(data, WXSIZEOF(data));

    wxImage img;

    REQUIRE( !img.LoadFile(mis, wxBITMAP_TYPE_ANI) );
}

#if wxUSE_XPM

TEST_CASE_METHOD(ImageHandlersInit, "wxImage::BadXPM", "[image][xpm][error]")
{
    // An XPM-like payload that opens a /* comment without ever closing
    // it. The comment-stripping loop used to call strlen() past the end
    // of the wxCharBuffer once it ran off the end without finding '*/'.
    static const unsigned char data[] =
    {
        0x2f,0x2a,0x20,0xa8,0xaf,0xb2,0xdf,0xd5,0xd0,0xdf,0xce,0x2f,
        0x0a,0x74,0x61,0x74,0x69,0x63,0x20,0x63,0x68,0x61,0x74,0x5b,
        0x5d,0x3d,0x7b,0x7b,0x0a,0x20,0x31,0x20,0x31,0x20,0x31,0x22,
        0x2c,0x0a,0x22,0x61,0x20,0x63,0x20,0x23,0x66,0x66,0x66,0x66,
        0x66,0x66,0x22,0x2c,0x0a,0x22,0x61,0x22,0x61,0x22,0x7d,0x3b,
        0x0a,
    };
    wxMemoryInputStream mis(data, WXSIZEOF(data));
    wxImage img;
    REQUIRE( !img.LoadFile(mis, wxBITMAP_TYPE_XPM) );
}

TEST_CASE_METHOD(ImageHandlersInit, "wxImage::BadXPMUnterminatedQuote",
                 "[image][xpm][error]")
{
    // A payload whose final " is never closed: the quote-stripping loop in
    // wxXPMDecoder::ReadFile() advanced p past the buffer terminator after
    // strncpy() and then dereferenced one byte further on the next outer
    // for-loop iteration, reading past the end of the wxCharBuffer.
    static const unsigned char data[] =
    {
        0x22,0x61,0x62,0x63,
    };
    wxMemoryInputStream mis(data, WXSIZEOF(data));
    wxImage img;
    REQUIRE( !img.LoadFile(mis, wxBITMAP_TYPE_XPM) );
}

TEST_CASE_METHOD(ImageHandlersInit, "wxImage::BadXPMWidthOverflow",
                 "[image][xpm][error]")
{
    // width * chars_per_pixel was computed in 32-bit unsigned in
    // wxXPMDecoder::ReadData() and used to check that each image line is long
    // enough, but the per-pixel index uses size_t arithmetic. With width =
    // 68174085 and chars_per_pixel = 63 the product is 4 294 967 355, which
    // wraps to 59, so a one-pixel image line passes the length check and the
    // key-reading loop then runs off the end of the buffer. Loading such a
    // file must be rejected.
    const std::string xpm = R"("/* XPM */"
"68174085 1 1 63"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa c #ffffff"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
)";
    wxMemoryInputStream mis(xpm.data(), xpm.size());
    wxImage img;
    REQUIRE( !img.LoadFile(mis, wxBITMAP_TYPE_XPM) );
}

TEST_CASE_METHOD(ImageHandlersInit, "wxImage::BadXPMDuplicateColourKey",
                 "[image][xpm][error]")
{
    // The colour table declares two colours but reuses the same key on both
    // lines, so the colour map only ends up with one distinct entry.
    // wxXPMDecoder::ReadData() sized the palette arrays by the declared colour
    // count while filling only the entries actually in the map, so the last
    // palette entry was left uninitialised for wxPalette() to read (and the
    // wxASSERT() in debug builds fired). The image data itself is valid and
    // must still load, now with a palette holding only the distinct colour.
    const std::string xpm = R"(/* XPM */
"2 1 2 1"
"a c #ff0000"
"a c #0000ff"
"aa"
)";
    wxMemoryInputStream mis(xpm.data(), xpm.size());
    wxImage img;
    REQUIRE( img.LoadFile(mis, wxBITMAP_TYPE_XPM) );
#if wxUSE_PALETTE
    CHECK( img.GetPalette().GetColoursCount() == 1 );
#endif
}

#endif // wxUSE_XPM

#if wxUSE_IFF

TEST_CASE_METHOD(ImageHandlersInit, "wxImage::BadIFF", "[image][iff][error]")
{
    // A FORM/ILBM file whose BMHD transparent-colour field is 0x4000 while
    // the palette only has 2 entries (1 bitplane and no CMAP chunk). The
    // transparent index used to be applied to the palette without a bounds
    // check, writing past the end of the palette buffer; loading such a file
    // must now be rejected.
    static const unsigned char data[] =
    {
        0x46,0x4f,0x52,0x4d,0x00,0x00,0x00,0x2e,
        0x49,0x4c,0x42,0x4d,0x42,0x4d,0x48,0x44,
        0x00,0x00,0x00,0x14,0x00,0x01,0x00,0x01,
        0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,
        0x40,0x00,0x00,0x00,0x00,0x01,0x00,0x01,
        0x42,0x4f,0x44,0x59,0x00,0x00,0x00,0x02,
        0x00,0x00,
    };
    wxMemoryInputStream mis(data, WXSIZEOF(data));
    wxImage img;
    REQUIRE( !img.LoadFile(mis, wxBITMAP_TYPE_IFF) );
}

TEST_CASE_METHOD(ImageHandlersInit, "wxImage::BadIFFBmhdOverflow",
                 "[image][iff][error]")
{
    // BMHD width = 21849, height = 65535 gives bmhd_width * bmhd_height * 3
    // = 4 295 622 645, which overflows the 32-bit signed int product used by
    // wxIFFDecoder::ReadIFF() to size the pixel buffer and wraps down to
    // 655 349. The subsequent BODY decode loop writes 3 * bmhd_width bytes
    // per scanline, so a BODY chunk containing 10 lineskips' worth of zeros
    // (lineskip = 2732 for this width, total 27320 bytes) is enough to
    // overrun the undersized heap allocation. The fix rejects the file at
    // BMHD validation time.
    wxImage::AddHandler(new wxIFFHandler);

    static const unsigned char header[] =
    {
        0x46,0x4f,0x52,0x4d,            // "FORM"
        0x00,0x00,0x6a,0xe0,            // FORM length = 27360
        0x49,0x4c,0x42,0x4d,            // "ILBM"
        0x42,0x4d,0x48,0x44,            // "BMHD"
        0x00,0x00,0x00,0x14,            // BMHD chunk length = 20
        0x55,0x59,                      // width  = 21849
        0xff,0xff,                      // height = 65535
        0x00,0x00,0x00,0x00,            // x, y
        0x01,                           // nPlanes
        0x00,                           // masking
        0x00,                           // compression (BI_RGB, uncompressed)
        0x00,                           // pad
        0x00,0x00,                      // transparentColor
        0x00,0x00,                      // x/y aspect
        0x00,0x00,0x00,0x00,            // page width / height
        0x42,0x4f,0x44,0x59,            // "BODY"
        0x00,0x00,0x6a,0xb8,            // BODY chunk length = 27320
    };
    std::vector<unsigned char> data(header, header + WXSIZEOF(header));
    data.resize(data.size() + 27320, 0);

    wxMemoryInputStream mis(data.data(), data.size());
    wxImage img;
    REQUIRE( !img.LoadFile(mis, wxBITMAP_TYPE_IFF) );
}

TEST_CASE_METHOD(ImageHandlersInit, "wxImage::BadIFFBodyTruncated",
                 "[image][iff][error]")
{
    // A BODY chunk that declares more data than the file actually contains:
    // dataptr + 8 + chunkLen > dataend, so the truncated branch in
    // wxIFFDecoder::ReadIFF() runs and used to set chunkLen = dataend - dataptr,
    // which is 8 too large (the chunk header is 8 bytes). The non-RLE BODY
    // decode loop then reads up to 8 bytes past the heap-allocated input
    // buffer. width = 16 with 1 bitplane gives lineskip = 2, and the second
    // half of the scanline (j = 8..15) reads bodyptr[1], one byte past dataend.
    // transparentColor = 0x4000 ensures ConvertToImage() also rejects the
    // resulting image so the test fails cleanly with the fix applied.
    wxImage::AddHandler(new wxIFFHandler);

    static const unsigned char data[] =
    {
        0x46,0x4f,0x52,0x4d,            // "FORM"
        0x00,0x00,0x00,0x29,            // FORM length (not validated)
        0x49,0x4c,0x42,0x4d,            // "ILBM"
        0x42,0x4d,0x48,0x44,            // "BMHD"
        0x00,0x00,0x00,0x14,            // BMHD chunk length = 20
        0x00,0x10,                      // width  = 16
        0x00,0x01,                      // height = 1
        0x00,0x00,0x00,0x00,            // x, y
        0x01,                           // nPlanes
        0x00,                           // masking
        0x00,                           // compression (uncompressed)
        0x00,                           // pad
        0x40,0x00,                      // transparentColor = 0x4000
        0x00,0x00,                      // x/y aspect
        0x00,0x00,0x00,0x00,            // page width / height
        0x42,0x4f,0x44,0x59,            // "BODY"
        0x00,0x00,0x00,0x64,            // BODY chunk length = 100 (lie)
        0xff,                           // 1 byte of body data
    };
    wxMemoryInputStream mis(data, WXSIZEOF(data));
    wxImage img;
    REQUIRE( !img.LoadFile(mis, wxBITMAP_TYPE_IFF) );
}

TEST_CASE_METHOD(ImageHandlersInit, "wxImage::BadIFFRLEBody",
                 "[image][iff][error]")
{
    // A run-length encoded (compression == 1) BODY whose data is a single
    // replicate control byte (0xFF) with no following data byte. decomprle()
    // only checked that one source byte remained before reading the replicate
    // packet's data byte, so it read bodyptr[1], one byte past the end of the
    // heap-allocated input buffer. transparentColor = 0x4000 makes
    // ConvertToImage() reject the result so the load fails with the fix.
    wxImage::AddHandler(new wxIFFHandler);

    static const unsigned char data[] =
    {
        0x46,0x4f,0x52,0x4d,            // "FORM"
        0x00,0x00,0x00,0x29,            // FORM length (not validated)
        0x49,0x4c,0x42,0x4d,            // "ILBM"
        0x42,0x4d,0x48,0x44,            // "BMHD"
        0x00,0x00,0x00,0x14,            // BMHD chunk length = 20
        0x00,0x08,                      // width  = 8
        0x00,0x01,                      // height = 1
        0x00,0x00,0x00,0x00,            // x, y
        0x01,                           // nPlanes
        0x00,                           // masking
        0x01,                           // compression = 1 (RLE)
        0x00,                           // pad
        0x40,0x00,                      // transparentColor = 0x4000
        0x00,0x00,                      // x/y aspect
        0x00,0x00,0x00,0x00,            // page width / height
        0x42,0x4f,0x44,0x59,            // "BODY"
        0x00,0x00,0x00,0x64,            // BODY chunk length = 100 (lie)
        0xff,                           // lone replicate control byte
    };
    wxMemoryInputStream mis(data, WXSIZEOF(data));
    wxImage img;
    REQUIRE( !img.LoadFile(mis, wxBITMAP_TYPE_IFF) );
}

#endif // wxUSE_IFF

TEST_CASE_METHOD(ImageHandlersInit, "wxImage::DibPadding", "[image]")
{
    /*
    There used to be an error with calculating the DWORD aligned scan line
    pitch for a BMP/ICO resulting in buffer overwrites (with at least MSVC9
    Debug this gave a heap corruption assertion when saving the mask of
    an ICO). Test for it here.
    */
    wxImage image("horse.gif");
    REQUIRE( image.IsOk() );

    image = image.Scale(99, 99);

    wxMemoryOutputStream memOut;
    REQUIRE( image.SaveFile(memOut, wxBITMAP_TYPE_ICO) );
}

static void CompareBMPImage(const wxString& file1, const wxString& file2)
{
    wxImage image1(file1);
    REQUIRE( image1.IsOk() );

    wxImage image2(file2);
    REQUIRE( image2.IsOk() );

    INFO("Comparing " << file1 << " and " << file2);
    CompareImage(*wxImage::FindHandler(wxBITMAP_TYPE_BMP), image1, 0, &image2);
}

TEST_CASE_METHOD(ImageHandlersInit, "wxImage::BMPFlippingAndRLECompression", "[image]")
{
    CompareBMPImage("image/horse_grey.bmp", "image/horse_grey_flipped.bmp");

    CompareBMPImage("image/horse_rle8.bmp", "image/horse_grey.bmp");
    CompareBMPImage("image/horse_rle8.bmp", "image/horse_rle8_flipped.bmp");

    CompareBMPImage("image/horse_rle4.bmp", "image/horse_rle4_flipped.bmp");

    CompareBMPImage("image/rle8-delta-320x240.bmp",
                    "image/rle8-delta-320x240-expected.bmp");
    CompareBMPImage("image/rle4-delta-320x240.bmp",
                    "image/rle8-delta-320x240-expected.bmp");
}

// If possible, check loading some BMP files by comparing loading them directly
// and via wxImage.
#ifdef CAN_LOAD_BITMAP_DIRECTLY

static wxImage ImageFromBMPFile(const wxString& filename)
{
    INFO("Loading pixel data from " << filename);
    wxFile file(filename);

    // Read the BMP file header
    const size_t hdrLen = 14;
    char hdr[hdrLen];
    ssize_t cbRead = file.Read(hdr, hdrLen);
    REQUIRE((size_t)cbRead == hdrLen);
    REQUIRE(hdr[0] == 'B');
    REQUIRE(hdr[1] == 'M');
    wxUint32 ofstDeclared = *(const wxUint32*)&hdr[10];

    // Now read the data
    size_t dataLen = file.Length() - hdrLen;
    std::vector<unsigned char> buf(dataLen);
    cbRead = file.Read(&buf[0], dataLen);
    REQUIRE((size_t)cbRead == dataLen);

    // Check there is no gap in the file between the end of the header
    // and the start of the pixel data. If there is, we can't tell
    // wxDIB::ConvertToBitmap() about it because we need to test its
    // code path where bits==nullptr, so we just have to fail the test
    const BITMAPINFO* pbmi = reinterpret_cast<const BITMAPINFO*>(&buf[0]);
    wxUint32 numColors = 0;
    if ( pbmi->bmiHeader.biCompression == BI_BITFIELDS )
    {
        if ( pbmi->bmiHeader.biSize == sizeof(BITMAPINFOHEADER) )
            numColors = 3;
    }
    else
    {
        if ( pbmi->bmiHeader.biClrUsed )
            numColors = pbmi->bmiHeader.biClrUsed;
        else if ( pbmi->bmiHeader.biBitCount <= 8 )
            numColors = 1 << pbmi->bmiHeader.biBitCount;
    }
    wxUint32 cbColorTable = numColors * sizeof(RGBQUAD);
    size_t ofstComputed = hdrLen + pbmi->bmiHeader.biSize + cbColorTable;
    REQUIRE(ofstComputed == ofstDeclared);

    // All good; now make an image out of it
    AutoHBITMAP ahbmp(wxDIB::ConvertToBitmap(pbmi));
    wxDIB dib(ahbmp);
    REQUIRE(dib.IsOk());

    return dib.ConvertToImage();
}

// Compare the results of loading a BMP using:
//  1. Windows' own conversion (GDI CreateDIBitmap() via wxDIB::ConvertToBitmap())
//  2. wxBMPHandler via wxImage::LoadFile()
//  3. wxBMPFileHandler via wxBitmap::LoadFile()
static void CompareBMPImageLoad(const wxString& filename, int properties = 0)
{
    INFO("Comparing loading methods for " << filename);

    wxImage image1 = ImageFromBMPFile(filename);
    REQUIRE( image1.IsOk() );

    wxImage image2(filename);
    REQUIRE( image2.IsOk() );

    wxBitmap bitmap3(filename, wxBITMAP_TYPE_BMP);
    REQUIRE( bitmap3.IsOk() );
    wxImage image3(bitmap3.ConvertToImage());
    REQUIRE( image3.IsOk() );

    // It is impossible (in general) for both of these
    // tests to pass on delta-RLE bitmaps. See #23638
    if ( !(properties & wxIMAGE_HAVE_DELTA_RLE_BITMAP) )
    {
        INFO("wxDIB::ConvertToBitmap vs wxImage::LoadFile");
        CompareImage(*wxImage::FindHandler(wxBITMAP_TYPE_BMP),
            image1, properties, &image2);
    }

    INFO("wxBitmap::LoadFile vs wxImage::LoadFile");
    CompareImage(*wxImage::FindHandler(wxBITMAP_TYPE_BMP),
        image3, properties, &image2);
}

TEST_CASE_METHOD(ImageHandlersInit, "wxImage::BMPLoadMethod", "[image][bmp]")
{
    CompareBMPImageLoad("image/bitfields.bmp");
    // We would check the alpha on this one, but at the moment it fails
    // because of the way CompareImage() saves and reloads images,
    // which for BMPs does not preserve the alpha channel
    CompareBMPImageLoad("image/bitfields-alpha.bmp"/*, wxIMAGE_HAVE_ALPHA*/);
    CompareBMPImageLoad("image/horse_grey.bmp");
    CompareBMPImageLoad("image/horse_rle8.bmp");
    CompareBMPImageLoad("image/horse_rle4.bmp");
    if (!wxIsRunningUnderWine())
        CompareBMPImageLoad("image/rgb16-3103.bmp");
    CompareBMPImageLoad("image/rgb32-7187.bmp");
    CompareBMPImageLoad("image/rle8-delta-320x240.bmp",
        wxIMAGE_HAVE_DELTA_RLE_BITMAP);
    CompareBMPImageLoad("image/rle4-delta-320x240.bmp",
        wxIMAGE_HAVE_DELTA_RLE_BITMAP);
}

#endif // CAN_LOAD_BITMAP_DIRECTLY

static int
FindMaxChannelDiff(const wxImage& i1, const wxImage& i2)
{
    if ( i1.GetWidth() != i2.GetWidth() )
        return false;

    if ( i1.GetHeight() != i2.GetHeight() )
        return false;

    const unsigned char* p1 = i1.GetData();
    const unsigned char* p2 = i2.GetData();
    const int numBytes = i1.GetWidth()*i1.GetHeight()*3;
    int maxDiff = 0;
    for ( int n = 0; n < numBytes; n++, p1++, p2++ )
    {
        const int diff = std::abs(*p1 - *p2);
        if ( diff > maxDiff )
            maxDiff = diff;
    }

    return maxDiff;
}

// Note that we accept up to one pixel difference, this happens because of
// different rounding behaviours in different compiler versions
// even under the same architecture, see the example in
// http://thread.gmane.org/gmane.comp.lib.wxwidgets.devel/151149/focus=151154

static void
ASSERT_IMAGE_EQUAL_TO_FILE(const wxImage& image, const wxString& file)
{
    // This environment variable can be set to 1 to save the images instead of
    // checking that the results match the existing files.
    wxString value;
    if ( wxGetEnv("WX_TEST_SAVE_SCALED_IMAGES", &value) && value == "1" )
    {
        INFO("Failed to save \"" << file << "\"");
        CHECK( image.SaveFile(file) );
    }
    else
    {
        const wxImage imageFromFile(file);
        if ( imageFromFile.IsOk() )
        {
            INFO("Wrong \"" << file << "\" " << Catch::StringMaker<wxImage>::convert(image));
            CHECK(FindMaxChannelDiff(imageFromFile, image) <= 1);
        }
        else
        {
            FAIL("Failed to load \"" << file << "\"");
        }
    }
}

TEST_CASE_METHOD(ImageHandlersInit, "wxImage::ScaleCompare", "[image]")
{
    wxImage original;
    REQUIRE(original.LoadFile("horse.bmp"));

    ASSERT_IMAGE_EQUAL_TO_FILE(original.Scale( 50,  50, wxIMAGE_QUALITY_BICUBIC),
                               "image/horse_bicubic_50x50.png");
    ASSERT_IMAGE_EQUAL_TO_FILE(original.Scale(100, 100, wxIMAGE_QUALITY_BICUBIC),
                               "image/horse_bicubic_100x100.png");
    ASSERT_IMAGE_EQUAL_TO_FILE(original.Scale(150, 150, wxIMAGE_QUALITY_BICUBIC),
                               "image/horse_bicubic_150x150.png");
    ASSERT_IMAGE_EQUAL_TO_FILE(original.Scale(300, 300, wxIMAGE_QUALITY_BICUBIC),
                               "image/horse_bicubic_300x300.png");

    ASSERT_IMAGE_EQUAL_TO_FILE(original.Scale( 50,  50, wxIMAGE_QUALITY_BOX_AVERAGE),
                               "image/horse_box_average_50x50.png");
    ASSERT_IMAGE_EQUAL_TO_FILE(original.Scale(100, 100, wxIMAGE_QUALITY_BOX_AVERAGE),
                               "image/horse_box_average_100x100.png");
    ASSERT_IMAGE_EQUAL_TO_FILE(original.Scale(150, 150, wxIMAGE_QUALITY_BOX_AVERAGE),
                               "image/horse_box_average_150x150.png");
    ASSERT_IMAGE_EQUAL_TO_FILE(original.Scale(300, 300, wxIMAGE_QUALITY_BOX_AVERAGE),
                               "image/horse_box_average_300x300.png");

    ASSERT_IMAGE_EQUAL_TO_FILE(original.Scale( 50,  50, wxIMAGE_QUALITY_BILINEAR),
                               "image/horse_bilinear_50x50.png");
    ASSERT_IMAGE_EQUAL_TO_FILE(original.Scale(100, 100, wxIMAGE_QUALITY_BILINEAR),
                               "image/horse_bilinear_100x100.png");
    ASSERT_IMAGE_EQUAL_TO_FILE(original.Scale(150, 150, wxIMAGE_QUALITY_BILINEAR),
                               "image/horse_bilinear_150x150.png");
    ASSERT_IMAGE_EQUAL_TO_FILE(original.Scale(300, 300, wxIMAGE_QUALITY_BILINEAR),
                               "image/horse_bilinear_300x300.png");

    // Test scaling symmetric image
    const static char* cross_xpm[] =
    {
        "9 9 5 1",
        "   c None",
        "r  c #FF0000",
        "g  c #00FF00",
        "b  c #0000FF",
        "w  c #FFFFFF",
        "    r    ",
        "    g    ",
        "    b    ",
        "    w    ",
        "rgbw wbgr",
        "    w    ",
        "    b    ",
        "    g    ",
        "    r    "
    };

    wxImage imgCross(cross_xpm);
    ASSERT_IMAGE_EQUAL_TO_FILE(imgCross.Scale(256, 256, wxIMAGE_QUALITY_BILINEAR),
                               "image/cross_bilinear_256x256.png");
    ASSERT_IMAGE_EQUAL_TO_FILE(imgCross.Scale(256, 256, wxIMAGE_QUALITY_BICUBIC),
                               "image/cross_bicubic_256x256.png");
    ASSERT_IMAGE_EQUAL_TO_FILE(imgCross.Scale(256, 256, wxIMAGE_QUALITY_BOX_AVERAGE),
                               "image/cross_box_average_256x256.png");
    ASSERT_IMAGE_EQUAL_TO_FILE(imgCross.Scale(256, 256, wxIMAGE_QUALITY_NEAREST),
                               "image/cross_nearest_neighb_256x256.png");
}

TEST_CASE_METHOD(ImageHandlersInit, "wxImage::CreateBitmapFromCursor", "[image]")
{
#if !defined __WXOSX_IPHONE__ && !defined __WXDFB__ && !defined __WXX11__

    wxImage image("image/wx.png");
    wxCursor cursor(image);
    wxBitmap bitmap(cursor);

#if defined(__WXGTK__)
    // cursor to bitmap could fail depending on windowing system and cursor (gdk-cursor-get-image)
    if ( !bitmap.IsOk() )
        return;
#endif

    wxImage result = bitmap.ConvertToImage();

    // on Windows the cursor is always scaled to 32x32px (96 DPI)
    // on macOS the resulting bitmap size depends on the DPI
    if ( image.GetSize() == result.GetSize() )
    {
        CHECK_THAT(image, RGBASimilarTo(result, 2));
    }
    else
    {
        wxVector<wxPoint> coords;
        coords.push_back(wxPoint(14, 10)); // blue square
        coords.push_back(wxPoint(8, 22));  // red square
        coords.push_back(wxPoint(26, 18)); // yellow square
        coords.push_back(wxPoint(25, 5));  // empty / tranparent

        for ( size_t i = 0; i < coords.size(); ++i )
        {
            wxPoint const& p1 = coords[i];
            wxPoint p2 = wxPoint(p1.x * (result.GetWidth() / (double)image.GetWidth()), p1.y * (result.GetHeight() / (double)image.GetHeight()));

#if defined(__WXMSW__)
            // when the cursor / result image is larger than the source image, the original image is centered in the result image
            if ( result.GetWidth() > image.GetWidth() )
                p2.x = (result.GetWidth() / 2) + (p1.x - (image.GetWidth() / 2));
            if ( result.GetHeight() > image.GetHeight() )
                p2.y = (result.GetHeight() / 2) + (p1.y - (image.GetHeight() / 2));
#endif

            wxColour cSrc(image.GetRed(p1.x, p1.y), image.GetGreen(p1.x, p1.y), image.GetBlue(p1.x, p1.y), image.GetAlpha(p1.x, p1.y));
            wxColour cRes(result.GetRed(p2.x, p2.y), result.GetGreen(p2.x, p2.y), result.GetBlue(p2.x, p2.y), result.GetAlpha(p2.x, p2.y));

            CHECK_EQUAL_COLOUR_RGBA(cRes, cSrc);
        }
    }
#endif
}

// This function assumes that the file is malformed in a way that it cannot
// be loaded but that doesn't fail a wxCHECK.
static void LoadMalformedImage(const wxString& file, wxBitmapType type)
{
    // If the file doesn't exist, it's a test bug.
    // (The product code would fail but for the wrong reason.)
    INFO("Checking that image exists: " << file);
    REQUIRE(wxFileExists(file));

    // Load the image, expecting a failure.
    wxImage image;
    INFO("Loading malformed image: " << file);
    REQUIRE(!image.LoadFile(file, type));
}

// This function assumes that the file is malformed in a way that wxImage
// fails a wxCHECK when trying to load it.
static void LoadMalformedImageWithException(const wxString& file,
                                            wxBitmapType type)
{
    // If the file doesn't exist, it's a test bug.
    // (The product code would fail but for the wrong reason.)
    INFO("Checking that image exists: " << file);
    REQUIRE(wxFileExists(file));

    wxImage image;
    INFO("Loading malformed image: " << file);
#ifdef __WXDEBUG__
    REQUIRE_THROWS(image.LoadFile(file, type));
#else
    REQUIRE(!image.LoadFile(file, type));
#endif
}

TEST_CASE_METHOD(ImageHandlersInit, "wxImage::BMP", "[image][bmp]")
{
    SECTION("Load malformed bitmaps")
    {
        LoadMalformedImage("image/8bpp-colorsused-negative.bmp",
                           wxBITMAP_TYPE_BMP);
        LoadMalformedImage("image/8bpp-colorsused-large.bmp",
                           wxBITMAP_TYPE_BMP);
        LoadMalformedImage("image/badrle4.bmp", wxBITMAP_TYPE_BMP);
        LoadMalformedImage("image/width-times-height-overflow.bmp", wxBITMAP_TYPE_BMP);
    }
    SECTION("8bpp colour index past end of palette")
    {
        // An 8bpp BMP whose pixel stream contains a colour index larger
        // than the palette colour count. Used to read past the palette
        // buffer in the decode loops.
        static const unsigned char data[] =
        {
            0x42,0x4d,0x3a,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x09,0x00,
            0x00,0x00,0x28,0x00,0x00,0x00,0x28,0x00,0x00,0x00,0x01,0x00,
            0x00,0x00,0x01,0x00,0x08,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
            0x42,0x4d,0x3a,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x03,0x00,
            0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x2b,0x00,
            0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
            0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x05,
            0x00,0x00,0x00,0x00,0x00,0x28,0x00,0x00,0x00,0x01,0x00,0x00,
        };
        wxMemoryInputStream mis(data, WXSIZEOF(data));
        wxImage img;
        REQUIRE( !img.LoadFile(mis, wxBITMAP_TYPE_BMP) );
    }
    wxImage image;
    SECTION("32bpp alpha")
    {
        REQUIRE(image.LoadFile("image/32bpp_rgb.bmp", wxBITMAP_TYPE_BMP));
        REQUIRE_FALSE(image.GetAlpha());

        // alpha is preserved for ICO
        REQUIRE(image.LoadFile("image/32bpp_rgb.ico", wxBITMAP_TYPE_ICO));
        const unsigned char* alpha = image.GetAlpha();
        REQUIRE(alpha);
        REQUIRE(alpha[0] == 0x80);

        // alpha is ignored for ICO if it is fully transparent
        REQUIRE(image.LoadFile("image/32bpp_rgb_a0.ico", wxBITMAP_TYPE_ICO));
        REQUIRE_FALSE(image.GetAlpha());

        REQUIRE(image.LoadFile("image/rgb32bf.bmp", wxBITMAP_TYPE_BMP));
        REQUIRE_FALSE(image.GetAlpha());
        REQUIRE(image.LoadFile("image/rgba32.bmp", wxBITMAP_TYPE_BMP));
        alpha = image.GetAlpha();
        REQUIRE(alpha);
        REQUIRE(alpha[0] == 0x80);
    }
}

TEST_CASE_METHOD(ImageHandlersInit, "wxImage::Paste", "[image][paste]")
{
    const static char* squares_xpm[] =
    {
        "9 9 7 1",
        "   c None",
        "y  c #FFFF00",
        "r  c #FF0000",
        "g  c #00FF00",
        "b  c #0000FF",
        "o  c #FF6600",
        "w  c #FFFFFF",
        "rrrrwgggg",
        "rrrrwgggg",
        "rrrrwgggg",
        "rrrrwgggg",
        "wwwwwwwww",
        "bbbbwoooo",
        "bbbbwoooo",
        "bbbbwoooo",
        "bbbbwoooo"
    };

    const static char* toggle_equal_size_xpm[] =
    {
        "9 9 2 1",
        "   c None",
        "y  c #FFFF00",
        "y y y y y",
        " y y y y ",
        "y y y y y",
        " y y y y ",
        "y y y y y",
        " y y y y ",
        "y y y y y",
        " y y y y ",
        "y y y y y",
    };

    const static char* transparent_image_xpm[] =
    {
        "5 5 2 1",
        "   c None", // Mask
        "y  c #FFFF00",
        "     ",
        "     ",
        "     ",
        "     ",
        "     ",
    };

    const static char* light_image_xpm[] =
    {
        "5 5 2 1",
        "   c None",
        "y  c #FFFF00",
        "yyyyy",
        "yyyyy",
        "yyyyy",
        "yyyyy",
        "yyyyy",
    };

    const static char* black_image_xpm[] =
    {
        "5 5 2 1",
        "   c #000000",
        "y  c None", // Mask
        "     ",
        "     ",
        "     ",
        "     ",
        "     ",
    };

    // Execute AddHandler() just once.
    static bool s_registeredHandler = false;
    if ( !s_registeredHandler )
    {
        wxImage::AddHandler(new wxPNGHandler());
        s_registeredHandler = true;
    }

    SECTION("Paste same size image")
    {
        wxImage actual(squares_xpm);
        wxImage paste(toggle_equal_size_xpm);
        wxImage expected(toggle_equal_size_xpm);
        actual.Paste(paste, 0, 0);
        CHECK_THAT(actual, RGBSameAs(expected));

        // Without alpha using "compose" doesn't change anything.
        actual.Paste(paste, 0, 0, wxIMAGE_ALPHA_BLEND_COMPOSE);
        CHECK_THAT(actual, RGBSameAs(expected));
    }

    SECTION("Paste larger image")
    {
        const static char* toggle_larger_size_xpm[] =
        {
            "13 13 2 1",
            "   c None",
            "y  c #FFFF00",
            "y y y y y y y",
            " y y y y y y ",
            "y y y y y y y",
            " y y y y y y ",
            "y y y y y y y",
            " y y y y y y ",
            "y y y y y y y",
            " y y y y y y ",
            "y y y y y y y",
            " y y y y y y ",
            "y y y y y y y",
            " y y y y y y ",
            "y y y y y y y",
        };

        wxImage actual(squares_xpm);
        wxImage paste(toggle_larger_size_xpm);
        wxImage expected(toggle_equal_size_xpm);
        actual.Paste(paste, -2, -2);
        CHECK_THAT(actual, RGBSameAs(expected));
    }

    SECTION("Paste smaller image")
    {
        const static char* toggle_smaller_size_xpm[] =
        {
            "5 5 2 1",
            "   c None",
            "y  c #FFFF00",
            "y y y",
            " y y ",
            "y y y",
            " y y ",
            "y y y",
        };

        const static char* expected_xpm[] =
        {
            "9 9 7 1",
            "   c None",
            "y  c #FFFF00",
            "r  c #FF0000",
            "g  c #00FF00",
            "b  c #0000FF",
            "o  c #FF6600",
            "w  c #FFFFFF",
            "rrrrwgggg",
            "rrrrwgggg",
            "rry y ygg",
            "rr y y gg",
            "wwy y yww",
            "bb y y oo",
            "bby y yoo",
            "bbbbwoooo",
            "bbbbwoooo"
        };

        wxImage actual(squares_xpm);
        wxImage paste(toggle_smaller_size_xpm);
        wxImage expected(expected_xpm);
        actual.Paste(paste, 2, 2);
        CHECK_THAT(actual, RGBSameAs(expected));
    }

    SECTION("Paste beyond top left corner")
    {
        const static char* expected_xpm[] =
        {
            "9 9 7 1",
            "   c None",
            "y  c #FFFF00",
            "r  c #FF0000",
            "g  c #00FF00",
            "b  c #0000FF",
            "o  c #FF6600",
            "w  c #FFFFFF",
            "oooowgggg",
            "oooowgggg",
            "oooowgggg",
            "oooowgggg",
            "wwwwwwwww",
            "bbbbwoooo",
            "bbbbwoooo",
            "bbbbwoooo",
            "bbbbwoooo"
        };

        wxImage actual(squares_xpm);
        wxImage paste(squares_xpm);
        wxImage expected(expected_xpm);
        actual.Paste(paste, -5, -5);
        CHECK_THAT(actual, RGBSameAs(expected));
    }

    SECTION("Paste beyond top right corner")
    {
        const static char* expected_xpm[] =
        {
            "9 9 7 1",
            "   c None",
            "y  c #FFFF00",
            "r  c #FF0000",
            "g  c #00FF00",
            "b  c #0000FF",
            "o  c #FF6600",
            "w  c #FFFFFF",
            "rrrrwbbbb",
            "rrrrwbbbb",
            "rrrrwbbbb",
            "rrrrwbbbb",
            "wwwwwwwww",
            "bbbbwoooo",
            "bbbbwoooo",
            "bbbbwoooo",
            "bbbbwoooo"
        };
        wxImage actual(squares_xpm);
        wxImage paste(squares_xpm);
        wxImage expected(expected_xpm);
        actual.Paste(paste, 5, -5);
        CHECK_THAT(actual, RGBSameAs(expected));
    }

    SECTION("Paste beyond bottom right corner")
    {
        const static char* expected_xpm[] =
        {
            "9 9 7 1",
            "   c None",
            "y  c #FF0000",
            "r  c #FF0000",
            "g  c #00FF00",
            "b  c #0000FF",
            "o  c #FF6600",
            "w  c #FFFFFF",
            "rrrrwgggg",
            "rrrrwgggg",
            "rrrrwgggg",
            "rrrrwgggg",
            "wwwwwwwww",
            "bbbbwrrrr",
            "bbbbwrrrr",
            "bbbbwrrrr",
            "bbbbwrrrr"
        };
        wxImage actual(squares_xpm);
        wxImage paste(squares_xpm);
        wxImage expected(expected_xpm);
        actual.Paste(paste, 5, 5);
        CHECK_THAT(actual, RGBSameAs(expected));
    }

    SECTION("Paste beyond bottom left corner")
    {
        const static char* expected_xpm[] =
        {
            "9 9 7 1",
            "   c None",
            "y  c #FFFF00",
            "r  c #FF0000",
            "g  c #00FF00",
            "b  c #0000FF",
            "o  c #FF6600",
            "w  c #FFFFFF",
            "rrrrwgggg",
            "rrrrwgggg",
            "rrrrwgggg",
            "rrrrwgggg",
            "wwwwwwwww",
            "ggggwoooo",
            "ggggwoooo",
            "ggggwoooo",
            "ggggwoooo"
        };
        wxImage actual(squares_xpm);
        wxImage paste(squares_xpm);
        wxImage expected(expected_xpm);
        actual.Paste(paste, -5, 5);
        CHECK_THAT(actual, RGBSameAs(expected));
    }

    SECTION("Paste fully opaque image onto blank image without alpha")
    {
        const wxImage background("image/paste_input_background.png");
        REQUIRE(background.IsOk());

        wxImage actual(background.GetSize());
        actual.Paste(background, 0, 0, wxIMAGE_ALPHA_BLEND_COMPOSE);
        CHECK_THAT(actual, RGBSameAs(background));
        CHECK(!actual.HasAlpha());
    }
    SECTION("Paste fully opaque image onto blank image with alpha")
    {
        const wxImage background("image/paste_input_background.png");
        REQUIRE(background.IsOk());

        wxImage actual(background.GetSize());
        actual.InitAlpha();
        actual.Paste(background, 0, 0, wxIMAGE_ALPHA_BLEND_COMPOSE);
        CHECK_THAT(actual, RGBSameAs(background));
        CHECK_THAT(actual, CenterAlphaPixelEquals(wxALPHA_OPAQUE));
    }
    SECTION("Paste fully transparent image")
    {
        const wxImage background("image/paste_input_background.png");
        REQUIRE(background.IsOk());

        wxImage actual = background.Copy();
        wxImage transparent(actual.GetSize());
        transparent.InitAlpha();
        memset(transparent.GetAlpha(), 0, transparent.GetWidth() * transparent.GetHeight());
        actual.Paste(transparent, 0, 0, wxIMAGE_ALPHA_BLEND_COMPOSE);
        CHECK_THAT(actual, RGBSameAs(background));
        CHECK_THAT(actual, CenterAlphaPixelEquals(wxALPHA_OPAQUE));
    }
    SECTION("Paste image with transparent region")
    {
        wxImage actual("image/paste_input_background.png");
        REQUIRE(actual.IsOk());

        const wxImage opaque_square("image/paste_input_overlay_transparent_border_opaque_square.png");
        REQUIRE(opaque_square.IsOk());

        actual.Paste(opaque_square, 0, 0, wxIMAGE_ALPHA_BLEND_COMPOSE);
        CHECK_THAT(actual, RGBSameAs(wxImage("image/paste_result_background_plus_overlay_transparent_border_opaque_square.png")));
        CHECK_THAT(actual, CenterAlphaPixelEquals(wxALPHA_OPAQUE));
    }
    SECTION("Paste image with semi transparent region")
    {
        wxImage actual("image/paste_input_background.png");
        REQUIRE(actual.IsOk());

        const wxImage transparent_square("image/paste_input_overlay_transparent_border_semitransparent_square.png");
        REQUIRE(transparent_square.IsOk());

        actual.Paste(transparent_square, 0, 0, wxIMAGE_ALPHA_BLEND_COMPOSE);
        CHECK_THAT(actual, RGBSameAs(wxImage("image/paste_result_background_plus_overlay_transparent_border_semitransparent_square.png")));
        CHECK_THAT(actual, CenterAlphaPixelEquals(wxALPHA_OPAQUE));
    }
    SECTION("Paste two semi transparent images on top of background")
    {
        wxImage actual("image/paste_input_background.png");
        REQUIRE(actual.IsOk());

        const wxImage transparent_square("image/paste_input_overlay_transparent_border_semitransparent_square.png");
        REQUIRE(transparent_square.IsOk());

        const wxImage transparent_circle("image/paste_input_overlay_transparent_border_semitransparent_circle.png");
        REQUIRE(transparent_circle.IsOk());

        actual.Paste(transparent_circle, 0, 0, wxIMAGE_ALPHA_BLEND_COMPOSE);
        actual.Paste(transparent_square, 0, 0, wxIMAGE_ALPHA_BLEND_COMPOSE);
        CHECK_THAT(actual, RGBSimilarTo(wxImage("image/paste_result_background_plus_circle_plus_square.png"), 1));
        CHECK_THAT(actual, CenterAlphaPixelEquals(wxALPHA_OPAQUE));
    }
    SECTION("Paste two semi transparent images together first, then on top of background")
    {
        wxImage actual("image/paste_input_background.png");
        REQUIRE(actual.IsOk());

        const wxImage transparent_square("image/paste_input_overlay_transparent_border_semitransparent_square.png");
        REQUIRE(transparent_square.IsOk());

        const wxImage transparent_circle("image/paste_input_overlay_transparent_border_semitransparent_circle.png");
        REQUIRE(transparent_circle.IsOk());

        wxImage circle = transparent_circle.Copy();
        circle.Paste(transparent_square, 0, 0, wxIMAGE_ALPHA_BLEND_COMPOSE);
        actual.Paste(circle, 0, 0, wxIMAGE_ALPHA_BLEND_COMPOSE);
        // When applied in this order, two times a rounding difference is triggered.
        CHECK_THAT(actual, RGBSimilarTo(wxImage("image/paste_result_background_plus_circle_plus_square.png"), 2));
        CHECK_THAT(actual, CenterAlphaPixelEquals(wxALPHA_OPAQUE));
    }
    SECTION("Paste semitransparent image over transparent image")
    {
        const wxImage transparent_square("image/paste_input_overlay_transparent_border_semitransparent_square.png");
        REQUIRE(transparent_square.IsOk());

        const wxImage transparent_circle("image/paste_input_overlay_transparent_border_semitransparent_circle.png");
        REQUIRE(transparent_circle.IsOk());

        wxImage actual(transparent_circle.GetSize());
        actual.InitAlpha();
        memset(actual.GetAlpha(), 0, actual.GetWidth() * actual.GetHeight());
        actual.Paste(transparent_circle, 0, 0, wxIMAGE_ALPHA_BLEND_COMPOSE);
        CHECK_THAT(actual, CenterAlphaPixelEquals(192));
        actual.Paste(transparent_square, 0, 0, wxIMAGE_ALPHA_BLEND_COMPOSE);
        CHECK_THAT(actual, RGBSimilarTo(wxImage("image/paste_result_no_background_square_over_circle.png"), 1));
        CHECK_THAT(actual, CenterAlphaPixelEquals(224));
    }
    SECTION("Paste fully transparent (masked) image over light image") // todo make test case for 'blend with mask'
    {
        wxImage actual(light_image_xpm);
        actual.InitAlpha();
        wxImage paste(transparent_image_xpm);
        wxImage expected(light_image_xpm);
        actual.Paste(paste, 0, 0, wxIMAGE_ALPHA_BLEND_COMPOSE);
        CHECK_THAT(actual, RGBSameAs(expected));
    }
    SECTION("Paste fully black (masked) image over light image") // todo make test case for 'blend with mask'
    {
        wxImage actual(light_image_xpm);
        actual.InitAlpha();
        wxImage paste(black_image_xpm);
        wxImage expected(black_image_xpm);
        actual.Paste(paste, 0, 0, wxIMAGE_ALPHA_BLEND_COMPOSE);
        CHECK_THAT(actual, RGBSameAs(expected));
    }
    SECTION("Paste dark image over light image")
    {
        wxImage black("image/paste_input_black.png");
        wxImage actual("image/paste_input_background.png");
        actual.InitAlpha();
        actual.Paste(black, 0, 0, wxIMAGE_ALPHA_BLEND_COMPOSE);
        CHECK_THAT(actual, CenterAlphaPixelEquals(255));
        CHECK_THAT(actual, RGBSameAs(black));
    }
    SECTION("Paste large image with negative vertical offset")
    {
        wxImage target(442, 249);
        wxImage to_be_pasted(345, 24900);
        target.InitAlpha();
        target.Paste(to_be_pasted, 48, -12325, wxIMAGE_ALPHA_BLEND_COMPOSE);
    }
    SECTION("Paste large image with negative horizontal offset")
    {
        wxImage target(249, 442);
        wxImage to_be_pasted(24900, 345);
        target.InitAlpha();
        target.Paste(to_be_pasted, -12325, 48, wxIMAGE_ALPHA_BLEND_COMPOSE);
    }

}

TEST_CASE("wxImage::RGBtoHSV", "[image][rgb][hsv]")
{
    SECTION("RGB(0,0,0) (Black) to HSV")
    {
       wxImage::RGBValue rgbBlack(0, 0, 0);
       wxImage::HSVValue hsvBlack = wxImage::RGBtoHSV(rgbBlack);

       CHECK(hsvBlack.value == Approx(0.0));
       // saturation and hue are undefined
    }
    SECTION("RGB(255,255,255) (White) to HSV")
    {
       wxImage::RGBValue rgbWhite(255, 255, 255);
       wxImage::HSVValue hsvWhite = wxImage::RGBtoHSV(rgbWhite);

       CHECK(hsvWhite.saturation == Approx(0.0));
       CHECK(hsvWhite.value == Approx(1.0));
       // hue is undefined
    }
    SECTION("RGB(0,255,0) (Green) to HSV")
    {
       wxImage::RGBValue rgbGreen(0, 255, 0);
       wxImage::HSVValue hsvGreen = wxImage::RGBtoHSV(rgbGreen);

       CHECK(hsvGreen.hue == Approx(1.0/3.0));
       CHECK(hsvGreen.saturation == Approx(1.0));
       CHECK(hsvGreen.value == Approx(1.0));
    }

    SECTION("RGB to HSV to RGB")
    {
        const wxImage::RGBValue rgbValues[] =
        {
            wxImage::RGBValue(   0,   0,   0 ),
            wxImage::RGBValue(  10,  10,  10 ),
            wxImage::RGBValue( 255, 255, 255 ),
            wxImage::RGBValue( 255,   0,   0 ),
            wxImage::RGBValue(   0, 255,   0 ),
            wxImage::RGBValue(   0,   0, 255 ),
            wxImage::RGBValue(   1,   2,   3 ),
            wxImage::RGBValue(  10,  20,  30 ),
            wxImage::RGBValue(   0,   1,   6 ),
            wxImage::RGBValue(   9,   0,  99 ),
        };

        for (unsigned i = 0; i < WXSIZEOF(rgbValues); i++)
        {
            wxImage::RGBValue rgbValue = rgbValues[i];
            wxImage::HSVValue hsvValue = wxImage::RGBtoHSV(rgbValue);
            wxImage::RGBValue rgbRoundtrip = wxImage::HSVtoRGB(hsvValue);

            CHECK(rgbRoundtrip.red == rgbValue.red);
            CHECK(rgbRoundtrip.green == rgbValue.green);
            CHECK(rgbRoundtrip.blue == rgbValue.blue);
        }
    }
}

TEST_CASE_METHOD(ImageHandlersInit, "wxImage::Clipboard", "[image][clipboard]")
{
#if wxUSE_CLIPBOARD && wxUSE_DATAOBJ
    wxInitAllImageHandlers();

    wxImage imgOriginal;
    REQUIRE(imgOriginal.LoadFile("horse.png") == true);

    wxImageDataObject* dobj1 = new wxImageDataObject(imgOriginal);
    {
        wxClipboardLocker lockClip;
        REQUIRE(wxTheClipboard->SetData(dobj1) == true);
    }

    wxImageDataObject dobj2;
    {
        wxClipboardLocker lockClip;
        REQUIRE(wxTheClipboard->GetData(dobj2) == true);
    }
    wxImage imgRetrieved = dobj2.GetImage();
    REQUIRE(imgRetrieved.IsOk());

    CHECK_THAT(imgOriginal, RGBASameAs(imgRetrieved));
#endif // wxUSE_CLIPBOARD && wxUSE_DATAOBJ
}

TEST_CASE("wxImage::InitAlpha", "[image][initalpha]")
{
    const wxColour maskCol(*wxRED);
    const wxColour fillCol(*wxGREEN);

    SECTION("RGB image without mask")
    {
        wxImage img(2, 2);
        img.SetRGB(0, 0, maskCol.Red(), maskCol.Green(), maskCol.Blue());
        img.SetRGB(0, 1, maskCol.Red(), maskCol.Green(), maskCol.Blue());
        img.SetRGB(1, 0, fillCol.Red(), fillCol.Green(), fillCol.Blue());
        img.SetRGB(1, 1, fillCol.Red(), fillCol.Green(), fillCol.Blue());
        REQUIRE_FALSE(img.HasAlpha());
        REQUIRE_FALSE(img.HasMask());

        wxImage imgRes = img;
        imgRes.InitAlpha();
        REQUIRE(imgRes.HasAlpha() == true);
        REQUIRE_FALSE(imgRes.HasMask());

        for (int y = 0; y < img.GetHeight(); y++)
            for (int x = 0; x < img.GetWidth(); x++)
            {
                wxColour cSrc(img.GetRed(x, y), img.GetGreen(x, y), img.GetBlue(x, y));
                wxColour cRes(imgRes.GetRed(x, y), imgRes.GetGreen(x, y), imgRes.GetBlue(x, y), imgRes.GetAlpha(x, y));

                CHECK_EQUAL_COLOUR_RGB(cRes, cSrc);
                CHECK((int)cRes.Alpha() == (int)wxIMAGE_ALPHA_OPAQUE);
            }
    }

    SECTION("RGB image with mask")
    {
        wxImage img(2, 2);
        img.SetRGB(0, 0, maskCol.Red(), maskCol.Green(), maskCol.Blue());
        img.SetRGB(0, 1, maskCol.Red(), maskCol.Green(), maskCol.Blue());
        img.SetRGB(1, 0, fillCol.Red(), fillCol.Green(), fillCol.Blue());
        img.SetRGB(1, 1, fillCol.Red(), fillCol.Green(), fillCol.Blue());
        img.SetMaskColour(maskCol.Red(), maskCol.Green(), maskCol.Blue());
        REQUIRE_FALSE(img.HasAlpha());
        REQUIRE(img.HasMask() == true);

        wxImage imgRes = img;
        imgRes.InitAlpha();
        REQUIRE(imgRes.HasAlpha() == true);
        REQUIRE_FALSE(imgRes.HasMask());

        for ( int y = 0; y < img.GetHeight(); y++ )
            for ( int x = 0; x < img.GetWidth(); x++ )
            {
                wxColour cSrc(img.GetRed(x, y), img.GetGreen(x, y), img.GetBlue(x, y));
                wxColour cRes(imgRes.GetRed(x, y), imgRes.GetGreen(x, y), imgRes.GetBlue(x, y), imgRes.GetAlpha(x, y));

                CHECK_EQUAL_COLOUR_RGB(cRes, cSrc);
                if ( cSrc == maskCol )
                {
                    CHECK((int)cRes.Alpha() == (int)wxIMAGE_ALPHA_TRANSPARENT);
                }
                else
                {
                    CHECK((int)cRes.Alpha() == (int)wxIMAGE_ALPHA_OPAQUE);
                }
            }
    }

    SECTION("RGBA image without mask")
    {
        wxImage img(2, 2);
        img.SetRGB(0, 0, maskCol.Red(), maskCol.Green(), maskCol.Blue());
        img.SetRGB(0, 1, maskCol.Red(), maskCol.Green(), maskCol.Blue());
        img.SetRGB(1, 0, fillCol.Red(), fillCol.Green(), fillCol.Blue());
        img.SetRGB(1, 1, fillCol.Red(), fillCol.Green(), fillCol.Blue());
        img.SetAlpha();
        img.SetAlpha(0, 0, 128);
        img.SetAlpha(0, 1, 0);
        img.SetAlpha(1, 0, 128);
        img.SetAlpha(1, 1, 0);
        REQUIRE(img.HasAlpha() == true);
        REQUIRE_FALSE(img.HasMask());

        wxImage imgRes = img;
#ifdef __WXDEBUG__
        CHECK_THROWS(imgRes.InitAlpha());
#else
        imgRes.InitAlpha();
#endif
        REQUIRE(imgRes.HasAlpha() == true);
        REQUIRE_FALSE(imgRes.HasMask());

        for ( int y = 0; y < img.GetHeight(); y++ )
            for ( int x = 0; x < img.GetWidth(); x++ )
            {
                wxColour cSrc(img.GetRed(x, y), img.GetGreen(x, y), img.GetBlue(x, y), img.GetAlpha(x, y));
                wxColour cRes(imgRes.GetRed(x, y), imgRes.GetGreen(x, y), imgRes.GetBlue(x, y), imgRes.GetAlpha(x, y));

                CHECK_EQUAL_COLOUR_RGBA(cRes, cSrc);
            }
    }

    SECTION("RGBA image with mask")
    {
        wxImage img(2, 2);
        img.SetRGB(0, 0, maskCol.Red(), maskCol.Green(), maskCol.Blue());
        img.SetRGB(0, 1, maskCol.Red(), maskCol.Green(), maskCol.Blue());
        img.SetRGB(1, 0, fillCol.Red(), fillCol.Green(), fillCol.Blue());
        img.SetRGB(1, 1, fillCol.Red(), fillCol.Green(), fillCol.Blue());
        img.SetAlpha();
        img.SetAlpha(0, 0, 128);
        img.SetAlpha(0, 1, 0);
        img.SetAlpha(1, 0, 128);
        img.SetAlpha(1, 1, 0);
        img.SetMaskColour(maskCol.Red(), maskCol.Green(), maskCol.Blue());
        REQUIRE(img.HasAlpha() == true);
        REQUIRE(img.HasMask() == true);

        wxImage imgRes = img;
#ifdef __WXDEBUG__
        CHECK_THROWS(imgRes.InitAlpha());
#else
        imgRes.InitAlpha();
#endif
        REQUIRE(imgRes.HasAlpha() == true);
        REQUIRE(imgRes.HasMask() == true);

        for ( int y = 0; y < img.GetHeight(); y++ )
            for ( int x = 0; x < img.GetWidth(); x++ )
            {
                wxColour cSrc(img.GetRed(x, y), img.GetGreen(x, y), img.GetBlue(x, y), img.GetAlpha(x, y));
                wxColour cRes(imgRes.GetRed(x, y), imgRes.GetGreen(x, y), imgRes.GetBlue(x, y), imgRes.GetAlpha(x, y));

                CHECK_EQUAL_COLOUR_RGBA(cRes, cSrc);
            }
    }
}

TEST_CASE("wxImage::XPM", "[image][xpm]")
{
   static const char * dummy_xpm[] = {
      "16 16 2 1",
      "@ c Black",
      "  c None",
      "@               ",
      " @              ",
      "  @             ",
      "   @            ",
      "    @           ",
      "     @          ",
      "      @         ",
      "       @        ",
      "        @       ",
      "         @      ",
      "          @     ",
      "           @    ",
      "            @   ",
      "             @  ",
      "              @ ",
      "               @"
   };

   wxImage image(dummy_xpm);
   CHECK( image.IsOk() );

   // The goal here is mostly just to check that this code compiles, i.e. that
   // creating all these classes from XPM works.
   CHECK( wxBitmap(dummy_xpm).IsOk() );
   CHECK( wxCursor(dummy_xpm).IsOk() );
   CHECK( wxIcon(dummy_xpm).IsOk() );
}

TEST_CASE_METHOD(ImageHandlersInit, "wxImage::PNM", "[image][pnm]")
{
#if wxUSE_PNM
    wxImage::AddHandler(new wxPNMHandler);

    SECTION("width*height*3 overflow")
    {
        // wxImage should reject the file as malformed (wxTrac#19326)
        LoadMalformedImageWithException("image/width_height_32_bit_overflow.pgm",
                                        wxBITMAP_TYPE_PNM);
    }
#endif
}

namespace
{

inline ImageRGBMatcher RGBSimilarToFile(const char* name)
{
    INFO("Loading file from " << name);

    wxImage expected;
    REQUIRE(expected.LoadFile(name));

    return ImageRGBMatcher(expected, 1);
}

} // anonymous namespace

TEST_CASE_METHOD(ImageHandlersInit, "wxImage::ChangeColours", "[image]")
{
    wxImage original;
    REQUIRE(original.LoadFile("image/toucan.png", wxBITMAP_TYPE_PNG));

    wxImage test;
    wxImage expected;

    test = original;
    test.RotateHue(0.538);
    CHECK_THAT(test, RGBSimilarToFile("image/toucan_hue_0.538.png"));

    test = original;
    test.ChangeSaturation(-0.41);
    CHECK_THAT(test, RGBSimilarToFile("image/toucan_sat_-0.41.png"));

    test = original;
    test.ChangeBrightness(-0.259);
    CHECK_THAT(test, RGBSimilarToFile("image/toucan_bright_-0.259.png"));

    test = original;
    test.ChangeHSV(0.538, -0.41, -0.259);
    CHECK_THAT(test, RGBSimilarToFile("image/toucan_hsv_0.538_-0.41_-0.259.png"));

    test = original;
    test = test.ChangeLightness(46);
    CHECK_THAT(test, RGBSimilarToFile("image/toucan_light_46.png"));

    test = original;
    test = test.ConvertToDisabled(240);
    CHECK_THAT(test, RGBSimilarToFile("image/toucan_dis_240.png"));

    test = original;
    test = test.ConvertToGreyscale();
    CHECK_THAT(test, RGBSimilarToFile("image/toucan_grey.png"));

    test = original;
    test = test.ConvertToMono(255, 255, 255);
    CHECK_THAT(test, RGBSimilarToFile("image/toucan_mono_255_255_255.png"));
}

TEST_CASE("wxImage::Clear", "[image]")
{
    wxImage image(2, 2);
    image.SetRGB(0, 0, 0xff, 0x00, 0x00);
    image.SetRGB(0, 1, 0x00, 0xff, 0x00);
    image.SetRGB(1, 0, 0x00, 0x00, 0xff);
    image.SetRGB(1, 1, 0xff, 0xff, 0xff);

    wxImage image2{image};

    // Check that the image has the expected red component values initially.
    CHECK( image2.GetRed(0, 0) == 0xff );
    CHECK( image2.GetRed(0, 1) == 0x00 );
    CHECK( image2.GetRed(1, 0) == 0x00 );
    CHECK( image2.GetRed(1, 1) == 0xff );

    // Check that the image got cleared.
    image2.Clear();
    CHECK( image2.GetRed(0, 0) == 0x00 );
    CHECK( image2.GetRed(0, 1) == 0x00 );
    CHECK( image2.GetRed(1, 0) == 0x00 );
    CHECK( image2.GetRed(1, 1) == 0x00 );

    // Check that the original image didn't change (see #23553).
    CHECK( image.GetRed(0, 0) == 0xff );
    CHECK( image.GetRed(1, 1) == 0xff );
}

TEST_CASE("wxImage::SizeLimits", "[image]")
{
#if SIZEOF_VOID_P == 8
    // Check that we can resample an image of size greater than 2^16, which is
    // the limit used in 32-bit code to avoid integer overflows.
    wxImage image(100000, 2);
    REQUIRE_NOTHROW( image = image.ResampleNearest(100000, 1) );
    CHECK( image.GetWidth() == 100000 );
    CHECK( image.GetHeight() == 1 );
#endif // SIZEOF_VOID_P == 8
}

// This can be used to test loading an arbitrary image file by setting the
// environment variable WX_TEST_IMAGE_PATH to point to it.
TEST_CASE_METHOD(ImageHandlersInit, "wxImage::LoadPath", "[.]")
{
    wxString path;
    REQUIRE( wxGetEnv("WX_TEST_IMAGE_PATH", &path) );

    TestLogEnabler enableLogs;

    wxImage image;
    REQUIRE( image.LoadFile(path) );

    WARN("Image "
            << image.GetWidth()
            << "*"
            << image.GetHeight()
            << (image.HasAlpha() ? " with alpha" : "")
            << " loaded");
}

#ifdef wxHAS_SVG

#include "wx/bmpbndl.h"
#include "wx/crt.h"

static wxSize ParseEnvVarAsSize(const wxString& varname)
{
    wxString sizeStr;
    REQUIRE( wxGetEnv(varname, &sizeStr) );

    wxString heightStr;
    unsigned width = 0;
    REQUIRE( sizeStr.BeforeFirst(',', &heightStr).ToUInt(&width) );

    unsigned height = 0;
    if ( !heightStr.empty() )
    {
        REQUIRE( heightStr.ToUInt(&height) );
    }
    else
    {
        height = width;
    }

    return wxSize(width, height);
}

// Compute difference between the 2 images by summing up squares of (naively
// computed, i.e. without any perception-based correction) distances between
// colours for each pixel.
static float ComputeImageDiff(const wxImage& img1, const wxImage& img2)
{
    const wxSize size = img1.GetSize();

    REQUIRE( img2.GetSize() == size );

    const auto sqr = [](int x) { return x * x; };

    const auto numPixels = size.x * size.y;
    const auto end = img1.GetData() + numPixels * 3;

    // Should we take alpha into account here?
    float diff = 0;
    for ( auto p1 = img1.GetData(), p2 = img2.GetData();
          p1 != end;
          p1 += 3, p2 += 3 )
    {
        diff += sqrt(sqr(p1[0] - p2[0]) + sqr(p1[1] - p2[1]) + sqr(p1[2] - p2[2]));
    }

    return diff / numPixels;
}

// The purpose of this test is to compute "resize quality" which is defined as
// the difference between resizing an image obtained by rendering an SVG at
// some resolution to the target size and rendering the same SVG directly at
// the target size.
//
// It requires the following environment variables to be set:
//
//  - WX_TEST_SVG_PATH: path to the SVG file to use
//  - WX_TEST_INITIAL_SIZE: size of the first image to render
//  - WX_TEST_TARGET_SIZE: size of the target image
//
// Sizes can be specified as either "x,y" or just "x" as a shorthand for "x,x".
TEST_CASE_METHOD(ImageHandlersInit, "wxImage::ResizeQuality", "[.]")
{
    wxString path;
    REQUIRE( wxGetEnv("WX_TEST_SVG_PATH", &path) );

    const wxSize startSize = ParseEnvVarAsSize("WX_TEST_INITIAL_SIZE");
    const wxSize targetSize = ParseEnvVarAsSize("WX_TEST_TARGET_SIZE");

    const auto bb = wxBitmapBundle::FromSVGFile(path, startSize);
    REQUIRE( bb.IsOk() );

    const wxImage initial = bb.GetBitmap(startSize).ConvertToImage();
    const wxImage rendered = bb.GetBitmap(targetSize).ConvertToImage();

    wxFprintf(stderr, "Error per pixel when resizing %d*%d to %d*%d:\n",
             startSize.x, startSize.y, targetSize.x, targetSize.y);
    wxFprintf(stderr, "  Normal:   %f\n", ComputeImageDiff(rendered,
                initial.Scale(targetSize)));
    wxFprintf(stderr, "  Nearest:  %f\n", ComputeImageDiff(rendered,
                initial.Scale(targetSize, wxIMAGE_QUALITY_NEAREST)));
    wxFprintf(stderr, "  Box avg:  %f\n", ComputeImageDiff(rendered,
                initial.Scale(targetSize, wxIMAGE_QUALITY_BOX_AVERAGE)));
    wxFprintf(stderr, "  Bilinear: %f\n", ComputeImageDiff(rendered,
                initial.Scale(targetSize, wxIMAGE_QUALITY_BILINEAR)));
    wxFprintf(stderr, "  Bicubic:  %f\n", ComputeImageDiff(rendered,
                initial.Scale(targetSize, wxIMAGE_QUALITY_BICUBIC)));
}

#endif // wxHAS_SVG

TEST_CASE_METHOD(ImageHandlersInit, "wxImage::Cursor", "[image][cursor]")
{
    // cursor from file
    wxCursor cursor1("horse.cur", wxBITMAP_TYPE_CUR);
    CHECK( cursor1.IsOk() );
    wxCursor cursor2("horse.ico", wxBITMAP_TYPE_ICO);
    CHECK( cursor2.IsOk() );
    wxCursor cursor3("horse.bmp", wxBITMAP_TYPE_BMP);
    CHECK( cursor3.IsOk() );

    // converted horse.cur to XBM, 32x32px, hotspot 16,23
    static const unsigned char xbm_horse[] = {
        0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00,
        0x00, 0x1F, 0x00, 0x00, 0xC0, 0x1F, 0x00, 0x00, 0xF8, 0x3F, 0x00, 0x00,
        0xFF, 0x3F, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00,
        0xFF, 0xFF, 0x01, 0x00, 0xFF, 0xFF, 0x01, 0x00, 0xFF, 0xFF, 0x01, 0x00,
        0xFF, 0xFF, 0x03, 0x00, 0xFF, 0xFF, 0x03, 0x00, 0xFF, 0xFF, 0x07, 0x00,
        0xFF, 0xFF, 0x07, 0x00, 0xFF, 0xFF, 0x07, 0x00, 0xFF, 0xFF, 0x07, 0x00,
        0xFF, 0xFF, 0x0F, 0x00, 0xFF, 0xFF, 0x0F, 0x00, 0xBF, 0xFF, 0x1F, 0x00,
        0x1F, 0xFE, 0x1F, 0x00, 0x0F, 0x7C, 0x1E, 0x00, 0x0F, 0x78, 0x3E, 0x00,
        0x07, 0xF0, 0x3F, 0x00, 0x03, 0xE0, 0x3F, 0x00, 0x01, 0xC0, 0x1F, 0x00,
        0x00, 0x80, 0x0F, 0x00, 0x00, 0x80, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
    };

    wxBitmap bmp((const char*)xbm_horse, 32, 32);
    REQUIRE( bmp.IsOk() );
    wxCursor cursorFromBmp(bmp, 16, 23);
    CHECK( cursorFromBmp.IsOk() );

    wxImage img = bmp.ConvertToImage();
    REQUIRE( img.IsOk() );
    img.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_X, 16);
    img.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_Y, 23);
    wxCursor cursor4(img);
    CHECK( cursor4.IsOk() );

#if defined(__WXGTK__)
    // GTK has a constructor accepting XBM
    wxCursor cursor5((const char*)xbm_horse, 32, 32, 16, 23, nullptr, wxWHITE, wxBLACK);
    CHECK( cursor5.IsOk() );
#endif

    // cursor from resource (win32 .rc file, macOS app resources)
#if defined( __WXMSW__ ) || defined( __WXOSX__ )
    wxCursor cursor6("horse");
    CHECK( cursor6.IsOk() );
#endif
#if defined( __WXOSX__ )
    wxCursor cursor7("bullseye");
    CHECK( cursor7.IsOk() );
#endif
}

/*
    TODO: add lots of more tests to wxImage functions
*/

#endif //wxUSE_IMAGE
