sessionitemcontainer.test.cpp File Reference

Implements class CLASS? More...

Include dependency graph for sessionitemcontainer.test.cpp:

Go to the source code of this file.

Classes
class	SessionItemContainerTest
	Tests for TestSessionItemContainer class. More...

Functions
	TEST_F (SessionItemContainerTest, canInsertItem)
	Checking ::canInsertItem. More...
	TEST_F (SessionItemContainerTest, canInsertItemForPropertyTag)
	Checking ::canInsertItem. More...
	TEST_F (SessionItemContainerTest, canTakeItem)
	Checking ::canTakeItem. More...
	TEST_F (SessionItemContainerTest, indexOfItem)
	Checking ::indexOfItem. More...
	TEST_F (SessionItemContainerTest, initialState)
	Initial state of emty SessionItemTag. More...
	TEST_F (SessionItemContainerTest, insertItem)
	Checking ::insertItem. More...
	TEST_F (SessionItemContainerTest, insertItemModelType)
	Checking ::insertItem when item has specific model type. More...
	TEST_F (SessionItemContainerTest, insertItemPropertyType)
	Checking ::insertItem when tag is related to property tag. More...
	TEST_F (SessionItemContainerTest, itemAt)
	Checking ::itemAt. More...
	TEST_F (SessionItemContainerTest, takeItem)
	Checking ::takeItem. More...
	TEST_F (SessionItemContainerTest, takeItemPropertyType)
	Checking ::takeItem when tag is related to property tag. 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 sessionitemcontainer.test.cpp.

Function Documentation

TEST_F() [1/11]

TEST_F	(	SessionItemContainerTest	,
		canInsertItem
	)

Checking ::canInsertItem.

Definition at line 239 of file sessionitemcontainer.test.cpp.

{
    const std::string tag_name("tag");
    const std::string model_type("model_a");
 
    SessionItemContainer tag(TagInfo::universalTag(tag_name));
 
    // inserting non-existing item
    EXPECT_FALSE(tag.canInsertItem(nullptr, 0));
 
    // we should be allowed to insert valid child
    auto child1 = std::make_unique<SessionItem>(model_type);
    EXPECT_TRUE(tag.canInsertItem(child1.get(), 0));
 
    // wrong index is not allowed for insertion
    EXPECT_FALSE(tag.canInsertItem(child1.get(), 1));
    EXPECT_FALSE(tag.canInsertItem(child1.get(), -1));
 
    // inserting child
    EXPECT_TRUE(tag.insertItem(child1.release(), tag.itemCount()));
 
    // can we insert second child?
    auto child2 = std::make_unique<SessionItem>(model_type);
    EXPECT_TRUE(tag.canInsertItem(child2.get(), 0));
    EXPECT_TRUE(tag.canInsertItem(child2.get(), 1));
    EXPECT_FALSE(tag.canInsertItem(child2.get(), 2));
    EXPECT_FALSE(tag.canInsertItem(child2.get(), -1));
}

References ModelView::SessionItemContainer::canInsertItem(), ModelView::SessionItemContainer::insertItem(), ModelView::SessionItemContainer::itemCount(), and ModelView::TagInfo::universalTag().

Here is the call graph for this function:

TEST_F() [2/11]

TEST_F	(	SessionItemContainerTest	,
		canInsertItemForPropertyTag
	)

Checking ::canInsertItem.

Definition at line 270 of file sessionitemcontainer.test.cpp.

{
    const std::string name("tag");
    const std::string property_type("Property");
 
    SessionItemContainer tag(TagInfo::propertyTag(name, property_type));
 
    // we should be allowed to insert valid child
    auto child1 = std::make_unique<SessionItem>(property_type);
    EXPECT_TRUE(tag.canInsertItem(child1.get(), 0));
 
    // inserting child
    EXPECT_TRUE(tag.insertItem(child1.release(), tag.itemCount()));
 
    // second property shouldn't be posible to insert because of exceeded maximum
    auto child2 = std::make_unique<SessionItem>(property_type);
    EXPECT_FALSE(tag.canInsertItem(child2.get(), 0));
}

References ModelView::SessionItemContainer::canInsertItem(), ModelView::SessionItemContainer::insertItem(), ModelView::SessionItemContainer::itemCount(), RealSpace::Particles::name(), and ModelView::TagInfo::propertyTag().

Here is the call graph for this function:

TEST_F() [3/11]

TEST_F	(	SessionItemContainerTest	,
		canTakeItem
	)

Checking ::canTakeItem.

Definition at line 217 of file sessionitemcontainer.test.cpp.

{
    const std::string tag_name("tag");
    const std::string model_type("model_a");
 
    SessionItemContainer tag(TagInfo::universalTag(tag_name));
 
    // taking non existing items
    EXPECT_FALSE(tag.canTakeItem(0));
 
    // inserting items
    SessionItem* child1 = new SessionItem(model_type);
    EXPECT_TRUE(tag.insertItem(child1, tag.itemCount()));
    EXPECT_TRUE(tag.canTakeItem(0));
 
    // taking non existing items
    EXPECT_FALSE(tag.canTakeItem(-1));
    EXPECT_FALSE(tag.canTakeItem(tag.itemCount()));
}

References ModelView::SessionItemContainer::canTakeItem(), ModelView::SessionItemContainer::insertItem(), ModelView::SessionItemContainer::itemCount(), and ModelView::TagInfo::universalTag().

Here is the call graph for this function:

TEST_F() [4/11]

TEST_F	(	SessionItemContainerTest	,
		indexOfItem
	)

Checking ::indexOfItem.

Definition at line 136 of file sessionitemcontainer.test.cpp.

{
    const std::string tag_name("tag");
    const std::string model_type("model_a");
 
    SessionItemContainer tag(TagInfo::universalTag(tag_name));
 
    // index of two items
    SessionItem* child1 = new SessionItem(model_type);
    SessionItem* child2 = new SessionItem(model_type);
    EXPECT_TRUE(tag.insertItem(child1, tag.itemCount()));
    EXPECT_EQ(tag.indexOfItem(child1), 0);
    EXPECT_TRUE(tag.insertItem(child2, tag.itemCount()));
    EXPECT_EQ(tag.indexOfItem(child1), 0);
    EXPECT_EQ(tag.indexOfItem(child2), 1);
 
    // not existing items
    EXPECT_EQ(tag.indexOfItem(nullptr), -1);
    auto child3 = std::make_unique<SessionItem>(model_type);
    EXPECT_EQ(tag.indexOfItem(child3.get()), -1);
}

References ModelView::SessionItemContainer::indexOfItem(), ModelView::SessionItemContainer::insertItem(), ModelView::SessionItemContainer::itemCount(), and ModelView::TagInfo::universalTag().

Here is the call graph for this function:

TEST_F() [5/11]

TEST_F	(	SessionItemContainerTest	,
		initialState
	)

Initial state of emty SessionItemTag.

Definition at line 33 of file sessionitemcontainer.test.cpp.

{
    const std::string name("tag");
    SessionItemContainer tag(TagInfo::universalTag(name));
 
    EXPECT_EQ(tag.itemCount(), 0);
    EXPECT_TRUE(tag.empty());
    EXPECT_EQ(tag.name(), name);
    EXPECT_EQ(tag.items(), std::vector<SessionItem*>());
}

References ModelView::SessionItemContainer::empty(), ModelView::SessionItemContainer::itemCount(), ModelView::SessionItemContainer::items(), ModelView::SessionItemContainer::name(), RealSpace::Particles::name(), and ModelView::TagInfo::universalTag().

Here is the call graph for this function:

TEST_F() [6/11]

TEST_F	(	SessionItemContainerTest	,
		insertItem
	)

Checking ::insertItem.

Definition at line 46 of file sessionitemcontainer.test.cpp.

{
    const std::string tag_name("tag");
    SessionItemContainer tag(TagInfo::universalTag(tag_name));
 
    // inserting non-existing item is not allowed
    EXPECT_FALSE(tag.insertItem(nullptr, tag.itemCount()));
    EXPECT_EQ(tag.itemCount(), 0);
 
    // insertion at the end
    SessionItem* child1 = new SessionItem;
    SessionItem* child2 = new SessionItem;
    EXPECT_TRUE(tag.insertItem(child1, tag.itemCount()));
    EXPECT_TRUE(tag.insertItem(child2, tag.itemCount()));
    EXPECT_EQ(tag.itemCount(), 2);
    EXPECT_FALSE(tag.empty());
    std::vector<SessionItem*> expected = {child1, child2};
    EXPECT_EQ(tag.items(), expected);
 
    // insertion at the beginning
    SessionItem* child3 = new SessionItem;
    EXPECT_TRUE(tag.insertItem(child3, 0));
    expected = {child3, child1, child2};
    EXPECT_EQ(tag.items(), expected);
 
    // insertion in between
    SessionItem* child4 = new SessionItem;
    EXPECT_TRUE(tag.insertItem(child4, 1));
    expected = {child3, child4, child1, child2};
    EXPECT_EQ(tag.items(), expected);
 
    // using index equal to number of items
    SessionItem* child5 = new SessionItem;
    EXPECT_TRUE(tag.insertItem(child5, tag.itemCount()));
    expected = {child3, child4, child1, child2, child5};
    EXPECT_EQ(tag.items(), expected);
 
    // insertion with wrong index
    SessionItem* child6 = new SessionItem;
    EXPECT_FALSE(tag.insertItem(child6, 42));
    EXPECT_EQ(tag.items(), expected);
    delete child6;
}

References ModelView::SessionItemContainer::empty(), ModelView::SessionItemContainer::insertItem(), ModelView::SessionItemContainer::itemCount(), ModelView::SessionItemContainer::items(), and ModelView::TagInfo::universalTag().

Here is the call graph for this function:

TEST_F() [7/11]

TEST_F	(	SessionItemContainerTest	,
		insertItemModelType
	)

Checking ::insertItem when item has specific model type.

Definition at line 92 of file sessionitemcontainer.test.cpp.

{
    const std::string tag_name("tag");
    const std::vector<std::string> model_types = {"model_a"};
 
    SessionItemContainer tag(TagInfo::universalTag(tag_name, model_types));
 
    // insertion of wrong model type is not allowed
    SessionItem* child1 = new SessionItem("model_a");
    SessionItem* child2 = new SessionItem("model_b");
    EXPECT_TRUE(tag.insertItem(child1, tag.itemCount()));
    EXPECT_FALSE(tag.insertItem(child2, tag.itemCount()));
    delete child2;
 
    std::vector<SessionItem*> expected = {child1};
    EXPECT_EQ(tag.items(), expected);
}

References ModelView::SessionItemContainer::insertItem(), ModelView::SessionItemContainer::itemCount(), ModelView::SessionItemContainer::items(), and ModelView::TagInfo::universalTag().

Here is the call graph for this function:

TEST_F() [8/11]

TEST_F	(	SessionItemContainerTest	,
		insertItemPropertyType
	)

Checking ::insertItem when tag is related to property tag.

Definition at line 112 of file sessionitemcontainer.test.cpp.

{
    const std::string name("tag");
    const std::string property_type("Property");
 
    SessionItemContainer tag(TagInfo::propertyTag(name, property_type));
 
    // insertion of second property item is not allowed (because of reached maximum)
    SessionItem* child1 = new SessionItem(property_type);
    SessionItem* child2 = new SessionItem(property_type);
    EXPECT_TRUE(tag.insertItem(child1, tag.itemCount()));
    EXPECT_FALSE(tag.insertItem(child2, tag.itemCount()));
    delete child2;
 
    // insertion of wrong model type is not allowed
    SessionItem* child3 = new SessionItem("another_model");
    EXPECT_FALSE(tag.insertItem(child3, tag.itemCount()));
    delete child3;
    std::vector<SessionItem*> expected = {child1};
    EXPECT_EQ(tag.items(), expected);
}

References ModelView::SessionItemContainer::insertItem(), ModelView::SessionItemContainer::itemCount(), ModelView::SessionItemContainer::items(), RealSpace::Particles::name(), and ModelView::TagInfo::propertyTag().

Here is the call graph for this function:

TEST_F() [9/11]

TEST_F	(	SessionItemContainerTest	,
		itemAt
	)

Checking ::itemAt.

Definition at line 160 of file sessionitemcontainer.test.cpp.

{
    const std::string tag_name("tag");
    const std::string model_type("model_a");
 
    SessionItemContainer tag(TagInfo::universalTag(tag_name));
 
    // items at given indices
    SessionItem* child1 = new SessionItem(model_type);
    SessionItem* child2 = new SessionItem(model_type);
    EXPECT_TRUE(tag.insertItem(child1, tag.itemCount()));
    EXPECT_TRUE(tag.insertItem(child2, tag.itemCount()));
    EXPECT_EQ(tag.itemAt(0), child1);
    EXPECT_EQ(tag.itemAt(1), child2);
 
    // non-existing indices
    EXPECT_EQ(tag.itemAt(2), nullptr);
    EXPECT_EQ(tag.itemAt(3), nullptr);
    EXPECT_EQ(tag.itemAt(-1), nullptr);
}

References ModelView::SessionItemContainer::insertItem(), ModelView::SessionItemContainer::itemAt(), ModelView::SessionItemContainer::itemCount(), and ModelView::TagInfo::universalTag().

Here is the call graph for this function:

TEST_F() [10/11]

TEST_F	(	SessionItemContainerTest	,
		takeItem
	)

Checking ::takeItem.

Definition at line 183 of file sessionitemcontainer.test.cpp.

{
    const std::string tag_name("tag");
    const std::string model_type("model_a");
 
    SessionItemContainer tag(TagInfo::universalTag(tag_name));
 
    // taking non existing items
    EXPECT_EQ(tag.takeItem(0), nullptr);
 
    // inserting items
    SessionItem* child1 = new SessionItem(model_type);
    SessionItem* child2 = new SessionItem(model_type);
    SessionItem* child3 = new SessionItem(model_type);
    EXPECT_TRUE(tag.insertItem(child1, tag.itemCount()));
    EXPECT_TRUE(tag.insertItem(child2, tag.itemCount()));
    EXPECT_TRUE(tag.insertItem(child3, tag.itemCount()));
 
    // taking item in between
    auto taken2 = tag.takeItem(1);
    EXPECT_EQ(child2, taken2);
    delete taken2;
 
    // order of remaining children
    std::vector<SessionItem*> expected = {child1, child3};
    EXPECT_EQ(tag.items(), expected);
 
    // taking non existing items
    EXPECT_EQ(tag.takeItem(-1), nullptr);
    EXPECT_EQ(tag.takeItem(tag.itemCount()), nullptr);
}

References ModelView::SessionItemContainer::insertItem(), ModelView::SessionItemContainer::itemCount(), ModelView::SessionItemContainer::items(), ModelView::SessionItemContainer::takeItem(), and ModelView::TagInfo::universalTag().

Here is the call graph for this function:

TEST_F() [11/11]

TEST_F	(	SessionItemContainerTest	,
		takeItemPropertyType
	)

Checking ::takeItem when tag is related to property tag.

Definition at line 291 of file sessionitemcontainer.test.cpp.

{
    const std::string name("tag");
    const std::string property_type("Property");
 
    SessionItemContainer tag(TagInfo::propertyTag(name, property_type));
 
    // insertion of second property item is not allowed (because of reached maximum)
    SessionItem* child1 = new SessionItem(property_type);
    EXPECT_TRUE(tag.insertItem(child1, tag.itemCount()));
 
    // attempt to take property item
    EXPECT_FALSE(tag.canTakeItem(0));
    EXPECT_EQ(tag.takeItem(0), nullptr);
}

References ModelView::SessionItemContainer::canTakeItem(), ModelView::SessionItemContainer::insertItem(), ModelView::SessionItemContainer::itemCount(), RealSpace::Particles::name(), ModelView::TagInfo::propertyTag(), and ModelView::SessionItemContainer::takeItem().

Here is the call graph for this function: