itemcatalogue.test.cpp File Reference

Implements class CLASS? More...

Include dependency graph for itemcatalogue.test.cpp:

Go to the source code of this file.

Classes
class	ItemCatalogueTest
	Testing ItemCatalogue construction. More...

Functions
	TEST_F (ItemCatalogueTest, addItem)
	TEST_F (ItemCatalogueTest, addLabeledItem)
	TEST_F (ItemCatalogueTest, assignmentOperator)
	TEST_F (ItemCatalogueTest, contains)
	TEST_F (ItemCatalogueTest, copyConstructor)
	TEST_F (ItemCatalogueTest, defaultItemCatalogue)
	TEST_F (ItemCatalogueTest, initialState)
	TEST_F (ItemCatalogueTest, merge)

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

Function Documentation

TEST_F() [1/8]

TEST_F	(	ItemCatalogueTest	,
		addItem
	)

Definition at line 41 of file itemcatalogue.test.cpp.

{
    ItemCatalogue catalogue;
 
    catalogue.registerItem<PropertyItem>();
 
    EXPECT_EQ(catalogue.itemCount(), 1);
 
    auto item = catalogue.create(Constants::PropertyType);
    EXPECT_TRUE(dynamic_cast<PropertyItem*>(item.get()) != nullptr);
 
    // registration of second item is not allowed
    EXPECT_THROW(catalogue.registerItem<PropertyItem>(), std::runtime_error);
 
    // item was not registered, creation not allowed
    EXPECT_THROW(catalogue.create("non-registered"), std::runtime_error);
 
    // checking model types and labels
    EXPECT_EQ(catalogue.modelTypes(), std::vector<std::string>({"Property"}));
    EXPECT_EQ(catalogue.labels(), std::vector<std::string>({""}));
}

References ModelView::ItemCatalogue::create(), ModelView::ItemCatalogue::itemCount(), ModelView::ItemCatalogue::labels(), ModelView::ItemCatalogue::modelTypes(), ModelView::Constants::PropertyType, and ModelView::ItemCatalogue::registerItem().

Here is the call graph for this function:

TEST_F() [2/8]

TEST_F	(	ItemCatalogueTest	,
		addLabeledItem
	)

Definition at line 134 of file itemcatalogue.test.cpp.

{
    ItemCatalogue catalogue;
    catalogue.registerItem<PropertyItem>("property");
    catalogue.registerItem<VectorItem>("vector item");
 
    // checking model types and labels
    EXPECT_EQ(catalogue.modelTypes(), std::vector<std::string>({"Property", "Vector"}));
    EXPECT_EQ(catalogue.labels(), std::vector<std::string>({"property", "vector item"}));
}

References ModelView::ItemCatalogue::labels(), ModelView::ItemCatalogue::modelTypes(), and ModelView::ItemCatalogue::registerItem().

Here is the call graph for this function:

TEST_F() [3/8]

TEST_F	(	ItemCatalogueTest	,
		assignmentOperator
	)

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

{
    ItemCatalogue catalogue;
    catalogue.registerItem<PropertyItem>();
 
    ItemCatalogue copy;
    copy = catalogue;
 
    // creation of item using first catalogue
    auto item = catalogue.create(Constants::PropertyType);
    EXPECT_TRUE(dynamic_cast<PropertyItem*>(item.get()) != nullptr);
 
    // creation of item using catalogue copy
    item = copy.create(Constants::PropertyType);
    EXPECT_TRUE(dynamic_cast<PropertyItem*>(item.get()) != nullptr);
}

References ModelView::copy, ModelView::ItemCatalogue::create(), ModelView::Constants::PropertyType, and ModelView::ItemCatalogue::registerItem().

Here is the call graph for this function:

TEST_F() [4/8]

TEST_F	(	ItemCatalogueTest	,
		contains
	)

Definition at line 108 of file itemcatalogue.test.cpp.

{
    ItemCatalogue catalogue;
    catalogue.registerItem<PropertyItem>();
 
    EXPECT_TRUE(catalogue.contains(Constants::PropertyType));
    EXPECT_FALSE(catalogue.contains(Constants::VectorItemType));
}

References ModelView::ItemCatalogue::contains(), ModelView::Constants::PropertyType, ModelView::ItemCatalogue::registerItem(), and ModelView::Constants::VectorItemType.

Here is the call graph for this function:

TEST_F() [5/8]

TEST_F	(	ItemCatalogueTest	,
		copyConstructor
	)

Definition at line 63 of file itemcatalogue.test.cpp.

{
    ItemCatalogue catalogue;
    catalogue.registerItem<PropertyItem>();
 
    ItemCatalogue copy(catalogue);
 
    // creation of item using first catalogue
    auto item = catalogue.create(Constants::PropertyType);
    EXPECT_TRUE(dynamic_cast<PropertyItem*>(item.get()) != nullptr);
 
    // creation of item using catalogue copy
    item = copy.create(Constants::PropertyType);
    EXPECT_TRUE(dynamic_cast<PropertyItem*>(item.get()) != nullptr);
 
    // checking model types and labels in new catalogue
    EXPECT_EQ(copy.modelTypes(), std::vector<std::string>({"Property"}));
    EXPECT_EQ(copy.labels(), std::vector<std::string>({""}));
 
    // adding item to first catalogue but not the second
    catalogue.registerItem<VectorItem>();
    item = catalogue.create(Constants::VectorItemType);
    EXPECT_TRUE(dynamic_cast<VectorItem*>(item.get()) != nullptr);
 
    // copy of catalogue knows nothing about new VectorType
    EXPECT_THROW(copy.create(Constants::VectorItemType), std::runtime_error);
}

References ModelView::copy, ModelView::ItemCatalogue::create(), ModelView::Constants::PropertyType, ModelView::ItemCatalogue::registerItem(), and ModelView::Constants::VectorItemType.

Here is the call graph for this function:

TEST_F() [6/8]

TEST_F	(	ItemCatalogueTest	,
		defaultItemCatalogue
	)

Definition at line 117 of file itemcatalogue.test.cpp.

{
    auto catalogue = CreateStandardItemCatalogue();
 
    auto item = catalogue->create(Constants::BaseType);
    EXPECT_TRUE(dynamic_cast<SessionItem*>(item.get()) != nullptr);
 
    item = catalogue->create(Constants::PropertyType);
    EXPECT_TRUE(dynamic_cast<PropertyItem*>(item.get()) != nullptr);
 
    item = catalogue->create(Constants::VectorItemType);
    EXPECT_TRUE(dynamic_cast<VectorItem*>(item.get()) != nullptr);
 
    item = catalogue->create(Constants::CompoundItemType);
    EXPECT_TRUE(dynamic_cast<CompoundItem*>(item.get()) != nullptr);
}

References ModelView::Constants::BaseType, ModelView::Constants::CompoundItemType, ModelView::CreateStandardItemCatalogue(), ModelView::Constants::PropertyType, and ModelView::Constants::VectorItemType.

Here is the call graph for this function:

TEST_F() [7/8]

TEST_F	(	ItemCatalogueTest	,
		initialState
	)

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

{
    ItemCatalogue catalogue;
    EXPECT_EQ(catalogue.itemCount(), 0);
    EXPECT_EQ(catalogue.modelTypes(), std::vector<std::string>({}));
    EXPECT_EQ(catalogue.labels(), std::vector<std::string>({}));
}

References ModelView::ItemCatalogue::itemCount(), ModelView::ItemCatalogue::labels(), and ModelView::ItemCatalogue::modelTypes().

Here is the call graph for this function:

TEST_F() [8/8]

TEST_F	(	ItemCatalogueTest	,
		merge
	)

Definition at line 145 of file itemcatalogue.test.cpp.

{
    ItemCatalogue catalogue1;
    catalogue1.registerItem<PropertyItem>("property");
    catalogue1.registerItem<VectorItem>("vector");
 
    ItemCatalogue catalogue2;
    catalogue2.registerItem<CompoundItem>("compound");
 
    // adding two catalogue together
    catalogue1.merge(catalogue2);
 
    std::vector<std::string> expected_models = {Constants::PropertyType, Constants::VectorItemType,
                                                Constants::CompoundItemType};
    std::vector<std::string> expected_labels = {"property", "vector", "compound"};
 
    EXPECT_EQ(catalogue1.modelTypes(), expected_models);
    EXPECT_EQ(catalogue1.labels(), expected_labels);
 
    auto item = catalogue1.create(Constants::VectorItemType);
    EXPECT_TRUE(dynamic_cast<VectorItem*>(item.get()) != nullptr);
 
    // duplications is not allowed
    EXPECT_THROW(catalogue1.merge(catalogue2), std::runtime_error);
}

References ModelView::Constants::CompoundItemType, ModelView::ItemCatalogue::create(), ModelView::ItemCatalogue::labels(), ModelView::ItemCatalogue::merge(), ModelView::ItemCatalogue::modelTypes(), ModelView::Constants::PropertyType, ModelView::ItemCatalogue::registerItem(), and ModelView::Constants::VectorItemType.

Here is the call graph for this function: