comboproperty.test.cpp File Reference

Implements class CLASS? More...

Include dependency graph for comboproperty.test.cpp:

Go to the source code of this file.

Classes
class	ComboPropertyTest

Functions
	TEST_F (ComboPropertyTest, comboEqualityDiffIndex)
	TEST_F (ComboPropertyTest, comboEqualityDiffList)
	TEST_F (ComboPropertyTest, createFrom)
	TEST_F (ComboPropertyTest, fromStream)
	TEST_F (ComboPropertyTest, fromVectorStream)
	TEST_F (ComboPropertyTest, initialState)
	TEST_F (ComboPropertyTest, setCurrentIndex)
	TEST_F (ComboPropertyTest, setSelected)
	TEST_F (ComboPropertyTest, setSringOfValues)
	TEST_F (ComboPropertyTest, setStringOfSelections)
	TEST_F (ComboPropertyTest, setValue)
	TEST_F (ComboPropertyTest, setValues)
	TEST_F (ComboPropertyTest, variantEqualityDiffIndex)
	Check equality of ComboProperty's variants when only selected item differs. More...
	TEST_F (ComboPropertyTest, variantEqualityDiffLists)
	Check equality of ComboProperty's variants. 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 comboproperty.test.cpp.

Function Documentation

TEST_F() [1/14]

TEST_F	(	ComboPropertyTest	,
		comboEqualityDiffIndex
	)

Definition at line 303 of file comboproperty.test.cpp.

{
    ComboProperty c1 = ComboProperty::createFrom({"a1", "a2"});
    ComboProperty c2 = ComboProperty::createFrom({"a1", "a2"});
 
    c1.setValue("a1");
    c2.setValue("a2");
    EXPECT_TRUE(c1 != c2);
 
    c2.setValue("a1");
    EXPECT_TRUE(c1 == c2);
}

References ModelView::ComboProperty::createFrom(), and ModelView::ComboProperty::setValue().

Here is the call graph for this function:

TEST_F() [2/14]

TEST_F	(	ComboPropertyTest	,
		comboEqualityDiffList
	)

Definition at line 316 of file comboproperty.test.cpp.

{
    ComboProperty c1;
    ComboProperty c2;
    EXPECT_TRUE(c1 == c2);
 
    c1 << "a1"
       << "a2";
    c2 << "a1"
       << "a2";
    EXPECT_TRUE(c1 == c2);
    EXPECT_FALSE(c1 != c2);
 
    c2 << "a3";
    EXPECT_TRUE(c1 != c2);
    EXPECT_FALSE(c1 == c2);
    c2.setValue("a2");
    EXPECT_TRUE(c1 != c2);
    EXPECT_FALSE(c1 == c2);
 
    c1 << "a3";
    c1.setValue("a2");
    EXPECT_TRUE(c1 == c2);
    EXPECT_FALSE(c1 != c2);
 
    // with selection indices
    c1 = ComboProperty() << "a1"
                         << "a2"
                         << "a3";
    c2 = ComboProperty() << "a1"
                         << "a2"
                         << "a3";
    EXPECT_TRUE(c1 == c2);
 
    c2.setSelected(0, false);
    c2.setSelected(2, true);
    EXPECT_TRUE(c1 != c2);
 
    c1.setStringOfSelections("2");
    c2.setStringOfSelections("2");
    EXPECT_TRUE(c1 == c2);
}

References ModelView::ComboProperty::setSelected(), ModelView::ComboProperty::setStringOfSelections(), and ModelView::ComboProperty::setValue().

Here is the call graph for this function:

TEST_F() [3/14]

TEST_F	(	ComboPropertyTest	,
		createFrom
	)

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

{
    // from vector of values, first item should be selected
    std::vector<std::string> expected{"a1", "a2"};
    ComboProperty combo = ComboProperty::createFrom(expected);
    EXPECT_EQ(combo.values(), expected);
    EXPECT_EQ(combo.currentIndex(), 0);
    EXPECT_EQ(combo.value(), "a1");
    EXPECT_EQ(combo.selectedIndices(), std::vector<int>({0}));
 
    // from vector of values, selection provided
    expected = {"b1", "b2", "b3"};
    combo = ComboProperty::createFrom(expected, "b2");
    EXPECT_EQ(combo.values(), expected);
    EXPECT_EQ(combo.currentIndex(), 1);
    EXPECT_EQ(combo.value(), "b2");
    EXPECT_EQ(combo.selectedIndices(), std::vector<int>({1}));
}

References ModelView::ComboProperty::createFrom(), ModelView::ComboProperty::currentIndex(), ModelView::ComboProperty::selectedIndices(), ModelView::ComboProperty::value(), and ModelView::ComboProperty::values().

Here is the call graph for this function:

TEST_F() [4/14]

TEST_F	(	ComboPropertyTest	,
		fromStream
	)

Definition at line 189 of file comboproperty.test.cpp.

{
    ComboProperty combo = ComboProperty() << "a1"
                                          << "a2";
    std::vector<std::string> expected{"a1", "a2"};
    EXPECT_EQ(combo.values(), expected);
    EXPECT_EQ(combo.currentIndex(), 0);
    EXPECT_EQ(combo.value(), "a1");
    EXPECT_EQ(combo.selectedIndices(), std::vector<int>({0}));
 
    // adding more
    combo << "c0";
    expected = {"a1", "a2", "c0"};
    EXPECT_EQ(combo.values(), expected);
    EXPECT_EQ(combo.currentIndex(), 0);
    EXPECT_EQ(combo.value(), "a1");
    EXPECT_EQ(combo.selectedIndices(), std::vector<int>({0}));
 
    // setting another index, adding more, state should be preserved
    combo.setCurrentIndex(1);
    combo.setSelected(2, true);
    EXPECT_EQ(combo.values(), expected);
    EXPECT_EQ(combo.currentIndex(), 1);
    EXPECT_EQ(combo.value(), "a2");
    EXPECT_EQ(combo.selectedIndices(), std::vector<int>({1, 2}));
    combo << "c1";
    expected = {"a1", "a2", "c0", "c1"};
    EXPECT_EQ(combo.values(), expected);
    EXPECT_EQ(combo.currentIndex(), 1);
}

References ModelView::ComboProperty::currentIndex(), ModelView::ComboProperty::selectedIndices(), ModelView::ComboProperty::setCurrentIndex(), ModelView::ComboProperty::setSelected(), ModelView::ComboProperty::value(), and ModelView::ComboProperty::values().

Here is the call graph for this function:

TEST_F() [5/14]

TEST_F	(	ComboPropertyTest	,
		fromVectorStream
	)

Definition at line 220 of file comboproperty.test.cpp.

{
    std::vector<std::string> expected{"a1", "a2"};
    ComboProperty combo = ComboProperty::createFrom(expected);
    combo.setSelected(0, true);
    combo.setSelected(1, true);
 
    EXPECT_EQ(combo.values(), expected);
    EXPECT_EQ(combo.currentIndex(), 0);
    EXPECT_EQ(combo.value(), "a1");
    EXPECT_EQ(combo.selectedIndices(), std::vector<int>({0, 1}));
 
    // adding from vector stream, old selection state should be preserved
    std::vector<std::string> more{"c1", "c2"};
    combo << more;
    expected = {"a1", "a2", "c1", "c2"};
    EXPECT_EQ(combo.values(), expected);
    EXPECT_EQ(combo.currentIndex(), 0);
    EXPECT_EQ(combo.value(), "a1");
    EXPECT_EQ(combo.selectedIndices(), std::vector<int>({0, 1}));
}

References ModelView::ComboProperty::createFrom(), ModelView::ComboProperty::currentIndex(), ModelView::ComboProperty::selectedIndices(), ModelView::ComboProperty::setSelected(), ModelView::ComboProperty::value(), and ModelView::ComboProperty::values().

Here is the call graph for this function:

TEST_F() [6/14]

TEST_F	(	ComboPropertyTest	,
		initialState
	)

Definition at line 29 of file comboproperty.test.cpp.

{
    ComboProperty combo;
    EXPECT_EQ(combo.value(), "");
    EXPECT_EQ(combo.values(), std::vector<std::string>());
    EXPECT_EQ(combo.toolTips(), std::vector<std::string>());
    EXPECT_EQ(combo.currentIndex(), -1);
    EXPECT_EQ(combo.stringOfValues(), "");
    EXPECT_EQ(combo.selectedIndices(), std::vector<int>());
    EXPECT_EQ(combo.label(), "None");
}

References ModelView::ComboProperty::currentIndex(), ModelView::ComboProperty::label(), ModelView::ComboProperty::selectedIndices(), ModelView::ComboProperty::stringOfValues(), ModelView::ComboProperty::toolTips(), ModelView::ComboProperty::value(), and ModelView::ComboProperty::values().

Here is the call graph for this function:

TEST_F() [7/14]

TEST_F	(	ComboPropertyTest	,
		setCurrentIndex
	)

Definition at line 80 of file comboproperty.test.cpp.

{
    std::vector<std::string> expected{"c1", "c2", "c3"};
    ComboProperty combo = ComboProperty::createFrom(expected);
 
    EXPECT_EQ(combo.currentIndex(), 0);
    EXPECT_EQ(combo.selectedIndices(), std::vector<int>({0}));
    EXPECT_EQ(combo.values(), expected);
 
    combo.setCurrentIndex(1);
    EXPECT_EQ(combo.value(), std::string("c2"));
    EXPECT_EQ(combo.selectedIndices(), std::vector<int>({1}));
 
    // setting unexpected index
    EXPECT_THROW(combo.setCurrentIndex(3), std::runtime_error);
    EXPECT_EQ(combo.value(), std::string("c2"));
    EXPECT_EQ(combo.selectedIndices(), std::vector<int>({1}));
}

References ModelView::ComboProperty::createFrom(), ModelView::ComboProperty::currentIndex(), ModelView::ComboProperty::selectedIndices(), ModelView::ComboProperty::setCurrentIndex(), ModelView::ComboProperty::value(), and ModelView::ComboProperty::values().

Here is the call graph for this function:

TEST_F() [8/14]

TEST_F	(	ComboPropertyTest	,
		setSelected
	)

Definition at line 135 of file comboproperty.test.cpp.

{
    std::vector<std::string> expectedValues = {"a1", "a2", "a3"};
    ComboProperty combo = ComboProperty::createFrom(expectedValues);
 
    EXPECT_EQ(combo.currentIndex(), 0);
    EXPECT_EQ(combo.value(), "a1");
    EXPECT_EQ(combo.values(), expectedValues);
    EXPECT_EQ(combo.selectedIndices(), std::vector<int>({0}));
    EXPECT_EQ(combo.selectedValues(), std::vector<std::string>({"a1"}));
 
    // selecting already selected element, nothing should change
    combo.setSelected(0);
    EXPECT_EQ(combo.currentIndex(), 0);
    EXPECT_EQ(combo.value(), "a1");
    EXPECT_EQ(combo.values(), expectedValues);
    EXPECT_EQ(combo.selectedIndices(), std::vector<int>({0}));
    EXPECT_EQ(combo.selectedValues(), std::vector<std::string>({"a1"}));
 
    // deselecting index
    combo.setSelected(0, false);
    EXPECT_EQ(combo.currentIndex(), -1);
    EXPECT_EQ(combo.value(), "");
    EXPECT_EQ(combo.values(), expectedValues);
    EXPECT_EQ(combo.selectedIndices(), std::vector<int>());
    EXPECT_EQ(combo.selectedValues(), std::vector<std::string>());
 
    // selecting two indeces
    combo.setSelected(1, true);
    combo.setSelected(2, true);
    EXPECT_EQ(combo.currentIndex(), 1);
    EXPECT_EQ(combo.value(), "a2");
    EXPECT_EQ(combo.values(), expectedValues);
    EXPECT_EQ(combo.selectedIndices(), std::vector<int>({1, 2}));
    EXPECT_EQ(combo.selectedValues(), std::vector<std::string>({"a2", "a3"}));
 
    // selecting by name
    combo.setSelected("a2", false);
    combo.setSelected("a1", true);
    EXPECT_EQ(combo.currentIndex(), 0);
    EXPECT_EQ(combo.value(), "a1");
    EXPECT_EQ(combo.values(), expectedValues);
    EXPECT_EQ(combo.selectedIndices(), std::vector<int>({0, 2}));
    EXPECT_EQ(combo.selectedValues(), std::vector<std::string>({"a1", "a3"}));
 
    // setting current index invalidates selection
    combo.setCurrentIndex(1);
    EXPECT_EQ(combo.currentIndex(), 1);
    EXPECT_EQ(combo.value(), "a2");
    EXPECT_EQ(combo.values(), expectedValues);
    EXPECT_EQ(combo.selectedIndices(), std::vector<int>({1}));
    EXPECT_EQ(combo.selectedValues(), std::vector<std::string>({"a2"}));
}

References ModelView::ComboProperty::createFrom(), ModelView::ComboProperty::currentIndex(), ModelView::ComboProperty::selectedIndices(), ModelView::ComboProperty::selectedValues(), ModelView::ComboProperty::setCurrentIndex(), ModelView::ComboProperty::setSelected(), ModelView::ComboProperty::value(), and ModelView::ComboProperty::values().

Here is the call graph for this function:

TEST_F() [9/14]

TEST_F	(	ComboPropertyTest	,
		setSringOfValues
	)

Definition at line 242 of file comboproperty.test.cpp.

{
    std::vector<std::string> expectedValues = {"a1", "a2"};
    ComboProperty combo = ComboProperty::createFrom(expectedValues);
 
    EXPECT_EQ(combo.stringOfValues(), std::string("a1;a2"));
    EXPECT_EQ(combo.value(), std::string("a1"));
    EXPECT_EQ(combo.currentIndex(), 0);
    EXPECT_EQ(combo.selectedIndices(), std::vector<int>({0}));
 
    // setting string of values, current value should change
    std::string stringOfValues("b1;b2;b3");
    combo.setStringOfValues(stringOfValues);
    EXPECT_EQ(combo.stringOfValues(), stringOfValues);
    EXPECT_EQ(combo.value(), std::string("b1"));
    EXPECT_EQ(combo.values(), std::vector<std::string>({"b1", "b2", "b3"}));
    EXPECT_EQ(combo.currentIndex(), 0);
    EXPECT_EQ(combo.selectedIndices(), std::vector<int>({0}));
 
    // setting new string of values, containing current value. Current values should remain.
    stringOfValues = std::string("c1;b1;c3");
    combo.setStringOfValues(stringOfValues);
    EXPECT_EQ(combo.stringOfValues(), stringOfValues);
    EXPECT_EQ(combo.value(), std::string("b1"));
    EXPECT_EQ(combo.currentIndex(), 1);
    EXPECT_EQ(combo.selectedIndices(), std::vector<int>({1}));
}

References ModelView::ComboProperty::createFrom(), ModelView::ComboProperty::currentIndex(), ModelView::ComboProperty::selectedIndices(), ModelView::ComboProperty::setStringOfValues(), ModelView::ComboProperty::stringOfValues(), ModelView::ComboProperty::value(), and ModelView::ComboProperty::values().

Here is the call graph for this function:

TEST_F() [10/14]

TEST_F	(	ComboPropertyTest	,
		setStringOfSelections
	)

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

{
    ComboProperty combo;
    EXPECT_EQ(combo.stringOfSelections(), "");
 
    // checking the content of stringOfSelections
    combo.setValues(std::vector<std::string>({"a1", "a2", "a3"}));
    EXPECT_EQ(combo.selectedIndices(), std::vector<int>({0}));
    EXPECT_EQ(combo.currentIndex(), 0);
    EXPECT_EQ(combo.stringOfSelections(), "0");
 
    combo.setSelected(2, true);
    EXPECT_EQ(combo.selectedIndices(), std::vector<int>({0, 2}));
    EXPECT_EQ(combo.currentIndex(), 0);
    EXPECT_EQ(combo.stringOfSelections(), "0,2");
 
    // setting string of selections
    combo.setStringOfSelections("");
    EXPECT_EQ(combo.selectedIndices(), std::vector<int>({}));
    EXPECT_EQ(combo.currentIndex(), -1);
    EXPECT_EQ(combo.stringOfSelections(), "");
 
    combo.setStringOfSelections("1,2");
    EXPECT_EQ(combo.selectedIndices(), std::vector<int>({1, 2}));
    EXPECT_EQ(combo.currentIndex(), 1);
    EXPECT_EQ(combo.stringOfSelections(), "1,2");
 
    combo.setStringOfSelections("0,42");
    EXPECT_EQ(combo.selectedIndices(), std::vector<int>({0}));
    EXPECT_EQ(combo.currentIndex(), 0);
    EXPECT_EQ(combo.stringOfSelections(), "0");
}

References ModelView::ComboProperty::currentIndex(), ModelView::ComboProperty::selectedIndices(), ModelView::ComboProperty::setSelected(), ModelView::ComboProperty::setStringOfSelections(), ModelView::ComboProperty::setValues(), and ModelView::ComboProperty::stringOfSelections().

Here is the call graph for this function:

TEST_F() [11/14]

TEST_F	(	ComboPropertyTest	,
		setValue
	)

Definition at line 60 of file comboproperty.test.cpp.

{
    std::vector<std::string> expected{"a1", "a2"};
    ComboProperty combo = ComboProperty::createFrom(expected);
 
    // setting second value
    combo.setValue("a2");
    EXPECT_EQ(combo.values(), expected);
    EXPECT_EQ(combo.currentIndex(), 1);
    EXPECT_EQ(combo.value(), "a2");
    EXPECT_EQ(combo.selectedIndices(), std::vector<int>({1}));
 
    // setting non-existing value
    EXPECT_THROW(combo.setValue("c0"), std::runtime_error);
    EXPECT_EQ(combo.values(), expected);
    EXPECT_EQ(combo.currentIndex(), 1);
    EXPECT_EQ(combo.value(), "a2");
    EXPECT_EQ(combo.selectedIndices(), std::vector<int>({1}));
}

References ModelView::ComboProperty::createFrom(), ModelView::ComboProperty::currentIndex(), ModelView::ComboProperty::selectedIndices(), ModelView::ComboProperty::setValue(), ModelView::ComboProperty::value(), and ModelView::ComboProperty::values().

Here is the call graph for this function:

TEST_F() [12/14]

TEST_F	(	ComboPropertyTest	,
		setValues
	)

Definition at line 99 of file comboproperty.test.cpp.

{
    // seting values through stream
    std::vector<std::string> expectedValues{"a1", "a2"};
    ComboProperty combo = ComboProperty::createFrom(expectedValues);
 
    EXPECT_EQ(combo.values(), expectedValues);
    EXPECT_EQ(combo.value(), std::string("a1"));
    EXPECT_EQ(combo.currentIndex(), 0);
    EXPECT_EQ(combo.selectedIndices(), std::vector<int>({0}));
 
    // setting values from setter, old values have to be overriden
    std::vector<std::string> newValues{"b1", "b2", "b3"};
    combo.setValues(newValues);
    EXPECT_EQ(combo.value(), std::string("b1"));
    EXPECT_EQ(combo.values(), newValues);
    EXPECT_EQ(combo.currentIndex(), 0);
    EXPECT_EQ(combo.selectedIndices(), std::vector<int>({0}));
 
    // setting new/old values through setter, old value should be preserved
    newValues = {"c1", "b1", "c2"};
    combo.setValues(newValues);
    EXPECT_EQ(combo.value(), std::string("b1"));
    EXPECT_EQ(combo.values(), newValues);
    EXPECT_EQ(combo.currentIndex(), 1);
    EXPECT_EQ(combo.selectedIndices(), std::vector<int>({1}));
 
    // setting empty list shouldn't change anything
    std::vector<std::string> empty;
    combo.setValues(empty);
    EXPECT_EQ(combo.value(), std::string("b1"));
    EXPECT_EQ(combo.values(), newValues);
    EXPECT_EQ(combo.currentIndex(), 1);
    EXPECT_EQ(combo.selectedIndices(), std::vector<int>({1}));
}

References ModelView::ComboProperty::createFrom(), ModelView::ComboProperty::currentIndex(), ModelView::ComboProperty::selectedIndices(), ModelView::ComboProperty::setValues(), ModelView::ComboProperty::value(), and ModelView::ComboProperty::values().

Here is the call graph for this function:

TEST_F() [13/14]

TEST_F	(	ComboPropertyTest	,
		variantEqualityDiffIndex
	)

Check equality of ComboProperty's variants when only selected item differs.

Definition at line 393 of file comboproperty.test.cpp.

{
    if (ModelView::Comparators::registered()) {
        ComboProperty c1 = ComboProperty::createFrom({"a1", "a2"});
        ComboProperty c2 = ComboProperty::createFrom({"a1", "a2"});
 
        c1.setValue("a1");
        c2.setValue("a2");
 
        EXPECT_FALSE(QVariant::fromValue(c1) == QVariant::fromValue(c2));
        EXPECT_TRUE(QVariant::fromValue(c1) != QVariant::fromValue(c2));
 
        c2.setValue("a1");
        EXPECT_TRUE(QVariant::fromValue(c1) == QVariant::fromValue(c2));
        EXPECT_FALSE(QVariant::fromValue(c1) != QVariant::fromValue(c2));
    }
 
    if (ModelView::Comparators::registered()) {
        ComboProperty c1 = ComboProperty::createFrom({"a1", "a2"});
        ComboProperty c2 = ComboProperty::createFrom({"a1", "a2"});
 
        c1.setValue("a1");
        c2.setValue("a2");
 
        std::vector<QVariant> variants = {QVariant::fromValue(c1), QVariant::fromValue(c2)};
 
        EXPECT_FALSE(variants[0] == variants[1]);
        EXPECT_TRUE(variants[0] != variants[1]);
    }
}

References ModelView::ComboProperty::createFrom(), ModelView::Comparators::registered(), and ModelView::ComboProperty::setValue().

Here is the call graph for this function:

TEST_F() [14/14]

TEST_F	(	ComboPropertyTest	,
		variantEqualityDiffLists
	)

Check equality of ComboProperty's variants.

If comparators are not registered, the behavior is undefined.

Definition at line 362 of file comboproperty.test.cpp.

{
    if (ModelView::Comparators::registered()) {
        ComboProperty c1 = ComboProperty() << "a1"
                                           << "a2";
        ComboProperty c2 = ComboProperty() << "a1"
                                           << "a2";
 
        EXPECT_TRUE(QVariant::fromValue(c1) == QVariant::fromValue(c2));
 
        c2 << "a3";
        c2.setValue("a2");
 
        EXPECT_TRUE(QVariant::fromValue(c1) != QVariant::fromValue(c2));
        EXPECT_FALSE(QVariant::fromValue(c1) == QVariant::fromValue(c2));
 
        c1 << "a3";
        c1.setValue("a2");
 
        EXPECT_TRUE(QVariant::fromValue(c1) == QVariant::fromValue(c2));
        EXPECT_FALSE(QVariant::fromValue(c1) != QVariant::fromValue(c2));
 
        c1.setStringOfSelections("0");
        c2.setStringOfSelections("1");
        EXPECT_TRUE(QVariant::fromValue(c1) != QVariant::fromValue(c2));
        EXPECT_FALSE(QVariant::fromValue(c1) == QVariant::fromValue(c2));
    }
}

References ModelView::Comparators::registered(), ModelView::ComboProperty::setStringOfSelections(), and ModelView::ComboProperty::setValue().

Here is the call graph for this function: