From 84cb9c6e40325a80c34c33a62f1553c19d151334 Mon Sep 17 00:00:00 2001 From: Shawn Silverman Date: Tue, 21 Nov 2017 20:53:05 -0800 Subject: [PATCH] In the tests, replacing the Reader and Writer variables by 'r' and 'w', respectively. --- src/tests/api.inc | 40 +- src/tests/array.inc | 80 ++-- src/tests/bytes.inc | 104 ++--- src/tests/floating_point.inc | 268 ++++++------ src/tests/map.inc | 84 ++-- src/tests/negative.inc | 84 ++-- src/tests/simple_value.inc | 102 ++--- src/tests/stream.inc | 66 +-- src/tests/syntax.inc | 64 +-- src/tests/tag.inc | 24 +- src/tests/unsigned.inc | 84 ++-- src/tests/well_formed.inc | 102 ++--- src/tests/write.inc | 762 +++++++++++++++++------------------ 13 files changed, 932 insertions(+), 932 deletions(-) diff --git a/src/tests/api.inc b/src/tests/api.inc index 4893551..d4a2279 100644 --- a/src/tests/api.inc +++ b/src/tests/api.inc @@ -6,13 +6,13 @@ test(short_write_single_byte) { uint8_t b[1]; cbor::BytesPrint bp{b, sizeof(b)}; - cbor::Writer cbor{bp}; - assertTrue(cbor.getWriteError() == 0); + cbor::Writer w{bp}; + assertTrue(w.getWriteError() == 0); uint8_t b2[] = { (0 << 5) + 24, 24 }; - cbor.writeUnsignedInt(b2[1]); - assertEqual(cbor.getWriteSize(), size_t{1}); - assertTrue(cbor.getWriteError() != 0); + w.writeUnsignedInt(b2[1]); + assertEqual(w.getWriteSize(), size_t{1}); + assertTrue(w.getWriteError() != 0); for (size_t i = 0; i < sizeof(b); i++) { assertEqual(b[i], b2[i]); @@ -22,17 +22,17 @@ test(short_write_single_byte) { test(short_write_2_bytes) { uint8_t b[2]; cbor::BytesPrint bp{b, sizeof(b)}; - cbor::Writer cbor{bp}; - assertTrue(cbor.getWriteError() == 0); + cbor::Writer w{bp}; + assertTrue(w.getWriteError() == 0); uint8_t b2[] = { (2 << 5) + 2, 0x01, 0x02 }; - cbor.beginBytes(2); - cbor.writeByte(b2[1]); - assertEqual(cbor.getWriteSize(), size_t{2}); - assertTrue(cbor.getWriteError() == 0); - cbor.writeByte(b2[2]); - assertEqual(cbor.getWriteSize(), size_t{2}); - assertTrue(cbor.getWriteError() != 0); + w.beginBytes(2); + w.writeByte(b2[1]); + assertEqual(w.getWriteSize(), size_t{2}); + assertTrue(w.getWriteError() == 0); + w.writeByte(b2[2]); + assertEqual(w.getWriteSize(), size_t{2}); + assertTrue(w.getWriteError() != 0); for (size_t i = 0; i < sizeof(b); i++) { assertEqual(b[i], b2[i]); @@ -42,14 +42,14 @@ test(short_write_2_bytes) { test(short_write_multi_bytes) { uint8_t b[2]; cbor::BytesPrint bp{b, sizeof(b)}; - cbor::Writer cbor{bp}; - assertTrue(cbor.getWriteError() == 0); - cbor.beginBytes(2); + cbor::Writer w{bp}; + assertTrue(w.getWriteError() == 0); + w.beginBytes(2); uint8_t b2[] = { (2 << 5) + 2, 0x01, 0x02 }; - cbor.writeBytes(&b2[1], 2); - assertEqual(cbor.getWriteSize(), size_t{2}); - assertTrue(cbor.getWriteError() != 0); + w.writeBytes(&b2[1], 2); + assertEqual(w.getWriteSize(), size_t{2}); + assertTrue(w.getWriteError() != 0); for (size_t i = 0; i < sizeof(b); i++) { assertEqual(b[i], b2[i]); diff --git a/src/tests/array.inc b/src/tests/array.inc index 237ef3c..c2ba9b8 100644 --- a/src/tests/array.inc +++ b/src/tests/array.inc @@ -8,66 +8,66 @@ test(array_empty) { uint8_t b[] = { (4 << 5) + 0 }; cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cbor{bs}; - assertTrue(cbor.isWellFormed()); - assertEqual(cbor.getReadSize(), size_t{1}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{1}); bs.reset(); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kArray)); - assertTrue(cbor.getLength() == 0); - assertEqual(cbor.getReadSize(), size_t{2}); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kArray)); + assertTrue(r.getLength() == 0); + assertEqual(r.getReadSize(), size_t{2}); } test(array_indefinite_empty) { uint8_t b[] = { (4 << 5) + 31, (7 << 5) + 31 }; cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cbor{bs}; - assertTrue(cbor.isWellFormed()); - assertEqual(cbor.getReadSize(), size_t{2}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{2}); bs.reset(); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kArray)); - assertTrue(cbor.isIndefiniteLength()); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kBreak)); - assertEqual(cbor.getReadSize(), size_t{4}); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kArray)); + assertTrue(r.isIndefiniteLength()); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kBreak)); + assertEqual(r.getReadSize(), size_t{4}); } test(array_something) { uint8_t b[] = { (4 << 5) + 4, 0x01, 0x02, (1 << 5) | 0x03, (0 << 5) + 24, 24 }; cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cbor{bs}; - assertTrue(cbor.isWellFormed()); - assertEqual(cbor.getReadSize(), size_t{6}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{6}); bs.reset(); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kArray)); - assertTrue(cbor.getLength() == 4); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kArray)); + assertTrue(r.getLength() == 4); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kUnsignedInt)); - assertTrue(cbor.getUnsignedInt() == 1); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kUnsignedInt)); - assertTrue(cbor.getUnsignedInt() == 2); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kNegativeInt)); - assertTrue(cbor.getInt() == -4); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kUnsignedInt)); - assertTrue(cbor.getUnsignedInt() == 24); - assertEqual(cbor.getReadSize(), size_t{12}); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kUnsignedInt)); + assertTrue(r.getUnsignedInt() == 1); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kUnsignedInt)); + assertTrue(r.getUnsignedInt() == 2); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kNegativeInt)); + assertTrue(r.getInt() == -4); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kUnsignedInt)); + assertTrue(r.getUnsignedInt() == 24); + assertEqual(r.getReadSize(), size_t{12}); } test(array_indefinite) { uint8_t b[] = { (4 << 5) + 31, 0x01, 0x02, (1 << 5) | 0x03, (7 << 5) + 31 }; cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cbor{bs}; - assertTrue(cbor.isWellFormed()); - assertEqual(cbor.getReadSize(), size_t{5}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{5}); bs.reset(); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kArray)); - assertTrue(cbor.isIndefiniteLength()); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kArray)); + assertTrue(r.isIndefiniteLength()); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kUnsignedInt)); - assertTrue(cbor.getUnsignedInt() == 1); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kUnsignedInt)); - assertTrue(cbor.getUnsignedInt() == 2); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kNegativeInt)); - assertTrue(cbor.getInt() == -4); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kUnsignedInt)); + assertTrue(r.getUnsignedInt() == 1); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kUnsignedInt)); + assertTrue(r.getUnsignedInt() == 2); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kNegativeInt)); + assertTrue(r.getInt() == -4); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kBreak)); - assertEqual(cbor.getReadSize(), size_t{10}); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kBreak)); + assertEqual(r.getReadSize(), size_t{10}); } diff --git a/src/tests/bytes.inc b/src/tests/bytes.inc index acdd461..c92c68a 100644 --- a/src/tests/bytes.inc +++ b/src/tests/bytes.inc @@ -8,102 +8,102 @@ test(bytes_empty) { uint8_t b[] = { (2 << 5) + 0 }; cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cbor{bs}; - assertTrue(cbor.isWellFormed()); - assertEqual(cbor.getReadSize(), size_t{1}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{1}); bs.reset(); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kBytes)); - assertTrue(cbor.getLength() == 0); - assertEqual(cbor.getReadSize(), size_t{2}); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kBytes)); + assertTrue(r.getLength() == 0); + assertEqual(r.getReadSize(), size_t{2}); } test(bytes_something) { uint8_t b[] = { (2 << 5) + 4, 0x01, 0x02, 0x03, 0x04, 0 }; cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cbor{bs}; - assertTrue(cbor.isWellFormed()); - assertEqual(cbor.getReadSize(), size_t{5}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{5}); bs.reset(); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kBytes)); - assertTrue(cbor.getLength() == 4); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kBytes)); + assertTrue(r.getLength() == 4); uint8_t b2[5]{0}; - assertEqual(cbor.readBytes(b2, 4), size_t{4}); + assertEqual(r.readBytes(b2, 4), size_t{4}); assertEqual(reinterpret_cast(&b2[0]), reinterpret_cast(&b[1])); - assertEqual(cbor.getReadSize(), size_t{10}); + assertEqual(r.getReadSize(), size_t{10}); } test(bytes_indefinite) { uint8_t b[] = { (2 << 5) + 31, (2 << 5) + 2, 0x01, 0x02, (2 << 5) + 3, 0x03, 0x04, 0x05, (7 << 5) + 31 }; cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cbor{bs}; - assertTrue(cbor.isWellFormed()); - assertEqual(cbor.getReadSize(), size_t{9}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{9}); bs.reset(); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kBytes)); - assertTrue(cbor.isIndefiniteLength()); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kBytes)); + assertTrue(r.isIndefiniteLength()); uint8_t b2[6]{0}; - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kBytes)); - assertTrue(cbor.getLength() == 2); - assertEqual(cbor.readBytes(&b2[0], 2), size_t{2}); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kBytes)); - assertTrue(cbor.getLength() == 3); - assertEqual(cbor.readBytes(&b2[2], 3), size_t{3}); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kBreak)); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kBytes)); + assertTrue(r.getLength() == 2); + assertEqual(r.readBytes(&b2[0], 2), size_t{2}); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kBytes)); + assertTrue(r.getLength() == 3); + assertEqual(r.readBytes(&b2[2], 3), size_t{3}); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kBreak)); uint8_t b3[] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0 }; assertEqual(reinterpret_cast(b2), reinterpret_cast(b3)); - assertEqual(cbor.getReadSize(), size_t{18}); + assertEqual(r.getReadSize(), size_t{18}); } test(text_empty) { uint8_t b[] = { (3 << 5) + 0 }; cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cbor{bs}; - assertTrue(cbor.isWellFormed()); - assertEqual(cbor.getReadSize(), size_t{1}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{1}); bs.reset(); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kText)); - assertTrue(cbor.getLength() == 0); - assertEqual(cbor.getReadSize(), size_t{2}); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kText)); + assertTrue(r.getLength() == 0); + assertEqual(r.getReadSize(), size_t{2}); } test(text_something) { uint8_t b[] = { (3 << 5) + 4, 0x49, 0x45, 0x54, 0x46, 0 }; cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cbor{bs}; - assertTrue(cbor.isWellFormed()); - assertEqual(cbor.getReadSize(), size_t{5}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{5}); bs.reset(); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kText)); - assertTrue(cbor.getLength() == 4); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kText)); + assertTrue(r.getLength() == 4); uint8_t b2[5]{0}; - assertEqual(cbor.readBytes(b2, 4), size_t{4}); + assertEqual(r.readBytes(b2, 4), size_t{4}); assertEqual(reinterpret_cast(&b2[0]), reinterpret_cast(&b[1])); - assertEqual(cbor.getReadSize(), size_t{10}); + assertEqual(r.getReadSize(), size_t{10}); } test(text_indefinite) { uint8_t b[] = { (3 << 5) + 31, (3 << 5) + 5, 0x73, 0x74, 0x72, 0x65, 0x61, (3 << 5) + 4, 0x6d, 0x69, 0x6e, 0x67, (7 << 5) + 31 }; cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cbor{bs}; - assertTrue(cbor.isWellFormed()); - assertEqual(cbor.getReadSize(), size_t{13}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{13}); bs.reset(); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kText)); - assertTrue(cbor.isIndefiniteLength()); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kText)); + assertTrue(r.isIndefiniteLength()); uint8_t b2[10]{0}; - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kText)); - assertTrue(cbor.getLength() == 5); - assertEqual(cbor.readBytes(&b2[0], 5), size_t{5}); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kText)); - assertTrue(cbor.getLength() == 4); - assertEqual(cbor.readBytes(&b2[5], 4), size_t{4}); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kText)); + assertTrue(r.getLength() == 5); + assertEqual(r.readBytes(&b2[0], 5), size_t{5}); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kText)); + assertTrue(r.getLength() == 4); + assertEqual(r.readBytes(&b2[5], 4), size_t{4}); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kBreak)); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kBreak)); uint8_t b3[] = { 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x69, 0x6e, 0x67, 0 }; assertEqual(reinterpret_cast(b2), reinterpret_cast(b3)); - assertEqual(cbor.getReadSize(), size_t{26}); + assertEqual(r.getReadSize(), size_t{26}); } diff --git a/src/tests/floating_point.inc b/src/tests/floating_point.inc index cb21643..a06f57a 100644 --- a/src/tests/floating_point.inc +++ b/src/tests/floating_point.inc @@ -8,265 +8,265 @@ test(half_zero) { uint8_t b[] = { (7 << 5) + 25, 0x00, 0x00 }; cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cbor{bs}; - assertTrue(cbor.isWellFormed()); - assertEqual(cbor.getReadSize(), size_t{3}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{3}); bs.reset(); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kFloat)); - assertEqual(cbor.getFloat(), 0.0f); - assertFalse(std::signbit(cbor.getFloat())); - assertEqual(cbor.getReadSize(), size_t{6}); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kFloat)); + assertEqual(r.getFloat(), 0.0f); + assertFalse(std::signbit(r.getFloat())); + assertEqual(r.getReadSize(), size_t{6}); } test(half_negative_zero) { uint8_t b[] = { (7 << 5) + 25, 0x80, 0x00 }; cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cbor{bs}; - assertTrue(cbor.isWellFormed()); - assertEqual(cbor.getReadSize(), size_t{3}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{3}); bs.reset(); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kFloat)); - assertEqual(cbor.getFloat(), 0.0f); - assertTrue(std::signbit(cbor.getFloat())); - assertEqual(cbor.getReadSize(), size_t{6}); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kFloat)); + assertEqual(r.getFloat(), 0.0f); + assertTrue(std::signbit(r.getFloat())); + assertEqual(r.getReadSize(), size_t{6}); } test(half_one) { uint8_t b[] = { (7 << 5) + 25, 0x3c, 0x00 }; cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cbor{bs}; - assertTrue(cbor.isWellFormed()); - assertEqual(cbor.getReadSize(), size_t{3}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{3}); bs.reset(); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kFloat)); - assertEqual(cbor.getFloat(), 1.0f); - assertEqual(cbor.getReadSize(), size_t{6}); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kFloat)); + assertEqual(r.getFloat(), 1.0f); + assertEqual(r.getReadSize(), size_t{6}); } test(half_1p5) { uint8_t b[] = { (7 << 5) + 25, 0x3e, 0x00 }; cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cbor{bs}; - assertTrue(cbor.isWellFormed()); - assertEqual(cbor.getReadSize(), size_t{3}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{3}); bs.reset(); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kFloat)); - assertEqual(cbor.getFloat(), 1.5f); - assertEqual(cbor.getReadSize(), size_t{6}); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kFloat)); + assertEqual(r.getFloat(), 1.5f); + assertEqual(r.getReadSize(), size_t{6}); } test(half_65504) { uint8_t b[] = { (7 << 5) + 25, 0x7b, 0xff }; cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cbor{bs}; - assertTrue(cbor.isWellFormed()); - assertEqual(cbor.getReadSize(), size_t{3}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{3}); bs.reset(); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kFloat)); - assertEqual(cbor.getFloat(), 65504.0f); - assertEqual(cbor.getReadSize(), size_t{6}); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kFloat)); + assertEqual(r.getFloat(), 65504.0f); + assertEqual(r.getReadSize(), size_t{6}); } test(half_small) { uint8_t b[] = { (7 << 5) + 25, 0x00, 0x01 }; cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cbor{bs}; - assertTrue(cbor.isWellFormed()); - assertEqual(cbor.getReadSize(), size_t{3}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{3}); bs.reset(); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kFloat)); - assertEqual(cbor.getFloat(), 5.960464477539063e-8f); - assertEqual(cbor.getReadSize(), size_t{6}); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kFloat)); + assertEqual(r.getFloat(), 5.960464477539063e-8f); + assertEqual(r.getReadSize(), size_t{6}); } test(half_medium_small) { uint8_t b[] = { (7 << 5) + 25, 0x04, 0x00 }; cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cbor{bs}; - assertTrue(cbor.isWellFormed()); - assertEqual(cbor.getReadSize(), size_t{3}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{3}); bs.reset(); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kFloat)); - assertEqual(cbor.getFloat(), 0.00006103515625f); - assertEqual(cbor.getReadSize(), size_t{6}); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kFloat)); + assertEqual(r.getFloat(), 0.00006103515625f); + assertEqual(r.getReadSize(), size_t{6}); } test(half_negative_4) { uint8_t b[] = { (7 << 5) + 25, 0xc4, 0x00 }; cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cbor{bs}; - assertTrue(cbor.isWellFormed()); - assertEqual(cbor.getReadSize(), size_t{3}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{3}); bs.reset(); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kFloat)); - assertEqual(cbor.getFloat(), -4.0f); - assertEqual(cbor.getReadSize(), size_t{6}); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kFloat)); + assertEqual(r.getFloat(), -4.0f); + assertEqual(r.getReadSize(), size_t{6}); } test(half_infinity) { uint8_t b[] = { (7 << 5) + 25, 0x7c, 0x00 }; cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cbor{bs}; - assertTrue(cbor.isWellFormed()); - assertEqual(cbor.getReadSize(), size_t{3}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{3}); bs.reset(); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kFloat)); - assertEqual(cbor.getFloat(), INFINITY); - assertEqual(cbor.getReadSize(), size_t{6}); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kFloat)); + assertEqual(r.getFloat(), INFINITY); + assertEqual(r.getReadSize(), size_t{6}); } test(half_negative_infinity) { uint8_t b[] = { (7 << 5) + 25, 0xfc, 0x00 }; cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cbor{bs}; - assertTrue(cbor.isWellFormed()); - assertEqual(cbor.getReadSize(), size_t{3}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{3}); bs.reset(); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kFloat)); - assertEqual(cbor.getFloat(), -INFINITY); - assertEqual(cbor.getReadSize(), size_t{6}); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kFloat)); + assertEqual(r.getFloat(), -INFINITY); + assertEqual(r.getReadSize(), size_t{6}); } test(half_nan) { uint8_t b[] = { (7 << 5) + 25, 0x7e, 0x00 }; cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cbor{bs}; - assertTrue(cbor.isWellFormed()); - assertEqual(cbor.getReadSize(), size_t{3}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{3}); bs.reset(); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kFloat)); - assertTrue(std::isnan(cbor.getFloat())); - assertEqual(cbor.getReadSize(), size_t{6}); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kFloat)); + assertTrue(std::isnan(r.getFloat())); + assertEqual(r.getReadSize(), size_t{6}); } test(float_100000) { uint8_t b[] = { (7 << 5) + 26, 0x47, 0xc3, 0x50, 0x00 }; cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cbor{bs}; - assertTrue(cbor.isWellFormed()); - assertEqual(cbor.getReadSize(), size_t{5}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{5}); bs.reset(); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kFloat)); - assertEqual(cbor.getFloat(), 100000.0f); - assertEqual(cbor.getReadSize(), size_t{10}); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kFloat)); + assertEqual(r.getFloat(), 100000.0f); + assertEqual(r.getReadSize(), size_t{10}); } test(float_large) { uint8_t b[] = { (7 << 5) + 26, 0x7f, 0x7f, 0xff, 0xff }; cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cbor{bs}; - assertTrue(cbor.isWellFormed()); - assertEqual(cbor.getReadSize(), size_t{5}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{5}); bs.reset(); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kFloat)); - assertEqual(cbor.getFloat(), 3.4028234663852886e+38f); - assertEqual(cbor.getReadSize(), size_t{10}); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kFloat)); + assertEqual(r.getFloat(), 3.4028234663852886e+38f); + assertEqual(r.getReadSize(), size_t{10}); } test(float_infinity) { uint8_t b[] = { (7 << 5) + 26, 0x7f, 0x80, 0x00, 0x00 }; cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cbor{bs}; - assertTrue(cbor.isWellFormed()); - assertEqual(cbor.getReadSize(), size_t{5}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{5}); bs.reset(); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kFloat)); - assertEqual(cbor.getFloat(), INFINITY); - assertEqual(cbor.getReadSize(), size_t{10}); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kFloat)); + assertEqual(r.getFloat(), INFINITY); + assertEqual(r.getReadSize(), size_t{10}); } test(float_negative_infinity) { uint8_t b[] = { (7 << 5) + 26, 0xff, 0x80, 0x00, 0x00 }; cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cbor{bs}; - assertTrue(cbor.isWellFormed()); - assertEqual(cbor.getReadSize(), size_t{5}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{5}); bs.reset(); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kFloat)); - assertEqual(cbor.getFloat(), -INFINITY); - assertEqual(cbor.getReadSize(), size_t{10}); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kFloat)); + assertEqual(r.getFloat(), -INFINITY); + assertEqual(r.getReadSize(), size_t{10}); } test(float_nan) { uint8_t b[] = { (7 << 5) + 26, 0x7f, 0xc0, 0x00, 0x00 }; cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cbor{bs}; - assertTrue(cbor.isWellFormed()); - assertEqual(cbor.getReadSize(), size_t{5}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{5}); bs.reset(); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kFloat)); - assertTrue(std::isnan(cbor.getFloat())); - assertEqual(cbor.getReadSize(), size_t{10}); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kFloat)); + assertTrue(std::isnan(r.getFloat())); + assertEqual(r.getReadSize(), size_t{10}); } test(double_1p1) { uint8_t b[] = { (7 << 5) + 27, 0x3f, 0xf1, 0x99, 0x99, 0x99, 0x99, 0x99, 0x9a }; cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cbor{bs}; - assertTrue(cbor.isWellFormed()); - assertEqual(cbor.getReadSize(), size_t{9}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{9}); bs.reset(); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kDouble)); - assertEqual(cbor.getDouble(), 1.1); - assertEqual(cbor.getReadSize(), size_t{18}); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kDouble)); + assertEqual(r.getDouble(), 1.1); + assertEqual(r.getReadSize(), size_t{18}); } test(double_negative_4p1) { uint8_t b[] = { (7 << 5) + 27, 0xc0, 0x10, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66 }; cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cbor{bs}; - assertTrue(cbor.isWellFormed()); - assertEqual(cbor.getReadSize(), size_t{9}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{9}); bs.reset(); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kDouble)); - assertEqual(cbor.getDouble(), -4.1); - assertEqual(cbor.getReadSize(), size_t{18}); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kDouble)); + assertEqual(r.getDouble(), -4.1); + assertEqual(r.getReadSize(), size_t{18}); } test(double_large) { uint8_t b[] = { (7 << 5) + 27, 0x7e, 0x37, 0xe4, 0x3c, 0x88, 0x00, 0x75, 0x9c }; cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cbor{bs}; - assertTrue(cbor.isWellFormed()); - assertEqual(cbor.getReadSize(), size_t{9}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{9}); bs.reset(); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kDouble)); - assertEqual(cbor.getDouble(), 1.0e+300); - assertEqual(cbor.getReadSize(), size_t{18}); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kDouble)); + assertEqual(r.getDouble(), 1.0e+300); + assertEqual(r.getReadSize(), size_t{18}); } test(double_infinity) { uint8_t b[] = { (7 << 5) + 27, 0x7f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cbor{bs}; - assertTrue(cbor.isWellFormed()); - assertEqual(cbor.getReadSize(), size_t{9}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{9}); bs.reset(); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kDouble)); - assertEqual(cbor.getDouble(), INFINITY); - assertEqual(cbor.getReadSize(), size_t{18}); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kDouble)); + assertEqual(r.getDouble(), INFINITY); + assertEqual(r.getReadSize(), size_t{18}); } test(double_negative_infinity) { uint8_t b[] = { (7 << 5) + 27, 0xff, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cbor{bs}; - assertTrue(cbor.isWellFormed()); - assertEqual(cbor.getReadSize(), size_t{9}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{9}); bs.reset(); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kDouble)); - assertEqual(cbor.getDouble(), -INFINITY); - assertEqual(cbor.getReadSize(), size_t{18}); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kDouble)); + assertEqual(r.getDouble(), -INFINITY); + assertEqual(r.getReadSize(), size_t{18}); } test(double_nan) { uint8_t b[] = { (7 << 5) + 27, 0x7f, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cbor{bs}; - assertTrue(cbor.isWellFormed()); - assertEqual(cbor.getReadSize(), size_t{9}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{9}); bs.reset(); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kDouble)); - assertTrue(std::isnan(cbor.getDouble())); - assertEqual(cbor.getReadSize(), size_t{18}); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kDouble)); + assertTrue(std::isnan(r.getDouble())); + assertEqual(r.getReadSize(), size_t{18}); } diff --git a/src/tests/map.inc b/src/tests/map.inc index 81a8a1f..37165fc 100644 --- a/src/tests/map.inc +++ b/src/tests/map.inc @@ -8,68 +8,68 @@ test(map_empty) { uint8_t b[] = { (5 << 5) + 0 }; cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cbor{bs}; - assertTrue(cbor.isWellFormed()); - assertEqual(cbor.getReadSize(), size_t{1}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{1}); bs.reset(); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kMap)); - assertTrue(cbor.getLength() == 0); - assertEqual(cbor.getReadSize(), size_t{2}); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kMap)); + assertTrue(r.getLength() == 0); + assertEqual(r.getReadSize(), size_t{2}); } test(map_indefinite_empty) { uint8_t b[] = { (5 << 5) + 31, (7 << 5) + 31 }; cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cbor{bs}; - assertTrue(cbor.isWellFormed()); - assertEqual(cbor.getReadSize(), size_t{2}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{2}); bs.reset(); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kMap)); - assertTrue(cbor.isIndefiniteLength()); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kBreak)); - assertEqual(cbor.getReadSize(), size_t{4}); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kMap)); + assertTrue(r.isIndefiniteLength()); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kBreak)); + assertEqual(r.getReadSize(), size_t{4}); } test(map_something) { uint8_t b[] = { (5 << 5) + 2, 0x01, 0x02, (1 << 5) | 0x03, (0 << 5) + 24, 24 }; cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cbor{bs}; - assertTrue(cbor.isWellFormed()); - assertEqual(cbor.getReadSize(), size_t{6}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{6}); bs.reset(); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kMap)); - assertTrue(cbor.getLength() == 2); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kMap)); + assertTrue(r.getLength() == 2); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kUnsignedInt)); - assertTrue(cbor.getUnsignedInt() == 1); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kUnsignedInt)); - assertTrue(cbor.getUnsignedInt() == 2); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kNegativeInt)); - assertTrue(cbor.getInt() == -4); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kUnsignedInt)); - assertTrue(cbor.getUnsignedInt() == 24); - assertEqual(cbor.getReadSize(), size_t{12}); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kUnsignedInt)); + assertTrue(r.getUnsignedInt() == 1); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kUnsignedInt)); + assertTrue(r.getUnsignedInt() == 2); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kNegativeInt)); + assertTrue(r.getInt() == -4); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kUnsignedInt)); + assertTrue(r.getUnsignedInt() == 24); + assertEqual(r.getReadSize(), size_t{12}); } test(map_indefinite) { uint8_t b[] = { (5 << 5) + 31, 0x01, 0x02, (1 << 5) | 0x03, (0 << 5) + 24, 24, (7 << 5) + 31 }; cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cbor{bs}; - assertTrue(cbor.isWellFormed()); - assertEqual(cbor.getReadSize(), size_t{7}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{7}); bs.reset(); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kMap)); - assertTrue(cbor.isIndefiniteLength()); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kMap)); + assertTrue(r.isIndefiniteLength()); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kUnsignedInt)); - assertTrue(cbor.getUnsignedInt() == 1); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kUnsignedInt)); - assertTrue(cbor.getUnsignedInt() == 2); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kNegativeInt)); - assertTrue(cbor.getInt() == -4); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kUnsignedInt)); - assertTrue(cbor.getUnsignedInt() == 24); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kUnsignedInt)); + assertTrue(r.getUnsignedInt() == 1); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kUnsignedInt)); + assertTrue(r.getUnsignedInt() == 2); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kNegativeInt)); + assertTrue(r.getInt() == -4); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kUnsignedInt)); + assertTrue(r.getUnsignedInt() == 24); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kBreak)); - assertEqual(cbor.getReadSize(), size_t{14}); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kBreak)); + assertEqual(r.getReadSize(), size_t{14}); } diff --git a/src/tests/negative.inc b/src/tests/negative.inc index 6216d2c..da8bbef 100644 --- a/src/tests/negative.inc +++ b/src/tests/negative.inc @@ -8,83 +8,83 @@ test(negative_zero) { uint8_t b[] = { (1 << 5) + 0 }; cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cbor{bs}; - assertTrue(cbor.isWellFormed()); - assertEqual(cbor.getReadSize(), size_t{1}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{1}); bs.reset(); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kNegativeInt)); - assertTrue(cbor.getInt() == -1); - assertEqual(cbor.getReadSize(), size_t{2}); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kNegativeInt)); + assertTrue(r.getInt() == -1); + assertEqual(r.getReadSize(), size_t{2}); } test(negative_19) { uint8_t b[] = { (1 << 5) + 19 }; cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cbor{bs}; - assertTrue(cbor.isWellFormed()); - assertEqual(cbor.getReadSize(), size_t{1}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{1}); bs.reset(); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kNegativeInt)); - assertTrue(cbor.getInt() == -20); - assertEqual(cbor.getReadSize(), size_t{2}); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kNegativeInt)); + assertTrue(r.getInt() == -20); + assertEqual(r.getReadSize(), size_t{2}); } test(negative_23) { uint8_t b[] = { (1 << 5) + 23 }; cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cbor{bs}; - assertTrue(cbor.isWellFormed()); - assertEqual(cbor.getReadSize(), size_t{1}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{1}); bs.reset(); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kNegativeInt)); - assertTrue(cbor.getInt() == -24); - assertEqual(cbor.getReadSize(), size_t{2}); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kNegativeInt)); + assertTrue(r.getInt() == -24); + assertEqual(r.getReadSize(), size_t{2}); } test(negative_1_byte) { uint8_t b[] = { (1 << 5) + 24, 0x12 }; cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cbor{bs}; - assertTrue(cbor.isWellFormed()); - assertEqual(cbor.getReadSize(), size_t{2}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{2}); bs.reset(); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kNegativeInt)); - assertTrue(cbor.getInt() == -0x13); - assertEqual(cbor.getReadSize(), size_t{4}); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kNegativeInt)); + assertTrue(r.getInt() == -0x13); + assertEqual(r.getReadSize(), size_t{4}); } test(negative_2_bytes) { uint8_t b[] = { (1 << 5) + 25, 0x12, 0x34 }; cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cbor{bs}; - assertTrue(cbor.isWellFormed()); - assertEqual(cbor.getReadSize(), size_t{3}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{3}); bs.reset(); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kNegativeInt)); - assertTrue(cbor.getInt() == -0x1235); - assertEqual(cbor.getReadSize(), size_t{6}); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kNegativeInt)); + assertTrue(r.getInt() == -0x1235); + assertEqual(r.getReadSize(), size_t{6}); } test(negative_4_bytes) { uint8_t b[] = { (1 << 5) + 26, 0x12, 0x34, 0x56, 0x78 }; cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cbor{bs}; - assertTrue(cbor.isWellFormed()); - assertEqual(cbor.getReadSize(), size_t{5}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{5}); bs.reset(); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kNegativeInt)); - assertTrue(cbor.getInt() == -0x12345679L); - assertEqual(cbor.getReadSize(), size_t{10}); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kNegativeInt)); + assertTrue(r.getInt() == -0x12345679L); + assertEqual(r.getReadSize(), size_t{10}); } test(negative_8_bytes) { uint8_t b[] = { (1 << 5) + 27, 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0 }; cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cbor{bs}; - assertTrue(cbor.isWellFormed()); - assertEqual(cbor.getReadSize(), size_t{9}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{9}); bs.reset(); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kNegativeInt)); - assertTrue(cbor.getInt() == -0x123456789abcdef1LL); - assertEqual(cbor.getReadSize(), size_t{18}); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kNegativeInt)); + assertTrue(r.getInt() == -0x123456789abcdef1LL); + assertEqual(r.getReadSize(), size_t{18}); } diff --git a/src/tests/simple_value.inc b/src/tests/simple_value.inc index 786904a..31b0d6c 100644 --- a/src/tests/simple_value.inc +++ b/src/tests/simple_value.inc @@ -8,104 +8,104 @@ test(boolean_false) { uint8_t b[] = { (7 << 5) + 20 }; cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cbor{bs}; - assertTrue(cbor.isWellFormed()); - assertEqual(cbor.getReadSize(), size_t{1}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{1}); bs.reset(); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kBoolean)); - assertEqual(cbor.getBoolean(), false); - assertEqual(cbor.getReadSize(), size_t{2}); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kBoolean)); + assertEqual(r.getBoolean(), false); + assertEqual(r.getReadSize(), size_t{2}); } test(boolean_true) { uint8_t b[] = { (7 << 5) + 21 }; cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cbor{bs}; - assertTrue(cbor.isWellFormed()); - assertEqual(cbor.getReadSize(), size_t{1}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{1}); bs.reset(); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kBoolean)); - assertEqual(cbor.getBoolean(), true); - assertEqual(cbor.getReadSize(), size_t{2}); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kBoolean)); + assertEqual(r.getBoolean(), true); + assertEqual(r.getReadSize(), size_t{2}); } test(null) { uint8_t b[] = { (7 << 5) + 22 }; cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cbor{bs}; - assertTrue(cbor.isWellFormed()); - assertEqual(cbor.getReadSize(), size_t{1}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{1}); bs.reset(); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kNull)); - assertEqual(cbor.getReadSize(), size_t{2}); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kNull)); + assertEqual(r.getReadSize(), size_t{2}); } test(undefined) { uint8_t b[] = { (7 << 5) + 23 }; cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cbor{bs}; - assertTrue(cbor.isWellFormed()); - assertEqual(cbor.getReadSize(), size_t{1}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{1}); bs.reset(); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kUndefined)); - assertEqual(cbor.getReadSize(), size_t{2}); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kUndefined)); + assertEqual(r.getReadSize(), size_t{2}); } test(simple_value_break) { uint8_t b[] = { (7 << 5) + 31 }; cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cbor{bs}; - assertFalse(cbor.isWellFormed()); // TODO: Can't have just a break? - assertEqual(cbor.getReadSize(), size_t{1}); + cbor::Reader r{bs}; + assertFalse(r.isWellFormed()); // TODO: Can't have just a break? + assertEqual(r.getReadSize(), size_t{1}); bs.reset(); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kBreak)); - assertEqual(cbor.getReadSize(), size_t{2}); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kBreak)); + assertEqual(r.getReadSize(), size_t{2}); } test(simple_value_zero) { uint8_t b[] = { (7 << 5) + 0 }; cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cbor{bs}; - assertTrue(cbor.isWellFormed()); - assertEqual(cbor.getReadSize(), size_t{1}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{1}); bs.reset(); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kSimpleValue)); - assertEqual(cbor.getSimpleValue(), 0); - assertEqual(cbor.getReadSize(), size_t{2}); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kSimpleValue)); + assertEqual(r.getSimpleValue(), 0); + assertEqual(r.getReadSize(), size_t{2}); } test(simple_value_19) { uint8_t b[] = { (7 << 5) + 19 }; cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cbor{bs}; - assertTrue(cbor.isWellFormed()); - assertEqual(cbor.getReadSize(), size_t{1}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{1}); bs.reset(); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kSimpleValue)); - assertEqual(cbor.getSimpleValue(), 19); - assertEqual(cbor.getReadSize(), size_t{2}); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kSimpleValue)); + assertEqual(r.getSimpleValue(), 19); + assertEqual(r.getReadSize(), size_t{2}); } test(simple_value_32_1_byte) { uint8_t b[] = { (7 << 5) + 24, 32 }; cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cbor{bs}; - assertTrue(cbor.isWellFormed()); - assertEqual(cbor.getReadSize(), size_t{2}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{2}); bs.reset(); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kSimpleValue)); - assertEqual(cbor.getSimpleValue(), 32); - assertEqual(cbor.getReadSize(), size_t{4}); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kSimpleValue)); + assertEqual(r.getSimpleValue(), 32); + assertEqual(r.getReadSize(), size_t{4}); } test(simple_value_255_1_byte) { uint8_t b[] = { (7 << 5) + 24, 255 }; cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cbor{bs}; - assertTrue(cbor.isWellFormed()); - assertEqual(cbor.getReadSize(), size_t{2}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{2}); bs.reset(); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kSimpleValue)); - assertEqual(cbor.getSimpleValue(), 255); - assertEqual(cbor.getReadSize(), size_t{4}); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kSimpleValue)); + assertEqual(r.getSimpleValue(), 255); + assertEqual(r.getReadSize(), size_t{4}); } diff --git a/src/tests/stream.inc b/src/tests/stream.inc index 212a00e..334b805 100644 --- a/src/tests/stream.inc +++ b/src/tests/stream.inc @@ -8,68 +8,68 @@ test(empty_stream) { uint8_t b[] = { }; cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cbor{bs}; - assertFalse(cbor.isWellFormed()); - assertEqual(cbor.getReadSize(), size_t{0}); + cbor::Reader r{bs}; + assertFalse(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{0}); bs.reset(); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kEOS)); - assertEqual(cbor.getReadSize(), size_t{0}); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kEOS)); + assertEqual(r.getReadSize(), size_t{0}); } test(partial_1_byte) { uint8_t b[] = { (0 << 5) + 24 }; cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cbor{bs}; - assertFalse(cbor.isWellFormed()); - assertEqual(cbor.getReadSize(), size_t{1}); + cbor::Reader r{bs}; + assertFalse(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{1}); bs.reset(); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kEOS)); - assertEqual(cbor.getReadSize(), size_t{2}); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kEOS)); + assertEqual(r.getReadSize(), size_t{2}); } test(partial_2_bytes) { uint8_t b[] = { (0 << 5) + 25, 0x12 }; cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cbor{bs}; - assertFalse(cbor.isWellFormed()); - assertEqual(cbor.getReadSize(), size_t{1}); + cbor::Reader r{bs}; + assertFalse(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{1}); bs.reset(); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kEOS)); - assertEqual(cbor.getReadSize(), size_t{2}); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kEOS)); + assertEqual(r.getReadSize(), size_t{2}); } test(partial_4_bytes) { uint8_t b[] = { (0 << 5) + 26, 0x12, 0x34, 0x56 }; cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cbor{bs}; - assertFalse(cbor.isWellFormed()); - assertEqual(cbor.getReadSize(), size_t{1}); + cbor::Reader r{bs}; + assertFalse(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{1}); bs.reset(); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kEOS)); - assertEqual(cbor.getReadSize(), size_t{2}); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kEOS)); + assertEqual(r.getReadSize(), size_t{2}); } test(partial_8_bytes) { uint8_t b[] = { (0 << 5) + 27, 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde }; cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cbor{bs}; - assertFalse(cbor.isWellFormed()); - assertEqual(cbor.getReadSize(), size_t{1}); + cbor::Reader r{bs}; + assertFalse(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{1}); bs.reset(); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kEOS)); - assertEqual(cbor.getReadSize(), size_t{2}); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kEOS)); + assertEqual(r.getReadSize(), size_t{2}); } test(unsigned_1_byte_with_wait) { uint8_t b[] = { (0 << 5) + 24, 0x21 }; cbor::BytesStream bs{b, sizeof(b), 1}; - cbor::Reader cbor{bs}; - assertFalse(cbor.isWellFormed()); - assertEqual(cbor.getReadSize(), size_t{0}); + cbor::Reader r{bs}; + assertFalse(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{0}); bs.reset(); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kEOS)); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kEOS)); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kUnsignedInt)); - assertTrue(cbor.getUnsignedInt() == 0x21); - assertEqual(cbor.getReadSize(), size_t{2}); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kEOS)); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kEOS)); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kUnsignedInt)); + assertTrue(r.getUnsignedInt() == 0x21); + assertEqual(r.getReadSize(), size_t{2}); } diff --git a/src/tests/syntax.inc b/src/tests/syntax.inc index b9173a1..dbdced9 100644 --- a/src/tests/syntax.inc +++ b/src/tests/syntax.inc @@ -11,13 +11,13 @@ test(disallow_bad_ai) { for (int j = 28; j <= 30; j++) { b[0] = (i << 5) + j; cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cbor{bs}; - assertFalse(cbor.isWellFormed()); - assertEqual(cbor.getReadSize(), size_t{1}); + cbor::Reader r{bs}; + assertFalse(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{1}); bs.reset(); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kSyntaxError)); - assertEqual(static_cast(cbor.getSyntaxError()), static_cast(cbor::SyntaxError::kUnknownAdditionalInfo)); - assertEqual(cbor.getReadSize(), size_t{2}); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kSyntaxError)); + assertEqual(static_cast(r.getSyntaxError()), static_cast(cbor::SyntaxError::kUnknownAdditionalInfo)); + assertEqual(r.getReadSize(), size_t{2}); } } } @@ -25,37 +25,37 @@ test(disallow_bad_ai) { test(disallow_indefinite_unsigned) { uint8_t b[] = { (0 << 5) + 31 }; cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cbor{bs}; - assertFalse(cbor.isWellFormed()); - assertEqual(cbor.getReadSize(), size_t{1}); + cbor::Reader r{bs}; + assertFalse(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{1}); bs.reset(); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kSyntaxError)); - assertEqual(static_cast(cbor.getSyntaxError()), static_cast(cbor::SyntaxError::kNotAnIndefiniteType)); - assertEqual(cbor.getReadSize(), size_t{2}); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kSyntaxError)); + assertEqual(static_cast(r.getSyntaxError()), static_cast(cbor::SyntaxError::kNotAnIndefiniteType)); + assertEqual(r.getReadSize(), size_t{2}); } test(disallow_indefinite_negative) { uint8_t b[] = { (1 << 5) + 31 }; cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cbor{bs}; - assertFalse(cbor.isWellFormed()); - assertEqual(cbor.getReadSize(), size_t{1}); + cbor::Reader r{bs}; + assertFalse(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{1}); bs.reset(); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kSyntaxError)); - assertEqual(static_cast(cbor.getSyntaxError()), static_cast(cbor::SyntaxError::kNotAnIndefiniteType)); - assertEqual(cbor.getReadSize(), size_t{2}); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kSyntaxError)); + assertEqual(static_cast(r.getSyntaxError()), static_cast(cbor::SyntaxError::kNotAnIndefiniteType)); + assertEqual(r.getReadSize(), size_t{2}); } test(disallow_indefinite_tag) { uint8_t b[] = { (6 << 5) + 31 }; cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cbor{bs}; - assertFalse(cbor.isWellFormed()); - assertEqual(cbor.getReadSize(), size_t{1}); + cbor::Reader r{bs}; + assertFalse(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{1}); bs.reset(); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kSyntaxError)); - assertEqual(static_cast(cbor.getSyntaxError()), static_cast(cbor::SyntaxError::kNotAnIndefiniteType)); - assertEqual(cbor.getReadSize(), size_t{2}); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kSyntaxError)); + assertEqual(static_cast(r.getSyntaxError()), static_cast(cbor::SyntaxError::kNotAnIndefiniteType)); + assertEqual(r.getReadSize(), size_t{2}); } // Technically, this test should disallow simple values < 32. They are @@ -65,14 +65,14 @@ test(disallow_but_allow_some_simple_values) { for (int i = 0; i < 32; i++) { b[1] = i; cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cbor{bs}; - assertTrue(cbor.isWellFormed()); - assertEqual(cbor.getReadSize(), size_t{2}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{2}); bs.reset(); - // assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kSyntaxError)); - // assertEqual(static_cast(cbor.getSyntaxError()), static_cast(cbor::SyntaxError::kBadSimpleValue)); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kSimpleValue)); - assertEqual(cbor.getSimpleValue(), i); - assertEqual(cbor.getReadSize(), size_t{4}); + // assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kSyntaxError)); + // assertEqual(static_cast(r.getSyntaxError()), static_cast(cbor::SyntaxError::kBadSimpleValue)); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kSimpleValue)); + assertEqual(r.getSimpleValue(), i); + assertEqual(r.getReadSize(), size_t{4}); } } diff --git a/src/tests/tag.inc b/src/tests/tag.inc index 463053f..af95e2f 100644 --- a/src/tests/tag.inc +++ b/src/tests/tag.inc @@ -8,23 +8,23 @@ test(tag_2) { uint8_t b[] = { (6 << 5) + 2 }; cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cbor{bs}; - assertFalse(cbor.isWellFormed()); // Missing something after the tag - assertEqual(cbor.getReadSize(), size_t{1}); + cbor::Reader r{bs}; + assertFalse(r.isWellFormed()); // Missing something after the tag + assertEqual(r.getReadSize(), size_t{1}); bs.reset(); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kTag)); - assertTrue(cbor.getTag() == 2); - assertEqual(cbor.getReadSize(), size_t{2}); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kTag)); + assertTrue(r.getTag() == 2); + assertEqual(r.getReadSize(), size_t{2}); } test(tag_55799) { uint8_t b[] = { (6 << 5) + 25, 0xd9, 0xf7 }; cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cbor{bs}; - assertFalse(cbor.isWellFormed()); // Missing something after the tag - assertEqual(cbor.getReadSize(), size_t{3}); + cbor::Reader r{bs}; + assertFalse(r.isWellFormed()); // Missing something after the tag + assertEqual(r.getReadSize(), size_t{3}); bs.reset(); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kTag)); - assertTrue(cbor.getTag() == cbor::kSelfDescribeTag); - assertEqual(cbor.getReadSize(), size_t{6}); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kTag)); + assertTrue(r.getTag() == cbor::kSelfDescribeTag); + assertEqual(r.getReadSize(), size_t{6}); } diff --git a/src/tests/unsigned.inc b/src/tests/unsigned.inc index c546fa2..5296be8 100644 --- a/src/tests/unsigned.inc +++ b/src/tests/unsigned.inc @@ -8,83 +8,83 @@ test(unsigned_zero) { uint8_t b[] = { (0 << 5) + 0 }; cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cbor{bs}; - assertTrue(cbor.isWellFormed()); - assertEqual(cbor.getReadSize(), size_t{1}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{1}); bs.reset(); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kUnsignedInt)); - assertTrue(cbor.getUnsignedInt() == 0); - assertEqual(cbor.getReadSize(), size_t{2}); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kUnsignedInt)); + assertTrue(r.getUnsignedInt() == 0); + assertEqual(r.getReadSize(), size_t{2}); } test(unsigned_19) { uint8_t b[] = { (0 << 5) + 19 }; cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cbor{bs}; - assertTrue(cbor.isWellFormed()); - assertEqual(cbor.getReadSize(), size_t{1}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{1}); bs.reset(); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kUnsignedInt)); - assertTrue(cbor.getUnsignedInt() == 19); - assertEqual(cbor.getReadSize(), size_t{2}); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kUnsignedInt)); + assertTrue(r.getUnsignedInt() == 19); + assertEqual(r.getReadSize(), size_t{2}); } test(unsigned_23) { uint8_t b[] = { (0 << 5) + 23 }; cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cbor{bs}; - assertTrue(cbor.isWellFormed()); - assertEqual(cbor.getReadSize(), size_t{1}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{1}); bs.reset(); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kUnsignedInt)); - assertTrue(cbor.getUnsignedInt() == 23); - assertEqual(cbor.getReadSize(), size_t{2}); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kUnsignedInt)); + assertTrue(r.getUnsignedInt() == 23); + assertEqual(r.getReadSize(), size_t{2}); } test(unsigned_1_byte) { uint8_t b[] = { (0 << 5) + 24, 0x12 }; cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cbor{bs}; - assertTrue(cbor.isWellFormed()); - assertEqual(cbor.getReadSize(), size_t{2}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{2}); bs.reset(); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kUnsignedInt)); - assertTrue(cbor.getUnsignedInt() == 0x12); - assertEqual(cbor.getReadSize(), size_t{4}); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kUnsignedInt)); + assertTrue(r.getUnsignedInt() == 0x12); + assertEqual(r.getReadSize(), size_t{4}); } test(unsigned_2_bytes) { uint8_t b[] = { (0 << 5) + 25, 0x12, 0x34 }; cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cbor{bs}; - assertTrue(cbor.isWellFormed()); - assertEqual(cbor.getReadSize(), size_t{3}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{3}); bs.reset(); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kUnsignedInt)); - assertTrue(cbor.getUnsignedInt() == 0x1234); - assertEqual(cbor.getReadSize(), size_t{6}); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kUnsignedInt)); + assertTrue(r.getUnsignedInt() == 0x1234); + assertEqual(r.getReadSize(), size_t{6}); } test(unsigned_4_bytes) { uint8_t b[] = { (0 << 5) + 26, 0x12, 0x34, 0x56, 0x78 }; cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cbor{bs}; - assertTrue(cbor.isWellFormed()); - assertEqual(cbor.getReadSize(), size_t{5}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{5}); bs.reset(); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kUnsignedInt)); - assertTrue(cbor.getUnsignedInt() == 0x12345678UL); - assertEqual(cbor.getReadSize(), size_t{10}); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kUnsignedInt)); + assertTrue(r.getUnsignedInt() == 0x12345678UL); + assertEqual(r.getReadSize(), size_t{10}); } test(unsigned_8_bytes) { uint8_t b[] = { (0 << 5) + 27, 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0 }; cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cbor{bs}; - assertTrue(cbor.isWellFormed()); - assertEqual(cbor.getReadSize(), size_t{9}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{9}); bs.reset(); - assertEqual(static_cast(cbor.readDataType()), static_cast(cbor::DataType::kUnsignedInt)); - assertTrue(cbor.getUnsignedInt() == 0x123456789abcdef0ULL); - assertEqual(cbor.getReadSize(), size_t{18}); + assertEqual(static_cast(r.readDataType()), static_cast(cbor::DataType::kUnsignedInt)); + assertTrue(r.getUnsignedInt() == 0x123456789abcdef0ULL); + assertEqual(r.getReadSize(), size_t{18}); } diff --git a/src/tests/well_formed.inc b/src/tests/well_formed.inc index ca94f50..5c4c396 100644 --- a/src/tests/well_formed.inc +++ b/src/tests/well_formed.inc @@ -8,9 +8,9 @@ test(well_formed_empty) { uint8_t b[0]; cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cbor{bs}; - assertFalse(cbor.isWellFormed()); - assertEqual(cbor.getReadSize(), size_t{0}); + cbor::Reader r{bs}; + assertFalse(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{0}); } test(well_formed_incomplete_1_byte) { @@ -18,9 +18,9 @@ test(well_formed_incomplete_1_byte) { for (int i = 0; i < 8; i++) { b[0] = (i << 5) + 24; cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cbor{bs}; - assertFalse(cbor.isWellFormed()); - assertEqual(cbor.getReadSize(), size_t{1}); + cbor::Reader r{bs}; + assertFalse(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{1}); } } @@ -29,9 +29,9 @@ test(well_formed_incomplete_2_bytes) { for (int i = 0; i < 8; i++) { b[0] = (i << 5) + 25; cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cbor{bs}; - assertFalse(cbor.isWellFormed()); - assertEqual(cbor.getReadSize(), size_t{1}); + cbor::Reader r{bs}; + assertFalse(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{1}); } } @@ -40,9 +40,9 @@ test(well_formed_incomplete_4_bytes) { for (int i = 0; i < 8; i++) { b[0] = (i << 5) + 26; cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cbor{bs}; - assertFalse(cbor.isWellFormed()); - assertEqual(cbor.getReadSize(), size_t{1}); + cbor::Reader r{bs}; + assertFalse(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{1}); } } @@ -51,9 +51,9 @@ test(well_formed_incomplete_8_bytes) { for (int i = 0; i < 8; i++) { b[0] = (i << 5) + 27; cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cbor{bs}; - assertFalse(cbor.isWellFormed()); - assertEqual(cbor.getReadSize(), size_t{1}); + cbor::Reader r{bs}; + assertFalse(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{1}); } } @@ -63,9 +63,9 @@ test(well_formed_bad_additional_info) { for (int j = 28; j <= 30; j++) { b[0] = (i << 5) + j; cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cbor{bs}; - assertFalse(cbor.isWellFormed()); - assertEqual(cbor.getReadSize(), size_t{1}); + cbor::Reader r{bs}; + assertFalse(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{1}); } } } @@ -73,87 +73,87 @@ test(well_formed_bad_additional_info) { test(well_formed_missing_tagged_item) { uint8_t b[] = { (6 << 5) + 25, 0xd9, 0xf7 }; cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cbor{bs}; - assertFalse(cbor.isWellFormed()); - assertEqual(cbor.getReadSize(), size_t{3}); + cbor::Reader r{bs}; + assertFalse(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{3}); } test(well_formed_bytes_too_short) { uint8_t b[] = { (2 << 5) + 3, 0x01, 0x02 }; cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cbor{bs}; - assertFalse(cbor.isWellFormed()); - assertEqual(cbor.getReadSize(), size_t{3}); + cbor::Reader r{bs}; + assertFalse(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{3}); } test(well_formed_bytes_indefinite_too_short) { uint8_t b[] = { (2 << 5) + 31, (2 << 5) + 2, 0x01, 0x02 }; cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cbor{bs}; - assertFalse(cbor.isWellFormed()); - assertEqual(cbor.getReadSize(), size_t{4}); + cbor::Reader r{bs}; + assertFalse(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{4}); } test(well_formed_bytes_indefinite_bad_type) { uint8_t b[] = { (2 << 5) + 31, (3 << 5) + 2, 0x01, 0x02, (7 << 5) + 31 }; cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cbor{bs}; - assertFalse(cbor.isWellFormed()); - assertEqual(cbor.getReadSize(), size_t{2}); + cbor::Reader r{bs}; + assertFalse(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{2}); } test(well_formed_text_too_short) { uint8_t b[] = { (3 << 5) + 3, 0x01, 0x02 }; cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cbor{bs}; - assertFalse(cbor.isWellFormed()); - assertEqual(cbor.getReadSize(), size_t{3}); + cbor::Reader r{bs}; + assertFalse(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{3}); } test(well_formed_text_indefinite_too_short) { uint8_t b[] = { (3 << 5) + 31, (3 << 5) + 2, 0x01, 0x02 }; cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cbor{bs}; - assertFalse(cbor.isWellFormed()); - assertEqual(cbor.getReadSize(), size_t{4}); + cbor::Reader r{bs}; + assertFalse(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{4}); } test(well_formed_text_indefinite_bad_type) { uint8_t b[] = { (3 << 5) + 31, (2 << 5) + 2, 0x01, 0x02, (7 << 5) + 31 }; cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cbor{bs}; - assertFalse(cbor.isWellFormed()); - assertEqual(cbor.getReadSize(), size_t{2}); + cbor::Reader r{bs}; + assertFalse(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{2}); } test(well_formed_array_too_short) { uint8_t b[] = { (4 << 5) + 3, 0x01, 0x02 }; cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cbor{bs}; - assertFalse(cbor.isWellFormed()); - assertEqual(cbor.getReadSize(), size_t{3}); + cbor::Reader r{bs}; + assertFalse(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{3}); } test(well_formed_map_too_short_complete_pair) { uint8_t b[] = { (5 << 5) + 3, 0x01, 0x02, 0x03, 0x04 }; cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cbor{bs}; - assertFalse(cbor.isWellFormed()); - assertEqual(cbor.getReadSize(), size_t{5}); + cbor::Reader r{bs}; + assertFalse(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{5}); } test(well_formed_map_too_short_incomplete_pair) { uint8_t b[] = { (5 << 5) + 3, 0x01, 0x02, 0x03, 0x04, 0x05 }; cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cbor{bs}; - assertFalse(cbor.isWellFormed()); - assertEqual(cbor.getReadSize(), size_t{6}); + cbor::Reader r{bs}; + assertFalse(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{6}); } test(well_formed_lone_break) { uint8_t b[] = { (7 << 5) + 31 }; cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cbor{bs}; - assertFalse(cbor.isWellFormed()); - assertEqual(cbor.getReadSize(), size_t{1}); + cbor::Reader r{bs}; + assertFalse(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{1}); } diff --git a/src/tests/write.inc b/src/tests/write.inc index 9001064..734f2dc 100644 --- a/src/tests/write.inc +++ b/src/tests/write.inc @@ -8,1059 +8,1059 @@ test(write_boolean_false) { uint8_t b[1]; cbor::BytesPrint bp{b, sizeof(b)}; - cbor::Writer cbor{bp}; - cbor.writeBoolean(false); - assertEqual(cbor.getWriteSize(), size_t{1}); + cbor::Writer w{bp}; + w.writeBoolean(false); + assertEqual(w.getWriteSize(), size_t{1}); cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cborReader{bs}; - assertTrue(cborReader.isWellFormed()); - assertEqual(cborReader.getReadSize(), size_t{1}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{1}); uint8_t b2[] = { (7 << 5) + 20 }; assertEqual(sizeof(b), sizeof(b2)); for (size_t i = 0; i < sizeof(b2); i++) { assertEqual(b[i], b2[i]); } - assertEqual(cbor.getWriteError(), 0); + assertEqual(w.getWriteError(), 0); } test(write_boolean_true) { uint8_t b[1]; cbor::BytesPrint bp{b, sizeof(b)}; - cbor::Writer cbor{bp}; - cbor.writeBoolean(true); - assertEqual(cbor.getWriteSize(), size_t{1}); + cbor::Writer w{bp}; + w.writeBoolean(true); + assertEqual(w.getWriteSize(), size_t{1}); cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cborReader{bs}; - assertTrue(cborReader.isWellFormed()); - assertEqual(cborReader.getReadSize(), size_t{1}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{1}); uint8_t b2[] = { (7 << 5) + 21 }; assertEqual(sizeof(b), sizeof(b2)); for (size_t i = 0; i < sizeof(b2); i++) { assertEqual(b[i], b2[i]); } - assertEqual(cbor.getWriteError(), 0); + assertEqual(w.getWriteError(), 0); } test(write_float_negative_4p1) { uint8_t b[5]{0}; cbor::BytesPrint bp{b, sizeof(b)}; - cbor::Writer cbor{bp}; - cbor.writeFloat(-4.1f); - assertEqual(cbor.getWriteSize(), size_t{5}); + cbor::Writer w{bp}; + w.writeFloat(-4.1f); + assertEqual(w.getWriteSize(), size_t{5}); cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cborReader{bs}; - assertTrue(cborReader.isWellFormed()); - assertEqual(cborReader.getReadSize(), size_t{5}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{5}); uint8_t b2[] = { (7 << 5) + 26, 0xc0, 0x83, 0x33, 0x33 }; assertEqual(sizeof(b), sizeof(b2)); for (size_t i = 0; i < sizeof(b2); i++) { assertEqual(b[i], b2[i]); } - assertEqual(cbor.getWriteError(), 0); + assertEqual(w.getWriteError(), 0); } test(write_float_100000) { uint8_t b[5]{0}; cbor::BytesPrint bp{b, sizeof(b)}; - cbor::Writer cbor{bp}; - cbor.writeFloat(100000.0f); - assertEqual(cbor.getWriteSize(), size_t{5}); + cbor::Writer w{bp}; + w.writeFloat(100000.0f); + assertEqual(w.getWriteSize(), size_t{5}); cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cborReader{bs}; - assertTrue(cborReader.isWellFormed()); - assertEqual(cborReader.getReadSize(), size_t{5}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{5}); uint8_t b2[] = { (7 << 5) + 26, 0x47, 0xc3, 0x50, 0x00 }; assertEqual(sizeof(b), sizeof(b2)); for (size_t i = 0; i < sizeof(b2); i++) { assertEqual(b[i], b2[i]); } - assertEqual(cbor.getWriteError(), 0); + assertEqual(w.getWriteError(), 0); } test(write_float_large) { uint8_t b[5]{0}; cbor::BytesPrint bp{b, sizeof(b)}; - cbor::Writer cbor{bp}; - cbor.writeFloat(3.4028234663852886e+38f); - assertEqual(cbor.getWriteSize(), size_t{5}); + cbor::Writer w{bp}; + w.writeFloat(3.4028234663852886e+38f); + assertEqual(w.getWriteSize(), size_t{5}); cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cborReader{bs}; - assertTrue(cborReader.isWellFormed()); - assertEqual(cborReader.getReadSize(), size_t{5}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{5}); uint8_t b2[] = { (7 << 5) + 26, 0x7f, 0x7f, 0xff, 0xff }; assertEqual(sizeof(b), sizeof(b2)); for (size_t i = 0; i < sizeof(b2); i++) { assertEqual(b[i], b2[i]); } - assertEqual(cbor.getWriteError(), 0); + assertEqual(w.getWriteError(), 0); } test(write_float_infinity) { uint8_t b[5]{0}; cbor::BytesPrint bp{b, sizeof(b)}; - cbor::Writer cbor{bp}; - cbor.writeFloat(INFINITY); - assertEqual(cbor.getWriteSize(), size_t{5}); + cbor::Writer w{bp}; + w.writeFloat(INFINITY); + assertEqual(w.getWriteSize(), size_t{5}); cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cborReader{bs}; - assertTrue(cborReader.isWellFormed()); - assertEqual(cborReader.getReadSize(), size_t{5}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{5}); uint8_t b2[] = { (7 << 5) + 26, 0x7f, 0x80, 0x00, 0x00 }; assertEqual(sizeof(b), sizeof(b2)); for (size_t i = 0; i < sizeof(b2); i++) { assertEqual(b[i], b2[i]); } - assertEqual(cbor.getWriteError(), 0); + assertEqual(w.getWriteError(), 0); } test(write_float_negative_infinity) { uint8_t b[5]{0}; cbor::BytesPrint bp{b, sizeof(b)}; - cbor::Writer cbor{bp}; - cbor.writeFloat(-INFINITY); - assertEqual(cbor.getWriteSize(), size_t{5}); + cbor::Writer w{bp}; + w.writeFloat(-INFINITY); + assertEqual(w.getWriteSize(), size_t{5}); cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cborReader{bs}; - assertTrue(cborReader.isWellFormed()); - assertEqual(cborReader.getReadSize(), size_t{5}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{5}); uint8_t b2[] = { (7 << 5) + 26, 0xff, 0x80, 0x00, 0x00 }; assertEqual(sizeof(b), sizeof(b2)); for (size_t i = 0; i < sizeof(b2); i++) { assertEqual(b[i], b2[i]); } - assertEqual(cbor.getWriteError(), 0); + assertEqual(w.getWriteError(), 0); } test(write_float_nan) { uint8_t b[5]{0}; cbor::BytesPrint bp{b, sizeof(b)}; - cbor::Writer cbor{bp}; - cbor.writeFloat(NAN); - assertEqual(cbor.getWriteSize(), size_t{5}); + cbor::Writer w{bp}; + w.writeFloat(NAN); + assertEqual(w.getWriteSize(), size_t{5}); cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cborReader{bs}; - assertTrue(cborReader.isWellFormed()); - assertEqual(cborReader.getReadSize(), size_t{5}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{5}); uint8_t b2[] = { (7 << 5) + 26, 0x7f, 0xc0, 0x00, 0x00 }; assertEqual(sizeof(b), sizeof(b2)); for (size_t i = 0; i < sizeof(b2); i++) { assertEqual(b[i], b2[i]); } - assertEqual(cbor.getWriteError(), 0); + assertEqual(w.getWriteError(), 0); } test(write_double_1p1) { uint8_t b[9]{0}; cbor::BytesPrint bp{b, sizeof(b)}; - cbor::Writer cbor{bp}; - cbor.writeDouble(1.1); - assertEqual(cbor.getWriteSize(), size_t{9}); + cbor::Writer w{bp}; + w.writeDouble(1.1); + assertEqual(w.getWriteSize(), size_t{9}); cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cborReader{bs}; - assertTrue(cborReader.isWellFormed()); - assertEqual(cborReader.getReadSize(), size_t{9}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{9}); uint8_t b2[] = { (7 << 5) + 27, 0x3f, 0xf1, 0x99, 0x99, 0x99, 0x99, 0x99, 0x9a }; assertEqual(sizeof(b), sizeof(b2)); for (size_t i = 0; i < sizeof(b2); i++) { assertEqual(b[i], b2[i]); } - assertEqual(cbor.getWriteError(), 0); + assertEqual(w.getWriteError(), 0); } test(write_double_negative_4p1) { uint8_t b[9]{0}; cbor::BytesPrint bp{b, sizeof(b)}; - cbor::Writer cbor{bp}; - cbor.writeDouble(-4.1); - assertEqual(cbor.getWriteSize(), size_t{9}); + cbor::Writer w{bp}; + w.writeDouble(-4.1); + assertEqual(w.getWriteSize(), size_t{9}); cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cborReader{bs}; - assertTrue(cborReader.isWellFormed()); - assertEqual(cborReader.getReadSize(), size_t{9}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{9}); uint8_t b2[] = { (7 << 5) + 27, 0xc0, 0x10, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66 }; assertEqual(sizeof(b), sizeof(b2)); for (size_t i = 0; i < sizeof(b2); i++) { assertEqual(b[i], b2[i]); } - assertEqual(cbor.getWriteError(), 0); + assertEqual(w.getWriteError(), 0); } test(write_double_large) { uint8_t b[9]{0}; cbor::BytesPrint bp{b, sizeof(b)}; - cbor::Writer cbor{bp}; - cbor.writeDouble(1.0e+300); - assertEqual(cbor.getWriteSize(), size_t{9}); + cbor::Writer w{bp}; + w.writeDouble(1.0e+300); + assertEqual(w.getWriteSize(), size_t{9}); cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cborReader{bs}; - assertTrue(cborReader.isWellFormed()); - assertEqual(cborReader.getReadSize(), size_t{9}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{9}); uint8_t b2[] = { (7 << 5) + 27, 0x7e, 0x37, 0xe4, 0x3c, 0x88, 0x00, 0x75, 0x9c }; assertEqual(sizeof(b), sizeof(b2)); for (size_t i = 0; i < sizeof(b2); i++) { assertEqual(b[i], b2[i]); } - assertEqual(cbor.getWriteError(), 0); + assertEqual(w.getWriteError(), 0); } test(write_double_infinity) { uint8_t b[9]{0}; cbor::BytesPrint bp{b, sizeof(b)}; - cbor::Writer cbor{bp}; - cbor.writeDouble(INFINITY); - assertEqual(cbor.getWriteSize(), size_t{9}); + cbor::Writer w{bp}; + w.writeDouble(INFINITY); + assertEqual(w.getWriteSize(), size_t{9}); cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cborReader{bs}; - assertTrue(cborReader.isWellFormed()); - assertEqual(cborReader.getReadSize(), size_t{9}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{9}); uint8_t b2[] = { (7 << 5) + 27, 0x7f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; assertEqual(sizeof(b), sizeof(b2)); for (size_t i = 0; i < sizeof(b2); i++) { assertEqual(b[i], b2[i]); } - assertEqual(cbor.getWriteError(), 0); + assertEqual(w.getWriteError(), 0); } test(write_double_negative_infinity) { uint8_t b[9]{0}; cbor::BytesPrint bp{b, sizeof(b)}; - cbor::Writer cbor{bp}; - cbor.writeDouble(-INFINITY); - assertEqual(cbor.getWriteSize(), size_t{9}); + cbor::Writer w{bp}; + w.writeDouble(-INFINITY); + assertEqual(w.getWriteSize(), size_t{9}); cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cborReader{bs}; - assertTrue(cborReader.isWellFormed()); - assertEqual(cborReader.getReadSize(), size_t{9}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{9}); uint8_t b2[] = { (7 << 5) + 27, 0xff, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; assertEqual(sizeof(b), sizeof(b2)); for (size_t i = 0; i < sizeof(b2); i++) { assertEqual(b[i], b2[i]); } - assertEqual(cbor.getWriteError(), 0); + assertEqual(w.getWriteError(), 0); } test(write_double_nan) { uint8_t b[9]{0}; cbor::BytesPrint bp{b, sizeof(b)}; - cbor::Writer cbor{bp}; - cbor.writeDouble(NAN); - assertEqual(cbor.getWriteSize(), size_t{9}); + cbor::Writer w{bp}; + w.writeDouble(NAN); + assertEqual(w.getWriteSize(), size_t{9}); cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cborReader{bs}; - assertTrue(cborReader.isWellFormed()); - assertEqual(cborReader.getReadSize(), size_t{9}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{9}); uint8_t b2[] = { (7 << 5) + 27, 0x7f, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; assertEqual(sizeof(b), sizeof(b2)); for (size_t i = 0; i < sizeof(b2); i++) { assertEqual(b[i], b2[i]); } - assertEqual(cbor.getWriteError(), 0); + assertEqual(w.getWriteError(), 0); } test(write_unsigned_zero) { uint8_t b[1]{0}; cbor::BytesPrint bp{b, sizeof(b)}; - cbor::Writer cbor{bp}; - cbor.writeUnsignedInt(0); - assertEqual(cbor.getWriteSize(), size_t{1}); + cbor::Writer w{bp}; + w.writeUnsignedInt(0); + assertEqual(w.getWriteSize(), size_t{1}); cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cborReader{bs}; - assertTrue(cborReader.isWellFormed()); - assertEqual(cborReader.getReadSize(), size_t{1}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{1}); uint8_t b2[] = { (0 << 5) + 0 }; assertEqual(sizeof(b), sizeof(b2)); for (size_t i = 0; i < sizeof(b2); i++) { assertEqual(b[i], b2[i]); } - assertEqual(cbor.getWriteError(), 0); + assertEqual(w.getWriteError(), 0); } test(write_unsigned_23) { uint8_t b[1]{0}; cbor::BytesPrint bp{b, sizeof(b)}; - cbor::Writer cbor{bp}; - cbor.writeUnsignedInt(23); - assertEqual(cbor.getWriteSize(), size_t{1}); + cbor::Writer w{bp}; + w.writeUnsignedInt(23); + assertEqual(w.getWriteSize(), size_t{1}); cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cborReader{bs}; - assertTrue(cborReader.isWellFormed()); - assertEqual(cborReader.getReadSize(), size_t{1}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{1}); uint8_t b2[] = { (0 << 5) + 23 }; assertEqual(sizeof(b), sizeof(b2)); for (size_t i = 0; i < sizeof(b2); i++) { assertEqual(b[i], b2[i]); } - assertEqual(cbor.getWriteError(), 0); + assertEqual(w.getWriteError(), 0); } test(write_unsigned_1_byte) { uint8_t b[2]{0}; cbor::BytesPrint bp{b, sizeof(b)}; - cbor::Writer cbor{bp}; - cbor.writeUnsignedInt(24); - assertEqual(cbor.getWriteSize(), size_t{2}); + cbor::Writer w{bp}; + w.writeUnsignedInt(24); + assertEqual(w.getWriteSize(), size_t{2}); cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cborReader{bs}; - assertTrue(cborReader.isWellFormed()); - assertEqual(cborReader.getReadSize(), size_t{2}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{2}); uint8_t b2[] = { (0 << 5) + 24, 24 }; assertEqual(sizeof(b), sizeof(b2)); for (size_t i = 0; i < sizeof(b2); i++) { assertEqual(b[i], b2[i]); } - assertEqual(cbor.getWriteError(), 0); + assertEqual(w.getWriteError(), 0); } test(write_unsigned_2_bytes) { uint8_t b[3]{0}; cbor::BytesPrint bp{b, sizeof(b)}; - cbor::Writer cbor{bp}; - cbor.writeUnsignedInt(0x0102); - assertEqual(cbor.getWriteSize(), size_t{3}); + cbor::Writer w{bp}; + w.writeUnsignedInt(0x0102); + assertEqual(w.getWriteSize(), size_t{3}); cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cborReader{bs}; - assertTrue(cborReader.isWellFormed()); - assertEqual(cborReader.getReadSize(), size_t{3}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{3}); uint8_t b2[] = { (0 << 5) + 25, 0x01, 0x02 }; assertEqual(sizeof(b), sizeof(b2)); for (size_t i = 0; i < sizeof(b2); i++) { assertEqual(b[i], b2[i]); } - assertEqual(cbor.getWriteError(), 0); + assertEqual(w.getWriteError(), 0); } test(write_unsigned_4_bytes) { uint8_t b[5]{0}; cbor::BytesPrint bp{b, sizeof(b)}; - cbor::Writer cbor{bp}; - cbor.writeUnsignedInt(0x01020304UL); - assertEqual(cbor.getWriteSize(), size_t{5}); + cbor::Writer w{bp}; + w.writeUnsignedInt(0x01020304UL); + assertEqual(w.getWriteSize(), size_t{5}); cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cborReader{bs}; - assertTrue(cborReader.isWellFormed()); - assertEqual(cborReader.getReadSize(), size_t{5}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{5}); uint8_t b2[] = { (0 << 5) + 26, 0x01, 0x02, 0x03, 0x04 }; assertEqual(sizeof(b), sizeof(b2)); for (size_t i = 0; i < sizeof(b2); i++) { assertEqual(b[i], b2[i]); } - assertEqual(cbor.getWriteError(), 0); + assertEqual(w.getWriteError(), 0); } test(write_unsigned_8_bytes) { uint8_t b[9]{0}; cbor::BytesPrint bp{b, sizeof(b)}; - cbor::Writer cbor{bp}; - cbor.writeUnsignedInt(0x0102030405060708ULL); - assertEqual(cbor.getWriteSize(), size_t{9}); + cbor::Writer w{bp}; + w.writeUnsignedInt(0x0102030405060708ULL); + assertEqual(w.getWriteSize(), size_t{9}); cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cborReader{bs}; - assertTrue(cborReader.isWellFormed()); - assertEqual(cborReader.getReadSize(), size_t{9}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{9}); uint8_t b2[] = { (0 << 5) + 27, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 }; assertEqual(sizeof(b), sizeof(b2)); for (size_t i = 0; i < sizeof(b2); i++) { assertEqual(b[i], b2[i]); } - assertEqual(cbor.getWriteError(), 0); + assertEqual(w.getWriteError(), 0); } test(write_negative_24) { uint8_t b[1]{0}; cbor::BytesPrint bp{b, sizeof(b)}; - cbor::Writer cbor{bp}; - cbor.writeInt(-24); - assertEqual(cbor.getWriteSize(), size_t{1}); + cbor::Writer w{bp}; + w.writeInt(-24); + assertEqual(w.getWriteSize(), size_t{1}); cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cborReader{bs}; - assertTrue(cborReader.isWellFormed()); - assertEqual(cborReader.getReadSize(), size_t{1}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{1}); uint8_t b2[] = { (1 << 5) + 23 }; assertEqual(sizeof(b), sizeof(b2)); for (size_t i = 0; i < sizeof(b2); i++) { assertEqual(b[i], b2[i]); } - assertEqual(cbor.getWriteError(), 0); + assertEqual(w.getWriteError(), 0); } test(write_negative_1_byte) { uint8_t b[2]{0}; cbor::BytesPrint bp{b, sizeof(b)}; - cbor::Writer cbor{bp}; - cbor.writeInt(-25); - assertEqual(cbor.getWriteSize(), size_t{2}); + cbor::Writer w{bp}; + w.writeInt(-25); + assertEqual(w.getWriteSize(), size_t{2}); cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cborReader{bs}; - assertTrue(cborReader.isWellFormed()); - assertEqual(cborReader.getReadSize(), size_t{2}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{2}); uint8_t b2[] = { (1 << 5) + 24, 24 }; assertEqual(sizeof(b), sizeof(b2)); for (size_t i = 0; i < sizeof(b2); i++) { assertEqual(b[i], b2[i]); } - assertEqual(cbor.getWriteError(), 0); + assertEqual(w.getWriteError(), 0); } test(write_negative_2_bytes) { uint8_t b[3]{0}; cbor::BytesPrint bp{b, sizeof(b)}; - cbor::Writer cbor{bp}; - cbor.writeInt(-0x0103); - assertEqual(cbor.getWriteSize(), size_t{3}); + cbor::Writer w{bp}; + w.writeInt(-0x0103); + assertEqual(w.getWriteSize(), size_t{3}); cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cborReader{bs}; - assertTrue(cborReader.isWellFormed()); - assertEqual(cborReader.getReadSize(), size_t{3}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{3}); uint8_t b2[] = { (1 << 5) + 25, 0x01, 0x02 }; assertEqual(sizeof(b), sizeof(b2)); for (size_t i = 0; i < sizeof(b2); i++) { assertEqual(b[i], b2[i]); } - assertEqual(cbor.getWriteError(), 0); + assertEqual(w.getWriteError(), 0); } test(write_negative_4_bytes) { uint8_t b[5]{0}; cbor::BytesPrint bp{b, sizeof(b)}; - cbor::Writer cbor{bp}; - cbor.writeInt(-0x01020305L); - assertEqual(cbor.getWriteSize(), size_t{5}); + cbor::Writer w{bp}; + w.writeInt(-0x01020305L); + assertEqual(w.getWriteSize(), size_t{5}); cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cborReader{bs}; - assertTrue(cborReader.isWellFormed()); - assertEqual(cborReader.getReadSize(), size_t{5}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{5}); uint8_t b2[] = { (1 << 5) + 26, 0x01, 0x02, 0x03, 0x04 }; assertEqual(sizeof(b), sizeof(b2)); for (size_t i = 0; i < sizeof(b2); i++) { assertEqual(b[i], b2[i]); } - assertEqual(cbor.getWriteError(), 0); + assertEqual(w.getWriteError(), 0); } test(write_negative_8_bytes) { uint8_t b[9]{0}; cbor::BytesPrint bp{b, sizeof(b)}; - cbor::Writer cbor{bp}; - cbor.writeInt(-0x0102030405060709LL); - assertEqual(cbor.getWriteSize(), size_t{9}); + cbor::Writer w{bp}; + w.writeInt(-0x0102030405060709LL); + assertEqual(w.getWriteSize(), size_t{9}); cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cborReader{bs}; - assertTrue(cborReader.isWellFormed()); - assertEqual(cborReader.getReadSize(), size_t{9}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{9}); uint8_t b2[] = { (1 << 5) + 27, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 }; assertEqual(sizeof(b), sizeof(b2)); for (size_t i = 0; i < sizeof(b2); i++) { assertEqual(b[i], b2[i]); } - assertEqual(cbor.getWriteError(), 0); + assertEqual(w.getWriteError(), 0); } test(write_null) { uint8_t b[1]{0}; cbor::BytesPrint bp{b, sizeof(b)}; - cbor::Writer cbor{bp}; - cbor.writeNull(); - assertEqual(cbor.getWriteSize(), size_t{1}); + cbor::Writer w{bp}; + w.writeNull(); + assertEqual(w.getWriteSize(), size_t{1}); cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cborReader{bs}; - assertTrue(cborReader.isWellFormed()); - assertEqual(cborReader.getReadSize(), size_t{1}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{1}); uint8_t b2[] = { (7 << 5) + 22 }; assertEqual(sizeof(b), sizeof(b2)); for (size_t i = 0; i < sizeof(b2); i++) { assertEqual(b[i], b2[i]); } - assertEqual(cbor.getWriteError(), 0); + assertEqual(w.getWriteError(), 0); } test(write_undefined) { uint8_t b[1]{0}; cbor::BytesPrint bp{b, sizeof(b)}; - cbor::Writer cbor{bp}; - cbor.writeUndefined(); - assertEqual(cbor.getWriteSize(), size_t{1}); + cbor::Writer w{bp}; + w.writeUndefined(); + assertEqual(w.getWriteSize(), size_t{1}); cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cborReader{bs}; - assertTrue(cborReader.isWellFormed()); - assertEqual(cborReader.getReadSize(), size_t{1}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{1}); uint8_t b2[] = { (7 << 5) + 23 }; assertEqual(sizeof(b), sizeof(b2)); for (size_t i = 0; i < sizeof(b2); i++) { assertEqual(b[i], b2[i]); } - assertEqual(cbor.getWriteError(), 0); + assertEqual(w.getWriteError(), 0); } test(write_simple_value_19) { uint8_t b[1]{0}; cbor::BytesPrint bp{b, sizeof(b)}; - cbor::Writer cbor{bp}; - cbor.writeSimpleValue(19); - assertEqual(cbor.getWriteSize(), size_t{1}); + cbor::Writer w{bp}; + w.writeSimpleValue(19); + assertEqual(w.getWriteSize(), size_t{1}); cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cborReader{bs}; - assertTrue(cborReader.isWellFormed()); - assertEqual(cborReader.getReadSize(), size_t{1}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{1}); uint8_t b2[] = { (7 << 5) + 19 }; assertEqual(sizeof(b), sizeof(b2)); for (size_t i = 0; i < sizeof(b2); i++) { assertEqual(b[i], b2[i]); } - assertEqual(cbor.getWriteError(), 0); + assertEqual(w.getWriteError(), 0); } test(write_simple_value_1_byte) { uint8_t b[2]{0}; cbor::BytesPrint bp{b, sizeof(b)}; - cbor::Writer cbor{bp}; - cbor.writeSimpleValue(32); - assertEqual(cbor.getWriteSize(), size_t{2}); + cbor::Writer w{bp}; + w.writeSimpleValue(32); + assertEqual(w.getWriteSize(), size_t{2}); cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cborReader{bs}; - assertTrue(cborReader.isWellFormed()); - assertEqual(cborReader.getReadSize(), size_t{2}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{2}); uint8_t b2[] = { (7 << 5) + 24, 32 }; assertEqual(sizeof(b), sizeof(b2)); for (size_t i = 0; i < sizeof(b2); i++) { assertEqual(b[i], b2[i]); } - assertEqual(cbor.getWriteError(), 0); + assertEqual(w.getWriteError(), 0); } test(write_tag_zero) { uint8_t b[2]{0}; cbor::BytesPrint bp{b, sizeof(b)}; - cbor::Writer cbor{bp}; - cbor.writeTag(0); - cbor.writeUnsignedInt(1); // Ensure there's something after the tag for well-formedness - assertEqual(cbor.getWriteSize(), size_t{2}); + cbor::Writer w{bp}; + w.writeTag(0); + w.writeUnsignedInt(1); // Ensure there's something after the tag for well-formedness + assertEqual(w.getWriteSize(), size_t{2}); cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cborReader{bs}; - assertTrue(cborReader.isWellFormed()); - assertEqual(cborReader.getReadSize(), size_t{2}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{2}); uint8_t b2[] = { (6 << 5) + 0, (0 << 5) + 1 }; assertEqual(sizeof(b), sizeof(b2)); for (size_t i = 0; i < sizeof(b2); i++) { assertEqual(b[i], b2[i]); } - assertEqual(cbor.getWriteError(), 0); + assertEqual(w.getWriteError(), 0); } test(write_tag_23) { uint8_t b[2]{0}; cbor::BytesPrint bp{b, sizeof(b)}; - cbor::Writer cbor{bp}; - cbor.writeTag(23); - cbor.writeUnsignedInt(1); // Ensure there's something after the tag for well-formedness - assertEqual(cbor.getWriteSize(), size_t{2}); + cbor::Writer w{bp}; + w.writeTag(23); + w.writeUnsignedInt(1); // Ensure there's something after the tag for well-formedness + assertEqual(w.getWriteSize(), size_t{2}); cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cborReader{bs}; - assertTrue(cborReader.isWellFormed()); - assertEqual(cborReader.getReadSize(), size_t{2}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{2}); uint8_t b2[] = { (6 << 5) + 23, (0 << 5) + 1 }; assertEqual(sizeof(b), sizeof(b2)); for (size_t i = 0; i < sizeof(b2); i++) { assertEqual(b[i], b2[i]); } - assertEqual(cbor.getWriteError(), 0); + assertEqual(w.getWriteError(), 0); } test(write_tag_1_byte) { uint8_t b[3]{0}; cbor::BytesPrint bp{b, sizeof(b)}; - cbor::Writer cbor{bp}; - cbor.writeTag(24); - cbor.writeUnsignedInt(1); // Ensure there's something after the tag for well-formedness - assertEqual(cbor.getWriteSize(), size_t{3}); + cbor::Writer w{bp}; + w.writeTag(24); + w.writeUnsignedInt(1); // Ensure there's something after the tag for well-formedness + assertEqual(w.getWriteSize(), size_t{3}); cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cborReader{bs}; - assertTrue(cborReader.isWellFormed()); - assertEqual(cborReader.getReadSize(), size_t{3}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{3}); uint8_t b2[] = { (6 << 5) + 24, 24, (0 << 5) + 1 }; assertEqual(sizeof(b), sizeof(b2)); for (size_t i = 0; i < sizeof(b2); i++) { assertEqual(b[i], b2[i]); } - assertEqual(cbor.getWriteError(), 0); + assertEqual(w.getWriteError(), 0); } test(write_tag_2_bytes) { uint8_t b[4]{0}; cbor::BytesPrint bp{b, sizeof(b)}; - cbor::Writer cbor{bp}; - cbor.writeTag(0x0102); - cbor.writeUnsignedInt(1); // Ensure there's something after the tag for well-formedness - assertEqual(cbor.getWriteSize(), size_t{4}); + cbor::Writer w{bp}; + w.writeTag(0x0102); + w.writeUnsignedInt(1); // Ensure there's something after the tag for well-formedness + assertEqual(w.getWriteSize(), size_t{4}); cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cborReader{bs}; - assertTrue(cborReader.isWellFormed()); - assertEqual(cborReader.getReadSize(), size_t{4}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{4}); uint8_t b2[] = { (6 << 5) + 25, 0x01, 0x02, (0 << 5) + 1 }; assertEqual(sizeof(b), sizeof(b2)); for (size_t i = 0; i < sizeof(b2); i++) { assertEqual(b[i], b2[i]); } - assertEqual(cbor.getWriteError(), 0); + assertEqual(w.getWriteError(), 0); } test(write_tag_4_bytes) { uint8_t b[6]{0}; cbor::BytesPrint bp{b, sizeof(b)}; - cbor::Writer cbor{bp}; - cbor.writeTag(0x01020304UL); - cbor.writeUnsignedInt(1); // Ensure there's something after the tag for well-formedness - assertEqual(cbor.getWriteSize(), size_t{6}); + cbor::Writer w{bp}; + w.writeTag(0x01020304UL); + w.writeUnsignedInt(1); // Ensure there's something after the tag for well-formedness + assertEqual(w.getWriteSize(), size_t{6}); cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cborReader{bs}; - assertTrue(cborReader.isWellFormed()); - assertEqual(cborReader.getReadSize(), size_t{6}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{6}); uint8_t b2[] = { (6 << 5) + 26, 0x01, 0x02, 0x03, 0x04, (0 << 5) + 1 }; assertEqual(sizeof(b), sizeof(b2)); for (size_t i = 0; i < sizeof(b2); i++) { assertEqual(b[i], b2[i]); } - assertEqual(cbor.getWriteError(), 0); + assertEqual(w.getWriteError(), 0); } test(write_tag_8_bytes) { uint8_t b[10]{0}; cbor::BytesPrint bp{b, sizeof(b)}; - cbor::Writer cbor{bp}; - cbor.writeTag(0x0102030405060708ULL); - cbor.writeUnsignedInt(1); // Ensure there's something after the tag for well-formedness - assertEqual(cbor.getWriteSize(), size_t{10}); + cbor::Writer w{bp}; + w.writeTag(0x0102030405060708ULL); + w.writeUnsignedInt(1); // Ensure there's something after the tag for well-formedness + assertEqual(w.getWriteSize(), size_t{10}); cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cborReader{bs}; - assertTrue(cborReader.isWellFormed()); - assertEqual(cborReader.getReadSize(), size_t{10}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{10}); uint8_t b2[] = { (6 << 5) + 27, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, (0 << 5) + 1 }; assertEqual(sizeof(b), sizeof(b2)); for (size_t i = 0; i < sizeof(b2); i++) { assertEqual(b[i], b2[i]); } - assertEqual(cbor.getWriteError(), 0); + assertEqual(w.getWriteError(), 0); } test(write_bytes_empty) { uint8_t b[1]{0}; cbor::BytesPrint bp{b, sizeof(b)}; - cbor::Writer cbor{bp}; - cbor.beginBytes(0); - assertEqual(cbor.getWriteSize(), size_t{1}); + cbor::Writer w{bp}; + w.beginBytes(0); + assertEqual(w.getWriteSize(), size_t{1}); cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cborReader{bs}; - assertTrue(cborReader.isWellFormed()); - assertEqual(cborReader.getReadSize(), size_t{1}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{1}); uint8_t b2[] = { (2 << 5) + 0 }; assertEqual(sizeof(b), sizeof(b2)); for (size_t i = 0; i < sizeof(b2); i++) { assertEqual(b[i], b2[i]); } - assertEqual(cbor.getWriteError(), 0); + assertEqual(w.getWriteError(), 0); } test(write_bytes_indefinite_empty) { uint8_t b[2]{0}; cbor::BytesPrint bp{b, sizeof(b)}; - cbor::Writer cbor{bp}; - cbor.beginIndefiniteBytes(); - cbor.endIndefinite(); - assertEqual(cbor.getWriteSize(), size_t{2}); + cbor::Writer w{bp}; + w.beginIndefiniteBytes(); + w.endIndefinite(); + assertEqual(w.getWriteSize(), size_t{2}); cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cborReader{bs}; - assertTrue(cborReader.isWellFormed()); - assertEqual(cborReader.getReadSize(), size_t{2}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{2}); uint8_t b2[] = { (2 << 5) + 31, (7 << 5) + 31 }; assertEqual(sizeof(b), sizeof(b2)); for (size_t i = 0; i < sizeof(b2); i++) { assertEqual(b[i], b2[i]); } - assertEqual(cbor.getWriteError(), 0); + assertEqual(w.getWriteError(), 0); } test(write_bytes_2) { uint8_t b[3]{0}; cbor::BytesPrint bp{b, sizeof(b)}; - cbor::Writer cbor{bp}; - cbor.beginBytes(2); + cbor::Writer w{bp}; + w.beginBytes(2); uint8_t data[] = { 0x01, 0x02 }; - cbor.writeBytes(data, sizeof(data)); - assertEqual(cbor.getWriteSize(), size_t{3}); + w.writeBytes(data, sizeof(data)); + assertEqual(w.getWriteSize(), size_t{3}); cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cborReader{bs}; - assertTrue(cborReader.isWellFormed()); - assertEqual(cborReader.getReadSize(), size_t{3}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{3}); uint8_t b2[] = { (2 << 5) + 2, 0x01, 0x02 }; assertEqual(sizeof(b), sizeof(b2)); for (size_t i = 0; i < sizeof(b2); i++) { assertEqual(b[i], b2[i]); } - assertEqual(cbor.getWriteError(), 0); + assertEqual(w.getWriteError(), 0); } test(write_bytes_indefinite) { uint8_t b[4]{0}; cbor::BytesPrint bp{b, sizeof(b)}; - cbor::Writer cbor{bp}; - cbor.beginIndefiniteBytes(); + cbor::Writer w{bp}; + w.beginIndefiniteBytes(); uint8_t data[] = { 0x01 }; - cbor.beginBytes(sizeof(data)); - cbor.writeBytes(data, sizeof(data)); - cbor.endIndefinite(); - assertEqual(cbor.getWriteSize(), size_t{4}); + w.beginBytes(sizeof(data)); + w.writeBytes(data, sizeof(data)); + w.endIndefinite(); + assertEqual(w.getWriteSize(), size_t{4}); cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cborReader{bs}; - assertTrue(cborReader.isWellFormed()); - assertEqual(cborReader.getReadSize(), size_t{4}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{4}); uint8_t b2[] = { (2 << 5) + 31, (2 << 5) + 1, 0x01, (7 << 5) + 31 }; assertEqual(sizeof(b), sizeof(b2)); for (size_t i = 0; i < sizeof(b2); i++) { assertEqual(b[i], b2[i]); } - assertEqual(cbor.getWriteError(), 0); + assertEqual(w.getWriteError(), 0); } test(write_text_empty) { uint8_t b[1]{0}; cbor::BytesPrint bp{b, sizeof(b)}; - cbor::Writer cbor{bp}; - cbor.beginText(0); - assertEqual(cbor.getWriteSize(), size_t{1}); + cbor::Writer w{bp}; + w.beginText(0); + assertEqual(w.getWriteSize(), size_t{1}); cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cborReader{bs}; - assertTrue(cborReader.isWellFormed()); - assertEqual(cborReader.getReadSize(), size_t{1}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{1}); uint8_t b2[] = { (3 << 5) + 0 }; assertEqual(sizeof(b), sizeof(b2)); for (size_t i = 0; i < sizeof(b2); i++) { assertEqual(b[i], b2[i]); } - assertEqual(cbor.getWriteError(), 0); + assertEqual(w.getWriteError(), 0); } test(write_text_indefinite_empty) { uint8_t b[2]{0}; cbor::BytesPrint bp{b, sizeof(b)}; - cbor::Writer cbor{bp}; - cbor.beginIndefiniteText(); - cbor.endIndefinite(); - assertEqual(cbor.getWriteSize(), size_t{2}); + cbor::Writer w{bp}; + w.beginIndefiniteText(); + w.endIndefinite(); + assertEqual(w.getWriteSize(), size_t{2}); cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cborReader{bs}; - assertTrue(cborReader.isWellFormed()); - assertEqual(cborReader.getReadSize(), size_t{2}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{2}); uint8_t b2[] = { (3 << 5) + 31, (7 << 5) + 31 }; assertEqual(sizeof(b), sizeof(b2)); for (size_t i = 0; i < sizeof(b2); i++) { assertEqual(b[i], b2[i]); } - assertEqual(cbor.getWriteError(), 0); + assertEqual(w.getWriteError(), 0); } test(write_text_2) { uint8_t b[3]{0}; cbor::BytesPrint bp{b, sizeof(b)}; - cbor::Writer cbor{bp}; - cbor.beginText(2); + cbor::Writer w{bp}; + w.beginText(2); uint8_t data[] = { 0x01, 0x02 }; - cbor.writeBytes(data, sizeof(data)); - assertEqual(cbor.getWriteSize(), size_t{3}); + w.writeBytes(data, sizeof(data)); + assertEqual(w.getWriteSize(), size_t{3}); cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cborReader{bs}; - assertTrue(cborReader.isWellFormed()); - assertEqual(cborReader.getReadSize(), size_t{3}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{3}); uint8_t b2[] = { (3 << 5) + 2, 0x01, 0x02 }; assertEqual(sizeof(b), sizeof(b2)); for (size_t i = 0; i < sizeof(b2); i++) { assertEqual(b[i], b2[i]); } - assertEqual(cbor.getWriteError(), 0); + assertEqual(w.getWriteError(), 0); } test(write_text_indefinite) { uint8_t b[4]{0}; cbor::BytesPrint bp{b, sizeof(b)}; - cbor::Writer cbor{bp}; - cbor.beginIndefiniteText(); + cbor::Writer w{bp}; + w.beginIndefiniteText(); uint8_t data[] = { 0x01 }; - cbor.beginText(sizeof(data)); - cbor.writeBytes(data, sizeof(data)); - cbor.endIndefinite(); - assertEqual(cbor.getWriteSize(), size_t{4}); + w.beginText(sizeof(data)); + w.writeBytes(data, sizeof(data)); + w.endIndefinite(); + assertEqual(w.getWriteSize(), size_t{4}); cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cborReader{bs}; - assertTrue(cborReader.isWellFormed()); - assertEqual(cborReader.getReadSize(), size_t{4}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{4}); uint8_t b2[] = { (3 << 5) + 31, (3 << 5) + 1, 0x01, (7 << 5) + 31 }; assertEqual(sizeof(b), sizeof(b2)); for (size_t i = 0; i < sizeof(b2); i++) { assertEqual(b[i], b2[i]); } - assertEqual(cbor.getWriteError(), 0); + assertEqual(w.getWriteError(), 0); } test(write_array_empty) { uint8_t b[1]{0}; cbor::BytesPrint bp{b, sizeof(b)}; - cbor::Writer cbor{bp}; - cbor.beginArray(0); - assertEqual(cbor.getWriteSize(), size_t{1}); + cbor::Writer w{bp}; + w.beginArray(0); + assertEqual(w.getWriteSize(), size_t{1}); cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cborReader{bs}; - assertTrue(cborReader.isWellFormed()); - assertEqual(cborReader.getReadSize(), size_t{1}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{1}); uint8_t b2[] = { (4 << 5) + 0 }; assertEqual(sizeof(b), sizeof(b2)); for (size_t i = 0; i < sizeof(b2); i++) { assertEqual(b[i], b2[i]); } - assertEqual(cbor.getWriteError(), 0); + assertEqual(w.getWriteError(), 0); } test(write_array_indefinite_empty) { uint8_t b[2]{0}; cbor::BytesPrint bp{b, sizeof(b)}; - cbor::Writer cbor{bp}; - cbor.beginIndefiniteArray(); - cbor.endIndefinite(); - assertEqual(cbor.getWriteSize(), size_t{2}); + cbor::Writer w{bp}; + w.beginIndefiniteArray(); + w.endIndefinite(); + assertEqual(w.getWriteSize(), size_t{2}); cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cborReader{bs}; - assertTrue(cborReader.isWellFormed()); - assertEqual(cborReader.getReadSize(), size_t{2}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{2}); uint8_t b2[] = { (4 << 5) + 31, (7 << 5) + 31 }; assertEqual(sizeof(b), sizeof(b2)); for (size_t i = 0; i < sizeof(b2); i++) { assertEqual(b[i], b2[i]); } - assertEqual(cbor.getWriteError(), 0); + assertEqual(w.getWriteError(), 0); } test(write_array_2) { uint8_t b[3]{0}; cbor::BytesPrint bp{b, sizeof(b)}; - cbor::Writer cbor{bp}; - cbor.beginArray(2); + cbor::Writer w{bp}; + w.beginArray(2); uint8_t data[] = { 0x01, 0x02 }; for (size_t i = 0; i < sizeof(data); i++) { - cbor.writeUnsignedInt(data[i]); + w.writeUnsignedInt(data[i]); } - assertEqual(cbor.getWriteSize(), size_t{3}); + assertEqual(w.getWriteSize(), size_t{3}); cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cborReader{bs}; - assertTrue(cborReader.isWellFormed()); - assertEqual(cborReader.getReadSize(), size_t{3}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{3}); uint8_t b2[] = { (4 << 5) + 2, 0x01, 0x02 }; assertEqual(sizeof(b), sizeof(b2)); for (size_t i = 0; i < sizeof(b2); i++) { assertEqual(b[i], b2[i]); } - assertEqual(cbor.getWriteError(), 0); + assertEqual(w.getWriteError(), 0); } test(write_array_indefinite) { uint8_t b[3]{0}; cbor::BytesPrint bp{b, sizeof(b)}; - cbor::Writer cbor{bp}; - cbor.beginIndefiniteArray(); + cbor::Writer w{bp}; + w.beginIndefiniteArray(); uint8_t data[] = { 0x01 }; for (size_t i = 0; i < sizeof(data); i++) { - cbor.writeUnsignedInt(data[i]); + w.writeUnsignedInt(data[i]); } - cbor.endIndefinite(); - assertEqual(cbor.getWriteSize(), size_t{3}); + w.endIndefinite(); + assertEqual(w.getWriteSize(), size_t{3}); cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cborReader{bs}; - assertTrue(cborReader.isWellFormed()); - assertEqual(cborReader.getReadSize(), size_t{3}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{3}); uint8_t b2[] = { (4 << 5) + 31, 0x01, (7 << 5) + 31 }; assertEqual(sizeof(b), sizeof(b2)); for (size_t i = 0; i < sizeof(b2); i++) { assertEqual(b[i], b2[i]); } - assertEqual(cbor.getWriteError(), 0); + assertEqual(w.getWriteError(), 0); } test(write_map_empty) { uint8_t b[1]{0}; cbor::BytesPrint bp{b, sizeof(b)}; - cbor::Writer cbor{bp}; - cbor.beginMap(0); - assertEqual(cbor.getWriteSize(), size_t{1}); + cbor::Writer w{bp}; + w.beginMap(0); + assertEqual(w.getWriteSize(), size_t{1}); cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cborReader{bs}; - assertTrue(cborReader.isWellFormed()); - assertEqual(cborReader.getReadSize(), size_t{1}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{1}); uint8_t b2[] = { (5 << 5) + 0 }; assertEqual(sizeof(b), sizeof(b2)); for (size_t i = 0; i < sizeof(b2); i++) { assertEqual(b[i], b2[i]); } - assertEqual(cbor.getWriteError(), 0); + assertEqual(w.getWriteError(), 0); } test(write_map_indefinite_empty) { uint8_t b[2]{0}; cbor::BytesPrint bp{b, sizeof(b)}; - cbor::Writer cbor{bp}; - cbor.beginIndefiniteMap(); - cbor.endIndefinite(); - assertEqual(cbor.getWriteSize(), size_t{2}); + cbor::Writer w{bp}; + w.beginIndefiniteMap(); + w.endIndefinite(); + assertEqual(w.getWriteSize(), size_t{2}); cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cborReader{bs}; - assertTrue(cborReader.isWellFormed()); - assertEqual(cborReader.getReadSize(), size_t{2}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{2}); uint8_t b2[] = { (5 << 5) + 31, (7 << 5) + 31 }; assertEqual(sizeof(b), sizeof(b2)); for (size_t i = 0; i < sizeof(b2); i++) { assertEqual(b[i], b2[i]); } - assertEqual(cbor.getWriteError(), 0); + assertEqual(w.getWriteError(), 0); } test(write_map_2) { uint8_t b[5]{0}; cbor::BytesPrint bp{b, sizeof(b)}; - cbor::Writer cbor{bp}; - cbor.beginMap(2); + cbor::Writer w{bp}; + w.beginMap(2); uint8_t data[] = { 0x01, 0x02, 0x03, 0x04 }; for (size_t i = 0; i < sizeof(data); i++) { - cbor.writeUnsignedInt(data[i]); + w.writeUnsignedInt(data[i]); } - assertEqual(cbor.getWriteSize(), size_t{5}); + assertEqual(w.getWriteSize(), size_t{5}); cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cborReader{bs}; - assertTrue(cborReader.isWellFormed()); - assertEqual(cborReader.getReadSize(), size_t{5}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{5}); uint8_t b2[] = { (5 << 5) + 2, 0x01, 0x02, 0x03, 0x04 }; assertEqual(sizeof(b), sizeof(b2)); for (size_t i = 0; i < sizeof(b2); i++) { assertEqual(b[i], b2[i]); } - assertEqual(cbor.getWriteError(), 0); + assertEqual(w.getWriteError(), 0); } test(write_map_indefinite) { uint8_t b[4]{0}; cbor::BytesPrint bp{b, sizeof(b)}; - cbor::Writer cbor{bp}; - cbor.beginIndefiniteMap(); + cbor::Writer w{bp}; + w.beginIndefiniteMap(); uint8_t data[] = { 0x01, 0x02 }; for (size_t i = 0; i < sizeof(data); i++) { - cbor.writeUnsignedInt(data[i]); + w.writeUnsignedInt(data[i]); } - cbor.endIndefinite(); - assertEqual(cbor.getWriteSize(), size_t{4}); + w.endIndefinite(); + assertEqual(w.getWriteSize(), size_t{4}); cbor::BytesStream bs{b, sizeof(b)}; - cbor::Reader cborReader{bs}; - assertTrue(cborReader.isWellFormed()); - assertEqual(cborReader.getReadSize(), size_t{4}); + cbor::Reader r{bs}; + assertTrue(r.isWellFormed()); + assertEqual(r.getReadSize(), size_t{4}); uint8_t b2[] = { (5 << 5) + 31, 0x01, 0x02, (7 << 5) + 31 }; assertEqual(sizeof(b), sizeof(b2)); for (size_t i = 0; i < sizeof(b2); i++) { assertEqual(b[i], b2[i]); } - assertEqual(cbor.getWriteError(), 0); + assertEqual(w.getWriteError(), 0); }