undostack.test.cpp File Reference

Implements class CLASS? More...

Include dependency graph for undostack.test.cpp:

Go to the source code of this file.

Classes
class	UndoStackTest

Functions
	TEST_F (UndoStackTest, beginMacrosEndMacros)
	Add item and changing its data from macros. More...
	TEST_F (UndoStackTest, commandTimeOfLife)
	Checking time of life of the command during undo/redo. More...
	TEST_F (UndoStackTest, copyLayerFromMultilayer)
	Creating two multilayers. Copying layer from one multilayer to another. More...
	TEST_F (UndoStackTest, expiredCommandTimeOfLife)
	Checking time of life of the command during undo/redo. More...
	TEST_F (UndoStackTest, initialState)
	TEST_F (UndoStackTest, insertAndSetData)
	Checks if we insert item, set data and undo everything we can get back to the data. More...
	TEST_F (UndoStackTest, insertDataAndGraph)
	Add GraphItem and Data1DItem, addisgn data to graph, undo, then redo. More...
	TEST_F (UndoStackTest, insertDataItemViaMacro)
	Setup Data1DItem via macro. More...
	TEST_F (UndoStackTest, insertNewItem)
	TEST_F (UndoStackTest, insertParentAndChild)
	Undo/redo scenario when few items inserted. More...
	TEST_F (UndoStackTest, insertPropertyItemID)
	Insert property item, unto, redo, and checking that identifier is preserved. More...
	TEST_F (UndoStackTest, itemIdentifierOnRemove)
	Insert item, remove row, undo and check item id. More...
	TEST_F (UndoStackTest, moveLayerFromMLDeleteAll)
	Create 2 multilayers, 3 layers each. More...
	TEST_F (UndoStackTest, moveLayerFromMLDeleteSecond)
	Move single layer from multilayer to another empty multilayer. More...
	TEST_F (UndoStackTest, moveLayerFromMultiLayer)
	Move single layer from multilayer to another empty multilayer. More...
	TEST_F (UndoStackTest, multiLayer)
	Create multilayer, add two layers, remove everything and undo. More...
	TEST_F (UndoStackTest, removeParentAndChild)
	Inserting parent and child, setting data to them, removing parent, undoing and checking. More...
	TEST_F (UndoStackTest, removeRow)
	Inserting item, setting the data, removing row, undoing, checking item and data. More...
	TEST_F (UndoStackTest, setData)
	Undo/redo scenario when item inserted and data set few times. More...
	TEST_F (UndoStackTest, setDataThroughItem)
	Undo/redo scenario when item data changed through item and not the model. More...
	TEST_F (UndoStackTest, setSameData)
	Undo/redo scenario when we set same data. Undo stack should be empty. More...

Detailed Description

Implements class CLASS?

Homepage:\n http://www.bornagainproject.org

License:\n GNU General Public License v3 or higher (see COPYING)

Copyright

Forschungszentrum Jülich GmbH 2020

Authors

Gennady Pospelov et al, Scientific Computing Group at MLZ (see CITATION, AUTHORS)

Definition in file undostack.test.cpp.

Function Documentation

TEST_F() [1/21]

TEST_F	(	UndoStackTest	,
		beginMacrosEndMacros
	)

Add item and changing its data from macros.

Definition at line 782 of file undostack.test.cpp.

{
    const int role = ItemDataRole::DATA;
    const QVariant data(42);
 
    SessionModel model;
    model.setUndoRedoEnabled(true);
    auto stack = model.undoStack();
 
    stack->beginMacro("macro1");
    auto item = model.insertItem<SessionItem>();
    item->setData(data, role);
    stack->endMacro();
 
    // initial state before removing the row
    EXPECT_EQ(stack->count(), 1); // insert and setData commands
    EXPECT_EQ(stack->index(), 1); // insert and setData commands
    EXPECT_FALSE(model.undoStack()->canRedo());
    EXPECT_TRUE(model.undoStack()->canUndo());
    EXPECT_EQ(item->data<QVariant>(role), data);
    EXPECT_EQ(model.rootItem()->childrenCount(), 1);
 
    // undoing and checking the data
    stack->undo();
    EXPECT_EQ(stack->count(), 1);
    EXPECT_EQ(stack->index(), 0);
    EXPECT_EQ(model.rootItem()->childrenCount(), 0);
 
    // redoing
    stack->redo();
    EXPECT_EQ(stack->count(), 1);
    EXPECT_EQ(stack->index(), 1);
    EXPECT_EQ(model.rootItem()->childrenCount(), 1);
    item = Utils::ChildAt(model.rootItem(), 0);
    EXPECT_EQ(model.data(item, role).value<double>(), 42.0);
}

References ModelView::UndoStackInterface::beginMacro(), ModelView::UndoStackInterface::canRedo(), ModelView::UndoStackInterface::canUndo(), ModelView::Utils::ChildAt(), ModelView::SessionItem::childrenCount(), ModelView::ItemDataRole::DATA, ModelView::SessionModel::data(), ModelView::SessionModel::insertItem(), ModelView::SessionModel::rootItem(), ModelView::SessionItem::setData(), ModelView::SessionModel::setUndoRedoEnabled(), and ModelView::SessionModel::undoStack().

Here is the call graph for this function:

TEST_F() [2/21]

TEST_F	(	UndoStackTest	,
		commandTimeOfLife
	)

Checking time of life of the command during undo/redo.

This is connected with the fact, that Qt takes ownership of the command and we have to use our own wrapper.

Definition at line 44 of file undostack.test.cpp.

{
    SessionModel model;
    auto item = model.insertItem<PropertyItem>();
    item->setData(42);
 
    std::weak_ptr<SetValueCommand> pw_command; // to trace command time of life
 
    UndoStack stack;
 
    {
        // creating command
        auto command =
            std::make_shared<SetValueCommand>(item, QVariant::fromValue(43), ItemDataRole::DATA);
        pw_command = command;
        EXPECT_EQ(pw_command.use_count(), 1);
 
        // checking state of item, stack and command
        EXPECT_EQ(item->data<int>(), 42);
        EXPECT_FALSE(stack.canRedo());
        EXPECT_FALSE(stack.canUndo());
        EXPECT_EQ(stack.index(), 0);
        EXPECT_EQ(stack.count(), 0);
        EXPECT_EQ(command->isObsolete(), false);
        EXPECT_FALSE(std::get<bool>(command->result()));
 
        // adding command to the stack, it will lead to command execution
        stack.execute(command);
        EXPECT_EQ(pw_command.use_count(), 2);
 
        // checking state of item, stack and command
        EXPECT_EQ(item->data<int>(), 43);
        EXPECT_FALSE(stack.canRedo());
        EXPECT_TRUE(stack.canUndo());
        EXPECT_EQ(stack.index(), 1);
        EXPECT_EQ(stack.count(), 1);
        EXPECT_EQ(command->isObsolete(), false);
        EXPECT_TRUE(std::get<bool>(command->result()));
 
        // undoing
        stack.undo();
        EXPECT_EQ(item->data<int>(), 42);
        EXPECT_TRUE(stack.canRedo());
        EXPECT_FALSE(stack.canUndo());
        EXPECT_EQ(stack.index(), 0);
        EXPECT_EQ(stack.count(), 1);
        EXPECT_EQ(command->isObsolete(), false);
        EXPECT_TRUE(std::get<bool>(command->result()));
 
        // redoing
        stack.redo();
        EXPECT_EQ(item->data<int>(), 43);
        EXPECT_FALSE(stack.canRedo());
        EXPECT_TRUE(stack.canUndo());
        EXPECT_EQ(stack.index(), 1);
        EXPECT_EQ(stack.count(), 1);
        EXPECT_EQ(command->isObsolete(), false);
        EXPECT_TRUE(std::get<bool>(command->result()));
    }
 
    EXPECT_EQ(pw_command.use_count(), 1);
    if (auto command = pw_command.lock()) {
        EXPECT_EQ(command->isObsolete(), false);
        EXPECT_TRUE(std::get<bool>(command->result()));
    }
}

References ModelView::UndoStack::canRedo(), ModelView::UndoStack::canUndo(), ModelView::UndoStack::count(), ModelView::ItemDataRole::DATA, ModelView::UndoStack::execute(), ModelView::UndoStack::index(), ModelView::SessionModel::insertItem(), ModelView::UndoStack::redo(), ModelView::SessionItem::setData(), and ModelView::UndoStack::undo().

Here is the call graph for this function:

TEST_F() [3/21]

TEST_F	(	UndoStackTest	,
		copyLayerFromMultilayer
	)

Creating two multilayers. Copying layer from one multilayer to another.

Definition at line 746 of file undostack.test.cpp.

{
    auto pool = std::make_shared<ItemPool>();
    ToyItems::SampleModel model(pool);
    model.setUndoRedoEnabled(true);
    auto stack = model.undoStack();
 
    const double expected_thickness = 55.0;
 
    // creating multi layer with 3 layers
    auto multilayer0 = model.insertItem<ToyItems::MultiLayerItem>();
    auto layer0 = model.insertItem<ToyItems::LayerItem>(multilayer0);
    layer0->setProperty(ToyItems::LayerItem::P_THICKNESS, expected_thickness);
    auto multilayer1 = model.insertItem<ToyItems::MultiLayerItem>();
 
    // copying layer
    auto layer_copy = dynamic_cast<ToyItems::LayerItem*>(model.copyItem(layer0, multilayer1));
    EXPECT_EQ(multilayer1->itemCount(ToyItems::MultiLayerItem::T_LAYERS), 1);
    EXPECT_EQ(layer_copy->property<double>(ToyItems::LayerItem::P_THICKNESS), expected_thickness);
    EXPECT_TRUE(layer0->identifier() != layer_copy->identifier());
 
    auto id = layer_copy->identifier();
    EXPECT_EQ(pool->item_for_key(layer_copy->identifier()), layer_copy);
 
    // undoing
    stack->undo();
    EXPECT_EQ(multilayer1->itemCount(ToyItems::MultiLayerItem::T_LAYERS), 0);
 
    // redoing
    stack->redo();
    EXPECT_EQ(multilayer1->itemCount(ToyItems::MultiLayerItem::T_LAYERS), 1);
    EXPECT_EQ(multilayer1->getItems(ToyItems::MultiLayerItem::T_LAYERS)[0]->identifier(), id);
}

References ModelView::SessionModel::copyItem(), ModelView::SessionItem::identifier(), ModelView::SessionModel::insertItem(), ToyItems::LayerItem::P_THICKNESS, ModelView::SessionItem::property(), ModelView::SessionItem::setProperty(), ModelView::SessionModel::setUndoRedoEnabled(), ToyItems::MultiLayerItem::T_LAYERS, and ModelView::SessionModel::undoStack().

Here is the call graph for this function:

TEST_F() [4/21]

TEST_F	(	UndoStackTest	,
		expiredCommandTimeOfLife
	)

Checking time of life of the command during undo/redo.

Same as above, but command is trying to set same value. It makes it "expired" and it should be removed from the stack.

Definition at line 115 of file undostack.test.cpp.

{
    SessionModel model;
    auto item = model.insertItem<PropertyItem>();
    item->setData(42);
 
    std::weak_ptr<SetValueCommand> pw_command; // to trace command time of life
 
    UndoStack stack;
 
    {
        // creating command which sets the same value
        auto command =
            std::make_shared<SetValueCommand>(item, QVariant::fromValue(42), ItemDataRole::DATA);
        pw_command = command;
        EXPECT_EQ(pw_command.use_count(), 1);
 
        // checking state of item, stack and command
        EXPECT_EQ(item->data<int>(), 42);
        EXPECT_FALSE(stack.canRedo());
        EXPECT_FALSE(stack.canUndo());
        EXPECT_EQ(stack.index(), 0);
        EXPECT_EQ(stack.count(), 0);
        EXPECT_EQ(command->isObsolete(), false);
        EXPECT_FALSE(std::get<bool>(command->result()));
 
        // adding command to the stack, it will lead to command execution
        stack.execute(command);
        EXPECT_EQ(pw_command.use_count(), 1); // was already deleted from the stack
 
        // checking state of item, stack and command
        EXPECT_EQ(item->data<int>(), 42);
        EXPECT_FALSE(stack.canRedo());
        EXPECT_FALSE(stack.canUndo());
        EXPECT_EQ(stack.index(), 0);
        EXPECT_EQ(stack.count(), 0);
        EXPECT_EQ(command->isObsolete(), true);
        EXPECT_FALSE(std::get<bool>(command->result()));
    }
 
    EXPECT_EQ(pw_command.use_count(), 0);
    EXPECT_EQ(pw_command.lock(), nullptr);
}

References ModelView::UndoStack::canRedo(), ModelView::UndoStack::canUndo(), ModelView::UndoStack::count(), ModelView::ItemDataRole::DATA, ModelView::UndoStack::execute(), ModelView::UndoStack::index(), ModelView::SessionModel::insertItem(), and ModelView::SessionItem::setData().

Here is the call graph for this function:

TEST_F() [5/21]

TEST_F	(	UndoStackTest	,
		initialState
	)

Definition at line 159 of file undostack.test.cpp.

{
    SessionModel model;
 
    // no undo/redo stack by default
    EXPECT_TRUE(model.undoStack() == nullptr);
 
    // switching undo/redo on
    model.setUndoRedoEnabled(true);
    auto stack = model.undoStack();
    EXPECT_TRUE(stack != nullptr);
 
    // initial state of undo redo stack
    EXPECT_TRUE(stack->isActive());
    EXPECT_FALSE(stack->canRedo());
    EXPECT_FALSE(stack->canUndo());
    EXPECT_EQ(stack->index(), 0);
}

References ModelView::SessionModel::setUndoRedoEnabled(), and ModelView::SessionModel::undoStack().

Here is the call graph for this function:

TEST_F() [6/21]

TEST_F	(	UndoStackTest	,
		insertAndSetData
	)

Checks if we insert item, set data and undo everything we can get back to the data.

Definition at line 375 of file undostack.test.cpp.

{
    const int role = ItemDataRole::DATA;
    SessionModel model;
    model.setUndoRedoEnabled(true);
    auto stack = model.undoStack();
 
    // creating item
    auto item = model.insertItem<SessionItem>();
    EXPECT_FALSE(model.data(item, role).isValid());
 
    // setting new data
    QVariant value(42.0);
    model.setData(item, value, role);
    EXPECT_EQ(model.data(item, role), value);
 
    EXPECT_EQ(stack->index(), 2); // insert and setData commands
    EXPECT_FALSE(model.undoStack()->canRedo());
    EXPECT_TRUE(model.undoStack()->canUndo());
 
    // undoing twice and checking
    stack->undo();
    stack->undo();
    EXPECT_EQ(stack->index(), 0);
    EXPECT_EQ(model.rootItem()->childrenCount(), 0);
 
    // returning all back
    stack->redo();
    stack->redo();
    EXPECT_EQ(stack->index(), 2);
    EXPECT_EQ(model.rootItem()->childrenCount(), 1);
    item = Utils::ChildAt(model.rootItem(), 0);
    EXPECT_EQ(model.data(item, role).value<double>(), 42.0);
}

References ModelView::UndoStackInterface::canRedo(), ModelView::UndoStackInterface::canUndo(), ModelView::Utils::ChildAt(), ModelView::SessionItem::childrenCount(), ModelView::ItemDataRole::DATA, ModelView::SessionModel::data(), ModelView::SessionModel::insertItem(), ModelView::SessionModel::rootItem(), ModelView::SessionModel::setData(), ModelView::SessionModel::setUndoRedoEnabled(), and ModelView::SessionModel::undoStack().

Here is the call graph for this function:

TEST_F() [7/21]

TEST_F	(	UndoStackTest	,
		insertDataAndGraph
	)

Add GraphItem and Data1DItem, addisgn data to graph, undo, then redo.

GraphItem should be pointing again to Data1DItem. This is real bug case.

Definition at line 823 of file undostack.test.cpp.

{
    // constructing model with pool, enabling undo/redo
    auto pool = std::make_shared<ItemPool>();
    SessionModel model("Model", pool);
    model.setUndoRedoEnabled(true);
    EXPECT_EQ(model.undoStack()->index(), 0);
    EXPECT_EQ(model.undoStack()->count(), 0);
 
    auto dataItem = model.insertItem<Data1DItem>();
    auto graphItem = model.insertItem<GraphItem>();
    graphItem->setDataItem(dataItem);
 
    auto data_item_identifier = dataItem->identifier();
    auto graph_item_identifier = graphItem->identifier();
 
    // model has two elements, graph is pointing to the data
    EXPECT_EQ(model.undoStack()->index(), 3);
    EXPECT_EQ(model.undoStack()->count(), 3);
    EXPECT_EQ(model.rootItem()->childrenCount(), 2);
    EXPECT_EQ(graphItem->dataItem(), dataItem);
 
    // checking pool
    EXPECT_EQ(pool->item_for_key(data_item_identifier), dataItem);
    EXPECT_EQ(pool->item_for_key(graph_item_identifier), graphItem);
 
    // undoing once (setDataItem operation)
    model.undoStack()->undo();
    EXPECT_EQ(model.undoStack()->index(), 2);
    EXPECT_EQ(model.undoStack()->count(), 3);
    EXPECT_EQ(model.rootItem()->childrenCount(), 2);
    EXPECT_EQ(graphItem->dataItem(), nullptr);
 
    // undoing two more times item
    model.undoStack()->undo();
    model.undoStack()->undo();
    EXPECT_EQ(model.undoStack()->index(), 0);
    EXPECT_EQ(model.undoStack()->count(), 3);
    EXPECT_EQ(model.rootItem()->childrenCount(), 0);
 
    // redoing (dataItem is back)
    model.undoStack()->redo();
    EXPECT_EQ(model.undoStack()->index(), 1);
    EXPECT_EQ(model.rootItem()->childrenCount(), 1);
    auto restoredDataItem = model.topItem<Data1DItem>();
    EXPECT_EQ(restoredDataItem->identifier(), data_item_identifier);
    EXPECT_EQ(pool->item_for_key(data_item_identifier), restoredDataItem);
 
    // redoing (GraphItem) is back
    model.undoStack()->redo();
    EXPECT_EQ(model.undoStack()->index(), 2);
    EXPECT_EQ(model.rootItem()->childrenCount(), 2);
    auto restoredGraphItem = model.topItem<GraphItem>();
    EXPECT_EQ(restoredGraphItem->identifier(), graph_item_identifier);
    EXPECT_EQ(restoredGraphItem->dataItem(), nullptr);
 
    // redoing (graph is linked with data gaian)
    model.undoStack()->redo();
    EXPECT_EQ(model.undoStack()->index(), 3);
    EXPECT_EQ(model.rootItem()->childrenCount(), 2);
    EXPECT_EQ(restoredGraphItem->dataItem(), restoredDataItem);
}

References ModelView::SessionItem::childrenCount(), ModelView::UndoStackInterface::count(), ModelView::SessionItem::identifier(), ModelView::UndoStackInterface::index(), ModelView::SessionModel::insertItem(), ModelView::UndoStackInterface::redo(), ModelView::SessionModel::rootItem(), ModelView::SessionModel::setUndoRedoEnabled(), ModelView::SessionModel::topItem(), ModelView::UndoStackInterface::undo(), and ModelView::SessionModel::undoStack().

Here is the call graph for this function:

TEST_F() [8/21]

TEST_F	(	UndoStackTest	,
		insertDataItemViaMacro
	)

Setup Data1DItem via macro.

Undo, then redo. Add GraphItem and Data1DItem, addisgn data to graph, undo, then redo. GraphItem should be pointing again to Data1DItem. This is real bug case.

Definition at line 891 of file undostack.test.cpp.

{
    SessionModel model;
    model.setUndoRedoEnabled(true);
    EXPECT_EQ(model.undoStack()->index(), 0);
    EXPECT_EQ(model.undoStack()->count(), 0);
 
    // setting up single data item via macro
    model.undoStack()->beginMacro("AddDataItem");
    auto dataItem = model.insertItem<Data1DItem>();
    const std::vector<double> expected_values = {1.0, 2.0, 3.0};
    const std::vector<double> expected_centers = {0.5, 1.5, 2.5};
    dataItem->setAxis<FixedBinAxisItem>(3, 0.0, 3.0);
    dataItem->setValues(expected_values);
    model.undoStack()->endMacro();
 
    EXPECT_EQ(model.undoStack()->index(), 1);
    EXPECT_EQ(model.undoStack()->count(), 1);
 
    // undoing and returning back
    model.undoStack()->undo();
    model.undoStack()->redo();
    EXPECT_EQ(model.undoStack()->index(), 1);
    EXPECT_EQ(model.undoStack()->count(), 1);
 
    auto restoredDataItem = model.topItem<Data1DItem>();
    EXPECT_EQ(restoredDataItem->binCenters(), expected_centers);
    EXPECT_EQ(restoredDataItem->binValues(), expected_values);
}

References ModelView::UndoStackInterface::beginMacro(), ModelView::UndoStackInterface::count(), ModelView::UndoStackInterface::endMacro(), ModelView::UndoStackInterface::index(), ModelView::SessionModel::insertItem(), ModelView::UndoStackInterface::redo(), ModelView::Data1DItem::setAxis(), ModelView::SessionModel::setUndoRedoEnabled(), ModelView::SessionModel::topItem(), ModelView::UndoStackInterface::undo(), and ModelView::SessionModel::undoStack().

Here is the call graph for this function:

TEST_F() [9/21]

TEST_F	(	UndoStackTest	,
		insertNewItem
	)

Definition at line 178 of file undostack.test.cpp.

{
    const model_type modelType(Constants::BaseType);
    SessionModel model;
    model.setUndoRedoEnabled(true);
    auto stack = model.undoStack();
 
    // inserting single item
    auto item = model.insertItem<SessionItem>();
    EXPECT_TRUE(item != nullptr);
    EXPECT_EQ(item->modelType(), Constants::BaseType);
    EXPECT_EQ(model.rootItem()->childrenCount(), 1);
    EXPECT_EQ(stack->index(), 1);
    EXPECT_EQ(stack->count(), 1);
    EXPECT_FALSE(stack->canRedo());
    EXPECT_TRUE(stack->canUndo());
 
    // undoing item insertion
    stack->undo();
    EXPECT_EQ(model.rootItem()->childrenCount(), 0);
    EXPECT_EQ(stack->index(), 0);
    EXPECT_EQ(stack->count(), 1);
    EXPECT_TRUE(stack->canRedo());
    EXPECT_FALSE(stack->canUndo());
 
    // redoing item insertion
    stack->redo();
    EXPECT_EQ(model.rootItem()->childrenCount(), 1);
    EXPECT_EQ(Utils::ChildAt(model.rootItem(), 0)->modelType(), modelType);
    EXPECT_EQ(stack->index(), 1);
    EXPECT_FALSE(stack->canRedo());
    EXPECT_TRUE(stack->canUndo());
 
    // clearing stack
    stack->clear();
    EXPECT_EQ(stack->index(), 0);
    EXPECT_FALSE(stack->canRedo());
    EXPECT_FALSE(stack->canUndo());
    EXPECT_EQ(model.rootItem()->childrenCount(), 1);
    EXPECT_EQ(Utils::ChildAt(model.rootItem(), 0)->modelType(), modelType);
}

References ModelView::Constants::BaseType, ModelView::Utils::ChildAt(), ModelView::SessionItem::childrenCount(), ModelView::SessionModel::insertItem(), ModelView::SessionItem::modelType(), ModelView::SessionModel::rootItem(), ModelView::SessionModel::setUndoRedoEnabled(), and ModelView::SessionModel::undoStack().

Here is the call graph for this function:

TEST_F() [10/21]

TEST_F	(	UndoStackTest	,
		insertParentAndChild
	)

Undo/redo scenario when few items inserted.

Definition at line 247 of file undostack.test.cpp.

{
    SessionModel model;
    model.setUndoRedoEnabled(true);
    auto stack = model.undoStack();
 
    auto parent = model.insertItem<SessionItem>();
    parent->registerTag(TagInfo::universalTag("defaultTag"), /*set_as_default*/ true);
 
    model.insertItem<PropertyItem>(parent);
    model.insertItem<PropertyItem>(parent);
 
    // state of the stack after insertion of 3 items
    EXPECT_EQ(stack->count(), 3);
    EXPECT_EQ(stack->index(), 3);
    EXPECT_EQ(model.rootItem()->childrenCount(), 1);
    EXPECT_EQ(parent->childrenCount(), 2);
 
    // undoing two last insertions
    stack->undo();
    stack->undo();
    EXPECT_EQ(stack->count(), 3);
    EXPECT_EQ(stack->index(), 1);
    EXPECT_EQ(model.rootItem()->childrenCount(), 1);
    EXPECT_EQ(parent->childrenCount(), 0);
 
    // redoing once
    stack->redo();
    EXPECT_EQ(stack->count(), 3);
    EXPECT_EQ(stack->index(), 2);
    EXPECT_EQ(model.rootItem()->childrenCount(), 1);
    EXPECT_EQ(parent->childrenCount(), 1);
    EXPECT_EQ(Utils::ChildAt(parent, 0)->modelType(), Constants::PropertyType);
}

References ModelView::Utils::ChildAt(), ModelView::SessionItem::childrenCount(), ModelView::SessionModel::insertItem(), ModelView::Constants::PropertyType, ModelView::SessionItem::registerTag(), ModelView::SessionModel::rootItem(), ModelView::SessionModel::setUndoRedoEnabled(), ModelView::SessionModel::undoStack(), and ModelView::TagInfo::universalTag().

Here is the call graph for this function:

TEST_F() [11/21]

TEST_F	(	UndoStackTest	,
		insertPropertyItemID
	)

Insert property item, unto, redo, and checking that identifier is preserved.

Definition at line 222 of file undostack.test.cpp.

{
    SessionModel model;
    model.setUndoRedoEnabled(true);
    auto stack = model.undoStack();
 
    auto item = model.insertItem<PropertyItem>();
    auto original_id = item->identifier();
 
    EXPECT_EQ(stack->index(), 1);
    EXPECT_EQ(stack->count(), 1);
 
    model.undoStack()->undo();
    EXPECT_EQ(model.rootItem()->childrenCount(), 0);
 
    model.undoStack()->redo();
    EXPECT_EQ(model.rootItem()->childrenCount(), 1);
 
    auto restored_property_item = Utils::ChildAt(model.rootItem(), 0);
    EXPECT_EQ(restored_property_item->modelType(), Constants::PropertyType);
    EXPECT_EQ(restored_property_item->identifier(), original_id);
}

References ModelView::Utils::ChildAt(), ModelView::SessionItem::childrenCount(), ModelView::SessionItem::identifier(), ModelView::SessionModel::insertItem(), ModelView::Constants::PropertyType, ModelView::UndoStackInterface::redo(), ModelView::SessionModel::rootItem(), ModelView::SessionModel::setUndoRedoEnabled(), ModelView::UndoStackInterface::undo(), and ModelView::SessionModel::undoStack().

Here is the call graph for this function:

TEST_F() [12/21]

TEST_F	(	UndoStackTest	,
		itemIdentifierOnRemove
	)

Insert item, remove row, undo and check item id.

Definition at line 493 of file undostack.test.cpp.

{
    SessionModel model;
    model.setUndoRedoEnabled(true);
    auto stack = model.undoStack();
 
    auto parent = model.insertItem<SessionItem>();
    parent->registerTag(TagInfo::universalTag("defaultTag"), /*set_as_default*/ true);
 
    identifier_type parent_id = parent->identifier();
    auto child = model.insertItem<PropertyItem>(parent);
    identifier_type child_id = child->identifier();
 
    // removing parent
    model.removeItem(model.rootItem(), {"", 0});
    EXPECT_EQ(stack->count(), 3);
    EXPECT_EQ(stack->index(), 3);
    EXPECT_EQ(model.rootItem()->childrenCount(), 0);
 
    stack->undo();
    auto parent_at = Utils::ChildAt(model.rootItem(), 0);
    auto child_at = Utils::ChildAt(parent_at, 0);
    identifier_type parent_id2 = parent_at->identifier();
    identifier_type child_id2 = child_at->identifier();
 
    EXPECT_EQ(parent_id, parent_id2);
    EXPECT_EQ(child_id, child_id2);
}

References ModelView::Utils::ChildAt(), ModelView::SessionItem::childrenCount(), ModelView::SessionItem::identifier(), ModelView::SessionModel::insertItem(), ModelView::SessionItem::registerTag(), ModelView::SessionModel::removeItem(), ModelView::SessionModel::rootItem(), ModelView::SessionModel::setUndoRedoEnabled(), ModelView::SessionModel::undoStack(), and ModelView::TagInfo::universalTag().

Here is the call graph for this function:

TEST_F() [13/21]

TEST_F	(	UndoStackTest	,
		moveLayerFromMLDeleteAll
	)

Create 2 multilayers, 3 layers each.

Move layer from one multilayer to another. Deleting everything and undoing.

Definition at line 674 of file undostack.test.cpp.

{
    auto pool = std::make_shared<ItemPool>();
 
    ToyItems::SampleModel model(pool);
    model.setUndoRedoEnabled(true);
    auto stack = model.undoStack();
 
    // creating multi layer with 3 layers
    auto multilayer0 = model.insertItem<ToyItems::MultiLayerItem>();
    auto layer0 = model.insertItem<ToyItems::LayerItem>(multilayer0);
    auto layer1 = model.insertItem<ToyItems::LayerItem>(multilayer0);
    auto layer2 = model.insertItem<ToyItems::LayerItem>(multilayer0);
 
    // saving identifiers for further reference
    identifier_type id_multilayer0 = multilayer0->identifier();
    identifier_type id_layer0 = layer0->identifier();
    identifier_type id_layer1 = layer1->identifier();
    identifier_type id_layer2 = layer2->identifier();
 
    // creating another multi layer with 3 layers
    auto multilayer1 = model.insertItem<ToyItems::MultiLayerItem>();
    auto layer3 = model.insertItem<ToyItems::LayerItem>(multilayer1);
    auto layer4 = model.insertItem<ToyItems::LayerItem>(multilayer1);
    auto layer5 = model.insertItem<ToyItems::LayerItem>(multilayer1);
 
    // saving identifiers for further reference
    identifier_type id_multilayer1 = multilayer1->identifier();
    identifier_type id_layer3 = layer3->identifier();
    identifier_type id_layer4 = layer4->identifier();
    identifier_type id_layer5 = layer5->identifier();
 
    // checking status of unddo stack
    EXPECT_EQ(stack->count(), 8);
    EXPECT_EQ(stack->index(), 8);
 
    // moving  layer1 to second multilayer
    model.moveItem(layer1, multilayer1, {ToyItems::MultiLayerItem::T_LAYERS, 0});
 
    // removing multilayers
    model.removeItem(model.rootItem(), {"", 1});
    model.removeItem(model.rootItem(), {"", 0});
 
    // checking status of unddo stack
    EXPECT_EQ(stack->count(), 11);
    EXPECT_EQ(stack->index(), 11);
 
    // undoing thrice
    stack->undo();
    stack->undo();
    stack->undo();
 
    // restoring pointers
    auto multilayer0_r = pool->item_for_key(id_multilayer0);
    auto layer0_r = pool->item_for_key(id_layer0);
    auto layer1_r = pool->item_for_key(id_layer1);
    auto layer2_r = pool->item_for_key(id_layer2);
    auto multilayer1_r = pool->item_for_key(id_multilayer1);
    auto layer3_r = pool->item_for_key(id_layer3);
    auto layer4_r = pool->item_for_key(id_layer4);
    auto layer5_r = pool->item_for_key(id_layer5);
 
    // checking layers
    std::vector<SessionItem*> expected = {layer0_r, layer1_r, layer2_r};
    EXPECT_EQ(multilayer0_r->children(), expected);
 
    expected = {layer3_r, layer4_r, layer5_r};
    EXPECT_EQ(multilayer1_r->children(), expected);
}

References ModelView::SessionItem::identifier(), ModelView::SessionModel::insertItem(), ModelView::SessionModel::moveItem(), ModelView::SessionModel::removeItem(), ModelView::SessionModel::rootItem(), ModelView::SessionModel::setUndoRedoEnabled(), ToyItems::MultiLayerItem::T_LAYERS, and ModelView::SessionModel::undoStack().

Here is the call graph for this function:

TEST_F() [14/21]

TEST_F	(	UndoStackTest	,
		moveLayerFromMLDeleteSecond
	)

Move single layer from multilayer to another empty multilayer.

Delete second multilayer and undo.

Definition at line 623 of file undostack.test.cpp.

{
    auto pool = std::make_shared<ItemPool>();
 
    ToyItems::SampleModel model(pool);
    model.setUndoRedoEnabled(true);
    auto stack = model.undoStack();
 
    // creating multi layer with 3 layers
    auto multilayer0 = model.insertItem<ToyItems::MultiLayerItem>();
    auto layer0 = model.insertItem<ToyItems::LayerItem>(multilayer0);
    auto multilayer1 = model.insertItem<ToyItems::MultiLayerItem>();
 
    // saving identifiers for further reference
    identifier_type id_multilayer0 = multilayer0->identifier();
    identifier_type id_layer0 = layer0->identifier();
    identifier_type id_multilayer1 = multilayer1->identifier();
 
    // moving layer from multilayer
    model.moveItem(layer0, multilayer1, {"", 0});
 
    // checking results
    std::vector<SessionItem*> expected = {layer0};
    EXPECT_EQ(multilayer0->children().size(), 0);
    EXPECT_EQ(multilayer1->children(), expected);
    EXPECT_EQ(pool->item_for_key(id_layer0), layer0);
 
    // deleting second multilayer
    model.removeItem(model.rootItem(), {"", 1});
 
    // undoing deletion
    stack->undo();
 
    // restoring ponters
    auto layer0_at = pool->item_for_key(id_layer0);
    auto multilayer1_at = pool->item_for_key(id_multilayer1);
 
    expected = {layer0_at};
    EXPECT_EQ(multilayer0->children().size(), 0);
    EXPECT_EQ(multilayer1_at->children(), expected);
 
    // unoing move
    stack->undo();
 
    EXPECT_EQ(multilayer0->children(), expected);
    EXPECT_EQ(multilayer1_at->children().size(), 0);
}

References ModelView::SessionItem::children(), ModelView::SessionItem::identifier(), ModelView::SessionModel::insertItem(), ModelView::SessionModel::moveItem(), ModelView::SessionModel::removeItem(), ModelView::SessionModel::rootItem(), ModelView::SessionModel::setUndoRedoEnabled(), and ModelView::SessionModel::undoStack().

Here is the call graph for this function:

TEST_F() [15/21]

TEST_F	(	UndoStackTest	,
		moveLayerFromMultiLayer
	)

Move single layer from multilayer to another empty multilayer.

Definition at line 586 of file undostack.test.cpp.

{
    auto pool = std::make_shared<ItemPool>();
 
    ToyItems::SampleModel model(pool);
    model.setUndoRedoEnabled(true);
    auto stack = model.undoStack();
 
    // creating multi layer with 3 layers
    auto multilayer0 = model.insertItem<ToyItems::MultiLayerItem>();
    auto layer0 = model.insertItem<ToyItems::LayerItem>(multilayer0);
    auto multilayer1 = model.insertItem<ToyItems::MultiLayerItem>();
 
    // saving identifiers for further reference
    identifier_type id_multilayer0 = multilayer0->identifier();
    identifier_type id_layer0 = layer0->identifier();
    identifier_type id_multilayer1 = multilayer1->identifier();
 
    // moving layer from multilayer
    model.moveItem(layer0, multilayer1, {"", 0});
 
    // checking results
    std::vector<SessionItem*> expected = {layer0};
    EXPECT_EQ(multilayer0->children().size(), 0);
    EXPECT_EQ(multilayer1->children(), expected);
    EXPECT_EQ(pool->item_for_key(id_layer0), layer0);
 
    // undoing
    stack->undo();
    EXPECT_EQ(multilayer0->children(), expected);
    EXPECT_EQ(multilayer1->children().size(), 0);
    EXPECT_EQ(pool->item_for_key(id_layer0), layer0);
}

References ModelView::SessionItem::children(), ModelView::SessionItem::identifier(), ModelView::SessionModel::insertItem(), ModelView::SessionModel::moveItem(), ModelView::SessionModel::setUndoRedoEnabled(), and ModelView::SessionModel::undoStack().

Here is the call graph for this function:

TEST_F() [16/21]

TEST_F	(	UndoStackTest	,
		multiLayer
	)

Create multilayer, add two layers, remove everything and undo.

Toy models are used here.

Definition at line 525 of file undostack.test.cpp.

{
    auto pool = std::make_shared<ItemPool>();
 
    ToyItems::SampleModel model(pool);
    model.setUndoRedoEnabled(true);
    auto stack = model.undoStack();
 
    // creating multi layer
    auto parent = model.insertItem<ToyItems::MultiLayerItem>();
    EXPECT_TRUE(dynamic_cast<ToyItems::MultiLayerItem*>(parent) != nullptr);
    EXPECT_EQ(parent->modelType(), ToyItems::Constants::MultiLayerItemType);
 
    // inserting two layers
    auto layer0 = model.insertItem<ToyItems::LayerItem>(parent);
    auto layer1 = model.insertItem<ToyItems::LayerItem>(parent);
 
    // saving identifiers for further reference
    identifier_type id_parent = parent->identifier();
    identifier_type id_layer0 = layer0->identifier();
    identifier_type id_layer1 = layer1->identifier();
 
    // checking status of unddo stack
    EXPECT_EQ(stack->count(), 3);
    EXPECT_EQ(stack->index(), 3);
 
    // removing multi layer completely
    model.removeItem(model.rootItem(), {"", 0});
    EXPECT_EQ(stack->count(), 4);
    EXPECT_EQ(stack->index(), 4);
    EXPECT_EQ(model.rootItem()->childrenCount(), 0);
 
    // multilayer and its two layers should gone from registration
    EXPECT_TRUE(pool->item_for_key(id_parent) == nullptr);
    EXPECT_TRUE(pool->item_for_key(id_layer0) == nullptr);
    EXPECT_TRUE(pool->item_for_key(id_layer1) == nullptr);
 
    // undoing multilayer removal
    stack->undo();
    EXPECT_EQ(stack->count(), 4);
    EXPECT_EQ(stack->index(), 3);
 
    // restoring pointers back
    auto parent_at = Utils::ChildAt(model.rootItem(), 0);
    auto layer0_at = Utils::ChildAt(parent_at, 0);
    auto layer1_at = Utils::ChildAt(parent_at, 1);
 
    // checking that restored item has corrrect identifiers
    EXPECT_EQ(parent_at->identifier(), id_parent);
    EXPECT_EQ(layer0_at->identifier(), id_layer0);
    EXPECT_EQ(layer1_at->identifier(), id_layer1);
 
    // checking tag
    EXPECT_EQ(layer0_at->tagRow().tag, ToyItems::MultiLayerItem::T_LAYERS);
    EXPECT_EQ(layer1_at->tagRow().tag, ToyItems::MultiLayerItem::T_LAYERS);
    std::vector<SessionItem*> expected = {layer0_at, layer1_at};
    EXPECT_EQ(parent_at->getItems(ToyItems::MultiLayerItem::T_LAYERS), expected);
}

References ModelView::Utils::ChildAt(), ModelView::SessionItem::childrenCount(), ModelView::SessionItem::identifier(), ModelView::SessionModel::insertItem(), ToyItems::Constants::MultiLayerItemType, ModelView::SessionModel::removeItem(), ModelView::SessionModel::rootItem(), ModelView::SessionModel::setUndoRedoEnabled(), ToyItems::MultiLayerItem::T_LAYERS, and ModelView::SessionModel::undoStack().

Here is the call graph for this function:

TEST_F() [17/21]

TEST_F	(	UndoStackTest	,
		removeParentAndChild
	)

Inserting parent and child, setting data to them, removing parent, undoing and checking.

Definition at line 450 of file undostack.test.cpp.

{
    const int role1(ItemDataRole::DATA), role2(ItemDataRole::DISPLAY);
    const QVariant data1(42);
    const QVariant data2 = QVariant::fromValue(std::string("abc"));
 
    SessionModel model;
    model.setUndoRedoEnabled(true);
    auto stack = model.undoStack();
 
    auto parent = model.insertItem<SessionItem>();
    parent->registerTag(TagInfo::universalTag("defaultTag"), /*set_as_default*/ true);
 
    parent->setData(data1, role1);
    auto child = model.insertItem<PropertyItem>(parent);
    child->setData(data2, role2);
 
    EXPECT_EQ(stack->count(), 4);
    EXPECT_EQ(stack->index(), 4);
 
    // removing parent
    model.removeItem(model.rootItem(), {"", 0});
    EXPECT_EQ(stack->count(), 5);
    EXPECT_EQ(stack->index(), 5);
    EXPECT_EQ(model.rootItem()->childrenCount(), 0);
 
    // undoing
    stack->undo();
    EXPECT_EQ(stack->count(), 5);
    EXPECT_EQ(stack->index(), 4);
    EXPECT_EQ(model.rootItem()->childrenCount(), 1);
    auto parent_at = Utils::ChildAt(model.rootItem(), 0);
    auto child_at = Utils::ChildAt(parent_at, 0);
 
    EXPECT_EQ(parent_at->modelType(), Constants::BaseType);
    EXPECT_EQ(child_at->modelType(), Constants::PropertyType);
 
    EXPECT_EQ(parent_at->data<QVariant>(role1), data1);
    EXPECT_EQ(child_at->data<QVariant>(role2), data2);
}

References ModelView::Constants::BaseType, ModelView::Utils::ChildAt(), ModelView::SessionItem::childrenCount(), ModelView::ItemDataRole::DATA, ModelView::ItemDataRole::DISPLAY, ModelView::SessionModel::insertItem(), ModelView::Constants::PropertyType, ModelView::SessionItem::registerTag(), ModelView::SessionModel::removeItem(), ModelView::SessionModel::rootItem(), ModelView::SessionItem::setData(), ModelView::SessionModel::setUndoRedoEnabled(), ModelView::SessionModel::undoStack(), and ModelView::TagInfo::universalTag().

Here is the call graph for this function:

TEST_F() [18/21]

TEST_F	(	UndoStackTest	,
		removeRow
	)

Inserting item, setting the data, removing row, undoing, checking item and data.

Definition at line 412 of file undostack.test.cpp.

{
    const int role = ItemDataRole::DATA;
    const QVariant data(42);
 
    SessionModel model;
    model.setUndoRedoEnabled(true);
    auto stack = model.undoStack();
 
    auto item = model.insertItem<SessionItem>();
    item->setData(data, role);
 
    // initial state before removing the row
    EXPECT_EQ(stack->count(), 2); // insert and setData commands
    EXPECT_EQ(stack->index(), 2); // insert and setData commands
    EXPECT_FALSE(model.undoStack()->canRedo());
    EXPECT_TRUE(model.undoStack()->canUndo());
    EXPECT_EQ(item->data<QVariant>(role), data);
    EXPECT_EQ(model.rootItem()->childrenCount(), 1);
 
    // removing the row
    model.removeItem(model.rootItem(), {"", 0});
    EXPECT_EQ(stack->count(), 3);
    EXPECT_EQ(stack->index(), 3);
    EXPECT_EQ(model.rootItem()->childrenCount(), 0);
 
    // undoing and checking the data
    stack->undo();
    EXPECT_EQ(stack->count(), 3);
    EXPECT_EQ(stack->index(), 2);
    EXPECT_EQ(model.rootItem()->childrenCount(), 1);
    item = Utils::ChildAt(model.rootItem(), 0);
    EXPECT_EQ(model.data(item, role).value<double>(), 42.0);
    EXPECT_EQ(item->modelType(), Constants::BaseType);
}

References ModelView::Constants::BaseType, ModelView::UndoStackInterface::canRedo(), ModelView::UndoStackInterface::canUndo(), ModelView::Utils::ChildAt(), ModelView::SessionItem::childrenCount(), ModelView::ItemDataRole::DATA, ModelView::SessionModel::data(), ModelView::SessionModel::insertItem(), ModelView::SessionModel::removeItem(), ModelView::SessionModel::rootItem(), ModelView::SessionItem::setData(), ModelView::SessionModel::setUndoRedoEnabled(), and ModelView::SessionModel::undoStack().

Here is the call graph for this function:

TEST_F() [19/21]

TEST_F	(	UndoStackTest	,
		setData
	)

Undo/redo scenario when item inserted and data set few times.

Definition at line 284 of file undostack.test.cpp.

{
    const int role = ItemDataRole::DATA;
    SessionModel model;
    model.setUndoRedoEnabled(true);
    auto stack = model.undoStack();
 
    // creating item
    auto item = model.insertItem<SessionItem>();
    EXPECT_FALSE(model.data(item, role).isValid());
 
    // setting new data
    QVariant value(42.0);
    model.setData(item, value, role);
    EXPECT_EQ(model.data(item, role), value);
 
    EXPECT_EQ(stack->index(), 2); // insert and setData commands
    EXPECT_FALSE(model.undoStack()->canRedo());
    EXPECT_TRUE(model.undoStack()->canUndo());
 
    // undoing and checking
    stack->undo();
    EXPECT_EQ(stack->index(), 1);
    EXPECT_FALSE(model.data(item, role).isValid());
 
    // setting data three times
    model.setData(item, QVariant::fromValue(42.0), role);
    model.setData(item, QVariant::fromValue(43.0), role);
    model.setData(item, QVariant::fromValue(44.0), role);
    EXPECT_EQ(stack->index(), 4);
    EXPECT_EQ(model.data(item, role).value<double>(), 44.0);
    stack->undo();
    stack->undo();
    EXPECT_EQ(model.data(item, role).value<double>(), 42.0);
    stack->redo();
    stack->redo();
    EXPECT_EQ(model.data(item, role).value<double>(), 44.0);
}

References ModelView::UndoStackInterface::canRedo(), ModelView::UndoStackInterface::canUndo(), ModelView::ItemDataRole::DATA, ModelView::SessionModel::data(), ModelView::SessionModel::insertItem(), ModelView::SessionModel::setData(), ModelView::SessionModel::setUndoRedoEnabled(), and ModelView::SessionModel::undoStack().

Here is the call graph for this function:

TEST_F() [20/21]

TEST_F	(	UndoStackTest	,
		setDataThroughItem
	)

Undo/redo scenario when item data changed through item and not the model.

Definition at line 325 of file undostack.test.cpp.

{
    const int role = ItemDataRole::DATA;
    const QVariant value(42.0);
 
    SessionModel model;
    model.setUndoRedoEnabled(true);
    auto stack = model.undoStack();
 
    // creating item
    auto item = model.insertItem<SessionItem>();
    EXPECT_FALSE(model.data(item, role).isValid());
 
    // setting new data through item (and not through model)
    item->setData(value, role);
    EXPECT_EQ(item->data<QVariant>(role), value);
 
    EXPECT_EQ(stack->index(), 2); // insert and setData commands
    EXPECT_FALSE(model.undoStack()->canRedo());
    EXPECT_TRUE(model.undoStack()->canUndo());
 
    // undoing and checking
    stack->undo();
    EXPECT_EQ(stack->index(), 1);
    EXPECT_FALSE(model.data(item, role).isValid());
}

References ModelView::UndoStackInterface::canRedo(), ModelView::UndoStackInterface::canUndo(), ModelView::ItemDataRole::DATA, ModelView::SessionModel::data(), ModelView::SessionModel::insertItem(), ModelView::SessionModel::setUndoRedoEnabled(), and ModelView::SessionModel::undoStack().

Here is the call graph for this function:

TEST_F() [21/21]

TEST_F	(	UndoStackTest	,
		setSameData
	)

Undo/redo scenario when we set same data. Undo stack should be empty.

Definition at line 354 of file undostack.test.cpp.

{
    SessionModel model;
    auto item = model.insertItem<PropertyItem>();
    item->setData(42.0);
 
    model.setUndoRedoEnabled(true);
    auto stack = model.undoStack();
    EXPECT_EQ(stack->index(), 0);
    EXPECT_FALSE(model.undoStack()->canRedo());
    EXPECT_FALSE(model.undoStack()->canUndo());
 
    // setting same data should not lead to appearance of command in a stack
    item->setData(42.0);
    EXPECT_EQ(stack->index(), 0);
    EXPECT_FALSE(model.undoStack()->canRedo());
    EXPECT_FALSE(model.undoStack()->canUndo());
}

References ModelView::UndoStackInterface::canRedo(), ModelView::UndoStackInterface::canUndo(), ModelView::SessionModel::insertItem(), ModelView::SessionItem::setData(), ModelView::SessionModel::setUndoRedoEnabled(), and ModelView::SessionModel::undoStack().

Here is the call graph for this function: