feedc0de/qt-creator
1
0
Fork 0
forked from qt-creator/qt-creator
Code Pull Requests Activity

QmlDesigner: Add an reason parameter to the image cache abort callback

Browse Source 
Sometimes we abort the request, sometimes it failed. In the first case
we maybe want the cancel the imageprovider request, in the second we
return an empty image.

Fixes: QDS-3388
Change-Id: Iaef76aa09ac734795f86447e1a7cf6a5c7b5ae81
Reviewed-by: Thomas Hartmann <thomas.hartmann@qt.io>
Reviewed-by: Henning Gründl <henning.gruendl@qt.io>
This commit is contained in:
Marco Bubke
2021-01-28 12:11:51 +01:00
parent 62582877f6
commit e34eb170dc
16 changed files with 127 additions and 90 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
src/plugins/qmldesigner/components/itemlibrary/itemlibraryiconimageprovider.cpp
View File

@@ -77,12 +77,19 @@ QQuickImageResponse *ItemLibraryIconImageProvider::requestImageResponse(const QS
},
Qt::QueuedConnection);
},
[response = QPointer<ImageRespose>(response.get())] {
[response = QPointer<ImageRespose>(response.get())](ImageCache::AbortReason abortReason) {
QMetaObject::invokeMethod(
response,
[response] {
if (response)
response->abort();
[response, abortReason] {
switch (abortReason) {
case ImageCache::AbortReason::Failed:
if (response)
response->abort();
break;
case ImageCache::AbortReason::Abort:
response->cancel();
break;
}
},
Qt::QueuedConnection);
});

2
src/plugins/qmldesigner/components/previewtooltip/previewtooltipbackend.cpp
View File

@@ -63,7 +63,7 @@ void PreviewTooltipBackend::showTooltip()
}
});
},
[] {},
[](auto) {},
m_extraId,
m_auxiliaryData);

20
src/plugins/qmldesigner/designercore/imagecache/asynchronousimagecache.cpp
View File

@@ -68,8 +68,8 @@ AsynchronousImageCache::~AsynchronousImageCache()
void AsynchronousImageCache::request(Utils::SmallStringView name,
Utils::SmallStringView extraId,
AsynchronousImageCache::RequestType requestType,
AsynchronousImageCache::CaptureImageCallback captureCallback,
AsynchronousImageCache::AbortCallback abortCallback,
ImageCache::CaptureImageCallback captureCallback,
ImageCache::AbortCallback abortCallback,
ImageCache::AuxiliaryData auxiliaryData,
ImageCacheStorageInterface &storage,
ImageCacheGeneratorInterface &generator,
@@ -83,7 +83,7 @@ void AsynchronousImageCache::request(Utils::SmallStringView name,
if (entry.hasEntry) {
if (entry.image.isNull())
abortCallback();
abortCallback(ImageCache::AbortReason::Failed);
else
captureCallback(entry.image);
} else {
@@ -109,8 +109,8 @@ void AsynchronousImageCache::wait()
}
void AsynchronousImageCache::requestImage(Utils::PathString name,
AsynchronousImageCache::CaptureImageCallback captureCallback,
AbortCallback abortCallback,
ImageCache::CaptureImageCallback captureCallback,
ImageCache::AbortCallback abortCallback,
Utils::SmallString extraId,
ImageCache::AuxiliaryData auxiliaryData)
{
@@ -124,8 +124,8 @@ void AsynchronousImageCache::requestImage(Utils::PathString name,
}
void AsynchronousImageCache::requestSmallImage(Utils::PathString name,
AsynchronousImageCache::CaptureImageCallback captureCallback,
AsynchronousImageCache::AbortCallback abortCallback,
ImageCache::CaptureImageCallback captureCallback,
ImageCache::AbortCallback abortCallback,
Utils::SmallString extraId,
ImageCache::AuxiliaryData auxiliaryData)
{
@@ -166,8 +166,8 @@ std::tuple<bool, AsynchronousImageCache::Entry> AsynchronousImageCache::getEntry
void AsynchronousImageCache::addEntry(Utils::PathString &&name,
Utils::SmallString &&extraId,
AsynchronousImageCache::CaptureImageCallback &&captureCallback,
AbortCallback &&abortCallback,
ImageCache::CaptureImageCallback &&captureCallback,
ImageCache::AbortCallback &&abortCallback,
ImageCache::AuxiliaryData &&auxiliaryData,
RequestType requestType)
{
@@ -185,7 +185,7 @@ void AsynchronousImageCache::clearEntries()
{
std::unique_lock lock{m_mutex};
for (Entry &entry : m_entries)
entry.abortCallback();
entry.abortCallback(ImageCache::AbortReason::Abort);
m_entries.clear();
}

14
src/plugins/qmldesigner/designercore/imagecache/imagecachecollector.cpp
View File

@@ -68,12 +68,10 @@ ImageCacheCollector::~ImageCacheCollector() = default;
void ImageCacheCollector::start(Utils::SmallStringView name,
Utils::SmallStringView state,
const ImageCache::AuxiliaryData &auxiliaryData,
const ImageCache::AuxiliaryData &,
CaptureCallback captureCallback,
AbortCallback abortCallback)
{
Q_UNUSED(auxiliaryData)
RewriterView rewriterView{RewriterView::Amend, nullptr};
NodeInstanceView nodeInstanceView{m_connectionManager};
@@ -91,7 +89,7 @@ void ImageCacheCollector::start(Utils::SmallStringView name,
model->setRewriterView(&rewriterView);
if (rewriterView.inErrorState() || !rewriterView.rootModelNode().metaInfo().isGraphicalItem()) {
abortCallback();
abortCallback(ImageCache::AbortReason::Failed);
return;
}
@@ -100,18 +98,18 @@ void ImageCacheCollector::start(Utils::SmallStringView name,
if (stateNode.isValid())
rewriterView.setCurrentStateNode(stateNode);
auto callback = [captureCallback = std::move(captureCallback)](QImage &&image) {
auto callback = [captureCallback = std::move(captureCallback)](const QImage &image) {
QSize smallImageSize = image.size().scaled(QSize{96, 96}.boundedTo(image.size()),
Qt::KeepAspectRatio);
QImage smallImage = image.isNull() ? QImage{} : image.scaled(smallImageSize);
captureCallback(std::move(image), std::move(smallImage));
captureCallback(image, smallImage);
};
m_connectionManager.setCallback(std::move(callback));
nodeInstanceView.setTarget(m_target.data());
nodeInstanceView.setCrashCallback(abortCallback);
nodeInstanceView.setCrashCallback([=] { abortCallback(ImageCache::AbortReason::Failed); });
model->setNodeInstanceView(&nodeInstanceView);
bool capturedDataArrived = m_connectionManager.waitForCapturedData();
@@ -123,7 +121,7 @@ void ImageCacheCollector::start(Utils::SmallStringView name,
model->setRewriterView({});
if (!capturedDataArrived)
abortCallback();
abortCallback(ImageCache::AbortReason::Failed);
}
std::pair<QImage, QImage> ImageCacheCollector::createImage(Utils::SmallStringView filePath,

4
src/plugins/qmldesigner/designercore/imagecache/imagecachecollectorinterface.h
View File

@@ -36,8 +36,8 @@ namespace QmlDesigner {
class ImageCacheCollectorInterface
{
public:
using CaptureCallback = std::function<void(QImage &&image, QImage &&smallImage)>;
using AbortCallback = std::function<void()>;
using CaptureCallback = ImageCache::CaptureImageWithSmallImageCallback;
using AbortCallback = ImageCache::AbortCallback;
using ImagePair = std::pair<QImage, QImage>;
virtual void start(Utils::SmallStringView filePath,

2
src/plugins/qmldesigner/designercore/imagecache/imagecacheconnectionmanager.h
View File

@@ -26,7 +26,7 @@ class CapturedDataCommand;
class ImageCacheConnectionManager : public ConnectionManager
{
public:
using Callback = std::function<void(QImage &&)>;
using Callback = std::function<void(const QImage &)>;
ImageCacheConnectionManager();

2
src/plugins/qmldesigner/designercore/imagecache/imagecachefontcollector.cpp
View File

@@ -140,7 +140,7 @@ void ImageCacheFontCollector::start(Utils::SmallStringView name,
return;
}
}
abortCallback();
abortCallback(ImageCache::AbortReason::Failed);
}
std::pair<QImage, QImage> ImageCacheFontCollector::createImage(

17
src/plugins/qmldesigner/designercore/imagecache/imagecachegenerator.cpp
View File

@@ -50,8 +50,8 @@ ImageCacheGenerator::~ImageCacheGenerator()
void ImageCacheGenerator::generateImage(Utils::SmallStringView name,
Utils::SmallStringView extraId,
Sqlite::TimeStamp timeStamp,
ImageCacheGeneratorInterface::CaptureCallback &&captureCallback,
AbortCallback &&abortCallback,
ImageCache::CaptureImageWithSmallImageCallback &&captureCallback,
ImageCache::AbortCallback &&abortCallback,
ImageCache::AuxiliaryData &&auxiliaryData)
{
{
@@ -96,7 +96,7 @@ void ImageCacheGenerator::clean()
{
std::lock_guard lock{m_mutex};
for (Task &task : m_tasks)
callCallbacks(task.abortCallbacks);
callCallbacks(task.abortCallbacks, ImageCache::AbortReason::Abort);
m_tasks.clear();
}
@@ -133,9 +133,9 @@ void ImageCacheGenerator::startGeneration()
task.filePath,
task.extraId,
std::move(task.auxiliaryData),
[this, task](QImage &&image, QImage &&smallImage) {
[this, task](const QImage &image, const QImage &smallImage) {
if (image.isNull())
callCallbacks(task.abortCallbacks);
callCallbacks(task.abortCallbacks, ImageCache::AbortReason::Failed);
else
callCallbacks(task.captureCallbacks, image, smallImage);
@@ -144,9 +144,10 @@ void ImageCacheGenerator::startGeneration()
image,
smallImage);
},
[this, task] {
callCallbacks(task.abortCallbacks);
m_storage.storeImage(createId(task.filePath, task.extraId), task.timeStamp, {}, {});
[this, task](ImageCache::AbortReason abortReason) {
callCallbacks(task.abortCallbacks, abortReason);
if (abortReason != ImageCache::AbortReason::Abort)
m_storage.storeImage(createId(task.filePath, task.extraId), task.timeStamp, {}, {});
});
std::lock_guard lock{m_mutex};

12
src/plugins/qmldesigner/designercore/imagecache/imagecachegenerator.h
View File

@@ -55,8 +55,8 @@ public:
void generateImage(Utils::SmallStringView filePath,
Utils::SmallStringView extraId,
Sqlite::TimeStamp timeStamp,
CaptureCallback &&captureCallback,
AbortCallback &&abortCallback,
ImageCache::CaptureImageWithSmallImageCallback &&captureCallback,
ImageCache::AbortCallback &&abortCallback,
ImageCache::AuxiliaryData &&auxiliaryData) override;
void clean() override;
@@ -70,8 +70,8 @@ private:
Utils::SmallStringView extraId,
ImageCache::AuxiliaryData &&auxiliaryData,
Sqlite::TimeStamp timeStamp,
CaptureCallback &&captureCallback,
AbortCallback &&abortCallback)
ImageCache::CaptureImageWithSmallImageCallback &&captureCallback,
ImageCache::AbortCallback &&abortCallback)
: filePath(filePath)
, extraId(std::move(extraId))
, auxiliaryData(std::move(auxiliaryData))
@@ -83,8 +83,8 @@ private:
Utils::PathString filePath;
Utils::SmallString extraId;
ImageCache::AuxiliaryData auxiliaryData;
std::vector<CaptureCallback> captureCallbacks;
std::vector<AbortCallback> abortCallbacks;
std::vector<ImageCache::CaptureImageWithSmallImageCallback> captureCallbacks;
std::vector<ImageCache::AbortCallback> abortCallbacks;
Sqlite::TimeStamp timeStamp;
};

7
src/plugins/qmldesigner/designercore/imagecache/imagecachegeneratorinterface.h
View File

@@ -36,14 +36,11 @@ namespace QmlDesigner {
class ImageCacheGeneratorInterface
{
public:
using CaptureCallback = std::function<void(const QImage &image, const QImage &smallImage)>;
using AbortCallback = std::function<void()>;
virtual void generateImage(Utils::SmallStringView name,
Utils::SmallStringView extraId,
Sqlite::TimeStamp timeStamp,
CaptureCallback &&captureCallback,
AbortCallback &&abortCallback,
ImageCache::CaptureImageWithSmallImageCallback &&captureCallback,
ImageCache::AbortCallback &&abortCallback,
ImageCache::AuxiliaryData &&auxiliaryData)
= 0;

26
src/plugins/qmldesigner/designercore/include/asynchronousimagecache.h
View File

@@ -43,8 +43,6 @@ class ImageCacheCollectorInterface;
class AsynchronousImageCache final : public AsynchronousImageCacheInterface
{
public:
using CaptureImageCallback = std::function<void(const QImage &)>;
using AbortCallback = std::function<void()>;
~AsynchronousImageCache();
@@ -53,13 +51,13 @@ public:
TimeStampProviderInterface &timeStampProvider);
void requestImage(Utils::PathString name,
CaptureImageCallback captureCallback,
AbortCallback abortCallback,
ImageCache::CaptureImageCallback captureCallback,
ImageCache::AbortCallback abortCallback,
Utils::SmallString extraId = {},
ImageCache::AuxiliaryData auxiliaryData = {}) override;
void requestSmallImage(Utils::PathString name,
CaptureImageCallback captureCallback,
AbortCallback abortCallback,
ImageCache::CaptureImageCallback captureCallback,
ImageCache::AbortCallback abortCallback,
Utils::SmallString extraId = {},
ImageCache::AuxiliaryData auxiliaryData = {}) override;
@@ -73,8 +71,8 @@ private:
Entry() = default;
Entry(Utils::PathString name,
Utils::SmallString extraId,
CaptureImageCallback &&captureCallback,
AbortCallback &&abortCallback,
ImageCache::CaptureImageCallback &&captureCallback,
ImageCache::AbortCallback &&abortCallback,
ImageCache::AuxiliaryData &&auxiliaryData,
RequestType requestType)
: name{std::move(name)}
@@ -87,8 +85,8 @@ private:
Utils::PathString name;
Utils::SmallString extraId;
CaptureImageCallback captureCallback;
AbortCallback abortCallback;
ImageCache::CaptureImageCallback captureCallback;
ImageCache::AbortCallback abortCallback;
ImageCache::AuxiliaryData auxiliaryData;
RequestType requestType = RequestType::Image;
};
@@ -96,8 +94,8 @@ private:
std::tuple<bool, Entry> getEntry();
void addEntry(Utils::PathString &&name,
Utils::SmallString &&extraId,
CaptureImageCallback &&captureCallback,
AbortCallback &&abortCallback,
ImageCache::CaptureImageCallback &&captureCallback,
ImageCache::AbortCallback &&abortCallback,
ImageCache::AuxiliaryData &&auxiliaryData,
RequestType requestType);
void clearEntries();
@@ -107,8 +105,8 @@ private:
static void request(Utils::SmallStringView name,
Utils::SmallStringView extraId,
AsynchronousImageCache::RequestType requestType,
AsynchronousImageCache::CaptureImageCallback captureCallback,
AsynchronousImageCache::AbortCallback abortCallback,
ImageCache::CaptureImageCallback captureCallback,
ImageCache::AbortCallback abortCallback,
ImageCache::AuxiliaryData auxiliaryData,
ImageCacheStorageInterface &storage,
ImageCacheGeneratorInterface &generator,

11
src/plugins/qmldesigner/designercore/include/asynchronousimagecacheinterface.h
View File

@@ -36,18 +36,15 @@ namespace QmlDesigner {
class AsynchronousImageCacheInterface
{
public:
using CaptureCallback = std::function<void(const QImage &)>;
using AbortCallback = std::function<void()>;
virtual void requestImage(Utils::PathString name,
CaptureCallback captureCallback,
AbortCallback abortCallback,
ImageCache::CaptureImageCallback captureCallback,
ImageCache::AbortCallback abortCallback,
Utils::SmallString extraId = {},
ImageCache::AuxiliaryData auxiliaryData = {})
= 0;
virtual void requestSmallImage(Utils::PathString name,
CaptureCallback captureCallback,
AbortCallback abortCallback,
ImageCache::CaptureImageCallback captureCallback,
ImageCache::AbortCallback abortCallback,
Utils::SmallString extraId = {},
ImageCache::AuxiliaryData auxiliaryData = {})
= 0;

8
src/plugins/qmldesigner/designercore/include/imagecacheauxiliarydata.h
View File

@@ -28,9 +28,12 @@
#include <utils/span.h>
#include <utils/variant.h>
#include <QImage>
#include <QSize>
#include <QString>
#include <functional>
namespace QmlDesigner {
namespace ImageCache {
@@ -56,6 +59,11 @@ public:
using AuxiliaryData = Utils::variant<NullAuxiliaryData, FontCollectorSizeAuxiliaryData, FontCollectorSizesAuxiliaryData>;
enum class AbortReason : char { Abort, Failed };
using CaptureImageCallback = std::function<void(const QImage &)>;
using CaptureImageWithSmallImageCallback = std::function<void(const QImage &image, const QImage &smallImage)>;
using AbortCallback = std::function<void(ImageCache::AbortReason)>;
} // namespace ImageCache
} // namespace QmlDesigner

19
tests/unit/unittest/asynchronousimagecache-test.cpp
View File

@@ -39,7 +39,7 @@ class AsynchronousImageCache : public testing::Test
protected:
Notification notification;
Notification waitInThread;
NiceMock<MockFunction<void()>> mockAbortCallback;
NiceMock<MockFunction<void(QmlDesigner::ImageCache::AbortReason)>> mockAbortCallback;
NiceMock<MockFunction<void(const QImage &image)>> mockCaptureCallback;
NiceMock<MockImageCacheStorage> mockStorage;
NiceMock<MockImageCacheGenerator> mockGenerator;
@@ -99,7 +99,8 @@ TEST_F(AsynchronousImageCache, RequestImageCallsAbortCallbackWithoutImage)
ON_CALL(mockStorage, fetchImage(Eq("/path/to/Component.qml"), _))
.WillByDefault(Return(QmlDesigner::ImageCacheStorageInterface::ImageEntry{QImage{}, true}));
EXPECT_CALL(mockAbortCallback, Call()).WillRepeatedly([&] { notification.notify(); });
EXPECT_CALL(mockAbortCallback, Call(Eq(QmlDesigner::ImageCache::AbortReason::Failed)))
.WillRepeatedly([&](auto) { notification.notify(); });
cache.requestImage("/path/to/Component.qml",
mockCaptureCallback.AsStdFunction(),
@@ -142,11 +143,11 @@ TEST_F(AsynchronousImageCache, RequestImageCallsAbortCallbackFromGenerator)
{
ON_CALL(mockGenerator, generateImage(Eq("/path/to/Component.qml"), _, _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto &&, auto &&abortCallback, auto) {
abortCallback();
abortCallback(QmlDesigner::ImageCache::AbortReason::Failed);
notification.notify();
});
EXPECT_CALL(mockAbortCallback, Call());
EXPECT_CALL(mockAbortCallback, Call(Eq(QmlDesigner::ImageCache::AbortReason::Failed)));
cache.requestImage("/path/to/Component.qml",
mockCaptureCallback.AsStdFunction(),
@@ -204,7 +205,8 @@ TEST_F(AsynchronousImageCache, RequestSmallImageCallsAbortCallbackWithoutSmallIm
ON_CALL(mockStorage, fetchSmallImage(Eq("/path/to/Component.qml"), _))
.WillByDefault(Return(QmlDesigner::ImageCacheStorageInterface::ImageEntry{QImage{}, true}));
EXPECT_CALL(mockAbortCallback, Call()).WillRepeatedly([&] { notification.notify(); });
EXPECT_CALL(mockAbortCallback, Call(Eq(QmlDesigner::ImageCache::AbortReason::Failed)))
.WillRepeatedly([&](auto) { notification.notify(); });
cache.requestSmallImage("/path/to/Component.qml",
mockCaptureCallback.AsStdFunction(),
@@ -247,11 +249,11 @@ TEST_F(AsynchronousImageCache, RequestSmallImageCallsAbortCallbackFromGenerator)
{
ON_CALL(mockGenerator, generateImage(Eq("/path/to/Component.qml"), _, _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto &&, auto &&abortCallback, auto) {
abortCallback();
abortCallback(QmlDesigner::ImageCache::AbortReason::Failed);
notification.notify();
});
EXPECT_CALL(mockAbortCallback, Call());
EXPECT_CALL(mockAbortCallback, Call(Eq(QmlDesigner::ImageCache::AbortReason::Failed)));
cache.requestSmallImage("/path/to/Component.qml",
mockCaptureCallback.AsStdFunction(),
@@ -292,7 +294,8 @@ TEST_F(AsynchronousImageCache, CleanCallsAbort)
mockCaptureCallback.AsStdFunction(),
mockAbortCallback.AsStdFunction());
EXPECT_CALL(mockAbortCallback, Call()).Times(AtLeast(2));
EXPECT_CALL(mockAbortCallback, Call(Eq(QmlDesigner::ImageCache::AbortReason::Abort)))
.Times(AtLeast(2));
cache.requestSmallImage("/path/to/Component3.qml",
mockCaptureCallback.AsStdFunction(),

54
tests/unit/unittest/imagecachegenerator-test.cpp
View File

@@ -56,7 +56,7 @@ protected:
QImage image1{10, 10, QImage::Format_ARGB32};
QImage smallImage1{1, 1, QImage::Format_ARGB32};
NiceMock<MockFunction<void(const QImage &, const QImage &)>> imageCallbackMock;
NiceMock<MockFunction<void()>> abortCallbackMock;
NiceMock<MockFunction<void(QmlDesigner::ImageCache::AbortReason)>> abortCallbackMock;
NiceMock<ImageCacheCollectorMock> collectorMock;
NiceMock<MockImageCacheStorage> storageMock;
QmlDesigner::ImageCacheGenerator generator{collectorMock, storageMock};
@@ -196,12 +196,15 @@ TEST_F(ImageCacheGenerator, AbortCallback)
captureCallback(QImage{image1}, QImage{smallImage1});
});
ON_CALL(collectorMock, start(Eq("name2"), _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto, auto abortCallback) { abortCallback(); });
.WillByDefault([&](auto, auto, auto, auto, auto abortCallback) {
abortCallback(QmlDesigner::ImageCache::AbortReason::Failed);
});
EXPECT_CALL(imageCallbackMock, Call(_, _)).WillOnce([&](const QImage &, const QImage &) {
notification.notify();
});
EXPECT_CALL(abortCallbackMock, Call()).WillOnce([&]() { notification.notify(); });
EXPECT_CALL(abortCallbackMock, Call(Eq(QmlDesigner::ImageCache::AbortReason::Failed)))
.WillOnce([&](auto) { notification.notify(); });
generator.generateImage(
"name", {}, {}, imageCallbackMock.AsStdFunction(), abortCallbackMock.AsStdFunction(), {});
@@ -210,10 +213,29 @@ TEST_F(ImageCacheGenerator, AbortCallback)
notification.wait(2);
}
TEST_F(ImageCacheGenerator, StoreNullImageForAbortCallback)
TEST_F(ImageCacheGenerator, StoreNullImageForAbortCallbackAbort)
{
ON_CALL(collectorMock, start(Eq("name"), _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto, auto abortCallback) {
abortCallback(QmlDesigner::ImageCache::AbortReason::Abort);
});
ON_CALL(collectorMock, start(Eq("dummyNotify"), _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto, auto) { notification.notify(); });
EXPECT_CALL(storageMock, storeImage(Eq("name"), _, _, _)).Times(0);
generator.generateImage(
"name", {}, {11}, imageCallbackMock.AsStdFunction(), abortCallbackMock.AsStdFunction(), {});
generator.generateImage("dummyNotify", {}, {}, {}, {}, {});
notification.wait();
}
TEST_F(ImageCacheGenerator, DontStoreNullImageForAbortCallbackFailed)
{
ON_CALL(collectorMock, start(_, _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto, auto abortCallback) { abortCallback(); });
.WillByDefault([&](auto, auto, auto, auto, auto abortCallback) {
abortCallback(QmlDesigner::ImageCache::AbortReason::Failed);
});
EXPECT_CALL(storageMock,
storeImage(Eq("name"), Eq(Sqlite::TimeStamp{11}), Eq(QImage{}), Eq(QImage{})))
@@ -231,7 +253,8 @@ TEST_F(ImageCacheGenerator, AbortForEmptyImage)
captureCallback(QImage{}, QImage{});
});
EXPECT_CALL(abortCallbackMock, Call()).WillOnce([&]() { notification.notify(); });
EXPECT_CALL(abortCallbackMock, Call(Eq(QmlDesigner::ImageCache::AbortReason::Failed)))
.WillOnce([&](auto) { notification.notify(); });
generator.generateImage(
"name", {}, {}, imageCallbackMock.AsStdFunction(), abortCallbackMock.AsStdFunction(), {});
@@ -264,7 +287,8 @@ TEST_F(ImageCacheGenerator, CleanIsCallingAbortCallback)
generator.generateImage(
"name2", {}, {11}, imageCallbackMock.AsStdFunction(), abortCallbackMock.AsStdFunction(), {});
EXPECT_CALL(abortCallbackMock, Call()).Times(AtLeast(1));
EXPECT_CALL(abortCallbackMock, Call(Eq(QmlDesigner::ImageCache::AbortReason::Abort)))
.Times(AtLeast(1));
generator.clean();
waitInThread.notify();
@@ -401,9 +425,11 @@ TEST_F(ImageCacheGenerator, UseLastTimeStampIfTasksAreMerged)
ON_CALL(collectorMock, start(Eq("notificationDummy"), _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto, auto) { notification.notify(); });
ON_CALL(collectorMock, start(Eq("name"), _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto, auto abortCallback) { abortCallback(); });
.WillByDefault([&](auto, auto, auto, auto, auto abortCallback) {
abortCallback(QmlDesigner::ImageCache::AbortReason::Failed);
});
EXPECT_CALL(storageMock, storeImage(Eq("name"), _, _, _));
EXPECT_CALL(storageMock, storeImage(Eq("name"), Eq(Sqlite::TimeStamp{4}), _, _));
generator.generateImage("waitDummy", {}, {}, {}, {}, {});
generator.generateImage("name", {}, {3}, {}, abortCallbackMock.AsStdFunction(), {});
@@ -438,16 +464,18 @@ TEST_F(ImageCacheGenerator, MergeCaptureCallbackIfTasksAreMerged)
TEST_F(ImageCacheGenerator, MergeAbortCallbackIfTasksAreMerged)
{
NiceMock<MockFunction<void()>> newerAbortCallbackMock;
NiceMock<MockFunction<void(QmlDesigner::ImageCache::AbortReason)>> newerAbortCallbackMock;
ON_CALL(collectorMock, start(Eq("waitDummy"), _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto, auto) { waitInThread.wait(); });
ON_CALL(collectorMock, start(Eq("notificationDummy"), _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto, auto) { notification.notify(); });
ON_CALL(collectorMock, start(Eq("name"), _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto, auto abortCallback) { abortCallback(); });
.WillByDefault([&](auto, auto, auto, auto, auto abortCallback) {
abortCallback(QmlDesigner::ImageCache::AbortReason::Failed);
});
EXPECT_CALL(abortCallbackMock, Call());
EXPECT_CALL(newerAbortCallbackMock, Call());
EXPECT_CALL(abortCallbackMock, Call(Eq(QmlDesigner::ImageCache::AbortReason::Failed)));
EXPECT_CALL(newerAbortCallbackMock, Call(Eq(QmlDesigner::ImageCache::AbortReason::Failed)));
generator.generateImage("waitDummy", {}, {}, {}, {}, {});
generator.generateImage("name", {}, {}, {}, abortCallbackMock.AsStdFunction(), {});

4
tests/unit/unittest/mockimagecachegenerator.h
View File

@@ -37,8 +37,8 @@ public:
(Utils::SmallStringView name,
Utils::SmallStringView state,
Sqlite::TimeStamp timeStamp,
CaptureCallback &&captureCallback,
AbortCallback &&abortCallback,
QmlDesigner::ImageCache::CaptureImageWithSmallImageCallback &&captureCallback,
QmlDesigner::ImageCache::AbortCallback &&abortCallback,
QmlDesigner::ImageCache::AuxiliaryData &&auxiliaryData),
(override));
MOCK_METHOD(void, clean, (), (override));