1 /*-------------------------------------------------------------------------
2 * drawElements Quality Program Tester Core
3 * ----------------------------------------
4 *
5 * Copyright 2015 The Android Open Source Project
6 *
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
18 *
19 *//*!
20 * \file
21 * \brief Template class that is either type of Left or Right.
22 *//*--------------------------------------------------------------------*/
23
24 #include "tcuEither.hpp"
25
26 namespace tcu
27 {
28 namespace
29 {
30
31 enum
32 {
33 COPYCHECK_VALUE = 1637423219
34 };
35
36 class TestClassWithConstructor
37 {
38 public:
TestClassWithConstructor(int i)39 TestClassWithConstructor (int i)
40 : m_i (i)
41 , m_copyCheck (COPYCHECK_VALUE)
42 {
43 }
44
~TestClassWithConstructor(void)45 ~TestClassWithConstructor (void)
46 {
47 DE_TEST_ASSERT(m_copyCheck == COPYCHECK_VALUE);
48 }
49
TestClassWithConstructor(const TestClassWithConstructor & other)50 TestClassWithConstructor (const TestClassWithConstructor& other)
51 : m_i (other.m_i)
52 , m_copyCheck (other.m_copyCheck)
53 {
54 }
55
operator =(const TestClassWithConstructor & other)56 TestClassWithConstructor& operator= (const TestClassWithConstructor& other)
57 {
58 TCU_CHECK(m_copyCheck == COPYCHECK_VALUE);
59
60 if (this == &other)
61 return *this;
62
63 m_i = other.m_i;
64 m_copyCheck = other.m_copyCheck;
65
66 TCU_CHECK(m_copyCheck == COPYCHECK_VALUE);
67
68 return *this;
69 }
70
getValue(void) const71 int getValue (void) const
72 {
73 TCU_CHECK(m_copyCheck == COPYCHECK_VALUE);
74
75 return m_i;
76 }
77
78 private:
79 int m_i;
80 int m_copyCheck;
81 };
82
83 } // anonymous
84
Either_selfTest(void)85 void Either_selfTest (void)
86 {
87 // Simple test for first
88 {
89 const int intValue = 1503457782;
90 const Either<int, float> either (intValue);
91
92 TCU_CHECK(either.isFirst());
93 TCU_CHECK(!either.isSecond());
94
95 TCU_CHECK(either.is<int>());
96 TCU_CHECK(!either.is<float>());
97
98 TCU_CHECK(either.getFirst() == intValue);
99 TCU_CHECK(either.get<int>() == intValue);
100 }
101
102 // Simple test for second
103 {
104 const float floatValue = 0.43223332995f;
105 const Either<int, float> either (floatValue);
106
107 TCU_CHECK(!either.isFirst());
108 TCU_CHECK(either.isSecond());
109
110 TCU_CHECK(!either.is<int>());
111 TCU_CHECK(either.is<float>());
112
113 TCU_CHECK(either.getSecond() == floatValue);
114 TCU_CHECK(either.get<float>() == floatValue);
115 }
116
117 // Assign first value
118 {
119 const int intValue = 1942092699;
120 const float floatValue = 0.43223332995f;
121 Either<int, float> either (floatValue);
122
123 either = intValue;
124
125 TCU_CHECK(either.isFirst());
126 TCU_CHECK(!either.isSecond());
127
128 TCU_CHECK(either.is<int>());
129 TCU_CHECK(!either.is<float>());
130
131 TCU_CHECK(either.getFirst() == intValue);
132 TCU_CHECK(either.get<int>() == intValue);
133 }
134
135 // Assign second value
136 {
137 const int intValue = 1942092699;
138 const float floatValue = 0.43223332995f;
139 Either<int, float> either (intValue);
140
141 either = floatValue;
142
143 TCU_CHECK(!either.isFirst());
144 TCU_CHECK(either.isSecond());
145
146 TCU_CHECK(!either.is<int>());
147 TCU_CHECK(either.is<float>());
148
149 TCU_CHECK(either.getSecond() == floatValue);
150 TCU_CHECK(either.get<float>() == floatValue);
151 }
152
153 // Assign first either value
154 {
155 const int intValue = 1942092699;
156 const float floatValue = 0.43223332995f;
157 Either<int, float> either (floatValue);
158 const Either<int, float> otherEither (intValue);
159
160 either = otherEither;
161
162 TCU_CHECK(either.isFirst());
163 TCU_CHECK(!either.isSecond());
164
165 TCU_CHECK(either.is<int>());
166 TCU_CHECK(!either.is<float>());
167
168 TCU_CHECK(either.getFirst() == intValue);
169 TCU_CHECK(either.get<int>() == intValue);
170 }
171
172 // Assign second either value
173 {
174 const int intValue = 1942092699;
175 const float floatValue = 0.43223332995f;
176 Either<int, float> either (intValue);
177 const Either<int, float> otherEither (floatValue);
178
179 either = otherEither;
180
181 TCU_CHECK(!either.isFirst());
182 TCU_CHECK(either.isSecond());
183
184 TCU_CHECK(!either.is<int>());
185 TCU_CHECK(either.is<float>());
186
187 TCU_CHECK(either.getSecond() == floatValue);
188 TCU_CHECK(either.get<float>() == floatValue);
189 }
190
191 // Simple test for first with constructor
192 {
193 const TestClassWithConstructor testObject (171899615);
194 const Either<TestClassWithConstructor, int> either (testObject);
195
196 TCU_CHECK(either.isFirst());
197 TCU_CHECK(!either.isSecond());
198
199 TCU_CHECK(either.is<TestClassWithConstructor>());
200 TCU_CHECK(!either.is<int>());
201
202 TCU_CHECK(either.getFirst().getValue() == testObject.getValue());
203 TCU_CHECK(either.get<TestClassWithConstructor>().getValue() == testObject.getValue());
204 }
205
206 // Simple test for second with constructor
207 {
208 const TestClassWithConstructor testObject (171899615);
209 const Either<int, TestClassWithConstructor> either (testObject);
210
211 TCU_CHECK(!either.isFirst());
212 TCU_CHECK(either.isSecond());
213
214 TCU_CHECK(either.is<TestClassWithConstructor>());
215 TCU_CHECK(!either.is<int>());
216
217 TCU_CHECK(either.getSecond().getValue() == testObject.getValue());
218 TCU_CHECK(either.get<TestClassWithConstructor>().getValue() == testObject.getValue());
219 }
220
221 // Assign first with constructor
222 {
223 const int intValue = 1942092699;
224 const TestClassWithConstructor testObject (171899615);
225 Either<TestClassWithConstructor, int> either (intValue);
226
227 either = testObject;
228
229 TCU_CHECK(either.isFirst());
230 TCU_CHECK(!either.isSecond());
231
232 TCU_CHECK(either.is<TestClassWithConstructor>());
233 TCU_CHECK(!either.is<int>());
234
235 TCU_CHECK(either.getFirst().getValue() == testObject.getValue());
236 TCU_CHECK(either.get<TestClassWithConstructor>().getValue() == testObject.getValue());
237 }
238
239 // Assign second with constructor
240 {
241 const int intValue = 1942092699;
242 const TestClassWithConstructor testObject (171899615);
243 Either<int, TestClassWithConstructor> either (intValue);
244
245 either = testObject;
246
247 TCU_CHECK(!either.isFirst());
248 TCU_CHECK(either.isSecond());
249
250 TCU_CHECK(either.is<TestClassWithConstructor>());
251 TCU_CHECK(!either.is<int>());
252
253 TCU_CHECK(either.getSecond().getValue() == testObject.getValue());
254 TCU_CHECK(either.get<TestClassWithConstructor>().getValue() == testObject.getValue());
255 }
256
257 // Assign first either with constructor
258 {
259 const int intValue = 1942092699;
260 const TestClassWithConstructor testObject (171899615);
261 Either<TestClassWithConstructor, int> either (intValue);
262 const Either<TestClassWithConstructor, int> otherEither (testObject);
263
264 either = otherEither;
265
266 TCU_CHECK(either.isFirst());
267 TCU_CHECK(!either.isSecond());
268
269 TCU_CHECK(either.is<TestClassWithConstructor>());
270 TCU_CHECK(!either.is<int>());
271
272 TCU_CHECK(either.getFirst().getValue() == testObject.getValue());
273 TCU_CHECK(either.get<TestClassWithConstructor>().getValue() == testObject.getValue());
274 }
275
276 // Assign second either with constructor
277 {
278 const int intValue = 1942092699;
279 const TestClassWithConstructor testObject (171899615);
280 Either<int, TestClassWithConstructor> either (intValue);
281 const Either<int, TestClassWithConstructor> otherEither (testObject);
282
283 either = otherEither;
284
285 TCU_CHECK(!either.isFirst());
286 TCU_CHECK(either.isSecond());
287
288 TCU_CHECK(either.is<TestClassWithConstructor>());
289 TCU_CHECK(!either.is<int>());
290
291 TCU_CHECK(either.getSecond().getValue() == testObject.getValue());
292 TCU_CHECK(either.get<TestClassWithConstructor>().getValue() == testObject.getValue());
293 }
294 }
295
296 } // tcu
297