@amazon-devices/expo-image 2.0.1758683737

package/kepler/test/ExpoImageComponent.cpp

@@ -0,0 +1,290 @@
+#include "../ExpoImageComponent.h"
+
+#include <KeplerScript/utils/image/KeplerScriptImageCacheHandler.h>
+#include <gmock/gmock-actions.h>
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include "catch.hpp"
+
+class MockImageLoaderDelegate : public volta::IImageLoaderDelegate {
+public:
+    MOCK_METHOD(void, notifyImageLoadStart, (), (override));
+    MOCK_METHOD(void, notifyImageLoadProgress, (float progress), (override));
+    MOCK_METHOD(void, notifyImageLoadSuccess, (volta::graphics::Image image), (override));
+    MOCK_METHOD(void, notifyImageLoadSuccess, (volta::image::ImageRef imageRef), (override));
+    MOCK_METHOD(
+            void,
+            notifyAnimatedImageLoadSuccess,
+            (std::shared_ptr<volta::animation::AnimatedImageDrawableLayer> image),
+            (override));
+    MOCK_METHOD(
+            void,
+            notifyNinePatchImageLoadSuccess,
+            (std::shared_ptr<volta::graphics::NinePatchImage> image),
+            (override));
+    MOCK_METHOD(void, notifyImageLoadFailure, (volta::ImageLoadError error), (override));
+    MOCK_METHOD(void, notifyImageLoadCancelled, (), (override));
+    MOCK_METHOD(void, notifyImagePrefetchFailure, (volta::ImageLoadError error), (override));
+    MOCK_METHOD(void, notifyImagePrefetchComplete, (), (override));
+};
+
+std::unique_ptr<volta::graphics::Image> mockImage(int width, int height) {
+    auto data = std::make_unique<uint8_t[]>(height * width * 4);
+    return volta::graphics::Image::makeRasterImage(
+            volta::graphics::Size{static_cast<float>(width), static_cast<float>(height)},
+            std::move(data),
+            width * 4);
+}
+
+class MockImageWrapper : public ImageWrapper {
+public:
+    MockImageWrapper(
+            int width,
+            int height,
+            const facebook::react::ImageSource& source,
+            const volta::IImageLoaderDelegate::Shared& loaderDelegate) :
+            ImageWrapper(source, loaderDelegate) {
+        image_ = mockImage(width, height);
+    }
+
+    void load() override {
+        return;
+    }
+    bool isLoaded() override {
+        return true;
+    }
+    volta::graphics::Image* getImage() {
+        return image_.get();
+    }
+
+private:
+    std::unique_ptr<volta::graphics::Image> image_;
+};
+
+TEST_CASE("ExpoImageDrawableLayer") {
+    ExpoImageDrawableLayer layer;
+    volta::graphics::Canvas canvas;
+    auto mockImg = mockImage(100, 100);
+
+    SECTION("setSize") {
+        auto size = volta::graphics::Size{21.f, 37.f};
+        layer.setSize(size);
+
+        EXPECT_EQ(layer.size_, size);
+    }
+
+    // TODO: PROJVEGA-211833 - Fix these test cases - removing volta::graphics::Canvas mocks
+    // SECTION("onDraw") {
+    //     facebook::react::ImageSource source;
+    //     auto delegate = std::make_shared<MockImageLoaderDelegate>();
+    //     auto clipRect = volta::graphics::Rect{0.f, 0.f, 50.f, 50.f};
+
+    //     EXPECT_CALL(canvas, drawImageRect2(testing::_, testing::_, testing::_, testing::_)).Times(1);
+    //     EXPECT_CALL(canvas, clipRect(clipRect, testing::_, testing::_)).Times(1);
+
+    //     layer.imageWrapper_ = std::make_shared<MockImageWrapper>(100, 100, source, delegate);
+    //     layer.setSize({50.f, 50.f});
+    //     layer.onDraw(canvas);
+    // }
+
+    // SECTION("paintImageWithContentFit cover") {
+    //     volta::graphics::Rect rect{-50.f, -50.f, 50.f, 50.f};
+    //     EXPECT_CALL(canvas, drawImageRect2(testing::_, rect, testing::_, testing::_)).Times(1);
+
+    //     layer.paintImageWithContentFit(*mockImg, canvas, volta::graphics::Paint(), ImageContentFit::Cover, false);
+    // }
+
+    // SECTION("paintImageWithContentFit contain") {
+    //     volta::graphics::Rect rect{50.f, 0.f, 150.f, 100.f};
+
+    //     layer.setSize({200.f, 100.f});
+    //     EXPECT_CALL(canvas, drawImageRect2(testing::_, rect, testing::_, testing::_)).Times(1);
+
+    //     layer.paintImageWithContentFit(*mockImg, canvas, volta::graphics::Paint(), ImageContentFit::Contain, false);
+    // }
+
+    // SECTION("paintImageWithContentFit fill") {
+    //     volta::graphics::Rect rect{0.f, 0.f, 200.f, 100.f};
+
+    //     layer.setSize({200.f, 100.f});
+    //     EXPECT_CALL(canvas, drawImageRect2(testing::_, rect, testing::_, testing::_)).Times(1);
+
+    //     layer.paintImageWithContentFit(*mockImg, canvas, volta::graphics::Paint(), ImageContentFit::Fill, false);
+    // }
+
+    // SECTION("paintImageWithContentFit none") {
+    //     volta::graphics::Rect rect{-25.f, -25.f, 75.f, 75.f};
+
+    //     layer.setSize({50.f, 50.f});
+    //     EXPECT_CALL(canvas, drawImageRect2(testing::_, rect, testing::_, testing::_)).Times(1);
+
+    //     layer.paintImageWithContentFit(*mockImg, canvas, volta::graphics::Paint(), ImageContentFit::None, false);
+    // }
+
+    // SECTION("paintImageWithContentFit scaleDown") {
+    //     volta::graphics::Rect rect{-25.f, -25.f, 75.f, 75.f};
+
+    //     layer.setSize({50.f, 50.f});
+    //     EXPECT_CALL(canvas, drawImageRect2(testing::_, rect, testing::_, testing::_)).Times(1);
+
+    //     layer.paintImageWithContentFit(*mockImg, canvas, volta::graphics::Paint(), ImageContentFit::ScaleDown, false);
+    // }
+}
+
+TEST_CASE("ExpoImageComponent") {
+    auto handler = std::make_shared<volta::react::KeplerScriptImageCacheHandler>();
+    ExpoImageComponent component(handler);
+
+    SECTION("setOverlayColor") {
+        component.setOverlayColor(0x12345678);
+
+        EXPECT_EQ(component.overlayColor_.argb(), static_cast<uint32_t>(0x12345678));
+        EXPECT_EQ(component.imageDrawableLayer_.overlayColor_.argb(), static_cast<uint32_t>(0x12345678));
+    }
+
+    SECTION("setTintColor") {
+        component.setTintColor(0x12345678);
+
+        EXPECT_EQ(component.tintColor_.argb(), static_cast<uint32_t>(0x12345678));
+        EXPECT_EQ(component.imageDrawableLayer_.tintColor_.argb(), static_cast<uint32_t>(0x12345678));
+    }
+
+    SECTION("setBlurRadius") {
+        component.setBlurRadius(2137.0);
+
+        EXPECT_EQ(component.imageDrawableLayer_.blurRadius_, 2137.0);
+    }
+
+    SECTION("setBlurRadius") {
+        component.setBlurRadius(2137.0);
+
+        EXPECT_EQ(component.imageDrawableLayer_.blurRadius_, 2137.0);
+    }
+
+    SECTION("setContentFit") {
+        auto handler = std::make_shared<volta::react::KeplerScriptImageCacheHandler>();
+
+        ExpoImageComponent c1(handler);
+
+        c1.setContentFit("fill");
+
+        EXPECT_EQ(c1.contentFit_, std::string{"fill"});
+        EXPECT_EQ(c1.imageDrawableLayer_.imageContentFit_, ImageContentFit::Fill);
+
+        ExpoImageComponent c2(handler);
+
+        c2.setContentFit("something-strange");
+
+        EXPECT_EQ(c2.contentFit_, std::string{"something-strange"});
+        EXPECT_EQ(c2.imageDrawableLayer_.imageContentFit_, ImageContentFit::Cover);
+    }
+
+    SECTION("setPlaceholderContentFit") {
+        auto handler = std::make_shared<volta::react::KeplerScriptImageCacheHandler>();
+
+        ExpoImageComponent c1(handler);
+
+        c1.setPlaceholderContentFit("fill");
+
+        EXPECT_EQ(c1.placeholderContentFit_, std::string{"fill"});
+        EXPECT_EQ(c1.imageDrawableLayer_.imagePlaceholderContentFit_, ImageContentFit::Fill);
+
+        ExpoImageComponent c2(handler);
+
+        c2.setPlaceholderContentFit("something-strange");
+
+        EXPECT_EQ(c2.placeholderContentFit_, std::string{"something-strange"});
+        EXPECT_EQ(c2.imageDrawableLayer_.imagePlaceholderContentFit_, ImageContentFit::ScaleDown);
+    }
+
+    SECTION("setAllowDownscaling") {
+        component.setAllowDownscaling(true);
+
+        EXPECT_EQ(component.imageDrawableLayer_.imageAllowDownscaling_, true);
+
+        component.setAllowDownscaling(false);
+
+        EXPECT_EQ(component.imageDrawableLayer_.imageAllowDownscaling_, false);
+    }
+
+    SECTION("setPlaceholder") {
+        auto sources = utils::json::JsonContainer::parseJson(
+                R"([{"uri": "https://example.com/image.png", "width": 100, "height": 100}])");
+
+        facebook::react::ImageSource imgSource;
+        imgSource.uri = "https://example.com/image.png";
+        imgSource.size = {100.f, 100.f};
+
+        auto delegate = std::make_shared<MockImageLoaderDelegate>();
+
+        component.currentPlaceholder_ = std::make_shared<MockImageWrapper>(100, 100, imgSource, delegate);
+        component.setPlaceholder(sources);
+
+        EXPECT_EQ(component.placeholders_.size(), 1);
+        EXPECT_EQ(component.placeholders_.at(0).uri, std::string{"https://example.com/image.png"});
+    }
+
+    SECTION("setSource") {
+        auto sources = utils::json::JsonContainer::parseJson(
+                R"([{"uri": "https://example.com/image.png", "width": 100, "height": 100}])");
+
+        facebook::react::ImageSource imgSource;
+        imgSource.uri = "https://example.com/image.png";
+        imgSource.size = {100.f, 100.f};
+
+        auto delegate = std::make_shared<MockImageLoaderDelegate>();
+
+        component.currentSource_ = std::make_shared<MockImageWrapper>(100, 100, imgSource, delegate);
+        component.setSource(sources);
+
+        EXPECT_EQ(component.sources_.size(), 1);
+        EXPECT_EQ(component.sources_.at(0).uri, std::string{"https://example.com/image.png"});
+    }
+
+    SECTION("setPriority") {
+        auto handler = std::make_shared<volta::react::KeplerScriptImageCacheHandler>();
+
+        ExpoImageComponent c1(handler);
+
+        c1.setPriority("high");
+
+        EXPECT_EQ(c1.priority_, ImagePriority::High);
+
+        ExpoImageComponent c2(handler);
+
+        c1.setPriority("something-strange");
+
+        EXPECT_EQ(c1.priority_, ImagePriority::Normal);
+    }
+
+    SECTION("setContentPosition") {
+        auto position =
+                utils::json::JsonContainer::parseJson(R"({"top": 10.0, "bottom": 20.0, "right": 30.0, "left": 40.0})");
+
+        component.setContentPosition(position);
+
+        auto expectedPosition = ImageContentPosition{{10.f, false}, {20.f, false}, {30.f, false}, {40.f, false}};
+
+        EXPECT_EQ(component.imageDrawableLayer_.imageContentPosition_.top_.value_, expectedPosition.top_.value_);
+        EXPECT_EQ(component.imageDrawableLayer_.imageContentPosition_.bottom_.value_, expectedPosition.bottom_.value_);
+        EXPECT_EQ(component.imageDrawableLayer_.imageContentPosition_.right_.value_, expectedPosition.right_.value_);
+        EXPECT_EQ(component.imageDrawableLayer_.imageContentPosition_.left_.value_, expectedPosition.left_.value_);
+    }
+
+    SECTION("setTransition") {
+        auto transition = utils::json::JsonContainer::parseJson(R"({"duration": 1000.0, "timing": "ease-in"})");
+        component.setTransition(transition);
+
+        EXPECT_EQ(component.shouldAnimateOnSrcChange_, true);
+    }
+
+    SECTION("setRecyclingKey") {
+        component.setRecyclingKey("a-key");
+        EXPECT_EQ(component.shouldClearOnSourceChange_, false);
+        EXPECT_EQ(component.recyclingKey_, std::string{"a-key"});
+
+        component.setRecyclingKey("b-key");
+        EXPECT_EQ(component.shouldClearOnSourceChange_, true);
+    }
+}

package/kepler/test/blurhash/decode.cpp

@@ -0,0 +1,39 @@
+#include "../../blurhash/decode.h"
+
+#include <gmock/gmock-actions.h>
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include "catch.hpp"
+
+TEST_CASE("blurhash") {
+    std::string validBlurHash = "LGF5]+Yk^6#M@-5c,1J5@[or[Q6.";
+    std::string invalidBlurHash = "some invalid blurhash";
+    std::string pureBlackHash = "L0006Mp2p2p2fRfRfRfRfQfQfQfQ";
+
+    SECTION("decodeBlurHash") {
+        const int channels = 3;
+        const int width = 32;
+        const int height = 32;
+
+        auto decoded = decodeBlurhash(pureBlackHash, width, height, 1, channels);
+
+        // channels times pixels
+        int bytesPerRow = 32 * channels;
+
+        for (int i = 0; i < height; i++) {
+            for (int j = 0; j < width; j++) {
+                for (int ch = 0; i < channels; i++) {
+                    int part = decoded.get()[channels * j + ch + i * bytesPerRow];
+                    // expect each channel to be close to 0
+                    CHECK(part < 10);
+                }
+            }
+        }
+    }
+
+    SECTION("isValidBlurHash") {
+        EXPECT_TRUE(isValidBlurhash(validBlurHash));
+        EXPECT_FALSE(isValidBlurhash(invalidBlurHash));
+    }
+}

package/kepler/test/contentposition/ImageContentPosition.cpp

@@ -0,0 +1,100 @@
+#include "../../contentposition/ImageContentPosition.h"
+
+#include <gmock/gmock-actions.h>
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include "catch.hpp"
+
+TEST_CASE("ImageContentPositionValue") {
+    SECTION("calcOffset") {
+        ImageContentPositionValue value{10.0f, false};
+
+        volta::graphics::Size imageRect{100.0f, 100.0f};
+        volta::graphics::Size viewRect{50.0f, 50.0f};
+
+        ImageContentPositionValue emptyValue;
+
+        auto calc = [](float value,
+                       const volta::graphics::Size& imageRect,
+                       const volta::graphics::Size& viewRect,
+                       bool isPercentage,
+                       bool isReverse) -> float { return 2137.0f; };
+
+        auto emptyResult = emptyValue.calcOffset(false, imageRect, viewRect, calc);
+
+        EXPECT_FALSE(emptyResult.has_value());
+
+        auto result = value.calcOffset(false, imageRect, viewRect, calc);
+        EXPECT_EQ(result.value(), 2137.0f);
+    }
+}
+
+TEST_CASE("ImageContentPosition") {
+    ImageContentPositionValue top{10.0f, false};
+    ImageContentPositionValue bottom{10.0f, false};
+    ImageContentPositionValue left{10.0f, false};
+    ImageContentPositionValue right{10.0f, false};
+    volta::graphics::Size imageRect{100.0f, 100.0f};
+    volta::graphics::Size viewRect{50.0f, 50.0f};
+
+    SECTION("offsetX with left position") {
+        ImageContentPosition pos;
+
+        float offset;
+
+        pos = ImageContentPosition(top, bottom, {}, {10.f, false});
+        offset = pos.offsetX(imageRect, viewRect);
+        EXPECT_EQ(offset, 10.f);
+    }
+
+    SECTION("offsetX with right position") {
+        ImageContentPosition pos;
+
+        float offset;
+
+        pos = ImageContentPosition(top, bottom, {}, {20.f, false});
+        offset = pos.offsetX(imageRect, viewRect);
+        EXPECT_EQ(offset, 20.f);
+    }
+
+    SECTION("offsetX without left and right positions") {
+        ImageContentPosition pos;
+
+        float offset;
+
+        pos = ImageContentPosition(top, bottom, {}, {});
+        offset = pos.offsetX(imageRect, viewRect);
+        EXPECT_EQ(offset, -25.f);
+    }
+
+    SECTION("offsetY with top position") {
+        ImageContentPosition pos;
+
+        float offset;
+
+        pos = ImageContentPosition({10.f, false}, {}, right, left);
+        offset = pos.offsetY(imageRect, viewRect);
+        EXPECT_EQ(offset, 10.f);
+    }
+
+    SECTION("offsetY with bottom position") {
+        ImageContentPosition pos;
+
+        float offset;
+
+        pos = ImageContentPosition({}, {10.f, false}, right, left);
+        offset = pos.offsetY(imageRect, viewRect);
+        EXPECT_EQ(offset, -60.f);
+    }
+
+    SECTION("offsetY without top or bottom positions") {
+        ImageContentPosition pos;
+
+        float offset;
+
+        pos = ImageContentPosition({}, {}, right, left);
+        offset = pos.offsetY(imageRect, viewRect);
+        EXPECT_EQ(offset, -25.f);
+    }
+}

package/kepler/test/managers/ExpoImageManager.cpp

@@ -0,0 +1,39 @@
+#include "../../managers/ExpoImageManager.h"
+
+#include <KeplerScript/components/ViewComponentViewManager.h>
+#include <gmock/gmock-actions.h>
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include "catch.hpp"
+
+TEST_CASE("ExpoImageManager") {
+    ExpoImageManager manager;
+
+    SECTION("aggregatePropSetters") {
+        volta::react::PropSetterAggregator aggregator;
+
+        manager.aggregatePropSetters(aggregator);
+
+        auto end = aggregator.propSetterMap_.end();
+
+        EXPECT_NE(aggregator.propSetterMap_.find("contentFit"), end);
+        EXPECT_NE(aggregator.propSetterMap_.find("placeholderContentFit"), end);
+        EXPECT_NE(aggregator.propSetterMap_.find("allowDownscaling"), end);
+        EXPECT_NE(aggregator.propSetterMap_.find("contentPosition"), end);
+        EXPECT_NE(aggregator.propSetterMap_.find("overlayColor"), end);
+        EXPECT_NE(aggregator.propSetterMap_.find("tintColor"), end);
+        EXPECT_NE(aggregator.propSetterMap_.find("blurRadius"), end);
+        EXPECT_NE(aggregator.propSetterMap_.find("placeholder"), end);
+        EXPECT_NE(aggregator.propSetterMap_.find("source"), end);
+        EXPECT_NE(aggregator.propSetterMap_.find("priority"), end);
+        EXPECT_NE(aggregator.propSetterMap_.find("transition"), end);
+        EXPECT_NE(aggregator.propSetterMap_.find("recyclingKey"), end);
+    }
+
+    SECTION("createCOmponentView") {
+        auto component = manager.createComponentView();
+
+        EXPECT_TRUE(component);
+    }
+}

package/kepler/test/thumbhash/decode.cpp

@@ -0,0 +1,18 @@
+#include "../../thumbhash/decode.h"
+
+#include <gmock/gmock-actions.h>
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include "catch.hpp"
+
+TEST_CASE("thumbhash") {
+    std::string hash = "1QcSHQRnh493V4dIh4eXh1h4kJUI";
+
+    SECTION("decodeThumbhash") {
+        auto [width, height, pixelArray] = decodeThumbhash(hash);
+
+        EXPECT_EQ(width, 23);
+        EXPECT_EQ(height, 32);
+    }
+}

package/kepler/test/utils/LoaderDelegate.cpp

@@ -0,0 +1,130 @@
+#include <KeplerScript/components/EventPayloadBuilder.h>
+#include <Volta/utils/Image.h>
+#include <gmock/gmock-actions.h>
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include <memory>
+
+#include "../../utils/PlaceholderImageLoaderDelegate.h"
+#include "../../utils/PrefetchImageLoaderDelegate.h"
+#include "../../utils/SourceImageLoaderDelegate.h"
+#include "../../utils/SourceImageLoaderDelegateEmitter.h"
+#include "catch.hpp"
+
+namespace {
+
+std::unique_ptr<volta::graphics::Image> mockImage() {
+    auto data = std::make_unique<uint8_t[]>(4);
+    return volta::graphics::Image::makeRasterImage(volta::graphics::Size{1, 1}, std::move(data), 4);
+}
+
+class MockSourceImageLoaderDelegateEmitter : public ISourceImageLoaderDelegateEmitter {
+public:
+    MockSourceImageLoaderDelegateEmitter() = default;
+
+    MOCK_METHOD(void, emit, (const std::string& eventName), (const override));
+    MOCK_METHOD(void, emit, (const std::string& eventName, const std::function<void(volta::react::EventPayloadBuilder&)>& builderFunc), (const overide));
+};
+
+}  // namespace
+
+TEST_CASE("PlaceholderImageLoaderDelegate") {
+    SECTION("notify on success") {
+        bool callbackCalled = false;
+        PlaceholderImageLoaderDelegate delegate([enabled = &callbackCalled]() { *enabled = true; });
+
+        auto mockImg = mockImage();
+        delegate.notifyImageLoadSuccess(*mockImg);
+        CHECK(callbackCalled);
+    }
+
+    SECTION("notify on error") {
+        bool callbackCalled = false;
+        PlaceholderImageLoaderDelegate delegate([enabled = &callbackCalled]() { *enabled = true; });
+
+        delegate.notifyImageLoadFailure(volta::ImageLoadError::DecodeError);
+        CHECK(callbackCalled);
+    }
+}
+
+TEST_CASE("PrefetchImageLoaderDelegate") {
+    SECTION("notify on success") {
+        bool callbackCalled = false;
+        bool success = false;
+        const int expectedImages = 2;
+        PrefetchImageLoaderDelegate delegate(
+                expectedImages,
+                [called = &callbackCalled, isSuccess = &success](bool success) {
+                    *called = true;
+                    *isSuccess = success;
+                });
+
+        auto mockImg = mockImage();
+
+        delegate.notifyImageLoadSuccess(*mockImg);
+        CHECK(!callbackCalled);
+        CHECK(!success);
+
+        delegate.notifyImageLoadSuccess(*mockImg);
+        CHECK(callbackCalled);
+        CHECK(success);
+    }
+
+    SECTION("notify on error") {
+        bool callbackCalled = false;
+        bool success = false;
+        const int expectedImages = 2;
+
+        PrefetchImageLoaderDelegate delegate(
+                expectedImages,
+                [called = &callbackCalled, isSuccess = &success](bool success) {
+                    *called = true;
+                    *isSuccess = success;
+                });
+
+        delegate.notifyImageLoadFailure(volta::ImageLoadError::DecodeError);
+        CHECK(callbackCalled);
+        CHECK(!success);
+    }
+}
+
+TEST_CASE("SourceImageLoaderDelegate") {
+    SECTION("notify on progress") {
+        auto emitter = std::make_unique<MockSourceImageLoaderDelegateEmitter>();
+
+        EXPECT_CALL(*emitter, emit("progress", testing::_)).Times(1);
+
+        bool loaded = false;
+
+        SourceImageLoaderDelegate delegate(std::move(emitter), [loaded = &loaded]() { *loaded = true; });
+
+        delegate.notifyImageLoadProgress(50.f);
+    }
+
+    SECTION("notify on success") {
+        auto emitter = std::make_unique<MockSourceImageLoaderDelegateEmitter>();
+        EXPECT_CALL(*emitter, emit("load")).Times(1);
+        EXPECT_CALL(*emitter, emit("loadEnd")).Times(1);
+
+        bool loaded = false;
+
+        SourceImageLoaderDelegate delegate(std::move(emitter), [loaded = &loaded]() { *loaded = true; });
+
+        auto mockImg = mockImage();
+
+        delegate.notifyImageLoadSuccess(*mockImg);
+    }
+
+    SECTION("notify on error") {
+        auto emitter = std::make_unique<MockSourceImageLoaderDelegateEmitter>();
+        EXPECT_CALL(*emitter, emit("error")).Times(1);
+        EXPECT_CALL(*emitter, emit("loadEnd")).Times(1);
+
+        bool loaded = false;
+
+        SourceImageLoaderDelegate delegate(std::move(emitter), [loaded = &loaded]() { *loaded = true; });
+
+        delegate.notifyImageLoadFailure(volta::ImageLoadError::DecodeError);
+    }
+}