1 // Copyright 2019 Google LLC
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 // https://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14
15 // Tests for the generated View class for Container and Box from
16 // nested_structure.emb.
17 //
18 // These tests check that nested structures work.
19 #include <stdint.h>
20
21 #include <vector>
22
23 #include "gtest/gtest.h"
24 #include "testdata/uint_sizes.emb.h"
25
26 namespace emboss {
27 namespace test {
28 namespace {
29
30 alignas(8) static const ::std::uint8_t kUIntSizes[36] = {
31 0x02, // 0:1 one_byte == 2
32 0x04, 0x01, // 1:3 two_byte == 260
33 0x66, 0x55, 0x44, // 3:6 three_byte == 0x445566
34 0x06, 0x05, 0x04, 0x03, // 6:10 four_byte == 0x03040506
35 0x21, 0x43, 0x65, 0x87, // 10:14 five_byte
36 0xa9, // 14:15 five_byte == 0xa987654321
37 0xbc, 0x9a, 0x78, 0x56, // 15:19 six_byte
38 0x34, 0x12, // 19:21 six_byte == 0x123456789abc
39 0x97, 0xa6, 0xb5, 0xc4, // 21:25 seven_byte
40 0xd3, 0xe2, 0xf1, // 25:28 seven_byte == 0xf1e2d3c4b5a697
41 0x06, 0x05, 0x04, 0x03, // 28:32 eight_byte
42 0x02, 0x01, 0x00, 0xff, // 32:36 eight_byte == 0xff00010203040506
43 };
44
TEST(SizesView,CanReadSizes)45 TEST(SizesView, CanReadSizes) {
46 auto view = MakeAlignedSizesView<const ::std::uint8_t, 8>(kUIntSizes,
47 sizeof kUIntSizes);
48 EXPECT_EQ(2, view.one_byte().Read());
49 EXPECT_EQ(260, view.two_byte().Read());
50 EXPECT_EQ(0x445566U, view.three_byte().Read());
51 EXPECT_EQ(0x03040506U, view.four_byte().Read());
52 EXPECT_EQ(0xa987654321UL, view.five_byte().Read());
53 EXPECT_EQ(0x123456789abcUL, view.six_byte().Read());
54 EXPECT_EQ(0xf1e2d3c4b5a697UL, view.seven_byte().Read());
55 EXPECT_EQ(0xff00010203040506UL, view.eight_byte().Read());
56 // Test that the views return appropriate integer widths.
57 EXPECT_EQ(1U, sizeof(view.one_byte().Read()));
58 EXPECT_EQ(2U, sizeof(view.two_byte().Read()));
59 EXPECT_EQ(4U, sizeof(view.three_byte().Read()));
60 EXPECT_EQ(4U, sizeof(view.four_byte().Read()));
61 EXPECT_EQ(8U, sizeof(view.five_byte().Read()));
62 EXPECT_EQ(8U, sizeof(view.six_byte().Read()));
63 EXPECT_EQ(8U, sizeof(view.seven_byte().Read()));
64 EXPECT_EQ(8U, sizeof(view.eight_byte().Read()));
65 }
66
TEST(SizesWriter,CanWriteSizes)67 TEST(SizesWriter, CanWriteSizes) {
68 ::std::uint8_t buffer[sizeof kUIntSizes];
69 auto writer = SizesWriter(buffer, sizeof buffer);
70 writer.one_byte().Write(2);
71 writer.two_byte().Write(260);
72 writer.three_byte().Write(0x445566U);
73 writer.four_byte().Write(0x03040506U);
74 writer.five_byte().Write(0xa987654321);
75 writer.six_byte().Write(0x123456789abc);
76 writer.seven_byte().Write(0xf1e2d3c4b5a697);
77 writer.eight_byte().Write(0xff00010203040506UL);
78 EXPECT_EQ(::std::vector</**/ ::std::uint8_t>(kUIntSizes,
79 kUIntSizes + sizeof kUIntSizes),
80 ::std::vector</**/ ::std::uint8_t>(buffer, buffer + sizeof buffer));
81 }
82
TEST(SizesView,CanReadSizesBigEndian)83 TEST(SizesView, CanReadSizesBigEndian) {
84 auto view = BigEndianSizesView(kUIntSizes, sizeof kUIntSizes);
85 EXPECT_EQ(2, view.one_byte().Read());
86 EXPECT_EQ(0x0401, view.two_byte().Read());
87 EXPECT_EQ(0x665544U, view.three_byte().Read());
88 EXPECT_EQ(0x06050403U, view.four_byte().Read());
89 EXPECT_EQ(0x21436587a9UL, view.five_byte().Read());
90 EXPECT_EQ(0xbc9a78563412UL, view.six_byte().Read());
91 EXPECT_EQ(0x97a6b5c4d3e2f1UL, view.seven_byte().Read());
92 EXPECT_EQ(0x06050403020100ffUL, view.eight_byte().Read());
93 // Test that the views return appropriate integer widths.
94 EXPECT_EQ(1U, sizeof(view.one_byte().Read()));
95 EXPECT_EQ(2U, sizeof(view.two_byte().Read()));
96 EXPECT_EQ(4U, sizeof(view.three_byte().Read()));
97 EXPECT_EQ(4U, sizeof(view.four_byte().Read()));
98 EXPECT_EQ(8U, sizeof(view.five_byte().Read()));
99 EXPECT_EQ(8U, sizeof(view.six_byte().Read()));
100 EXPECT_EQ(8U, sizeof(view.seven_byte().Read()));
101 EXPECT_EQ(8U, sizeof(view.eight_byte().Read()));
102 }
103
TEST(SizesWriter,CanWriteSizesBigEndian)104 TEST(SizesWriter, CanWriteSizesBigEndian) {
105 ::std::uint8_t buffer[sizeof kUIntSizes];
106 auto writer = BigEndianSizesWriter(buffer, sizeof buffer);
107 writer.one_byte().Write(2);
108 writer.two_byte().Write(0x0401);
109 writer.three_byte().Write(0x665544U);
110 writer.four_byte().Write(0x06050403U);
111 writer.five_byte().Write(0x21436587a9);
112 writer.six_byte().Write(0xbc9a78563412);
113 writer.seven_byte().Write(0x97a6b5c4d3e2f1);
114 writer.eight_byte().Write(0x06050403020100ffUL);
115 EXPECT_EQ(::std::vector</**/ ::std::uint8_t>(kUIntSizes,
116 kUIntSizes + sizeof kUIntSizes),
117 ::std::vector</**/ ::std::uint8_t>(buffer, buffer + sizeof buffer));
118 }
119
TEST(SizesView,CanReadSizesAlternatingEndian)120 TEST(SizesView, CanReadSizesAlternatingEndian) {
121 auto view = AlternatingEndianSizesView(kUIntSizes, sizeof kUIntSizes);
122 EXPECT_EQ(2, view.one_byte().Read());
123 EXPECT_EQ(0x0104, view.two_byte().Read());
124 EXPECT_EQ(0x665544U, view.three_byte().Read());
125 EXPECT_EQ(0x03040506U, view.four_byte().Read());
126 EXPECT_EQ(0x21436587a9UL, view.five_byte().Read());
127 EXPECT_EQ(0x123456789abcUL, view.six_byte().Read());
128 EXPECT_EQ(0x97a6b5c4d3e2f1UL, view.seven_byte().Read());
129 EXPECT_EQ(0xff00010203040506UL, view.eight_byte().Read());
130 // Test that the views return appropriate integer widths.
131 EXPECT_EQ(1U, sizeof(view.one_byte().Read()));
132 EXPECT_EQ(2U, sizeof(view.two_byte().Read()));
133 EXPECT_EQ(4U, sizeof(view.three_byte().Read()));
134 EXPECT_EQ(4U, sizeof(view.four_byte().Read()));
135 EXPECT_EQ(8U, sizeof(view.five_byte().Read()));
136 EXPECT_EQ(8U, sizeof(view.six_byte().Read()));
137 EXPECT_EQ(8U, sizeof(view.seven_byte().Read()));
138 EXPECT_EQ(8U, sizeof(view.eight_byte().Read()));
139 }
140
TEST(SizesWriter,CanWriteSizesAlternatingEndian)141 TEST(SizesWriter, CanWriteSizesAlternatingEndian) {
142 ::std::uint8_t buffer[sizeof kUIntSizes];
143 auto writer = AlternatingEndianSizesWriter(buffer, sizeof buffer);
144 writer.one_byte().Write(2);
145 writer.two_byte().Write(0x0104);
146 writer.three_byte().Write(0x665544U);
147 writer.four_byte().Write(0x03040506);
148 writer.five_byte().Write(0x21436587a9);
149 writer.six_byte().Write(0x123456789abc);
150 writer.seven_byte().Write(0x97a6b5c4d3e2f1);
151 writer.eight_byte().Write(0xff00010203040506UL);
152 EXPECT_EQ(::std::vector</**/ ::std::uint8_t>(kUIntSizes,
153 kUIntSizes + sizeof kUIntSizes),
154 ::std::vector</**/ ::std::uint8_t>(buffer, buffer + sizeof buffer));
155 }
156
TEST(SizesView,DecodeUIntsFromText)157 TEST(SizesView, DecodeUIntsFromText) {
158 ::std::uint8_t buffer[sizeof kUIntSizes] = {0};
159 auto writer = SizesWriter(buffer, sizeof buffer);
160 EXPECT_TRUE(::emboss::UpdateFromText(writer, R"(
161 {
162 one_byte: 2
163 two_byte: 260
164 three_byte: 0x445566
165 four_byte: 0x03040506
166 five_byte: 0xa987654321
167 six_byte: 0x123456789abc
168 seven_byte: 0xf1e2d3c4b5a697
169 eight_byte: 0xff00010203040506
170 }
171 )"));
172 EXPECT_EQ(::std::vector</**/ ::std::uint8_t>(kUIntSizes,
173 kUIntSizes + sizeof kUIntSizes),
174 ::std::vector</**/ ::std::uint8_t>(buffer, buffer + sizeof buffer));
175 EXPECT_EQ(2, writer.one_byte().Read());
176 EXPECT_TRUE(::emboss::UpdateFromText(writer, "{one_byte:5}"));
177 EXPECT_EQ(5, buffer[0]);
178 EXPECT_EQ(5, writer.one_byte().Read());
179 EXPECT_FALSE(::emboss::UpdateFromText(writer, "{one_byte:256}"));
180 EXPECT_EQ(5, buffer[0]);
181 EXPECT_EQ(5, writer.one_byte().Read());
182 EXPECT_FALSE(::emboss::UpdateFromText(writer, "{three_byte:0x1000000}"));
183 EXPECT_FALSE(::emboss::UpdateFromText(writer, "{no_byte:0}"));
184 }
185
TEST(SizesView,DecodeUIntsFromTextWithCommas)186 TEST(SizesView, DecodeUIntsFromTextWithCommas) {
187 ::std::uint8_t buffer[sizeof kUIntSizes] = {0};
188 auto writer = SizesWriter(buffer, sizeof buffer);
189 EXPECT_TRUE(::emboss::UpdateFromText(writer, R"(
190 {
191 one_byte: 2,
192 two_byte: 260,
193 three_byte: 0x445566,
194 four_byte: 0x03040506,
195 five_byte: 0xa987654321,
196 six_byte: 0x123456789abc,
197 seven_byte: 0xf1e2d3c4b5a697,
198 eight_byte: 0xff00010203040506,
199 }
200 )"));
201 EXPECT_EQ(::std::vector</**/ ::std::uint8_t>(kUIntSizes,
202 kUIntSizes + sizeof kUIntSizes),
203 ::std::vector</**/ ::std::uint8_t>(buffer, buffer + sizeof buffer));
204 }
205
TEST(SizesView,DecodeBigEndianUIntsFromText)206 TEST(SizesView, DecodeBigEndianUIntsFromText) {
207 ::std::uint8_t buffer[sizeof kUIntSizes] = {0};
208 auto writer = BigEndianSizesWriter(buffer, sizeof buffer);
209 EXPECT_TRUE(::emboss::UpdateFromText(writer, R"(
210 {
211 one_byte: 2
212 two_byte: 0x0401
213 three_byte: 0x665544
214 four_byte: 0x06050403
215 five_byte: 0x21436587a9
216 six_byte: 0xbc9a78563412
217 seven_byte: 0x97a6b5c4d3e2f1
218 eight_byte: 0x06050403020100ff
219 }
220 )"));
221 EXPECT_EQ(::std::vector</**/ ::std::uint8_t>(kUIntSizes,
222 kUIntSizes + sizeof kUIntSizes),
223 ::std::vector</**/ ::std::uint8_t>(buffer, buffer + sizeof buffer));
224 }
225
TEST(SizesView,EncodeUIntsToText)226 TEST(SizesView, EncodeUIntsToText) {
227 auto view = MakeAlignedSizesView<const ::std::uint8_t, 8>(kUIntSizes,
228 sizeof kUIntSizes);
229 EXPECT_EQ(
230 "{\n"
231 " one_byte: 2 # 0x2\n"
232 " two_byte: 260 # 0x104\n"
233 " three_byte: 4_478_310 # 0x44_5566\n"
234 " four_byte: 50_595_078 # 0x304_0506\n"
235 " five_byte: 728_121_033_505 # 0xa9_8765_4321\n"
236 " six_byte: 20_015_998_343_868 # 0x1234_5678_9abc\n"
237 " seven_byte: 68_084_868_553_483_927 # 0xf1_e2d3_c4b5_a697\n"
238 " eight_byte: 18_374_687_587_823_781_126 # 0xff00_0102_0304_0506\n"
239 "}",
240 ::emboss::WriteToString(view, ::emboss::MultilineText()));
241 EXPECT_EQ(
242 "{ one_byte: 2, two_byte: 260, three_byte: 4478310, four_byte: 50595078, "
243 "five_byte: 728121033505, six_byte: 20015998343868, seven_byte: "
244 "68084868553483927, eight_byte: 18374687587823781126 }",
245 ::emboss::WriteToString(view));
246 }
247
248 static const ::std::uint8_t kEnumSizes[36] = {
249 0x01, // 0:1 one_byte == VALUE1
250 0x0a, 0x00, // 1:3 two_byte == VALUE10
251 0x10, 0x27, 0x00, // 3:6 three_byte == VALUE10000
252 0x64, 0x00, 0x00, 0x00, // 6:10 four_byte == VALUE100
253 0xa0, 0x86, 0x01, 0x00, // 10:14 five_byte
254 0x00, // 14:15 five_byte == VALUE100000
255 0x40, 0x42, 0x0f, 0x00, // 15:19 six_byte
256 0x00, 0x00, // 19:21 six_byte == VALUE1000000
257 0x80, 0x96, 0x98, 0x00, // 21:25 seven_byte
258 0x00, 0x00, 0x00, // 25:28 seven_byte == VALUE10000000
259 0xe8, 0x03, 0x00, 0x00, // 28:32 eight_byte
260 0x00, 0x00, 0x00, 0x00, // 32:36 eight_byte == VALUE1000
261 };
262
TEST(SizesView,CanReadEnumSizes)263 TEST(SizesView, CanReadEnumSizes) {
264 auto view = EnumSizesView(kEnumSizes, sizeof kEnumSizes);
265 EXPECT_EQ(Enum::VALUE1, view.one_byte().Read());
266 EXPECT_EQ(Enum::VALUE10, view.two_byte().Read());
267 EXPECT_EQ(Enum::VALUE10000, view.three_byte().Read());
268 EXPECT_EQ(Enum::VALUE100, view.four_byte().Read());
269 EXPECT_EQ(Enum::VALUE100000, view.five_byte().Read());
270 EXPECT_EQ(Enum::VALUE1000000, view.six_byte().Read());
271 EXPECT_EQ(Enum::VALUE10000000, view.seven_byte().Read());
272 EXPECT_EQ(Enum::VALUE1000, view.eight_byte().Read());
273 // Emboss enums are always derived from uint64_t.
274 EXPECT_EQ(8U, sizeof(view.one_byte().Read()));
275 EXPECT_EQ(8U, sizeof(view.two_byte().Read()));
276 EXPECT_EQ(8U, sizeof(view.three_byte().Read()));
277 EXPECT_EQ(8U, sizeof(view.four_byte().Read()));
278 EXPECT_EQ(8U, sizeof(view.five_byte().Read()));
279 EXPECT_EQ(8U, sizeof(view.six_byte().Read()));
280 EXPECT_EQ(8U, sizeof(view.seven_byte().Read()));
281 EXPECT_EQ(8U, sizeof(view.eight_byte().Read()));
282 }
283
TEST(SizesWriter,CanWriteEnumSizes)284 TEST(SizesWriter, CanWriteEnumSizes) {
285 ::std::uint8_t buffer[sizeof kEnumSizes];
286 auto writer = EnumSizesWriter(buffer, sizeof buffer);
287 writer.one_byte().Write(Enum::VALUE1);
288 writer.two_byte().Write(Enum::VALUE10);
289 writer.three_byte().Write(Enum::VALUE10000);
290 writer.four_byte().Write(Enum::VALUE100);
291 writer.five_byte().Write(Enum::VALUE100000);
292 writer.six_byte().Write(Enum::VALUE1000000);
293 writer.seven_byte().Write(Enum::VALUE10000000);
294 writer.eight_byte().Write(Enum::VALUE1000);
295 EXPECT_EQ(::std::vector</**/ ::std::uint8_t>(kEnumSizes,
296 kEnumSizes + sizeof kEnumSizes),
297 ::std::vector</**/ ::std::uint8_t>(buffer, buffer + sizeof buffer));
298 }
299
TEST(SizesView,DecodeEnumsFromText)300 TEST(SizesView, DecodeEnumsFromText) {
301 ::std::uint8_t buffer[sizeof kEnumSizes] = {0};
302 auto writer = EnumSizesWriter(buffer, sizeof buffer);
303 EXPECT_TRUE(::emboss::UpdateFromText(writer, R"(
304 {
305 one_byte: VALUE1
306 two_byte: VALUE10
307 three_byte: VALUE10000
308 four_byte: VALUE100
309 five_byte: VALUE100000
310 six_byte: VALUE1000000
311 seven_byte: VALUE10000000
312 eight_byte: VALUE1000
313 }
314 )"));
315 EXPECT_EQ(::std::vector</**/ ::std::uint8_t>(kEnumSizes,
316 kEnumSizes + sizeof kEnumSizes),
317 ::std::vector</**/ ::std::uint8_t>(buffer, buffer + sizeof buffer));
318 }
319
TEST(SizesView,DecodeEnumsFromIntegerText)320 TEST(SizesView, DecodeEnumsFromIntegerText) {
321 ::std::uint8_t buffer[sizeof kEnumSizes] = {0};
322 auto writer = EnumSizesWriter(buffer, sizeof buffer);
323 EXPECT_TRUE(::emboss::UpdateFromText(writer, R"(
324 {
325 one_byte: 1
326 two_byte: 10
327 three_byte: 10000
328 four_byte: 100
329 five_byte: 100000
330 six_byte: 1000000
331 seven_byte: 10000000
332 eight_byte: 1000
333 }
334 )"));
335 EXPECT_EQ(::std::vector</**/ ::std::uint8_t>(kEnumSizes,
336 kEnumSizes + sizeof kEnumSizes),
337 ::std::vector</**/ ::std::uint8_t>(buffer, buffer + sizeof buffer));
338 }
339
340 static const ::std::uint8_t kExplicitlySizedEnumSizes
341 [ExplicitlySizedEnumSizes::IntrinsicSizeInBytes()] = {
342 0x01, // 0:1 one_byte == VALUE1
343 0x0a, 0x00, // 1:3 two_byte == VALUE10
344 0x10, 0x27, 0x00, // 3:6 three_byte == VALUE10000
345 0x64, 0x00, 0x00, 0x00, // 6:10 three_and_a_half_byte == VALUE100
346 };
347
TEST(SizesView,CanReadExplicitlySizedEnumSizes)348 TEST(SizesView, CanReadExplicitlySizedEnumSizes) {
349 auto view = ExplicitlySizedEnumSizesView(kExplicitlySizedEnumSizes,
350 sizeof kExplicitlySizedEnumSizes);
351 EXPECT_EQ(ExplicitlySizedEnum::VALUE1, view.one_byte().Read());
352 EXPECT_EQ(ExplicitlySizedEnum::VALUE10, view.two_byte().Read());
353 EXPECT_EQ(ExplicitlySizedEnum::VALUE10000, view.three_byte().Read());
354 EXPECT_EQ(ExplicitlySizedEnum::VALUE100, view.three_and_a_half_byte().Read());
355 // 28-bit explicitly-sized enum should be uint32_t.
356 EXPECT_EQ(4U, sizeof(view.one_byte().Read()));
357 EXPECT_EQ(4U, sizeof(view.two_byte().Read()));
358 EXPECT_EQ(4U, sizeof(view.three_byte().Read()));
359 EXPECT_EQ(4U, sizeof(view.three_and_a_half_byte().Read()));
360 }
361
TEST(SizesWriter,CanWriteExplicitlySizedEnumSizes)362 TEST(SizesWriter, CanWriteExplicitlySizedEnumSizes) {
363 ::std::uint8_t buffer[sizeof kExplicitlySizedEnumSizes] = {0};
364 auto writer = ExplicitlySizedEnumSizesWriter(buffer, sizeof buffer);
365 writer.one_byte().Write(ExplicitlySizedEnum::VALUE1);
366 writer.two_byte().Write(ExplicitlySizedEnum::VALUE10);
367 writer.three_byte().Write(ExplicitlySizedEnum::VALUE10000);
368 writer.three_and_a_half_byte().Write(ExplicitlySizedEnum::VALUE100);
369 EXPECT_EQ(::std::vector</**/ ::std::uint8_t>(
370 kExplicitlySizedEnumSizes,
371 kExplicitlySizedEnumSizes + sizeof kExplicitlySizedEnumSizes),
372 ::std::vector</**/ ::std::uint8_t>(buffer, buffer + sizeof buffer));
373 }
374
TEST(SizesView,DecodeExplicitlySizedEnumsFromText)375 TEST(SizesView, DecodeExplicitlySizedEnumsFromText) {
376 ::std::uint8_t buffer[sizeof kExplicitlySizedEnumSizes] = {0};
377 auto writer = ExplicitlySizedEnumSizesWriter(buffer, sizeof buffer);
378 EXPECT_TRUE(::emboss::UpdateFromText(writer, R"(
379 {
380 one_byte: VALUE1
381 two_byte: VALUE10
382 three_byte: VALUE10000
383 three_and_a_half_byte: VALUE100
384 }
385 )"));
386 EXPECT_EQ(::std::vector</**/ ::std::uint8_t>(
387 kExplicitlySizedEnumSizes,
388 kExplicitlySizedEnumSizes + sizeof kExplicitlySizedEnumSizes),
389 ::std::vector</**/ ::std::uint8_t>(buffer, buffer + sizeof buffer));
390 }
391
TEST(SizesView,DecodeExplicitlySizedEnumsFromIntegerText)392 TEST(SizesView, DecodeExplicitlySizedEnumsFromIntegerText) {
393 ::std::uint8_t buffer[sizeof kExplicitlySizedEnumSizes] = {0};
394 auto writer = ExplicitlySizedEnumSizesWriter(buffer, sizeof buffer);
395 EXPECT_TRUE(::emboss::UpdateFromText(writer, R"(
396 {
397 one_byte: 1
398 two_byte: 10
399 three_byte: 10000
400 three_and_a_half_byte: 100
401 }
402 )"));
403 EXPECT_EQ(::std::vector</**/ ::std::uint8_t>(
404 kExplicitlySizedEnumSizes,
405 kExplicitlySizedEnumSizes + sizeof kExplicitlySizedEnumSizes),
406 ::std::vector</**/ ::std::uint8_t>(buffer, buffer + sizeof buffer));
407 }
408
409 static const ::std::uint8_t kUIntArraySizes[72] = {
410 0x02, // 0:2 one_byte[0] == 2
411 0x03, // 0:2 one_byte[1] == 3
412 0x04, 0x01, // 2:6 two_byte[0] == 260
413 0x05, 0x01, // 2:6 two_byte[1] == 261
414 0x66, 0x55, 0x44, // 6:12 three_byte[0] == 0x445566
415 0x67, 0x55, 0x44, // 6:12 three_byte[1] == 0x445567
416 0x06, 0x05, 0x04, 0x03, // 12:20 four_byte[0] == 0x03040506
417 0x07, 0x05, 0x04, 0x03, // 12:20 four_byte[1] == 0x03040507
418 0x21, 0x43, 0x65, 0x87, // 20:30 five_byte[0]
419 0xa9, // 20:30 five_byte[0] == 0xa987654321
420 0x22, 0x43, 0x65, 0x87, // 20:30 five_byte[1]
421 0xa9, // 20:30 five_byte[1] == 0xa987654322
422 0xbc, 0x9a, 0x78, 0x56, // 30:42 six_byte[0]
423 0x34, 0x12, // 30:42 six_byte[0] == 0x123456789abc
424 0xbd, 0x9a, 0x78, 0x56, // 30:42 six_byte[1]
425 0x34, 0x12, // 30:42 six_byte[1] == 0x123456789abd
426 0x97, 0xa6, 0xb5, 0xc4, // 42:56 seven_byte[0]
427 0xd3, 0xe2, 0xf1, // 42:56 seven_byte[0] == 0xf1e2d3c4b5a697
428 0x98, 0xa6, 0xb5, 0xc4, // 42:56 seven_byte[1]
429 0xd3, 0xe2, 0xf1, // 42:56 seven_byte[1] == 0xf1e2d3c4b5a698
430 0x06, 0x05, 0x04, 0x03, // 56:72 eight_byte[0]
431 0x02, 0x01, 0x00, 0xff, // 56:72 eight_byte[0] == 0xff00010203040506
432 0x07, 0x05, 0x04, 0x03, // 56:72 eight_byte[1]
433 0x02, 0x01, 0x00, 0xff, // 56:72 eight_byte[1] == 0xff00010203040507
434 };
435
TEST(SizesView,CanReadArraySizes)436 TEST(SizesView, CanReadArraySizes) {
437 auto view = ArraySizesView(kUIntArraySizes, sizeof kUIntArraySizes);
438 EXPECT_EQ(2, view.one_byte()[0].Read());
439 EXPECT_EQ(3, view.one_byte()[1].Read());
440 EXPECT_EQ(260, view.two_byte()[0].Read());
441 EXPECT_EQ(261, view.two_byte()[1].Read());
442 EXPECT_EQ(0x445566U, view.three_byte()[0].Read());
443 EXPECT_EQ(0x445567U, view.three_byte()[1].Read());
444 EXPECT_EQ(0x03040506U, view.four_byte()[0].Read());
445 EXPECT_EQ(0x03040507U, view.four_byte()[1].Read());
446 EXPECT_EQ(0xa987654321UL, view.five_byte()[0].Read());
447 EXPECT_EQ(0xa987654322UL, view.five_byte()[1].Read());
448 EXPECT_EQ(0x123456789abcUL, view.six_byte()[0].Read());
449 EXPECT_EQ(0x123456789abdUL, view.six_byte()[1].Read());
450 EXPECT_EQ(0xf1e2d3c4b5a697UL, view.seven_byte()[0].Read());
451 EXPECT_EQ(0xf1e2d3c4b5a698UL, view.seven_byte()[1].Read());
452 EXPECT_EQ(0xff00010203040506UL, view.eight_byte()[0].Read());
453 EXPECT_EQ(0xff00010203040507UL, view.eight_byte()[1].Read());
454 // Test that the views return appropriate integer widths.
455 EXPECT_EQ(1U, sizeof(view.one_byte()[0].Read()));
456 EXPECT_EQ(2U, sizeof(view.two_byte()[0].Read()));
457 EXPECT_EQ(4U, sizeof(view.three_byte()[0].Read()));
458 EXPECT_EQ(4U, sizeof(view.four_byte()[0].Read()));
459 EXPECT_EQ(8U, sizeof(view.five_byte()[0].Read()));
460 EXPECT_EQ(8U, sizeof(view.six_byte()[0].Read()));
461 EXPECT_EQ(8U, sizeof(view.seven_byte()[0].Read()));
462 EXPECT_EQ(8U, sizeof(view.eight_byte()[0].Read()));
463 }
464
TEST(SizesView,ToString)465 TEST(SizesView, ToString) {
466 ::std::array</**/ ::std::uint8_t, sizeof kUIntArraySizes> buf = {'a', 'b'};
467 auto view = MakeArraySizesView(&buf);
468
469 EXPECT_EQ(view.one_byte().ToString</**/ ::std::string>(), "ab");
470 }
471
TEST(SizesView,CopyFrom)472 TEST(SizesView, CopyFrom) {
473 ::std::array</**/ ::std::uint8_t, sizeof kUIntArraySizes> buf_x = {};
474 ::std::array</**/ ::std::uint8_t, sizeof kUIntArraySizes> buf_y = {};
475
476 const auto x = SizesWriter(&buf_x);
477 const auto y = SizesWriter(&buf_y);
478
479 constexpr int kValue = 42;
480 x.one_byte().Write(kValue);
481 EXPECT_NE(x.one_byte().Read(), y.one_byte().Read());
482 y.one_byte().CopyFrom(x.one_byte());
483 EXPECT_EQ(x.one_byte().Read(), y.one_byte().Read());
484 }
485
TEST(SizesView,TryToCopyFrom)486 TEST(SizesView, TryToCopyFrom) {
487 ::std::array</**/ ::std::uint8_t, sizeof kUIntArraySizes> buf_x = {};
488 ::std::array</**/ ::std::uint8_t, sizeof kUIntArraySizes> buf_y = {};
489
490 const auto x = SizesWriter(&buf_x);
491 const auto y = SizesWriter(&buf_y);
492
493 constexpr int kValue = 42;
494 x.one_byte().Write(kValue);
495 EXPECT_NE(x.one_byte().Read(), y.one_byte().Read());
496 EXPECT_TRUE(y.one_byte().TryToCopyFrom(x.one_byte()));
497 EXPECT_EQ(x.one_byte().Read(), y.one_byte().Read());
498 }
499
500 } // namespace
501 } // namespace test
502 } // namespace emboss
503