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