test/zserio/ReflectableTest.cpp
Line | Count | Source |
1 | | #include <string> |
2 | | #include <functional> |
3 | | #include <type_traits> |
4 | | |
5 | | #include "gtest/gtest.h" |
6 | | |
7 | | #include "zserio/ArrayTraits.h" |
8 | | #include "zserio/BitStreamReader.h" |
9 | | #include "zserio/BitStreamWriter.h" |
10 | | #include "zserio/BitSizeOfCalculator.h" |
11 | | #include "zserio/Reflectable.h" |
12 | | #include "zserio/Vector.h" |
13 | | |
14 | | #include "test_object/std_allocator/ReflectableBitmask.h" |
15 | | #include "test_object/std_allocator/ReflectableEnum.h" |
16 | | #include "test_object/std_allocator/ReflectableNested.h" |
17 | | #include "test_object/std_allocator/ReflectableObject.h" |
18 | | |
19 | | using test_object::std_allocator::ReflectableBitmask; |
20 | | using test_object::std_allocator::ReflectableEnum; |
21 | | using test_object::std_allocator::ReflectableNested; |
22 | | using test_object::std_allocator::ReflectableObject; |
23 | | |
24 | | using namespace std::placeholders; |
25 | | |
26 | | namespace zserio |
27 | | { |
28 | | |
29 | | namespace |
30 | | { |
31 | | |
32 | | ReflectableObject createInitializedReflectableObject(const string<>& stringField, |
33 | | uint32_t reflectableNestedValue) |
34 | 5 | { |
35 | 5 | ReflectableObject reflectableObject(stringField, ReflectableNested{reflectableNestedValue}); |
36 | 5 | reflectableObject.initializeChildren(); |
37 | 5 | return reflectableObject; |
38 | 5 | } |
39 | | |
40 | | } // namespace |
41 | | |
42 | | namespace detail |
43 | | { |
44 | | |
45 | | template <typename FUNC> |
46 | | struct return_type; |
47 | | |
48 | | template <typename R, typename CLASS, typename... ARGS> |
49 | | struct return_type<R (CLASS::*) (ARGS...) const> |
50 | | { |
51 | | using type = R; |
52 | | }; |
53 | | |
54 | | } // namespace |
55 | | |
56 | | class ReflectableTest : public ::testing::Test |
57 | | { |
58 | | protected: |
59 | | template <typename RAW_ARRAY> |
60 | | void checkArrayAnyValue(const RAW_ARRAY& rawArray, const IReflectableConstPtr& reflectable) |
61 | 40 | { |
62 | 40 | ASSERT_EQ(rawArray, |
63 | 40 | reflectable->getAnyValue().template get<std::reference_wrapper<const RAW_ARRAY>>().get()); |
64 | 40 | } |
65 | | |
66 | | template <typename RAW_ARRAY> |
67 | | void checkArrayAnyValue(const RAW_ARRAY& rawArray, const IReflectablePtr& reflectable) |
68 | 31 | { |
69 | 31 | ASSERT_EQ(rawArray, |
70 | 31 | reflectable->getAnyValue().template get<std::reference_wrapper<RAW_ARRAY>>().get()); |
71 | 31 | } |
72 | | |
73 | | template <typename RAW_ARRAY, typename REFLECTABLE_PTR, typename ELEMENT_CHECKER> |
74 | | void checkArray(const RAW_ARRAY& rawArray, const REFLECTABLE_PTR& reflectable, |
75 | | const ELEMENT_CHECKER& elementChecker) |
76 | 71 | { |
77 | 71 | ASSERT_TRUE(reflectable->isArray()); |
78 | 71 | ASSERT_EQ(rawArray.size(), reflectable->size()); |
79 | 330 | for (size_t i = 0; 71 i < rawArray.size(); ++i259 ) |
80 | 259 | { |
81 | 259 | if (i % 2 == 0) |
82 | 141 | elementChecker(rawArray[i], reflectable->at(i)); |
83 | 118 | else |
84 | 118 | elementChecker(rawArray[i], (*reflectable)[i]); |
85 | 259 | } |
86 | | |
87 | 71 | ASSERT_THROW(reflectable->at(rawArray.size()), CppRuntimeException); |
88 | 71 | ASSERT_THROW((*reflectable)[rawArray.size()], CppRuntimeException); |
89 | | |
90 | 71 | checkArrayAnyValue(rawArray, reflectable); |
91 | | |
92 | 71 | ASSERT_THROW(reflectable->getBool(), CppRuntimeException); |
93 | 71 | ASSERT_THROW(reflectable->getInt8(), CppRuntimeException); |
94 | 71 | ASSERT_THROW(reflectable->getInt16(), CppRuntimeException); |
95 | 71 | ASSERT_THROW(reflectable->getInt32(), CppRuntimeException); |
96 | 71 | ASSERT_THROW(reflectable->getInt64(), CppRuntimeException); |
97 | 71 | ASSERT_THROW(reflectable->getUInt8(), CppRuntimeException); |
98 | 71 | ASSERT_THROW(reflectable->getUInt16(), CppRuntimeException); |
99 | 71 | ASSERT_THROW(reflectable->getUInt32(), CppRuntimeException); |
100 | 71 | ASSERT_THROW(reflectable->getUInt64(), CppRuntimeException); |
101 | 71 | ASSERT_THROW(reflectable->getFloat(), CppRuntimeException); |
102 | 71 | ASSERT_THROW(reflectable->getDouble(), CppRuntimeException); |
103 | 71 | ASSERT_THROW(reflectable->getBytes(), CppRuntimeException); |
104 | 71 | ASSERT_THROW(reflectable->getStringView(), CppRuntimeException); |
105 | 71 | ASSERT_THROW(reflectable->getBitBuffer(), CppRuntimeException); |
106 | | |
107 | 71 | ASSERT_THROW(reflectable->toInt(), CppRuntimeException); |
108 | 71 | ASSERT_THROW(reflectable->toUInt(), CppRuntimeException); |
109 | 71 | ASSERT_THROW(reflectable->toDouble(), CppRuntimeException); |
110 | 71 | ASSERT_THROW(reflectable->toString(), CppRuntimeException); |
111 | | |
112 | 71 | ASSERT_THROW(reflectable->bitSizeOf(0), CppRuntimeException); |
113 | | |
114 | 71 | BitBuffer bitBuffer(0); |
115 | 71 | BitStreamWriter writer(bitBuffer); |
116 | 71 | ASSERT_THROW(reflectable->write(writer), CppRuntimeException); |
117 | | |
118 | 71 | checkNonCompound(reflectable); |
119 | 71 | } |
120 | | |
121 | | template <typename T, typename REFLECTABLE_PTR, typename READ_FUNC> |
122 | | void checkWriteRead(T value, const REFLECTABLE_PTR& reflectable, const READ_FUNC& readFunc, |
123 | | size_t bitBufferSize) |
124 | 308 | { |
125 | 308 | BitBuffer bitBuffer(bitBufferSize); |
126 | 308 | BitStreamWriter writer(bitBuffer); |
127 | 308 | reflectable->write(writer); |
128 | 308 | const size_t bitSizeOfValue = reflectable->bitSizeOf(); |
129 | 308 | ASSERT_EQ(bitSizeOfValue, writer.getBitPosition()); |
130 | | |
131 | 308 | BitStreamReader reader(bitBuffer); |
132 | 308 | ASSERT_EQ(value, readFunc(reader)); |
133 | 308 | ASSERT_EQ(bitSizeOfValue, reader.getBitPosition()); |
134 | 308 | } |
135 | | |
136 | | void checkNonArray(const IReflectableConstPtr& reflectable) |
137 | 308 | { |
138 | 308 | ASSERT_FALSE(reflectable->isArray()); |
139 | 308 | ASSERT_THROW(reflectable->size(), CppRuntimeException); |
140 | 308 | ASSERT_THROW(reflectable->at(0), CppRuntimeException); |
141 | 308 | ASSERT_THROW((*reflectable)[0], CppRuntimeException); |
142 | 308 | } |
143 | | |
144 | | void checkNonArray(const IReflectablePtr& reflectable) |
145 | 125 | { |
146 | 125 | checkNonArray(static_cast<IReflectableConstPtr>(reflectable)); |
147 | | |
148 | 125 | ASSERT_THROW(reflectable->at(0), CppRuntimeException); |
149 | 125 | ASSERT_THROW((*reflectable)[0], CppRuntimeException); |
150 | 125 | ASSERT_THROW(reflectable->resize(1), CppRuntimeException); |
151 | 125 | ASSERT_THROW(reflectable->setAt(AnyHolder<>(), 0), CppRuntimeException); |
152 | 125 | } |
153 | | |
154 | | template <typename REFLECTABLE_PTR> |
155 | | void checkNonCompoundConstMethods(const REFLECTABLE_PTR& reflectable) |
156 | 368 | { |
157 | 368 | ASSERT_THROW(reflectable->getField("field"), CppRuntimeException); |
158 | 368 | ASSERT_THROW(reflectable->getParameter("parameter"), CppRuntimeException); |
159 | 368 | ASSERT_THROW(reflectable->callFunction("function"), CppRuntimeException); |
160 | 368 | ASSERT_THROW(reflectable->getChoice(), CppRuntimeException); |
161 | | |
162 | 368 | ASSERT_EQ(nullptr, reflectable->find("some.field")); |
163 | 368 | ASSERT_EQ(nullptr, (*reflectable)["some.field"]); |
164 | 368 | } |
165 | | |
166 | | void checkNonCompound(const IReflectablePtr& reflectable) |
167 | 153 | { |
168 | 153 | ASSERT_THROW(reflectable->initializeChildren(), CppRuntimeException); |
169 | 153 | ASSERT_THROW(reflectable->initialize(vector<AnyHolder<>>()), CppRuntimeException); |
170 | 153 | ASSERT_THROW(reflectable->setField("field", AnyHolder<>{}), CppRuntimeException); |
171 | 153 | ASSERT_THROW(reflectable->createField("field"), CppRuntimeException); |
172 | 153 | ASSERT_THROW(reflectable->initializeOffsets(), CppRuntimeException); |
173 | | |
174 | 153 | checkNonCompoundConstMethods(reflectable); |
175 | 153 | } |
176 | | |
177 | | void checkNonCompound(const IReflectableConstPtr& reflectable) |
178 | 215 | { |
179 | 215 | checkNonCompoundConstMethods(reflectable); |
180 | 215 | } |
181 | | |
182 | | template <typename T, typename REFLECTABLE_PTR, typename GETTER, |
183 | | typename std::enable_if< |
184 | | std::is_same<T, typename detail::return_type<GETTER>::type>::value, int>::type = 0> |
185 | | void checkCppTypeGetter(T value, const REFLECTABLE_PTR& reflectable, const GETTER& getter, |
186 | | const char* testName, const char* getterName) |
187 | 283 | { |
188 | 566 | ASSERT_EQ(value, ((*reflectable).*getter)()) << testName << " : " << getterName; |
189 | 283 | } |
190 | | |
191 | | template <typename T, typename REFLECTABLE_PTR, typename GETTER, |
192 | | typename std::enable_if< |
193 | | !std::is_same<T, typename detail::return_type<GETTER>::type>::value, int>::type = 0> |
194 | | void checkCppTypeGetter(T, const REFLECTABLE_PTR& reflectable, const GETTER& getter, |
195 | | const char* testName, const char* getterName) |
196 | 3.86k | { |
197 | 7.72k | ASSERT_THROW(((*reflectable).*getter)(), CppRuntimeException) << testName << " : " << getterName; |
198 | 3.86k | } |
199 | | |
200 | | template <typename REFLECTABLE_PTR, typename GETTER, |
201 | | typename std::enable_if<std::is_same<Span<const uint8_t>, |
202 | | typename detail::return_type<GETTER>::type>::value, int>::type = 0> |
203 | | void checkCppTypeGetter(Span<const uint8_t> value, const REFLECTABLE_PTR& reflectable, const GETTER& getter, |
204 | | const char* testName, const char* getterName) |
205 | 7 | { |
206 | 14 | ASSERT_EQ(value.size(), ((*reflectable).*getter)().size()) << testName << " : " << getterName; |
207 | 14 | ASSERT_EQ(value.data(), ((*reflectable).*getter)().data()) << testName << " : " << getterName; |
208 | 7 | } |
209 | | |
210 | | template <typename REFLECTABLE_PTR, typename GETTER, |
211 | | typename std::enable_if<std::is_same<const BitBuffer&, |
212 | | typename detail::return_type<GETTER>::type>::value, int>::type = 0> |
213 | | void checkCppTypeGetter(const BitBuffer& value, const REFLECTABLE_PTR& reflectable, const GETTER& getter, |
214 | | const char* testName, const char* getterName) |
215 | 7 | { |
216 | 14 | ASSERT_EQ(value, ((*reflectable).*getter)()) << testName << " : " << getterName; |
217 | 7 | } |
218 | | |
219 | | template <typename T, typename REFLECTABLE_PTR> |
220 | | void checkCppTypeGetters(T value, const REFLECTABLE_PTR& reflectable, const char* testName) |
221 | 297 | { |
222 | 297 | checkCppTypeGetter(value, reflectable, &IReflectable::getBool, testName, "getBool"); |
223 | | |
224 | 297 | checkCppTypeGetter(value, reflectable, &IReflectable::getInt8, testName, "getInt8"); |
225 | 297 | checkCppTypeGetter(value, reflectable, &IReflectable::getInt16, testName, "getInt16"); |
226 | 297 | checkCppTypeGetter(value, reflectable, &IReflectable::getInt32, testName, "getInt32"); |
227 | 297 | checkCppTypeGetter(value, reflectable, &IReflectable::getInt64, testName, "getInt64"); |
228 | | |
229 | 297 | checkCppTypeGetter(value, reflectable, &IReflectable::getUInt8, testName, "getUInt8"); |
230 | 297 | checkCppTypeGetter(value, reflectable, &IReflectable::getUInt16, testName, "getUInt16"); |
231 | 297 | checkCppTypeGetter(value, reflectable, &IReflectable::getUInt32, testName, "getUInt32"); |
232 | 297 | checkCppTypeGetter(value, reflectable, &IReflectable::getUInt64, testName, "getUInt64"); |
233 | | |
234 | 297 | checkCppTypeGetter(value, reflectable, &IReflectable::getFloat, testName, "getFloat"); |
235 | 297 | checkCppTypeGetter(value, reflectable, &IReflectable::getDouble, testName, "getDouble"); |
236 | | |
237 | 297 | checkCppTypeGetter(value, reflectable, &IReflectable::getBytes, testName, "getBytes"); |
238 | 297 | checkCppTypeGetter(value, reflectable, &IReflectable::getStringView, testName, "getStringView"); |
239 | 297 | checkCppTypeGetter(value, reflectable, &IReflectable::getBitBuffer, testName, "getBitBuffer"); |
240 | 297 | } |
241 | | |
242 | | template <typename T, typename REFLECTABLE_PTR, typename GETTER, typename READ_FUNC> |
243 | | void checkFloatingPoint(T value, const REFLECTABLE_PTR& reflectable, |
244 | | const GETTER& getter, const READ_FUNC& readFunc, size_t bitSize = sizeof(T) * 8) |
245 | 19 | { |
246 | 19 | ASSERT_DOUBLE_EQ(value, ((*reflectable).*getter)()); |
247 | | |
248 | 19 | ASSERT_DOUBLE_EQ(value, reflectable->toDouble()); |
249 | 19 | ASSERT_THROW(reflectable->toInt(), CppRuntimeException); |
250 | 19 | ASSERT_THROW(reflectable->toUInt(), CppRuntimeException); |
251 | 19 | ASSERT_THROW(reflectable->toString(), CppRuntimeException); // NOT IMPLEMENTED! |
252 | | |
253 | 19 | checkCppTypeGetters(value, reflectable, "checkFloatingPoint"); |
254 | | |
255 | 19 | checkNonCompound(reflectable); |
256 | 19 | checkNonArray(reflectable); |
257 | | |
258 | 19 | checkWriteRead(value, reflectable, readFunc, bitSize); |
259 | 19 | } |
260 | | |
261 | | template <typename T, typename REFLECTABLE_PTR, typename GETTER, typename READ_FUNC> |
262 | | void checkIntegral(T value, const REFLECTABLE_PTR& reflectable, |
263 | | const GETTER& getter, const READ_FUNC& readFunc, size_t bitSize, const char* testName) |
264 | 232 | { |
265 | 232 | ASSERT_EQ(value, ((*reflectable).*getter)()); |
266 | | |
267 | 232 | ASSERT_EQ(value, reflectable->getAnyValue().template get<T>()); |
268 | | |
269 | 232 | ASSERT_DOUBLE_EQ(static_cast<double>(value), reflectable->toDouble()); |
270 | 232 | ASSERT_EQ(zserio::toString(value), reflectable->toString()); |
271 | | |
272 | 232 | checkCppTypeGetters(value, reflectable, testName); |
273 | | |
274 | 232 | checkNonCompound(reflectable); |
275 | 232 | checkNonArray(reflectable); |
276 | | |
277 | 232 | checkWriteRead(value, reflectable, readFunc, bitSize); |
278 | 232 | } |
279 | | |
280 | | template <typename T, typename REFLECTABLE_PTR, typename GETTER, typename READ_FUNC> |
281 | | void checkSignedIntegral(T value, const REFLECTABLE_PTR& reflectable, |
282 | | const GETTER& getter, const READ_FUNC& readFunc, size_t bitSize = sizeof(T) * 8) |
283 | 114 | { |
284 | 114 | ASSERT_EQ(value, reflectable->toInt()); |
285 | 114 | ASSERT_THROW(reflectable->toUInt(), CppRuntimeException); |
286 | | |
287 | 114 | checkIntegral(value, reflectable, getter, readFunc, bitSize, "checkSignedIntegral"); |
288 | 114 | } |
289 | | |
290 | | template <typename T, typename REFLECTABLE_PTR, typename GETTER, typename READ_FUNC> |
291 | | void checkUnsignedIntegral(T value, const REFLECTABLE_PTR& reflectable, |
292 | | const GETTER& getter, const READ_FUNC& readFunc, size_t bitSize = sizeof(T) * 8) |
293 | 118 | { |
294 | 118 | ASSERT_EQ(value, reflectable->toUInt()); |
295 | 118 | ASSERT_THROW(reflectable->toInt(), CppRuntimeException); |
296 | | |
297 | 118 | checkIntegral(value, reflectable, getter, readFunc, bitSize, "checkUnsignedIntegral"); |
298 | 118 | } |
299 | | |
300 | | template <typename REFLECTABLE_PTR> |
301 | | void checkString(StringView value, const REFLECTABLE_PTR& reflectable) |
302 | 11 | { |
303 | 11 | ASSERT_EQ(value, reflectable->getAnyValue().template get<StringView>()); |
304 | | |
305 | 11 | ASSERT_EQ(toString(value), reflectable->toString()); |
306 | 11 | ASSERT_THROW(reflectable->toInt(), CppRuntimeException); |
307 | 11 | ASSERT_THROW(reflectable->toUInt(), CppRuntimeException); |
308 | 11 | ASSERT_THROW(reflectable->toDouble(), CppRuntimeException); |
309 | | |
310 | 11 | checkCppTypeGetters(value, reflectable, "checkString"); |
311 | | |
312 | 11 | checkNonCompound(reflectable); |
313 | 11 | checkNonArray(reflectable); |
314 | | |
315 | 11 | checkWriteRead(toString(value), reflectable, |
316 | 11 | std::bind(&BitStreamReader::readString<>, _1, std::allocator<uint8_t>()), |
317 | 11 | bitSizeOfVarSize(convertSizeToUInt32(value.size())) + value.size() * 8); |
318 | 11 | } |
319 | | |
320 | | template <typename REFLECTABLE_PTR> |
321 | | void checkBitBuffer(const BitBuffer& value, const REFLECTABLE_PTR& reflectable) |
322 | 7 | { |
323 | 7 | ASSERT_EQ(value, reflectable->getAnyValue(). |
324 | 7 | template get<std::reference_wrapper<const BitBuffer>>().get()); |
325 | | |
326 | 7 | ASSERT_THROW(reflectable->toString(), CppRuntimeException); |
327 | 7 | ASSERT_THROW(reflectable->toDouble(), CppRuntimeException); |
328 | 7 | ASSERT_THROW(reflectable->toInt(), CppRuntimeException); |
329 | 7 | ASSERT_THROW(reflectable->toUInt(), CppRuntimeException); |
330 | | |
331 | 7 | checkCppTypeGetters(value, reflectable, "checkBitBuffer"); |
332 | | |
333 | 7 | checkNonCompound(reflectable); |
334 | 7 | checkNonArray(reflectable); |
335 | | |
336 | 7 | checkWriteRead(value, reflectable, |
337 | 7 | std::bind(&BitStreamReader::readBitBuffer<>, _1, std::allocator<uint8_t>()), |
338 | 7 | bitSizeOfVarSize(convertSizeToUInt32(value.getBitSize())) + value.getBitSize()); |
339 | 7 | } |
340 | | |
341 | | template <typename REFLECTABLE_PTR> |
342 | | void checkBytes(const std::vector<uint8_t>& value, const REFLECTABLE_PTR& reflectable) |
343 | 7 | { |
344 | 7 | ASSERT_EQ(value.data(), reflectable->getBytes().data()); |
345 | 7 | ASSERT_EQ(value.size(), reflectable->getBytes().size()); |
346 | 7 | auto anyValue = reflectable->getAnyValue().template get<Span<const uint8_t>>(); |
347 | 7 | ASSERT_EQ(value.data(), anyValue.data()); |
348 | 7 | ASSERT_EQ(value.size(), anyValue.size()); |
349 | | |
350 | 7 | ASSERT_THROW(reflectable->toString(), CppRuntimeException); |
351 | 7 | ASSERT_THROW(reflectable->toDouble(), CppRuntimeException); |
352 | 7 | ASSERT_THROW(reflectable->toInt(), CppRuntimeException); |
353 | 7 | ASSERT_THROW(reflectable->toUInt(), CppRuntimeException); |
354 | | |
355 | 7 | checkCppTypeGetters(Span<const uint8_t>(value), reflectable, "checkBytes"); |
356 | | |
357 | 7 | checkNonCompound(reflectable); |
358 | 7 | checkNonArray(reflectable); |
359 | | |
360 | 7 | const size_t bitSize = value.size() * 8; |
361 | 7 | checkWriteRead(value, reflectable, |
362 | 7 | std::bind(&BitStreamReader::readBytes<>, _1, std::allocator<uint8_t>()), |
363 | 7 | bitSizeOfVarSize(convertSizeToUInt32(bitSize)) + bitSize); |
364 | 7 | } |
365 | | |
366 | | template <typename REFLECTABLE_PTR> |
367 | | void checkBitmask(ReflectableBitmask bitmask, const REFLECTABLE_PTR& reflectable) |
368 | 11 | { |
369 | 11 | ASSERT_EQ(bitmask.getValue(), reflectable->getUInt8()); |
370 | | |
371 | 11 | ASSERT_EQ(bitmask, reflectable->getAnyValue().template get<ReflectableBitmask>()); |
372 | | |
373 | 11 | ASSERT_EQ(bitmask.getValue(), reflectable->toUInt()); |
374 | 11 | ASSERT_EQ(bitmask.getValue(), reflectable->toDouble()); |
375 | 11 | ASSERT_EQ(bitmask.toString(), reflectable->toString()); |
376 | 11 | ASSERT_THROW(reflectable->toInt(), CppRuntimeException); |
377 | | |
378 | 11 | checkCppTypeGetters(bitmask.getValue(), reflectable, "checkBitmask"); |
379 | | |
380 | 11 | checkNonCompound(reflectable); |
381 | 11 | checkNonArray(reflectable); |
382 | | |
383 | 11 | checkWriteRead(bitmask, reflectable, |
384 | 11 | [](BitStreamReader& reader) { |
385 | 11 | return ReflectableBitmask(reader); |
386 | 11 | }, 8 |
387 | 11 | ); |
388 | 11 | } |
389 | | |
390 | | template <typename REFLECTABLE_PTR> |
391 | | void checkEnum(ReflectableEnum enumeration, const REFLECTABLE_PTR& reflectable) |
392 | 10 | { |
393 | 10 | ASSERT_EQ(enumToValue(enumeration), reflectable->getInt8()); |
394 | | |
395 | 10 | ASSERT_EQ(enumeration, reflectable->getAnyValue().template get<ReflectableEnum>()); |
396 | | |
397 | 10 | ASSERT_EQ(enumToValue(enumeration), reflectable->toInt()); |
398 | 10 | ASSERT_EQ(enumToValue(enumeration), reflectable->toDouble()); |
399 | 10 | ASSERT_EQ(enumToString(enumeration), reflectable->toString()); |
400 | 10 | ASSERT_THROW(reflectable->toUInt(), CppRuntimeException); |
401 | | |
402 | 10 | checkCppTypeGetters(enumToValue(enumeration), reflectable, "checkEnum"); |
403 | | |
404 | 10 | checkNonCompound(reflectable); |
405 | 10 | checkNonArray(reflectable); |
406 | | |
407 | 10 | checkWriteRead(enumeration, reflectable, |
408 | 10 | [](BitStreamReader& reader) { |
409 | 10 | return zserio::read<ReflectableEnum>(reader); |
410 | 10 | }, 8 |
411 | 10 | ); |
412 | 10 | } |
413 | | |
414 | | void checkCompoundAnyValue(const ReflectableObject& reflectableObject, |
415 | | const IReflectableConstPtr& reflectable) |
416 | 8 | { |
417 | 8 | ASSERT_EQ(reflectableObject, |
418 | 8 | reflectable->getAnyValue(). |
419 | 8 | template get<std::reference_wrapper<const ReflectableObject>>().get()); |
420 | 8 | ASSERT_EQ(reflectableObject.getReflectableNested(), |
421 | 8 | reflectable->getField("reflectableNested")->getAnyValue(). |
422 | 8 | template get<std::reference_wrapper<const ReflectableNested>>().get()); |
423 | 8 | } |
424 | | |
425 | | void checkCompoundAnyValue(const ReflectableObject& reflectableObject, |
426 | | const IReflectablePtr& reflectable) |
427 | 3 | { |
428 | 3 | ASSERT_EQ(reflectableObject, |
429 | 3 | reflectable->getAnyValue(). |
430 | 3 | template get<std::reference_wrapper<ReflectableObject>>().get()); |
431 | 3 | ASSERT_EQ(reflectableObject.getReflectableNested(), |
432 | 3 | reflectable->getField("reflectableNested")->getAnyValue(). |
433 | 3 | template get<std::reference_wrapper<ReflectableNested>>().get()); |
434 | 3 | } |
435 | | |
436 | | template <typename REFLECTABLE_PTR> |
437 | | void checkCompoundConstMethods(const ReflectableObject& reflectableObject, |
438 | | const REFLECTABLE_PTR& reflectable) |
439 | 11 | { |
440 | 11 | ASSERT_TRUE(TypeInfoUtil::isCompound(reflectable->getTypeInfo().getSchemaType())); |
441 | | |
442 | | // field getter |
443 | 11 | ASSERT_EQ(reflectableObject.getReflectableNested().getValue(), |
444 | 11 | reflectable->getField("reflectableNested")->getField("value")->getUInt32()); |
445 | 11 | ASSERT_THROW(reflectable->getField("nonexistent"), CppRuntimeException); |
446 | 11 | ASSERT_THROW(reflectable->getField("reflectableNested")->getField("nonexistent"), CppRuntimeException); |
447 | | |
448 | | // find field |
449 | 11 | ASSERT_EQ(reflectableObject.getReflectableNested().getValue(), |
450 | 11 | reflectable->find("reflectableNested.value")->toUInt()); |
451 | 11 | ASSERT_EQ(reflectableObject.getReflectableNested().getValue(), |
452 | 11 | (*reflectable)["reflectableNested.value"]->toDouble()); |
453 | | |
454 | | // find parameter |
455 | 11 | ASSERT_NO_THROW(reflectable->getField("reflectableNested")->getParameter("dummyParam")); |
456 | 11 | ASSERT_EQ(13, (*reflectable)["reflectableNested.dummyParam"]->getInt32()); |
457 | 11 | ASSERT_NO_THROW(reflectable->getField("reflectableNested")->getParameter("stringParam")); |
458 | 11 | ASSERT_EQ(reflectableObject.getStringField(), |
459 | 11 | (*reflectable)["reflectableNested.stringParam"]->toString()); |
460 | 11 | ASSERT_THROW(reflectable->getField("reflectableNested")->getParameter("nonexistent"), |
461 | 11 | CppRuntimeException); |
462 | | |
463 | | // find function |
464 | 11 | ASSERT_EQ(reflectableObject.getReflectableNested().getValue(), |
465 | 11 | (*reflectable)["reflectableNested.getValue"]->getUInt32()); |
466 | 11 | ASSERT_THROW(reflectable->getField("reflectableNested")->callFunction("nonexistent"), |
467 | 11 | CppRuntimeException); |
468 | | |
469 | | // find failed |
470 | 11 | ASSERT_EQ(nullptr, reflectable->find("reflectableNested.nonexistent")); |
471 | 11 | ASSERT_EQ(nullptr, reflectable->find("nonexistent")); |
472 | 11 | ASSERT_EQ(nullptr, reflectable->find("reflectableNested.value.nonexistent")); |
473 | 11 | ASSERT_EQ(nullptr, reflectable->find("reflectableNested.dummyParam.nonexistent")); |
474 | 11 | ASSERT_EQ(nullptr, reflectable->find("reflectableNested.getValue.nonexistent")); |
475 | | // find failed because the underlying code throws |
476 | 11 | ASSERT_EQ(nullptr, reflectable->find("reflectableNested.throwingFunction.nonexistent")); |
477 | | |
478 | 11 | checkCompoundAnyValue(reflectableObject, reflectable); |
479 | | |
480 | 11 | ASSERT_THROW(reflectable->getBool(), CppRuntimeException); |
481 | 11 | ASSERT_THROW(reflectable->getInt8(), CppRuntimeException); |
482 | 11 | ASSERT_THROW(reflectable->getInt16(), CppRuntimeException); |
483 | 11 | ASSERT_THROW(reflectable->getInt32(), CppRuntimeException); |
484 | 11 | ASSERT_THROW(reflectable->getInt64(), CppRuntimeException); |
485 | 11 | ASSERT_THROW(reflectable->getUInt8(), CppRuntimeException); |
486 | 11 | ASSERT_THROW(reflectable->getUInt16(), CppRuntimeException); |
487 | 11 | ASSERT_THROW(reflectable->getUInt32(), CppRuntimeException); |
488 | 11 | ASSERT_THROW(reflectable->getUInt64(), CppRuntimeException); |
489 | 11 | ASSERT_THROW(reflectable->getFloat(), CppRuntimeException); |
490 | 11 | ASSERT_THROW(reflectable->getDouble(), CppRuntimeException); |
491 | 11 | ASSERT_THROW(reflectable->getBytes(), CppRuntimeException); |
492 | 11 | ASSERT_THROW(reflectable->getStringView(), CppRuntimeException); |
493 | 11 | ASSERT_THROW(reflectable->getBitBuffer(), CppRuntimeException); |
494 | | |
495 | 11 | ASSERT_THROW(reflectable->toInt(), CppRuntimeException); |
496 | 11 | ASSERT_THROW(reflectable->toUInt(), CppRuntimeException); |
497 | 11 | ASSERT_THROW(reflectable->toDouble(), CppRuntimeException); |
498 | 11 | ASSERT_THROW(reflectable->toString(), CppRuntimeException); |
499 | | |
500 | 11 | checkNonArray(reflectable); |
501 | | |
502 | 11 | checkWriteRead(reflectableObject, reflectable, |
503 | 11 | [](BitStreamReader& reader) { |
504 | 11 | return ReflectableObject(reader); |
505 | 11 | }, reflectableObject.bitSizeOf() |
506 | 11 | ); |
507 | 11 | } |
508 | | |
509 | | void checkCompound(const ReflectableObject& reflectableObject, const IReflectableConstPtr& reflectable) |
510 | 5 | { |
511 | 5 | checkCompoundConstMethods(reflectableObject, reflectable); |
512 | 5 | } |
513 | | |
514 | | void checkCompound(const ReflectableObject& reflectableObject, const IReflectablePtr& reflectable) |
515 | 3 | { |
516 | 3 | checkCompoundConstMethods(reflectableObject, reflectable); |
517 | 3 | checkCompoundConstMethods(reflectableObject, static_cast<IReflectableConstPtr>(reflectable)); |
518 | | |
519 | | // setter |
520 | 3 | reflectable->getField("reflectableNested")->setField("value", AnyHolder<>(static_cast<uint32_t>(11))); |
521 | 3 | ASSERT_EQ(11, reflectableObject.getReflectableNested().getValue()); |
522 | 3 | ASSERT_THROW(reflectable->setField("nonexistent", AnyHolder<>()), CppRuntimeException); |
523 | 3 | ASSERT_THROW(reflectable->find("reflectableNested")->setField("nonexistent", AnyHolder<>()), |
524 | 3 | CppRuntimeException); |
525 | | |
526 | | // any value |
527 | 3 | ASSERT_EQ(reflectableObject.getReflectableNested(), reflectable->find("reflectableNested")-> |
528 | 3 | getAnyValue().template get<std::reference_wrapper<ReflectableNested>>().get()); |
529 | | |
530 | 3 | reflectable->createField("reflectableNested"); |
531 | 3 | ASSERT_EQ(uint32_t(), reflectableObject.getReflectableNested().getValue()); |
532 | | |
533 | 3 | reflectable->setField("reflectableNested", AnyHolder<>(ReflectableNested{42})); |
534 | 3 | ASSERT_EQ(42, reflectableObject.getReflectableNested().getValue()); |
535 | 3 | reflectable->initializeChildren(); // keep the reflectable initialized for following tests |
536 | 3 | } |
537 | | }; |
538 | | |
539 | | TEST_F(ReflectableTest, boolReflectable) |
540 | 1 | { |
541 | 1 | const bool value = true; |
542 | 1 | auto reflectable = ReflectableFactory::getBool(value); |
543 | 1 | checkUnsignedIntegral(value, reflectable, &IReflectable::getBool, |
544 | 1 | std::bind(&BitStreamReader::readBool, _1)); |
545 | 1 | } |
546 | | |
547 | | TEST_F(ReflectableTest, int8Reflectable) |
548 | 1 | { |
549 | 1 | const int8_t value = -12; |
550 | 1 | auto reflectable = ReflectableFactory::getInt8(value); |
551 | 1 | checkSignedIntegral(value, reflectable, &IReflectable::getInt8, |
552 | 1 | std::bind(&BitStreamReader::readSignedBits, _1, 8)); |
553 | 1 | } |
554 | | |
555 | | TEST_F(ReflectableTest, int16Reflectable) |
556 | 1 | { |
557 | 1 | const int16_t value = -1234; |
558 | 1 | auto reflectable = ReflectableFactory::getInt16(value); |
559 | 1 | checkSignedIntegral(value, reflectable, &IReflectable::getInt16, |
560 | 1 | std::bind(&BitStreamReader::readSignedBits, _1, 16)); |
561 | 1 | } |
562 | | |
563 | | TEST_F(ReflectableTest, int32Reflectable) |
564 | 1 | { |
565 | 1 | const int32_t value = -123456; |
566 | 1 | auto reflectable = ReflectableFactory::getInt32(value); |
567 | 1 | checkSignedIntegral(value, reflectable, &IReflectable::getInt32, |
568 | 1 | std::bind(&BitStreamReader::readSignedBits, _1, 32)); |
569 | 1 | } |
570 | | |
571 | | TEST_F(ReflectableTest, int64Reflectable) |
572 | 1 | { |
573 | 1 | const int64_t value = -1234567890; |
574 | 1 | auto reflectable = ReflectableFactory::getInt64(value); |
575 | 1 | checkSignedIntegral(value, reflectable, &IReflectable::getInt64, |
576 | 1 | std::bind(&BitStreamReader::readSignedBits64, _1, 64)); |
577 | 1 | } |
578 | | |
579 | | TEST_F(ReflectableTest, uint8Reflectable) |
580 | 1 | { |
581 | 1 | const uint8_t value = 0xFF; |
582 | 1 | auto reflectable = ReflectableFactory::getUInt8(value); |
583 | 1 | checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt8, |
584 | 1 | std::bind(&BitStreamReader::readBits, _1, 8)); |
585 | 1 | } |
586 | | |
587 | | TEST_F(ReflectableTest, uint16Reflectable) |
588 | 1 | { |
589 | 1 | const uint16_t value = 0xFFFF; |
590 | 1 | auto reflectable = ReflectableFactory::getUInt16(value); |
591 | 1 | checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt16, |
592 | 1 | std::bind(&BitStreamReader::readBits, _1, 16)); |
593 | 1 | } |
594 | | |
595 | | TEST_F(ReflectableTest, uint32Reflectable) |
596 | 1 | { |
597 | 1 | const uint32_t value = 0xFFFFFFFF; |
598 | 1 | auto reflectable = ReflectableFactory::getUInt32(value); |
599 | 1 | checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt32, |
600 | 1 | std::bind(&BitStreamReader::readBits, _1, 32)); |
601 | 1 | } |
602 | | |
603 | | TEST_F(ReflectableTest, uint64Reflectable) |
604 | 1 | { |
605 | 1 | const uint64_t value = 0xFFFFFFFFFFFF; |
606 | 1 | auto reflectable = ReflectableFactory::getUInt64(value); |
607 | 1 | checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt64, |
608 | 1 | std::bind(&BitStreamReader::readBits64, _1, 64)); |
609 | 1 | } |
610 | | |
611 | | TEST_F(ReflectableTest, fixedSignedBitField5) // mapped to int8_t |
612 | 1 | { |
613 | 1 | const uint8_t numBits = 5; |
614 | 1 | const int8_t value = 15; |
615 | 1 | auto reflectable = ReflectableFactory::getFixedSignedBitField(value, numBits); |
616 | 1 | checkSignedIntegral(value, reflectable, &IReflectable::getInt8, |
617 | 1 | std::bind(&BitStreamReader::readSignedBits, _1, numBits), numBits); |
618 | | |
619 | 1 | ASSERT_THROW(ReflectableFactory::getFixedSignedBitField(value, 10), CppRuntimeException); |
620 | 1 | } |
621 | | |
622 | | TEST_F(ReflectableTest, fixedSignedBitField15) // mapped to int16_t |
623 | 1 | { |
624 | 1 | const uint8_t numBits = 15; |
625 | 1 | const int16_t value = -15; |
626 | 1 | auto reflectable = ReflectableFactory::getFixedSignedBitField(value, numBits); |
627 | 1 | checkSignedIntegral(value, reflectable, &IReflectable::getInt16, |
628 | 1 | std::bind(&BitStreamReader::readSignedBits, _1, numBits), numBits); |
629 | | |
630 | 1 | ASSERT_THROW(ReflectableFactory::getFixedSignedBitField(value, 5), CppRuntimeException); |
631 | 1 | ASSERT_THROW(ReflectableFactory::getFixedSignedBitField(value, 17), CppRuntimeException); |
632 | 1 | } |
633 | | |
634 | | TEST_F(ReflectableTest, fixedSignedBitField31) // mapped to int32_t |
635 | 1 | { |
636 | 1 | const uint8_t numBits = 31; |
637 | 1 | const int32_t value = -12345678; |
638 | 1 | auto reflectable = ReflectableFactory::getFixedSignedBitField(value, numBits); |
639 | 1 | checkSignedIntegral(value, reflectable, &IReflectable::getInt32, |
640 | 1 | std::bind(&BitStreamReader::readSignedBits, _1, numBits), numBits); |
641 | | |
642 | 1 | ASSERT_THROW(ReflectableFactory::getFixedSignedBitField(value, 16), CppRuntimeException); |
643 | 1 | ASSERT_THROW(ReflectableFactory::getFixedSignedBitField(value, 33), CppRuntimeException); |
644 | 1 | } |
645 | | |
646 | | TEST_F(ReflectableTest, fixedSignedBitField60) // mapped to int64_t |
647 | 1 | { |
648 | 1 | const uint8_t numBits = 60; |
649 | 1 | const int64_t value = 1234567890; |
650 | 1 | auto reflectable = ReflectableFactory::getFixedSignedBitField(value, numBits); |
651 | 1 | checkSignedIntegral(value, reflectable, &IReflectable::getInt64, |
652 | 1 | std::bind(&BitStreamReader::readSignedBits64, _1, numBits), numBits); |
653 | | |
654 | 1 | ASSERT_THROW(ReflectableFactory::getFixedSignedBitField(value, 31), CppRuntimeException); |
655 | 1 | ASSERT_THROW(ReflectableFactory::getFixedSignedBitField(value, 65), CppRuntimeException); |
656 | 1 | } |
657 | | |
658 | | TEST_F(ReflectableTest, fixedUnsignedBitField7) // mapped to uint8_t |
659 | 1 | { |
660 | 1 | const uint8_t numBits = 7; |
661 | 1 | const uint8_t value = 0x2F; |
662 | 1 | auto reflectable = ReflectableFactory::getFixedUnsignedBitField(value, numBits); |
663 | 1 | checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt8, |
664 | 1 | std::bind(&BitStreamReader::readBits, _1, numBits), numBits); |
665 | | |
666 | 1 | ASSERT_THROW(ReflectableFactory::getFixedUnsignedBitField(value, 9), CppRuntimeException); |
667 | 1 | } |
668 | | |
669 | | TEST_F(ReflectableTest, fixedUnsignedBitField9) // mapped to uint16_t |
670 | 1 | { |
671 | 1 | const uint8_t numBits = 9; |
672 | 1 | const uint16_t value = 0x1FF; |
673 | 1 | auto reflectable = ReflectableFactory::getFixedUnsignedBitField(value, numBits); |
674 | 1 | checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt16, |
675 | 1 | std::bind(&BitStreamReader::readBits, _1, numBits), numBits); |
676 | | |
677 | 1 | ASSERT_THROW(ReflectableFactory::getFixedUnsignedBitField(value, 8), CppRuntimeException); |
678 | 1 | ASSERT_THROW(ReflectableFactory::getFixedUnsignedBitField(value, 17), CppRuntimeException); |
679 | 1 | } |
680 | | |
681 | | TEST_F(ReflectableTest, fixedUnsignedBitField31) // mapped to uint32_t |
682 | 1 | { |
683 | 1 | const uint8_t numBits = 31; |
684 | 1 | const uint32_t value = UINT32_MAX >> 1; |
685 | 1 | auto reflectable = ReflectableFactory::getFixedUnsignedBitField(value, numBits); |
686 | 1 | checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt32, |
687 | 1 | std::bind(&BitStreamReader::readBits, _1, numBits), numBits); |
688 | | |
689 | 1 | ASSERT_THROW(ReflectableFactory::getFixedUnsignedBitField(value, 16), CppRuntimeException); |
690 | 1 | ASSERT_THROW(ReflectableFactory::getFixedUnsignedBitField(value, 33), CppRuntimeException); |
691 | 1 | } |
692 | | |
693 | | TEST_F(ReflectableTest, fixedUnsignedBitField33) // mapped to uint64_t |
694 | 1 | { |
695 | 1 | const uint8_t numBits = 33; |
696 | 1 | const uint64_t value = static_cast<uint64_t>(UINT32_MAX) << 1U; |
697 | 1 | auto reflectable = ReflectableFactory::getFixedUnsignedBitField(value, numBits); |
698 | 1 | checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt64, |
699 | 1 | std::bind(&BitStreamReader::readBits64, _1, numBits), numBits); |
700 | | |
701 | 1 | ASSERT_THROW(ReflectableFactory::getFixedUnsignedBitField(value, 32), CppRuntimeException); |
702 | 1 | ASSERT_THROW(ReflectableFactory::getFixedUnsignedBitField(value, 65), CppRuntimeException); |
703 | 1 | } |
704 | | |
705 | | TEST_F(ReflectableTest, dynamicSignedBitField5) // mapped to int8_t |
706 | 1 | { |
707 | 1 | const uint8_t maxBitSize = 8; |
708 | 1 | const uint8_t numBits = 5; |
709 | 1 | const int8_t value = 15; |
710 | 1 | auto reflectable = ReflectableFactory::getDynamicSignedBitField(value, maxBitSize, numBits); |
711 | 1 | checkSignedIntegral(value, reflectable, &IReflectable::getInt8, |
712 | 1 | std::bind(&BitStreamReader::readSignedBits, _1, numBits), numBits); |
713 | | |
714 | | // maxBitSize out of bounds |
715 | 1 | ASSERT_THROW(ReflectableFactory::getDynamicSignedBitField(value, 9, numBits), CppRuntimeException); |
716 | | |
717 | | // dynamicBitSize out of bounds |
718 | 1 | ASSERT_THROW(ReflectableFactory::getDynamicSignedBitField(value, 4, numBits), CppRuntimeException); |
719 | 1 | } |
720 | | |
721 | | TEST_F(ReflectableTest, dynamicSignedBitField15) // mapped to int16_t |
722 | 1 | { |
723 | 1 | const uint8_t maxBitSize = 16; |
724 | 1 | const uint8_t numBits = 15; |
725 | 1 | const int16_t value = -15; |
726 | 1 | auto reflectable = ReflectableFactory::getDynamicSignedBitField(value, maxBitSize, numBits); |
727 | 1 | checkSignedIntegral(value, reflectable, &IReflectable::getInt16, |
728 | 1 | std::bind(&BitStreamReader::readSignedBits, _1, numBits), numBits); |
729 | | |
730 | | // maxBitSize out of bounds |
731 | 1 | ASSERT_THROW(ReflectableFactory::getDynamicSignedBitField(value, 8, numBits), CppRuntimeException); |
732 | 1 | ASSERT_THROW(ReflectableFactory::getDynamicSignedBitField(value, 17, numBits), CppRuntimeException); |
733 | | |
734 | | // dynamicBitSize out of bounds |
735 | 1 | ASSERT_THROW(ReflectableFactory::getDynamicSignedBitField(value, 12, numBits), CppRuntimeException); |
736 | 1 | } |
737 | | |
738 | | TEST_F(ReflectableTest, dynamicSignedBitField31) // mapped to int32_t |
739 | 1 | { |
740 | 1 | const uint8_t maxBitSize = 32; |
741 | 1 | const uint8_t numBits = 31; |
742 | 1 | const int32_t value = -12345678; |
743 | 1 | auto reflectable = ReflectableFactory::getDynamicSignedBitField(value, maxBitSize, numBits); |
744 | 1 | checkSignedIntegral(value, reflectable, &IReflectable::getInt32, |
745 | 1 | std::bind(&BitStreamReader::readSignedBits, _1, numBits), numBits); |
746 | | |
747 | | // maxBitSize out of bounds |
748 | 1 | ASSERT_THROW(ReflectableFactory::getDynamicSignedBitField(value, 16, numBits), CppRuntimeException); |
749 | 1 | ASSERT_THROW(ReflectableFactory::getDynamicSignedBitField(value, 33, numBits), CppRuntimeException); |
750 | | |
751 | | // dynamicBitSize out of bounds |
752 | 1 | ASSERT_THROW(ReflectableFactory::getDynamicSignedBitField(value, 29, numBits), CppRuntimeException); |
753 | 1 | } |
754 | | |
755 | | TEST_F(ReflectableTest, dynamicSignedBitField60) // mapped to int64_t |
756 | 1 | { |
757 | 1 | const uint8_t maxBitSize = 64; |
758 | 1 | const uint8_t numBits = 60; |
759 | 1 | const int64_t value = 1234567890; |
760 | 1 | auto reflectable = ReflectableFactory::getDynamicSignedBitField(value, maxBitSize, numBits); |
761 | 1 | checkSignedIntegral(value, reflectable, &IReflectable::getInt64, |
762 | 1 | std::bind(&BitStreamReader::readSignedBits64, _1, numBits), numBits); |
763 | | |
764 | | // maxBitSize out of bounds |
765 | 1 | ASSERT_THROW(ReflectableFactory::getDynamicSignedBitField(value, 32, numBits), CppRuntimeException); |
766 | 1 | ASSERT_THROW(ReflectableFactory::getDynamicSignedBitField(value, 65, numBits), CppRuntimeException); |
767 | | |
768 | | // dynamicBitSize out of bounds |
769 | 1 | ASSERT_THROW(ReflectableFactory::getDynamicSignedBitField(value, 58, numBits), CppRuntimeException); |
770 | | |
771 | | // dynamic signed bit field as a type reference (maxBitSize must be 64!) |
772 | 1 | ASSERT_NO_THROW(ReflectableFactory::getDynamicSignedBitField(value, 64)); |
773 | 1 | ASSERT_THROW(ReflectableFactory::getDynamicSignedBitField(value, 58), CppRuntimeException); |
774 | 1 | } |
775 | | |
776 | | TEST_F(ReflectableTest, dynamicUnsignedBitField7) // mapped to uint8_t |
777 | 1 | { |
778 | 1 | const uint8_t maxBitSize = 8; |
779 | 1 | const uint8_t numBits = 7; |
780 | 1 | const uint8_t value = 0x2F; |
781 | 1 | auto reflectable = ReflectableFactory::getDynamicUnsignedBitField(value, maxBitSize, numBits); |
782 | 1 | checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt8, |
783 | 1 | std::bind(&BitStreamReader::readBits, _1, numBits), numBits); |
784 | | |
785 | | // maxBitSize out of bounds |
786 | 1 | ASSERT_THROW(ReflectableFactory::getDynamicUnsignedBitField(value, 9, numBits), CppRuntimeException); |
787 | | |
788 | | // dynamicBitSize out of bounds |
789 | 1 | ASSERT_THROW(ReflectableFactory::getDynamicUnsignedBitField(value, 6, numBits), CppRuntimeException); |
790 | 1 | } |
791 | | |
792 | | TEST_F(ReflectableTest, dynamicUnsignedBitField9) // mapped to uint16_t |
793 | 1 | { |
794 | 1 | const uint8_t maxBitSize = 16; |
795 | 1 | const uint8_t numBits = 9; |
796 | 1 | const uint16_t value = 0x1FF; |
797 | 1 | auto reflectable = ReflectableFactory::getDynamicUnsignedBitField(value, maxBitSize, numBits); |
798 | 1 | checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt16, |
799 | 1 | std::bind(&BitStreamReader::readBits, _1, numBits), numBits); |
800 | | |
801 | | // maxBitSize out of bounds |
802 | 1 | ASSERT_THROW(ReflectableFactory::getDynamicUnsignedBitField(value, 8, numBits), CppRuntimeException); |
803 | 1 | ASSERT_THROW(ReflectableFactory::getDynamicUnsignedBitField(value, 17, numBits), CppRuntimeException); |
804 | | |
805 | | // dynamicBitSize out of bounds |
806 | 1 | ASSERT_THROW(ReflectableFactory::getDynamicUnsignedBitField(value, 9, 10), CppRuntimeException); |
807 | 1 | } |
808 | | |
809 | | TEST_F(ReflectableTest, dynamicUnsignedBitField31) // mapped to uint32_t |
810 | 1 | { |
811 | 1 | const uint8_t maxBitSize = 32; |
812 | 1 | const uint8_t numBits = 31; |
813 | 1 | const uint32_t value = UINT32_MAX >> 1; |
814 | 1 | auto reflectable = ReflectableFactory::getDynamicUnsignedBitField(value, maxBitSize, numBits); |
815 | 1 | checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt32, |
816 | 1 | std::bind(&BitStreamReader::readBits, _1, numBits), numBits); |
817 | | |
818 | | // maxBitSize out of bounds |
819 | 1 | ASSERT_THROW(ReflectableFactory::getDynamicUnsignedBitField(value, 16, numBits), CppRuntimeException); |
820 | 1 | ASSERT_THROW(ReflectableFactory::getDynamicUnsignedBitField(value, 33, numBits), CppRuntimeException); |
821 | | |
822 | | // dynamicBitSize out of bounds |
823 | 1 | ASSERT_THROW(ReflectableFactory::getDynamicUnsignedBitField(value, 29, numBits), CppRuntimeException); |
824 | 1 | } |
825 | | |
826 | | TEST_F(ReflectableTest, dynamicUnsignedBitField33) // mapped to uint64_t |
827 | 1 | { |
828 | 1 | const uint8_t maxBitSize = 64; |
829 | 1 | const uint8_t numBits = 33; |
830 | 1 | const uint64_t value = static_cast<uint64_t>(UINT32_MAX) << 1U; |
831 | 1 | auto reflectable = ReflectableFactory::getDynamicUnsignedBitField(value, maxBitSize, numBits); |
832 | 1 | checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt64, |
833 | 1 | std::bind(&BitStreamReader::readBits64, _1, numBits), numBits); |
834 | | |
835 | | // maxBitSize out of bounds |
836 | 1 | ASSERT_THROW(ReflectableFactory::getDynamicUnsignedBitField(value, 32, numBits), CppRuntimeException); |
837 | 1 | ASSERT_THROW(ReflectableFactory::getDynamicUnsignedBitField(value, 65, numBits), CppRuntimeException); |
838 | | |
839 | | // dynamicBitSize out of bounds |
840 | 1 | ASSERT_THROW(ReflectableFactory::getDynamicUnsignedBitField(value, 33, 34), CppRuntimeException); |
841 | | |
842 | | // dynamic unsigned bit field as a type reference (maxBitSize must be 64!) |
843 | 1 | ASSERT_NO_THROW(ReflectableFactory::getDynamicUnsignedBitField(value, 64)); |
844 | 1 | ASSERT_THROW(ReflectableFactory::getDynamicUnsignedBitField(value, 58), CppRuntimeException); |
845 | 1 | } |
846 | | |
847 | | TEST_F(ReflectableTest, varint16Reflectable) |
848 | 1 | { |
849 | 1 | const int16_t value = -1234; |
850 | 1 | auto reflectable = ReflectableFactory::getVarInt16(value); |
851 | 1 | checkSignedIntegral(value, reflectable, &IReflectable::getInt16, |
852 | 1 | std::bind(&BitStreamReader::readVarInt16, _1), bitSizeOfVarInt16(value)); |
853 | 1 | } |
854 | | |
855 | | TEST_F(ReflectableTest, varint32Reflectable) |
856 | 1 | { |
857 | 1 | const int32_t value = 54321; |
858 | 1 | auto reflectable = ReflectableFactory::getVarInt32(value); |
859 | 1 | checkSignedIntegral(value, reflectable, &IReflectable::getInt32, |
860 | 1 | std::bind(&BitStreamReader::readVarInt32, _1), bitSizeOfVarInt32(value)); |
861 | 1 | } |
862 | | |
863 | | TEST_F(ReflectableTest, varint64Reflectable) |
864 | 1 | { |
865 | 1 | const int64_t value = -87654321; |
866 | 1 | auto reflectable = ReflectableFactory::getVarInt64(value); |
867 | 1 | checkSignedIntegral(value, reflectable, &IReflectable::getInt64, |
868 | 1 | std::bind(&BitStreamReader::readVarInt64, _1), bitSizeOfVarInt64(value)); |
869 | 1 | } |
870 | | |
871 | | TEST_F(ReflectableTest, varintReflectable) |
872 | 1 | { |
873 | 1 | const int64_t value = INT64_MAX; |
874 | 1 | auto reflectable = ReflectableFactory::getVarInt(value); |
875 | 1 | checkSignedIntegral(value, reflectable, &IReflectable::getInt64, |
876 | 1 | std::bind(&BitStreamReader::readVarInt, _1), bitSizeOfVarInt(value)); |
877 | 1 | } |
878 | | |
879 | | TEST_F(ReflectableTest, varuint16Reflectable) |
880 | 1 | { |
881 | 1 | const uint16_t value = 1234; |
882 | 1 | auto reflectable = ReflectableFactory::getVarUInt16(value); |
883 | 1 | checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt16, |
884 | 1 | std::bind(&BitStreamReader::readVarUInt16, _1), bitSizeOfVarUInt16(value)); |
885 | 1 | } |
886 | | |
887 | | TEST_F(ReflectableTest, varuint32Reflectable) |
888 | 1 | { |
889 | 1 | const uint32_t value = 0x1FFFFFFF; |
890 | 1 | auto reflectable = ReflectableFactory::getVarUInt32(value); |
891 | 1 | checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt32, |
892 | 1 | std::bind(&BitStreamReader::readVarUInt32, _1), bitSizeOfVarUInt32(value)); |
893 | 1 | } |
894 | | |
895 | | TEST_F(ReflectableTest, varuint64Reflectable) |
896 | 1 | { |
897 | 1 | const uint64_t value = 4242424242; |
898 | 1 | auto reflectable = ReflectableFactory::getVarUInt64(value); |
899 | 1 | checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt64, |
900 | 1 | std::bind(&BitStreamReader::readVarUInt64, _1), bitSizeOfVarUInt64(value)); |
901 | 1 | } |
902 | | |
903 | | TEST_F(ReflectableTest, varuintReflectable) |
904 | 1 | { |
905 | 1 | const uint64_t value = UINT64_MAX; |
906 | 1 | auto reflectable = ReflectableFactory::getVarUInt(value); |
907 | 1 | checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt64, |
908 | 1 | std::bind(&BitStreamReader::readVarUInt, _1), bitSizeOfVarUInt(value)); |
909 | 1 | } |
910 | | |
911 | | TEST_F(ReflectableTest, varsizeReflectable) |
912 | 1 | { |
913 | 1 | const uint32_t value = (UINT32_C(1) << (7+7+7+7+3)) - 1; |
914 | 1 | auto reflectable = ReflectableFactory::getVarSize(value); |
915 | 1 | checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt32, |
916 | 1 | std::bind(&BitStreamReader::readVarSize, _1), bitSizeOfVarSize(value)); |
917 | 1 | } |
918 | | |
919 | | TEST_F(ReflectableTest, float16Reflectable) |
920 | 1 | { |
921 | 1 | const float value = 2.0F; |
922 | 1 | auto reflectable = ReflectableFactory::getFloat16(value); |
923 | 1 | checkFloatingPoint(value, reflectable, &IReflectable::getFloat, |
924 | 1 | std::bind(&BitStreamReader::readFloat16, _1)); |
925 | 1 | } |
926 | | |
927 | | TEST_F(ReflectableTest, float32Reflectable) |
928 | 1 | { |
929 | 1 | const float value = 1.2F; |
930 | 1 | auto reflectable = ReflectableFactory::getFloat32(value); |
931 | 1 | checkFloatingPoint(value, reflectable, &IReflectable::getFloat, |
932 | 1 | std::bind(&BitStreamReader::readFloat32, _1)); |
933 | 1 | } |
934 | | |
935 | | TEST_F(ReflectableTest, float64Reflectable) |
936 | 1 | { |
937 | 1 | const double value = 1.2; |
938 | 1 | auto reflectable = ReflectableFactory::getFloat64(value); |
939 | 1 | checkFloatingPoint(value, reflectable, &IReflectable::getDouble, |
940 | 1 | std::bind(&BitStreamReader::readFloat64, _1)); |
941 | 1 | } |
942 | | |
943 | | TEST_F(ReflectableTest, stringReflectable) |
944 | 1 | { |
945 | 1 | const std::string value = "some longer string value to have a chance that some allocation hopefully occurs"; |
946 | 1 | auto reflectable = ReflectableFactory::getString(value); |
947 | 1 | checkString(value, reflectable); |
948 | 1 | } |
949 | | |
950 | | TEST_F(ReflectableTest, stringViewReflectable) |
951 | 1 | { |
952 | 1 | auto view = makeStringView("some text as a string view"); |
953 | 1 | auto reflectable = ReflectableFactory::getString(view); |
954 | 1 | checkString(view, reflectable); |
955 | 1 | } |
956 | | |
957 | | TEST_F(ReflectableTest, bitBufferReflectable) |
958 | 1 | { |
959 | 1 | const BitBuffer value = BitBuffer{std::vector<uint8_t>({0xAB, 0xF0}), 12}; |
960 | 1 | auto reflectable = ReflectableFactory::getBitBuffer(value); |
961 | 1 | checkBitBuffer(value, reflectable); |
962 | 1 | } |
963 | | |
964 | | TEST_F(ReflectableTest, bytesReflectable) |
965 | 1 | { |
966 | 1 | const vector<uint8_t> value{{0, 127, 128, 255}}; |
967 | 1 | auto reflectable = ReflectableFactory::getBytes(value); |
968 | 1 | checkBytes(value, reflectable); |
969 | 1 | } |
970 | | |
971 | | TEST_F(ReflectableTest, boolConstArray) |
972 | 1 | { |
973 | 1 | const auto rawArray = std::vector<bool>({true, false, true, false}); |
974 | 1 | auto reflectable = ReflectableFactory::getBoolArray(rawArray); |
975 | 1 | checkArray(rawArray, reflectable, |
976 | 4 | [&](bool value, const IReflectableConstPtr& elementReflectable) { |
977 | 4 | checkUnsignedIntegral(value, elementReflectable, &IReflectable::getBool, |
978 | 4 | std::bind(&BitStreamReader::readBool, _1)); |
979 | 4 | } |
980 | 1 | ); |
981 | 1 | } |
982 | | |
983 | | TEST_F(ReflectableTest, boolArray) |
984 | 1 | { |
985 | 1 | auto rawArray = std::vector<bool>({true, false, true, false}); |
986 | 1 | auto reflectable = ReflectableFactory::getBoolArray(rawArray); |
987 | 1 | checkArray(rawArray, reflectable, |
988 | 4 | [&](bool value, const IReflectableConstPtr& elementReflectable) { |
989 | 4 | checkUnsignedIntegral(value, elementReflectable, &IReflectable::getBool, |
990 | 4 | std::bind(&BitStreamReader::readBool, _1)); |
991 | 4 | } |
992 | 1 | ); |
993 | 1 | } |
994 | | |
995 | | TEST_F(ReflectableTest, int8ConstArray) |
996 | 1 | { |
997 | 1 | const auto rawArray = std::vector<int8_t>({-10, -20, 30, 40}); |
998 | 1 | auto reflectable = ReflectableFactory::getInt8Array(rawArray); |
999 | 1 | checkArray(rawArray, reflectable, |
1000 | 4 | [&](int8_t value, const IReflectableConstPtr& elementReflectable) { |
1001 | 4 | checkSignedIntegral(value, elementReflectable, &IReflectable::getInt8, |
1002 | 4 | std::bind(&BitStreamReader::readSignedBits, _1, 8)); |
1003 | 4 | } |
1004 | 1 | ); |
1005 | | |
1006 | 1 | auto nonConstReflectable = std::const_pointer_cast<IReflectable>(reflectable); |
1007 | 1 | ASSERT_THROW(nonConstReflectable->getAnyValue(), CppRuntimeException); |
1008 | 1 | } |
1009 | | |
1010 | | TEST_F(ReflectableTest, int8Array) |
1011 | 1 | { |
1012 | 1 | auto rawArray = std::vector<int8_t>({-10, -20, 30, 40}); |
1013 | 1 | auto reflectable = ReflectableFactory::getInt8Array(rawArray); |
1014 | 1 | checkArray(rawArray, reflectable, |
1015 | 4 | [&](int8_t value, const IReflectableConstPtr& elementReflectable) { |
1016 | 4 | checkSignedIntegral(value, elementReflectable, &IReflectable::getInt8, |
1017 | 4 | std::bind(&BitStreamReader::readSignedBits, _1, 8)); |
1018 | 4 | } |
1019 | 1 | ); |
1020 | 1 | checkArray(rawArray, static_cast<IReflectableConstPtr>(reflectable), |
1021 | 4 | [&](int8_t value, const IReflectableConstPtr& elementReflectable) { |
1022 | 4 | checkSignedIntegral(value, elementReflectable, &IReflectable::getInt8, |
1023 | 4 | std::bind(&BitStreamReader::readSignedBits, _1, 8)); |
1024 | 4 | } |
1025 | 1 | ); |
1026 | | |
1027 | 1 | reflectable->resize(0); |
1028 | 1 | ASSERT_EQ(0, reflectable->size()); |
1029 | 1 | reflectable->append(AnyHolder<>(static_cast<int8_t>(13))); |
1030 | 1 | ASSERT_EQ(1, reflectable->size()); |
1031 | 1 | ASSERT_EQ(13, reflectable->at(0)->getInt8()); |
1032 | 1 | reflectable->setAt(AnyHolder<>(static_cast<int8_t>(42)), 0); |
1033 | 1 | ASSERT_EQ(1, reflectable->size()); |
1034 | 1 | ASSERT_EQ(42, reflectable->at(0)->getInt8()); |
1035 | 1 | reflectable->resize(2); |
1036 | 1 | ASSERT_EQ(2, reflectable->size()); |
1037 | | |
1038 | | // out of range |
1039 | 1 | ASSERT_THROW(reflectable->setAt(AnyHolder<>(static_cast<int8_t>(-42)), 2), CppRuntimeException); |
1040 | 1 | } |
1041 | | |
1042 | | TEST_F(ReflectableTest, int16ConstArray) |
1043 | 1 | { |
1044 | 1 | const auto rawArray = std::vector<int16_t>({-100, -200, 300, 400}); |
1045 | 1 | auto reflectable = ReflectableFactory::getInt16Array(rawArray); |
1046 | 1 | checkArray(rawArray, reflectable, |
1047 | 4 | [&](int16_t value, const IReflectableConstPtr& elementReflectable) { |
1048 | 4 | checkSignedIntegral(value, elementReflectable, &IReflectable::getInt16, |
1049 | 4 | std::bind(&BitStreamReader::readSignedBits, _1, 16)); |
1050 | 4 | } |
1051 | 1 | ); |
1052 | 1 | } |
1053 | | |
1054 | | TEST_F(ReflectableTest, int16Array) |
1055 | 1 | { |
1056 | 1 | auto rawArray = std::vector<int16_t>({-100, -200, 300, 400}); |
1057 | 1 | auto reflectable = ReflectableFactory::getInt16Array(rawArray); |
1058 | 1 | checkArray(rawArray, reflectable, |
1059 | 4 | [&](int16_t value, const IReflectableConstPtr& elementReflectable) { |
1060 | 4 | checkSignedIntegral(value, elementReflectable, &IReflectable::getInt16, |
1061 | 4 | std::bind(&BitStreamReader::readSignedBits, _1, 16)); |
1062 | 4 | } |
1063 | 1 | ); |
1064 | 1 | } |
1065 | | |
1066 | | TEST_F(ReflectableTest, int32ConstArray) |
1067 | 1 | { |
1068 | 1 | const auto rawArray = std::vector<int32_t>({-10000, -20000, 30000, 40000}); |
1069 | 1 | auto reflectable = ReflectableFactory::getInt32Array(rawArray); |
1070 | 1 | checkArray(rawArray, reflectable, |
1071 | 4 | [&](int32_t value, const IReflectableConstPtr& elementReflectable) { |
1072 | 4 | checkSignedIntegral(value, elementReflectable, &IReflectable::getInt32, |
1073 | 4 | std::bind(&BitStreamReader::readSignedBits, _1, 32)); |
1074 | 4 | } |
1075 | 1 | ); |
1076 | 1 | } |
1077 | | |
1078 | | TEST_F(ReflectableTest, int32Array) |
1079 | 1 | { |
1080 | 1 | auto rawArray = std::vector<int32_t>({-10000, -20000, 30000, 40000}); |
1081 | 1 | auto reflectable = ReflectableFactory::getInt32Array(rawArray); |
1082 | 1 | checkArray(rawArray, reflectable, |
1083 | 4 | [&](int32_t value, const IReflectableConstPtr& elementReflectable) { |
1084 | 4 | checkSignedIntegral(value, elementReflectable, &IReflectable::getInt32, |
1085 | 4 | std::bind(&BitStreamReader::readSignedBits, _1, 32)); |
1086 | 4 | } |
1087 | 1 | ); |
1088 | 1 | } |
1089 | | |
1090 | | TEST_F(ReflectableTest, int64ConstArray) |
1091 | 1 | { |
1092 | 1 | const auto rawArray = std::vector<int64_t>({-10000000, -20000000, 30000000, 40000000}); |
1093 | 1 | auto reflectable = ReflectableFactory::getInt64Array(rawArray); |
1094 | 1 | checkArray(rawArray, reflectable, |
1095 | 4 | [&](int64_t value, const IReflectableConstPtr& elementReflectable) { |
1096 | 4 | checkSignedIntegral(value, elementReflectable, &IReflectable::getInt64, |
1097 | 4 | std::bind(&BitStreamReader::readSignedBits64, _1, 64)); |
1098 | 4 | } |
1099 | 1 | ); |
1100 | 1 | } |
1101 | | |
1102 | | TEST_F(ReflectableTest, int64Array) |
1103 | 1 | { |
1104 | 1 | auto rawArray = std::vector<int64_t>({-10000000, -20000000, 30000000, 40000000}); |
1105 | 1 | auto reflectable = ReflectableFactory::getInt64Array(rawArray); |
1106 | 1 | checkArray(rawArray, reflectable, |
1107 | 4 | [&](int64_t value, const IReflectableConstPtr& elementReflectable) { |
1108 | 4 | checkSignedIntegral(value, elementReflectable, &IReflectable::getInt64, |
1109 | 4 | std::bind(&BitStreamReader::readSignedBits64, _1, 64)); |
1110 | 4 | } |
1111 | 1 | ); |
1112 | 1 | } |
1113 | | |
1114 | | TEST_F(ReflectableTest, uint8ConstArray) |
1115 | 1 | { |
1116 | 1 | const auto rawArray = std::vector<uint8_t>({10, 20, 30, 40}); |
1117 | 1 | auto reflectable = ReflectableFactory::getUInt8Array(rawArray); |
1118 | 1 | checkArray(rawArray, reflectable, |
1119 | 4 | [&](uint8_t value, const IReflectableConstPtr& elementReflectable) { |
1120 | 4 | checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt8, |
1121 | 4 | std::bind(&BitStreamReader::readBits, _1, 8)); |
1122 | 4 | } |
1123 | 1 | ); |
1124 | 1 | } |
1125 | | |
1126 | | TEST_F(ReflectableTest, uint8Array) |
1127 | 1 | { |
1128 | 1 | auto rawArray = std::vector<uint8_t>{{10, 20, 30, 40}}; |
1129 | 1 | auto reflectable = ReflectableFactory::getUInt8Array(rawArray); |
1130 | 1 | checkArray(rawArray, reflectable, |
1131 | 4 | [&](uint8_t value, const IReflectablePtr& elementReflectable) { |
1132 | 4 | checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt8, |
1133 | 4 | std::bind(&BitStreamReader::readBits, _1, 8)); |
1134 | 4 | } |
1135 | 1 | ); |
1136 | 1 | } |
1137 | | |
1138 | | TEST_F(ReflectableTest, uint16ConstArray) |
1139 | 1 | { |
1140 | 1 | const auto rawArray = std::vector<uint16_t>({100, 200, 300, 400}); |
1141 | 1 | auto reflectable = ReflectableFactory::getUInt16Array(rawArray); |
1142 | 1 | checkArray(rawArray, reflectable, |
1143 | 4 | [&](uint16_t value, const IReflectableConstPtr& elementReflectable) { |
1144 | 4 | checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt16, |
1145 | 4 | std::bind(&BitStreamReader::readBits, _1, 16)); |
1146 | 4 | } |
1147 | 1 | ); |
1148 | 1 | } |
1149 | | |
1150 | | TEST_F(ReflectableTest, uint16Array) |
1151 | 1 | { |
1152 | 1 | auto rawArray = std::vector<uint16_t>{{100, 200, 300, 400}}; |
1153 | 1 | auto reflectable = ReflectableFactory::getUInt16Array(rawArray); |
1154 | 1 | checkArray(rawArray, reflectable, |
1155 | 4 | [&](uint16_t value, const IReflectablePtr& elementReflectable) { |
1156 | 4 | checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt16, |
1157 | 4 | std::bind(&BitStreamReader::readBits, _1, 16)); |
1158 | 4 | } |
1159 | 1 | ); |
1160 | 1 | } |
1161 | | |
1162 | | TEST_F(ReflectableTest, uint32ConstArray) |
1163 | 1 | { |
1164 | 1 | const auto rawArray = std::vector<uint32_t>({10000, 20000, 30000, 40000}); |
1165 | 1 | auto reflectable = ReflectableFactory::getUInt32Array(rawArray); |
1166 | 1 | checkArray(rawArray, reflectable, |
1167 | 4 | [&](uint32_t value, const IReflectableConstPtr& elementReflectable) { |
1168 | 4 | checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt32, |
1169 | 4 | std::bind(&BitStreamReader::readBits, _1, 32)); |
1170 | 4 | } |
1171 | 1 | ); |
1172 | 1 | } |
1173 | | |
1174 | | |
1175 | | |
1176 | | TEST_F(ReflectableTest, uint32Array) |
1177 | 1 | { |
1178 | 1 | auto rawArray = std::vector<uint32_t>{{10000, 20000, 30000, 40000}}; |
1179 | 1 | auto reflectable = ReflectableFactory::getUInt32Array(rawArray); |
1180 | 1 | checkArray(rawArray, reflectable, |
1181 | 4 | [&](uint32_t value, const IReflectablePtr& elementReflectable) { |
1182 | 4 | checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt32, |
1183 | 4 | std::bind(&BitStreamReader::readBits, _1, 32)); |
1184 | 4 | } |
1185 | 1 | ); |
1186 | 1 | } |
1187 | | |
1188 | | TEST_F(ReflectableTest, uint64ConstArray) |
1189 | 1 | { |
1190 | 1 | const auto rawArray = std::vector<uint64_t>({10000000, 20000000, 30000000, 40000000}); |
1191 | 1 | auto reflectable = ReflectableFactory::getUInt64Array(rawArray); |
1192 | 1 | checkArray(rawArray, reflectable, |
1193 | 4 | [&](uint64_t value, const IReflectableConstPtr& elementReflectable) { |
1194 | 4 | checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt64, |
1195 | 4 | std::bind(&BitStreamReader::readBits64, _1, 64)); |
1196 | 4 | } |
1197 | 1 | ); |
1198 | 1 | } |
1199 | | |
1200 | | TEST_F(ReflectableTest, uint64Array) |
1201 | 1 | { |
1202 | 1 | auto rawArray = std::vector<uint64_t>{{10000000, 20000000, 30000000, 40000000}}; |
1203 | 1 | auto reflectable = ReflectableFactory::getUInt64Array(rawArray); |
1204 | 1 | checkArray(rawArray, reflectable, |
1205 | 4 | [&](uint64_t value, const IReflectablePtr& elementReflectable) { |
1206 | 4 | checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt64, |
1207 | 4 | std::bind(&BitStreamReader::readBits64, _1, 64)); |
1208 | 4 | } |
1209 | 1 | ); |
1210 | 1 | } |
1211 | | |
1212 | | TEST_F(ReflectableTest, fixedSignedBitField5ConstArray) |
1213 | 1 | { |
1214 | 1 | const uint8_t numBits = 5; |
1215 | 1 | const auto rawArray = std::vector<int8_t>{{-3, -1, 2, 4, 6}}; |
1216 | 1 | auto reflectable = ReflectableFactory::getFixedSignedBitFieldArray(rawArray, numBits); |
1217 | 1 | checkArray(rawArray, reflectable, |
1218 | 5 | [&](int8_t value, const IReflectableConstPtr& elementReflectable) { |
1219 | 5 | checkSignedIntegral(value, elementReflectable, &IReflectable::getInt8, |
1220 | 5 | std::bind(&BitStreamReader::readSignedBits, _1, numBits), numBits); |
1221 | 5 | } |
1222 | 1 | ); |
1223 | 1 | } |
1224 | | |
1225 | | TEST_F(ReflectableTest, fixedSignedBitField5Array) |
1226 | 1 | { |
1227 | 1 | const uint8_t numBits = 5; |
1228 | 1 | auto rawArray = std::vector<int8_t>{{-3, -1, 2, 4, 6}}; |
1229 | 1 | auto reflectable = ReflectableFactory::getFixedSignedBitFieldArray(rawArray, numBits); |
1230 | 1 | checkArray(rawArray, reflectable, |
1231 | 5 | [&](int8_t value, const IReflectableConstPtr& elementReflectable) { |
1232 | 5 | checkSignedIntegral(value, elementReflectable, &IReflectable::getInt8, |
1233 | 5 | std::bind(&BitStreamReader::readSignedBits, _1, numBits), numBits); |
1234 | 5 | } |
1235 | 1 | ); |
1236 | 1 | checkArray(rawArray, static_cast<IReflectableConstPtr>(reflectable), |
1237 | 5 | [&](int8_t value, const IReflectableConstPtr& elementReflectable) { |
1238 | 5 | checkSignedIntegral(value, elementReflectable, &IReflectable::getInt8, |
1239 | 5 | std::bind(&BitStreamReader::readSignedBits, _1, numBits), numBits); |
1240 | 5 | } |
1241 | 1 | ); |
1242 | | |
1243 | 1 | reflectable->resize(0); |
1244 | 1 | ASSERT_EQ(0, reflectable->size()); |
1245 | 1 | reflectable->append(AnyHolder<>(static_cast<int8_t>(13))); |
1246 | 1 | ASSERT_EQ(1, reflectable->size()); |
1247 | 1 | ASSERT_EQ(13, reflectable->at(0)->getInt8()); |
1248 | 1 | reflectable->setAt(AnyHolder<>(static_cast<int8_t>(42)), 0); |
1249 | 1 | ASSERT_EQ(1, reflectable->size()); |
1250 | 1 | ASSERT_EQ(42, reflectable->at(0)->getInt8()); |
1251 | 1 | reflectable->resize(2); |
1252 | 1 | ASSERT_EQ(2, reflectable->size()); |
1253 | | |
1254 | | // out of range |
1255 | 1 | ASSERT_THROW(reflectable->setAt(AnyHolder<>(static_cast<int8_t>(42)), 2), CppRuntimeException); |
1256 | 1 | } |
1257 | | |
1258 | | TEST_F(ReflectableTest, fixedUnsignedBitField5ConstArray) |
1259 | 1 | { |
1260 | 1 | const uint8_t numBits = 5; |
1261 | 1 | const auto rawArray = std::vector<uint8_t>{{3, 1, 2, 4, 6}}; |
1262 | 1 | auto reflectable = ReflectableFactory::getFixedUnsignedBitFieldArray(rawArray, numBits); |
1263 | 1 | checkArray(rawArray, reflectable, |
1264 | 5 | [&](uint8_t value, const IReflectableConstPtr& elementReflectable) { |
1265 | 5 | checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt8, |
1266 | 5 | std::bind(&BitStreamReader::readBits, _1, numBits), numBits); |
1267 | 5 | } |
1268 | 1 | ); |
1269 | 1 | } |
1270 | | |
1271 | | TEST_F(ReflectableTest, fixedUnsignedBitField5Array) |
1272 | 1 | { |
1273 | 1 | const uint8_t numBits = 5; |
1274 | 1 | auto rawArray = std::vector<uint8_t>{{3, 1, 2, 4, 6}}; |
1275 | 1 | auto reflectable = ReflectableFactory::getFixedUnsignedBitFieldArray(rawArray, numBits); |
1276 | 1 | checkArray(rawArray, reflectable, |
1277 | 5 | [&](uint8_t value, const IReflectableConstPtr& elementReflectable) { |
1278 | 5 | checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt8, |
1279 | 5 | std::bind(&BitStreamReader::readBits, _1, numBits), numBits); |
1280 | 5 | } |
1281 | 1 | ); |
1282 | 1 | } |
1283 | | |
1284 | | TEST_F(ReflectableTest, dynamicSignedBitField5ConstArray) |
1285 | 1 | { |
1286 | 1 | const uint8_t maxBitSize = 8; |
1287 | 1 | const uint8_t numBits = 5; |
1288 | 1 | const auto rawArray = std::vector<int8_t>{{-3, -1, 2, 4, 6}}; |
1289 | 1 | auto reflectable = ReflectableFactory::getDynamicSignedBitFieldArray(rawArray, maxBitSize, numBits); |
1290 | 1 | checkArray(rawArray, reflectable, |
1291 | 5 | [&](int8_t value, const IReflectableConstPtr& elementReflectable) { |
1292 | 5 | checkSignedIntegral(value, elementReflectable, &IReflectable::getInt8, |
1293 | 5 | std::bind(&BitStreamReader::readSignedBits, _1, numBits), numBits); |
1294 | 5 | } |
1295 | 1 | ); |
1296 | | |
1297 | 1 | auto nonConstReflectable = std::const_pointer_cast<IReflectable>(reflectable); |
1298 | 1 | ASSERT_THROW(nonConstReflectable->getAnyValue(), CppRuntimeException); |
1299 | 1 | } |
1300 | | |
1301 | | TEST_F(ReflectableTest, dynamicSignedBitField5Array) |
1302 | 1 | { |
1303 | 1 | const uint8_t maxBitSize = 8; |
1304 | 1 | const uint8_t numBits = 5; |
1305 | 1 | auto rawArray = std::vector<int8_t>{{-3, -1, 2, 4, 6}}; |
1306 | 1 | auto reflectable = ReflectableFactory::getDynamicSignedBitFieldArray(rawArray, maxBitSize, numBits); |
1307 | 1 | checkArray(rawArray, reflectable, |
1308 | 5 | [&](int8_t value, const IReflectablePtr& elementReflectable) { |
1309 | 5 | checkSignedIntegral(value, elementReflectable, &IReflectable::getInt8, |
1310 | 5 | std::bind(&BitStreamReader::readSignedBits, _1, numBits), numBits); |
1311 | 5 | } |
1312 | 1 | ); |
1313 | 1 | checkArray(rawArray, static_cast<IReflectableConstPtr>(reflectable), |
1314 | 5 | [&](int8_t value, const IReflectableConstPtr& elementReflectable) { |
1315 | 5 | checkSignedIntegral(value, elementReflectable, &IReflectable::getInt8, |
1316 | 5 | std::bind(&BitStreamReader::readSignedBits, _1, numBits), numBits); |
1317 | 5 | } |
1318 | 1 | ); |
1319 | | |
1320 | 1 | reflectable->resize(0); |
1321 | 1 | ASSERT_EQ(0, reflectable->size()); |
1322 | 1 | reflectable->append(AnyHolder<>(static_cast<int8_t>(13))); |
1323 | 1 | ASSERT_EQ(1, reflectable->size()); |
1324 | 1 | ASSERT_EQ(13, reflectable->at(0)->getInt8()); |
1325 | 1 | reflectable->setAt(AnyHolder<>(static_cast<int8_t>(42)), 0); |
1326 | 1 | ASSERT_EQ(1, reflectable->size()); |
1327 | 1 | ASSERT_EQ(42, reflectable->at(0)->getInt8()); |
1328 | 1 | reflectable->resize(2); |
1329 | 1 | ASSERT_EQ(2, reflectable->size()); |
1330 | | |
1331 | | // out of range |
1332 | 1 | ASSERT_THROW(reflectable->setAt(AnyHolder<>(static_cast<int8_t>(42)), 2), CppRuntimeException); |
1333 | 1 | } |
1334 | | |
1335 | | TEST_F(ReflectableTest, dynamicUnsignedBitField5ConstArray) |
1336 | 1 | { |
1337 | 1 | const uint8_t maxBitSize = 8; |
1338 | 1 | const uint8_t numBits = 5; |
1339 | 1 | const auto rawArray = std::vector<uint8_t>{{3, 1, 2, 4, 6}}; |
1340 | 1 | auto reflectable = ReflectableFactory::getDynamicUnsignedBitFieldArray(rawArray, maxBitSize, numBits); |
1341 | 1 | checkArray(rawArray, reflectable, |
1342 | 5 | [&](uint8_t value, const IReflectableConstPtr& elementReflectable) { |
1343 | 5 | checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt8, |
1344 | 5 | std::bind(&BitStreamReader::readBits, _1, numBits), numBits); |
1345 | 5 | } |
1346 | 1 | ); |
1347 | 1 | } |
1348 | | |
1349 | | TEST_F(ReflectableTest, dynamicUnsignedBitField5Array) |
1350 | 1 | { |
1351 | 1 | const uint8_t maxBitSize = 8; |
1352 | 1 | const uint8_t numBits = 5; |
1353 | 1 | auto rawArray = std::vector<uint8_t>{{3, 1, 2, 4, 6}}; |
1354 | 1 | auto reflectable = ReflectableFactory::getDynamicUnsignedBitFieldArray(rawArray, maxBitSize, numBits); |
1355 | 1 | checkArray(rawArray, reflectable, |
1356 | 5 | [&](uint8_t value, const IReflectableConstPtr& elementReflectable) { |
1357 | 5 | checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt8, |
1358 | 5 | std::bind(&BitStreamReader::readBits, _1, numBits), numBits); |
1359 | 5 | } |
1360 | 1 | ); |
1361 | 1 | } |
1362 | | |
1363 | | TEST_F(ReflectableTest, varint16ConstArray) |
1364 | 1 | { |
1365 | 1 | const auto rawArray = std::vector<int16_t>({-10, -20, 30, 40}); |
1366 | 1 | auto reflectable = ReflectableFactory::getVarInt16Array(rawArray); |
1367 | 1 | checkArray(rawArray, reflectable, |
1368 | 4 | [&](int16_t value, const IReflectableConstPtr& elementReflectable) { |
1369 | 4 | checkSignedIntegral(value, elementReflectable, &IReflectable::getInt16, |
1370 | 4 | std::bind(&BitStreamReader::readVarInt16, _1)); |
1371 | 4 | } |
1372 | 1 | ); |
1373 | 1 | } |
1374 | | |
1375 | | TEST_F(ReflectableTest, varint16Array) |
1376 | 1 | { |
1377 | 1 | auto rawArray = std::vector<int16_t>{{-10, -20, 30, 40}}; |
1378 | 1 | auto reflectable = ReflectableFactory::getVarInt16Array(rawArray); |
1379 | 1 | checkArray(rawArray, reflectable, |
1380 | 4 | [&](int16_t value, const IReflectablePtr& elementReflectable) { |
1381 | 4 | checkSignedIntegral(value, elementReflectable, &IReflectable::getInt16, |
1382 | 4 | std::bind(&BitStreamReader::readVarInt16, _1)); |
1383 | 4 | } |
1384 | 1 | ); |
1385 | 1 | } |
1386 | | |
1387 | | TEST_F(ReflectableTest, varint32ConstArray) |
1388 | 1 | { |
1389 | 1 | const auto rawArray = std::vector<int32_t>({-10000, -20000, 30000, 40000}); |
1390 | 1 | auto reflectable = ReflectableFactory::getVarInt32Array(rawArray); |
1391 | 1 | checkArray(rawArray, reflectable, |
1392 | 4 | [&](int32_t value, const IReflectableConstPtr& elementReflectable) { |
1393 | 4 | checkSignedIntegral(value, elementReflectable, &IReflectable::getInt32, |
1394 | 4 | std::bind(&BitStreamReader::readVarInt32, _1)); |
1395 | 4 | } |
1396 | 1 | ); |
1397 | 1 | } |
1398 | | |
1399 | | TEST_F(ReflectableTest, varint32Array) |
1400 | 1 | { |
1401 | 1 | auto rawArray = std::vector<int32_t>{{-10000, -20000, 30000, 40000}}; |
1402 | 1 | auto reflectable = ReflectableFactory::getVarInt32Array(rawArray); |
1403 | 1 | checkArray(rawArray, reflectable, |
1404 | 4 | [&](int32_t value, const IReflectablePtr& elementReflectable) { |
1405 | 4 | checkSignedIntegral(value, elementReflectable, &IReflectable::getInt32, |
1406 | 4 | std::bind(&BitStreamReader::readVarInt32, _1)); |
1407 | 4 | } |
1408 | 1 | ); |
1409 | 1 | } |
1410 | | |
1411 | | TEST_F(ReflectableTest, varint64ConstArray) |
1412 | 1 | { |
1413 | 1 | const auto rawArray = std::vector<int64_t>({-10000000, -20000000, 30000000, 40000000}); |
1414 | 1 | auto reflectable = ReflectableFactory::getVarInt64Array(rawArray); |
1415 | 1 | checkArray(rawArray, reflectable, |
1416 | 4 | [&](int64_t value, const IReflectableConstPtr& elementReflectable) { |
1417 | 4 | checkSignedIntegral(value, elementReflectable, &IReflectable::getInt64, |
1418 | 4 | std::bind(&BitStreamReader::readVarInt64, _1)); |
1419 | 4 | } |
1420 | 1 | ); |
1421 | 1 | } |
1422 | | |
1423 | | TEST_F(ReflectableTest, varint64Array) |
1424 | 1 | { |
1425 | 1 | auto rawArray = std::vector<int64_t>{{-10000000, -20000000, 30000000, 40000000}}; |
1426 | 1 | auto reflectable = ReflectableFactory::getVarInt64Array(rawArray); |
1427 | 1 | checkArray(rawArray, reflectable, |
1428 | 4 | [&](int64_t value, const IReflectablePtr& elementReflectable) { |
1429 | 4 | checkSignedIntegral(value, elementReflectable, &IReflectable::getInt64, |
1430 | 4 | std::bind(&BitStreamReader::readVarInt64, _1)); |
1431 | 4 | } |
1432 | 1 | ); |
1433 | 1 | } |
1434 | | |
1435 | | TEST_F(ReflectableTest, varintConstArray) |
1436 | 1 | { |
1437 | 1 | const auto rawArray = std::vector<int64_t>({-10000000, -20000000, 30000000, 40000000}); |
1438 | 1 | auto reflectable = ReflectableFactory::getVarIntArray(rawArray); |
1439 | 1 | checkArray(rawArray, reflectable, |
1440 | 4 | [&](int64_t value, const IReflectableConstPtr& elementReflectable) { |
1441 | 4 | checkSignedIntegral(value, elementReflectable, &IReflectable::getInt64, |
1442 | 4 | std::bind(&BitStreamReader::readVarInt, _1)); |
1443 | 4 | } |
1444 | 1 | ); |
1445 | 1 | } |
1446 | | |
1447 | | TEST_F(ReflectableTest, varintArray) |
1448 | 1 | { |
1449 | 1 | auto rawArray = std::vector<int64_t>{{-10000000, -20000000, 30000000, 40000000}}; |
1450 | 1 | auto reflectable = ReflectableFactory::getVarIntArray(rawArray); |
1451 | 1 | checkArray(rawArray, reflectable, |
1452 | 4 | [&](int64_t value, const IReflectablePtr& elementReflectable) { |
1453 | 4 | checkSignedIntegral(value, elementReflectable, &IReflectable::getInt64, |
1454 | 4 | std::bind(&BitStreamReader::readVarInt, _1)); |
1455 | 4 | } |
1456 | 1 | ); |
1457 | 1 | } |
1458 | | |
1459 | | TEST_F(ReflectableTest, varuint16ConstArray) |
1460 | 1 | { |
1461 | 1 | const auto rawArray = std::vector<uint16_t>({10, 20, 30, 40}); |
1462 | 1 | auto reflectable = ReflectableFactory::getVarUInt16Array(rawArray); |
1463 | 1 | checkArray(rawArray, reflectable, |
1464 | 4 | [&](uint16_t value, const IReflectableConstPtr& elementReflectable) { |
1465 | 4 | checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt16, |
1466 | 4 | std::bind(&BitStreamReader::readVarUInt16, _1)); |
1467 | 4 | } |
1468 | 1 | ); |
1469 | 1 | } |
1470 | | |
1471 | | TEST_F(ReflectableTest, varuint16Array) |
1472 | 1 | { |
1473 | 1 | auto rawArray = std::vector<uint16_t>{{10, 20, 30, 40}}; |
1474 | 1 | auto reflectable = ReflectableFactory::getVarUInt16Array(rawArray); |
1475 | 1 | checkArray(rawArray, reflectable, |
1476 | 4 | [&](uint16_t value, const IReflectablePtr& elementReflectable) { |
1477 | 4 | checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt16, |
1478 | 4 | std::bind(&BitStreamReader::readVarUInt16, _1)); |
1479 | 4 | } |
1480 | 1 | ); |
1481 | 1 | } |
1482 | | |
1483 | | TEST_F(ReflectableTest, varuint32ConstArray) |
1484 | 1 | { |
1485 | 1 | const auto rawArray = std::vector<uint32_t>({10000, 20000, 30000, 40000}); |
1486 | 1 | auto reflectable = ReflectableFactory::getVarUInt32Array(rawArray); |
1487 | 1 | checkArray(rawArray, reflectable, |
1488 | 4 | [&](uint32_t value, const IReflectableConstPtr& elementReflectable) { |
1489 | 4 | checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt32, |
1490 | 4 | std::bind(&BitStreamReader::readVarUInt32, _1)); |
1491 | 4 | } |
1492 | 1 | ); |
1493 | 1 | } |
1494 | | |
1495 | | TEST_F(ReflectableTest, varuint32Array) |
1496 | 1 | { |
1497 | 1 | auto rawArray = std::vector<uint32_t>{{10000, 20000, 30000, 40000}}; |
1498 | 1 | auto reflectable = ReflectableFactory::getVarUInt32Array(rawArray); |
1499 | 1 | checkArray(rawArray, reflectable, |
1500 | 4 | [&](uint32_t value, const IReflectablePtr& elementReflectable) { |
1501 | 4 | checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt32, |
1502 | 4 | std::bind(&BitStreamReader::readVarUInt32, _1)); |
1503 | 4 | } |
1504 | 1 | ); |
1505 | 1 | } |
1506 | | |
1507 | | TEST_F(ReflectableTest, varuint64ConstArray) |
1508 | 1 | { |
1509 | 1 | const auto rawArray = std::vector<uint64_t>({10000, 20000, 30000, 40000}); |
1510 | 1 | auto reflectable = ReflectableFactory::getVarUInt64Array(rawArray); |
1511 | 1 | checkArray(rawArray, reflectable, |
1512 | 4 | [&](uint64_t value, const IReflectableConstPtr& elementReflectable) { |
1513 | 4 | checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt64, |
1514 | 4 | std::bind(&BitStreamReader::readVarUInt64, _1)); |
1515 | 4 | } |
1516 | 1 | ); |
1517 | 1 | } |
1518 | | |
1519 | | TEST_F(ReflectableTest, varuint64Array) |
1520 | 1 | { |
1521 | 1 | auto rawArray = std::vector<uint64_t>{{10000, 20000, 30000, 40000}}; |
1522 | 1 | auto reflectable = ReflectableFactory::getVarUInt64Array(rawArray); |
1523 | 1 | checkArray(rawArray, reflectable, |
1524 | 4 | [&](uint64_t value, const IReflectablePtr& elementReflectable) { |
1525 | 4 | checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt64, |
1526 | 4 | std::bind(&BitStreamReader::readVarUInt64, _1)); |
1527 | 4 | } |
1528 | 1 | ); |
1529 | 1 | } |
1530 | | |
1531 | | TEST_F(ReflectableTest, varuintConstArray) |
1532 | 1 | { |
1533 | 1 | const auto rawArray = std::vector<uint64_t>({10000, 20000, 30000, 40000}); |
1534 | 1 | auto reflectable = ReflectableFactory::getVarUIntArray(rawArray); |
1535 | 1 | checkArray(rawArray, reflectable, |
1536 | 4 | [&](uint64_t value, const IReflectableConstPtr& elementReflectable) { |
1537 | 4 | checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt64, |
1538 | 4 | std::bind(&BitStreamReader::readVarUInt, _1)); |
1539 | 4 | } |
1540 | 1 | ); |
1541 | 1 | } |
1542 | | |
1543 | | TEST_F(ReflectableTest, varuintArray) |
1544 | 1 | { |
1545 | 1 | auto rawArray = std::vector<uint64_t>{{10000, 20000, 30000, 40000}}; |
1546 | 1 | auto reflectable = ReflectableFactory::getVarUIntArray(rawArray); |
1547 | 1 | checkArray(rawArray, reflectable, |
1548 | 4 | [&](uint64_t value, const IReflectablePtr& elementReflectable) { |
1549 | 4 | checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt64, |
1550 | 4 | std::bind(&BitStreamReader::readVarUInt, _1)); |
1551 | 4 | } |
1552 | 1 | ); |
1553 | 1 | } |
1554 | | |
1555 | | TEST_F(ReflectableTest, varsizeConstArray) |
1556 | 1 | { |
1557 | 1 | const auto rawArray = std::vector<uint32_t>({10000, 20000, 30000, 40000}); |
1558 | 1 | auto reflectable = ReflectableFactory::getVarSizeArray(rawArray); |
1559 | 1 | checkArray(rawArray, reflectable, |
1560 | 4 | [&](uint32_t value, const IReflectableConstPtr& elementReflectable) { |
1561 | 4 | checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt32, |
1562 | 4 | std::bind(&BitStreamReader::readVarSize, _1)); |
1563 | 4 | } |
1564 | 1 | ); |
1565 | 1 | } |
1566 | | |
1567 | | TEST_F(ReflectableTest, varsizeArray) |
1568 | 1 | { |
1569 | 1 | auto rawArray = std::vector<uint32_t>{{10000, 20000, 30000, 40000}}; |
1570 | 1 | auto reflectable = ReflectableFactory::getVarSizeArray(rawArray); |
1571 | 1 | checkArray(rawArray, reflectable, |
1572 | 4 | [&](uint32_t value, const IReflectablePtr& elementReflectable) { |
1573 | 4 | checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt32, |
1574 | 4 | std::bind(&BitStreamReader::readVarSize, _1)); |
1575 | 4 | } |
1576 | 1 | ); |
1577 | 1 | } |
1578 | | |
1579 | | TEST_F(ReflectableTest, float16ConstArray) |
1580 | 1 | { |
1581 | 1 | const auto rawArray = std::vector<float>{{2.0F, 0.0F}}; |
1582 | 1 | auto reflectable = ReflectableFactory::getFloat16Array(rawArray); |
1583 | 1 | checkArray(rawArray, reflectable, |
1584 | 2 | [&](float value, const IReflectableConstPtr& elementReflectable) { |
1585 | 2 | checkFloatingPoint(value, elementReflectable, &IReflectable::getFloat, |
1586 | 2 | std::bind(&BitStreamReader::readFloat16, _1)); |
1587 | 2 | } |
1588 | 1 | ); |
1589 | 1 | } |
1590 | | |
1591 | | TEST_F(ReflectableTest, float16Array) |
1592 | 1 | { |
1593 | 1 | auto rawArray = std::vector<float>{{2.0F, 0.0F}}; |
1594 | 1 | auto reflectable = ReflectableFactory::getFloat16Array(rawArray); |
1595 | 1 | checkArray(rawArray, reflectable, |
1596 | 2 | [&](float value, const IReflectablePtr& elementReflectable) { |
1597 | 2 | checkFloatingPoint(value, elementReflectable, &IReflectable::getFloat, |
1598 | 2 | std::bind(&BitStreamReader::readFloat16, _1)); |
1599 | 2 | } |
1600 | 1 | ); |
1601 | 1 | } |
1602 | | |
1603 | | TEST_F(ReflectableTest, float32ConstArray) |
1604 | 1 | { |
1605 | 1 | const auto rawArray = std::vector<float>{{2.0F, 0.0F, 1.2F}}; |
1606 | 1 | auto reflectable = ReflectableFactory::getFloat32Array(rawArray); |
1607 | 1 | checkArray(rawArray, reflectable, |
1608 | 3 | [&](float value, const IReflectableConstPtr& elementReflectable) { |
1609 | 3 | checkFloatingPoint(value, elementReflectable, &IReflectable::getFloat, |
1610 | 3 | std::bind(&BitStreamReader::readFloat32, _1)); |
1611 | 3 | } |
1612 | 1 | ); |
1613 | 1 | } |
1614 | | |
1615 | | TEST_F(ReflectableTest, float32Array) |
1616 | 1 | { |
1617 | 1 | auto rawArray = std::vector<float>{{2.0F, 0.0F, 1.2F}}; |
1618 | 1 | auto reflectable = ReflectableFactory::getFloat32Array(rawArray); |
1619 | 1 | checkArray(rawArray, reflectable, |
1620 | 3 | [&](float value, const IReflectablePtr& elementReflectable) { |
1621 | 3 | checkFloatingPoint(value, elementReflectable, &IReflectable::getFloat, |
1622 | 3 | std::bind(&BitStreamReader::readFloat32, _1)); |
1623 | 3 | } |
1624 | 1 | ); |
1625 | 1 | } |
1626 | | |
1627 | | TEST_F(ReflectableTest, float64ConstArray) |
1628 | 1 | { |
1629 | 1 | const auto rawArray = std::vector<double>{{2.0, 0.0, 1.2}}; |
1630 | 1 | auto reflectable = ReflectableFactory::getFloat64Array(rawArray); |
1631 | 1 | checkArray(rawArray, reflectable, |
1632 | 3 | [&](double value, const IReflectableConstPtr& elementReflectable) { |
1633 | 3 | checkFloatingPoint(value, elementReflectable, &IReflectable::getDouble, |
1634 | 3 | std::bind(&BitStreamReader::readFloat64, _1)); |
1635 | 3 | } |
1636 | 1 | ); |
1637 | 1 | } |
1638 | | |
1639 | | TEST_F(ReflectableTest, float64Array) |
1640 | 1 | { |
1641 | 1 | auto rawArray = std::vector<double>{{2.0, 0.0, 1.2}}; |
1642 | 1 | auto reflectable = ReflectableFactory::getFloat64Array(rawArray); |
1643 | 1 | checkArray(rawArray, reflectable, |
1644 | 3 | [&](double value, const IReflectablePtr& elementReflectable) { |
1645 | 3 | checkFloatingPoint(value, elementReflectable, &IReflectable::getDouble, |
1646 | 3 | std::bind(&BitStreamReader::readFloat64, _1)); |
1647 | 3 | } |
1648 | 1 | ); |
1649 | 1 | } |
1650 | | |
1651 | | TEST_F(ReflectableTest, stringConstArray) |
1652 | 1 | { |
1653 | 1 | const auto rawArray = std::vector<std::string>{{"one", "two", "three"}}; |
1654 | 1 | auto reflectable = ReflectableFactory::getStringArray(rawArray); |
1655 | 1 | checkArray(rawArray, reflectable, |
1656 | 3 | [&](StringView value, const IReflectableConstPtr& elementReflectable) { |
1657 | 3 | checkString(value, elementReflectable); |
1658 | 3 | } |
1659 | 1 | ); |
1660 | | |
1661 | 1 | auto nonConstReflectable = std::const_pointer_cast<IReflectable>(reflectable); |
1662 | 1 | ASSERT_THROW(nonConstReflectable->getAnyValue(), CppRuntimeException); |
1663 | 1 | } |
1664 | | |
1665 | | TEST_F(ReflectableTest, stringArray) |
1666 | 1 | { |
1667 | 1 | auto rawArray = std::vector<std::string>{{"one", "two", "three"}}; |
1668 | 1 | auto reflectable = ReflectableFactory::getStringArray(rawArray); |
1669 | 1 | checkArray(rawArray, reflectable, |
1670 | 3 | [&](StringView value, const IReflectablePtr& elementReflectable) { |
1671 | 3 | checkString(value, elementReflectable); |
1672 | 3 | } |
1673 | 1 | ); |
1674 | 1 | checkArray(rawArray, static_cast<IReflectableConstPtr>(reflectable), |
1675 | 3 | [&](StringView value, const IReflectableConstPtr& elementReflectable) { |
1676 | 3 | checkString(value, elementReflectable); |
1677 | 3 | } |
1678 | 1 | ); |
1679 | | |
1680 | 1 | reflectable->resize(0); |
1681 | 1 | ASSERT_EQ(0, reflectable->size()); |
1682 | 1 | reflectable->append(AnyHolder<>(std::string("appended"))); |
1683 | 1 | ASSERT_EQ(1, reflectable->size()); |
1684 | 1 | ASSERT_EQ("appended"_sv, reflectable->at(0)->getStringView()); |
1685 | 1 | reflectable->setAt(AnyHolder<>(std::string("set")), 0); |
1686 | 1 | ASSERT_EQ(1, reflectable->size()); |
1687 | 1 | ASSERT_EQ("set"_sv, reflectable->at(0)->getStringView()); |
1688 | 1 | reflectable->resize(2); |
1689 | 1 | ASSERT_EQ(2, reflectable->size()); |
1690 | | |
1691 | | // out of range |
1692 | 1 | ASSERT_THROW(reflectable->setAt(AnyHolder<>(std::string("set")), 2), CppRuntimeException); |
1693 | 1 | } |
1694 | | |
1695 | | TEST_F(ReflectableTest, bitBufferConstArray) |
1696 | 1 | { |
1697 | 1 | const auto rawArray = std::vector<BitBuffer>{{BitBuffer({0xF8}, 5), BitBuffer({0xAB, 0xCD}, 16)}}; |
1698 | 1 | auto reflectable = ReflectableFactory::getBitBufferArray(rawArray); |
1699 | 1 | checkArray(rawArray, reflectable, |
1700 | 2 | [&](const BitBuffer& value, const IReflectableConstPtr& elementReflectable) { |
1701 | 2 | checkBitBuffer(value, elementReflectable); |
1702 | 2 | } |
1703 | 1 | ); |
1704 | 1 | } |
1705 | | |
1706 | | TEST_F(ReflectableTest, bitBufferArray) |
1707 | 1 | { |
1708 | 1 | auto rawArray = std::vector<BitBuffer>{{BitBuffer({0xF8}, 5), BitBuffer({0xAB, 0xCD}, 16)}}; |
1709 | 1 | auto reflectable = ReflectableFactory::getBitBufferArray(rawArray); |
1710 | 1 | checkArray(rawArray, reflectable, |
1711 | 2 | [&](const BitBuffer& value, const IReflectablePtr& elementReflectable) { |
1712 | 2 | checkBitBuffer(value, elementReflectable); |
1713 | 2 | } |
1714 | 1 | ); |
1715 | 1 | checkArray(rawArray, static_cast<IReflectableConstPtr>(reflectable), |
1716 | 2 | [&](const BitBuffer& value, const IReflectableConstPtr& elementReflectable) { |
1717 | 2 | checkBitBuffer(value, elementReflectable); |
1718 | 2 | } |
1719 | 1 | ); |
1720 | | |
1721 | 1 | reflectable->resize(0); |
1722 | 1 | ASSERT_EQ(0, reflectable->size()); |
1723 | 1 | reflectable->append(AnyHolder<>(BitBuffer())); |
1724 | 1 | ASSERT_EQ(1, reflectable->size()); |
1725 | 1 | ASSERT_EQ(0, reflectable->at(0)->getBitBuffer().getBitSize()); |
1726 | 1 | reflectable->setAt(AnyHolder<>(BitBuffer({0xA0}, 4)), 0); |
1727 | 1 | ASSERT_EQ(1, reflectable->size()); |
1728 | 1 | ASSERT_EQ(4, reflectable->at(0)->getBitBuffer().getBitSize()); |
1729 | 1 | reflectable->resize(2); |
1730 | 1 | ASSERT_EQ(2, reflectable->size()); |
1731 | | |
1732 | | // out of range |
1733 | 1 | ASSERT_THROW(reflectable->setAt(AnyHolder<>(BitBuffer()), 2), CppRuntimeException); |
1734 | 1 | } |
1735 | | |
1736 | | TEST_F(ReflectableTest, bytesConstArray) |
1737 | 1 | { |
1738 | 1 | const auto rawArray = std::vector<std::vector<uint8_t>>{{ |
1739 | 1 | {{0x00, 0x01}}, |
1740 | 1 | {{0xFF, 0xFE}} |
1741 | 1 | }}; |
1742 | 1 | auto reflectable = ReflectableFactory::getBytesArray(rawArray); |
1743 | 1 | checkArray(rawArray, reflectable, |
1744 | 2 | [&](const vector<uint8_t>& value, const IReflectableConstPtr& elementReflectable) { |
1745 | 2 | checkBytes(value, elementReflectable); |
1746 | 2 | } |
1747 | 1 | ); |
1748 | 1 | } |
1749 | | |
1750 | | TEST_F(ReflectableTest, bytesArray) |
1751 | 1 | { |
1752 | 1 | auto rawArray = std::vector<std::vector<uint8_t>>{{ |
1753 | 1 | {{0x00, 0x01}}, |
1754 | 1 | {{0xFF, 0xFE}} |
1755 | 1 | }}; |
1756 | 1 | auto reflectable = ReflectableFactory::getBytesArray(rawArray); |
1757 | 1 | checkArray(rawArray, reflectable, |
1758 | 2 | [&](const vector<uint8_t>& value, const IReflectablePtr& elementReflectable) { |
1759 | 2 | checkBytes(value, elementReflectable); |
1760 | 2 | } |
1761 | 1 | ); |
1762 | 1 | checkArray(rawArray, static_cast<IReflectableConstPtr>(reflectable), |
1763 | 2 | [&](const vector<uint8_t>& value, const IReflectableConstPtr& elementReflectable) { |
1764 | 2 | checkBytes(value, elementReflectable); |
1765 | 2 | } |
1766 | 1 | ); |
1767 | | |
1768 | 1 | reflectable->resize(0); |
1769 | 1 | ASSERT_EQ(0, reflectable->size()); |
1770 | 1 | reflectable->append(AnyHolder<>(std::vector<uint8_t>())); |
1771 | 1 | ASSERT_EQ(1, reflectable->size()); |
1772 | 1 | ASSERT_EQ(0, reflectable->at(0)->getBytes().size()); |
1773 | 1 | reflectable->setAt(AnyHolder<>(std::vector<uint8_t>{{0xAB, 0xCD}}), 0); |
1774 | 1 | ASSERT_EQ(1, reflectable->size()); |
1775 | 1 | ASSERT_EQ(2, reflectable->at(0)->getBytes().size()); |
1776 | 1 | reflectable->resize(2); |
1777 | 1 | ASSERT_EQ(2, reflectable->size()); |
1778 | | |
1779 | | // out of range |
1780 | 1 | ASSERT_THROW(reflectable->setAt(AnyHolder<>(std::vector<uint8_t>()), 2), CppRuntimeException); |
1781 | 1 | } |
1782 | | |
1783 | | TEST_F(ReflectableTest, bitmaskConstReflectable) |
1784 | 1 | { |
1785 | 1 | const ReflectableBitmask bitmask = ReflectableBitmask::Values::WRITE; |
1786 | 1 | auto reflectable = bitmask.reflectable(); |
1787 | 1 | checkBitmask(bitmask, reflectable); |
1788 | 1 | } |
1789 | | |
1790 | | TEST_F(ReflectableTest, bitmaskReflectable) |
1791 | 1 | { |
1792 | 1 | ReflectableBitmask bitmask = ReflectableBitmask::Values::WRITE; |
1793 | 1 | auto reflectable = bitmask.reflectable(); |
1794 | 1 | checkBitmask(bitmask, reflectable); |
1795 | 1 | } |
1796 | | |
1797 | | TEST_F(ReflectableTest, bitmaskConstArray) |
1798 | 1 | { |
1799 | 1 | const auto rawArray = std::vector<ReflectableBitmask>{{ |
1800 | 1 | ReflectableBitmask::Values::WRITE, ReflectableBitmask::Values::CREATE, |
1801 | 1 | ReflectableBitmask::Values::READ |
1802 | 1 | }}; |
1803 | 1 | auto reflectable = ReflectableFactory::getBitmaskArray(rawArray); |
1804 | 1 | checkArray(rawArray, reflectable, |
1805 | 3 | [&](ReflectableBitmask value, const IReflectableConstPtr& elementReflectable) { |
1806 | 3 | checkBitmask(value, elementReflectable); |
1807 | 3 | } |
1808 | 1 | ); |
1809 | | |
1810 | 1 | auto nonConstReflectable = std::const_pointer_cast<IReflectable>(reflectable); |
1811 | 1 | ASSERT_THROW(nonConstReflectable->getAnyValue(), CppRuntimeException); |
1812 | 1 | } |
1813 | | |
1814 | | TEST_F(ReflectableTest, bitmaskArray) |
1815 | 1 | { |
1816 | 1 | auto rawArray = std::vector<ReflectableBitmask>{{ |
1817 | 1 | ReflectableBitmask::Values::WRITE, ReflectableBitmask::Values::CREATE, |
1818 | 1 | ReflectableBitmask::Values::READ |
1819 | 1 | }}; |
1820 | 1 | auto reflectable = ReflectableFactory::getBitmaskArray(rawArray); |
1821 | 1 | checkArray(rawArray, reflectable, |
1822 | 3 | [&](ReflectableBitmask value, const IReflectablePtr& elementReflectable) { |
1823 | 3 | checkBitmask(value, elementReflectable); |
1824 | 3 | } |
1825 | 1 | ); |
1826 | 1 | checkArray(rawArray, static_cast<IReflectableConstPtr>(reflectable), |
1827 | 3 | [&](ReflectableBitmask value, const IReflectableConstPtr& elementReflectable) { |
1828 | 3 | checkBitmask(value, elementReflectable); |
1829 | 3 | } |
1830 | 1 | ); |
1831 | | |
1832 | 1 | reflectable->resize(0); |
1833 | 1 | ASSERT_EQ(0, reflectable->size()); |
1834 | 1 | reflectable->append(AnyHolder<>(ReflectableBitmask(ReflectableBitmask::Values::READ))); |
1835 | 1 | ASSERT_EQ(1, reflectable->size()); |
1836 | 1 | ASSERT_EQ(ReflectableBitmask::Values::READ, ReflectableBitmask(reflectable->at(0)->getUInt8())); |
1837 | 1 | reflectable->setAt(AnyHolder<>(ReflectableBitmask(ReflectableBitmask::Values::CREATE)), 0); |
1838 | 1 | ASSERT_EQ(1, reflectable->size()); |
1839 | 1 | ASSERT_EQ(ReflectableBitmask::Values::CREATE, ReflectableBitmask(reflectable->at(0)->getUInt8())); |
1840 | 1 | reflectable->resize(2); |
1841 | 1 | ASSERT_EQ(2, reflectable->size()); |
1842 | | |
1843 | 1 | reflectable->append(AnyHolder<>(ReflectableBitmask(ReflectableBitmask::Values::WRITE).getValue())); |
1844 | 1 | ASSERT_EQ(3, reflectable->size()); |
1845 | 1 | ASSERT_EQ(ReflectableBitmask::Values::WRITE, ReflectableBitmask(reflectable->at(2)->getUInt8())); |
1846 | 1 | reflectable->setAt(AnyHolder<>(ReflectableBitmask(ReflectableBitmask::Values::READ).getValue()), 2); |
1847 | 1 | ASSERT_EQ(3, reflectable->size()); |
1848 | 1 | ASSERT_EQ(ReflectableBitmask::Values::READ, ReflectableBitmask(reflectable->at(2)->getUInt8())); |
1849 | | |
1850 | | // out of range |
1851 | 1 | ASSERT_THROW(reflectable->setAt(AnyHolder<>(ReflectableBitmask::Values::CREATE), 3), CppRuntimeException); |
1852 | 1 | } |
1853 | | |
1854 | | TEST_F(ReflectableTest, enumReflectable) |
1855 | 1 | { |
1856 | 1 | const ReflectableEnum enumeration = ReflectableEnum::VALUE1; |
1857 | 1 | auto reflectable = enumReflectable(enumeration); |
1858 | 1 | checkEnum(enumeration, reflectable); |
1859 | 1 | } |
1860 | | |
1861 | | TEST_F(ReflectableTest, enumConstArray) |
1862 | 1 | { |
1863 | 1 | const auto rawArray = std::vector<ReflectableEnum>{{ReflectableEnum::VALUE1, ReflectableEnum::VALUE2, |
1864 | 1 | ReflectableEnum::VALUE3}}; |
1865 | 1 | auto reflectable = ReflectableFactory::getEnumArray(rawArray); |
1866 | 1 | checkArray(rawArray, reflectable, |
1867 | 3 | [&](ReflectableEnum value, const IReflectableConstPtr& elementReflectable) { |
1868 | 3 | checkEnum(value, elementReflectable); |
1869 | 3 | } |
1870 | 1 | ); |
1871 | | |
1872 | 1 | auto nonConstReflectable = std::const_pointer_cast<IReflectable>(reflectable); |
1873 | 1 | ASSERT_THROW(nonConstReflectable->getAnyValue(), CppRuntimeException); |
1874 | 1 | } |
1875 | | |
1876 | | TEST_F(ReflectableTest, enumArray) |
1877 | 1 | { |
1878 | 1 | auto rawArray = std::vector<ReflectableEnum>{{ReflectableEnum::VALUE1, ReflectableEnum::VALUE2, |
1879 | 1 | ReflectableEnum::VALUE3}}; |
1880 | 1 | auto reflectable = ReflectableFactory::getEnumArray(rawArray); |
1881 | 1 | checkArray(rawArray, reflectable, |
1882 | 3 | [&](ReflectableEnum value, const IReflectablePtr& elementReflectable) { |
1883 | 3 | checkEnum(value, elementReflectable); |
1884 | 3 | } |
1885 | 1 | ); |
1886 | 1 | checkArray(rawArray, static_cast<IReflectableConstPtr>(reflectable), |
1887 | 3 | [&](ReflectableEnum value, const IReflectableConstPtr& elementReflectable) { |
1888 | 3 | checkEnum(value, elementReflectable); |
1889 | 3 | } |
1890 | 1 | ); |
1891 | | |
1892 | 1 | reflectable->resize(0); |
1893 | 1 | ASSERT_EQ(0, reflectable->size()); |
1894 | 1 | reflectable->append(AnyHolder<>(ReflectableEnum::VALUE3)); |
1895 | 1 | ASSERT_EQ(1, reflectable->size()); |
1896 | 1 | ASSERT_EQ(enumToValue(ReflectableEnum::VALUE3), reflectable->at(0)->getInt8()); |
1897 | 1 | reflectable->setAt(AnyHolder<>(ReflectableEnum::VALUE2), 0); |
1898 | 1 | ASSERT_EQ(1, reflectable->size()); |
1899 | 1 | ASSERT_EQ(enumToValue(ReflectableEnum::VALUE2), reflectable->at(0)->getInt8()); |
1900 | 1 | reflectable->resize(2); |
1901 | 1 | ASSERT_EQ(2, reflectable->size()); |
1902 | | |
1903 | 1 | reflectable->append(AnyHolder<>(enumToValue(ReflectableEnum::VALUE1))); |
1904 | 1 | ASSERT_EQ(3, reflectable->size()); |
1905 | 1 | ASSERT_EQ(enumToValue(ReflectableEnum::VALUE1), reflectable->at(2)->getInt8()); |
1906 | 1 | reflectable->setAt(AnyHolder<>(enumToValue(ReflectableEnum::VALUE2)), 2); |
1907 | 1 | ASSERT_EQ(3, reflectable->size()); |
1908 | 1 | ASSERT_EQ(enumToValue(ReflectableEnum::VALUE2), reflectable->at(2)->getInt8()); |
1909 | | |
1910 | | // out of range |
1911 | 1 | ASSERT_THROW(reflectable->setAt(AnyHolder<>(ReflectableEnum::VALUE2), 3), CppRuntimeException); |
1912 | 1 | } |
1913 | | |
1914 | | TEST_F(ReflectableTest, compoundConst) |
1915 | 1 | { |
1916 | 1 | { |
1917 | 1 | const ReflectableObject reflectableObjectUninitialized = ReflectableObject{"test", |
1918 | 1 | ReflectableNested{13}}; |
1919 | 1 | auto reflectable = reflectableObjectUninitialized.reflectable(); |
1920 | 1 | ASSERT_FALSE(reflectable->find("reflectableNested.stringParam")); |
1921 | 1 | } |
1922 | | |
1923 | 1 | const ReflectableObject reflectableObject = createInitializedReflectableObject("test", 13); |
1924 | 1 | auto reflectable = reflectableObject.reflectable(); |
1925 | 1 | checkCompound(reflectableObject, reflectable); |
1926 | | |
1927 | 1 | IReflectablePtr nonConstReflectable = std::const_pointer_cast<IReflectable>(reflectable); |
1928 | 1 | ASSERT_THROW(nonConstReflectable->initializeChildren(), CppRuntimeException); |
1929 | 1 | ASSERT_THROW(nonConstReflectable->initialize(vector<AnyHolder<>>()), CppRuntimeException); |
1930 | 1 | ASSERT_NO_THROW(reflectable->getField("reflectableNested")); |
1931 | 1 | ASSERT_THROW(nonConstReflectable->getField("reflectableNested"), CppRuntimeException); |
1932 | 1 | ASSERT_NO_THROW(reflectable->getAnyValue()); |
1933 | 1 | ASSERT_THROW(nonConstReflectable->getAnyValue(), CppRuntimeException); |
1934 | | |
1935 | 1 | IReflectableConstPtr childReflectable = reflectable->getField("reflectableNested"); |
1936 | 1 | IReflectablePtr nonConstChildReflectable =std::const_pointer_cast<IReflectable>(childReflectable); |
1937 | 1 | ASSERT_THROW(nonConstChildReflectable->setField("value", AnyHolder<>(static_cast<uint32_t>(11))), |
1938 | 1 | CppRuntimeException); |
1939 | 1 | ASSERT_NO_THROW(childReflectable->getParameter("dummyParam")); |
1940 | 1 | ASSERT_THROW(nonConstChildReflectable->getParameter("dummyParam"), CppRuntimeException); |
1941 | 1 | ASSERT_NO_THROW(childReflectable->callFunction("getValue")); |
1942 | 1 | ASSERT_THROW(nonConstChildReflectable->callFunction("getValue"), CppRuntimeException); |
1943 | 1 | ASSERT_THROW(nonConstChildReflectable->initializeOffsets(0), CppRuntimeException); |
1944 | 1 | } |
1945 | | |
1946 | | TEST_F(ReflectableTest, compound) |
1947 | 1 | { |
1948 | 1 | { |
1949 | 1 | ReflectableObject reflectableObjectUninitialized = ReflectableObject{"test", ReflectableNested{13}}; |
1950 | 1 | auto reflectable = reflectableObjectUninitialized.reflectable(); |
1951 | 1 | ASSERT_FALSE(reflectable->find("reflectableNested.stringParam")); |
1952 | 1 | } |
1953 | | |
1954 | 1 | ReflectableObject reflectableObject = ReflectableObject{"test", ReflectableNested{13}}; |
1955 | 1 | auto reflectable = reflectableObject.reflectable(); |
1956 | | |
1957 | | // not initialized |
1958 | 1 | ASSERT_THROW(reflectable->getField("reflectableNested")->getParameter("dummyParam"), CppRuntimeException); |
1959 | 1 | ASSERT_THROW(reflectable->getField("reflectableNested")->getParameter("stringParam"), CppRuntimeException); |
1960 | 1 | ASSERT_FALSE(static_cast<IReflectableConstPtr>(reflectable)->find("reflectableNested.stringParam")); |
1961 | | |
1962 | 1 | reflectable->initializeChildren(); |
1963 | 1 | checkCompound(reflectableObject, reflectable); |
1964 | 1 | } |
1965 | | |
1966 | | TEST_F(ReflectableTest, compoundConstArray) |
1967 | 1 | { |
1968 | 1 | ReflectableObject reflectableObject1; |
1969 | 1 | reflectableObject1 = createInitializedReflectableObject("1", 13); // to cover assignment operator |
1970 | 1 | const auto rawArray = std::vector<ReflectableObject>{{ |
1971 | 1 | reflectableObject1, |
1972 | 1 | createInitializedReflectableObject("2", 42) |
1973 | 1 | }}; |
1974 | 1 | auto reflectable = ReflectableFactory::getCompoundArray(rawArray); |
1975 | 1 | checkArray(rawArray, reflectable, |
1976 | 2 | [&](const ReflectableObject& value, const IReflectableConstPtr& elementReflectable) { |
1977 | 2 | checkCompound(value, elementReflectable); |
1978 | 2 | } |
1979 | 1 | ); |
1980 | | |
1981 | 1 | IReflectablePtr nonConstReflectable = std::const_pointer_cast<IReflectable>(reflectable); |
1982 | 1 | ASSERT_THROW(nonConstReflectable->at(0), CppRuntimeException); |
1983 | 1 | ASSERT_THROW((*nonConstReflectable)[0], CppRuntimeException); |
1984 | 1 | ASSERT_THROW(nonConstReflectable->resize(nonConstReflectable->size() + 1), CppRuntimeException); |
1985 | 1 | ASSERT_THROW(nonConstReflectable->setAt(AnyHolder<>(ReflectableObject{"test", ReflectableNested{0}}), 0), |
1986 | 1 | CppRuntimeException); |
1987 | 1 | ASSERT_THROW(nonConstReflectable->append(AnyHolder<>(ReflectableObject{"test", ReflectableNested{0}})), |
1988 | 1 | CppRuntimeException); |
1989 | 1 | ASSERT_THROW(nonConstReflectable->getAnyValue(), CppRuntimeException); |
1990 | 1 | } |
1991 | | |
1992 | | TEST_F(ReflectableTest, compoundArray) |
1993 | 1 | { |
1994 | 1 | auto rawArray = std::vector<ReflectableObject>{{ |
1995 | 1 | createInitializedReflectableObject("1", 13), |
1996 | 1 | createInitializedReflectableObject("2", 42) |
1997 | 1 | }}; |
1998 | 1 | auto reflectable = ReflectableFactory::getCompoundArray(rawArray); |
1999 | 1 | checkArray(rawArray, reflectable, |
2000 | 2 | [&](const ReflectableObject& value, const IReflectablePtr& elementReflectable) { |
2001 | 2 | checkCompound(value, elementReflectable); |
2002 | 2 | } |
2003 | 1 | ); |
2004 | 1 | checkArray(rawArray, static_cast<IReflectableConstPtr>(reflectable), |
2005 | 2 | [&](const ReflectableObject& value, const IReflectableConstPtr& elementReflectable) { |
2006 | 2 | checkCompound(value, elementReflectable); |
2007 | 2 | } |
2008 | 1 | ); |
2009 | | |
2010 | 1 | reflectable->resize(reflectable->size() + 1); |
2011 | 1 | IReflectablePtr newCompound = reflectable->at(reflectable->size() - 1); |
2012 | 1 | ASSERT_TRUE(newCompound); |
2013 | | |
2014 | 1 | reflectable->setAt(AnyHolder<>(ReflectableObject{"test", ReflectableNested{0}}), 0); |
2015 | 1 | ASSERT_EQ(0, reflectable->at(0)->find("reflectableNested.value")->getUInt32()); |
2016 | 1 | reflectable->append(AnyHolder<>(ReflectableObject{"test|", ReflectableNested{1}})); |
2017 | 1 | ASSERT_EQ(1, reflectable->at(reflectable->size() - 1)->find("reflectableNested.value")->getUInt32()); |
2018 | | |
2019 | 1 | const size_t size = reflectable->size(); |
2020 | 1 | ASSERT_THROW(reflectable->setAt(AnyHolder<>(), size), CppRuntimeException); // out of range |
2021 | 1 | } |
2022 | | |
2023 | | TEST_F(ReflectableTest, defaultUnimplementedMethods) |
2024 | 1 | { |
2025 | 1 | class Reflectable : public ReflectableBase<std::allocator<uint8_t>> |
2026 | 1 | { |
2027 | 1 | public: |
2028 | 1 | using ReflectableBase<std::allocator<uint8_t>>::ReflectableBase; |
2029 | 1 | }; |
2030 | | |
2031 | 1 | Reflectable reflectable(BuiltinTypeInfo<>::getUInt8()); |
2032 | 1 | ASSERT_THROW(reflectable.bitSizeOf(0), CppRuntimeException); |
2033 | | |
2034 | 1 | BitBuffer bitBuffer(0); |
2035 | 1 | BitStreamWriter writer(bitBuffer); |
2036 | 1 | ASSERT_THROW(reflectable.write(writer), CppRuntimeException); |
2037 | | |
2038 | 1 | ASSERT_THROW(reflectable.getAnyValue(), CppRuntimeException); |
2039 | | |
2040 | 1 | const Reflectable& constReflectableRef = reflectable; |
2041 | 1 | ASSERT_THROW(constReflectableRef.getAnyValue(), CppRuntimeException); |
2042 | 1 | } |
2043 | | |
2044 | | TEST_F(ReflectableTest, reflectableOwner) |
2045 | 1 | { |
2046 | 1 | auto reflectable = ReflectableObject::typeInfo().createInstance(); |
2047 | | |
2048 | | // must be as the first one to initialize object |
2049 | 1 | ASSERT_NO_THROW(reflectable->initializeChildren()); |
2050 | | |
2051 | 1 | IReflectableConstPtr constReflectable = reflectable; |
2052 | | |
2053 | | // same as default initialized |
2054 | 1 | ReflectableObject defaultReflectableObject; |
2055 | 1 | defaultReflectableObject.initializeChildren(); |
2056 | 1 | ASSERT_EQ(defaultReflectableObject, |
2057 | 1 | reflectable->getAnyValue().template get<std::reference_wrapper<ReflectableObject>>().get()); |
2058 | 1 | ASSERT_EQ(defaultReflectableObject, |
2059 | 1 | constReflectable->getAnyValue().template get<std::reference_wrapper<ReflectableObject>>().get()); |
2060 | | |
2061 | | // has no type arguments |
2062 | 1 | ASSERT_THROW(reflectable->initialize(std::vector<AnyHolder<>>()), CppRuntimeException); |
2063 | | |
2064 | 1 | ASSERT_TRUE(TypeInfoUtil::isCompound(reflectable->getTypeInfo().getSchemaType())); |
2065 | 1 | ASSERT_FALSE(reflectable->isArray()); |
2066 | 1 | reflectable->setField("reflectableNested", AnyHolder<>(ReflectableNested{42})); |
2067 | 1 | ASSERT_EQ(42, reflectable->getField("reflectableNested")->getField("value")->getUInt32()); |
2068 | 1 | ASSERT_EQ(42, constReflectable->getField("reflectableNested")->getField("value")->getUInt32()); |
2069 | 1 | ASSERT_THROW(reflectable->createField("nonexistent"), CppRuntimeException); |
2070 | 1 | ASSERT_THROW(reflectable->getParameter("nonexistent"), CppRuntimeException); |
2071 | 1 | ASSERT_THROW(constReflectable->getParameter("nonexistent"), CppRuntimeException); |
2072 | 1 | ASSERT_THROW(reflectable->callFunction("nonexistent"), CppRuntimeException); |
2073 | 1 | ASSERT_THROW(constReflectable->callFunction("nonexistent"), CppRuntimeException); |
2074 | 1 | ASSERT_THROW(reflectable->getChoice(), CppRuntimeException); |
2075 | 1 | ASSERT_THROW(constReflectable->getChoice(), CppRuntimeException); |
2076 | 1 | ASSERT_FALSE(reflectable->find("nonexistent")); |
2077 | 1 | ASSERT_FALSE(constReflectable->find("nonexistent")); |
2078 | 1 | ASSERT_FALSE((*reflectable)["nonexistent"]); |
2079 | 1 | ASSERT_FALSE((*constReflectable)["nonexistent"]); |
2080 | | |
2081 | 1 | ASSERT_THROW(reflectable->size(), CppRuntimeException); // not an array |
2082 | 1 | ASSERT_THROW(reflectable->resize(0), CppRuntimeException); // not an array |
2083 | 1 | ASSERT_THROW(reflectable->at(0), CppRuntimeException); // not an array |
2084 | 1 | ASSERT_THROW(constReflectable->at(0), CppRuntimeException); // not an array |
2085 | 1 | ASSERT_THROW((*reflectable)[0], CppRuntimeException); // not an array |
2086 | 1 | ASSERT_THROW((*constReflectable)[0], CppRuntimeException); // not an array |
2087 | 1 | ASSERT_THROW(reflectable->setAt(AnyHolder<>(), 0), CppRuntimeException); // not an array |
2088 | 1 | ASSERT_THROW(reflectable->append(AnyHolder<>()), CppRuntimeException); // not an array |
2089 | | |
2090 | 1 | ASSERT_THROW(reflectable->getBool(), CppRuntimeException); |
2091 | 1 | ASSERT_THROW(reflectable->getInt8(), CppRuntimeException); |
2092 | 1 | ASSERT_THROW(reflectable->getInt16(), CppRuntimeException); |
2093 | 1 | ASSERT_THROW(reflectable->getInt32(), CppRuntimeException); |
2094 | 1 | ASSERT_THROW(reflectable->getInt64(), CppRuntimeException); |
2095 | 1 | ASSERT_THROW(reflectable->getUInt8(), CppRuntimeException); |
2096 | 1 | ASSERT_THROW(reflectable->getUInt16(), CppRuntimeException); |
2097 | 1 | ASSERT_THROW(reflectable->getUInt32(), CppRuntimeException); |
2098 | 1 | ASSERT_THROW(reflectable->getUInt64(), CppRuntimeException); |
2099 | 1 | ASSERT_THROW(reflectable->getFloat(), CppRuntimeException); |
2100 | 1 | ASSERT_THROW(reflectable->getDouble(), CppRuntimeException); |
2101 | 1 | ASSERT_THROW(reflectable->getBytes(), CppRuntimeException); |
2102 | 1 | ASSERT_THROW(reflectable->getStringView(), CppRuntimeException); |
2103 | 1 | ASSERT_THROW(reflectable->getBitBuffer(), CppRuntimeException); |
2104 | | |
2105 | 1 | ASSERT_THROW(reflectable->toInt(), CppRuntimeException); |
2106 | 1 | ASSERT_THROW(reflectable->toUInt(), CppRuntimeException); |
2107 | 1 | ASSERT_THROW(reflectable->toDouble(), CppRuntimeException); |
2108 | 1 | ASSERT_THROW(reflectable->toString(), CppRuntimeException); |
2109 | | |
2110 | 1 | ASSERT_EQ(reflectable->bitSizeOf(), reflectable->initializeOffsets()); |
2111 | | |
2112 | 1 | ASSERT_NO_THROW(reflectable->initializeChildren()); |
2113 | | |
2114 | 1 | const size_t bitSizeOfValue = reflectable->bitSizeOf(); |
2115 | 1 | BitBuffer bitBuffer(bitSizeOfValue); |
2116 | 1 | BitStreamWriter writer(bitBuffer); |
2117 | 1 | reflectable->write(writer); |
2118 | 1 | ASSERT_EQ(bitSizeOfValue, writer.getBitPosition()); |
2119 | 1 | } |
2120 | | |
2121 | | } // namespace zserio |