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

QmlDesigner: Add move only trace token

Browse Source 
It is quite hard to define always an end to a trace. A move only
token can do that. The drawback is that the token gets bigger but only
compile them for an avtivated category.

Change-Id: I88b47c5b47e4129b1cd402e89251b45fa126111c
Reviewed-by: <github-actions-qt-creator@cristianadam.eu>
Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
Reviewed-by: Qt CI Patch Build Bot <ci_patchbuild_bot@qt.io>
This commit is contained in:
Marco Bubke
2023-10-13 22:06:05 +02:00
committed by Tim Jenssen
parent 3d8c740705
commit 11bf705e26
26 changed files with 588 additions and 415 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
src/libs/nanotrace/nanotracehr.cpp
View File

@@ -24,14 +24,14 @@ void printEvent(std::ostream &out, const TraceEvent &event, qint64 processId, st
{
out << R"({"ph":")" << event.type << R"(","name":")" << event.name << R"(","cat":")"
<< event.category << R"(","ts":")"
<< static_cast<double>(event.time.time_since_epoch().count()) / 1000 << R"(","pid":")"
<< processId << R"(","tid":")" << threadId << R"(")";
<< static_cast<double>(event.time.time_since_epoch().count()) / 1000 << R"(","pid":)"
<< processId << R"(,"tid":)" << threadId;
if (event.type == 'X')
out << R"(,"dur":)" << static_cast<double>(event.duration.count()) / 1000;
if (event.id != 0)
out << R"(,"id":)" << event.id;
out << R"(,"id":")" << event.id << R"(")";
if (event.arguments.size())
out << R"(,"args":)" << event.arguments;
@@ -45,9 +45,9 @@ void writeMetaEvent(TraceFile<true> *file, std::string_view key, std::string_vie
auto &out = file->out;
if (out.is_open()) {
file->out << R"({"name":")" << key << R"(","ph":"M", "pid":")"
<< QCoreApplication::applicationPid() << R"(","tid":")"
<< std::this_thread::get_id() << R"(","args":{"name":")" << value << R"("}})"
file->out << R"({"name":")" << key << R"(","ph":"M", "pid":)"
<< QCoreApplication::applicationPid() << R"(,"tid":)"
<< std::this_thread::get_id() << R"(,"args":{"name":")" << value << R"("}})"
<< ",\n";
}
}
@@ -194,6 +194,6 @@ void EventQueue<TraceEvent, std::true_type>::flush()
}
}
template class NANOTRACE_EXPORT EventQueue<StringViewTraceEvent, std::true_type>;
template class NANOTRACE_EXPORT EventQueue<StringTraceEvent, std::true_type>;
template class EventQueue<StringViewTraceEvent, std::true_type>;
template class EventQueue<StringTraceEvent, std::true_type>;
} // namespace NanotraceHR

170
src/libs/nanotrace/nanotracehr.h
View File

@@ -58,6 +58,7 @@ constexpr TracerLiteral operator""_t(const char *text, size_t size)
} // namespace Literals
using namespace Literals;
template<typename String>
struct TraceEvent
{
@@ -142,6 +143,7 @@ public:
TraceFile &operator=(TraceFile &&) = delete;
~TraceFile() { finalizeFile(*this); }
std::string filePath;
std::mutex fileMutex;
std::future<void> processing;
@@ -257,43 +259,108 @@ TraceEvent &getTraceEvent(EnabledEventQueue<TraceEvent> &eventQueue)
return eventQueue.currentEvents[eventQueue.eventsIndex++];
}
template<bool enabled>
template<typename Category, bool enabled>
class Token
{
public:
using IsActive = std::false_type;
using ArgumentType = typename Category::ArgumentType;
constexpr std::size_t operator*() const { return 0; }
Token() {}
~Token() {}
constexpr Token(const Token &) = delete;
constexpr Token &operator=(const Token &) = delete;
constexpr Token(Token &&other) noexcept = default;
constexpr Token &operator=(Token &&other) noexcept = default;
constexpr explicit operator bool() const { return false; }
static constexpr bool isActive() { return false; }
Token begin(ArgumentType) { return Token{}; }
void tick(ArgumentType) {}
void end() {}
};
template<typename TraceEvent, bool enabled>
class Category;
template<>
class Token<true>
template<typename Category>
class Token<Category, true>
{
friend Category<StringViewTraceEvent, true>;
friend Category<StringTraceEvent, true>;
Token(std::size_t id)
: m_id{id}
Token(std::string_view name, std::size_t id, Category &category)
: m_name{name}
, m_id{id}
, m_category{&category}
{}
public:
using IsActive = std::true_type;
using StringType = typename Category::StringType;
using ArgumentType = typename Category::ArgumentType;
constexpr std::size_t operator*() const { return m_id; }
friend Category;
Token() = default;
Token(const Token &) = delete;
Token &operator=(const Token &) = delete;
Token(Token &&other) noexcept
: m_name{other.m_name}
, m_id{std::exchange(other.m_id, 0)}
, m_category{std::exchange(other.m_category, nullptr)}
{}
Token &operator=(Token &&other) noexcept
{
if (&other != this) {
m_name = other.m_name;
m_id = std::exchange(other.m_id, 0);
m_category = std::exchange(other.m_category, nullptr);
}
return *this;
}
~Token() { end(); }
constexpr explicit operator bool() const { return m_id; }
static constexpr bool isActive() { return true; }
Token begin(ArgumentType name)
{
if (m_id)
m_category->beginAsynchronous(m_id, name);
return Token{m_name, m_id, *m_category};
}
void tick(ArgumentType name)
{
if (m_id)
m_category->tickAsynchronous(m_id, name);
}
void end()
{
if (m_id)
m_category->endAsynchronous(m_id, m_name);
m_id = 0;
}
private:
std::size_t m_id;
StringType m_name;
std::size_t m_id = 0;
Category *m_category = nullptr;
};
template<typename TraceEvent, bool enabled>
@@ -302,16 +369,15 @@ class Category
public:
using IsActive = std::false_type;
using ArgumentType = typename TraceEvent::ArgumentType;
using TokenType = Token<Category, false>;
Category(ArgumentType, EventQueue<TraceEvent, std::true_type> &) {}
Category(ArgumentType, EventQueue<TraceEvent, std::false_type> &) {}
Token<false> beginAsynchronous(ArgumentType) { return {}; }
TokenType beginAsynchronous(ArgumentType) { return {}; }
void tickAsynchronous(Token<false>, ArgumentType) {}
void endAsynchronous(Token<false>, ArgumentType) {}
void tickAsynchronous(ArgumentType) {}
static constexpr bool isActive() { return false; }
};
@@ -323,6 +389,9 @@ public:
using IsActive = std::true_type;
using ArgumentType = typename TraceEvent::ArgumentType;
using StringType = typename TraceEvent::StringType;
using TokenType = Token<Category, true>;
friend TokenType;
template<typename EventQueue>
Category(ArgumentType name, EventQueue &queue)
@@ -334,43 +403,13 @@ public:
idCounter = globalIdCounter += 1ULL << 32;
}
Token<true> beginAsynchronous(ArgumentType traceName)
TokenType beginAsynchronous(ArgumentType traceName)
{
auto id = ++idCounter;
auto &traceEvent = getTraceEvent(m_eventQueue);
traceEvent.name = std::move(traceName);
traceEvent.category = m_name;
traceEvent.time = Clock::now();
traceEvent.type = 'b';
traceEvent.id = id;
std::size_t id = ++idCounter;
return id;
}
beginAsynchronous(id, traceName);
void tickAsynchronous(Token<true> token, ArgumentType traceName)
{
if (!token)
return;
auto &traceEvent = getTraceEvent(m_eventQueue);
traceEvent.name = std::move(traceName);
traceEvent.category = m_name;
traceEvent.time = Clock::now();
traceEvent.type = 'n';
traceEvent.id = *token;
}
void endAsynchronous(Token<true> token, ArgumentType traceName)
{
if (!token)
return;
auto &traceEvent = getTraceEvent(m_eventQueue);
traceEvent.name = std::move(traceName);
traceEvent.category = m_name;
traceEvent.time = Clock::now();
traceEvent.type = 'e';
traceEvent.id = *token;
return {traceName, id, *this};
}
EnabledEventQueue<TraceEvent> &eventQueue() const { return m_eventQueue; }
@@ -379,6 +418,39 @@ public:
static constexpr bool isActive() { return true; }
private:
void beginAsynchronous(std::size_t id, StringType traceName)
{
auto &traceEvent = getTraceEvent(m_eventQueue);
traceEvent.name = std::move(traceName);
traceEvent.category = m_name;
traceEvent.type = 'b';
traceEvent.id = id;
traceEvent.time = Clock::now();
}
void tickAsynchronous(std::size_t id, StringType traceName)
{
auto time = Clock::now();
auto &traceEvent = getTraceEvent(m_eventQueue);
traceEvent.name = std::move(traceName);
traceEvent.category = m_name;
traceEvent.time = time;
traceEvent.type = 'n';
traceEvent.id = id;
}
void endAsynchronous(std::size_t id, StringType traceName)
{
auto time = Clock::now();
auto &traceEvent = getTraceEvent(m_eventQueue);
traceEvent.name = std::move(traceName);
traceEvent.category = m_name;
traceEvent.time = time;
traceEvent.type = 'e';
traceEvent.id = id;
}
private:
StringType m_name;
EnabledEventQueue<TraceEvent> &m_eventQueue;

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

@@ -15,8 +15,9 @@ namespace QmlDesigner {
using namespace NanotraceHR::Literals;
namespace ImageCache {
namespace {
using TraceFile = NanotraceHR::TraceFile<imageCacheTracingIsEnabled()>;
using TraceFile = NanotraceHR::TraceFile<ImageCache::tracingIsEnabled()>;
TraceFile traceFile{"qml_designer.json"};
@@ -24,14 +25,14 @@ thread_local auto eventQueueData = NanotraceHR::makeEventQueueData<NanotraceHR::
traceFile);
thread_local NanotraceHR::EventQueue eventQueue = eventQueueData.createEventQueue();
thread_local NanotraceHR::StringViewCategory<imageCacheTracingIsEnabled()> category{"image cache"_t,
eventQueue};
thread_local Category category_{"image cache"_t, eventQueue};
} // namespace
NanotraceHR::StringViewCategory<imageCacheTracingIsEnabled()> &imageCacheCategory()
Category &category()
{
return category;
return category_;
}
} // namespace ImageCache
AsynchronousImageCache::AsynchronousImageCache(ImageCacheStorageInterface &storage,
ImageCacheGeneratorInterface &generator,
@@ -52,7 +53,7 @@ void AsynchronousImageCache::request(Utils::SmallStringView name,
ImageCache::CaptureImageCallback captureCallback,
ImageCache::AbortCallback abortCallback,
ImageCache::AuxiliaryData auxiliaryData,
ImageCacheTraceToken traceToken,
ImageCache::TraceToken traceToken,
ImageCacheStorageInterface &storage,
ImageCacheGeneratorInterface &generator,
TimeStampProviderInterface &timeStampProvider)
@@ -62,11 +63,7 @@ void AsynchronousImageCache::request(Utils::SmallStringView name,
const auto timeStamp = timeStampProvider.timeStamp(name);
auto requestImageFromStorage = [&](RequestType requestType) {
imageCacheCategory().tickAsynchronous(traceToken, "start fetching image from storage"_t);
QScopeGuard finally{[=] {
imageCacheCategory().tickAsynchronous(traceToken, "end fetching image from storage"_t);
}};
auto storageTraceToken = traceToken.begin("fetching image from storage"_t);
switch (requestType) {
case RequestType::Image:
return storage.fetchImage(id, timeStamp);
@@ -80,22 +77,24 @@ void AsynchronousImageCache::request(Utils::SmallStringView name,
return storage.fetchImage(id, timeStamp);
};
const auto entry = requestImageFromStorage(requestType);
if (entry) {
if (entry->isNull()) {
traceToken.tick("there was an null image in storage"_t);
abortCallback(ImageCache::AbortReason::Failed);
imageCacheCategory().endAsynchronous(traceToken,
"abort image request because entry in database is null"_t);
} else {
captureCallback(*entry);
imageCacheCategory().endAsynchronous(traceToken, "image request delivered from storage"_t);
}
traceToken.end();
} else {
auto callback =
auto imageGeneratedCallback =
[captureCallback = std::move(captureCallback),
requestType,
traceToken](const QImage &image, const QImage &midSizeImage, const QImage &smallImage) {
requestType](const QImage &image,
const QImage &midSizeImage,
const QImage &smallImage,
ImageCache::TraceToken traceToken) {
auto selectImage = [](RequestType requestType,
const QImage &image,
const QImage &midSizeImage,
@@ -113,19 +112,27 @@ void AsynchronousImageCache::request(Utils::SmallStringView name,
return image;
};
traceToken.end();
captureCallback(selectImage(requestType, image, midSizeImage, smallImage));
imageCacheCategory().endAsynchronous(traceToken,
"image request delivered from generation"_t);
};
imageCacheCategory().tickAsynchronous(traceToken, "request image generation"_t);
auto imageGenerationAbortedCallback =
[abortCallback = std::move(abortCallback)](ImageCache::AbortReason reason,
ImageCache::TraceToken traceToken) {
traceToken.tick("image could not be created"_t);
traceToken.end();
abortCallback(reason);
};
traceToken.tick("call the generator"_t);
generator.generateImage(name,
extraId,
timeStamp,
std::move(callback),
std::move(abortCallback),
std::move(auxiliaryData));
std::move(imageGeneratedCallback),
std::move(imageGenerationAbortedCallback),
std::move(auxiliaryData),
std::move(traceToken));
}
}
@@ -135,7 +142,7 @@ void AsynchronousImageCache::requestImage(Utils::SmallStringView name,
Utils::SmallStringView extraId,
ImageCache::AuxiliaryData auxiliaryData)
{
auto traceToken = imageCacheCategory().beginAsynchronous(
auto traceToken = ImageCache::category().beginAsynchronous(
"request image in asynchornous image cache"_t);
m_taskQueue.addTask(std::move(name),
std::move(extraId),
@@ -143,7 +150,7 @@ void AsynchronousImageCache::requestImage(Utils::SmallStringView name,
std::move(abortCallback),
std::move(auxiliaryData),
RequestType::Image,
traceToken);
std ::move(traceToken));
}
void AsynchronousImageCache::requestMidSizeImage(Utils::SmallStringView name,
@@ -152,7 +159,7 @@ void AsynchronousImageCache::requestMidSizeImage(Utils::SmallStringView name,
Utils::SmallStringView extraId,
ImageCache::AuxiliaryData auxiliaryData)
{
auto traceToken = imageCacheCategory().beginAsynchronous(
auto traceToken = ImageCache::category().beginAsynchronous(
"request mid size image in asynchornous image cache"_t);
m_taskQueue.addTask(std::move(name),
std::move(extraId),
@@ -160,7 +167,7 @@ void AsynchronousImageCache::requestMidSizeImage(Utils::SmallStringView name,
std::move(abortCallback),
std::move(auxiliaryData),
RequestType::MidSizeImage,
traceToken);
std ::move(traceToken));
}
void AsynchronousImageCache::requestSmallImage(Utils::SmallStringView name,
@@ -169,7 +176,7 @@ void AsynchronousImageCache::requestSmallImage(Utils::SmallStringView name,
Utils::SmallStringView extraId,
ImageCache::AuxiliaryData auxiliaryData)
{
auto traceToken = imageCacheCategory().beginAsynchronous(
auto traceToken = ImageCache::category().beginAsynchronous(
"request small size image in asynchornous image cache"_t);
m_taskQueue.addTask(std::move(name),
std::move(extraId),
@@ -177,7 +184,7 @@ void AsynchronousImageCache::requestSmallImage(Utils::SmallStringView name,
std::move(abortCallback),
std::move(auxiliaryData),
RequestType::SmallImage,
traceToken);
std ::move(traceToken));
}
void AsynchronousImageCache::clean()
@@ -186,4 +193,31 @@ void AsynchronousImageCache::clean()
m_taskQueue.clean();
}
void AsynchronousImageCache::Dispatch::operator()(Entry &entry)
{
using namespace NanotraceHR::Literals;
request(entry.name,
entry.extraId,
entry.requestType,
std::move(entry.captureCallback),
std::move(entry.abortCallback),
std::move(entry.auxiliaryData),
std::move(entry.traceToken),
storage,
generator,
timeStampProvider);
}
void AsynchronousImageCache::Clean::operator()(Entry &entry)
{
using namespace NanotraceHR::Literals;
entry.traceToken.tick("cleaning up in the cache"_t);
entry.abortCallback(ImageCache::AbortReason::Abort);
entry.traceToken.end();
}
} // namespace QmlDesigner

7
src/plugins/qmldesigner/designercore/imagecache/asynchronousimagefactory.cpp
View File

@@ -46,7 +46,10 @@ void AsynchronousImageFactory::request(Utils::SmallStringView name,
if (currentModifiedTime < (storageModifiedTime + pause))
return;
auto capture = [&](const QImage &image, const QImage &midSizeImage, const QImage &smallImage) {
auto capture = [&](const QImage &image,
const QImage &midSizeImage,
const QImage &smallImage,
ImageCache::TraceToken) {
storage.storeImage(id, currentModifiedTime, image, midSizeImage, smallImage);
};
@@ -54,7 +57,7 @@ void AsynchronousImageFactory::request(Utils::SmallStringView name,
extraId,
std::move(auxiliaryData),
std::move(capture),
ImageCache::AbortCallback{});
ImageCache::InternalAbortCallback{});
}
void AsynchronousImageFactory::clean()

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

@@ -73,8 +73,12 @@ void ImageCacheCollector::start(Utils::SmallStringView name,
Utils::SmallStringView state,
const ImageCache::AuxiliaryData &auxiliaryData,
CaptureCallback captureCallback,
AbortCallback abortCallback)
AbortCallback abortCallback,
ImageCache::TraceToken traceToken)
{
using namespace NanotraceHR::Literals;
auto collectorTraceToken = traceToken.begin("generate image in standard collector"_t);
RewriterView rewriterView{m_externalDependencies, RewriterView::Amend};
NodeInstanceView nodeInstanceView{m_connectionManager, m_externalDependencies};
nodeInstanceView.setCaptureImageMinimumAndMaximumSize(captureImageMinimumSize,
@@ -101,7 +105,7 @@ void ImageCacheCollector::start(Utils::SmallStringView name,
if (!rewriterView.errors().isEmpty() || (!rewriterView.rootModelNode().metaInfo().isGraphicalItem()
&& !is3DRoot)) {
if (abortCallback)
abortCallback(ImageCache::AbortReason::Failed);
abortCallback(ImageCache::AbortReason::Failed, std::move(traceToken));
return;
}
@@ -117,21 +121,17 @@ void ImageCacheCollector::start(Utils::SmallStringView name,
if (stateNode.isValid())
rewriterView.setCurrentStateNode(stateNode);
auto callback = [=, captureCallback = std::move(captureCallback)](const QImage &image) {
if (nullImageHandling == ImageCacheCollectorNullImageHandling::CaptureNullImage
|| !image.isNull()) {
QImage midSizeImage = scaleImage(image, QSize{300, 300});
QImage smallImage = scaleImage(midSizeImage, QSize{96, 96});
captureCallback(image, midSizeImage, smallImage);
}
};
QImage captureImage;
auto callback = [&](const QImage &image) { captureImage = image; };
if (!m_target)
return;
nodeInstanceView.setTarget(m_target.data());
m_connectionManager.setCallback(std::move(callback));
nodeInstanceView.setCrashCallback([=] { abortCallback(ImageCache::AbortReason::Failed); });
bool isCrashed = false;
nodeInstanceView.setCrashCallback([&] { isCrashed = true; });
model->setNodeInstanceView(&nodeInstanceView);
bool capturedDataArrived = m_connectionManager.waitForCapturedData();
@@ -142,8 +142,18 @@ void ImageCacheCollector::start(Utils::SmallStringView name,
model->setNodeInstanceView({});
model->setRewriterView({});
if (isCrashed)
abortCallback(ImageCache::AbortReason::Failed, std::move(traceToken));
if (!capturedDataArrived && abortCallback)
abortCallback(ImageCache::AbortReason::Failed);
abortCallback(ImageCache::AbortReason::Failed, std::move(traceToken));
if (nullImageHandling == ImageCacheCollectorNullImageHandling::CaptureNullImage
|| !captureImage.isNull()) {
QImage midSizeImage = scaleImage(captureImage, QSize{300, 300});
QImage smallImage = scaleImage(midSizeImage, QSize{96, 96});
captureCallback(captureImage, midSizeImage, smallImage, std::move(traceToken));
}
}
ImageCacheCollectorInterface::ImageTuple ImageCacheCollector::createImage(

3
src/plugins/qmldesigner/designercore/imagecache/imagecachecollector.h
View File

@@ -41,7 +41,8 @@ public:
Utils::SmallStringView state,
const ImageCache::AuxiliaryData &auxiliaryData,
CaptureCallback captureCallback,
AbortCallback abortCallback) override;
AbortCallback abortCallback,
ImageCache::TraceToken traceToken) override;
ImageTuple createImage(Utils::SmallStringView filePath,
Utils::SmallStringView state,

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

@@ -15,14 +15,15 @@ class ImageCacheCollectorInterface
{
public:
using CaptureCallback = ImageCache::CaptureImageWithScaledImagesCallback;
using AbortCallback = ImageCache::AbortCallback;
using AbortCallback = ImageCache::InternalAbortCallback;
using ImageTuple = std::tuple<QImage, QImage, QImage>;
virtual void start(Utils::SmallStringView filePath,
Utils::SmallStringView extraId,
const ImageCache::AuxiliaryData &auxiliaryData,
CaptureCallback captureCallback,
AbortCallback abortCallback)
AbortCallback abortCallback,
ImageCache::TraceToken traceToken = {})
= 0;
virtual ImageTuple createImage(Utils::SmallStringView filePath,

17
src/plugins/qmldesigner/designercore/imagecache/imagecachedispatchcollector.h
View File

@@ -12,13 +12,15 @@ class ImageCacheDispatchCollector final : public ImageCacheCollectorInterface
{
public:
ImageCacheDispatchCollector(CollectorEntries collectors)
: m_collectors{std::move(collectors)} {};
: m_collectors{std::move(collectors)}
{}
void start(Utils::SmallStringView filePath,
Utils::SmallStringView state,
const ImageCache::AuxiliaryData &auxiliaryData,
CaptureCallback captureCallback,
AbortCallback abortCallback) override
AbortCallback abortCallback,
ImageCache::TraceToken traceToken) override
{
std::apply(
[&](const auto &...collectors) {
@@ -27,6 +29,7 @@ public:
auxiliaryData,
std::move(captureCallback),
std::move(abortCallback),
std::move(traceToken),
collectors...);
},
m_collectors);
@@ -61,6 +64,7 @@ private:
const ImageCache::AuxiliaryData &auxiliaryData,
CaptureCallback captureCallback,
AbortCallback abortCallback,
ImageCache::TraceToken traceToken,
const Collector &collector,
const Collectors &...collectors)
{
@@ -69,13 +73,15 @@ private:
state,
auxiliaryData,
std::move(captureCallback),
std::move(abortCallback));
std::move(abortCallback),
std::move(traceToken));
} else {
dispatchStart(filePath,
state,
auxiliaryData,
std::move(captureCallback),
std::move(abortCallback),
std::move(traceToken),
collectors...);
}
}
@@ -84,10 +90,11 @@ private:
Utils::SmallStringView,
const ImageCache::AuxiliaryData &,
CaptureCallback,
AbortCallback abortCallback)
AbortCallback abortCallback,
ImageCache::TraceToken traceToken)
{
qWarning() << "ImageCacheDispatchCollector: cannot handle file type.";
abortCallback(ImageCache::AbortReason::Failed);
abortCallback(ImageCache::AbortReason::Failed, std::move(traceToken));
}
template<typename Collector, typename... Collectors>

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

@@ -94,7 +94,8 @@ void ImageCacheFontCollector::start(Utils::SmallStringView name,
Utils::SmallStringView,
const ImageCache::AuxiliaryData &auxiliaryDataValue,
CaptureCallback captureCallback,
AbortCallback abortCallback)
AbortCallback abortCallback,
ImageCache::TraceToken traceToken)
{
QFont font;
if (resolveFont(QString(name), font) >= 0) {
@@ -107,12 +108,12 @@ void ImageCacheFontCollector::start(Utils::SmallStringView name,
QImage image = createFontImage(text, textColor, font, size);
if (!image.isNull()) {
captureCallback(std::move(image), {}, {});
captureCallback(std::move(image), {}, {}, std::move(traceToken));
return;
}
}
}
abortCallback(ImageCache::AbortReason::Failed);
abortCallback(ImageCache::AbortReason::Failed, std::move(traceToken));
}
ImageCacheCollectorInterface::ImageTuple ImageCacheFontCollector::createImage(

3
src/plugins/qmldesigner/designercore/imagecache/imagecachefontcollector.h
View File

@@ -18,7 +18,8 @@ public:
Utils::SmallStringView extraId,
const ImageCache::AuxiliaryData &auxiliaryData,
CaptureCallback captureCallback,
AbortCallback abortCallback) override;
AbortCallback abortCallback,
ImageCache::TraceToken traceToken) override;
ImageTuple createImage(Utils::SmallStringView filePath,
Utils::SmallStringView extraId,

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

@@ -42,8 +42,9 @@ void ImageCacheGenerator::generateImage(Utils::SmallStringView name,
Utils::SmallStringView extraId,
Sqlite::TimeStamp timeStamp,
ImageCache::CaptureImageWithScaledImagesCallback &&captureCallback,
ImageCache::AbortCallback &&abortCallback,
ImageCache::AuxiliaryData &&auxiliaryData)
ImageCache::InternalAbortCallback &&abortCallback,
ImageCache::AuxiliaryData &&auxiliaryData,
ImageCache::TraceToken traceToken)
{
{
std::lock_guard lock{m_mutex};
@@ -64,7 +65,8 @@ void ImageCacheGenerator::generateImage(Utils::SmallStringView name,
std::move(auxiliaryData),
timeStamp,
std::move(captureCallback),
std::move(abortCallback));
std::move(abortCallback),
std::move(traceToken));
}
}
@@ -89,9 +91,14 @@ void callCallbacks(const Callbacks &callbacks, Argument &&...arguments)
void ImageCacheGenerator::clean()
{
using namespace NanotraceHR::Literals;
std::lock_guard lock{m_mutex};
for (Task &task : m_tasks)
callCallbacks(task.abortCallbacks, ImageCache::AbortReason::Abort);
for (Task &task : m_tasks) {
task.traceToken.tick("cleaning up in the generator"_t);
task.traceToken.end();
callCallbacks(task.abortCallbacks, ImageCache::AbortReason::Abort, std::move(task.traceToken));
}
m_tasks.clear();
}
@@ -124,27 +131,43 @@ void ImageCacheGenerator::startGeneration()
task.filePath,
task.extraId,
std::move(task.auxiliaryData),
[this, task](const QImage &image, const QImage &midSizeImage, const QImage &smallImage) {
[this,
abortCallbacks = task.abortCallbacks,
captureCallbacks = std::move(task.captureCallbacks),
filePath = task.filePath,
extraId = task.extraId,
timeStamp = task.timeStamp](const QImage &image,
const QImage &midSizeImage,
const QImage &smallImage,
ImageCache::TraceToken traceToken) {
if (image.isNull() && midSizeImage.isNull() && smallImage.isNull())
callCallbacks(task.abortCallbacks, ImageCache::AbortReason::Failed);
callCallbacks(abortCallbacks,
ImageCache::AbortReason::Failed,
std::move(traceToken));
else
callCallbacks(task.captureCallbacks, image, midSizeImage, smallImage);
callCallbacks(captureCallbacks,
image,
midSizeImage,
smallImage,
std::move(traceToken));
m_storage.storeImage(createId(task.filePath, task.extraId),
task.timeStamp,
m_storage.storeImage(createId(filePath, extraId),
timeStamp,
image,
midSizeImage,
smallImage);
},
[this, task](ImageCache::AbortReason abortReason) {
callCallbacks(task.abortCallbacks, abortReason);
[this,
abortCallbacks = task.abortCallbacks,
filePath = task.filePath,
extraId = task.extraId,
timeStamp = task.timeStamp](ImageCache::AbortReason abortReason,
ImageCache::TraceToken traceToken) {
callCallbacks(abortCallbacks, abortReason, std::move(traceToken));
if (abortReason != ImageCache::AbortReason::Abort)
m_storage.storeImage(createId(task.filePath, task.extraId),
task.timeStamp,
{},
{},
{});
});
m_storage.storeImage(createId(filePath, extraId), timeStamp, {}, {}, {});
},
std::move(task.traceToken));
std::lock_guard lock{m_mutex};
if (m_tasks.empty())

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

@@ -34,8 +34,9 @@ public:
Utils::SmallStringView extraId,
Sqlite::TimeStamp timeStamp,
ImageCache::CaptureImageWithScaledImagesCallback &&captureCallback,
ImageCache::AbortCallback &&abortCallback,
ImageCache::AuxiliaryData &&auxiliaryData) override;
ImageCache::InternalAbortCallback &&abortCallback,
ImageCache::AuxiliaryData &&auxiliaryData,
ImageCache::TraceToken traceToken = {}) override;
void clean() override;
void waitForFinished() override;
@@ -44,26 +45,30 @@ private:
struct Task
{
Task() = default;
Task(Utils::SmallStringView filePath,
Utils::SmallStringView extraId,
ImageCache::AuxiliaryData &&auxiliaryData,
Sqlite::TimeStamp timeStamp,
ImageCache::CaptureImageWithScaledImagesCallback &&captureCallback,
ImageCache::AbortCallback &&abortCallback)
ImageCache::InternalAbortCallback &&abortCallback,
ImageCache::TraceToken traceToken)
: filePath(filePath)
, extraId(std::move(extraId))
, auxiliaryData(std::move(auxiliaryData))
, captureCallbacks({std::move(captureCallback)})
, abortCallbacks({std::move(abortCallback)})
, timeStamp(timeStamp)
, traceToken{std::move(traceToken)}
{}
Utils::PathString filePath;
Utils::SmallString extraId;
ImageCache::AuxiliaryData auxiliaryData;
std::vector<ImageCache::CaptureImageWithScaledImagesCallback> captureCallbacks;
std::vector<ImageCache::AbortCallback> abortCallbacks;
std::vector<ImageCache::InternalAbortCallback> abortCallbacks;
Sqlite::TimeStamp timeStamp;
ImageCache::TraceToken traceToken;
};
void startGeneration();
@@ -71,7 +76,6 @@ private:
[[nodiscard]] std::tuple<std::unique_lock<std::mutex>, bool> waitForEntries();
void stopThread();
private:
private:
std::unique_ptr<QThread> m_backgroundThread;
mutable std::mutex m_mutex;

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

@@ -18,8 +18,9 @@ public:
Utils::SmallStringView extraId,
Sqlite::TimeStamp timeStamp,
ImageCache::CaptureImageWithScaledImagesCallback &&captureCallback,
ImageCache::AbortCallback &&abortCallback,
ImageCache::AuxiliaryData &&auxiliaryData)
ImageCache::InternalAbortCallback &&abortCallback,
ImageCache::AuxiliaryData &&auxiliaryData,
ImageCache::TraceToken = {})
= 0;
virtual void clean() = 0;

6
src/plugins/qmldesigner/designercore/imagecache/meshimagecachecollector.cpp
View File

@@ -30,7 +30,8 @@ void MeshImageCacheCollector::start(Utils::SmallStringView name,
Utils::SmallStringView state,
const ImageCache::AuxiliaryData &auxiliaryData,
CaptureCallback captureCallback,
AbortCallback abortCallback)
AbortCallback abortCallback,
ImageCache::TraceToken traceToken)
{
QTemporaryFile file(QDir::tempPath() + "/mesh-XXXXXX.qml");
if (file.open()) {
@@ -63,7 +64,8 @@ void MeshImageCacheCollector::start(Utils::SmallStringView name,
Utils::PathString path{file.fileName()};
m_imageCacheCollector.start(path, state, auxiliaryData, captureCallback, abortCallback);
m_imageCacheCollector
.start(path, state, auxiliaryData, captureCallback, abortCallback, std::move(traceToken));
}
ImageCacheCollectorInterface::ImageTuple MeshImageCacheCollector::createImage(

3
src/plugins/qmldesigner/designercore/imagecache/meshimagecachecollector.h
View File

@@ -29,7 +29,8 @@ public:
Utils::SmallStringView state,
const ImageCache::AuxiliaryData &auxiliaryData,
CaptureCallback captureCallback,
AbortCallback abortCallback) override;
AbortCallback abortCallback,
ImageCache::TraceToken traceToken = {}) override;
ImageTuple createImage(Utils::SmallStringView filePath,
Utils::SmallStringView state,

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

@@ -83,7 +83,7 @@ private:
Task task = std::move(m_tasks.front());
m_tasks.pop_front();
return {task};
return {std::move(task)};
}
void ensureThreadIsRunning()

7
src/plugins/qmldesigner/designercore/imagecache/textureimagecachecollector.cpp
View File

@@ -17,7 +17,8 @@ void TextureImageCacheCollector::start(Utils::SmallStringView name,
Utils::SmallStringView,
const ImageCache::AuxiliaryData &,
CaptureCallback captureCallback,
AbortCallback abortCallback)
AbortCallback abortCallback,
ImageCache::TraceToken traceToken)
{
Asset asset {QString(name)};
QImage image;
@@ -31,11 +32,11 @@ void TextureImageCacheCollector::start(Utils::SmallStringView name,
}
if (image.isNull())
abortCallback(ImageCache::AbortReason::Failed);
abortCallback(ImageCache::AbortReason::Failed, std::move(traceToken));
else
image = image.scaled(QSize{300, 300}, Qt::KeepAspectRatio);
captureCallback({}, image, {});
captureCallback({}, image, {}, std::move(traceToken));
}
ImageCacheCollectorInterface::ImageTuple TextureImageCacheCollector::createImage(

3
src/plugins/qmldesigner/designercore/imagecache/textureimagecachecollector.h
View File

@@ -17,7 +17,8 @@ public:
Utils::SmallStringView state,
const ImageCache::AuxiliaryData &auxiliaryData,
CaptureCallback captureCallback,
AbortCallback abortCallback) override;
AbortCallback abortCallback,
ImageCache::TraceToken traceToken = {}) override;
ImageTuple createImage(Utils::SmallStringView filePath,
Utils::SmallStringView state,

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

@@ -3,10 +3,11 @@
#pragma once
#include <qmldesignercorelib_exports.h>
#include "asynchronousimagecacheinterface.h"
#include <imagecache/taskqueue.h>
#include <nanotrace/nanotracehr.h>
#include <condition_variable>
#include <deque>
@@ -22,19 +23,6 @@ class ImageCacheStorageInterface;
class ImageCacheGeneratorInterface;
class ImageCacheCollectorInterface;
constexpr bool imageCacheTracingIsEnabled()
{
#ifdef ENABLE_IMAGE_CACHE_TRACING
return NanotraceHR::isTracerActive();
#else
return false;
#endif
}
using ImageCacheTraceToken = NanotraceHR::Token<imageCacheTracingIsEnabled()>;
NanotraceHR::StringViewCategory<imageCacheTracingIsEnabled()> &imageCacheCategory();
class AsynchronousImageCache final : public AsynchronousImageCacheInterface
{
public:
@@ -74,14 +62,14 @@ private:
ImageCache::AbortCallback &&abortCallback,
ImageCache::AuxiliaryData &&auxiliaryData,
RequestType requestType,
ImageCacheTraceToken traceToken)
ImageCache::TraceToken traceToken)
: name{std::move(name)}
, extraId{std::move(extraId)}
, captureCallback{std::move(captureCallback)}
, abortCallback{std::move(abortCallback)}
, auxiliaryData{std::move(auxiliaryData)}
, requestType{requestType}
, traceToken{traceToken}
, traceToken{std::move(traceToken)}
{}
Utils::PathString name;
@@ -90,7 +78,7 @@ private:
ImageCache::AbortCallback abortCallback;
ImageCache::AuxiliaryData auxiliaryData;
RequestType requestType = RequestType::Image;
ImageCacheTraceToken traceToken;
ImageCache::TraceToken traceToken;
};
static void request(Utils::SmallStringView name,
@@ -99,26 +87,14 @@ private:
ImageCache::CaptureImageCallback captureCallback,
ImageCache::AbortCallback abortCallback,
ImageCache::AuxiliaryData auxiliaryData,
ImageCacheTraceToken traceToken,
ImageCache::TraceToken traceToken,
ImageCacheStorageInterface &storage,
ImageCacheGeneratorInterface &generator,
TimeStampProviderInterface &timeStampProvider);
struct Dispatch
{
void operator()(Entry &entry)
{
request(entry.name,
entry.extraId,
entry.requestType,
std::move(entry.captureCallback),
std::move(entry.abortCallback),
std::move(entry.auxiliaryData),
entry.traceToken,
storage,
generator,
timeStampProvider);
}
QMLDESIGNERCORE_EXPORT void operator()(Entry &entry);
ImageCacheStorageInterface &storage;
ImageCacheGeneratorInterface &generator;
@@ -127,13 +103,7 @@ private:
struct Clean
{
void operator()(Entry &entry)
{
using namespace NanotraceHR::Literals;
entry.abortCallback(ImageCache::AbortReason::Abort);
imageCacheCategory().endAsynchronous(entry.traceToken, "aborted for cleanup"_t);
}
QMLDESIGNERCORE_EXPORT void operator()(Entry &entry);
};
private:

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

@@ -3,6 +3,7 @@
#pragma once
#include <nanotrace/nanotracehr.h>
#include <utils/span.h>
#include <QImage>
@@ -16,6 +17,19 @@ namespace QmlDesigner {
namespace ImageCache {
constexpr bool tracingIsEnabled()
{
#ifdef ENABLE_IMAGE_CACHE_TRACING
return NanotraceHR::isTracerActive();
#else
return false;
#endif
}
using Category = NanotraceHR::StringViewCategory<tracingIsEnabled()>;
using TraceToken = Category::TokenType;
Category &category();
class FontCollectorSizeAuxiliaryData
{
public:
@@ -46,9 +60,11 @@ using AuxiliaryData = std::variant<std::monostate,
enum class AbortReason : char { Abort, Failed, NoEntry };
using CaptureImageCallback = std::function<void(const QImage &)>;
using CaptureImageWithScaledImagesCallback = std::function<
void(const QImage &image, const QImage &midSizeImage, const QImage &smallImage)>;
using CaptureImageWithScaledImagesCallback = std::function<void(
const QImage &image, const QImage &midSizeImage, const QImage &smallImage, ImageCache::TraceToken)>;
using AbortCallback = std::function<void(ImageCache::AbortReason)>;
using InternalAbortCallback = std::function<void(ImageCache::AbortReason, ImageCache::TraceToken)>;
} // namespace ImageCache
} // namespace QmlDesigner

3
tests/unit/tests/mocks/imagecachecollectormock.h
View File

@@ -16,7 +16,8 @@ public:
Utils::SmallStringView state,
const QmlDesigner::ImageCache::AuxiliaryData &auxiliaryData,
ImageCacheCollectorInterface::CaptureCallback captureCallback,
ImageCacheCollectorInterface::AbortCallback abortCallback),
ImageCacheCollectorInterface::AbortCallback abortCallback,
QmlDesigner::ImageCache::TraceToken),
(override));
MOCK_METHOD(ImageTuple,

5
tests/unit/tests/mocks/mockimagecachegenerator.h
View File

@@ -16,8 +16,9 @@ public:
Utils::SmallStringView state,
Sqlite::TimeStamp timeStamp,
QmlDesigner::ImageCache::CaptureImageWithScaledImagesCallback &&captureCallback,
QmlDesigner::ImageCache::AbortCallback &&abortCallback,
QmlDesigner::ImageCache::AuxiliaryData &&auxiliaryData),
QmlDesigner::ImageCache::InternalAbortCallback &&abortCallback,
QmlDesigner::ImageCache::AuxiliaryData &&auxiliaryData,
QmlDesigner::ImageCache::TraceToken),
(override));
MOCK_METHOD(void, clean, (), (override));
MOCK_METHOD(void, waitForFinished, (), (override));

90
tests/unit/tests/unittests/imagecache/asynchronousimagecache-test.cpp
View File

@@ -93,8 +93,8 @@ TEST_F(AsynchronousImageCache, request_image_request_image_from_generator)
.WillByDefault(Return(Sqlite::TimeStamp{123}));
EXPECT_CALL(mockGenerator,
generateImage(Eq("/path/to/Component.qml"), _, Eq(Sqlite::TimeStamp{123}), _, _, _))
.WillRepeatedly([&](auto, auto, auto, auto, auto, auto) { notification.notify(); });
generateImage(Eq("/path/to/Component.qml"), _, Eq(Sqlite::TimeStamp{123}), _, _, _, _))
.WillRepeatedly([&](auto, auto, auto, auto, auto, auto, auto) { notification.notify(); });
cache.requestImage("/path/to/Component.qml",
mockCaptureCallback.AsStdFunction(),
@@ -104,9 +104,9 @@ TEST_F(AsynchronousImageCache, request_image_request_image_from_generator)
TEST_F(AsynchronousImageCache, request_image_calls_capture_callback_with_image_from_generator)
{
ON_CALL(mockGenerator, generateImage(Eq("/path/to/Component.qml"), _, _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto &&callback, auto, auto) {
callback(QImage{image1}, QImage{midSizeImage1}, QImage{smallImage1});
ON_CALL(mockGenerator, generateImage(Eq("/path/to/Component.qml"), _, _, _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto &&callback, auto, auto, auto) {
callback(QImage{image1}, QImage{midSizeImage1}, QImage{smallImage1}, {});
notification.notify();
});
@@ -120,9 +120,9 @@ TEST_F(AsynchronousImageCache, request_image_calls_capture_callback_with_image_f
TEST_F(AsynchronousImageCache, request_image_calls_abort_callback_from_generator)
{
ON_CALL(mockGenerator, generateImage(Eq("/path/to/Component.qml"), _, _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto &&, auto &&abortCallback, auto) {
abortCallback(QmlDesigner::ImageCache::AbortReason::Failed);
ON_CALL(mockGenerator, generateImage(Eq("/path/to/Component.qml"), _, _, _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto &&, auto &&abortCallback, auto, auto) {
abortCallback(QmlDesigner::ImageCache::AbortReason::Failed, {});
notification.notify();
});
@@ -200,8 +200,8 @@ TEST_F(AsynchronousImageCache, request_mid_size_image_request_image_from_generat
.WillByDefault(Return(Sqlite::TimeStamp{123}));
EXPECT_CALL(mockGenerator,
generateImage(Eq("/path/to/Component.qml"), _, Eq(Sqlite::TimeStamp{123}), _, _, _))
.WillRepeatedly([&](auto, auto, auto, auto, auto, auto) { notification.notify(); });
generateImage(Eq("/path/to/Component.qml"), _, Eq(Sqlite::TimeStamp{123}), _, _, _, _))
.WillRepeatedly([&](auto, auto, auto, auto, auto, auto, auto) { notification.notify(); });
cache.requestMidSizeImage("/path/to/Component.qml",
mockCaptureCallback.AsStdFunction(),
@@ -211,9 +211,9 @@ TEST_F(AsynchronousImageCache, request_mid_size_image_request_image_from_generat
TEST_F(AsynchronousImageCache, request_mid_size_image_calls_capture_callback_with_image_from_generator)
{
ON_CALL(mockGenerator, generateImage(Eq("/path/to/Component.qml"), _, _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto &&callback, auto, auto) {
callback(QImage{image1}, QImage{midSizeImage1}, QImage{smallImage1});
ON_CALL(mockGenerator, generateImage(Eq("/path/to/Component.qml"), _, _, _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto &&callback, auto, auto, auto) {
callback(QImage{image1}, QImage{midSizeImage1}, QImage{smallImage1}, {});
notification.notify();
});
@@ -227,9 +227,9 @@ TEST_F(AsynchronousImageCache, request_mid_size_image_calls_capture_callback_wit
TEST_F(AsynchronousImageCache, request_mid_size_image_calls_abort_callback_from_generator)
{
ON_CALL(mockGenerator, generateImage(Eq("/path/to/Component.qml"), _, _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto &&, auto &&abortCallback, auto) {
abortCallback(QmlDesigner::ImageCache::AbortReason::Failed);
ON_CALL(mockGenerator, generateImage(Eq("/path/to/Component.qml"), _, _, _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto &&, auto &&abortCallback, auto, auto) {
abortCallback(QmlDesigner::ImageCache::AbortReason::Failed, {});
notification.notify();
});
@@ -306,8 +306,8 @@ TEST_F(AsynchronousImageCache, request_small_image_request_image_from_generator)
.WillByDefault(Return(Sqlite::TimeStamp{123}));
EXPECT_CALL(mockGenerator,
generateImage(Eq("/path/to/Component.qml"), _, Eq(Sqlite::TimeStamp{123}), _, _, _))
.WillRepeatedly([&](auto, auto, auto, auto, auto, auto) { notification.notify(); });
generateImage(Eq("/path/to/Component.qml"), _, Eq(Sqlite::TimeStamp{123}), _, _, _, _))
.WillRepeatedly([&](auto, auto, auto, auto, auto, auto, auto) { notification.notify(); });
cache.requestSmallImage("/path/to/Component.qml",
mockCaptureCallback.AsStdFunction(),
@@ -317,9 +317,9 @@ TEST_F(AsynchronousImageCache, request_small_image_request_image_from_generator)
TEST_F(AsynchronousImageCache, request_small_image_calls_capture_callback_with_image_from_generator)
{
ON_CALL(mockGenerator, generateImage(Eq("/path/to/Component.qml"), _, _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto &&callback, auto, auto) {
callback(QImage{image1}, QImage{midSizeImage1}, QImage{smallImage1});
ON_CALL(mockGenerator, generateImage(Eq("/path/to/Component.qml"), _, _, _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto &&callback, auto, auto, auto) {
callback(QImage{image1}, QImage{midSizeImage1}, QImage{smallImage1}, {});
notification.notify();
});
@@ -333,9 +333,9 @@ TEST_F(AsynchronousImageCache, request_small_image_calls_capture_callback_with_i
TEST_F(AsynchronousImageCache, request_small_image_calls_abort_callback_from_generator)
{
ON_CALL(mockGenerator, generateImage(Eq("/path/to/Component.qml"), _, _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto &&, auto &&abortCallback, auto) {
abortCallback(QmlDesigner::ImageCache::AbortReason::Failed);
ON_CALL(mockGenerator, generateImage(Eq("/path/to/Component.qml"), _, _, _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto &&, auto &&abortCallback, auto, auto) {
abortCallback(QmlDesigner::ImageCache::AbortReason::Failed, {});
notification.notify();
});
@@ -349,9 +349,9 @@ TEST_F(AsynchronousImageCache, request_small_image_calls_abort_callback_from_gen
TEST_F(AsynchronousImageCache, clean_removes_entries)
{
EXPECT_CALL(mockGenerator, generateImage(_, _, _, _, _, _))
.WillRepeatedly([&](auto, auto, auto, auto &&captureCallback, auto &&, auto) {
captureCallback(QImage{}, QImage{}, QImage{});
EXPECT_CALL(mockGenerator, generateImage(_, _, _, _, _, _, _))
.WillRepeatedly([&](auto, auto, auto, auto &&captureCallback, auto &&, auto, auto) {
captureCallback(QImage{}, QImage{}, QImage{}, {});
waitInThread.wait();
});
cache.requestSmallImage("/path/to/Component1.qml",
@@ -369,8 +369,8 @@ TEST_F(AsynchronousImageCache, clean_removes_entries)
TEST_F(AsynchronousImageCache, clean_calls_abort)
{
ON_CALL(mockGenerator, generateImage(_, _, _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto, auto &&, auto) { waitInThread.wait(); });
ON_CALL(mockGenerator, generateImage(_, _, _, _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto, auto &&, auto, auto) { waitInThread.wait(); });
cache.requestSmallImage("/path/to/Component1.qml",
mockCaptureCallback.AsStdFunction(),
mockAbortCallback.AsStdFunction());
@@ -399,8 +399,9 @@ TEST_F(AsynchronousImageCache, after_clean_new_jobs_works)
{
cache.clean();
EXPECT_CALL(mockGenerator, generateImage(Eq("/path/to/Component.qml"), _, _, _, _, _))
.WillRepeatedly([&](auto, auto, auto, auto &&, auto &&, auto) { notification.notify(); });
EXPECT_CALL(mockGenerator, generateImage(Eq("/path/to/Component.qml"), _, _, _, _, _, _))
.WillRepeatedly(
[&](auto, auto, auto, auto &&, auto &&, auto, auto) { notification.notify(); });
cache.requestSmallImage("/path/to/Component.qml",
mockCaptureCallback.AsStdFunction(),
@@ -460,8 +461,8 @@ TEST_F(AsynchronousImageCache, request_image_with_extra_id_request_image_from_ge
EXPECT_CALL(mockGenerator,
generateImage(
Eq("/path/to/Component.qml"), Eq("extraId1"), Eq(Sqlite::TimeStamp{123}), _, _, _))
.WillRepeatedly([&](auto, auto, auto, auto &&, auto, auto) { notification.notify(); });
Eq("/path/to/Component.qml"), Eq("extraId1"), Eq(Sqlite::TimeStamp{123}), _, _, _, _))
.WillRepeatedly([&](auto, auto, auto, auto &&, auto, auto, auto) { notification.notify(); });
cache.requestImage("/path/to/Component.qml",
mockCaptureCallback.AsStdFunction(),
@@ -477,8 +478,8 @@ TEST_F(AsynchronousImageCache, request_mid_size_image_with_extra_id_request_imag
EXPECT_CALL(mockGenerator,
generateImage(
Eq("/path/to/Component.qml"), Eq("extraId1"), Eq(Sqlite::TimeStamp{123}), _, _, _))
.WillRepeatedly([&](auto, auto, auto, auto &&, auto, auto) { notification.notify(); });
Eq("/path/to/Component.qml"), Eq("extraId1"), Eq(Sqlite::TimeStamp{123}), _, _, _, _))
.WillRepeatedly([&](auto, auto, auto, auto &&, auto, auto, auto) { notification.notify(); });
cache.requestMidSizeImage("/path/to/Component.qml",
mockCaptureCallback.AsStdFunction(),
@@ -494,8 +495,8 @@ TEST_F(AsynchronousImageCache, request_small_image_with_extra_id_request_image_f
EXPECT_CALL(mockGenerator,
generateImage(
Eq("/path/to/Component.qml"), Eq("extraId1"), Eq(Sqlite::TimeStamp{123}), _, _, _))
.WillRepeatedly([&](auto, auto, auto, auto &&, auto, auto) { notification.notify(); });
Eq("/path/to/Component.qml"), Eq("extraId1"), Eq(Sqlite::TimeStamp{123}), _, _, _, _))
.WillRepeatedly([&](auto, auto, auto, auto &&, auto, auto, auto) { notification.notify(); });
cache.requestSmallImage("/path/to/Component.qml",
mockCaptureCallback.AsStdFunction(),
@@ -521,8 +522,9 @@ TEST_F(AsynchronousImageCache, request_image_with_auxiliary_data_request_image_f
AllOf(Field(&FontCollectorSizesAuxiliaryData::sizes,
ElementsAre(QSize{20, 11})),
Field(&FontCollectorSizesAuxiliaryData::colorName,
Eq(u"color"))))))
.WillRepeatedly([&](auto, auto, auto, auto &&, auto, auto) { notification.notify(); });
Eq(u"color")))),
_))
.WillRepeatedly([&](auto, auto, auto, auto &&, auto, auto, auto) { notification.notify(); });
cache.requestImage("/path/to/Component.qml",
mockCaptureCallback.AsStdFunction(),
@@ -549,8 +551,9 @@ TEST_F(AsynchronousImageCache, request_mid_size_image_with_auxiliary_data_reques
AllOf(Field(&FontCollectorSizesAuxiliaryData::sizes,
ElementsAre(QSize{20, 11})),
Field(&FontCollectorSizesAuxiliaryData::colorName,
Eq(u"color"))))))
.WillRepeatedly([&](auto, auto, auto, auto &&, auto, auto) { notification.notify(); });
Eq(u"color")))),
_))
.WillRepeatedly([&](auto, auto, auto, auto &&, auto, auto, auto) { notification.notify(); });
cache.requestMidSizeImage("/path/to/Component.qml",
mockCaptureCallback.AsStdFunction(),
@@ -577,8 +580,9 @@ TEST_F(AsynchronousImageCache, request_small_image_with_auxiliary_data_request_i
AllOf(Field(&FontCollectorSizesAuxiliaryData::sizes,
ElementsAre(QSize{20, 11})),
Field(&FontCollectorSizesAuxiliaryData::colorName,
Eq(u"color"))))))
.WillRepeatedly([&](auto, auto, auto, auto &&, auto, auto) { notification.notify(); });
Eq(u"color")))),
_))
.WillRepeatedly([&](auto, auto, auto, auto &&, auto, auto, auto) { notification.notify(); });
cache.requestSmallImage("/path/to/Component.qml",
mockCaptureCallback.AsStdFunction(),

27
tests/unit/tests/unittests/imagecache/asynchronousimagefactory-test.cpp
View File

@@ -43,8 +43,9 @@ TEST_F(AsynchronousImageFactory, request_image_request_image_from_collector)
IsEmpty(),
VariantWith<std::monostate>(std::monostate{}),
_,
_,
_))
.WillRepeatedly([&](auto, auto, auto, auto, auto) { notification.notify(); });
.WillRepeatedly([&](auto, auto, auto, auto, auto, auto) { notification.notify(); });
factory.generate("/path/to/Component.qml");
notification.wait();
@@ -57,8 +58,9 @@ TEST_F(AsynchronousImageFactory, request_image_with_extra_id_request_image_from_
Eq("foo"),
VariantWith<std::monostate>(std::monostate{}),
_,
_,
_))
.WillRepeatedly([&](auto, auto, auto, auto, auto) { notification.notify(); });
.WillRepeatedly([&](auto, auto, auto, auto, auto, auto) { notification.notify(); });
factory.generate("/path/to/Component.qml", "foo");
notification.wait();
@@ -77,8 +79,9 @@ TEST_F(AsynchronousImageFactory, request_image_with_auxiliary_data_request_image
Field(&FontCollectorSizesAuxiliaryData::colorName, Eq(u"color")),
Field(&FontCollectorSizesAuxiliaryData::text, Eq(u"some text")))),
_,
_,
_))
.WillRepeatedly([&](auto, auto, auto, auto, auto) { notification.notify(); });
.WillRepeatedly([&](auto, auto, auto, auto, auto, auto) { notification.notify(); });
factory.generate("/path/to/Component.qml",
"foo",
@@ -99,7 +102,7 @@ TEST_F(AsynchronousImageFactory, dont_request_image_request_image_from_collector
ON_CALL(timeStampProviderMock, timeStamp(Eq("/path/to/Component.qml")))
.WillByDefault(Return(Sqlite::TimeStamp{1}));
EXPECT_CALL(collectorMock, start(_, _, _, _, _)).Times(0);
EXPECT_CALL(collectorMock, start(_, _, _, _, _, _)).Times(0);
factory.generate("/path/to/Component.qml");
notification.wait();
@@ -113,7 +116,7 @@ TEST_F(AsynchronousImageFactory, request_image_request_image_from_collector_if_f
.WillByDefault(Return(Sqlite::TimeStamp{125}));
ON_CALL(timeStampProviderMock, pause()).WillByDefault(Return(Sqlite::TimeStamp{1}));
EXPECT_CALL(collectorMock, start(_, _, _, _, _)).WillOnce([&](auto, auto, auto, auto, auto) {
EXPECT_CALL(collectorMock, start(_, _, _, _, _, _)).WillOnce([&](auto, auto, auto, auto, auto, auto) {
notification.notify();
});
@@ -123,15 +126,15 @@ TEST_F(AsynchronousImageFactory, request_image_request_image_from_collector_if_f
TEST_F(AsynchronousImageFactory, clean_removes_entries)
{
EXPECT_CALL(collectorMock, start(Eq("/path/to/Component1.qml"), _, _, _, _))
.WillRepeatedly([&](auto, auto, auto, auto, auto) {
EXPECT_CALL(collectorMock, start(Eq("/path/to/Component1.qml"), _, _, _, _, _))
.WillRepeatedly([&](auto, auto, auto, auto, auto, auto) {
notification.notify();
waitInThread.wait();
});
factory.generate("/path/to/Component1.qml");
notification.wait();
EXPECT_CALL(collectorMock, start(Eq("/path/to/Component3.qml"), _, _, _, _)).Times(0);
EXPECT_CALL(collectorMock, start(Eq("/path/to/Component3.qml"), _, _, _, _, _)).Times(0);
factory.generate("/path/to/Component3.qml");
factory.clean();
@@ -147,8 +150,9 @@ TEST_F(AsynchronousImageFactory, after_clean_new_jobs_works)
IsEmpty(),
VariantWith<std::monostate>(std::monostate{}),
_,
_,
_))
.WillRepeatedly([&](auto, auto, auto, auto, auto) { notification.notify(); });
.WillRepeatedly([&](auto, auto, auto, auto, auto, auto) { notification.notify(); });
factory.generate("/path/to/Component.qml");
notification.wait();
@@ -166,9 +170,10 @@ TEST_F(AsynchronousImageFactory, capture_image_callback_stores_image)
Eq("id"),
VariantWith<std::monostate>(std::monostate{}),
_,
_,
_))
.WillByDefault([&](auto, auto, auto, auto capture, auto) {
capture(image1, midSizeImage1, smallImage1);
.WillByDefault([&](auto, auto, auto, auto capture, auto, auto) {
capture(image1, midSizeImage1, smallImage1, {});
});
EXPECT_CALL(storageMock,

44
tests/unit/tests/unittests/imagecache/imagecachedispatchcollector-test.cpp
View File

@@ -12,6 +12,7 @@
namespace {
using QmlDesigner::ImageCache::FontCollectorSizesAuxiliaryData;
using QmlDesigner::ImageCache::TraceToken;
MATCHER_P(IsIcon, icon, std::string(negation ? "isn't " : "is ") + PrintToString(icon))
{
@@ -47,8 +48,8 @@ protected:
protected:
std::vector<QSize> sizes{{20, 11}};
NiceMock<MockFunction<void(const QImage &, const QImage &, const QImage &)>> captureCallbackMock;
NiceMock<MockFunction<void(QmlDesigner::ImageCache::AbortReason)>> abortCallbackMock;
NiceMock<MockFunction<void(const QImage &, const QImage &, const QImage &, TraceToken)>> captureCallbackMock;
NiceMock<MockFunction<void(QmlDesigner::ImageCache::AbortReason, TraceToken)>> abortCallbackMock;
NiceMock<ImageCacheCollectorMock> collectorMock1;
NiceMock<ImageCacheCollectorMock> collectorMock2;
QImage image1{1, 1, QImage::Format_ARGB32};
@@ -83,8 +84,8 @@ TEST_F(ImageCacheDispatchCollector, call_qml_collector_start)
},
&collectorMock2))};
EXPECT_CALL(captureCallbackMock, Call(_, _, _));
EXPECT_CALL(abortCallbackMock, Call(_));
EXPECT_CALL(captureCallbackMock, Call(_, _, _, _));
EXPECT_CALL(abortCallbackMock, Call(_, _));
EXPECT_CALL(collectorMock2,
start(Eq("foo.qml"),
Eq("state"),
@@ -93,18 +94,20 @@ TEST_F(ImageCacheDispatchCollector, call_qml_collector_start)
ElementsAre(QSize{20, 11})),
Field(&FontCollectorSizesAuxiliaryData::colorName, Eq(u"color")))),
_,
_,
_))
.WillRepeatedly([&](auto, auto, auto, auto captureCallback, auto abortCallback) {
captureCallback({}, {}, {});
abortCallback(QmlDesigner::ImageCache::AbortReason::Abort);
.WillRepeatedly([&](auto, auto, auto, auto captureCallback, auto abortCallback, auto) {
captureCallback({}, {}, {}, {});
abortCallback(QmlDesigner::ImageCache::AbortReason::Abort, {});
});
EXPECT_CALL(collectorMock1, start(_, _, _, _, _)).Times(0);
EXPECT_CALL(collectorMock1, start(_, _, _, _, _, _)).Times(0);
collector.start("foo.qml",
"state",
FontCollectorSizesAuxiliaryData{sizes, "color", "text"},
captureCallbackMock.AsStdFunction(),
abortCallbackMock.AsStdFunction());
abortCallbackMock.AsStdFunction(),
{});
}
TEST_F(ImageCacheDispatchCollector, call_ui_file_collector_start)
@@ -119,8 +122,8 @@ TEST_F(ImageCacheDispatchCollector, call_ui_file_collector_start)
const QmlDesigner::ImageCache::AuxiliaryData &) { return true; },
&collectorMock2))};
EXPECT_CALL(captureCallbackMock, Call(_, _, _));
EXPECT_CALL(abortCallbackMock, Call(_));
EXPECT_CALL(captureCallbackMock, Call(_, _, _, _));
EXPECT_CALL(abortCallbackMock, Call(_, _));
EXPECT_CALL(collectorMock1,
start(Eq("foo.ui.qml"),
Eq("state"),
@@ -129,18 +132,20 @@ TEST_F(ImageCacheDispatchCollector, call_ui_file_collector_start)
ElementsAre(QSize{20, 11})),
Field(&FontCollectorSizesAuxiliaryData::colorName, Eq(u"color")))),
_,
_,
_))
.WillRepeatedly([&](auto, auto, auto, auto captureCallback, auto abortCallback) {
captureCallback({}, {}, {});
abortCallback(QmlDesigner::ImageCache::AbortReason::Abort);
.WillRepeatedly([&](auto, auto, auto, auto captureCallback, auto abortCallback, auto) {
captureCallback({}, {}, {}, {});
abortCallback(QmlDesigner::ImageCache::AbortReason::Abort, {});
});
EXPECT_CALL(collectorMock2, start(_, _, _, _, _)).Times(0);
EXPECT_CALL(collectorMock2, start(_, _, _, _, _, _)).Times(0);
collector.start("foo.ui.qml",
"state",
FontCollectorSizesAuxiliaryData{sizes, "color", "text"},
captureCallbackMock.AsStdFunction(),
abortCallbackMock.AsStdFunction());
abortCallbackMock.AsStdFunction(),
{});
}
TEST_F(ImageCacheDispatchCollector, dont_call_collector_start_for_unknown_file)
@@ -155,14 +160,15 @@ TEST_F(ImageCacheDispatchCollector, dont_call_collector_start_for_unknown_file)
const QmlDesigner::ImageCache::AuxiliaryData &) { return false; },
&collectorMock2))};
EXPECT_CALL(collectorMock2, start(_, _, _, _, _)).Times(0);
EXPECT_CALL(collectorMock1, start(_, _, _, _, _)).Times(0);
EXPECT_CALL(collectorMock2, start(_, _, _, _, _, _)).Times(0);
EXPECT_CALL(collectorMock1, start(_, _, _, _, _, _)).Times(0);
collector.start("foo.mesh",
"state",
FontCollectorSizesAuxiliaryData{sizes, "color", "text"},
captureCallbackMock.AsStdFunction(),
abortCallbackMock.AsStdFunction());
abortCallbackMock.AsStdFunction(),
{});
}
TEST_F(ImageCacheDispatchCollector, call_first_collector_create_icon)

315
tests/unit/tests/unittests/imagecache/imagecachegenerator-test.cpp
View File

@@ -13,6 +13,8 @@
namespace {
using QmlDesigner::ImageCache::TraceToken;
class ImageCacheGenerator : public testing::Test
{
protected:
@@ -34,8 +36,8 @@ protected:
QImage image1{10, 10, QImage::Format_ARGB32};
QImage midSizeImage1{5, 5, QImage::Format_ARGB32};
QImage smallImage1{1, 1, QImage::Format_ARGB32};
NiceMock<MockFunction<void(const QImage &, const QImage &, const QImage &)>> imageCallbackMock;
NiceMock<MockFunction<void(QmlDesigner::ImageCache::AbortReason)>> abortCallbackMock;
NiceMock<MockFunction<void(const QImage &, const QImage &, const QImage &, TraceToken)>> imageCallbackMock;
NiceMock<MockFunction<void(QmlDesigner::ImageCache::AbortReason, TraceToken)>> abortCallbackMock;
NiceMock<ImageCacheCollectorMock> collectorMock;
NiceMock<MockImageCacheStorage> storageMock;
QmlDesigner::ImageCacheGenerator generator{collectorMock, storageMock};
@@ -43,13 +45,13 @@ protected:
TEST_F(ImageCacheGenerator, calls_collector_with_capture_callback)
{
EXPECT_CALL(collectorMock, start(Eq("name"), _, _, _, _))
.WillRepeatedly([&](auto, auto, auto, auto captureCallback, auto) {
captureCallback(QImage{image1}, QImage{midSizeImage1}, QImage{smallImage1});
EXPECT_CALL(collectorMock, start(Eq("name"), _, _, _, _, _))
.WillRepeatedly([&](auto, auto, auto, auto captureCallback, auto, auto) {
captureCallback(QImage{image1}, QImage{midSizeImage1}, QImage{smallImage1}, {});
});
EXPECT_CALL(imageCallbackMock, Call(_, _, _))
EXPECT_CALL(imageCallbackMock, Call(_, _, _, _))
.WillRepeatedly(
[&](const QImage &, const QImage &, const QImage &) { notification.notify(); });
[&](const QImage &, const QImage &, const QImage &, auto) { notification.notify(); });
generator.generateImage("name", {}, {}, imageCallbackMock.AsStdFunction(), {}, {});
notification.wait();
@@ -57,8 +59,8 @@ TEST_F(ImageCacheGenerator, calls_collector_with_capture_callback)
TEST_F(ImageCacheGenerator, calls_collector_only_if_not_processing)
{
EXPECT_CALL(collectorMock, start(AnyOf(Eq("name"), Eq("name2")), _, _, _, _))
.WillRepeatedly([&](auto, auto, auto, auto, auto) { notification.notify(); });
EXPECT_CALL(collectorMock, start(AnyOf(Eq("name"), Eq("name2")), _, _, _, _, _))
.WillRepeatedly([&](auto, auto, auto, auto, auto, auto) { notification.notify(); });
generator.generateImage("name", {}, {}, imageCallbackMock.AsStdFunction(), {}, {});
generator.generateImage("name2", {}, {}, imageCallbackMock.AsStdFunction(), {}, {});
@@ -67,16 +69,17 @@ TEST_F(ImageCacheGenerator, calls_collector_only_if_not_processing)
TEST_F(ImageCacheGenerator, process_task_after_first_finished)
{
ON_CALL(imageCallbackMock, Call(_, _, _))
.WillByDefault([&](const QImage &, const QImage &, const QImage &) { notification.notify(); });
ON_CALL(imageCallbackMock, Call(_, _, _, _))
.WillByDefault(
[&](const QImage &, const QImage &, const QImage &, auto) { notification.notify(); });
EXPECT_CALL(collectorMock, start(Eq("name"), _, _, _, _))
.WillOnce([&](auto, auto, auto, auto captureCallback, auto) {
captureCallback(QImage{image1}, QImage{midSizeImage1}, QImage{smallImage1});
EXPECT_CALL(collectorMock, start(Eq("name"), _, _, _, _, _))
.WillOnce([&](auto, auto, auto, auto captureCallback, auto, auto) {
captureCallback(QImage{image1}, QImage{midSizeImage1}, QImage{smallImage1}, {});
});
EXPECT_CALL(collectorMock, start(Eq("name2"), _, _, _, _))
.WillOnce([&](auto, auto, auto, auto captureCallback, auto) {
captureCallback(QImage{image1}, QImage{midSizeImage1}, QImage{smallImage1});
EXPECT_CALL(collectorMock, start(Eq("name2"), _, _, _, _, _))
.WillOnce([&](auto, auto, auto, auto captureCallback, auto, auto) {
captureCallback(QImage{image1}, QImage{midSizeImage1}, QImage{smallImage1}, {});
});
generator.generateImage("name", {}, {}, imageCallbackMock.AsStdFunction(), {}, {});
@@ -86,13 +89,13 @@ TEST_F(ImageCacheGenerator, process_task_after_first_finished)
TEST_F(ImageCacheGenerator, dont_crash_at_destructing_generator)
{
ON_CALL(collectorMock, start(Eq("name"), _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto captureCallback, auto) {
captureCallback(QImage{image1}, QImage{midSizeImage1}, QImage{smallImage1});
ON_CALL(collectorMock, start(Eq("name"), _, _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto captureCallback, auto, auto) {
captureCallback(QImage{image1}, QImage{midSizeImage1}, QImage{smallImage1}, {});
});
generator.generateImage(
"name", {}, {}, imageCallbackMock.AsStdFunction(), abortCallbackMock.AsStdFunction(), {});
"name", {}, {}, imageCallbackMock.AsStdFunction(), abortCallbackMock.AsStdFunction(), {}, {});
generator.generateImage(
"name2", {}, {}, imageCallbackMock.AsStdFunction(), abortCallbackMock.AsStdFunction(), {});
generator.generateImage(
@@ -103,9 +106,9 @@ TEST_F(ImageCacheGenerator, dont_crash_at_destructing_generator)
TEST_F(ImageCacheGenerator, store_image)
{
ON_CALL(collectorMock, start(Eq("name"), _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto captureCallback, auto) {
captureCallback(QImage{image1}, QImage{midSizeImage1}, QImage{smallImage1});
ON_CALL(collectorMock, start(Eq("name"), _, _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto captureCallback, auto, auto) {
captureCallback(QImage{image1}, QImage{midSizeImage1}, QImage{smallImage1}, {});
});
EXPECT_CALL(storageMock,
@@ -122,9 +125,9 @@ TEST_F(ImageCacheGenerator, store_image)
TEST_F(ImageCacheGenerator, store_image_with_extra_id)
{
ON_CALL(collectorMock, start(Eq("name"), _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto captureCallback, auto) {
captureCallback(QImage{image1}, QImage{midSizeImage1}, QImage{smallImage1});
ON_CALL(collectorMock, start(Eq("name"), _, _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto captureCallback, auto, auto) {
captureCallback(QImage{image1}, QImage{midSizeImage1}, QImage{smallImage1}, {});
});
EXPECT_CALL(storageMock,
@@ -141,9 +144,9 @@ TEST_F(ImageCacheGenerator, store_image_with_extra_id)
TEST_F(ImageCacheGenerator, store_null_image)
{
ON_CALL(collectorMock, start(Eq("name"), _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto captureCallback, auto) {
captureCallback(QImage{}, QImage{}, QImage{});
ON_CALL(collectorMock, start(Eq("name"), _, _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto captureCallback, auto, auto) {
captureCallback(QImage{}, QImage{}, QImage{}, {});
});
EXPECT_CALL(
@@ -158,9 +161,9 @@ TEST_F(ImageCacheGenerator, store_null_image)
TEST_F(ImageCacheGenerator, store_null_image_with_extra_id)
{
ON_CALL(collectorMock, start(Eq("name"), _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto captureCallback, auto) {
captureCallback(QImage{}, QImage{}, QImage{});
ON_CALL(collectorMock, start(Eq("name"), _, _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto captureCallback, auto, auto) {
captureCallback(QImage{}, QImage{}, QImage{}, {});
});
EXPECT_CALL(storageMock,
@@ -182,19 +185,20 @@ TEST_F(ImageCacheGenerator, store_null_image_with_extra_id)
TEST_F(ImageCacheGenerator, abort_callback)
{
ON_CALL(collectorMock, start(Eq("name"), _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto captureCallback, auto) {
captureCallback(QImage{image1}, QImage{midSizeImage1}, QImage{smallImage1});
ON_CALL(collectorMock, start(Eq("name"), _, _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto captureCallback, auto, auto) {
captureCallback(QImage{image1}, QImage{midSizeImage1}, QImage{smallImage1}, {});
});
ON_CALL(collectorMock, start(Eq("name2"), _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto, auto abortCallback) {
abortCallback(QmlDesigner::ImageCache::AbortReason::Failed);
ON_CALL(collectorMock, start(Eq("name2"), _, _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto, auto abortCallback, auto) {
abortCallback(QmlDesigner::ImageCache::AbortReason::Failed, {});
});
EXPECT_CALL(imageCallbackMock, Call(_, _, _))
.WillOnce([&](const QImage &, const QImage &, const QImage &) { notification.notify(); });
EXPECT_CALL(abortCallbackMock, Call(Eq(QmlDesigner::ImageCache::AbortReason::Failed)))
.WillOnce([&](auto) { notification.notify(); });
EXPECT_CALL(imageCallbackMock, Call(_, _, _, _))
.WillOnce(
[&](const QImage &, const QImage &, const QImage &, auto) { notification.notify(); });
EXPECT_CALL(abortCallbackMock, Call(Eq(QmlDesigner::ImageCache::AbortReason::Failed), _))
.WillOnce([&](auto, auto) { notification.notify(); });
generator.generateImage(
"name", {}, {}, imageCallbackMock.AsStdFunction(), abortCallbackMock.AsStdFunction(), {});
@@ -205,12 +209,12 @@ TEST_F(ImageCacheGenerator, abort_callback)
TEST_F(ImageCacheGenerator, store_null_image_for_abort_callback_abort)
{
ON_CALL(collectorMock, start(Eq("name"), _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto, auto abortCallback) {
abortCallback(QmlDesigner::ImageCache::AbortReason::Abort);
ON_CALL(collectorMock, start(Eq("name"), _, _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto, auto abortCallback, auto) {
abortCallback(QmlDesigner::ImageCache::AbortReason::Abort, {});
});
ON_CALL(collectorMock, start(Eq("dummyNotify"), _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto, auto) { notification.notify(); });
ON_CALL(collectorMock, start(Eq("dummyNotify"), _, _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto, auto, auto) { notification.notify(); });
EXPECT_CALL(storageMock, storeImage(Eq("name"), _, _, _, _)).Times(0);
@@ -222,9 +226,9 @@ TEST_F(ImageCacheGenerator, store_null_image_for_abort_callback_abort)
TEST_F(ImageCacheGenerator, dont_store_null_image_for_abort_callback_failed)
{
ON_CALL(collectorMock, start(_, _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto, auto abortCallback) {
abortCallback(QmlDesigner::ImageCache::AbortReason::Failed);
ON_CALL(collectorMock, start(_, _, _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto, auto abortCallback, auto) {
abortCallback(QmlDesigner::ImageCache::AbortReason::Failed, {});
});
EXPECT_CALL(
@@ -239,13 +243,13 @@ TEST_F(ImageCacheGenerator, dont_store_null_image_for_abort_callback_failed)
TEST_F(ImageCacheGenerator, abort_for_null_image)
{
ON_CALL(collectorMock, start(Eq("name"), _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto captureCallback, auto) {
captureCallback(QImage{}, QImage{}, QImage{});
ON_CALL(collectorMock, start(Eq("name"), _, _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto captureCallback, auto, auto) {
captureCallback(QImage{}, QImage{}, QImage{}, {});
});
EXPECT_CALL(abortCallbackMock, Call(Eq(QmlDesigner::ImageCache::AbortReason::Failed)))
.WillOnce([&](auto) { notification.notify(); });
EXPECT_CALL(abortCallbackMock, Call(Eq(QmlDesigner::ImageCache::AbortReason::Failed), _))
.WillOnce([&](auto, auto) { notification.notify(); });
generator.generateImage(
"name", {}, {}, imageCallbackMock.AsStdFunction(), abortCallbackMock.AsStdFunction(), {});
@@ -254,13 +258,13 @@ TEST_F(ImageCacheGenerator, abort_for_null_image)
TEST_F(ImageCacheGenerator, call_image_callback_if_small_image_is_not_null)
{
ON_CALL(collectorMock, start(Eq("name"), _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto captureCallback, auto) {
captureCallback({}, {}, smallImage1);
ON_CALL(collectorMock, start(Eq("name"), _, _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto captureCallback, auto, auto) {
captureCallback({}, {}, smallImage1, {});
});
EXPECT_CALL(imageCallbackMock, Call(Eq(QImage()), Eq(QImage()), Eq(smallImage1)))
.WillOnce([&](auto, auto, auto) { notification.notify(); });
EXPECT_CALL(imageCallbackMock, Call(Eq(QImage()), Eq(QImage()), Eq(smallImage1), _))
.WillOnce([&](auto, auto, auto, auto) { notification.notify(); });
generator.generateImage(
"name", {}, {}, imageCallbackMock.AsStdFunction(), abortCallbackMock.AsStdFunction(), {});
@@ -269,9 +273,9 @@ TEST_F(ImageCacheGenerator, call_image_callback_if_small_image_is_not_null)
TEST_F(ImageCacheGenerator, store_image_if_small_image_is_not_null)
{
ON_CALL(collectorMock, start(Eq("name"), _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto captureCallback, auto) {
captureCallback({}, {}, smallImage1);
ON_CALL(collectorMock, start(Eq("name"), _, _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto captureCallback, auto, auto) {
captureCallback({}, {}, smallImage1, {});
});
EXPECT_CALL(storageMock, storeImage(_, _, Eq(QImage()), Eq(QImage()), Eq(smallImage1)))
@@ -284,13 +288,13 @@ TEST_F(ImageCacheGenerator, store_image_if_small_image_is_not_null)
TEST_F(ImageCacheGenerator, call_image_callback_if_mid_size_image_is_not_null)
{
ON_CALL(collectorMock, start(Eq("name"), _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto captureCallback, auto) {
captureCallback({}, midSizeImage1, {});
ON_CALL(collectorMock, start(Eq("name"), _, _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto captureCallback, auto, auto) {
captureCallback({}, midSizeImage1, {}, {});
});
EXPECT_CALL(imageCallbackMock, Call(Eq(QImage()), Eq(midSizeImage1), Eq(QImage{})))
.WillOnce([&](auto, auto, auto) { notification.notify(); });
EXPECT_CALL(imageCallbackMock, Call(Eq(QImage()), Eq(midSizeImage1), Eq(QImage{}), _))
.WillOnce([&](auto, auto, auto, auto) { notification.notify(); });
generator.generateImage(
"name", {}, {}, imageCallbackMock.AsStdFunction(), abortCallbackMock.AsStdFunction(), {});
@@ -299,9 +303,9 @@ TEST_F(ImageCacheGenerator, call_image_callback_if_mid_size_image_is_not_null)
TEST_F(ImageCacheGenerator, store_image_if_mid_size_image_is_not_null)
{
ON_CALL(collectorMock, start(Eq("name"), _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto captureCallback, auto) {
captureCallback({}, midSizeImage1, {});
ON_CALL(collectorMock, start(Eq("name"), _, _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto captureCallback, auto, auto) {
captureCallback({}, midSizeImage1, {}, {});
});
EXPECT_CALL(storageMock, storeImage(_, _, Eq(QImage()), Eq(midSizeImage1), Eq(QImage())))
@@ -314,12 +318,13 @@ TEST_F(ImageCacheGenerator, store_image_if_mid_size_image_is_not_null)
TEST_F(ImageCacheGenerator, call_image_callback_if_image_is_not_null)
{
ON_CALL(collectorMock, start(Eq("name"), _, _, _, _))
.WillByDefault(
[&](auto, auto, auto, auto captureCallback, auto) { captureCallback(image1, {}, {}); });
ON_CALL(collectorMock, start(Eq("name"), _, _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto captureCallback, auto, auto) {
captureCallback(image1, {}, {}, {});
});
EXPECT_CALL(imageCallbackMock, Call(Eq(image1), Eq(QImage{}), Eq(QImage{})))
.WillOnce([&](auto, auto, auto) { notification.notify(); });
EXPECT_CALL(imageCallbackMock, Call(Eq(image1), Eq(QImage{}), Eq(QImage{}), _))
.WillOnce([&](auto, auto, auto, auto) { notification.notify(); });
generator.generateImage(
"name", {}, {}, imageCallbackMock.AsStdFunction(), abortCallbackMock.AsStdFunction(), {});
@@ -328,9 +333,10 @@ TEST_F(ImageCacheGenerator, call_image_callback_if_image_is_not_null)
TEST_F(ImageCacheGenerator, store_image_if_image_is_not_null)
{
ON_CALL(collectorMock, start(Eq("name"), _, _, _, _))
.WillByDefault(
[&](auto, auto, auto, auto captureCallback, auto) { captureCallback(image1, {}, {}); });
ON_CALL(collectorMock, start(Eq("name"), _, _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto captureCallback, auto, auto) {
captureCallback(image1, {}, {}, {});
});
EXPECT_CALL(storageMock, storeImage(_, _, Eq(image1), Eq(QImage{}), Eq(QImage{})))
.WillOnce([&](auto, auto, auto, auto, auto) { notification.notify(); });
@@ -342,9 +348,10 @@ TEST_F(ImageCacheGenerator, store_image_if_image_is_not_null)
TEST_F(ImageCacheGenerator, call_wal_checkpoint_full_if_queue_is_empty)
{
ON_CALL(collectorMock, start(Eq("name"), _, _, _, _))
.WillByDefault(
[&](auto, auto, auto, auto captureCallback, auto) { captureCallback({}, {}, {}); });
ON_CALL(collectorMock, start(Eq("name"), _, _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto captureCallback, auto, auto) {
captureCallback({}, {}, {}, {});
});
EXPECT_CALL(storageMock, walCheckpointFull()).WillRepeatedly([&]() { notification.notify(); });
@@ -357,17 +364,16 @@ TEST_F(ImageCacheGenerator, call_wal_checkpoint_full_if_queue_is_empty)
TEST_F(ImageCacheGenerator, clean_is_calling_abort_callback)
{
ON_CALL(collectorMock, start(_, _, _, _, _)).WillByDefault([&](auto, auto, auto, auto, auto) {
notification.wait();
});
ON_CALL(collectorMock, start(_, _, _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto, auto, auto) { notification.wait(); });
generator.generateImage(
"name", {}, {11}, imageCallbackMock.AsStdFunction(), abortCallbackMock.AsStdFunction(), {});
generator.generateImage(
"name2", {}, {11}, imageCallbackMock.AsStdFunction(), abortCallbackMock.AsStdFunction(), {});
EXPECT_CALL(abortCallbackMock, Call(Eq(QmlDesigner::ImageCache::AbortReason::Abort)))
EXPECT_CALL(abortCallbackMock, Call(Eq(QmlDesigner::ImageCache::AbortReason::Abort), _))
.Times(AtLeast(1))
.WillRepeatedly([&](auto) { waitInThread.notify(); });
.WillRepeatedly([&](auto, auto) { waitInThread.notify(); });
generator.clean();
notification.notify();
@@ -376,14 +382,14 @@ TEST_F(ImageCacheGenerator, clean_is_calling_abort_callback)
TEST_F(ImageCacheGenerator, wait_for_finished)
{
ON_CALL(collectorMock, start(Eq("name"), _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto captureCallback, auto) {
ON_CALL(collectorMock, start(Eq("name"), _, _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto captureCallback, auto, auto) {
waitInThread.wait();
captureCallback(QImage{image1}, QImage{midSizeImage1}, QImage{smallImage1});
captureCallback(QImage{image1}, QImage{midSizeImage1}, QImage{smallImage1}, {});
});
ON_CALL(collectorMock, start(Eq("name2"), _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto captureCallback, auto) {
captureCallback(QImage{image1}, QImage{midSizeImage1}, QImage{smallImage1});
ON_CALL(collectorMock, start(Eq("name2"), _, _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto captureCallback, auto, auto) {
captureCallback(QImage{image1}, QImage{midSizeImage1}, QImage{smallImage1}, {});
});
generator.generateImage(
@@ -391,7 +397,7 @@ TEST_F(ImageCacheGenerator, wait_for_finished)
generator.generateImage(
"name2", {}, {11}, imageCallbackMock.AsStdFunction(), abortCallbackMock.AsStdFunction(), {});
EXPECT_CALL(imageCallbackMock, Call(_, _, _)).Times(AtMost(2));
EXPECT_CALL(imageCallbackMock, Call(_, _, _, _)).Times(AtMost(2));
waitInThread.notify();
generator.waitForFinished();
@@ -399,8 +405,8 @@ TEST_F(ImageCacheGenerator, wait_for_finished)
TEST_F(ImageCacheGenerator, calls_collector_with_extra_id)
{
EXPECT_CALL(collectorMock, start(Eq("name"), Eq("extraId1"), _, _, _))
.WillRepeatedly([&](auto, auto, auto, auto, auto) { notification.notify(); });
EXPECT_CALL(collectorMock, start(Eq("name"), Eq("extraId1"), _, _, _, _))
.WillRepeatedly([&](auto, auto, auto, auto, auto, auto) { notification.notify(); });
generator.generateImage("name", "extraId1", {}, imageCallbackMock.AsStdFunction(), {}, {});
notification.wait();
@@ -419,8 +425,9 @@ TEST_F(ImageCacheGenerator, calls_collector_with_auxiliary_data)
ElementsAre(QSize{20, 11})),
Field(&FontCollectorSizesAuxiliaryData::colorName, Eq(u"color")))),
_,
_,
_))
.WillRepeatedly([&](auto, auto, auto, auto, auto) { notification.notify(); });
.WillRepeatedly([&](auto, auto, auto, auto, auto, auto) { notification.notify(); });
generator.generateImage("name",
{},
@@ -433,12 +440,12 @@ TEST_F(ImageCacheGenerator, calls_collector_with_auxiliary_data)
TEST_F(ImageCacheGenerator, merge_tasks)
{
EXPECT_CALL(collectorMock, start(Eq("waitDummy"), _, _, _, _))
.WillRepeatedly([&](auto, auto, auto, auto, auto) { waitInThread.wait(); });
EXPECT_CALL(collectorMock, start(Eq("notificationDummy"), _, _, _, _))
.WillRepeatedly([&](auto, auto, auto, auto, auto) { notification.notify(); });
EXPECT_CALL(collectorMock, start(Eq("waitDummy"), _, _, _, _, _))
.WillRepeatedly([&](auto, auto, auto, auto, auto, auto) { waitInThread.wait(); });
EXPECT_CALL(collectorMock, start(Eq("notificationDummy"), _, _, _, _, _))
.WillRepeatedly([&](auto, auto, auto, auto, auto, auto) { notification.notify(); });
EXPECT_CALL(collectorMock, start(Eq("name"), _, _, _, _));
EXPECT_CALL(collectorMock, start(Eq("name"), _, _, _, _, _));
generator.generateImage("waitDummy", {}, {}, {}, {}, {});
generator.generateImage("name", {}, {}, {}, {}, {});
@@ -450,13 +457,13 @@ TEST_F(ImageCacheGenerator, merge_tasks)
TEST_F(ImageCacheGenerator, dont_merge_tasks_with_different_id)
{
EXPECT_CALL(collectorMock, start(Eq("waitDummy"), _, _, _, _))
.WillRepeatedly([&](auto, auto, auto, auto, auto) { waitInThread.wait(); });
EXPECT_CALL(collectorMock, start(Eq("waitDummy"), _, _, _, _, _))
.WillRepeatedly([&](auto, auto, auto, auto, auto, auto) { waitInThread.wait(); });
EXPECT_CALL(collectorMock, start(Eq("name"), _, _, _, _))
.WillRepeatedly([&](auto, auto, auto, auto, auto) { notification.notify(); });
EXPECT_CALL(collectorMock, start(Eq("name2"), _, _, _, _))
.WillRepeatedly([&](auto, auto, auto, auto, auto) { notification.notify(); });
EXPECT_CALL(collectorMock, start(Eq("name"), _, _, _, _, _))
.WillRepeatedly([&](auto, auto, auto, auto, auto, auto) { notification.notify(); });
EXPECT_CALL(collectorMock, start(Eq("name2"), _, _, _, _, _))
.WillRepeatedly([&](auto, auto, auto, auto, auto, auto) { notification.notify(); });
generator.generateImage("waitDummy", {}, {}, {}, {}, {});
generator.generateImage("name", {}, {}, {}, {}, {});
@@ -467,12 +474,12 @@ TEST_F(ImageCacheGenerator, dont_merge_tasks_with_different_id)
TEST_F(ImageCacheGenerator, merge_tasks_with_same_extra_id)
{
EXPECT_CALL(collectorMock, start(Eq("waitDummy"), _, _, _, _))
.WillRepeatedly([&](auto, auto, auto, auto, auto) { waitInThread.wait(); });
EXPECT_CALL(collectorMock, start(Eq("notificationDummy"), _, _, _, _))
.WillRepeatedly([&](auto, auto, auto, auto, auto) { notification.notify(); });
EXPECT_CALL(collectorMock, start(Eq("waitDummy"), _, _, _, _, _))
.WillRepeatedly([&](auto, auto, auto, auto, auto, auto) { waitInThread.wait(); });
EXPECT_CALL(collectorMock, start(Eq("notificationDummy"), _, _, _, _, _))
.WillRepeatedly([&](auto, auto, auto, auto, auto, auto) { notification.notify(); });
EXPECT_CALL(collectorMock, start(Eq("name"), _, _, _, _));
EXPECT_CALL(collectorMock, start(Eq("name"), _, _, _, _, _));
generator.generateImage("waitDummy", {}, {}, {}, {}, {});
generator.generateImage("name", "id1", {}, {}, {}, {});
@@ -484,12 +491,12 @@ TEST_F(ImageCacheGenerator, merge_tasks_with_same_extra_id)
TEST_F(ImageCacheGenerator, dont_merge_tasks_with_different_extra_id)
{
EXPECT_CALL(collectorMock, start(Eq("waitDummy"), _, _, _, _))
.WillRepeatedly([&](auto, auto, auto, auto, auto) { waitInThread.wait(); });
EXPECT_CALL(collectorMock, start(Eq("waitDummy"), _, _, _, _, _))
.WillRepeatedly([&](auto, auto, auto, auto, auto, auto) { waitInThread.wait(); });
EXPECT_CALL(collectorMock, start(Eq("name"), _, _, _, _))
EXPECT_CALL(collectorMock, start(Eq("name"), _, _, _, _, _))
.Times(2)
.WillRepeatedly([&](auto, auto, auto, auto, auto) { notification.notify(); });
.WillRepeatedly([&](auto, auto, auto, auto, auto, auto) { notification.notify(); });
generator.generateImage("waitDummy", {}, {}, {}, {}, {});
generator.generateImage("name", "id1", {}, {}, {}, {});
@@ -500,13 +507,13 @@ TEST_F(ImageCacheGenerator, dont_merge_tasks_with_different_extra_id)
TEST_F(ImageCacheGenerator, use_last_time_stamp_if_tasks_are_merged)
{
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(QmlDesigner::ImageCache::AbortReason::Failed);
ON_CALL(collectorMock, start(Eq("waitDummy"), _, _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto, auto, auto) { waitInThread.wait(); });
ON_CALL(collectorMock, start(Eq("notificationDummy"), _, _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto, auto, auto) { notification.notify(); });
ON_CALL(collectorMock, start(Eq("name"), _, _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto, auto abortCallback, auto) {
abortCallback(QmlDesigner::ImageCache::AbortReason::Failed, {});
});
EXPECT_CALL(storageMock, storeImage(Eq("name"), Eq(Sqlite::TimeStamp{4}), _, _, _));
@@ -521,18 +528,18 @@ TEST_F(ImageCacheGenerator, use_last_time_stamp_if_tasks_are_merged)
TEST_F(ImageCacheGenerator, merge_capture_callback_if_tasks_are_merged)
{
NiceMock<MockFunction<void(const QImage &, const QImage &, const QImage &)>> newerImageCallbackMock;
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 imageCallback, auto) {
imageCallback(QImage{image1}, QImage{midSizeImage1}, QImage{smallImage1});
NiceMock<MockFunction<void(const QImage &, const QImage &, const QImage &, TraceToken)>> newerImageCallbackMock;
ON_CALL(collectorMock, start(Eq("waitDummy"), _, _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto, auto, auto) { waitInThread.wait(); });
ON_CALL(collectorMock, start(Eq("notificationDummy"), _, _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto, auto, auto) { notification.notify(); });
ON_CALL(collectorMock, start(Eq("name"), _, _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto imageCallback, auto, auto) {
imageCallback(QImage{image1}, QImage{midSizeImage1}, QImage{smallImage1}, {});
});
EXPECT_CALL(imageCallbackMock, Call(_, _, _));
EXPECT_CALL(newerImageCallbackMock, Call(_, _, _));
EXPECT_CALL(imageCallbackMock, Call(_, _, _, _));
EXPECT_CALL(newerImageCallbackMock, Call(_, _, _, _));
generator.generateImage("waitDummy", {}, {}, {}, {}, {});
generator.generateImage("name", {}, {}, imageCallbackMock.AsStdFunction(), {}, {});
@@ -544,18 +551,18 @@ TEST_F(ImageCacheGenerator, merge_capture_callback_if_tasks_are_merged)
TEST_F(ImageCacheGenerator, merge_abort_callback_if_tasks_are_merged)
{
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(QmlDesigner::ImageCache::AbortReason::Failed);
NiceMock<MockFunction<void(QmlDesigner::ImageCache::AbortReason, TraceToken)>> newerAbortCallbackMock;
ON_CALL(collectorMock, start(Eq("waitDummy"), _, _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto, auto, auto) { waitInThread.wait(); });
ON_CALL(collectorMock, start(Eq("notificationDummy"), _, _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto, auto, auto) { notification.notify(); });
ON_CALL(collectorMock, start(Eq("name"), _, _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto, auto abortCallback, auto) {
abortCallback(QmlDesigner::ImageCache::AbortReason::Failed, {});
});
EXPECT_CALL(abortCallbackMock, Call(Eq(QmlDesigner::ImageCache::AbortReason::Failed)));
EXPECT_CALL(newerAbortCallbackMock, Call(Eq(QmlDesigner::ImageCache::AbortReason::Failed)));
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(), {});
@@ -567,9 +574,9 @@ TEST_F(ImageCacheGenerator, merge_abort_callback_if_tasks_are_merged)
TEST_F(ImageCacheGenerator, dont_call_null_image_callback)
{
EXPECT_CALL(collectorMock, start(_, _, _, _, _))
.WillOnce([&](auto, auto, auto, auto captureCallback, auto) {
captureCallback(image1, midSizeImage1, smallImage1);
EXPECT_CALL(collectorMock, start(_, _, _, _, _, _))
.WillOnce([&](auto, auto, auto, auto captureCallback, auto, auto) {
captureCallback(image1, midSizeImage1, smallImage1, {});
notification.notify();
});
@@ -579,9 +586,9 @@ TEST_F(ImageCacheGenerator, dont_call_null_image_callback)
TEST_F(ImageCacheGenerator, dont_call_null_abort_callback_for_null_image)
{
EXPECT_CALL(collectorMock, start(_, _, _, _, _))
.WillOnce([&](auto, auto, auto, auto captureCallback, auto) {
captureCallback(QImage{}, QImage{}, QImage{});
EXPECT_CALL(collectorMock, start(_, _, _, _, _, _))
.WillOnce([&](auto, auto, auto, auto captureCallback, auto, auto) {
captureCallback(QImage{}, QImage{}, QImage{}, {});
notification.notify();
});
@@ -591,9 +598,9 @@ TEST_F(ImageCacheGenerator, dont_call_null_abort_callback_for_null_image)
TEST_F(ImageCacheGenerator, dont_call_null_abort_callback)
{
EXPECT_CALL(collectorMock, start(_, _, _, _, _))
.WillOnce([&](auto, auto, auto, auto, auto abortCallback) {
abortCallback(QmlDesigner::ImageCache::AbortReason::Failed);
EXPECT_CALL(collectorMock, start(_, _, _, _, _, _))
.WillOnce([&](auto, auto, auto, auto, auto abortCallback, auto) {
abortCallback(QmlDesigner::ImageCache::AbortReason::Failed, {});
notification.notify();
});