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 to ensure that conditional fields work.
16 #include <stdint.h>
17
18 #include <vector>
19
20 #include "gtest/gtest.h"
21 #include "testdata/condition.emb.h"
22
23 namespace emboss {
24 namespace test {
25 namespace {
26
TEST(Conditional,WithConditionTrueFieldsAreOk)27 TEST(Conditional, WithConditionTrueFieldsAreOk) {
28 ::std::uint8_t buffer[2] = {0, 0};
29 auto writer = BasicConditionalWriter(buffer, sizeof buffer);
30 EXPECT_TRUE(writer.Ok());
31 EXPECT_TRUE(writer.x().Ok());
32 EXPECT_TRUE(writer.xc().Ok());
33 }
34
TEST(Conditional,WithConditionTrueAllFieldsAreReadable)35 TEST(Conditional, WithConditionTrueAllFieldsAreReadable) {
36 ::std::uint8_t buffer[2] = {0, 2};
37 auto writer = BasicConditionalWriter(buffer, sizeof buffer);
38 EXPECT_EQ(0, writer.x().Read());
39 EXPECT_EQ(2, writer.xc().Read());
40 }
41
TEST(Conditional,WithConditionTrueConditionalFieldIsWritable)42 TEST(Conditional, WithConditionTrueConditionalFieldIsWritable) {
43 ::std::uint8_t buffer1[2] = {0, 2};
44 auto writer1 = BasicConditionalWriter(buffer1, sizeof buffer1);
45 EXPECT_TRUE(writer1.xc().TryToWrite(3));
46 EXPECT_EQ(3, buffer1[1]);
47
48 ::std::uint8_t buffer2[2] = {0, 0};
49 auto writer2 = BasicConditionalWriter(buffer2, sizeof buffer2);
50 EXPECT_FALSE(writer2.xc().Equals(writer1.xc()));
51 EXPECT_TRUE(writer2.xc().TryToCopyFrom(writer1.xc()));
52 EXPECT_TRUE(writer2.xc().Equals(writer1.xc()));
53 EXPECT_EQ(3, buffer2[1]);
54 }
55
TEST(Conditional,WithConditionFalseStructIsOkButConditionalFieldIsNot)56 TEST(Conditional, WithConditionFalseStructIsOkButConditionalFieldIsNot) {
57 ::std::uint8_t buffer[2] = {1, 2};
58 auto writer = BasicConditionalWriter(buffer, sizeof buffer);
59 EXPECT_TRUE(writer.Ok());
60 EXPECT_TRUE(writer.x().Ok());
61 EXPECT_FALSE(writer.xc().Ok());
62 }
63
64 #if EMBOSS_CHECK_ABORTS
TEST(Conditional,BasicConditionFalseReadCrashes)65 TEST(Conditional, BasicConditionFalseReadCrashes) {
66 ::std::uint8_t buffer[2] = {1, 2};
67 auto writer = BasicConditionalWriter(buffer, sizeof buffer);
68 EXPECT_DEATH(writer.xc().Read(), "");
69 }
70
TEST(Conditional,BasicConditionFalseWriteCrashes)71 TEST(Conditional, BasicConditionFalseWriteCrashes) {
72 ::std::uint8_t buffer[2] = {1, 2};
73 auto writer = BasicConditionalWriter(buffer, sizeof buffer);
74 EXPECT_DEATH(writer.xc().Write(3), "");
75 }
76 #endif // EMBOSS_CHECK_ABORTS
77
TEST(Conditional,BasicConditionTrueSizeIncludesConditionalField)78 TEST(Conditional, BasicConditionTrueSizeIncludesConditionalField) {
79 ::std::uint8_t buffer[2] = {0, 2};
80 auto writer = BasicConditionalWriter(buffer, sizeof buffer);
81 EXPECT_EQ(2U, writer.SizeInBytes());
82 EXPECT_EQ(2, BasicConditional::MaxSizeInBytes());
83 EXPECT_EQ(1, BasicConditional::MinSizeInBytes());
84 EXPECT_EQ(2, writer.MaxSizeInBytes().Read());
85 EXPECT_EQ(1, writer.MinSizeInBytes().Read());
86 }
87
TEST(Conditional,BasicConditionFalseSizeDoesNotIncludeConditionalField)88 TEST(Conditional, BasicConditionFalseSizeDoesNotIncludeConditionalField) {
89 ::std::uint8_t buffer[2] = {1, 2};
90 auto writer = BasicConditionalWriter(buffer, sizeof buffer);
91 EXPECT_EQ(1U, writer.SizeInBytes());
92 EXPECT_EQ(2, writer.MaxSizeInBytes().Read());
93 EXPECT_EQ(1, writer.MinSizeInBytes().Read());
94 }
95
TEST(Conditional,WithConditionFalseStructIsOkWhenBufferIsSmall)96 TEST(Conditional, WithConditionFalseStructIsOkWhenBufferIsSmall) {
97 ::std::uint8_t buffer[1] = {1};
98 auto writer = BasicConditionalWriter(buffer, sizeof buffer);
99 EXPECT_TRUE(writer.Ok());
100 EXPECT_TRUE(writer.x().Ok());
101 EXPECT_FALSE(writer.xc().Ok());
102 }
103
TEST(Conditional,WithConditionTrueStructIsNotOkWhenBufferIsSmall)104 TEST(Conditional, WithConditionTrueStructIsNotOkWhenBufferIsSmall) {
105 ::std::uint8_t buffer[1] = {0};
106 auto writer = BasicConditionalWriter(buffer, sizeof buffer);
107 EXPECT_FALSE(writer.Ok());
108 EXPECT_TRUE(writer.x().Ok());
109 EXPECT_TRUE(writer.has_xc().Known());
110 EXPECT_TRUE(writer.has_xc().Value());
111 EXPECT_FALSE(writer.xc().Ok());
112 }
113
TEST(Conditional,WithNegativeConditionTrueFieldsAreOk)114 TEST(Conditional, WithNegativeConditionTrueFieldsAreOk) {
115 ::std::uint8_t buffer[2] = {1, 0};
116 auto writer = NegativeConditionalWriter(buffer, sizeof buffer);
117 EXPECT_TRUE(writer.Ok());
118 EXPECT_TRUE(writer.x().Ok());
119 EXPECT_TRUE(writer.xc().Ok());
120 }
121
TEST(Conditional,WithNegativeConditionTrueAllFieldsAreReadable)122 TEST(Conditional, WithNegativeConditionTrueAllFieldsAreReadable) {
123 ::std::uint8_t buffer[2] = {1, 2};
124 auto writer = NegativeConditionalWriter(buffer, sizeof buffer);
125 EXPECT_EQ(1, writer.x().Read());
126 EXPECT_EQ(2, writer.xc().Read());
127 }
128
TEST(Conditional,WithNegativeConditionTrueConditionalFieldIsWritable)129 TEST(Conditional, WithNegativeConditionTrueConditionalFieldIsWritable) {
130 ::std::uint8_t buffer1[2] = {1, 2};
131 auto writer1 = NegativeConditionalWriter(buffer1, sizeof buffer1);
132 EXPECT_TRUE(writer1.xc().TryToWrite(3));
133 EXPECT_EQ(3, buffer1[1]);
134
135 ::std::uint8_t buffer2[2] = {1, 0};
136 auto writer2 = NegativeConditionalWriter(buffer2, sizeof buffer2);
137 EXPECT_FALSE(writer2.xc().Equals(writer1.xc()));
138 EXPECT_TRUE(writer2.xc().TryToCopyFrom(writer1.xc()));
139 EXPECT_TRUE(writer2.xc().Equals(writer1.xc()));
140 EXPECT_EQ(3, buffer2[1]);
141 }
142
TEST(Conditional,WithNegativeConditionFalseStructIsOkButConditionalFieldIsNot)143 TEST(Conditional,
144 WithNegativeConditionFalseStructIsOkButConditionalFieldIsNot) {
145 ::std::uint8_t buffer[2] = {0, 2};
146 auto writer = NegativeConditionalWriter(buffer, sizeof buffer);
147 EXPECT_TRUE(writer.Ok());
148 EXPECT_TRUE(writer.x().Ok());
149 EXPECT_FALSE(writer.xc().Ok());
150 }
151
TEST(Conditional,NegativeConditionFalseReadCrashes)152 TEST(Conditional, NegativeConditionFalseReadCrashes) {
153 ::std::uint8_t buffer1[2] = {0, 2};
154 auto writer1 = NegativeConditionalWriter(buffer1, sizeof buffer1);
155 #if EMBOSS_CHECK_ABORTS
156 EXPECT_DEATH(writer1.xc().Read(), "");
157 #endif // EMBOSS_CHECK_ABORTS
158
159 ::std::uint8_t buffer2[2] = {0, 0};
160 auto writer2 = BasicConditionalWriter(buffer2, sizeof buffer2);
161 EXPECT_TRUE(writer2.xc().CouldWriteValue(2));
162 EXPECT_EQ(writer2.xc().Read(), 0);
163 EXPECT_FALSE(writer2.xc().TryToCopyFrom(writer1.xc()));
164 EXPECT_EQ(writer2.xc().Read(), 0);
165 }
166
TEST(Conditional,NegativeConditionFalseWriteCrashes)167 TEST(Conditional, NegativeConditionFalseWriteCrashes) {
168 ::std::uint8_t buffer1[2] = {0, 2};
169 auto writer1 = NegativeConditionalWriter(buffer1, sizeof buffer1);
170 #if EMBOSS_CHECK_ABORTS
171 EXPECT_DEATH(writer1.xc().Write(3), "");
172 #endif // EMBOSS_CHECK_ABORTS
173
174 ::std::uint8_t buffer2[2] = {0, 2};
175 auto writer2 = NegativeConditionalWriter(buffer2, sizeof buffer2);
176 EXPECT_FALSE(writer2.xc().TryToCopyFrom(writer1.xc()));
177 }
178
TEST(Conditional,NegativeConditionTrueSizeIncludesConditionalField)179 TEST(Conditional, NegativeConditionTrueSizeIncludesConditionalField) {
180 ::std::uint8_t buffer[2] = {1, 2};
181 auto writer = NegativeConditionalWriter(buffer, sizeof buffer);
182 EXPECT_EQ(2U, writer.SizeInBytes());
183 }
184
TEST(Conditional,NegativeConditionFalseSizeDoesNotIncludeConditionalField)185 TEST(Conditional, NegativeConditionFalseSizeDoesNotIncludeConditionalField) {
186 ::std::uint8_t buffer[2] = {0, 2};
187 auto writer = NegativeConditionalWriter(buffer, sizeof buffer);
188 EXPECT_EQ(1U, writer.SizeInBytes());
189 }
190
TEST(Conditional,WithNegativeConditionFalseStructIsOkWhenBufferIsSmall)191 TEST(Conditional, WithNegativeConditionFalseStructIsOkWhenBufferIsSmall) {
192 ::std::uint8_t buffer[1] = {0};
193 auto writer = NegativeConditionalWriter(buffer, sizeof buffer);
194 EXPECT_TRUE(writer.Ok());
195 EXPECT_TRUE(writer.x().Ok());
196 EXPECT_FALSE(writer.xc().Ok());
197 }
198
TEST(Conditional,WithNegativeConditionTrueStructIsNotOkWhenBufferIsSmall)199 TEST(Conditional, WithNegativeConditionTrueStructIsNotOkWhenBufferIsSmall) {
200 ::std::uint8_t buffer[1] = {1};
201 auto writer = NegativeConditionalWriter(buffer, sizeof buffer);
202 EXPECT_FALSE(writer.Ok());
203 EXPECT_TRUE(writer.x().Ok());
204 EXPECT_TRUE(writer.has_xc().Known());
205 EXPECT_TRUE(writer.has_xc().Value());
206 EXPECT_FALSE(writer.xc().Ok());
207 }
208
TEST(Conditional,SizeIncludesUnconditionalFieldsThatOverlapWithConditionalFields)209 TEST(Conditional,
210 SizeIncludesUnconditionalFieldsThatOverlapWithConditionalFields) {
211 ::std::uint8_t buffer[2] = {1, 2};
212 auto writer = ConditionalAndUnconditionalOverlappingFinalFieldWriter(
213 buffer, sizeof buffer);
214 EXPECT_TRUE(writer.Ok());
215 EXPECT_EQ(2U, writer.SizeInBytes());
216 }
217
TEST(Conditional,SizeIsConstantWhenUnconditionalFieldsOverlapWithConditionalFields)218 TEST(Conditional,
219 SizeIsConstantWhenUnconditionalFieldsOverlapWithConditionalFields) {
220 EXPECT_EQ(
221 2U,
222 ConditionalAndUnconditionalOverlappingFinalFieldWriter::SizeInBytes());
223 }
224
TEST(Conditional,WhenConditionalFieldIsFirstSizeIsConstant)225 TEST(Conditional, WhenConditionalFieldIsFirstSizeIsConstant) {
226 EXPECT_EQ(2U, ConditionalBasicConditionalFieldFirstWriter::SizeInBytes());
227 }
228
TEST(Conditional,WhenConditionIsFalseDynamicallyPlacedFieldDoesNotAffectSize)229 TEST(Conditional, WhenConditionIsFalseDynamicallyPlacedFieldDoesNotAffectSize) {
230 ::std::uint8_t buffer[3] = {1, 0, 10};
231 auto writer = ConditionalAndDynamicLocationWriter(buffer, sizeof buffer);
232 EXPECT_TRUE(writer.Ok());
233 EXPECT_EQ(3U, writer.SizeInBytes());
234 }
235
TEST(Conditional,WhenConditionIsTrueDynamicallyPlacedFieldDoesAffectSize)236 TEST(Conditional, WhenConditionIsTrueDynamicallyPlacedFieldDoesAffectSize) {
237 ::std::uint8_t buffer[4] = {0, 0, 3, 0};
238 auto writer = ConditionalAndDynamicLocationWriter(buffer, sizeof buffer);
239 EXPECT_TRUE(writer.Ok());
240 EXPECT_EQ(4U, writer.SizeInBytes());
241 }
242
TEST(Conditional,WhenConditionIsTrueDynamicallyPlacedFieldOutOfRangeIsError)243 TEST(Conditional, WhenConditionIsTrueDynamicallyPlacedFieldOutOfRangeIsError) {
244 ::std::uint8_t buffer[3] = {0, 0, 3};
245 auto writer = ConditionalAndDynamicLocationWriter(buffer, sizeof buffer);
246 EXPECT_FALSE(writer.Ok());
247 EXPECT_EQ(4U, writer.SizeInBytes());
248 }
249
TEST(Conditional,ConditionUsesMinInt)250 TEST(Conditional, ConditionUsesMinInt) {
251 ::std::uint8_t buffer[2] = {0, 0};
252 auto view = MakeConditionUsesMinIntView(buffer, sizeof buffer);
253 EXPECT_TRUE(view.Ok());
254 EXPECT_FALSE(view.has_xc().ValueOr(true));
255 EXPECT_EQ(1U, view.SizeInBytes());
256 buffer[0] = 0x80;
257 EXPECT_TRUE(view.Ok());
258 EXPECT_EQ(-0x80, view.x().Read());
259 EXPECT_TRUE(view.has_xc().ValueOr(false));
260 EXPECT_EQ(2U, view.SizeInBytes());
261 }
262
TEST(Conditional,StructWithNestedConditionIsNotOkWhenOuterConditionDoesNotExist)263 TEST(Conditional,
264 StructWithNestedConditionIsNotOkWhenOuterConditionDoesNotExist) {
265 ::std::uint8_t buffer[3] = {1, 0, 3};
266 auto writer = NestedConditionalWriter(buffer, sizeof buffer);
267 ASSERT_FALSE(writer.IntrinsicSizeInBytes().Ok());
268 ASSERT_FALSE((writer.xc().Ok()));
269 ASSERT_FALSE(writer.SizeIsKnown());
270 ASSERT_FALSE(writer.IsComplete());
271 ASSERT_FALSE(writer.Ok());
272 ASSERT_TRUE(writer.has_xc().Known());
273 ASSERT_FALSE(writer.has_xc().Value());
274 ASSERT_FALSE(writer.has_xcc().Known());
275 }
276
TEST(Conditional,StructWithCorrectNestedConditionIsOkWhenOuterConditionDoesNotExist)277 TEST(Conditional,
278 StructWithCorrectNestedConditionIsOkWhenOuterConditionDoesNotExist) {
279 ::std::uint8_t buffer[3] = {1, 0, 3};
280 auto writer = CorrectNestedConditionalWriter(buffer, sizeof buffer);
281 EXPECT_TRUE(writer.IsComplete());
282 EXPECT_TRUE(writer.Ok());
283 EXPECT_TRUE(writer.has_xc().Known());
284 EXPECT_FALSE(writer.has_xc().Value());
285 EXPECT_TRUE(writer.has_xcc().Known());
286 EXPECT_FALSE(writer.has_xcc().Value());
287 EXPECT_TRUE(writer.SizeIsKnown());
288 EXPECT_EQ(1U, writer.SizeInBytes());
289 }
290
TEST(Conditional,StructWithNestedConditionIsOkWhenOuterConditionExists)291 TEST(Conditional, StructWithNestedConditionIsOkWhenOuterConditionExists) {
292 ::std::uint8_t buffer[3] = {0, 1, 3};
293 auto writer = NestedConditionalWriter(buffer, sizeof buffer);
294 EXPECT_TRUE(writer.Ok());
295 ASSERT_TRUE(writer.SizeIsKnown());
296 EXPECT_TRUE(writer.has_xc().Known());
297 EXPECT_TRUE(writer.has_xc().Value());
298 EXPECT_TRUE(writer.has_xcc().Known());
299 EXPECT_FALSE(writer.has_xcc().Value());
300 EXPECT_EQ(2U, writer.SizeInBytes());
301 }
302
TEST(Conditional,AlwaysMissingFieldDoesNotContributeToStaticSize)303 TEST(Conditional, AlwaysMissingFieldDoesNotContributeToStaticSize) {
304 EXPECT_EQ(0U, OnlyAlwaysFalseConditionWriter::SizeInBytes());
305 EXPECT_EQ(1U, AlwaysFalseConditionWriter::SizeInBytes());
306 }
307
TEST(Conditional,AlwaysMissingFieldDoesNotContributeToSize)308 TEST(Conditional, AlwaysMissingFieldDoesNotContributeToSize) {
309 ::std::uint8_t buffer[1] = {0};
310 auto view = MakeAlwaysFalseConditionDynamicSizeView(buffer, sizeof buffer);
311 ASSERT_TRUE(view.SizeIsKnown());
312 EXPECT_EQ(1U, view.SizeInBytes());
313 }
314
TEST(Conditional,StructIsOkWithAlwaysMissingField)315 TEST(Conditional, StructIsOkWithAlwaysMissingField) {
316 ::std::uint8_t buffer[1] = {0};
317 auto writer = AlwaysFalseConditionWriter(buffer, sizeof buffer);
318 EXPECT_TRUE(writer.Ok());
319 ASSERT_TRUE(writer.SizeIsKnown());
320 EXPECT_EQ(1U, writer.SizeInBytes());
321 EXPECT_EQ(1U, AlwaysFalseConditionView::SizeInBytes());
322 }
323
TEST(Conditional,StructIsOkWithOnlyAlwaysMissingField)324 TEST(Conditional, StructIsOkWithOnlyAlwaysMissingField) {
325 ::std::uint8_t buffer[1] = {0};
326 auto writer = OnlyAlwaysFalseConditionWriter(buffer, sizeof buffer);
327 EXPECT_TRUE(writer.Ok());
328 ASSERT_TRUE(writer.SizeIsKnown());
329 EXPECT_EQ(0U, writer.SizeInBytes());
330 EXPECT_EQ(0U, OnlyAlwaysFalseConditionView::SizeInBytes());
331 }
332
TEST(Conditional,ConditionDoesNotBlockStaticSize)333 TEST(Conditional, ConditionDoesNotBlockStaticSize) {
334 EXPECT_EQ(3U, ConditionDoesNotContributeToSizeView::SizeInBytes());
335 }
336
TEST(Conditional,EqualsHaveAllFields)337 TEST(Conditional, EqualsHaveAllFields) {
338 ::std::array</**/ ::std::uint8_t, 2> buf_a = {0, 1};
339 ::std::array</**/ ::std::uint8_t, 2> buf_b = {0, 1};
340 EXPECT_EQ(buf_a, buf_b);
341
342 auto a = BasicConditionalWriter(&buf_a);
343 auto a_const = BasicConditionalWriter(
344 static_cast</**/ ::std::array</**/ ::std::uint8_t, 2> *>(&buf_a));
345 auto b = BasicConditionalWriter(&buf_b);
346
347 EXPECT_TRUE(a.has_xc().Known());
348 EXPECT_TRUE(a.has_xc().Value());
349 EXPECT_TRUE(b.has_xc().Known());
350 EXPECT_TRUE(b.has_xc().Value());
351
352 EXPECT_TRUE(a.Equals(a));
353 EXPECT_TRUE(a.UncheckedEquals(a));
354 EXPECT_TRUE(b.Equals(b));
355 EXPECT_TRUE(b.UncheckedEquals(b));
356
357 EXPECT_TRUE(a.Equals(b));
358 EXPECT_TRUE(a.UncheckedEquals(b));
359 EXPECT_TRUE(b.Equals(a));
360 EXPECT_TRUE(b.UncheckedEquals(a));
361
362 EXPECT_TRUE(a_const.Equals(b));
363 EXPECT_TRUE(a_const.UncheckedEquals(b));
364 EXPECT_TRUE(b.Equals(a_const));
365 EXPECT_TRUE(b.UncheckedEquals(a_const));
366
367 b.xc().Write(b.xc().Read() + 1);
368 EXPECT_FALSE(a.Equals(b));
369 EXPECT_FALSE(a.UncheckedEquals(b));
370 EXPECT_FALSE(b.Equals(a));
371 EXPECT_FALSE(b.UncheckedEquals(a));
372
373 EXPECT_FALSE(a_const.Equals(b));
374 EXPECT_FALSE(a_const.UncheckedEquals(b));
375 EXPECT_FALSE(b.Equals(a_const));
376 EXPECT_FALSE(b.UncheckedEquals(a_const));
377 }
378
TEST(Conditional,EqualsOneViewMissingField)379 TEST(Conditional, EqualsOneViewMissingField) {
380 ::std::array</**/ ::std::uint8_t, 2> buf_a = {0, 1};
381 ::std::array</**/ ::std::uint8_t, 2> buf_b = {1, 1};
382 EXPECT_NE(buf_a, buf_b);
383
384 auto a = BasicConditionalWriter(&buf_a);
385 auto b = BasicConditionalWriter(&buf_b);
386
387 EXPECT_TRUE(a.has_xc().Known());
388 EXPECT_TRUE(a.has_xc().Value());
389 EXPECT_TRUE(b.has_xc().Known());
390 EXPECT_FALSE(b.has_xc().Value());
391
392 EXPECT_FALSE(a.Equals(b));
393 EXPECT_FALSE(a.UncheckedEquals(b));
394 EXPECT_FALSE(b.Equals(a));
395 EXPECT_FALSE(b.UncheckedEquals(a));
396 }
397
TEST(Conditional,EqualsBothFieldsMissing)398 TEST(Conditional, EqualsBothFieldsMissing) {
399 ::std::array</**/ ::std::uint8_t, 2> buf_a = {1, 1};
400 ::std::array</**/ ::std::uint8_t, 2> buf_b = {1, 1};
401 EXPECT_EQ(buf_a, buf_b);
402
403 auto a = BasicConditionalWriter(&buf_a);
404 auto a_const = BasicConditionalWriter(
405 static_cast</**/ ::std::array</**/ ::std::uint8_t, 2> *>(&buf_a));
406 auto b = BasicConditionalWriter(&buf_b);
407
408 EXPECT_TRUE(a.has_xc().Known());
409 EXPECT_FALSE(a.has_xc().Value());
410 EXPECT_TRUE(b.has_xc().Known());
411 EXPECT_FALSE(b.has_xc().Value());
412
413 EXPECT_TRUE(a.Equals(b));
414 EXPECT_TRUE(a.UncheckedEquals(b));
415 EXPECT_TRUE(b.Equals(a));
416 EXPECT_TRUE(b.UncheckedEquals(a));
417
418 EXPECT_TRUE(a_const.Equals(b));
419 EXPECT_TRUE(a_const.UncheckedEquals(b));
420 EXPECT_TRUE(b.Equals(a_const));
421 EXPECT_TRUE(b.UncheckedEquals(a_const));
422
423 ++buf_b[1];
424 EXPECT_NE(buf_a, buf_b);
425 EXPECT_TRUE(a.Equals(b));
426 EXPECT_TRUE(a.UncheckedEquals(b));
427 EXPECT_TRUE(b.Equals(a));
428 EXPECT_TRUE(b.UncheckedEquals(a));
429
430 EXPECT_TRUE(a_const.Equals(b));
431 EXPECT_TRUE(a_const.UncheckedEquals(b));
432 EXPECT_TRUE(b.Equals(a_const));
433 EXPECT_TRUE(b.UncheckedEquals(a_const));
434 }
435
TEST(Conditional,TrueEnumBasedCondition)436 TEST(Conditional, TrueEnumBasedCondition) {
437 ::std::uint8_t buffer[2] = {1};
438 auto writer = EnumConditionWriter(buffer, sizeof buffer);
439 EXPECT_TRUE(writer.Ok());
440 ASSERT_TRUE(writer.SizeIsKnown());
441 EXPECT_EQ(2U, writer.SizeInBytes());
442 EXPECT_TRUE(writer.has_xc().Value());
443 EXPECT_EQ(0, writer.xc().Read());
444 EXPECT_TRUE(writer.has_xc2().Value());
445 EXPECT_EQ(0, writer.xc2().Read());
446 }
447
TEST(Conditional,FalseEnumBasedCondition)448 TEST(Conditional, FalseEnumBasedCondition) {
449 ::std::uint8_t buffer[2] = {0};
450 auto writer = EnumConditionWriter(buffer, sizeof buffer);
451 EXPECT_TRUE(writer.Ok());
452 ASSERT_TRUE(writer.SizeIsKnown());
453 EXPECT_EQ(1U, writer.SizeInBytes());
454 EXPECT_FALSE(writer.xc().Ok());
455 EXPECT_FALSE(writer.has_xc().Value());
456 EXPECT_FALSE(writer.xc2().Ok());
457 EXPECT_FALSE(writer.has_xc2().Value());
458 }
459
TEST(Conditional,TrueEnumBasedNegativeCondition)460 TEST(Conditional, TrueEnumBasedNegativeCondition) {
461 ::std::uint8_t buffer[2] = {0};
462 auto writer = NegativeEnumConditionWriter(buffer, sizeof buffer);
463 EXPECT_TRUE(writer.Ok());
464 ASSERT_TRUE(writer.SizeIsKnown());
465 EXPECT_EQ(2U, writer.SizeInBytes());
466 EXPECT_EQ(0, writer.xc().Read());
467 }
468
TEST(Conditional,FalseEnumBasedNegativeCondition)469 TEST(Conditional, FalseEnumBasedNegativeCondition) {
470 ::std::uint8_t buffer[2] = {1};
471 auto writer = NegativeEnumConditionWriter(buffer, sizeof buffer);
472 EXPECT_TRUE(writer.Ok());
473 ASSERT_TRUE(writer.SizeIsKnown());
474 EXPECT_EQ(1U, writer.SizeInBytes());
475 EXPECT_FALSE(writer.xc().Ok());
476 }
477
TEST(LessThanConditional,LessThan)478 TEST(LessThanConditional, LessThan) {
479 ::std::uint8_t buffer[2] = {4};
480 auto writer = LessThanConditionWriter(buffer, sizeof buffer);
481 EXPECT_TRUE(writer.Ok());
482 ASSERT_TRUE(writer.SizeIsKnown());
483 EXPECT_EQ(2U, writer.SizeInBytes());
484 EXPECT_TRUE(writer.xc().Ok());
485 }
486
TEST(LessThanConditional,Equal)487 TEST(LessThanConditional, Equal) {
488 ::std::uint8_t buffer[2] = {5};
489 auto writer = LessThanConditionWriter(buffer, sizeof buffer);
490 EXPECT_TRUE(writer.Ok());
491 ASSERT_TRUE(writer.SizeIsKnown());
492 EXPECT_EQ(1U, writer.SizeInBytes());
493 EXPECT_FALSE(writer.xc().Ok());
494 }
495
TEST(LessThanConditional,GreaterThan)496 TEST(LessThanConditional, GreaterThan) {
497 ::std::uint8_t buffer[2] = {6};
498 auto writer = LessThanConditionWriter(buffer, sizeof buffer);
499 EXPECT_TRUE(writer.Ok());
500 ASSERT_TRUE(writer.SizeIsKnown());
501 EXPECT_EQ(1U, writer.SizeInBytes());
502 EXPECT_FALSE(writer.xc().Ok());
503 }
504
TEST(LessThanOrEqualConditional,LessThan)505 TEST(LessThanOrEqualConditional, LessThan) {
506 ::std::uint8_t buffer[2] = {4};
507 auto writer = LessThanOrEqualConditionWriter(buffer, sizeof buffer);
508 EXPECT_TRUE(writer.Ok());
509 ASSERT_TRUE(writer.SizeIsKnown());
510 EXPECT_EQ(2U, writer.SizeInBytes());
511 EXPECT_TRUE(writer.xc().Ok());
512 }
513
TEST(LessThanOrEqualConditional,Equal)514 TEST(LessThanOrEqualConditional, Equal) {
515 ::std::uint8_t buffer[2] = {5};
516 auto writer = LessThanOrEqualConditionWriter(buffer, sizeof buffer);
517 EXPECT_TRUE(writer.Ok());
518 ASSERT_TRUE(writer.SizeIsKnown());
519 EXPECT_EQ(2U, writer.SizeInBytes());
520 EXPECT_TRUE(writer.xc().Ok());
521 }
522
TEST(LessThanOrEqualConditional,GreaterThan)523 TEST(LessThanOrEqualConditional, GreaterThan) {
524 ::std::uint8_t buffer[2] = {6};
525 auto writer = LessThanOrEqualConditionWriter(buffer, sizeof buffer);
526 EXPECT_TRUE(writer.Ok());
527 ASSERT_TRUE(writer.SizeIsKnown());
528 EXPECT_EQ(1U, writer.SizeInBytes());
529 EXPECT_FALSE(writer.xc().Ok());
530 }
531
TEST(GreaterThanConditional,LessThan)532 TEST(GreaterThanConditional, LessThan) {
533 ::std::uint8_t buffer[2] = {4};
534 auto writer = GreaterThanConditionWriter(buffer, sizeof buffer);
535 EXPECT_TRUE(writer.Ok());
536 ASSERT_TRUE(writer.SizeIsKnown());
537 EXPECT_EQ(1U, writer.SizeInBytes());
538 EXPECT_FALSE(writer.xc().Ok());
539 }
540
TEST(GreaterThanConditional,Equal)541 TEST(GreaterThanConditional, Equal) {
542 ::std::uint8_t buffer[2] = {5};
543 auto writer = GreaterThanConditionWriter(buffer, sizeof buffer);
544 EXPECT_TRUE(writer.Ok());
545 ASSERT_TRUE(writer.SizeIsKnown());
546 EXPECT_EQ(1U, writer.SizeInBytes());
547 EXPECT_FALSE(writer.xc().Ok());
548 }
549
TEST(GreaterThanConditional,GreaterThan)550 TEST(GreaterThanConditional, GreaterThan) {
551 ::std::uint8_t buffer[2] = {6};
552 auto writer = GreaterThanConditionWriter(buffer, sizeof buffer);
553 EXPECT_TRUE(writer.Ok());
554 ASSERT_TRUE(writer.SizeIsKnown());
555 EXPECT_EQ(2U, writer.SizeInBytes());
556 EXPECT_TRUE(writer.xc().Ok());
557 }
558
TEST(GreaterThanOrEqualConditional,LessThan)559 TEST(GreaterThanOrEqualConditional, LessThan) {
560 ::std::uint8_t buffer[2] = {4};
561 auto writer = GreaterThanOrEqualConditionWriter(buffer, sizeof buffer);
562 EXPECT_TRUE(writer.Ok());
563 ASSERT_TRUE(writer.SizeIsKnown());
564 EXPECT_EQ(1U, writer.SizeInBytes());
565 EXPECT_FALSE(writer.xc().Ok());
566 }
567
TEST(GreaterThanOrEqualConditional,Equal)568 TEST(GreaterThanOrEqualConditional, Equal) {
569 ::std::uint8_t buffer[2] = {5};
570 auto writer = GreaterThanOrEqualConditionWriter(buffer, sizeof buffer);
571 EXPECT_TRUE(writer.Ok());
572 ASSERT_TRUE(writer.SizeIsKnown());
573 EXPECT_EQ(2U, writer.SizeInBytes());
574 EXPECT_TRUE(writer.xc().Ok());
575 }
576
TEST(GreaterThanOrEqualConditional,GreaterThan)577 TEST(GreaterThanOrEqualConditional, GreaterThan) {
578 ::std::uint8_t buffer[2] = {6};
579 auto writer = GreaterThanOrEqualConditionWriter(buffer, sizeof buffer);
580 EXPECT_TRUE(writer.Ok());
581 ASSERT_TRUE(writer.SizeIsKnown());
582 EXPECT_EQ(2U, writer.SizeInBytes());
583 EXPECT_TRUE(writer.xc().Ok());
584 }
585
TEST(RangeConditional,ValueTooSmall)586 TEST(RangeConditional, ValueTooSmall) {
587 ::std::uint8_t buffer[3] = {1, 9};
588 auto writer = RangeConditionWriter(buffer, sizeof buffer);
589 EXPECT_TRUE(writer.Ok());
590 ASSERT_TRUE(writer.SizeIsKnown());
591 EXPECT_EQ(2U, writer.SizeInBytes());
592 EXPECT_FALSE(writer.xc().Ok());
593 }
594
TEST(RangeConditional,ValueTooLarge)595 TEST(RangeConditional, ValueTooLarge) {
596 ::std::uint8_t buffer[3] = {11, 12};
597 auto writer = RangeConditionWriter(buffer, sizeof buffer);
598 EXPECT_TRUE(writer.Ok());
599 ASSERT_TRUE(writer.SizeIsKnown());
600 EXPECT_EQ(2U, writer.SizeInBytes());
601 EXPECT_FALSE(writer.xc().Ok());
602 }
603
TEST(RangeConditional,ValuesSwapped)604 TEST(RangeConditional, ValuesSwapped) {
605 ::std::uint8_t buffer[3] = {8, 7};
606 auto writer = RangeConditionWriter(buffer, sizeof buffer);
607 EXPECT_TRUE(writer.Ok());
608 ASSERT_TRUE(writer.SizeIsKnown());
609 EXPECT_EQ(2U, writer.SizeInBytes());
610 EXPECT_FALSE(writer.xc().Ok());
611 }
612
TEST(RangeConditional,True)613 TEST(RangeConditional, True) {
614 ::std::uint8_t buffer[3] = {7, 8};
615 auto writer = RangeConditionWriter(buffer, sizeof buffer);
616 EXPECT_TRUE(writer.Ok());
617 ASSERT_TRUE(writer.SizeIsKnown());
618 EXPECT_EQ(3U, writer.SizeInBytes());
619 EXPECT_TRUE(writer.xc().Ok());
620 }
621
TEST(ReverseRangeConditional,ValueTooSmall)622 TEST(ReverseRangeConditional, ValueTooSmall) {
623 ::std::uint8_t buffer[3] = {1, 9};
624 auto writer = ReverseRangeConditionWriter(buffer, sizeof buffer);
625 EXPECT_TRUE(writer.Ok());
626 ASSERT_TRUE(writer.SizeIsKnown());
627 EXPECT_EQ(2U, writer.SizeInBytes());
628 EXPECT_FALSE(writer.xc().Ok());
629 }
630
TEST(ReverseRangeConditional,ValueTooLarge)631 TEST(ReverseRangeConditional, ValueTooLarge) {
632 ::std::uint8_t buffer[3] = {11, 12};
633 auto writer = ReverseRangeConditionWriter(buffer, sizeof buffer);
634 EXPECT_TRUE(writer.Ok());
635 ASSERT_TRUE(writer.SizeIsKnown());
636 EXPECT_EQ(2U, writer.SizeInBytes());
637 EXPECT_FALSE(writer.xc().Ok());
638 }
639
TEST(ReverseRangeConditional,ValuesSwapped)640 TEST(ReverseRangeConditional, ValuesSwapped) {
641 ::std::uint8_t buffer[3] = {8, 7};
642 auto writer = ReverseRangeConditionWriter(buffer, sizeof buffer);
643 EXPECT_TRUE(writer.Ok());
644 ASSERT_TRUE(writer.SizeIsKnown());
645 EXPECT_EQ(2U, writer.SizeInBytes());
646 EXPECT_FALSE(writer.xc().Ok());
647 }
648
TEST(ReverseRangeConditional,True)649 TEST(ReverseRangeConditional, True) {
650 ::std::uint8_t buffer[3] = {7, 8};
651 auto writer = ReverseRangeConditionWriter(buffer, sizeof buffer);
652 EXPECT_TRUE(writer.Ok());
653 ASSERT_TRUE(writer.SizeIsKnown());
654 EXPECT_EQ(3U, writer.SizeInBytes());
655 EXPECT_TRUE(writer.xc().Ok());
656 }
657
TEST(AndConditional,BothFalse)658 TEST(AndConditional, BothFalse) {
659 ::std::uint8_t buffer[3] = {1, 1};
660 auto writer = AndConditionWriter(buffer, sizeof buffer);
661 EXPECT_TRUE(writer.Ok());
662 ASSERT_TRUE(writer.SizeIsKnown());
663 EXPECT_EQ(2U, writer.SizeInBytes());
664 EXPECT_FALSE(writer.xc().Ok());
665 }
666
TEST(AndConditional,FirstFalse)667 TEST(AndConditional, FirstFalse) {
668 ::std::uint8_t buffer[3] = {1, 5};
669 auto writer = AndConditionWriter(buffer, sizeof buffer);
670 EXPECT_TRUE(writer.Ok());
671 ASSERT_TRUE(writer.SizeIsKnown());
672 EXPECT_EQ(2U, writer.SizeInBytes());
673 EXPECT_FALSE(writer.xc().Ok());
674 }
675
TEST(AndConditional,SecondFalse)676 TEST(AndConditional, SecondFalse) {
677 ::std::uint8_t buffer[3] = {5, 1};
678 auto writer = AndConditionWriter(buffer, sizeof buffer);
679 EXPECT_TRUE(writer.Ok());
680 ASSERT_TRUE(writer.SizeIsKnown());
681 EXPECT_EQ(2U, writer.SizeInBytes());
682 EXPECT_FALSE(writer.xc().Ok());
683 }
684
TEST(AndConditional,BothTrue)685 TEST(AndConditional, BothTrue) {
686 ::std::uint8_t buffer[3] = {5, 5};
687 auto writer = AndConditionWriter(buffer, sizeof buffer);
688 EXPECT_TRUE(writer.Ok());
689 ASSERT_TRUE(writer.SizeIsKnown());
690 EXPECT_EQ(3U, writer.SizeInBytes());
691 EXPECT_TRUE(writer.xc().Ok());
692 }
693
TEST(OrConditional,BothFalse)694 TEST(OrConditional, BothFalse) {
695 ::std::uint8_t buffer[3] = {1, 1};
696 auto writer = OrConditionWriter(buffer, sizeof buffer);
697 EXPECT_TRUE(writer.Ok());
698 ASSERT_TRUE(writer.SizeIsKnown());
699 EXPECT_EQ(2U, writer.SizeInBytes());
700 EXPECT_FALSE(writer.xc().Ok());
701 }
702
TEST(OrConditional,FirstFalse)703 TEST(OrConditional, FirstFalse) {
704 ::std::uint8_t buffer[3] = {1, 5};
705 auto writer = OrConditionWriter(buffer, sizeof buffer);
706 EXPECT_TRUE(writer.Ok());
707 ASSERT_TRUE(writer.SizeIsKnown());
708 EXPECT_EQ(3U, writer.SizeInBytes());
709 EXPECT_TRUE(writer.xc().Ok());
710 }
711
TEST(OrConditional,SecondFalse)712 TEST(OrConditional, SecondFalse) {
713 ::std::uint8_t buffer[3] = {5, 1};
714 auto writer = OrConditionWriter(buffer, sizeof buffer);
715 EXPECT_TRUE(writer.Ok());
716 ASSERT_TRUE(writer.SizeIsKnown());
717 EXPECT_EQ(3U, writer.SizeInBytes());
718 EXPECT_TRUE(writer.xc().Ok());
719 }
720
TEST(OrConditional,BothTrue)721 TEST(OrConditional, BothTrue) {
722 ::std::uint8_t buffer[3] = {5, 5};
723 auto writer = OrConditionWriter(buffer, sizeof buffer);
724 EXPECT_TRUE(writer.Ok());
725 ASSERT_TRUE(writer.SizeIsKnown());
726 EXPECT_EQ(3U, writer.SizeInBytes());
727 EXPECT_TRUE(writer.xc().Ok());
728 }
729
TEST(ChoiceConditional,UseX)730 TEST(ChoiceConditional, UseX) {
731 ::std::array</**/ ::std::uint8_t, 4> buffer = {1, 5, 0, 10};
732 auto view = MakeChoiceConditionView(&buffer);
733 EXPECT_TRUE(view.Ok());
734 EXPECT_TRUE(view.SizeIsKnown());
735 EXPECT_EQ(4U, view.SizeInBytes());
736 EXPECT_TRUE(view.has_xyc().ValueOr(false));
737 EXPECT_EQ(10, view.xyc().Read());
738 }
739
TEST(ChoiceConditional,UseY)740 TEST(ChoiceConditional, UseY) {
741 ::std::array</**/ ::std::uint8_t, 4> buffer = {2, 5, 0, 10};
742 auto view = MakeChoiceConditionView(&buffer);
743 EXPECT_TRUE(view.Ok());
744 EXPECT_TRUE(view.SizeIsKnown());
745 EXPECT_EQ(3U, view.SizeInBytes());
746 EXPECT_FALSE(view.has_xyc().ValueOr(true));
747 }
748
TEST(FlagConditional,True)749 TEST(FlagConditional, True) {
750 ::std::uint8_t buffer[2] = {0x80, 0xff};
751 auto writer = ContainsContainsBitsWriter(buffer, sizeof buffer);
752 EXPECT_TRUE(writer.Ok());
753 EXPECT_TRUE(writer.SizeIsKnown());
754 EXPECT_TRUE(writer.top().Ok());
755 }
756
TEST(WriteToString,MissingFieldsAreNotWritten)757 TEST(WriteToString, MissingFieldsAreNotWritten) {
758 ::std::uint8_t buffer[2] = {0x01, 0x00};
759 auto reader = BasicConditionalWriter(buffer, 1U);
760 EXPECT_EQ(
761 "{\n"
762 " x: 1 # 0x1\n"
763 "}",
764 ::emboss::WriteToString(reader, ::emboss::MultilineText()));
765 EXPECT_EQ("{ x: 1 }", ::emboss::WriteToString(reader));
766 }
767
TEST(WriteToString,NotOkFieldsAreNotWritten)768 TEST(WriteToString, NotOkFieldsAreNotWritten) {
769 ::std::uint8_t buffer[2] = {0x00, 0x00};
770 auto reader = BasicConditionalWriter(buffer, 1U);
771 EXPECT_FALSE(reader.Ok());
772 EXPECT_EQ(
773 "{\n"
774 " x: 0 # 0x0\n"
775 " # xc: UNREADABLE\n"
776 "}",
777 ::emboss::WriteToString(
778 reader, ::emboss::MultilineText().WithAllowPartialOutput(true)));
779 EXPECT_EQ(
780 "{ x: 0 }",
781 ::emboss::WriteToString(
782 reader, ::emboss::TextOutputOptions().WithAllowPartialOutput(true)));
783 }
784
TEST(WriteToString,NotOkStructSubFieldsAreNotWritten)785 TEST(WriteToString, NotOkStructSubFieldsAreNotWritten) {
786 ::std::uint8_t buffer[2] = {0x00, 0x00};
787 auto reader = ConditionalInlineWriter(buffer, 2U);
788 EXPECT_FALSE(reader.Ok());
789 EXPECT_EQ(
790 "{\n"
791 " payload_id: 0 # 0x0\n"
792 " type_0: {\n"
793 " a: 0 # 0x0\n"
794 " # b: UNREADABLE\n"
795 " # c: UNREADABLE\n"
796 " }\n"
797 "}",
798 ::emboss::WriteToString(
799 reader, ::emboss::MultilineText().WithAllowPartialOutput(true)));
800 EXPECT_EQ(
801 "{ payload_id: 0, type_0: { a: 0 } }",
802 ::emboss::WriteToString(
803 reader, ::emboss::TextOutputOptions().WithAllowPartialOutput(true)));
804 }
805
TEST(WriteToString,PresentFieldsNotWritten)806 TEST(WriteToString, PresentFieldsNotWritten) {
807 ::std::uint8_t buffer[2] = {0x00, 0x01};
808 auto reader = BasicConditionalWriter(buffer, 2U);
809 EXPECT_EQ(
810 "{\n"
811 " x: 0 # 0x0\n"
812 " xc: 1 # 0x1\n"
813 "}",
814 ::emboss::WriteToString(reader, ::emboss::MultilineText()));
815 EXPECT_EQ("{ x: 0, xc: 1 }", ::emboss::WriteToString(reader));
816 }
817
TEST(WriteToString,AlwaysFalseCondition)818 TEST(WriteToString, AlwaysFalseCondition) {
819 ::std::uint8_t buffer[2] = {0x00};
820 auto reader = MakeAlwaysFalseConditionView(buffer, 1U);
821 EXPECT_EQ(
822 "{\n"
823 " x: 0 # 0x0\n"
824 "}",
825 ::emboss::WriteToString(reader, ::emboss::MultilineText()));
826 EXPECT_EQ("{ x: 0 }", ::emboss::WriteToString(reader));
827 }
828
TEST(WriteToString,OnlyAlwaysFalseCondition)829 TEST(WriteToString, OnlyAlwaysFalseCondition) {
830 ::std::uint8_t buffer[2] = {0x00};
831 auto reader = MakeOnlyAlwaysFalseConditionView(buffer, 0U);
832 EXPECT_EQ(
833 "{\n"
834 "}",
835 ::emboss::WriteToString(reader, ::emboss::MultilineText()));
836 EXPECT_EQ("{ }", ::emboss::WriteToString(reader));
837 }
838
TEST(WriteToString,EmptyStruct)839 TEST(WriteToString, EmptyStruct) {
840 ::std::uint8_t buffer[2] = {0x00};
841 auto reader = MakeEmptyStructView(buffer, 0U);
842 EXPECT_EQ(
843 "{\n"
844 "}",
845 ::emboss::WriteToString(reader, ::emboss::MultilineText()));
846 EXPECT_EQ("{ }", ::emboss::WriteToString(reader));
847 }
848
TEST(ConditionalInline,ConditionalInline)849 TEST(ConditionalInline, ConditionalInline) {
850 ::std::uint8_t buffer[4] = {0x00, 0x01, 0x02, 0x03};
851 auto reader = ConditionalInlineWriter(buffer, 4U);
852 EXPECT_EQ(1, reader.type_0().a().Read());
853 EXPECT_TRUE(reader.has_type_1().Known());
854 EXPECT_FALSE(reader.has_type_1().Value());
855 }
856
TEST(ConditionalAnonymous,ConditionalAnonymous)857 TEST(ConditionalAnonymous, ConditionalAnonymous) {
858 ::std::array</**/ ::std::uint8_t, 2> buffer = {0x00, 0x98};
859 auto view = MakeConditionalAnonymousView(&buffer);
860 EXPECT_TRUE(view.Ok());
861 EXPECT_FALSE(view.has_low().Value());
862 EXPECT_FALSE(view.has_mid().Value());
863 EXPECT_FALSE(view.has_high().Value());
864 view.x().Write(100);
865 EXPECT_TRUE(view.has_low().Value());
866 EXPECT_FALSE(view.has_mid().Value());
867 EXPECT_TRUE(view.has_high().Value());
868 EXPECT_EQ(0, view.low().Read());
869 EXPECT_EQ(1, view.high().Read());
870 view.low().Write(1);
871 EXPECT_TRUE(view.has_low().Value());
872 EXPECT_TRUE(view.has_mid().Value());
873 EXPECT_TRUE(view.has_high().Value());
874 EXPECT_EQ(1, view.low().Read());
875 EXPECT_EQ(3, view.mid().Read());
876 EXPECT_EQ(1, view.high().Read());
877 }
878
TEST(ConditionalOnFlag,ConditionalOnFlag)879 TEST(ConditionalOnFlag, ConditionalOnFlag) {
880 ::std::array</**/ ::std::uint8_t, 2> buffer = {0x00, 0x98};
881 auto view = MakeConditionalOnFlagView(&buffer);
882 EXPECT_TRUE(view.Ok());
883 EXPECT_FALSE(view.enabled().Read());
884 EXPECT_FALSE(view.has_value().Value());
885 buffer[0] = 1;
886 EXPECT_TRUE(view.enabled().Read());
887 EXPECT_TRUE(view.has_value().Value());
888 EXPECT_EQ(0x98, view.value().Read());
889 }
890
891 } // namespace
892 } // namespace test
893 } // namespace emboss
894