BornAgain  1.19.0
Simulate and fit neutron and x-ray scattering at grazing incidence
Classes | Functions
reallimits.test.cpp File Reference

Implements class CLASS? More...

Include dependency graph for reallimits.test.cpp:

Go to the source code of this file.

Classes

class  RealLimitsTest
 

Functions

 TEST_F (RealLimitsTest, comparisonOperators)
 
 TEST_F (RealLimitsTest, copyConstructor)
 
 TEST_F (RealLimitsTest, initialState)
 
 TEST_F (RealLimitsTest, limited)
 
 TEST_F (RealLimitsTest, limitless)
 
 TEST_F (RealLimitsTest, lowerLimited)
 
 TEST_F (RealLimitsTest, nonnegative)
 
 TEST_F (RealLimitsTest, positive)
 
 TEST_F (RealLimitsTest, toVariant)
 
 TEST_F (RealLimitsTest, upperLimited)
 
 TEST_F (RealLimitsTest, variantEquality)
 

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

Function Documentation

◆ TEST_F() [1/11]

TEST_F ( RealLimitsTest  ,
comparisonOperators   
)

Definition at line 180 of file reallimits.test.cpp.

181 {
182  RealLimits lim1 = RealLimits::limited(1.0, 2.0);
183  RealLimits lim2 = RealLimits::limited(1.0, 2.0);
184  EXPECT_TRUE(lim1 == lim2);
185  EXPECT_FALSE(lim1 != lim2);
186 
187  RealLimits lim3 = RealLimits::limitless();
188  RealLimits lim4 = RealLimits::limitless();
189  EXPECT_TRUE(lim3 == lim4);
190  EXPECT_FALSE(lim3 != lim4);
191 
192  RealLimits lim5 = RealLimits::lowerLimited(1.0);
193  RealLimits lim6 = RealLimits::lowerLimited(1.0);
194  EXPECT_TRUE(lim5 == lim6);
195  EXPECT_FALSE(lim5 != lim6);
196 
197  RealLimits lim7 = RealLimits::upperLimited(1.0);
198  RealLimits lim8 = RealLimits::upperLimited(1.0);
199  EXPECT_TRUE(lim7 == lim8);
200  EXPECT_FALSE(lim7 != lim8);
201 
202  EXPECT_TRUE(RealLimits::positive() == RealLimits::positive());
203  EXPECT_TRUE(RealLimits::nonnegative() == RealLimits::nonnegative());
204 
205  EXPECT_FALSE(RealLimits::positive() == RealLimits::nonnegative());
206 }
ModelView::RealLimits
Limits for double.
Definition: reallimits.h:25
RealLimits::limitless
static RealLimits limitless()
Creates an object withoud bounds (default)
Definition: RealLimits.cpp:130
RealLimits::upperLimited
static RealLimits upperLimited(double bound_value)
Creates an object bounded from the right.
Definition: RealLimits.cpp:120
RealLimits::lowerLimited
static RealLimits lowerLimited(double bound_value)
Creates an object bounded from the left.
Definition: RealLimits.cpp:105
RealLimits::positive
static RealLimits positive()
Creates an object which can have only positive values (>0., zero is not included)
Definition: RealLimits.cpp:110
RealLimits::nonnegative
static RealLimits nonnegative()
Creates an object which can have only positive values with 0. included.
Definition: RealLimits.cpp:115
RealLimits::limited
static RealLimits limited(double left_bound_value, double right_bound_value)
Creates an object bounded from the left and right.
Definition: RealLimits.cpp:125

References ModelView::RealLimits::limited(), ModelView::RealLimits::limitless(), ModelView::RealLimits::lowerLimited(), ModelView::RealLimits::nonnegative(), ModelView::RealLimits::positive(), and ModelView::RealLimits::upperLimited().

Here is the call graph for this function:

◆ TEST_F() [2/11]

TEST_F ( RealLimitsTest  ,
copyConstructor   
)

Definition at line 208 of file reallimits.test.cpp.

209 {
210  RealLimits lim1 = RealLimits::limited(1.0, 2.0);
211  RealLimits lim2 = lim1;
212  EXPECT_TRUE(lim1 == lim2);
213  EXPECT_FALSE(lim1 != lim2);
214 
215  RealLimits lim3(lim1);
216  EXPECT_TRUE(lim1 == lim3);
217  EXPECT_FALSE(lim1 != lim3);
218 }

References ModelView::RealLimits::limited().

Here is the call graph for this function:

◆ TEST_F() [3/11]

TEST_F ( RealLimitsTest  ,
initialState   
)

Definition at line 28 of file reallimits.test.cpp.

29 {
30  RealLimits limits;
31 
32  EXPECT_FALSE(limits.hasLowerLimit());
33  EXPECT_FALSE(limits.hasUpperLimit());
34  EXPECT_FALSE(limits.hasLowerAndUpperLimits());
35  EXPECT_TRUE(limits.isInRange(-std::numeric_limits<double>::infinity()));
36  EXPECT_TRUE(limits.isInRange(0.0));
37  EXPECT_TRUE(limits.isInRange(std::numeric_limits<double>::infinity()));
38 
39  EXPECT_FALSE(limits.isPositive());
40  EXPECT_FALSE(limits.isNonnegative());
41  EXPECT_FALSE(limits.isLowerLimited());
42  EXPECT_FALSE(limits.isUpperLimited());
43  EXPECT_FALSE(limits.isLimited());
44 }
ModelView::RealLimits::isLimited
bool isLimited() const
Definition: reallimits.cpp:151
ModelView::RealLimits::isLowerLimited
bool isLowerLimited() const
Definition: reallimits.cpp:141
ModelView::RealLimits::isPositive
bool isPositive() const
Definition: reallimits.cpp:130
ModelView::RealLimits::hasUpperLimit
bool hasUpperLimit() const
if has upper limit
Definition: reallimits.cpp:81
ModelView::RealLimits::hasLowerAndUpperLimits
bool hasLowerAndUpperLimits() const
if has lower and upper limit
Definition: reallimits.cpp:91
ModelView::RealLimits::isInRange
bool isInRange(double value) const
returns true if proposed value is in limits range
Definition: reallimits.cpp:96
ModelView::RealLimits::isNonnegative
bool isNonnegative() const
Definition: reallimits.cpp:136
ModelView::RealLimits::isUpperLimited
bool isUpperLimited() const
Definition: reallimits.cpp:146
ModelView::RealLimits::hasLowerLimit
bool hasLowerLimit() const
if has lower limit
Definition: reallimits.cpp:71

References ModelView::RealLimits::hasLowerAndUpperLimits(), ModelView::RealLimits::hasLowerLimit(), ModelView::RealLimits::hasUpperLimit(), ModelView::RealLimits::isInRange(), ModelView::RealLimits::isLimited(), ModelView::RealLimits::isLowerLimited(), ModelView::RealLimits::isNonnegative(), ModelView::RealLimits::isPositive(), and ModelView::RealLimits::isUpperLimited().

Here is the call graph for this function:

◆ TEST_F() [4/11]

TEST_F ( RealLimitsTest  ,
limited   
)

Definition at line 87 of file reallimits.test.cpp.

88 {
89  // [-10.0, 2.0[
90  RealLimits limits = RealLimits::limited(-10.0, 2.0);
91  EXPECT_TRUE(limits.hasLowerLimit());
92  EXPECT_TRUE(limits.hasUpperLimit());
93  EXPECT_TRUE(limits.hasLowerAndUpperLimits());
94 
95  EXPECT_EQ(limits.lowerLimit(), -10.0);
96  EXPECT_EQ(limits.upperLimit(), 2.0);
97 
98  EXPECT_FALSE(limits.isInRange(-11.0));
99  EXPECT_TRUE(limits.isInRange(-9.0));
100  EXPECT_TRUE(limits.isInRange(0.0));
101  EXPECT_TRUE(limits.isInRange(1.0));
102  EXPECT_FALSE(limits.isInRange(2.0));
103  EXPECT_FALSE(limits.isInRange(3.0));
104 
105  EXPECT_FALSE(limits.isPositive());
106  EXPECT_FALSE(limits.isNonnegative());
107  EXPECT_FALSE(limits.isLowerLimited());
108  EXPECT_FALSE(limits.isUpperLimited());
109  EXPECT_TRUE(limits.isLimited());
110 }
ModelView::RealLimits::upperLimit
double upperLimit() const
Returns upper limit.
Definition: reallimits.cpp:86
ModelView::RealLimits::lowerLimit
double lowerLimit() const
Returns lower limit.
Definition: reallimits.cpp:76

References ModelView::RealLimits::hasLowerAndUpperLimits(), ModelView::RealLimits::hasLowerLimit(), ModelView::RealLimits::hasUpperLimit(), ModelView::RealLimits::isInRange(), ModelView::RealLimits::isLimited(), ModelView::RealLimits::isLowerLimited(), ModelView::RealLimits::isNonnegative(), ModelView::RealLimits::isPositive(), ModelView::RealLimits::isUpperLimited(), ModelView::RealLimits::limited(), ModelView::RealLimits::lowerLimit(), and ModelView::RealLimits::upperLimit().

Here is the call graph for this function:

◆ TEST_F() [5/11]

TEST_F ( RealLimitsTest  ,
limitless   
)

Definition at line 158 of file reallimits.test.cpp.

159 {
160  RealLimits limits = RealLimits::limitless();
161 
162  EXPECT_FALSE(limits.hasLowerLimit());
163  EXPECT_FALSE(limits.hasUpperLimit());
164  EXPECT_FALSE(limits.hasLowerAndUpperLimits());
165 
166  EXPECT_EQ(limits.lowerLimit(), std::numeric_limits<double>::lowest());
167  EXPECT_EQ(limits.upperLimit(), std::numeric_limits<double>::max());
168 
169  EXPECT_TRUE(limits.isInRange(-std::numeric_limits<double>::infinity()));
170  EXPECT_TRUE(limits.isInRange(0.0));
171  EXPECT_TRUE(limits.isInRange(std::numeric_limits<double>::infinity()));
172 
173  EXPECT_FALSE(limits.isPositive());
174  EXPECT_FALSE(limits.isNonnegative());
175  EXPECT_FALSE(limits.isLowerLimited());
176  EXPECT_FALSE(limits.isUpperLimited());
177  EXPECT_FALSE(limits.isLimited());
178 }

References ModelView::RealLimits::hasLowerAndUpperLimits(), ModelView::RealLimits::hasLowerLimit(), ModelView::RealLimits::hasUpperLimit(), ModelView::RealLimits::isInRange(), ModelView::RealLimits::isLimited(), ModelView::RealLimits::isLowerLimited(), ModelView::RealLimits::isNonnegative(), ModelView::RealLimits::isPositive(), ModelView::RealLimits::isUpperLimited(), ModelView::RealLimits::limitless(), ModelView::RealLimits::lowerLimit(), and ModelView::RealLimits::upperLimit().

Here is the call graph for this function:

◆ TEST_F() [6/11]

TEST_F ( RealLimitsTest  ,
lowerLimited   
)

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

47 {
48  // [5.0, inf[
49  RealLimits limits = RealLimits::lowerLimited(5.0);
50  EXPECT_TRUE(limits.hasLowerLimit());
51  EXPECT_FALSE(limits.hasUpperLimit());
52  EXPECT_FALSE(limits.hasLowerAndUpperLimits());
53 
54  EXPECT_EQ(limits.lowerLimit(), 5.0);
55  EXPECT_DOUBLE_EQ(limits.upperLimit(), std::numeric_limits<double>::max());
56 
57  EXPECT_FALSE(limits.isPositive());
58  EXPECT_FALSE(limits.isNonnegative());
59  EXPECT_TRUE(limits.isLowerLimited());
60  EXPECT_FALSE(limits.isUpperLimited());
61  EXPECT_FALSE(limits.isLimited());
62 }

References ModelView::RealLimits::hasLowerAndUpperLimits(), ModelView::RealLimits::hasLowerLimit(), ModelView::RealLimits::hasUpperLimit(), ModelView::RealLimits::isLimited(), ModelView::RealLimits::isLowerLimited(), ModelView::RealLimits::isNonnegative(), ModelView::RealLimits::isPositive(), ModelView::RealLimits::isUpperLimited(), ModelView::RealLimits::lowerLimit(), ModelView::RealLimits::lowerLimited(), and ModelView::RealLimits::upperLimit().

Here is the call graph for this function:

◆ TEST_F() [7/11]

TEST_F ( RealLimitsTest  ,
nonnegative   
)

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

136 {
137  // [0.0, 2.0[
138  RealLimits limits = RealLimits::nonnegative();
139  EXPECT_TRUE(limits.hasLowerLimit());
140  EXPECT_FALSE(limits.hasUpperLimit());
141  EXPECT_FALSE(limits.hasLowerAndUpperLimits());
142 
143  EXPECT_EQ(limits.lowerLimit(), 0.0);
144  EXPECT_EQ(limits.upperLimit(), std::numeric_limits<double>::max());
145 
146  EXPECT_FALSE(limits.isInRange(-11.0));
147  EXPECT_TRUE(limits.isInRange(0.0));
148  EXPECT_TRUE(limits.isInRange(std::numeric_limits<double>::min()));
149  EXPECT_TRUE(limits.isInRange(1.0));
150 
151  EXPECT_FALSE(limits.isPositive());
152  EXPECT_TRUE(limits.isNonnegative());
153  EXPECT_FALSE(limits.isLowerLimited());
154  EXPECT_FALSE(limits.isUpperLimited());
155  EXPECT_FALSE(limits.isLimited());
156 }

References ModelView::RealLimits::hasLowerAndUpperLimits(), ModelView::RealLimits::hasLowerLimit(), ModelView::RealLimits::hasUpperLimit(), ModelView::RealLimits::isInRange(), ModelView::RealLimits::isLimited(), ModelView::RealLimits::isLowerLimited(), ModelView::RealLimits::isNonnegative(), ModelView::RealLimits::isPositive(), ModelView::RealLimits::isUpperLimited(), ModelView::RealLimits::lowerLimit(), ModelView::RealLimits::nonnegative(), and ModelView::RealLimits::upperLimit().

Here is the call graph for this function:

◆ TEST_F() [8/11]

TEST_F ( RealLimitsTest  ,
positive   
)

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

113 {
114  // ]0.0, 2.0[
115  RealLimits limits = RealLimits::positive();
116  EXPECT_TRUE(limits.hasLowerLimit());
117  EXPECT_FALSE(limits.hasUpperLimit());
118  EXPECT_FALSE(limits.hasLowerAndUpperLimits());
119 
120  EXPECT_EQ(limits.lowerLimit(), std::numeric_limits<double>::min());
121  EXPECT_EQ(limits.upperLimit(), std::numeric_limits<double>::max());
122 
123  EXPECT_FALSE(limits.isInRange(-11.0));
124  EXPECT_FALSE(limits.isInRange(0.0));
125  EXPECT_TRUE(limits.isInRange(std::numeric_limits<double>::min()));
126  EXPECT_TRUE(limits.isInRange(1.0));
127 
128  EXPECT_TRUE(limits.isPositive());
129  EXPECT_FALSE(limits.isNonnegative());
130  EXPECT_FALSE(limits.isLowerLimited());
131  EXPECT_FALSE(limits.isUpperLimited());
132  EXPECT_FALSE(limits.isLimited());
133 }

References ModelView::RealLimits::hasLowerAndUpperLimits(), ModelView::RealLimits::hasLowerLimit(), ModelView::RealLimits::hasUpperLimit(), ModelView::RealLimits::isInRange(), ModelView::RealLimits::isLimited(), ModelView::RealLimits::isLowerLimited(), ModelView::RealLimits::isNonnegative(), ModelView::RealLimits::isPositive(), ModelView::RealLimits::isUpperLimited(), ModelView::RealLimits::lowerLimit(), ModelView::RealLimits::positive(), and ModelView::RealLimits::upperLimit().

Here is the call graph for this function:

◆ TEST_F() [9/11]

TEST_F ( RealLimitsTest  ,
toVariant   
)

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

221 {
222  RealLimits limit = RealLimits::limited(1.0, 2.0);
223  QVariant variant = QVariant::fromValue(limit);
224 
225  EXPECT_EQ(variant.value<RealLimits>().isLimited(), limit.isLimited());
226  EXPECT_EQ(variant.value<RealLimits>().lowerLimit(), limit.lowerLimit());
227  EXPECT_EQ(variant.value<RealLimits>().upperLimit(), limit.upperLimit());
228 }

References ModelView::RealLimits::isLimited(), ModelView::RealLimits::limited(), ModelView::RealLimits::lowerLimit(), and ModelView::RealLimits::upperLimit().

Here is the call graph for this function:

◆ TEST_F() [10/11]

TEST_F ( RealLimitsTest  ,
upperLimited   
)

Definition at line 64 of file reallimits.test.cpp.

65 {
66  // [-inf, 5.0[
67  RealLimits limits = RealLimits::upperLimited(5.0);
68  EXPECT_FALSE(limits.hasLowerLimit());
69  EXPECT_TRUE(limits.hasUpperLimit());
70  EXPECT_FALSE(limits.hasLowerAndUpperLimits());
71 
72  EXPECT_DOUBLE_EQ(limits.lowerLimit(), std::numeric_limits<double>::lowest());
73  EXPECT_EQ(5.0, limits.upperLimit());
74 
75  EXPECT_TRUE(limits.isInRange(-std::numeric_limits<double>::infinity()));
76  EXPECT_TRUE(limits.isInRange(-2.0));
77  EXPECT_FALSE(limits.isInRange(5.0));
78  EXPECT_FALSE(limits.isInRange(std::numeric_limits<double>::infinity()));
79 
80  EXPECT_FALSE(limits.isPositive());
81  EXPECT_FALSE(limits.isNonnegative());
82  EXPECT_FALSE(limits.isLowerLimited());
83  EXPECT_TRUE(limits.isUpperLimited());
84  EXPECT_FALSE(limits.isLimited());
85 }

References ModelView::RealLimits::hasLowerAndUpperLimits(), ModelView::RealLimits::hasLowerLimit(), ModelView::RealLimits::hasUpperLimit(), ModelView::RealLimits::isInRange(), ModelView::RealLimits::isLimited(), ModelView::RealLimits::isLowerLimited(), ModelView::RealLimits::isNonnegative(), ModelView::RealLimits::isPositive(), ModelView::RealLimits::isUpperLimited(), ModelView::RealLimits::lowerLimit(), ModelView::RealLimits::upperLimit(), and ModelView::RealLimits::upperLimited().

Here is the call graph for this function:

◆ TEST_F() [11/11]

TEST_F ( RealLimitsTest  ,
variantEquality   
)

Definition at line 230 of file reallimits.test.cpp.

231 {
232  if (ModelView::Comparators::registered()) {
233  QVariant var1a = QVariant::fromValue(RealLimits::limited(1.0, 2.0));
234  QVariant var1b = QVariant::fromValue(RealLimits::limited(1.0, 2.0));
235  QVariant var2 = QVariant::fromValue(RealLimits::lowerLimited(1.0));
236 
237  EXPECT_TRUE(var1a == var1b);
238  EXPECT_FALSE(var1a == var2);
239  EXPECT_FALSE(var1a != var1b);
240  EXPECT_TRUE(var1a != var2);
241  }
242 }
ModelView::Comparators::registered
static bool registered()
Definition: comparators.cpp:38

References ModelView::RealLimits::limited(), ModelView::RealLimits::lowerLimited(), and ModelView::Comparators::registered().

Here is the call graph for this function: