#include <nodes/FlowScene>

#include <functional>

#include <memory>

#include <utility>

#include <vector>

#include <nodes/Node>

#include <nodes/NodeDataModel>

#include <catch2/catch.hpp>

#include "ApplicationSetup.hpp"

#include "Stringify.hpp"

#include "StubNodeDataModel.hpp"

using QtNodes::Connection;

using QtNodes::DataModelRegistry;

using QtNodes::FlowScene;

using QtNodes::Node;

using QtNodes::NodeData;

using QtNodes::NodeDataModel;

using QtNodes::NodeDataType;

using QtNodes::PortIndex;

using QtNodes::PortType;

TEST_CASE("FlowScene triggers connections created or deleted", "[gui]")

{

struct MockDataModel : StubNodeDataModel

};

auto setup = applicationSetup();

FlowScene scene;

Node& fromNode = scene.createNode(std::make_unique<MockDataModel>());

Node& toNode = scene.createNode(std::make_unique<MockDataModel>());

Node& unrelatedNode = scene.createNode(std::make_unique<MockDataModel>());

auto& fromNgo = fromNode.nodeGraphicsObject();

auto& toNgo = toNode.nodeGraphicsObject();

auto& unrelatedNgo = unrelatedNode.nodeGraphicsObject();

fromNgo.setPos(0, 0);

toNgo.setPos(200, 20);

unrelatedNgo.setPos(-100, -100);

auto& from = dynamic_cast<MockDataModel&>(*fromNode.nodeDataModel());

auto& to = dynamic_cast<MockDataModel&>(*toNode.nodeDataModel());

auto& unrelated = dynamic_cast<MockDataModel&>(*unrelatedNode.nodeDataModel());

SECTION("creating half a connection (not finishing the connection)")

{

auto connection = scene.createConnection(PortType::Out, fromNode, 0);

CHECK(from.inputCreatedCalledCount == 0);

CHECK(from.outputCreatedCalledCount == 0);

CHECK(to.inputCreatedCalledCount == 0);

CHECK(to.outputCreatedCalledCount == 0);

CHECK(unrelated.inputCreatedCalledCount == 0);

CHECK(unrelated.outputCreatedCalledCount == 0);

scene.deleteConnection(*connection);

}

struct Creation

};

Creation sceneCreation{"scene.createConnection",

[&] { return scene.createConnection(toNode, 0, fromNode, 0); }};

Creation partialCreation{"scene.createConnection-by partial", [&] {

auto connection = scene.createConnection(PortType::Out, fromNode, 0);

connection->setNodeToPort(toNode, PortType::In, 0);

return connection;

}};

struct Deletion

};

Deletion sceneDeletion{"scene.deleteConnection",

[&](Connection & c) { scene.deleteConnection(c); }};

Deletion partialDragDeletion{"scene-deleteConnectionByDraggingOff",

[&](Connection & c)

{

PortIndex portIndex = c.getPortIndex(PortType::In);

Node * node = c.getNode(PortType::In);

node->nodeState().getEntries(PortType::In)[portIndex].clear();

c.clearNode(PortType::In);

}};

SECTION("creating a connection")

{

std::vector<Creation> cases({sceneCreation, partialCreation});

for (Creation const& create : cases)

{

SECTION(create.name)

{

auto connection = create.createConnection();

CHECK(from.inputCreatedCalledCount == 0);

CHECK(from.outputCreatedCalledCount == 1);

CHECK(to.inputCreatedCalledCount == 1);

CHECK(to.outputCreatedCalledCount == 0);

CHECK(unrelated.inputCreatedCalledCount == 0);

CHECK(unrelated.outputCreatedCalledCount == 0);

scene.deleteConnection(*connection);

}

}

}

SECTION("deleting a connection")

{

std::vector<Deletion> cases({sceneDeletion, partialDragDeletion});

for (auto const& deletion : cases)

{

SECTION("deletion: " + deletion.name)

{

Connection & connection = *sceneCreation.createConnection();

from.resetCallCounts();

to.resetCallCounts();

deletion.deleteConnection(connection);

// Here the Connection reference becomes dangling

CHECK(from.inputDeletedCalledCount == 0);

CHECK(from.outputDeletedCalledCount == 1);

CHECK(to.inputDeletedCalledCount == 1);

CHECK(to.outputDeletedCalledCount == 0);

CHECK(unrelated.inputDeletedCalledCount == 0);

CHECK(unrelated.outputDeletedCalledCount == 0);

}

}

}

}

TEST_CASE("FlowScene's DataModelRegistry outlives nodes and connections", "[asan][gui]")

{

class MockDataModel : public StubNodeDataModel

};

struct MockDataModelCreator

};

int modelsDestroyed = 0;

// Introduce a new scope, so that modelsDestroyed will be alive even after the

// FlowScene is destroyed.

{

auto setup = applicationSetup();

auto registry = std::make_shared<DataModelRegistry>();

registry->registerModel(MockDataModelCreator(&modelsDestroyed));

modelsDestroyed = 0;

FlowScene scene(std::move(registry));

auto& node = scene.createNode(scene.registry().create("name"));

// On destruction, if this `node` outlives its MockDataModelCreator,

// (if it outlives the DataModelRegistry), then we trigger undefined

// behavior through use-after-free. ASAN will catch that.

}

CHECK(modelsDestroyed == 1);

}