itemutils.test.cpp File Reference

Implements class CLASS? More...

Include dependency graph for itemutils.test.cpp:

Go to the source code of this file.

Classes
class	ItemUtilsTest

Functions
	TEST_F (ItemUtilsTest, CastedItems)
	TEST_F (ItemUtilsTest, FindNextItemToSelect)
	Looking for previous item. More...
	TEST_F (ItemUtilsTest, FindNextSibling)
	Looking for next item. More...
	TEST_F (ItemUtilsTest, FindPreviousSibling)
	Looking for previous item. More...
	TEST_F (ItemUtilsTest, HasTag)
	Checks method ::HasTag. More...
	TEST_F (ItemUtilsTest, IsItemAncestor)
	Looking for previous item. More...
	TEST_F (ItemUtilsTest, IsSinglePropertyTag)
	Checks method ::IsSinglePropertyTag. More...
	TEST_F (ItemUtilsTest, itemCopyNumber)
	Copy number of child in parents tree. More...
	TEST_F (ItemUtilsTest, iterateIfItem)
	Conditional iteration over item and its children. More...
	TEST_F (ItemUtilsTest, iterateItem)
	Simple iteration over item and its children. More...
	TEST_F (ItemUtilsTest, iterateModel)
	Iteration over root item of the model. More...
	TEST_F (ItemUtilsTest, RegisteredTags)
	Checks method ::RegisteredTags. More...
	TEST_F (ItemUtilsTest, RegisteredUniversalTags)
	Checks method ::RegisteredUniversalTags. More...
	TEST_F (ItemUtilsTest, SinglePropertyItems)
	Check access to top level and property items. More...
	TEST_F (ItemUtilsTest, TopLevelItems)
	Check access to top level and property items. More...
	TEST_F (ItemUtilsTest, UniqueItems)

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 itemutils.test.cpp.

Function Documentation

TEST_F() [1/16]

TEST_F	(	ItemUtilsTest	,
		CastedItems
	)

Definition at line 319 of file itemutils.test.cpp.

{
    SessionModel model;
    auto item0 = model.insertItem<SessionItem>(model.rootItem());
    auto item1 = model.insertItem<PropertyItem>(model.rootItem());
    auto item2 = model.insertItem<VectorItem>(model.rootItem());
    std::vector<SessionItem*> data = {nullptr, item0, item1, item2, item0, item1, item2, nullptr};
 
    EXPECT_EQ(Utils::CastedItems<PropertyItem>(data), std::vector<PropertyItem*>({item1, item1}));
}

References ModelView::SessionModel::insertItem(), and ModelView::SessionModel::rootItem().

Here is the call graph for this function:

TEST_F() [2/16]

TEST_F	(	ItemUtilsTest	,
		FindNextItemToSelect
	)

Looking for previous item.

Definition at line 265 of file itemutils.test.cpp.

{
    SessionModel model;
 
    auto parent = model.insertItem<SessionItem>();
    parent->registerTag(TagInfo::universalTag("default_tag"), /*set_as_default*/ true);
    parent->registerTag(TagInfo::propertyTag("property_tag", Constants::PropertyType));
 
    auto property = model.insertItem<PropertyItem>(parent, "property_tag");
    auto child0 = model.insertItem<SessionItem>(parent, "default_tag");
    auto child1 = model.insertItem<SessionItem>(parent, "default_tag");
    auto child2 = model.insertItem<SessionItem>(parent, "default_tag");
 
    EXPECT_EQ(Utils::FindNextItemToSelect(child0), child1);
    EXPECT_EQ(Utils::FindNextItemToSelect(child1), child2);
    EXPECT_EQ(Utils::FindNextItemToSelect(child2), child1);
    EXPECT_EQ(Utils::FindNextItemToSelect(property), parent);
    EXPECT_EQ(Utils::FindNextItemToSelect(parent), model.rootItem());
}

References ModelView::Utils::FindNextItemToSelect(), ModelView::SessionModel::insertItem(), ModelView::TagInfo::propertyTag(), ModelView::Constants::PropertyType, ModelView::SessionItem::registerTag(), ModelView::SessionModel::rootItem(), and ModelView::TagInfo::universalTag().

Here is the call graph for this function:

TEST_F() [3/16]

TEST_F	(	ItemUtilsTest	,
		FindNextSibling
	)

Looking for next item.

Definition at line 221 of file itemutils.test.cpp.

{
    SessionModel model;
 
    auto parent = model.insertItem<SessionItem>();
    parent->registerTag(TagInfo::universalTag("default_tag"), /*set_as_default*/ true);
    parent->registerTag(TagInfo::propertyTag("property_tag", Constants::PropertyType));
 
    auto property = model.insertItem<PropertyItem>(parent, "property_tag");
    auto child0 = model.insertItem<SessionItem>(parent, "default_tag");
    auto child1 = model.insertItem<SessionItem>(parent, "default_tag");
    auto child2 = model.insertItem<SessionItem>(parent, "default_tag");
 
    EXPECT_EQ(Utils::FindNextSibling(child0), child1);
    EXPECT_EQ(Utils::FindNextSibling(child1), child2);
    EXPECT_EQ(Utils::FindNextSibling(child2), nullptr);
    EXPECT_EQ(Utils::FindNextSibling(property), nullptr);
    EXPECT_EQ(Utils::FindNextSibling(parent), nullptr);
}

References ModelView::Utils::FindNextSibling(), ModelView::SessionModel::insertItem(), ModelView::TagInfo::propertyTag(), ModelView::Constants::PropertyType, ModelView::SessionItem::registerTag(), and ModelView::TagInfo::universalTag().

Here is the call graph for this function:

TEST_F() [4/16]

TEST_F	(	ItemUtilsTest	,
		FindPreviousSibling
	)

Looking for previous item.

Definition at line 243 of file itemutils.test.cpp.

{
    SessionModel model;
 
    auto parent = model.insertItem<SessionItem>();
    parent->registerTag(TagInfo::universalTag("default_tag"), /*set_as_default*/ true);
    parent->registerTag(TagInfo::propertyTag("property_tag", Constants::PropertyType));
 
    auto property = model.insertItem<PropertyItem>(parent, "property_tag");
    auto child0 = model.insertItem<SessionItem>(parent, "default_tag");
    auto child1 = model.insertItem<SessionItem>(parent, "default_tag");
    auto child2 = model.insertItem<SessionItem>(parent, "default_tag");
 
    EXPECT_EQ(Utils::FindPreviousSibling(child0), nullptr);
    EXPECT_EQ(Utils::FindPreviousSibling(child1), child0);
    EXPECT_EQ(Utils::FindPreviousSibling(child2), child1);
    EXPECT_EQ(Utils::FindPreviousSibling(property), nullptr);
    EXPECT_EQ(Utils::FindPreviousSibling(parent), nullptr);
}

References ModelView::Utils::FindPreviousSibling(), ModelView::SessionModel::insertItem(), ModelView::TagInfo::propertyTag(), ModelView::Constants::PropertyType, ModelView::SessionItem::registerTag(), and ModelView::TagInfo::universalTag().

Here is the call graph for this function:

TEST_F() [5/16]

TEST_F	(	ItemUtilsTest	,
		HasTag
	)

Checks method ::HasTag.

Definition at line 133 of file itemutils.test.cpp.

{
    SessionItem item;
    item.registerTag(TagInfo::universalTag("default_tag"), /*set_as_default*/ true);
 
    EXPECT_TRUE(Utils::HasTag(item, "default_tag"));
    EXPECT_FALSE(Utils::HasTag(item, "nonexisting_tag"));
}

References ModelView::Utils::HasTag(), ModelView::SessionItem::registerTag(), and ModelView::TagInfo::universalTag().

Here is the call graph for this function:

TEST_F() [6/16]

TEST_F	(	ItemUtilsTest	,
		IsItemAncestor
	)

Looking for previous item.

Definition at line 287 of file itemutils.test.cpp.

{
    SessionModel model;
    EXPECT_FALSE(Utils::IsItemAncestor(model.rootItem(), model.rootItem()));
 
    // rootItem in ancestor of vectorItem, but not vice versa
    auto vector_item = model.insertItem<VectorItem>();
    EXPECT_TRUE(Utils::IsItemAncestor(vector_item, model.rootItem()));
    EXPECT_FALSE(Utils::IsItemAncestor(model.rootItem(), vector_item));
 
    auto x_item = vector_item->getItem(VectorItem::P_X);
 
    EXPECT_TRUE(Utils::IsItemAncestor(x_item, model.rootItem()));
    EXPECT_TRUE(Utils::IsItemAncestor(x_item, vector_item));
    EXPECT_FALSE(Utils::IsItemAncestor(model.rootItem(), x_item));
    EXPECT_FALSE(Utils::IsItemAncestor(vector_item, x_item));
 
    auto y_item = vector_item->getItem(VectorItem::P_Y);
    EXPECT_FALSE(Utils::IsItemAncestor(x_item, y_item));
}

References ModelView::SessionModel::insertItem(), ModelView::Utils::IsItemAncestor(), ModelView::VectorItem::P_X, ModelView::VectorItem::P_Y, and ModelView::SessionModel::rootItem().

Here is the call graph for this function:

TEST_F() [7/16]

TEST_F	(	ItemUtilsTest	,
		IsSinglePropertyTag
	)

Checks method ::IsSinglePropertyTag.

Definition at line 144 of file itemutils.test.cpp.

{
    SessionItem item;
    item.registerTag(TagInfo::universalTag("default_tag"), /*set_as_default*/ true);
    item.registerTag(TagInfo::propertyTag("property_tag", Constants::PropertyType));
 
    EXPECT_FALSE(Utils::IsSinglePropertyTag(item, "default_tag"));
    EXPECT_TRUE(Utils::IsSinglePropertyTag(item, "property_tag"));
}

References ModelView::Utils::IsSinglePropertyTag(), ModelView::TagInfo::propertyTag(), ModelView::Constants::PropertyType, ModelView::SessionItem::registerTag(), and ModelView::TagInfo::universalTag().

Here is the call graph for this function:

TEST_F() [8/16]

TEST_F	(	ItemUtilsTest	,
		itemCopyNumber
	)

Copy number of child in parents tree.

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

{
    SessionModel model;
 
    auto parent = model.insertItem<SessionItem>();
    parent->registerTag(TagInfo::universalTag("defaultTag"), /*set_as_default*/ true);
 
    auto child1 = model.insertItem<SessionItem>(parent);
    auto child2 = model.insertItem<SessionItem>(parent);
    auto child3 = model.insertItem<PropertyItem>(parent);
 
    EXPECT_EQ(Utils::CopyNumber(child1), 0);
    EXPECT_EQ(Utils::CopyNumber(child2), 1);
    EXPECT_EQ(Utils::CopyNumber(child3), -1);
}

References ModelView::Utils::CopyNumber(), ModelView::SessionModel::insertItem(), ModelView::SessionItem::registerTag(), and ModelView::TagInfo::universalTag().

Here is the call graph for this function:

TEST_F() [9/16]

TEST_F	(	ItemUtilsTest	,
		iterateIfItem
	)

Conditional iteration over item and its children.

Definition at line 65 of file itemutils.test.cpp.

{
    std::vector<const SessionItem*> visited_items;
 
    // function which will not let iterate over children
    std::function<bool(const SessionItem*)> fun = [&](const SessionItem* item) {
        visited_items.push_back(item);
        return false;
    };
 
    // iteration over lonely parent
    std::unique_ptr<SessionItem> parent(new SessionItem);
    parent->registerTag(TagInfo::universalTag("defaultTag"), /*set_as_default*/ true);
 
    auto child1 = new SessionItem;
    auto child2 = new SessionItem;
    parent->insertItem(child1, TagRow::append());
    parent->insertItem(child2, TagRow::append());
 
    std::vector<const SessionItem*> expected = {parent.get()};
    Utils::iterate_if(parent.get(), fun);
    EXPECT_EQ(visited_items, expected);
}

References ModelView::TagRow::append(), ModelView::SessionItem::insertItem(), ModelView::Utils::iterate_if(), and ModelView::TagInfo::universalTag().

Here is the call graph for this function:

TEST_F() [10/16]

TEST_F	(	ItemUtilsTest	,
		iterateItem
	)

Simple iteration over item and its children.

Definition at line 32 of file itemutils.test.cpp.

{
    std::vector<const SessionItem*> visited_items;
 
    auto fun = [&](const SessionItem* item) { visited_items.push_back(item); };
 
    // iteration over nullptr
    Utils::iterate(nullptr, fun);
    EXPECT_TRUE(visited_items.empty());
 
    // iteration over lonely parent
    std::unique_ptr<SessionItem> parent(new SessionItem);
    parent->registerTag(TagInfo::universalTag("defaultTag"), /*set_as_default*/ true);
 
    std::vector<const SessionItem*> expected = {parent.get()};
    Utils::iterate(parent.get(), fun);
    EXPECT_EQ(visited_items, expected);
 
    // adding children
    auto child1 = new SessionItem;
    auto child2 = new SessionItem;
    parent->insertItem(child1, TagRow::append());
    parent->insertItem(child2, TagRow::append());
 
    visited_items.clear();
    Utils::iterate(parent.get(), fun);
 
    expected = {parent.get(), child1, child2};
    EXPECT_EQ(visited_items, expected);
}

References ModelView::TagRow::append(), ModelView::SessionItem::insertItem(), ModelView::Utils::iterate(), and ModelView::TagInfo::universalTag().

Here is the call graph for this function:

TEST_F() [11/16]

TEST_F	(	ItemUtilsTest	,
		iterateModel
	)

Iteration over root item of the model.

Definition at line 91 of file itemutils.test.cpp.

{
    SessionModel model;
 
    // building model
    auto parent1 = model.insertItem<SessionItem>();
    auto parent2 = model.insertItem<SessionItem>();
    parent1->registerTag(TagInfo::universalTag("defaultTag"), /*set_as_default*/ true);
    parent2->registerTag(TagInfo::universalTag("defaultTag"), /*set_as_default*/ true);
    auto child1 = model.insertItem<SessionItem>(parent1);
    auto child2 = model.insertItem<SessionItem>(parent1);
 
    std::vector<const SessionItem*> visited_items;
    auto fun = [&](const SessionItem* item) { visited_items.push_back(item); };
 
    // iteration
    Utils::iterate(model.rootItem(), fun);
 
    std::vector<const SessionItem*> expected = {model.rootItem(), parent1, child1, child2, parent2};
    EXPECT_EQ(visited_items, expected);
}

References ModelView::SessionModel::insertItem(), ModelView::Utils::iterate(), ModelView::SessionItem::registerTag(), ModelView::SessionModel::rootItem(), and ModelView::TagInfo::universalTag().

Here is the call graph for this function:

TEST_F() [12/16]

TEST_F	(	ItemUtilsTest	,
		RegisteredTags
	)

Checks method ::RegisteredTags.

Definition at line 156 of file itemutils.test.cpp.

{
    SessionItem item;
    EXPECT_TRUE(Utils::RegisteredTags(item).empty());
 
    item.registerTag(TagInfo::universalTag("default_tag"), /*set_as_default*/ true);
    item.registerTag(TagInfo::propertyTag("property_tag", Constants::PropertyType));
 
    EXPECT_EQ(Utils::RegisteredTags(item),
              std::vector<std::string>({"default_tag", "property_tag"}));
}

References ModelView::TagInfo::propertyTag(), ModelView::Constants::PropertyType, ModelView::Utils::RegisteredTags(), ModelView::SessionItem::registerTag(), and ModelView::TagInfo::universalTag().

Here is the call graph for this function:

TEST_F() [13/16]

TEST_F	(	ItemUtilsTest	,
		RegisteredUniversalTags
	)

Checks method ::RegisteredUniversalTags.

Definition at line 170 of file itemutils.test.cpp.

{
    SessionItem item;
    EXPECT_TRUE(Utils::RegisteredUniversalTags(item).empty());
 
    item.registerTag(TagInfo::universalTag("default_tag"), /*set_as_default*/ true);
    item.registerTag(TagInfo::propertyTag("property_tag", Constants::PropertyType));
 
    EXPECT_EQ(Utils::RegisteredUniversalTags(item), std::vector<std::string>({"default_tag"}));
}

References ModelView::TagInfo::propertyTag(), ModelView::Constants::PropertyType, ModelView::Utils::RegisteredUniversalTags(), ModelView::SessionItem::registerTag(), and ModelView::TagInfo::universalTag().

Here is the call graph for this function:

TEST_F() [14/16]

TEST_F	(	ItemUtilsTest	,
		SinglePropertyItems
	)

Check access to top level and property items.

Definition at line 202 of file itemutils.test.cpp.

{
    SessionModel model;
 
    auto parent = model.insertItem<SessionItem>();
    parent->registerTag(TagInfo::universalTag("default_tag"), /*set_as_default*/ true);
    parent->registerTag(TagInfo::propertyTag("property_tag", Constants::PropertyType));
 
    auto child1 = model.insertItem<SessionItem>(parent, "default_tag");
    auto child2 = model.insertItem<PropertyItem>(parent, "property_tag");
    model.insertItem<SessionItem>(parent, "default_tag");
 
    EXPECT_EQ(Utils::SinglePropertyItems(*model.rootItem()), std::vector<SessionItem*>({}));
    EXPECT_EQ(Utils::SinglePropertyItems(*child1), std::vector<SessionItem*>({}));
    EXPECT_EQ(Utils::SinglePropertyItems(*parent), std::vector<SessionItem*>({child2}));
}

References ModelView::SessionModel::insertItem(), ModelView::TagInfo::propertyTag(), ModelView::Constants::PropertyType, ModelView::SessionItem::registerTag(), ModelView::SessionModel::rootItem(), ModelView::Utils::SinglePropertyItems(), and ModelView::TagInfo::universalTag().

Here is the call graph for this function:

TEST_F() [15/16]

TEST_F	(	ItemUtilsTest	,
		TopLevelItems
	)

Check access to top level and property items.

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

{
    SessionModel model;
 
    auto parent = model.insertItem<SessionItem>();
    parent->registerTag(TagInfo::universalTag("default_tag"), /*set_as_default*/ true);
    parent->registerTag(TagInfo::propertyTag("property_tag", Constants::PropertyType));
 
    auto child1 = model.insertItem<SessionItem>(parent, "default_tag");
    model.insertItem<PropertyItem>(parent, "property_tag");
    auto child3 = model.insertItem<SessionItem>(parent, "default_tag");
 
    EXPECT_EQ(Utils::TopLevelItems(*model.rootItem()), std::vector<SessionItem*>({parent}));
    EXPECT_EQ(Utils::TopLevelItems(*child1), std::vector<SessionItem*>({}));
    EXPECT_EQ(Utils::TopLevelItems(*parent), std::vector<SessionItem*>({child1, child3}));
}

References ModelView::SessionModel::insertItem(), ModelView::TagInfo::propertyTag(), ModelView::Constants::PropertyType, ModelView::SessionItem::registerTag(), ModelView::SessionModel::rootItem(), ModelView::Utils::TopLevelItems(), and ModelView::TagInfo::universalTag().

Here is the call graph for this function:

TEST_F() [16/16]

TEST_F	(	ItemUtilsTest	,
		UniqueItems
	)

Definition at line 308 of file itemutils.test.cpp.

{
    SessionModel model;
    auto item0 = model.insertItem<SessionItem>(model.rootItem());
    auto item1 = model.insertItem<SessionItem>(model.rootItem());
    auto item2 = model.insertItem<SessionItem>(model.rootItem());
    std::vector<SessionItem*> data = {nullptr, item0, item1, item2, item0, item2, nullptr};
    std::vector<SessionItem*> expected = {item0, item1, item2};
    EXPECT_EQ(Utils::UniqueItems(data), expected);
}

References ModelView::SessionModel::insertItem(), ModelView::SessionModel::rootItem(), and ModelView::Utils::UniqueItems().

Here is the call graph for this function: