///////////////////////////////////////////////////////////////////////////////
// Name:        tests/graphics/imagelist.cpp
// Purpose:     image list unit tests
// Author:      Artur Wieczorek
// Created:     2021-01-11
// Copyright:   (c) 2021 wxWidgets development team
///////////////////////////////////////////////////////////////////////////////

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

#include "testprec.h"


#include "wx/bitmap.h"
#include "wx/graphics.h"
#include "wx/icon.h"
#include "wx/imaglist.h"

#include "wx/dcmemory.h"

static bool HasNoRealAlpha(const wxBitmap& bmp)
{
    if ( !bmp.HasAlpha() )
        return true;

    // wxMSW can add a fully opaque alpha channel to the bitmaps used in the
    // image list.
    const wxImage img = bmp.ConvertToImage();
    const unsigned char* p = img.GetAlpha();
    if ( !p )
        return true;

    const unsigned char* const end = p + img.GetWidth()*img.GetHeight();
    for ( ; p < end; ++p )
    {
        if ( *p != wxALPHA_OPAQUE )
            return false;
    }

    return true;
}

static bool HasMaskOrAlpha(const wxBitmap& bmp)
{
    // When adding bitmaps with mask to the image list, the mask can be
    // transformed to alpha channel internally, so check that the bitmap has
    // either mask or alpha.
    return bmp.HasAlpha() || bmp.GetMask();
}

// ----------------------------------------------------------------------------
// test fixture
// ----------------------------------------------------------------------------

class ImageListTestCase
{
protected:
    ImageListTestCase();

    const wxSize BITMAP_SIZE;

    wxBitmap bmpRGB, bmpRGBA, bmpMask,
             bmpRGBWithMask, bmpRGBAWithMask;
    wxIcon ico;
};

ImageListTestCase::ImageListTestCase()
                 : BITMAP_SIZE(32, 32),
                   bmpRGB(BITMAP_SIZE, 24),
                   bmpMask(BITMAP_SIZE, 1)
{
    {
        wxMemoryDC mdc(bmpRGB);
        mdc.SetBackground(*wxBLUE_BRUSH);
        mdc.Clear();
        mdc.SetBrush(*wxRED_BRUSH);
        mdc.DrawRectangle(4, 4, 24, 24);
    }
    REQUIRE(bmpRGB.IsOk());

    // Make a bitmap with some transparent and semi-transparent pixels.
    wxImage imgWithAlpha(BITMAP_SIZE.x, BITMAP_SIZE.y);
    imgWithAlpha.SetAlpha();
    unsigned char* const alpha = imgWithAlpha.GetAlpha();
    for ( unsigned char* a = alpha; a < alpha + BITMAP_SIZE.x*BITMAP_SIZE.y; ++a )
        *a = wxALPHA_OPAQUE;
    alpha[0] = wxALPHA_TRANSPARENT;
    alpha[1] = wxALPHA_OPAQUE / 2;
    bmpRGBA = wxBitmap(imgWithAlpha);
    REQUIRE(bmpRGBA.IsOk());

    {
        wxMemoryDC mdc(bmpMask);
#if wxUSE_GRAPHICS_CONTEXT
        wxGraphicsContext* gc = mdc.GetGraphicsContext();
        if ( gc )
            gc->SetAntialiasMode(wxANTIALIAS_NONE);
#endif //wxUSE_GRAPHICS_CONTEXT
        mdc.SetBackground(*wxBLACK_BRUSH);
        mdc.Clear();
        mdc.SetBrush(*wxWHITE_BRUSH);
        mdc.DrawRectangle(0, 0, 16, 32);
    }

    bmpRGBWithMask = bmpRGB;
    bmpRGBWithMask.SetMask(new wxMask(bmpMask));
    REQUIRE(bmpRGBWithMask.IsOk());

    bmpRGBAWithMask = bmpRGBA;
    bmpRGBAWithMask.SetMask(new wxMask(bmpMask));
    REQUIRE(bmpRGBAWithMask.IsOk());

    ico.CopyFromBitmap(bmpRGBWithMask);
    REQUIRE(ico.IsOk());

    REQUIRE(bmpRGB.HasAlpha() == false);
    REQUIRE(bmpRGB.GetMask() == nullptr);

    REQUIRE(bmpRGBWithMask.HasAlpha() == false);
    REQUIRE(bmpRGBWithMask.GetMask() != nullptr);

    REQUIRE(bmpRGBA.HasAlpha() == true);
    REQUIRE(bmpRGBA.GetMask() == nullptr);

    REQUIRE(bmpRGBAWithMask.HasAlpha() == true);
    REQUIRE(bmpRGBAWithMask.GetMask() != nullptr);
}

// ----------------------------------------------------------------------------
// tests
// ----------------------------------------------------------------------------

TEST_CASE_METHOD(ImageListTestCase,
                 "ImageList:WithMask", "[imagelist][withmask]")
{
    wxImageList il(BITMAP_SIZE.x, BITMAP_SIZE.y, true);

    SECTION("Add RGB image to list")
    {
        il.RemoveAll();
        int idx = il.Add(bmpRGB);
        CHECK(il.GetImageCount() == 1);
        wxBitmap bmp1 = il.GetBitmap(idx);
        CHECK(HasNoRealAlpha(bmp1));
        CHECK(bmp1.GetSize() == BITMAP_SIZE);

        idx = il.Add(bmpRGBWithMask);
        CHECK(il.GetImageCount() == 2);
        wxBitmap bmp2 = il.GetBitmap(idx);
        CHECK(HasMaskOrAlpha(bmp2));
        CHECK(bmp2.GetSize() == BITMAP_SIZE);

        idx = il.Add(bmpRGB, *wxRED);
        CHECK(il.GetImageCount() == 3);
        wxBitmap bmp3 = il.GetBitmap(idx);
        CHECK(HasMaskOrAlpha(bmp3));
        CHECK(bmp3.GetSize() == BITMAP_SIZE);
    }

    SECTION("Add RGBA image to list")
    {
        il.RemoveAll();
        int idx = il.Add(bmpRGBA);
        CHECK(il.GetImageCount() == 1);
        wxBitmap bmp1 = il.GetBitmap(idx);
        CHECK(HasMaskOrAlpha(bmp1));
        CHECK(bmp1.GetSize() == BITMAP_SIZE);

        idx = il.Add(bmpRGBAWithMask);
        CHECK(il.GetImageCount() == 2);
        wxBitmap bmp2 = il.GetBitmap(idx);
        CHECK(HasMaskOrAlpha(bmp2));
        CHECK(bmp2.GetSize() == BITMAP_SIZE);

        idx = il.Add(bmpRGBA, *wxRED);
        CHECK(il.GetImageCount() == 3);
        wxBitmap bmp3 = il.GetBitmap(idx);
        CHECK(HasMaskOrAlpha(bmp3));
        CHECK(bmp3.GetSize() == BITMAP_SIZE);
    }

    SECTION("Add icon to list")
    {
        il.RemoveAll();
        int idx = il.Add(ico);
        CHECK(il.GetImageCount() == 1);
        wxIcon icon1 = il.GetIcon(idx);
        CHECK(icon1.GetSize() == BITMAP_SIZE);
    }

    SECTION("Replace with RGB image")
    {
        il.RemoveAll();
        int idx1 = il.Add(bmpRGBA);
        CHECK(il.GetImageCount() == 1);
        int idx2 = il.Add(bmpRGBAWithMask);
        CHECK(il.GetImageCount() == 2);

        il.Replace(idx1, bmpRGB);
        il.Replace(idx2, bmpRGBWithMask);

        wxBitmap bmp1 = il.GetBitmap(idx1);
        CHECK(HasMaskOrAlpha(bmp1));
        CHECK(bmp1.GetSize() == BITMAP_SIZE);

        wxBitmap bmp2 = il.GetBitmap(idx2);
        CHECK(HasMaskOrAlpha(bmp2));
        CHECK(bmp2.GetSize() == BITMAP_SIZE);
    }

    SECTION("Replace with RGBA image")
    {
        il.RemoveAll();
        int idx1 = il.Add(bmpRGB);
        CHECK(il.GetImageCount() == 1);
        int idx2 = il.Add(bmpRGBWithMask);
        CHECK(il.GetImageCount() == 2);

        il.Replace(idx1, bmpRGBA);
        il.Replace(idx2, bmpRGBAWithMask);

        wxBitmap bmp1 = il.GetBitmap(idx1);
        CHECK(HasMaskOrAlpha(bmp1));
        CHECK(bmp1.GetSize() == BITMAP_SIZE);

        wxBitmap bmp2 = il.GetBitmap(idx2);
        CHECK(HasMaskOrAlpha(bmp2));
        CHECK(bmp2.GetSize() == BITMAP_SIZE);
    }

    SECTION("Add images with incompatible sizes")
    {
        il.RemoveAll();
        wxSize sz = il.GetSize();

        wxBitmap bmpSmallerW(sz.GetWidth() / 2, sz.GetHeight(), 24);
        {
            wxMemoryDC mdc(bmpSmallerW);
            mdc.SetBackground(*wxBLUE_BRUSH);
            mdc.Clear();
        }
        REQUIRE(bmpSmallerW.IsOk());

        wxBitmap bmpSmallerH(sz.GetWidth(), sz.GetHeight() / 2, 24);
        {
            wxMemoryDC mdc(bmpSmallerH);
            mdc.SetBackground(*wxBLUE_BRUSH);
            mdc.Clear();
        }
        REQUIRE(bmpSmallerH.IsOk());

        wxBitmap bmpSmallerWH(sz.GetWidth() / 2, sz.GetHeight() / 2, 24);
        {
            wxMemoryDC mdc(bmpSmallerWH);
            mdc.SetBackground(*wxBLUE_BRUSH);
            mdc.Clear();
        }
        REQUIRE(bmpSmallerWH.IsOk());

        wxBitmap bmpBiggerW(sz.GetWidth() * 3 / 2, sz.GetHeight(), 24);
        {
            wxMemoryDC mdc(bmpBiggerW);
            mdc.SetBackground(*wxBLUE_BRUSH);
            mdc.Clear();
        }
        REQUIRE(bmpBiggerW.IsOk());

        wxBitmap bmpBiggerW2x(sz.GetWidth() * 2, sz.GetHeight(), 24);
        {
            wxMemoryDC mdc(bmpBiggerW2x);
            mdc.SetBackground(*wxBLUE_BRUSH);
            mdc.Clear();
        }
        REQUIRE(bmpBiggerW2x.IsOk());

        wxBitmap bmpBiggerH(sz.GetWidth(), sz.GetHeight() * 3 / 2, 24);
        {
            wxMemoryDC mdc(bmpBiggerH);
            mdc.SetBackground(*wxBLUE_BRUSH);
            mdc.Clear();
        }
        REQUIRE(bmpBiggerH.IsOk());

        wxBitmap bmpBiggerH2x(sz.GetWidth(), sz.GetHeight() * 2, 24);
        {
            wxMemoryDC mdc(bmpBiggerH2x);
            mdc.SetBackground(*wxBLUE_BRUSH);
            mdc.Clear();
        }
        REQUIRE(bmpBiggerH2x.IsOk());

        wxBitmap bmpBiggerWH(sz.GetWidth() * 3 / 2, sz.GetHeight() * 3 / 2, 24);
        {
            wxMemoryDC mdc(bmpBiggerWH);
            mdc.SetBackground(*wxBLUE_BRUSH);
            mdc.Clear();
        }
        REQUIRE(bmpBiggerWH.IsOk());

        wxBitmap bmpBiggerWH2x(sz.GetWidth() * 2, sz.GetHeight() * 2, 24);
        {
            wxMemoryDC mdc(bmpBiggerWH2x);
            mdc.SetBackground(*wxBLUE_BRUSH);
            mdc.Clear();
        }
        REQUIRE(bmpBiggerWH2x.IsOk());

        // Adding
        int cnt = il.GetImageCount();
        int idx = il.Add(bmpSmallerW);
        CHECK(idx == -1);
        CHECK(il.GetImageCount() == cnt);

        cnt = il.GetImageCount();
        idx = il.Add(bmpSmallerH);
        CHECK(idx >= 0);
        CHECK(il.GetImageCount() == cnt + 1);
        wxBitmap bmp = il.GetBitmap(idx);
        CHECK(bmp.GetWidth() == sz.GetWidth());
        CHECK(bmp.GetHeight() == sz.GetHeight());

        cnt = il.GetImageCount();
        idx = il.Add(bmpSmallerWH);
        CHECK(idx == -1);
        CHECK(il.GetImageCount() == cnt);

        cnt = il.GetImageCount();
        idx = il.Add(bmpBiggerW);
        CHECK(idx >= 0);
        CHECK(il.GetImageCount() == cnt + 1);
        bmp = il.GetBitmap(idx);
        CHECK(bmp.GetWidth() == sz.GetWidth());
        CHECK(bmp.GetHeight() == sz.GetHeight());

        cnt = il.GetImageCount();
        idx = il.Add(bmpBiggerW2x);
        CHECK(idx >= 0);
        CHECK(il.GetImageCount() == cnt + 2);
        bmp = il.GetBitmap(idx);
        CHECK(bmp.GetWidth() == sz.GetWidth());
        CHECK(bmp.GetHeight() == sz.GetHeight());

        cnt = il.GetImageCount();
        idx = il.Add(bmpBiggerH);
        CHECK(idx >= 0);
        CHECK(il.GetImageCount() == cnt + 1);
        bmp = il.GetBitmap(idx);
        CHECK(bmp.GetWidth() == sz.GetWidth());
        CHECK(bmp.GetHeight() == sz.GetHeight());

        cnt = il.GetImageCount();
        idx = il.Add(bmpBiggerH2x);
        CHECK(idx >= 0);
        CHECK(il.GetImageCount() == cnt + 1);
        bmp = il.GetBitmap(idx);
        CHECK(bmp.GetWidth() == sz.GetWidth());
        CHECK(bmp.GetHeight() == sz.GetHeight());

        cnt = il.GetImageCount();
        idx = il.Add(bmpBiggerWH);
        CHECK(idx >= 0);
        CHECK(il.GetImageCount() == cnt + 1);
        bmp = il.GetBitmap(idx);
        CHECK(bmp.GetWidth() == sz.GetWidth());
        CHECK(bmp.GetHeight() == sz.GetHeight());

        cnt = il.GetImageCount();
        idx = il.Add(bmpBiggerWH2x);
        CHECK(idx >= 0);
        CHECK(il.GetImageCount() == cnt + 2);
        bmp = il.GetBitmap(idx);
        CHECK(bmp.GetWidth() == sz.GetWidth());
        CHECK(bmp.GetHeight() == sz.GetHeight());

        // Replacing
        il.RemoveAll();

        cnt = il.GetImageCount();
        bool ok = il.Replace(0, bmpRGBA);
        CHECK(ok == false);
        CHECK(il.GetImageCount() == cnt);

        // List with 1 image
        idx = il.Add(bmpRGB);
        CHECK(idx >= 0);

        cnt = il.GetImageCount();
        ok = il.Replace(0, bmpRGBA);
        CHECK(ok == true);
        CHECK(il.GetImageCount() == cnt);
        bmp = il.GetBitmap(0);
        CHECK(bmp.GetWidth() == sz.GetWidth());
        CHECK(bmp.GetHeight() == sz.GetHeight());

        cnt = il.GetImageCount();
        ok = il.Replace(0, bmpSmallerW);
        CHECK(ok == true);
        CHECK(il.GetImageCount() == cnt);
        bmp = il.GetBitmap(0);
        CHECK(bmp.GetWidth() == sz.GetWidth());
        CHECK(bmp.GetHeight() == sz.GetHeight());

        cnt = il.GetImageCount();
        ok = il.Replace(0, bmpSmallerH);
        CHECK(ok == true);
        CHECK(il.GetImageCount() == cnt);
        bmp = il.GetBitmap(0);
        CHECK(bmp.GetWidth() == sz.GetWidth());
        CHECK(bmp.GetHeight() == sz.GetHeight());

        cnt = il.GetImageCount();
        ok = il.Replace(0, bmpSmallerWH);
        CHECK(ok == true);
        CHECK(il.GetImageCount() == cnt);
        bmp = il.GetBitmap(0);
        CHECK(bmp.GetWidth() == sz.GetWidth());
        CHECK(bmp.GetHeight() == sz.GetHeight());

        cnt = il.GetImageCount();
        ok = il.Replace(0, bmpBiggerW);
        CHECK(ok == true);
        CHECK(il.GetImageCount() == cnt);
        bmp = il.GetBitmap(0);
        CHECK(bmp.GetWidth() == sz.GetWidth());
        CHECK(bmp.GetHeight() == sz.GetHeight());

        cnt = il.GetImageCount();
        ok = il.Replace(0, bmpBiggerW2x);
        CHECK(ok == true);
        CHECK(il.GetImageCount() == cnt);
        bmp = il.GetBitmap(0);
        CHECK(bmp.GetWidth() == sz.GetWidth());
        CHECK(bmp.GetHeight() == sz.GetHeight());

        cnt = il.GetImageCount();
        ok = il.Replace(0, bmpBiggerH);
        CHECK(ok == true);
        CHECK(il.GetImageCount() == cnt);
        bmp = il.GetBitmap(0);
        CHECK(bmp.GetWidth() == sz.GetWidth());
        CHECK(bmp.GetHeight() == sz.GetHeight());

        cnt = il.GetImageCount();
        ok = il.Replace(0, bmpBiggerH2x);
        CHECK(ok == true);
        CHECK(il.GetImageCount() == cnt);
        bmp = il.GetBitmap(0);
        CHECK(bmp.GetWidth() == sz.GetWidth());
        CHECK(bmp.GetHeight() == sz.GetHeight());

        cnt = il.GetImageCount();
        ok = il.Replace(0, bmpBiggerWH);
        CHECK(ok == true);
        CHECK(il.GetImageCount() == cnt);
        bmp = il.GetBitmap(0);
        CHECK(bmp.GetWidth() == sz.GetWidth());
        CHECK(bmp.GetHeight() == sz.GetHeight());

        cnt = il.GetImageCount();
        ok = il.Replace(0, bmpBiggerWH2x);
        CHECK(ok == true);
        CHECK(il.GetImageCount() == cnt);
        bmp = il.GetBitmap(0);
        CHECK(bmp.GetWidth() == sz.GetWidth());
        CHECK(bmp.GetHeight() == sz.GetHeight());
    }
}

TEST_CASE_METHOD(ImageListTestCase,
                 "ImageList:NoMask", "[imagelist][nomask]")
{
    wxImageList il(BITMAP_SIZE.x, BITMAP_SIZE.y, false);

    SECTION("Add RGB image to list")
    {
        il.RemoveAll();
        int idx = il.Add(bmpRGB);
        CHECK(il.GetImageCount() == 1);
        wxBitmap bmp1 = il.GetBitmap(idx);
        CHECK(bmp1.HasAlpha() == false);
        CHECK(bmp1.GetMask() == nullptr);
        CHECK(bmp1.GetSize() == BITMAP_SIZE);

        idx = il.Add(bmpRGBWithMask);
        CHECK(il.GetImageCount() == 2);
        wxBitmap bmp2 = il.GetBitmap(idx);
        CHECK(HasMaskOrAlpha(bmp2));
        CHECK(bmp2.GetSize() == BITMAP_SIZE);

        idx = il.Add(bmpRGB, *wxRED);
        CHECK(il.GetImageCount() == 3);
        wxBitmap bmp3 = il.GetBitmap(idx);
        CHECK(HasMaskOrAlpha(bmp3));
        CHECK(bmp3.GetSize() == BITMAP_SIZE);
    }

    SECTION("Add RGBA image to list")
    {
        il.RemoveAll();
        int idx = il.Add(bmpRGBA);
        CHECK(il.GetImageCount() == 1);
        wxBitmap bmp1 = il.GetBitmap(idx);
        CHECK(bmp1.HasAlpha() == true);
        CHECK(bmp1.GetMask() == nullptr);
        CHECK(bmp1.GetSize() == BITMAP_SIZE);

        idx = il.Add(bmpRGBAWithMask);
        CHECK(il.GetImageCount() == 2);
        wxBitmap bmp2 = il.GetBitmap(idx);
        CHECK(HasMaskOrAlpha(bmp2));
        CHECK(bmp2.GetSize() == BITMAP_SIZE);

        idx = il.Add(bmpRGBA, *wxRED);
        CHECK(il.GetImageCount() == 3);
        wxBitmap bmp3 = il.GetBitmap(idx);
        CHECK(HasMaskOrAlpha(bmp3));
        CHECK(bmp3.GetSize() == BITMAP_SIZE);
    }

    SECTION("Add icon to list")
    {
        il.RemoveAll();
        int idx = il.Add(ico);
        CHECK(il.GetImageCount() == 1);
        wxIcon icon1 = il.GetIcon(idx);
        CHECK(icon1.GetSize() == BITMAP_SIZE);
    }

    SECTION("Replace with RGB image")
    {
        il.RemoveAll();
        int idx1 = il.Add(bmpRGBA);
        CHECK(il.GetImageCount() == 1);
        int idx2 = il.Add(bmpRGBAWithMask);
        CHECK(il.GetImageCount() == 2);

        il.Replace(idx1, bmpRGB);
        il.Replace(idx2, bmpRGBWithMask);

        wxBitmap bmp1 = il.GetBitmap(idx1);
        CHECK(bmp1.HasAlpha() == false);
        CHECK(bmp1.GetMask() == nullptr);
        CHECK(bmp1.GetSize() == BITMAP_SIZE);

        wxBitmap bmp2 = il.GetBitmap(idx2);
        CHECK(HasMaskOrAlpha(bmp2));
        CHECK(bmp2.GetSize() == BITMAP_SIZE);
    }

    SECTION("Replace with RGBA image")
    {
        il.RemoveAll();
        int idx1 = il.Add(bmpRGB);
        CHECK(il.GetImageCount() == 1);
        int idx2 = il.Add(bmpRGBWithMask);
        CHECK(il.GetImageCount() == 2);

        il.Replace(idx1, bmpRGBA);
        il.Replace(idx2, bmpRGBAWithMask);

        wxBitmap bmp1 = il.GetBitmap(idx1);
        CHECK(bmp1.HasAlpha() == true);
        CHECK(bmp1.GetMask() == nullptr);
        CHECK(bmp1.GetSize() == BITMAP_SIZE);

        wxBitmap bmp2 = il.GetBitmap(idx2);
        CHECK(HasMaskOrAlpha(bmp2));
        CHECK(bmp2.GetSize() == BITMAP_SIZE);
    }

    SECTION("Add 2x width image")
    {
        il.RemoveAll();
        int idx = il.Add(wxBitmap(BITMAP_SIZE.x * 2, BITMAP_SIZE.y));
        CHECK(idx == 0);
        CHECK(il.GetImageCount() == 2);
    }
}

TEST_CASE("ImageList:NegativeTests", "[imagelist][negative]")
{
    wxBitmap bmp(32, 32, 24);
    {
        wxMemoryDC mdc(bmp);
        mdc.SetBackground(*wxBLUE_BRUSH);
        mdc.Clear();
        mdc.SetBrush(*wxRED_BRUSH);
        mdc.DrawRectangle(4, 4, 24, 24);
    }
    REQUIRE(bmp.IsOk());

    SECTION("Invalid size (negative)")
    {
        wxImageList il;
        bool ok = il.Create(-1, -1);
        CHECK_FALSE(ok);
#ifdef __WXDEBUG__
        REQUIRE_THROWS(il.GetImageCount());
#else
        CHECK(il.GetImageCount() == 0);
#endif

        wxSize sz = il.GetSize();
        CHECK(sz.x == 0);
        CHECK(sz.y == 0);

        int w = -1;
        int h = -1;
#ifdef __WXDEBUG__
        REQUIRE_THROWS(il.GetSize(0, w, h));
#else
        ok = il.GetSize(0, w, h);
        CHECK_FALSE(ok);
        CHECK(w == 0);
        CHECK(h == 0);
#endif

#ifdef __WXDEBUG__
        CHECK_THROWS(il.Add(bmp));
        REQUIRE_THROWS(il.GetImageCount());
#else
        CHECK(il.Add(bmp) == -1);
        CHECK(il.GetImageCount() == 0);
#endif
    }

    SECTION("Invalid size (zero)")
    {
        wxImageList il;
        bool ok = il.Create(0, 0);
        CHECK_FALSE(ok);
#ifdef __WXDEBUG__
        REQUIRE_THROWS(il.GetImageCount());
#else
        CHECK(il.GetImageCount() == 0);
#endif

        wxSize sz = il.GetSize();
        CHECK(sz.x == 0);
        CHECK(sz.y == 0);

        int w = -1;
        int h = -1;
#ifdef __WXDEBUG__
        REQUIRE_THROWS(ok = il.GetSize(0, w, h));
#else
        ok = il.GetSize(0, w, h);
        CHECK_FALSE(ok);
        CHECK(w == 0);
        CHECK(h == 0);
#endif

#ifdef __WXDEBUG__
        CHECK_THROWS(il.Add(bmp));
        REQUIRE_THROWS(il.GetImageCount());
#else
        CHECK(il.Add(bmp) == -1);
        CHECK(il.GetImageCount() == 0);
#endif

#ifdef __WXDEBUG__
        CHECK_THROWS(il.Replace(0, bmp));
        REQUIRE_THROWS(il.GetImageCount());
#else
        CHECK_FALSE(il.Replace(0, bmp));
        CHECK(il.GetImageCount() == 0);
#endif
    }

    SECTION("Add to invalid image list")
    {
        wxImageList il;
#ifdef __WXDEBUG__
        CHECK_THROWS( il.Add(bmp) );
#else
        CHECK( il.Add(bmp) == -1 );
#endif
    }

    SECTION("Invalid Get/Replace/Remove indices")
    {
        wxImageList il(32, 32, false);
        CHECK(il.GetImageCount() == 0);

        wxSize sz = il.GetSize();
        CHECK(sz.x == 32);
        CHECK(sz.y == 32);

        int w = -1;
        int h = -1;
        bool ok = il.GetSize(0, w, h);
        CHECK(ok == true);
        CHECK(w == 32);
        CHECK(h == 32);

        int idx = il.Add(bmp);
        CHECK(idx == 0);
        CHECK(il.GetImageCount() == 1);

        wxBitmap bmp2 = il.GetBitmap(-1);
        CHECK_FALSE(bmp2.IsOk());
        CHECK(il.GetImageCount() == 1);

        wxBitmap bmp3 = il.GetBitmap(5);
        CHECK_FALSE(bmp3.IsOk());
        CHECK(il.GetImageCount() == 1);

        wxIcon icon2 = il.GetIcon(-1);
        CHECK_FALSE(icon2.IsOk());
        CHECK(il.GetImageCount() == 1);

        wxBitmap icon3 = il.GetIcon(5);
        CHECK_FALSE(icon3.IsOk());
        CHECK(il.GetImageCount() == 1);

        ok = il.Replace(-1, bmp);
        CHECK_FALSE(ok);
        CHECK(il.GetImageCount() == 1);

        ok = il.Replace(5, bmp);
        CHECK_FALSE(ok);
        CHECK(il.GetImageCount() == 1);

        ok = il.Remove(-1);
        CHECK_FALSE(ok);
        CHECK(il.GetImageCount() == 1);

        ok = il.Remove(5);
        CHECK_FALSE(ok);
        CHECK(il.GetImageCount() == 1);
    }
}

// This test relies on logical pixels being different from physical ones.
#ifdef wxHAS_DPI_INDEPENDENT_PIXELS

TEST_CASE("ImageList:HiDPI", "[imagelist][hidpi]")
{
    wxImage img1(8, 4);
    img1.SetRGB(wxRect(0, 0, 8, 4), 0, 63, 127);
    REQUIRE(img1.IsOk());

    wxImage img2(16, 8);
    img2.SetRGB(wxRect(0, 0, 16, 8), 255, 128, 64);
    REQUIRE(img2.IsOk());

    wxBitmap bmp1x(img1, -1, 1.0);
    REQUIRE(bmp1x.IsOk());
    CHECK(bmp1x.GetSize() == wxSize(8, 4));
    CHECK(bmp1x.GetLogicalSize() == wxSize(8, 4));
    CHECK_FALSE(bmp1x.HasAlpha());
    CHECK(bmp1x.GetMask() == nullptr);

    wxBitmap bmp2x(img2, -1, 2.0);
    REQUIRE(bmp2x.IsOk());
    CHECK(bmp2x.GetSize() == wxSize(16, 8));
    CHECK(bmp2x.GetLogicalSize() == wxSize(8, 4));
    CHECK_FALSE(bmp2x.HasAlpha());
    CHECK(bmp2x.GetMask() == nullptr);

    // Logical image size
    wxImageList il(8, 4, false);

    int idx = il.Add(bmp2x);
    REQUIRE(idx == 0);
    REQUIRE(il.GetImageCount() == 1);

    idx = il.Add(bmp1x);
    REQUIRE(idx == 1);
    REQUIRE(il.GetImageCount() == 2);

    wxBitmap bmp = il.GetBitmap(0);
    REQUIRE(bmp.IsOk() == true);
    CHECK(bmp.GetScaleFactor() == 2.0);
    CHECK(bmp.GetSize() == wxSize(16, 8));
    CHECK(bmp.GetLogicalSize() == wxSize(8, 4));
    CHECK_FALSE(bmp.HasAlpha());
    CHECK(bmp.GetMask() == nullptr);

    bmp = il.GetBitmap(1);
    REQUIRE(bmp.IsOk() == true);
    CHECK(bmp.GetScaleFactor() == 1.0);
    CHECK(bmp.GetSize() == wxSize(8, 4));
    CHECK(bmp.GetLogicalSize() == wxSize(8, 4));
    CHECK_FALSE(bmp.HasAlpha());
    CHECK(bmp.GetMask() == nullptr);
}
#endif // wxHAS_DPI_INDEPENDENT_PIXELS
