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

QmlDesigner: Add states to ImageCache

Browse Source 
Task-number: QDS-2998
Change-Id: I8e65881181ae1010ef1f8bab92fa71d92c961bcd
Reviewed-by: Thomas Hartmann <thomas.hartmann@qt.io>
This commit is contained in:
Marco Bubke
2020-11-09 16:35:00 +01:00
parent 2ee63af4cd
commit 2a2dfbec73
21 changed files with 331 additions and 292 deletions
Download Patch File Download Diff File Expand all files Collapse all files

138
share/qtcreator/qml/qmlpuppet/commands/createscenecommand.cpp
View File

@@ -29,136 +29,20 @@
namespace QmlDesigner {
CreateSceneCommand::CreateSceneCommand() = default;
CreateSceneCommand::CreateSceneCommand(const QVector<InstanceContainer> &instanceContainer,
const QVector<ReparentContainer> &reparentContainer,
const QVector<IdContainer> &idVector,
const QVector<PropertyValueContainer> &valueChangeVector,
const QVector<PropertyBindingContainer> &bindingChangeVector,
const QVector<PropertyValueContainer> &auxiliaryChangeVector,
const QVector<AddImportContainer> &importVector,
const QVector<MockupTypeContainer> &mockupTypeVector,
const QUrl &fileUrl,
const QHash<QString, QVariantMap> &edit3dToolStates,
const QString &language)
: m_instanceVector(instanceContainer),
m_reparentInstanceVector(reparentContainer),
m_idVector(idVector),
m_valueChangeVector(valueChangeVector),
m_bindingChangeVector(bindingChangeVector),
m_auxiliaryChangeVector(auxiliaryChangeVector),
m_importVector(importVector),
m_mockupTypeVector(mockupTypeVector),
m_fileUrl(fileUrl),
m_edit3dToolStates(edit3dToolStates),
m_language(language)
{
}
QVector<InstanceContainer> CreateSceneCommand::instances() const
{
return m_instanceVector;
}
QVector<ReparentContainer> CreateSceneCommand::reparentInstances() const
{
return m_reparentInstanceVector;
}
QVector<IdContainer> CreateSceneCommand::ids() const
{
return m_idVector;
}
QVector<PropertyValueContainer> CreateSceneCommand::valueChanges() const
{
return m_valueChangeVector;
}
QVector<PropertyBindingContainer> CreateSceneCommand::bindingChanges() const
{
return m_bindingChangeVector;
}
QVector<PropertyValueContainer> CreateSceneCommand::auxiliaryChanges() const
{
return m_auxiliaryChangeVector;
}
QVector<AddImportContainer> CreateSceneCommand::imports() const
{
return m_importVector;
}
QVector<MockupTypeContainer> CreateSceneCommand::mockupTypes() const
{
return m_mockupTypeVector;
}
QUrl CreateSceneCommand::fileUrl() const
{
return m_fileUrl;
}
QHash<QString, QVariantMap> CreateSceneCommand::edit3dToolStates() const
{
return m_edit3dToolStates;
}
QString CreateSceneCommand::language() const
{
return m_language;
}
QDataStream &operator<<(QDataStream &out, const CreateSceneCommand &command)
{
out << command.instances();
out << command.reparentInstances();
out << command.ids();
out << command.valueChanges();
out << command.bindingChanges();
out << command.auxiliaryChanges();
out << command.imports();
out << command.mockupTypes();
out << command.fileUrl();
out << command.edit3dToolStates();
out << command.language();
return out;
}
QDataStream &operator>>(QDataStream &in, CreateSceneCommand &command)
{
in >> command.m_instanceVector;
in >> command.m_reparentInstanceVector;
in >> command.m_idVector;
in >> command.m_valueChangeVector;
in >> command.m_bindingChangeVector;
in >> command.m_auxiliaryChangeVector;
in >> command.m_importVector;
in >> command.m_mockupTypeVector;
in >> command.m_fileUrl;
in >> command.m_edit3dToolStates;
in >> command.m_language;
return in;
}
QDebug operator <<(QDebug debug, const CreateSceneCommand &command)
{
return debug.nospace() << "CreateSceneCommand("
<< "instances: " << command.instances() << ", "
<< "reparentInstances: " << command.reparentInstances() << ", "
<< "ids: " << command.ids() << ", "
<< "valueChanges: " << command.valueChanges() << ", "
<< "bindingChanges: " << command.bindingChanges() << ", "
<< "auxiliaryChanges: " << command.auxiliaryChanges() << ", "
<< "imports: " << command.imports() << ", "
<< "mockupTypes: " << command.mockupTypes() << ", "
<< "fileUrl: " << command.fileUrl() << ", "
<< "edit3dToolStates: " << command.edit3dToolStates() << ", "
<< "language: " << command.language() << ")";
<< "instances: " << command.instances << ", "
<< "reparentInstances: " << command.reparentInstances << ", "
<< "ids: " << command.ids << ", "
<< "valueChanges: " << command.valueChanges << ", "
<< "bindingChanges: " << command.bindingChanges << ", "
<< "auxiliaryChanges: " << command.auxiliaryChanges << ", "
<< "imports: " << command.imports << ", "
<< "mockupTypes: " << command.mockupTypes << ", "
<< "fileUrl: " << command.fileUrl << ", "
<< "edit3dToolStates: " << command.edit3dToolStates << ", "
<< "language: " << command.language << ")";
}
}

120
share/qtcreator/qml/qmlpuppet/commands/createscenecommand.h
View File

@@ -41,53 +41,87 @@ namespace QmlDesigner {
class CreateSceneCommand
{
friend QDataStream &operator>>(QDataStream &in, CreateSceneCommand &command);
public:
CreateSceneCommand() = default;
explicit CreateSceneCommand(const QVector<InstanceContainer> &instanceContainer,
const QVector<ReparentContainer> &reparentContainer,
const QVector<IdContainer> &idVector,
const QVector<PropertyValueContainer> &valueChangeVector,
const QVector<PropertyBindingContainer> &bindingChangeVector,
const QVector<PropertyValueContainer> &auxiliaryChangeVector,
const QVector<AddImportContainer> &importVector,
const QVector<MockupTypeContainer> &mockupTypeVector,
const QUrl &fileUrl,
const QHash<QString, QVariantMap> &edit3dToolStates,
const QString &language,
qint32 stateInstanceId)
: instances(instanceContainer)
, reparentInstances(reparentContainer)
, ids(idVector)
, valueChanges(valueChangeVector)
, bindingChanges(bindingChangeVector)
, auxiliaryChanges(auxiliaryChangeVector)
, imports(importVector)
, mockupTypes(mockupTypeVector)
, fileUrl(fileUrl)
, edit3dToolStates(edit3dToolStates)
, language(language)
, stateInstanceId{stateInstanceId}
{}
friend QDataStream &operator<<(QDataStream &out, const CreateSceneCommand &command)
{
out << command.instances;
out << command.reparentInstances;
out << command.ids;
out << command.valueChanges;
out << command.bindingChanges;
out << command.auxiliaryChanges;
out << command.imports;
out << command.mockupTypes;
out << command.fileUrl;
out << command.edit3dToolStates;
out << command.language;
out << command.stateInstanceId;
return out;
}
friend QDataStream &operator>>(QDataStream &in, CreateSceneCommand &command)
{
in >> command.instances;
in >> command.reparentInstances;
in >> command.ids;
in >> command.valueChanges;
in >> command.bindingChanges;
in >> command.auxiliaryChanges;
in >> command.imports;
in >> command.mockupTypes;
in >> command.fileUrl;
in >> command.edit3dToolStates;
in >> command.language;
in >> command.stateInstanceId;
return in;
}
public:
CreateSceneCommand();
explicit CreateSceneCommand(
const QVector<InstanceContainer> &instanceContainer,
const QVector<ReparentContainer> &reparentContainer,
const QVector<IdContainer> &idVector,
const QVector<PropertyValueContainer> &valueChangeVector,
const QVector<PropertyBindingContainer> &bindingChangeVector,
const QVector<PropertyValueContainer> &auxiliaryChangeVector,
const QVector<AddImportContainer> &importVector,
const QVector<MockupTypeContainer> &mockupTypeVector,
const QUrl &fileUrl,
const QHash<QString, QVariantMap> &edit3dToolStates,
const QString &language);
QVector<InstanceContainer> instances() const;
QVector<ReparentContainer> reparentInstances() const;
QVector<IdContainer> ids() const;
QVector<PropertyValueContainer> valueChanges() const;
QVector<PropertyBindingContainer> bindingChanges() const;
QVector<PropertyValueContainer> auxiliaryChanges() const;
QVector<AddImportContainer> imports() const;
QVector<MockupTypeContainer> mockupTypes() const;
QUrl fileUrl() const;
QHash<QString, QVariantMap> edit3dToolStates() const;
QString language() const;
private:
QVector<InstanceContainer> m_instanceVector;
QVector<ReparentContainer> m_reparentInstanceVector;
QVector<IdContainer> m_idVector;
QVector<PropertyValueContainer> m_valueChangeVector;
QVector<PropertyBindingContainer> m_bindingChangeVector;
QVector<PropertyValueContainer> m_auxiliaryChangeVector;
QVector<AddImportContainer> m_importVector;
QVector<MockupTypeContainer> m_mockupTypeVector;
QUrl m_fileUrl;
QHash<QString, QVariantMap> m_edit3dToolStates;
QString m_language;
QVector<InstanceContainer> instances;
QVector<ReparentContainer> reparentInstances;
QVector<IdContainer> ids;
QVector<PropertyValueContainer> valueChanges;
QVector<PropertyBindingContainer> bindingChanges;
QVector<PropertyValueContainer> auxiliaryChanges;
QVector<AddImportContainer> imports;
QVector<MockupTypeContainer> mockupTypes;
QUrl fileUrl;
QHash<QString, QVariantMap> edit3dToolStates;
QString language;
qint32 stateInstanceId = 0;
};
QDataStream &operator<<(QDataStream &out, const CreateSceneCommand &command);
QDataStream &operator>>(QDataStream &in, CreateSceneCommand &command);
QDebug operator<<(QDebug debug, const CreateSceneCommand &command);
QDebug operator <<(QDebug debug, const CreateSceneCommand &command);
}
} // namespace QmlDesigner
Q_DECLARE_METATYPE(QmlDesigner::CreateSceneCommand)

43
share/qtcreator/qml/qmlpuppet/qml2puppet/instances/nodeinstanceserver.cpp
View File

@@ -318,12 +318,13 @@ void NodeInstanceServer::stopRenderTimer()
void NodeInstanceServer::createScene(const CreateSceneCommand &command)
{
setTranslationLanguage(command.language());
setTranslationLanguage(command.language);
initializeView();
Internal::QmlPrivateGate::stopUnifiedTimer();
setupScene(command);
setupState(command.stateInstanceId);
refreshBindings();
startRenderTimer();
}
@@ -399,15 +400,7 @@ void NodeInstanceServer::reparentInstances(const ReparentInstancesCommand &comma
void NodeInstanceServer::changeState(const ChangeStateCommand &command)
{
if (hasInstanceForId(command.stateInstanceId())) {
if (activeStateInstance().isValid())
activeStateInstance().deactivateState();
ServerNodeInstance instance = instanceForId(command.stateInstanceId());
instance.activateState();
} else {
if (activeStateInstance().isValid())
activeStateInstance().deactivateState();
}
setupState(command.stateInstanceId());
startRenderTimer();
}
@@ -569,38 +562,37 @@ void NodeInstanceServer::setupDefaultDummyData()
QList<ServerNodeInstance> NodeInstanceServer::setupInstances(const CreateSceneCommand &command)
{
QList<ServerNodeInstance> instanceList = createInstances(command.instances());
QList<ServerNodeInstance> instanceList = createInstances(command.instances);
foreach (const IdContainer &container, command.ids()) {
for (const IdContainer &container : std::as_const(command.ids)) {
if (hasInstanceForId(container.instanceId()))
instanceForId(container.instanceId()).setId(container.id());
}
foreach (const PropertyValueContainer &container, command.valueChanges()) {
for (const PropertyValueContainer &container : std::as_const(command.valueChanges)) {
if (container.isDynamic())
setInstancePropertyVariant(container);
}
foreach (const PropertyValueContainer &container, command.valueChanges()) {
for (const PropertyValueContainer &container : std::as_const(command.valueChanges)) {
if (!container.isDynamic())
setInstancePropertyVariant(container);
}
reparentInstances(command.reparentInstances());
reparentInstances(command.reparentInstances);
foreach (const PropertyBindingContainer &container, command.bindingChanges()) {
for (const PropertyBindingContainer &container : std::as_const(command.bindingChanges)) {
if (container.isDynamic())
setInstancePropertyBinding(container);
}
foreach (const PropertyBindingContainer &container, command.bindingChanges()) {
for (const PropertyBindingContainer &container : std::as_const(command.bindingChanges)) {
if (!container.isDynamic())
setInstancePropertyBinding(container);
}
foreach (const PropertyValueContainer &container, command.auxiliaryChanges()) {
for (const PropertyValueContainer &container : std::as_const(command.auxiliaryChanges))
setInstanceAuxiliaryData(container);
}
for (int i = instanceList.size(); --i >= 0; )
instanceList[i].doComponentComplete();
@@ -1498,4 +1490,17 @@ void NodeInstanceServer::handleInstanceHidden(const ServerNodeInstance &/*instan
{
}
void NodeInstanceServer::setupState(qint32 stateInstanceId)
{
if (hasInstanceForId(stateInstanceId)) {
if (activeStateInstance().isValid())
activeStateInstance().deactivateState();
ServerNodeInstance instance = instanceForId(stateInstanceId);
instance.activateState();
} else {
if (activeStateInstance().isValid())
activeStateInstance().deactivateState();
}
}
} // namespace QmlDesigner

1
share/qtcreator/qml/qmlpuppet/qml2puppet/instances/nodeinstanceserver.h
View File

@@ -289,6 +289,7 @@ protected:
static QList<QObject*> allSubObjectsForObject(QObject *object);
virtual void resizeCanvasSizeToRootItemSize() = 0;
void setupState(qint32 stateInstanceId);
private:
void setupOnlyWorkingImports(const QStringList &workingImportStatementList);

5
share/qtcreator/qml/qmlpuppet/qml2puppet/instances/qt5informationnodeinstanceserver.cpp
View File

@@ -1316,8 +1316,7 @@ void Qt5InformationNodeInstanceServer::createScene(const CreateSceneCommand &com
Qt5NodeInstanceServer::createScene(command);
QList<ServerNodeInstance> instanceList;
const auto instances = command.instances();
for (const InstanceContainer &container : instances) {
for (const InstanceContainer &container : std::as_const(command.instances)) {
if (hasInstanceForId(container.instanceId())) {
ServerNodeInstance instance = instanceForId(container.instanceId());
if (instance.isValid())
@@ -1331,7 +1330,7 @@ void Qt5InformationNodeInstanceServer::createScene(const CreateSceneCommand &com
nodeInstanceClient()->componentCompleted(createComponentCompletedCommand(instanceList));
if (isQuick3DMode())
setup3DEditView(instanceList, command.edit3dToolStates());
setup3DEditView(instanceList, command.edit3dToolStates);
QObject::connect(&m_renderModelNodeImageViewTimer, &QTimer::timeout,
this, &Qt5InformationNodeInstanceServer::doRenderModelNodeImageView);

9
share/qtcreator/qml/qmlpuppet/qml2puppet/instances/qt5nodeinstanceserver.cpp
View File

@@ -116,11 +116,10 @@ void Qt5NodeInstanceServer::resetAllItems()
void Qt5NodeInstanceServer::setupScene(const CreateSceneCommand &command)
{
setupMockupTypes(command.mockupTypes());
setupFileUrl(command.fileUrl());
setupImports(command.imports());
setupDummyData(command.fileUrl());
setupMockupTypes(command.mockupTypes);
setupFileUrl(command.fileUrl);
setupImports(command.imports);
setupDummyData(command.fileUrl);
setupInstances(command);
quickView()->resize(rootNodeInstance().boundingRect().size().toSize());

2
share/qtcreator/qml/qmlpuppet/qml2puppet/instances/qt5previewnodeinstanceserver.cpp
View File

@@ -46,7 +46,7 @@ Qt5PreviewNodeInstanceServer::Qt5PreviewNodeInstanceServer(NodeInstanceClientInt
void Qt5PreviewNodeInstanceServer::createScene(const CreateSceneCommand &command)
{
setTranslationLanguage(command.language());
setTranslationLanguage(command.language);
initializeView();
setupScene(command);
startRenderTimer();

2
share/qtcreator/qml/qmlpuppet/qml2puppet/instances/qt5rendernodeinstanceserver.cpp
View File

@@ -137,7 +137,7 @@ void Qt5RenderNodeInstanceServer::createScene(const CreateSceneCommand &command)
Qt5NodeInstanceServer::createScene(command);
QList<ServerNodeInstance> instanceList;
foreach (const InstanceContainer &container, command.instances()) {
for (const InstanceContainer &container : std::as_const(command.instances)) {
if (hasInstanceForId(container.instanceId())) {
ServerNodeInstance instance = instanceForId(container.instanceId());
if (instance.isValid()) {

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

@@ -44,6 +44,7 @@ ImageCache::ImageCache(ImageCacheStorageInterface &storage,
while (isRunning()) {
if (auto [hasEntry, entry] = getEntry(); hasEntry) {
request(entry.name,
entry.state,
entry.requestType,
std::move(entry.captureCallback),
std::move(entry.abortCallback),
@@ -64,6 +65,7 @@ ImageCache::~ImageCache()
}
void ImageCache::request(Utils::SmallStringView name,
Utils::SmallStringView state,
ImageCache::RequestType requestType,
ImageCache::CaptureCallback captureCallback,
ImageCache::AbortCallback abortCallback,
@@ -71,9 +73,11 @@ void ImageCache::request(Utils::SmallStringView name,
ImageCacheGeneratorInterface &generator,
TimeStampProviderInterface &timeStampProvider)
{
const auto id = state.empty() ? Utils::PathString{name} : Utils::PathString{name, "+", state};
const auto timeStamp = timeStampProvider.timeStamp(name);
const auto entry = requestType == RequestType::Image ? storage.fetchImage(name, timeStamp)
: storage.fetchIcon(name, timeStamp);
const auto entry = requestType == RequestType::Image ? storage.fetchImage(id, timeStamp)
: storage.fetchIcon(id, timeStamp);
if (entry.hasEntry) {
if (entry.image.isNull())
@@ -81,7 +85,11 @@ void ImageCache::request(Utils::SmallStringView name,
else
captureCallback(entry.image);
} else {
generator.generateImage(name, timeStamp, std::move(captureCallback), std::move(abortCallback));
generator.generateImage(name,
state,
timeStamp,
std::move(captureCallback),
std::move(abortCallback));
}
}
@@ -95,17 +103,27 @@ void ImageCache::wait()
void ImageCache::requestImage(Utils::PathString name,
ImageCache::CaptureCallback captureCallback,
AbortCallback abortCallback)
AbortCallback abortCallback,
Utils::SmallString state)
{
addEntry(std::move(name), std::move(captureCallback), std::move(abortCallback), RequestType::Image);
addEntry(std::move(name),
std::move(state),
std::move(captureCallback),
std::move(abortCallback),
RequestType::Image);
m_condition.notify_all();
}
void ImageCache::requestIcon(Utils::PathString name,
ImageCache::CaptureCallback captureCallback,
ImageCache::AbortCallback abortCallback)
ImageCache::AbortCallback abortCallback,
Utils::SmallString state)
{
addEntry(std::move(name), std::move(captureCallback), std::move(abortCallback), RequestType::Icon);
addEntry(std::move(name),
std::move(state),
std::move(captureCallback),
std::move(abortCallback),
RequestType::Icon);
m_condition.notify_all();
}
@@ -136,6 +154,7 @@ std::tuple<bool, ImageCache::Entry> ImageCache::getEntry()
}
void ImageCache::addEntry(Utils::PathString &&name,
Utils::SmallString &&state,
ImageCache::CaptureCallback &&captureCallback,
AbortCallback &&abortCallback,
RequestType requestType)
@@ -143,6 +162,7 @@ void ImageCache::addEntry(Utils::PathString &&name,
std::unique_lock lock{m_mutex};
m_entries.emplace_back(std::move(name),
std::move(state),
std::move(captureCallback),
std::move(abortCallback),
requestType);

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

@@ -67,6 +67,7 @@ ImageCacheCollector::ImageCacheCollector(ImageCacheConnectionManager &connection
ImageCacheCollector::~ImageCacheCollector() = default;
void ImageCacheCollector::start(Utils::SmallStringView name,
Utils::SmallStringView state,
CaptureCallback captureCallback,
AbortCallback abortCallback)
{
@@ -91,6 +92,11 @@ void ImageCacheCollector::start(Utils::SmallStringView name,
return;
}
ModelNode stateNode = rewriterView.modelNodeForId(QString{state});
if (stateNode.isValid())
rewriterView.setCurrentStateNode(stateNode);
m_connectionManager.setCallback(std::move(captureCallback));
nodeInstanceView.setTarget(m_target.get());

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

@@ -53,6 +53,7 @@ public:
~ImageCacheCollector();
void start(Utils::SmallStringView filePath,
Utils::SmallStringView state,
CaptureCallback captureCallback,
AbortCallback abortCallback) override;

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

@@ -38,6 +38,7 @@ public:
using AbortCallback = std::function<void()>;
virtual void start(Utils::SmallStringView filePath,
Utils::SmallStringView state,
CaptureCallback captureCallback,
AbortCallback abortCallback)
= 0;

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

@@ -47,14 +47,20 @@ ImageCacheGenerator::~ImageCacheGenerator()
waitForFinished();
}
void ImageCacheGenerator::generateImage(Utils::SmallStringView name,
Sqlite::TimeStamp timeStamp,
ImageCacheGeneratorInterface::CaptureCallback &&captureCallback,
AbortCallback &&abortCallback)
void ImageCacheGenerator::generateImage(
Utils::SmallStringView name,
Utils::SmallStringView state,
Sqlite::TimeStamp timeStamp,
ImageCacheGeneratorInterface::CaptureCallback &&captureCallback,
AbortCallback &&abortCallback)
{
{
std::lock_guard lock{m_mutex};
m_tasks.emplace_back(name, timeStamp, std::move(captureCallback), std::move(abortCallback));
m_tasks.emplace_back(name,
state,
timeStamp,
std::move(captureCallback),
std::move(abortCallback));
}
m_condition.notify_all();
@@ -99,6 +105,7 @@ void ImageCacheGenerator::startGeneration()
m_collector.start(
task.filePath,
task.state,
[this, task](QImage &&image) {
if (image.isNull())
task.abortCallback();

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

@@ -51,6 +51,7 @@ public:
~ImageCacheGenerator();
void generateImage(Utils::SmallStringView filePath,
Utils::SmallStringView state,
Sqlite::TimeStamp timeStamp,
CaptureCallback &&captureCallback,
AbortCallback &&abortCallback) override;
@@ -63,16 +64,19 @@ private:
{
Task() = default;
Task(Utils::SmallStringView filePath,
Utils::SmallStringView state,
Sqlite::TimeStamp timeStamp,
CaptureCallback &&captureCallback,
AbortCallback &&abortCallback)
: filePath(filePath)
, state(std::move(state))
, captureCallback(std::move(captureCallback))
, abortCallback(std::move(abortCallback))
, timeStamp(timeStamp)
{}
Utils::PathString filePath;
Utils::SmallString state;
CaptureCallback captureCallback;
AbortCallback abortCallback;
Sqlite::TimeStamp timeStamp;

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

@@ -39,6 +39,7 @@ public:
using AbortCallback = std::function<void()>;
virtual void generateImage(Utils::SmallStringView name,
Utils::SmallStringView state,
Sqlite::TimeStamp timeStamp,
CaptureCallback &&captureCallback,
AbortCallback &&abortCallback)

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

@@ -54,10 +54,12 @@ public:
void requestImage(Utils::PathString name,
CaptureCallback captureCallback,
AbortCallback abortCallback);
AbortCallback abortCallback,
Utils::SmallString state = {});
void requestIcon(Utils::PathString name,
CaptureCallback captureCallback,
AbortCallback abortCallback);
AbortCallback abortCallback,
Utils::SmallString state = {});
void clean();
void waitForFinished();
@@ -68,16 +70,19 @@ private:
{
Entry() = default;
Entry(Utils::PathString name,
Utils::SmallString state,
CaptureCallback &&captureCallback,
AbortCallback &&abortCallback,
RequestType requestType)
: name{std::move(name)}
, state{std::move(state)}
, captureCallback{std::move(captureCallback)}
, abortCallback{std::move(abortCallback)}
, requestType{requestType}
{}
Utils::PathString name;
Utils::SmallString state;
CaptureCallback captureCallback;
AbortCallback abortCallback;
RequestType requestType = RequestType::Image;
@@ -85,6 +90,7 @@ private:
std::tuple<bool, Entry> getEntry();
void addEntry(Utils::PathString &&name,
Utils::SmallString &&state,
CaptureCallback &&captureCallback,
AbortCallback &&abortCallback,
RequestType requestType);
@@ -93,6 +99,7 @@ private:
void stopThread();
bool isRunning();
static void request(Utils::SmallStringView name,
Utils::SmallStringView state,
ImageCache::RequestType requestType,
ImageCache::CaptureCallback captureCallback,
ImageCache::AbortCallback abortCallback,

47
src/plugins/qmldesigner/designercore/instances/nodeinstanceview.cpp
View File

@@ -856,7 +856,7 @@ CreateSceneCommand NodeInstanceView::createCreateSceneCommand()
QList<ModelNode> nodeList = allModelNodes();
QList<NodeInstance> instanceList;
foreach (const ModelNode &node, nodeList) {
for (const ModelNode &node : std::as_const(nodeList)) {
NodeInstance instance = loadNode(node);
if (!isSkippedNode(node))
instanceList.append(instance);
@@ -868,7 +868,7 @@ CreateSceneCommand NodeInstanceView::createCreateSceneCommand()
QList<BindingProperty> bindingPropertyList;
QVector<PropertyValueContainer> auxiliaryContainerVector;
foreach (const ModelNode &node, nodeList) {
for (const ModelNode &node : std::as_const(nodeList)) {
variantPropertyList.append(node.variantProperties());
bindingPropertyList.append(node.bindingProperties());
if (node.isValid() && hasInstanceForModelNode(node)) {
@@ -883,9 +883,8 @@ CreateSceneCommand NodeInstanceView::createCreateSceneCommand()
}
}
QVector<InstanceContainer> instanceContainerList;
foreach (const NodeInstance &instance, instanceList) {
for (const NodeInstance &instance : std::as_const(instanceList)) {
InstanceContainer::NodeSourceType nodeSourceType = static_cast<InstanceContainer::NodeSourceType>(instance.modelNode().nodeSourceType());
InstanceContainer::NodeMetaType nodeMetaType = InstanceContainer::ObjectMetaType;
@@ -911,7 +910,7 @@ CreateSceneCommand NodeInstanceView::createCreateSceneCommand()
}
QVector<ReparentContainer> reparentContainerList;
foreach (const NodeInstance &instance, instanceList) {
for (const NodeInstance &instance : std::as_const(instanceList)) {
if (instance.modelNode().hasParentProperty()) {
NodeAbstractProperty parentProperty = instance.modelNode().parentProperty();
ReparentContainer container(instance.instanceId(), -1, PropertyName(), instanceForModelNode(parentProperty.parentModelNode()).instanceId(), parentProperty.name());
@@ -920,7 +919,7 @@ CreateSceneCommand NodeInstanceView::createCreateSceneCommand()
}
QVector<IdContainer> idContainerList;
foreach (const NodeInstance &instance, instanceList) {
for (const NodeInstance &instance : std::as_const(instanceList)) {
QString id = instance.modelNode().id();
if (!id.isEmpty()) {
IdContainer container(instance.instanceId(), id);
@@ -929,7 +928,7 @@ CreateSceneCommand NodeInstanceView::createCreateSceneCommand()
}
QVector<PropertyValueContainer> valueContainerList;
foreach (const VariantProperty &property, variantPropertyList) {
for (const VariantProperty &property : std::as_const(variantPropertyList)) {
ModelNode node = property.parentModelNode();
if (node.isValid() && hasInstanceForModelNode(node)) {
NodeInstance instance = instanceForModelNode(node);
@@ -939,7 +938,7 @@ CreateSceneCommand NodeInstanceView::createCreateSceneCommand()
}
QVector<PropertyBindingContainer> bindingContainerList;
foreach (const BindingProperty &property, bindingPropertyList) {
for (const BindingProperty &property : std::as_const(bindingPropertyList)) {
ModelNode node = property.parentModelNode();
if (node.isValid() && hasInstanceForModelNode(node)) {
NodeInstance instance = instanceForModelNode(node);
@@ -949,7 +948,7 @@ CreateSceneCommand NodeInstanceView::createCreateSceneCommand()
}
QVector<AddImportContainer> importVector;
foreach (const Import &import, model()->imports())
for (const Import &import : model()->imports())
importVector.append(AddImportContainer(import.url(), import.file(), import.version(), import.alias(), import.importPaths()));
QVector<MockupTypeContainer> mockupTypesVector;
@@ -993,19 +992,23 @@ CreateSceneCommand NodeInstanceView::createCreateSceneCommand()
if (auto multiLanguageAspect = QmlProjectManager::QmlMultiLanguageAspect::current(m_currentTarget))
lastUsedLanguage = multiLanguageAspect->currentLocale();
return CreateSceneCommand(
instanceContainerList,
reparentContainerList,
idContainerList,
valueContainerList,
bindingContainerList,
auxiliaryContainerVector,
importVector,
mockupTypesVector,
model()->fileUrl(),
m_edit3DToolStates[model()->fileUrl()],
lastUsedLanguage
);
ModelNode stateNode = currentStateNode();
qint32 stateInstanceId = 0;
if (stateNode.isValid() && stateNode.metaInfo().isSubclassOf("QtQuick.State", 1, 0))
stateInstanceId = stateNode.internalId();
return CreateSceneCommand(instanceContainerList,
reparentContainerList,
idContainerList,
valueContainerList,
bindingContainerList,
auxiliaryContainerVector,
importVector,
mockupTypesVector,
model()->fileUrl(),
m_edit3DToolStates[model()->fileUrl()],
lastUsedLanguage,
stateInstanceId);
}
ClearSceneCommand NodeInstanceView::createClearSceneCommand() const

82
tests/unit/unittest/imagecache-test.cpp
View File

@@ -112,8 +112,8 @@ TEST_F(ImageCache, RequestImageRequestImageFromGenerator)
.WillByDefault(Return(Sqlite::TimeStamp{123}));
EXPECT_CALL(mockGenerator,
generateImage(Eq("/path/to/Component.qml"), Eq(Sqlite::TimeStamp{123}), _, _))
.WillRepeatedly([&](auto &&, auto, auto &&callback, auto) { notification.notify(); });
generateImage(Eq("/path/to/Component.qml"), _, Eq(Sqlite::TimeStamp{123}), _, _))
.WillRepeatedly([&](auto, auto, auto, auto &&callback, auto) { notification.notify(); });
cache.requestImage("/path/to/Component.qml",
mockCaptureCallback.AsStdFunction(),
@@ -123,8 +123,8 @@ TEST_F(ImageCache, RequestImageRequestImageFromGenerator)
TEST_F(ImageCache, RequestImageCallsCaptureCallbackWithImageFromGenerator)
{
ON_CALL(mockGenerator, generateImage(Eq("/path/to/Component.qml"), _, _, _))
.WillByDefault([&](auto &&, auto, auto &&callback, auto) {
ON_CALL(mockGenerator, generateImage(Eq("/path/to/Component.qml"), _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto &&callback, auto) {
callback(QImage{image1});
notification.notify();
});
@@ -139,8 +139,8 @@ TEST_F(ImageCache, RequestImageCallsCaptureCallbackWithImageFromGenerator)
TEST_F(ImageCache, RequestImageCallsAbortCallbackFromGenerator)
{
ON_CALL(mockGenerator, generateImage(Eq("/path/to/Component.qml"), _, _, _))
.WillByDefault([&](auto &&, auto, auto &&, auto &&abortCallback) {
ON_CALL(mockGenerator, generateImage(Eq("/path/to/Component.qml"), _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto &&, auto &&abortCallback) {
abortCallback();
notification.notify();
});
@@ -217,8 +217,8 @@ TEST_F(ImageCache, RequestIconRequestImageFromGenerator)
.WillByDefault(Return(Sqlite::TimeStamp{123}));
EXPECT_CALL(mockGenerator,
generateImage(Eq("/path/to/Component.qml"), Eq(Sqlite::TimeStamp{123}), _, _))
.WillRepeatedly([&](auto &&, auto, auto &&callback, auto) { notification.notify(); });
generateImage(Eq("/path/to/Component.qml"), _, Eq(Sqlite::TimeStamp{123}), _, _))
.WillRepeatedly([&](auto, auto, auto, auto &&callback, auto) { notification.notify(); });
cache.requestIcon("/path/to/Component.qml",
mockCaptureCallback.AsStdFunction(),
@@ -228,8 +228,8 @@ TEST_F(ImageCache, RequestIconRequestImageFromGenerator)
TEST_F(ImageCache, RequestIconCallsCaptureCallbackWithImageFromGenerator)
{
ON_CALL(mockGenerator, generateImage(Eq("/path/to/Component.qml"), _, _, _))
.WillByDefault([&](auto &&, auto, auto &&callback, auto) {
ON_CALL(mockGenerator, generateImage(Eq("/path/to/Component.qml"), _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto &&callback, auto) {
callback(QImage{image1});
notification.notify();
});
@@ -244,8 +244,8 @@ TEST_F(ImageCache, RequestIconCallsCaptureCallbackWithImageFromGenerator)
TEST_F(ImageCache, RequestIconCallsAbortCallbackFromGenerator)
{
ON_CALL(mockGenerator, generateImage(Eq("/path/to/Component.qml"), _, _, _))
.WillByDefault([&](auto &&, auto, auto &&, auto &&abortCallback) {
ON_CALL(mockGenerator, generateImage(Eq("/path/to/Component.qml"), _, _, _, _))
.WillByDefault([&](auto, auto, auto, auto &&, auto &&abortCallback) {
abortCallback();
notification.notify();
});
@@ -260,8 +260,8 @@ TEST_F(ImageCache, RequestIconCallsAbortCallbackFromGenerator)
TEST_F(ImageCache, CleanRemovesEntries)
{
EXPECT_CALL(mockGenerator, generateImage(_, _, _, _))
.WillRepeatedly([&](auto &&, auto, auto &&mockCaptureCallback, auto &&) {
EXPECT_CALL(mockGenerator, generateImage(_, _, _, _, _))
.WillRepeatedly([&](auto, auto, auto, auto &&mockCaptureCallback, auto &&) {
mockCaptureCallback(QImage{});
waitInThread.wait();
});
@@ -280,9 +280,9 @@ TEST_F(ImageCache, CleanRemovesEntries)
TEST_F(ImageCache, CleanCallsAbort)
{
ON_CALL(mockGenerator, generateImage(_, _, _, _))
ON_CALL(mockGenerator, generateImage(_, _, _, _, _))
.WillByDefault(
[&](auto &&, auto, auto &&mockCaptureCallback, auto &&) { waitInThread.wait(); });
[&](auto, auto, auto, auto &&mockCaptureCallback, auto &&) { waitInThread.wait(); });
cache.requestIcon("/path/to/Component1.qml",
mockCaptureCallback.AsStdFunction(),
mockAbortCallback.AsStdFunction());
@@ -310,8 +310,8 @@ TEST_F(ImageCache, AfterCleanNewJobsWorks)
{
cache.clean();
EXPECT_CALL(mockGenerator, generateImage(Eq("/path/to/Component.qml"), _, _, _))
.WillRepeatedly([&](auto &&, auto, auto &&, auto &&) { notification.notify(); });
EXPECT_CALL(mockGenerator, generateImage(Eq("/path/to/Component.qml"), _, _, _, _))
.WillRepeatedly([&](auto, auto, auto, auto &&, auto &&) { notification.notify(); });
cache.requestIcon("/path/to/Component.qml",
mockCaptureCallback.AsStdFunction(),
@@ -342,4 +342,50 @@ TEST_F(ImageCache, WaitForFinishedInGenerator)
cache.waitForFinished();
}
TEST_F(ImageCache, RequestImageWithStateFetchesImageFromStorage)
{
EXPECT_CALL(mockStorage, fetchImage(Eq("/path/to/Component.qml+state1"), _))
.WillRepeatedly([&](Utils::SmallStringView, auto) {
notification.notify();
return QmlDesigner::ImageCacheStorageInterface::Entry{{}, false};
});
cache.requestImage("/path/to/Component.qml",
mockCaptureCallback.AsStdFunction(),
mockAbortCallback.AsStdFunction(),
"state1");
notification.wait();
}
TEST_F(ImageCache, RequestIconWithStateFetchesImageFromStorage)
{
EXPECT_CALL(mockStorage, fetchIcon(Eq("/path/to/Component.qml+state1"), _))
.WillRepeatedly([&](Utils::SmallStringView, auto) {
notification.notify();
return QmlDesigner::ImageCacheStorageInterface::Entry{{}, false};
});
cache.requestIcon("/path/to/Component.qml",
mockCaptureCallback.AsStdFunction(),
mockAbortCallback.AsStdFunction(),
"state1");
notification.wait();
}
TEST_F(ImageCache, RequestImageWithStateRequestImageFromGenerator)
{
ON_CALL(mockTimeStampProvider, timeStamp(Eq("/path/to/Component.qml")))
.WillByDefault(Return(Sqlite::TimeStamp{123}));
EXPECT_CALL(mockGenerator,
generateImage(Eq("/path/to/Component.qml"), Eq("state1"), Eq(Sqlite::TimeStamp{123}), _, _))
.WillRepeatedly([&](auto, auto, auto, auto &&callback, auto) { notification.notify(); });
cache.requestImage("/path/to/Component.qml",
mockCaptureCallback.AsStdFunction(),
mockAbortCallback.AsStdFunction(),
"state1");
notification.wait();
}
} // namespace

1
tests/unit/unittest/imagecachecollectormock.h
View File

@@ -35,6 +35,7 @@ public:
MOCK_METHOD(void,
start,
(Utils::SmallStringView filePath,
Utils::SmallStringView state,
ImageCacheCollectorInterface::CaptureCallback captureCallback,
ImageCacheCollectorInterface::AbortCallback abortCallback),
(override));

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

@@ -63,24 +63,25 @@ protected:
TEST_F(ImageCacheGenerator, CallsCollectorWithCaptureCallback)
{
EXPECT_CALL(collectorMock, start(Eq("name"), _, _))
.WillRepeatedly([&](auto, auto captureCallback, auto) { captureCallback(QImage{image1}); });
EXPECT_CALL(collectorMock, start(Eq("name"), _, _, _))
.WillRepeatedly(
[&](auto, auto, auto captureCallback, auto) { captureCallback(QImage{image1}); });
EXPECT_CALL(imageCallbackMock, Call(_)).WillRepeatedly([&](const QImage &) {
notification.notify();
});
generator.generateImage("name", {}, imageCallbackMock.AsStdFunction(), {});
generator.generateImage("name", {}, {}, imageCallbackMock.AsStdFunction(), {});
notification.wait();
}
TEST_F(ImageCacheGenerator, CallsCollectorOnlyIfNotProcessing)
{
EXPECT_CALL(collectorMock, start(Eq("name"), _, _)).WillRepeatedly([&](auto, auto, auto) {
EXPECT_CALL(collectorMock, start(Eq("name"), _, _, _)).WillRepeatedly([&](auto, auto, auto, auto) {
notification.notify();
});
generator.generateImage("name", {}, imageCallbackMock.AsStdFunction(), {});
generator.generateImage("name", {}, imageCallbackMock.AsStdFunction(), {});
generator.generateImage("name", {}, {}, imageCallbackMock.AsStdFunction(), {});
generator.generateImage("name", {}, {}, imageCallbackMock.AsStdFunction(), {});
notification.wait(2);
}
@@ -88,37 +89,39 @@ TEST_F(ImageCacheGenerator, ProcessTaskAfterFirstFinished)
{
ON_CALL(imageCallbackMock, Call(_)).WillByDefault([&](const QImage &) { notification.notify(); });
EXPECT_CALL(collectorMock, start(Eq("name"), _, _)).WillOnce([&](auto, auto captureCallback, auto) {
captureCallback(QImage{image1});
});
EXPECT_CALL(collectorMock, start(Eq("name2"), _, _)).WillOnce([&](auto, auto captureCallback, auto) {
captureCallback(QImage{image1});
});
EXPECT_CALL(collectorMock, start(Eq("name"), _, _, _))
.WillOnce([&](auto, auto, auto captureCallback, auto) { captureCallback(QImage{image1}); });
EXPECT_CALL(collectorMock, start(Eq("name2"), _, _, _))
.WillOnce([&](auto, auto, auto captureCallback, auto) { captureCallback(QImage{image1}); });
generator.generateImage("name", {}, imageCallbackMock.AsStdFunction(), {});
generator.generateImage("name2", {}, imageCallbackMock.AsStdFunction(), {});
generator.generateImage("name", {}, {}, imageCallbackMock.AsStdFunction(), {});
generator.generateImage("name2", {}, {}, imageCallbackMock.AsStdFunction(), {});
notification.wait(2);
}
TEST_F(ImageCacheGenerator, DontCrashAtDestructingGenerator)
{
ON_CALL(collectorMock, start(Eq("name"), _, _)).WillByDefault([&](auto, auto captureCallback, auto) {
captureCallback(QImage{image1});
});
ON_CALL(collectorMock, start(Eq("name"), _, _, _))
.WillByDefault(
[&](auto, auto, auto captureCallback, auto) { captureCallback(QImage{image1}); });
generator.generateImage("name",
{},
{},
imageCallbackMock.AsStdFunction(),
abortCallbackMock.AsStdFunction());
generator.generateImage("name2",
{},
{},
imageCallbackMock.AsStdFunction(),
abortCallbackMock.AsStdFunction());
generator.generateImage("name3",
{},
{},
imageCallbackMock.AsStdFunction(),
abortCallbackMock.AsStdFunction());
generator.generateImage("name4",
{},
{},
imageCallbackMock.AsStdFunction(),
abortCallbackMock.AsStdFunction());
@@ -126,27 +129,27 @@ TEST_F(ImageCacheGenerator, DontCrashAtDestructingGenerator)
TEST_F(ImageCacheGenerator, StoreImage)
{
ON_CALL(collectorMock, start(Eq("name"), _, _)).WillByDefault([&](auto, auto captureCallback, auto) {
captureCallback(QImage{image1});
});
ON_CALL(collectorMock, start(Eq("name"), _, _, _))
.WillByDefault(
[&](auto, auto, auto captureCallback, auto) { captureCallback(QImage{image1}); });
EXPECT_CALL(storageMock, storeImage(Eq("name"), Eq(Sqlite::TimeStamp{11}), Eq(image1)))
.WillRepeatedly([&](auto, auto, auto) { notification.notify(); });
generator.generateImage("name", {11}, imageCallbackMock.AsStdFunction(), {});
generator.generateImage("name", {}, {11}, imageCallbackMock.AsStdFunction(), {});
notification.wait();
}
TEST_F(ImageCacheGenerator, StoreNullImage)
{
ON_CALL(collectorMock, start(Eq("name"), _, _)).WillByDefault([&](auto, auto captureCallback, auto) {
captureCallback(QImage{});
});
ON_CALL(collectorMock, start(Eq("name"), _, _, _))
.WillByDefault([&](auto, auto, auto captureCallback, auto) { captureCallback(QImage{}); });
EXPECT_CALL(storageMock, storeImage(Eq("name"), Eq(Sqlite::TimeStamp{11}), Eq(QImage{})))
.WillRepeatedly([&](auto, auto, auto) { notification.notify(); });
generator.generateImage("name",
{},
{11},
imageCallbackMock.AsStdFunction(),
abortCallbackMock.AsStdFunction());
@@ -155,21 +158,22 @@ TEST_F(ImageCacheGenerator, StoreNullImage)
TEST_F(ImageCacheGenerator, AbortCallback)
{
ON_CALL(collectorMock, start(Eq("name"), _, _)).WillByDefault([&](auto, auto captureCallback, auto) {
captureCallback(QImage{image1});
});
ON_CALL(collectorMock, start(Eq("name2"), _, _)).WillByDefault([&](auto, auto, auto abortCallback) {
abortCallback();
});
ON_CALL(collectorMock, start(Eq("name"), _, _, _))
.WillByDefault(
[&](auto, auto, auto captureCallback, auto) { captureCallback(QImage{image1}); });
ON_CALL(collectorMock, start(Eq("name2"), _, _, _))
.WillByDefault([&](auto, auto, auto, auto abortCallback) { abortCallback(); });
EXPECT_CALL(imageCallbackMock, Call(_)).WillOnce([&](const QImage &) { notification.notify(); });
EXPECT_CALL(abortCallbackMock, Call()).WillOnce([&]() { notification.notify(); });
generator.generateImage("name",
{},
{},
imageCallbackMock.AsStdFunction(),
abortCallbackMock.AsStdFunction());
generator.generateImage("name2",
{},
{},
imageCallbackMock.AsStdFunction(),
abortCallbackMock.AsStdFunction());
@@ -178,7 +182,7 @@ TEST_F(ImageCacheGenerator, AbortCallback)
TEST_F(ImageCacheGenerator, StoreNullImageForAbortCallback)
{
ON_CALL(collectorMock, start(_, _, _)).WillByDefault([&](auto, auto, auto abortCallback) {
ON_CALL(collectorMock, start(_, _, _, _)).WillByDefault([&](auto, auto, auto, auto abortCallback) {
abortCallback();
});
@@ -186,6 +190,7 @@ TEST_F(ImageCacheGenerator, StoreNullImageForAbortCallback)
.WillOnce([&](auto, auto, auto) { notification.notify(); });
generator.generateImage("name",
{},
{11},
imageCallbackMock.AsStdFunction(),
abortCallbackMock.AsStdFunction());
@@ -194,13 +199,13 @@ TEST_F(ImageCacheGenerator, StoreNullImageForAbortCallback)
TEST_F(ImageCacheGenerator, AbortForEmptyImage)
{
ON_CALL(collectorMock, start(Eq("name"), _, _)).WillByDefault([&](auto, auto captureCallback, auto) {
captureCallback(QImage{});
});
ON_CALL(collectorMock, start(Eq("name"), _, _, _))
.WillByDefault([&](auto, auto, auto captureCallback, auto) { captureCallback(QImage{}); });
EXPECT_CALL(abortCallbackMock, Call()).WillOnce([&]() { notification.notify(); });
generator.generateImage("name",
{},
{},
imageCallbackMock.AsStdFunction(),
abortCallbackMock.AsStdFunction());
@@ -209,17 +214,18 @@ TEST_F(ImageCacheGenerator, AbortForEmptyImage)
TEST_F(ImageCacheGenerator, CallWalCheckpointFullIfQueueIsEmpty)
{
ON_CALL(collectorMock, start(Eq("name"), _, _)).WillByDefault([&](auto, auto captureCallback, auto) {
captureCallback({});
});
ON_CALL(collectorMock, start(Eq("name"), _, _, _))
.WillByDefault([&](auto, auto, auto captureCallback, auto) { captureCallback({}); });
EXPECT_CALL(storageMock, walCheckpointFull()).WillRepeatedly([&]() { notification.notify(); });
generator.generateImage("name",
{},
{11},
imageCallbackMock.AsStdFunction(),
abortCallbackMock.AsStdFunction());
generator.generateImage("name2",
{},
{11},
imageCallbackMock.AsStdFunction(),
abortCallbackMock.AsStdFunction());
@@ -228,15 +234,17 @@ TEST_F(ImageCacheGenerator, CallWalCheckpointFullIfQueueIsEmpty)
TEST_F(ImageCacheGenerator, CleanIsCallingAbortCallback)
{
ON_CALL(collectorMock, start(_, _, _)).WillByDefault([&](auto, auto captureCallback, auto) {
ON_CALL(collectorMock, start(_, _, _, _)).WillByDefault([&](auto, auto, auto captureCallback, auto) {
captureCallback({});
waitInThread.wait();
});
generator.generateImage("name",
{},
{11},
imageCallbackMock.AsStdFunction(),
abortCallbackMock.AsStdFunction());
generator.generateImage("name2",
{},
{11},
imageCallbackMock.AsStdFunction(),
abortCallbackMock.AsStdFunction());
@@ -249,14 +257,16 @@ TEST_F(ImageCacheGenerator, CleanIsCallingAbortCallback)
TEST_F(ImageCacheGenerator, WaitForFinished)
{
ON_CALL(collectorMock, start(_, _, _)).WillByDefault([&](auto, auto captureCallback, auto) {
ON_CALL(collectorMock, start(_, _, _, _)).WillByDefault([&](auto, auto, auto captureCallback, auto) {
captureCallback(QImage{image1});
});
generator.generateImage("name",
{},
{11},
imageCallbackMock.AsStdFunction(),
abortCallbackMock.AsStdFunction());
generator.generateImage("name2",
{},
{11},
imageCallbackMock.AsStdFunction(),
abortCallbackMock.AsStdFunction());
@@ -266,4 +276,13 @@ TEST_F(ImageCacheGenerator, WaitForFinished)
generator.waitForFinished();
}
TEST_F(ImageCacheGenerator, CallsCollectorWithState)
{
EXPECT_CALL(collectorMock, start(Eq("name"), Eq("state1"), _, _))
.WillRepeatedly([&](auto, auto, auto, auto) { notification.notify(); });
generator.generateImage("name", "state1", {}, imageCallbackMock.AsStdFunction(), {});
notification.wait();
}
} // namespace

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

@@ -35,6 +35,7 @@ public:
MOCK_METHOD(void,
generateImage,
(Utils::SmallStringView name,
Utils::SmallStringView state,
Sqlite::TimeStamp timeStamp,
CaptureCallback &&captureCallback,
AbortCallback &&abortCallback),