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