BornAgain  1.19.0
Simulate and fit neutron and x-ray scattering at grazing incidence
comboproperty.test.cpp
Go to the documentation of this file.
1 // ************************************************************************************************
2 //
3 // qt-mvvm: Model-view-view-model framework for large GUI applications
4 //
5 //! @file mvvm/tests/testmodel/comboproperty.test.cpp
6 //! @brief Implements class CLASS?
7 //!
8 //! @homepage http://www.bornagainproject.org
9 //! @license GNU General Public License v3 or higher (see COPYING)
10 //! @copyright Forschungszentrum Jülich GmbH 2020
11 //! @authors Gennady Pospelov et al, Scientific Computing Group at MLZ (see CITATION, AUTHORS)
12 //
13 // ************************************************************************************************
14 
15 #include "google_test.h"
16 #include "mvvm/model/comboproperty.h"
17 #include "mvvm/model/comparators.h"
18 #include <stdexcept>
19 
20 using namespace ModelView;
21 
22 class ComboPropertyTest : public ::testing::Test {
23 public:
24  ~ComboPropertyTest();
25 };
26 
27 ComboPropertyTest::~ComboPropertyTest() = default;
28 
29 TEST_F(ComboPropertyTest, initialState)
30 {
31  ComboProperty combo;
32  EXPECT_EQ(combo.value(), "");
33  EXPECT_EQ(combo.values(), std::vector<std::string>());
34  EXPECT_EQ(combo.toolTips(), std::vector<std::string>());
35  EXPECT_EQ(combo.currentIndex(), -1);
36  EXPECT_EQ(combo.stringOfValues(), "");
37  EXPECT_EQ(combo.selectedIndices(), std::vector<int>());
38  EXPECT_EQ(combo.label(), "None");
39 }
40 
41 TEST_F(ComboPropertyTest, createFrom)
42 {
43  // from vector of values, first item should be selected
44  std::vector<std::string> expected{"a1", "a2"};
45  ComboProperty combo = ComboProperty::createFrom(expected);
46  EXPECT_EQ(combo.values(), expected);
47  EXPECT_EQ(combo.currentIndex(), 0);
48  EXPECT_EQ(combo.value(), "a1");
49  EXPECT_EQ(combo.selectedIndices(), std::vector<int>({0}));
50 
51  // from vector of values, selection provided
52  expected = {"b1", "b2", "b3"};
53  combo = ComboProperty::createFrom(expected, "b2");
54  EXPECT_EQ(combo.values(), expected);
55  EXPECT_EQ(combo.currentIndex(), 1);
56  EXPECT_EQ(combo.value(), "b2");
57  EXPECT_EQ(combo.selectedIndices(), std::vector<int>({1}));
58 }
59 
60 TEST_F(ComboPropertyTest, setValue)
61 {
62  std::vector<std::string> expected{"a1", "a2"};
63  ComboProperty combo = ComboProperty::createFrom(expected);
64 
65  // setting second value
66  combo.setValue("a2");
67  EXPECT_EQ(combo.values(), expected);
68  EXPECT_EQ(combo.currentIndex(), 1);
69  EXPECT_EQ(combo.value(), "a2");
70  EXPECT_EQ(combo.selectedIndices(), std::vector<int>({1}));
71 
72  // setting non-existing value
73  EXPECT_THROW(combo.setValue("c0"), std::runtime_error);
74  EXPECT_EQ(combo.values(), expected);
75  EXPECT_EQ(combo.currentIndex(), 1);
76  EXPECT_EQ(combo.value(), "a2");
77  EXPECT_EQ(combo.selectedIndices(), std::vector<int>({1}));
78 }
79 
80 TEST_F(ComboPropertyTest, setCurrentIndex)
81 {
82  std::vector<std::string> expected{"c1", "c2", "c3"};
83  ComboProperty combo = ComboProperty::createFrom(expected);
84 
85  EXPECT_EQ(combo.currentIndex(), 0);
86  EXPECT_EQ(combo.selectedIndices(), std::vector<int>({0}));
87  EXPECT_EQ(combo.values(), expected);
88 
89  combo.setCurrentIndex(1);
90  EXPECT_EQ(combo.value(), std::string("c2"));
91  EXPECT_EQ(combo.selectedIndices(), std::vector<int>({1}));
92 
93  // setting unexpected index
94  EXPECT_THROW(combo.setCurrentIndex(3), std::runtime_error);
95  EXPECT_EQ(combo.value(), std::string("c2"));
96  EXPECT_EQ(combo.selectedIndices(), std::vector<int>({1}));
97 }
98 
99 TEST_F(ComboPropertyTest, setValues)
100 {
101  // seting values through stream
102  std::vector<std::string> expectedValues{"a1", "a2"};
103  ComboProperty combo = ComboProperty::createFrom(expectedValues);
104 
105  EXPECT_EQ(combo.values(), expectedValues);
106  EXPECT_EQ(combo.value(), std::string("a1"));
107  EXPECT_EQ(combo.currentIndex(), 0);
108  EXPECT_EQ(combo.selectedIndices(), std::vector<int>({0}));
109 
110  // setting values from setter, old values have to be overriden
111  std::vector<std::string> newValues{"b1", "b2", "b3"};
112  combo.setValues(newValues);
113  EXPECT_EQ(combo.value(), std::string("b1"));
114  EXPECT_EQ(combo.values(), newValues);
115  EXPECT_EQ(combo.currentIndex(), 0);
116  EXPECT_EQ(combo.selectedIndices(), std::vector<int>({0}));
117 
118  // setting new/old values through setter, old value should be preserved
119  newValues = {"c1", "b1", "c2"};
120  combo.setValues(newValues);
121  EXPECT_EQ(combo.value(), std::string("b1"));
122  EXPECT_EQ(combo.values(), newValues);
123  EXPECT_EQ(combo.currentIndex(), 1);
124  EXPECT_EQ(combo.selectedIndices(), std::vector<int>({1}));
125 
126  // setting empty list shouldn't change anything
127  std::vector<std::string> empty;
128  combo.setValues(empty);
129  EXPECT_EQ(combo.value(), std::string("b1"));
130  EXPECT_EQ(combo.values(), newValues);
131  EXPECT_EQ(combo.currentIndex(), 1);
132  EXPECT_EQ(combo.selectedIndices(), std::vector<int>({1}));
133 }
134 
135 TEST_F(ComboPropertyTest, setSelected)
136 {
137  std::vector<std::string> expectedValues = {"a1", "a2", "a3"};
138  ComboProperty combo = ComboProperty::createFrom(expectedValues);
139 
140  EXPECT_EQ(combo.currentIndex(), 0);
141  EXPECT_EQ(combo.value(), "a1");
142  EXPECT_EQ(combo.values(), expectedValues);
143  EXPECT_EQ(combo.selectedIndices(), std::vector<int>({0}));
144  EXPECT_EQ(combo.selectedValues(), std::vector<std::string>({"a1"}));
145 
146  // selecting already selected element, nothing should change
147  combo.setSelected(0);
148  EXPECT_EQ(combo.currentIndex(), 0);
149  EXPECT_EQ(combo.value(), "a1");
150  EXPECT_EQ(combo.values(), expectedValues);
151  EXPECT_EQ(combo.selectedIndices(), std::vector<int>({0}));
152  EXPECT_EQ(combo.selectedValues(), std::vector<std::string>({"a1"}));
153 
154  // deselecting index
155  combo.setSelected(0, false);
156  EXPECT_EQ(combo.currentIndex(), -1);
157  EXPECT_EQ(combo.value(), "");
158  EXPECT_EQ(combo.values(), expectedValues);
159  EXPECT_EQ(combo.selectedIndices(), std::vector<int>());
160  EXPECT_EQ(combo.selectedValues(), std::vector<std::string>());
161 
162  // selecting two indeces
163  combo.setSelected(1, true);
164  combo.setSelected(2, true);
165  EXPECT_EQ(combo.currentIndex(), 1);
166  EXPECT_EQ(combo.value(), "a2");
167  EXPECT_EQ(combo.values(), expectedValues);
168  EXPECT_EQ(combo.selectedIndices(), std::vector<int>({1, 2}));
169  EXPECT_EQ(combo.selectedValues(), std::vector<std::string>({"a2", "a3"}));
170 
171  // selecting by name
172  combo.setSelected("a2", false);
173  combo.setSelected("a1", true);
174  EXPECT_EQ(combo.currentIndex(), 0);
175  EXPECT_EQ(combo.value(), "a1");
176  EXPECT_EQ(combo.values(), expectedValues);
177  EXPECT_EQ(combo.selectedIndices(), std::vector<int>({0, 2}));
178  EXPECT_EQ(combo.selectedValues(), std::vector<std::string>({"a1", "a3"}));
179 
180  // setting current index invalidates selection
181  combo.setCurrentIndex(1);
182  EXPECT_EQ(combo.currentIndex(), 1);
183  EXPECT_EQ(combo.value(), "a2");
184  EXPECT_EQ(combo.values(), expectedValues);
185  EXPECT_EQ(combo.selectedIndices(), std::vector<int>({1}));
186  EXPECT_EQ(combo.selectedValues(), std::vector<std::string>({"a2"}));
187 }
188 
189 TEST_F(ComboPropertyTest, fromStream)
190 {
191  ComboProperty combo = ComboProperty() << "a1"
192  << "a2";
193  std::vector<std::string> expected{"a1", "a2"};
194  EXPECT_EQ(combo.values(), expected);
195  EXPECT_EQ(combo.currentIndex(), 0);
196  EXPECT_EQ(combo.value(), "a1");
197  EXPECT_EQ(combo.selectedIndices(), std::vector<int>({0}));
198 
199  // adding more
200  combo << "c0";
201  expected = {"a1", "a2", "c0"};
202  EXPECT_EQ(combo.values(), expected);
203  EXPECT_EQ(combo.currentIndex(), 0);
204  EXPECT_EQ(combo.value(), "a1");
205  EXPECT_EQ(combo.selectedIndices(), std::vector<int>({0}));
206 
207  // setting another index, adding more, state should be preserved
208  combo.setCurrentIndex(1);
209  combo.setSelected(2, true);
210  EXPECT_EQ(combo.values(), expected);
211  EXPECT_EQ(combo.currentIndex(), 1);
212  EXPECT_EQ(combo.value(), "a2");
213  EXPECT_EQ(combo.selectedIndices(), std::vector<int>({1, 2}));
214  combo << "c1";
215  expected = {"a1", "a2", "c0", "c1"};
216  EXPECT_EQ(combo.values(), expected);
217  EXPECT_EQ(combo.currentIndex(), 1);
218 }
219 
220 TEST_F(ComboPropertyTest, fromVectorStream)
221 {
222  std::vector<std::string> expected{"a1", "a2"};
223  ComboProperty combo = ComboProperty::createFrom(expected);
224  combo.setSelected(0, true);
225  combo.setSelected(1, true);
226 
227  EXPECT_EQ(combo.values(), expected);
228  EXPECT_EQ(combo.currentIndex(), 0);
229  EXPECT_EQ(combo.value(), "a1");
230  EXPECT_EQ(combo.selectedIndices(), std::vector<int>({0, 1}));
231 
232  // adding from vector stream, old selection state should be preserved
233  std::vector<std::string> more{"c1", "c2"};
234  combo << more;
235  expected = {"a1", "a2", "c1", "c2"};
236  EXPECT_EQ(combo.values(), expected);
237  EXPECT_EQ(combo.currentIndex(), 0);
238  EXPECT_EQ(combo.value(), "a1");
239  EXPECT_EQ(combo.selectedIndices(), std::vector<int>({0, 1}));
240 }
241 
242 TEST_F(ComboPropertyTest, setSringOfValues)
243 {
244  std::vector<std::string> expectedValues = {"a1", "a2"};
245  ComboProperty combo = ComboProperty::createFrom(expectedValues);
246 
247  EXPECT_EQ(combo.stringOfValues(), std::string("a1;a2"));
248  EXPECT_EQ(combo.value(), std::string("a1"));
249  EXPECT_EQ(combo.currentIndex(), 0);
250  EXPECT_EQ(combo.selectedIndices(), std::vector<int>({0}));
251 
252  // setting string of values, current value should change
253  std::string stringOfValues("b1;b2;b3");
254  combo.setStringOfValues(stringOfValues);
255  EXPECT_EQ(combo.stringOfValues(), stringOfValues);
256  EXPECT_EQ(combo.value(), std::string("b1"));
257  EXPECT_EQ(combo.values(), std::vector<std::string>({"b1", "b2", "b3"}));
258  EXPECT_EQ(combo.currentIndex(), 0);
259  EXPECT_EQ(combo.selectedIndices(), std::vector<int>({0}));
260 
261  // setting new string of values, containing current value. Current values should remain.
262  stringOfValues = std::string("c1;b1;c3");
263  combo.setStringOfValues(stringOfValues);
264  EXPECT_EQ(combo.stringOfValues(), stringOfValues);
265  EXPECT_EQ(combo.value(), std::string("b1"));
266  EXPECT_EQ(combo.currentIndex(), 1);
267  EXPECT_EQ(combo.selectedIndices(), std::vector<int>({1}));
268 }
269 
270 TEST_F(ComboPropertyTest, setStringOfSelections)
271 {
272  ComboProperty combo;
273  EXPECT_EQ(combo.stringOfSelections(), "");
274 
275  // checking the content of stringOfSelections
276  combo.setValues(std::vector<std::string>({"a1", "a2", "a3"}));
277  EXPECT_EQ(combo.selectedIndices(), std::vector<int>({0}));
278  EXPECT_EQ(combo.currentIndex(), 0);
279  EXPECT_EQ(combo.stringOfSelections(), "0");
280 
281  combo.setSelected(2, true);
282  EXPECT_EQ(combo.selectedIndices(), std::vector<int>({0, 2}));
283  EXPECT_EQ(combo.currentIndex(), 0);
284  EXPECT_EQ(combo.stringOfSelections(), "0,2");
285 
286  // setting string of selections
287  combo.setStringOfSelections("");
288  EXPECT_EQ(combo.selectedIndices(), std::vector<int>({}));
289  EXPECT_EQ(combo.currentIndex(), -1);
290  EXPECT_EQ(combo.stringOfSelections(), "");
291 
292  combo.setStringOfSelections("1,2");
293  EXPECT_EQ(combo.selectedIndices(), std::vector<int>({1, 2}));
294  EXPECT_EQ(combo.currentIndex(), 1);
295  EXPECT_EQ(combo.stringOfSelections(), "1,2");
296 
297  combo.setStringOfSelections("0,42");
298  EXPECT_EQ(combo.selectedIndices(), std::vector<int>({0}));
299  EXPECT_EQ(combo.currentIndex(), 0);
300  EXPECT_EQ(combo.stringOfSelections(), "0");
301 }
302 
303 TEST_F(ComboPropertyTest, comboEqualityDiffIndex)
304 {
305  ComboProperty c1 = ComboProperty::createFrom({"a1", "a2"});
306  ComboProperty c2 = ComboProperty::createFrom({"a1", "a2"});
307 
308  c1.setValue("a1");
309  c2.setValue("a2");
310  EXPECT_TRUE(c1 != c2);
311 
312  c2.setValue("a1");
313  EXPECT_TRUE(c1 == c2);
314 }
315 
316 TEST_F(ComboPropertyTest, comboEqualityDiffList)
317 {
318  ComboProperty c1;
319  ComboProperty c2;
320  EXPECT_TRUE(c1 == c2);
321 
322  c1 << "a1"
323  << "a2";
324  c2 << "a1"
325  << "a2";
326  EXPECT_TRUE(c1 == c2);
327  EXPECT_FALSE(c1 != c2);
328 
329  c2 << "a3";
330  EXPECT_TRUE(c1 != c2);
331  EXPECT_FALSE(c1 == c2);
332  c2.setValue("a2");
333  EXPECT_TRUE(c1 != c2);
334  EXPECT_FALSE(c1 == c2);
335 
336  c1 << "a3";
337  c1.setValue("a2");
338  EXPECT_TRUE(c1 == c2);
339  EXPECT_FALSE(c1 != c2);
340 
341  // with selection indices
342  c1 = ComboProperty() << "a1"
343  << "a2"
344  << "a3";
345  c2 = ComboProperty() << "a1"
346  << "a2"
347  << "a3";
348  EXPECT_TRUE(c1 == c2);
349 
350  c2.setSelected(0, false);
351  c2.setSelected(2, true);
352  EXPECT_TRUE(c1 != c2);
353 
354  c1.setStringOfSelections("2");
355  c2.setStringOfSelections("2");
356  EXPECT_TRUE(c1 == c2);
357 }
358 
359 //! Check equality of ComboProperty's variants.
360 //! If comparators are not registered, the behavior is undefined.
361 
362 TEST_F(ComboPropertyTest, variantEqualityDiffLists)
363 {
364  if (ModelView::Comparators::registered()) {
365  ComboProperty c1 = ComboProperty() << "a1"
366  << "a2";
367  ComboProperty c2 = ComboProperty() << "a1"
368  << "a2";
369 
370  EXPECT_TRUE(QVariant::fromValue(c1) == QVariant::fromValue(c2));
371 
372  c2 << "a3";
373  c2.setValue("a2");
374 
375  EXPECT_TRUE(QVariant::fromValue(c1) != QVariant::fromValue(c2));
376  EXPECT_FALSE(QVariant::fromValue(c1) == QVariant::fromValue(c2));
377 
378  c1 << "a3";
379  c1.setValue("a2");
380 
381  EXPECT_TRUE(QVariant::fromValue(c1) == QVariant::fromValue(c2));
382  EXPECT_FALSE(QVariant::fromValue(c1) != QVariant::fromValue(c2));
383 
384  c1.setStringOfSelections("0");
385  c2.setStringOfSelections("1");
386  EXPECT_TRUE(QVariant::fromValue(c1) != QVariant::fromValue(c2));
387  EXPECT_FALSE(QVariant::fromValue(c1) == QVariant::fromValue(c2));
388  }
389 }
390 
391 //! Check equality of ComboProperty's variants when only selected item differs.
392 
393 TEST_F(ComboPropertyTest, variantEqualityDiffIndex)
394 {
395  if (ModelView::Comparators::registered()) {
396  ComboProperty c1 = ComboProperty::createFrom({"a1", "a2"});
397  ComboProperty c2 = ComboProperty::createFrom({"a1", "a2"});
398 
399  c1.setValue("a1");
400  c2.setValue("a2");
401 
402  EXPECT_FALSE(QVariant::fromValue(c1) == QVariant::fromValue(c2));
403  EXPECT_TRUE(QVariant::fromValue(c1) != QVariant::fromValue(c2));
404 
405  c2.setValue("a1");
406  EXPECT_TRUE(QVariant::fromValue(c1) == QVariant::fromValue(c2));
407  EXPECT_FALSE(QVariant::fromValue(c1) != QVariant::fromValue(c2));
408  }
409 
410  if (ModelView::Comparators::registered()) {
411  ComboProperty c1 = ComboProperty::createFrom({"a1", "a2"});
412  ComboProperty c2 = ComboProperty::createFrom({"a1", "a2"});
413 
414  c1.setValue("a1");
415  c2.setValue("a2");
416 
417  std::vector<QVariant> variants = {QVariant::fromValue(c1), QVariant::fromValue(c2)};
418 
419  EXPECT_FALSE(variants[0] == variants[1]);
420  EXPECT_TRUE(variants[0] != variants[1]);
421  }
422 }
ModelView::ComboProperty
Custom property to define list of string values with multiple selections.
Definition: comboproperty.h:27
ModelView::ComboProperty::toolTips
std::vector< std::string > toolTips() const
returns list of tool tips for all values
Definition: comboproperty.cpp:106
ModelView::ComboProperty::selectedIndices
std::vector< int > selectedIndices() const
Returns vector of selected indices.
Definition: comboproperty.cpp:183
ModelView::ComboProperty::label
std::string label() const
Returns the label to show.
Definition: comboproperty.cpp:248
ModelView::ComboProperty::setStringOfSelections
void setStringOfSelections(const std::string &values)
Sets selected indices from string.
Definition: comboproperty.cpp:234
ModelView::ComboProperty::stringOfValues
std::string stringOfValues() const
Returns a single string containing values delimited with ';'.
Definition: comboproperty.cpp:167
ModelView::ComboProperty::setStringOfValues
void setStringOfValues(const std::string &values)
Sets values from the string containing delimeter ';'.
Definition: comboproperty.cpp:174
ModelView::ComboProperty::setSelected
void setSelected(int index, bool value=true)
Sets given index selection flag.
Definition: comboproperty.cpp:201
ModelView::ComboProperty::value
std::string value() const
Definition: comboproperty.cpp:74
ModelView::ComboProperty::setValue
void setValue(const std::string &name)
Definition: comboproperty.cpp:79
ModelView::ComboProperty::values
std::vector< std::string > values() const
Definition: comboproperty.cpp:88
ModelView::ComboProperty::setValues
void setValues(const std::vector< std::string > &values)
Sets new list of values. Current value will be preserved, if exists in a new list.
Definition: comboproperty.cpp:95
ModelView::ComboProperty::stringOfSelections
std::string stringOfSelections() const
Return string with coma separated list of selected indices.
Definition: comboproperty.cpp:224
ModelView::ComboProperty::selectedValues
std::vector< std::string > selectedValues() const
Returns list of string with selected values;.
Definition: comboproperty.cpp:190
ModelView::ComboProperty::createFrom
static ComboProperty createFrom(const std::vector< std::string > &values, const std::string &current_value={})
Definition: comboproperty.cpp:61
ModelView::ComboProperty::setCurrentIndex
void setCurrentIndex(int index)
Definition: comboproperty.cpp:121
ModelView::Comparators::registered
static bool registered()
Definition: comparators.cpp:38
comboproperty.h
Defines class CLASS?
TEST_F
TEST_F(ComboPropertyTest, initialState)
Definition: comboproperty.test.cpp:29
comparators.h
Defines class CLASS?
google_test.h
Defines class CLASS?
ModelView
materialitems.h Collection of materials to populate MaterialModel.
Definition: importtablewidget.h:26