diff options
Diffstat (limited to 'test/u.cc')
| -rw-r--r-- | test/u.cc | 683 |
1 files changed, 683 insertions, 0 deletions
diff --git a/test/u.cc b/test/u.cc new file mode 100644 index 0000000..933a4f2 --- /dev/null +++ b/test/u.cc @@ -0,0 +1,683 @@ +#include <gtest/gtest.h> + +#include "u8.hh" +#include "umod8.hh" +#include "u16.hh" + +#include <vector> + +TEST(u8, empty) { + std::vector<uint8_t> empty; + auto it = empty.begin(); + auto ret = u8::read(it, empty.end()); + ASSERT_FALSE(ret.has_value()); + EXPECT_EQ(u::ReadError::End, ret.error()); + + auto ret_replace = u8::read_replace(it, empty.end()); + ASSERT_FALSE(ret_replace.has_value()); + EXPECT_EQ(u::ReadErrorReplace::End, ret_replace.error()); + + EXPECT_FALSE(u8::write(it, empty.end(), 0x40)); + + EXPECT_FALSE(u8::skip(it, empty.end())); +} + +TEST(u8, examples) { + { + std::vector<uint8_t> literal{0x57}; + auto it = literal.begin(); + auto ret = u8::read(it, literal.end()); + ASSERT_TRUE(ret.has_value()); + EXPECT_EQ(0x57, *ret); + EXPECT_EQ(it, literal.end()); + + it = literal.begin(); + EXPECT_TRUE(u8::skip(it, literal.end())); + EXPECT_EQ(it, literal.end()); + } + { + std::vector<uint8_t> literal{0xce, 0x92}; + auto it = literal.begin(); + auto ret = u8::read(it, literal.end()); + ASSERT_TRUE(ret.has_value()); + EXPECT_EQ(0x392, *ret); + EXPECT_EQ(it, literal.end()); + + it = literal.begin(); + EXPECT_TRUE(u8::skip(it, literal.end())); + EXPECT_EQ(it, literal.end()); + } + { + std::vector<uint8_t> literal{0xec, 0x9c, 0x84}; + auto it = literal.begin(); + auto ret = u8::read(it, literal.end()); + ASSERT_TRUE(ret.has_value()); + EXPECT_EQ(0xc704, *ret); + EXPECT_EQ(it, literal.end()); + + it = literal.begin(); + EXPECT_TRUE(u8::skip(it, literal.end())); + EXPECT_EQ(it, literal.end()); + } + { + std::vector<uint8_t> literal{0xf0, 0x90, 0x8d, 0x85}; + auto it = literal.begin(); + auto ret = u8::read(it, literal.end()); + ASSERT_TRUE(ret.has_value()); + EXPECT_EQ(0x10345, *ret); + EXPECT_EQ(it, literal.end()); + + it = literal.begin(); + auto ret_replace = u8::read_replace(it, literal.end()); + ASSERT_TRUE(ret_replace.has_value()); + EXPECT_EQ(0x10345, *ret_replace); + EXPECT_EQ(it, literal.end()); + + it = literal.begin(); + EXPECT_TRUE(u8::skip(it, literal.end())); + EXPECT_EQ(it, literal.end()); + } + { + std::vector<uint8_t> literal(1, 0x0); + auto it = literal.begin(); + EXPECT_TRUE(u8::write(it, literal.end(), 0x57)); + EXPECT_EQ(0x57, literal[0]); + EXPECT_EQ(it, literal.end()); + } + { + std::vector<uint8_t> literal(2, 0x0); + auto it = literal.begin(); + EXPECT_TRUE(u8::write(it, literal.end(), 0x392)); + EXPECT_EQ(0xce, literal[0]); + EXPECT_EQ(0x92, literal[1]); + EXPECT_EQ(it, literal.end()); + } + { + std::vector<uint8_t> literal(3, 0x0); + auto it = literal.begin(); + EXPECT_TRUE(u8::write(it, literal.end(), 0xc704)); + EXPECT_EQ(0xec, literal[0]); + EXPECT_EQ(0x9c, literal[1]); + EXPECT_EQ(0x84, literal[2]); + EXPECT_EQ(it, literal.end()); + } + { + std::vector<uint8_t> literal(4, 0x0); + auto it = literal.begin(); + EXPECT_TRUE(u8::write(it, literal.end(), 0x10345)); + EXPECT_EQ(0xf0, literal[0]); + EXPECT_EQ(0x90, literal[1]); + EXPECT_EQ(0x8d, literal[2]); + EXPECT_EQ(0x85, literal[3]); + EXPECT_EQ(it, literal.end()); + } +} + +TEST(u8, overlong) { + { + std::vector<uint8_t> literal{0xc0, 0x80}; + auto it = literal.begin(); + auto ret = u8::read(it, literal.end()); + ASSERT_FALSE(ret.has_value()); + EXPECT_EQ(u::ReadError::Invalid, ret.error()); + } +} + +TEST(u8, incomplete) { + { + std::vector<uint8_t> literal{0xce}; + auto it = literal.begin(); + auto ret = u8::read(it, literal.end()); + ASSERT_FALSE(ret.has_value()); + EXPECT_EQ(u::ReadError::Incomplete, ret.error()); + } + { + std::vector<uint8_t> literal{0xec}; + auto it = literal.begin(); + auto ret = u8::read(it, literal.end()); + ASSERT_FALSE(ret.has_value()); + EXPECT_EQ(u::ReadError::Incomplete, ret.error()); + } + { + std::vector<uint8_t> literal{0xec, 0x9c}; + auto it = literal.begin(); + auto ret = u8::read(it, literal.end()); + ASSERT_FALSE(ret.has_value()); + EXPECT_EQ(u::ReadError::Incomplete, ret.error()); + + it = literal.begin(); + auto ret_replace = u8::read_replace(it, literal.end()); + ASSERT_FALSE(ret_replace.has_value()); + EXPECT_EQ(u::ReadErrorReplace::Incomplete, ret_replace.error()); + } + { + std::vector<uint8_t> literal{0xf0}; + auto it = literal.begin(); + auto ret = u8::read(it, literal.end()); + ASSERT_FALSE(ret.has_value()); + EXPECT_EQ(u::ReadError::Incomplete, ret.error()); + } + { + std::vector<uint8_t> literal{0xf0, 0x90}; + auto it = literal.begin(); + auto ret = u8::read(it, literal.end()); + ASSERT_FALSE(ret.has_value()); + EXPECT_EQ(u::ReadError::Incomplete, ret.error()); + } + { + std::vector<uint8_t> literal{0xf0, 0x90, 0x8d}; + auto it = literal.begin(); + auto ret = u8::read(it, literal.end()); + ASSERT_FALSE(ret.has_value()); + EXPECT_EQ(u::ReadError::Incomplete, ret.error()); + } +} + +TEST(u8, invalid) { + { + std::vector<uint8_t> literal{0xf0, 0xf0, 0xf0, 0xf0}; + auto it = literal.begin(); + auto ret = u8::read(it, literal.end()); + ASSERT_FALSE(ret.has_value()); + EXPECT_EQ(u::ReadError::Invalid, ret.error()); + it = literal.begin(); + auto ret_replace = u8::read_replace(it, literal.end()); + ASSERT_TRUE(ret_replace.has_value()); + EXPECT_EQ(0xfffd, *ret_replace); + EXPECT_EQ(it, literal.end()); + } + { + std::vector<uint8_t> literal{0xa0}; + auto it = literal.begin(); + auto ret = u8::read(it, literal.end()); + ASSERT_FALSE(ret.has_value()); + EXPECT_EQ(u::ReadError::Invalid, ret.error()); + it = literal.begin(); + auto ret_replace = u8::read_replace(it, literal.end()); + ASSERT_TRUE(ret_replace.has_value()); + EXPECT_EQ(0xfffd, *ret_replace); + EXPECT_EQ(it, literal.end()); + } + { + std::vector<uint8_t> literal{0xce, 0xff}; + auto it = literal.begin(); + auto ret = u8::read(it, literal.end()); + ASSERT_FALSE(ret.has_value()); + EXPECT_EQ(u::ReadError::Invalid, ret.error()); + it = literal.begin(); + auto ret_replace = u8::read_replace(it, literal.end()); + ASSERT_TRUE(ret_replace.has_value()); + EXPECT_EQ(0xfffd, *ret_replace); + EXPECT_EQ(it, literal.end()); + } + { + std::vector<uint8_t> literal{0xec, 0xff, 0x84}; + auto it = literal.begin(); + auto ret = u8::read(it, literal.end()); + ASSERT_FALSE(ret.has_value()); + EXPECT_EQ(u::ReadError::Invalid, ret.error()); + it = literal.begin(); + auto ret_replace = u8::read_replace(it, literal.end()); + ASSERT_TRUE(ret_replace.has_value()); + EXPECT_EQ(0xfffd, *ret_replace); + EXPECT_EQ(it, literal.end()); + } + { + std::vector<uint8_t> literal{0xec, 0x9c, 0xff}; + auto it = literal.begin(); + auto ret = u8::read(it, literal.end()); + ASSERT_FALSE(ret.has_value()); + EXPECT_EQ(u::ReadError::Invalid, ret.error()); + it = literal.begin(); + auto ret_replace = u8::read_replace(it, literal.end()); + ASSERT_TRUE(ret_replace.has_value()); + EXPECT_EQ(0xfffd, *ret_replace); + EXPECT_EQ(it, literal.end()); + } + { + std::vector<uint8_t> literal{0xf0, 0xff, 0x8d, 0x85}; + auto it = literal.begin(); + auto ret = u8::read(it, literal.end()); + ASSERT_FALSE(ret.has_value()); + EXPECT_EQ(u::ReadError::Invalid, ret.error()); + it = literal.begin(); + auto ret_replace = u8::read_replace(it, literal.end()); + ASSERT_TRUE(ret_replace.has_value()); + EXPECT_EQ(0xfffd, *ret_replace); + EXPECT_EQ(it, literal.end()); + } + { + std::vector<uint8_t> literal{0xf0, 0x90, 0xff, 0x85}; + auto it = literal.begin(); + auto ret = u8::read(it, literal.end()); + ASSERT_FALSE(ret.has_value()); + EXPECT_EQ(u::ReadError::Invalid, ret.error()); + it = literal.begin(); + auto ret_replace = u8::read_replace(it, literal.end()); + ASSERT_TRUE(ret_replace.has_value()); + EXPECT_EQ(0xfffd, *ret_replace); + EXPECT_EQ(it, literal.end()); + } + { + std::vector<uint8_t> literal{0xf0, 0x90, 0x8d, 0xff}; + auto it = literal.begin(); + auto ret = u8::read(it, literal.end()); + ASSERT_FALSE(ret.has_value()); + EXPECT_EQ(u::ReadError::Invalid, ret.error()); + it = literal.begin(); + auto ret_replace = u8::read_replace(it, literal.end()); + ASSERT_TRUE(ret_replace.has_value()); + EXPECT_EQ(0xfffd, *ret_replace); + EXPECT_EQ(it, literal.end()); + } +} + +TEST(umod8, empty) { + std::vector<uint8_t> empty; + auto it = empty.begin(); + auto ret = umod8::read(it, empty.end()); + ASSERT_FALSE(ret.has_value()); + EXPECT_EQ(u::ReadError::End, ret.error()); + + auto ret_replace = umod8::read_replace(it, empty.end()); + ASSERT_FALSE(ret_replace.has_value()); + EXPECT_EQ(u::ReadErrorReplace::End, ret_replace.error()); + + EXPECT_FALSE(umod8::write(it, empty.end(), 0x40)); + + EXPECT_FALSE(umod8::skip(it, empty.end())); +} + +TEST(umod8, examples) { + { + std::vector<uint8_t> literal{0x45}; + auto it = literal.begin(); + auto ret = umod8::read(it, literal.end()); + ASSERT_TRUE(ret.has_value()); + EXPECT_EQ(0x45, *ret); + EXPECT_EQ(it, literal.end()); + + it = literal.begin(); + EXPECT_TRUE(umod8::skip(it, literal.end())); + EXPECT_EQ(it, literal.end()); + } + { + std::vector<uint8_t> literal{0xc8, 0x85}; + auto it = literal.begin(); + auto ret = umod8::read(it, literal.end()); + ASSERT_TRUE(ret.has_value()); + EXPECT_EQ(0x205, *ret); + EXPECT_EQ(it, literal.end()); + + it = literal.begin(); + EXPECT_TRUE(umod8::skip(it, literal.end())); + EXPECT_EQ(it, literal.end()); + } + { + std::vector<uint8_t> literal{0xed, 0xa0, 0x81, 0xed, 0xb0, 0x80}; + auto it = literal.begin(); + auto ret = umod8::read(it, literal.end()); + ASSERT_TRUE(ret.has_value()); + EXPECT_EQ(0x10400, *ret); + EXPECT_EQ(it, literal.end()); + + it = literal.begin(); + auto ret_replace = umod8::read_replace(it, literal.end()); + ASSERT_TRUE(ret_replace.has_value()); + EXPECT_EQ(0x10400, *ret_replace); + EXPECT_EQ(it, literal.end()); + + it = literal.begin(); + EXPECT_TRUE(umod8::skip(it, literal.end())); + EXPECT_EQ(it, literal.end()); + } + { + std::vector<uint8_t> literal{0xc0, 0x80}; + auto it = literal.begin(); + auto ret = umod8::read(it, literal.end()); + ASSERT_TRUE(ret.has_value()); + EXPECT_EQ(0, *ret); + EXPECT_EQ(it, literal.end()); + } + { + std::vector<uint8_t> literal(1, 0x0); + auto it = literal.begin(); + EXPECT_TRUE(umod8::write(it, literal.end(), 0x45)); + EXPECT_EQ(0x45, literal[0]); + EXPECT_EQ(it, literal.end()); + } + { + std::vector<uint8_t> literal(2, 0x0); + auto it = literal.begin(); + EXPECT_TRUE(umod8::write(it, literal.end(), 0x205)); + EXPECT_EQ(0xc8, literal[0]); + EXPECT_EQ(0x85, literal[1]); + EXPECT_EQ(it, literal.end()); + } + { + std::vector<uint8_t> literal(6, 0x0); + auto it = literal.begin(); + EXPECT_TRUE(umod8::write(it, literal.end(), 0x10400)); + EXPECT_EQ(0xed, literal[0]); + EXPECT_EQ(0xa0, literal[1]); + EXPECT_EQ(0x81, literal[2]); + EXPECT_EQ(0xed, literal[3]); + EXPECT_EQ(0xb0, literal[4]); + EXPECT_EQ(0x80, literal[5]); + EXPECT_EQ(it, literal.end()); + } + { + std::vector<uint8_t> literal(2, 0x0); + auto it = literal.begin(); + EXPECT_TRUE(umod8::write(it, literal.end(), 0x0)); + EXPECT_EQ(0xc0, literal[0]); + EXPECT_EQ(0x80, literal[1]); + EXPECT_EQ(it, literal.end()); + } +} + +TEST(umod8, overlong) { +} + +TEST(umod8, incomplete) { + { + std::vector<uint8_t> literal{0xc8}; + auto it = literal.begin(); + auto ret = umod8::read(it, literal.end()); + ASSERT_FALSE(ret.has_value()); + EXPECT_EQ(u::ReadError::Incomplete, ret.error()); + } + { + std::vector<uint8_t> literal{0xed}; + auto it = literal.begin(); + auto ret = umod8::read(it, literal.end()); + ASSERT_FALSE(ret.has_value()); + EXPECT_EQ(u::ReadError::Incomplete, ret.error()); + } + { + std::vector<uint8_t> literal{0xed, 0xa0}; + auto it = literal.begin(); + auto ret = umod8::read(it, literal.end()); + ASSERT_FALSE(ret.has_value()); + EXPECT_EQ(u::ReadError::Incomplete, ret.error()); + } + { + std::vector<uint8_t> literal{0xed, 0xa0, 0x81, 0xed}; + auto it = literal.begin(); + auto ret = umod8::read(it, literal.end()); + ASSERT_FALSE(ret.has_value()); + EXPECT_EQ(u::ReadError::Incomplete, ret.error()); + + it = literal.begin(); + auto ret_replace = umod8::read_replace(it, literal.end()); + ASSERT_FALSE(ret_replace.has_value()); + EXPECT_EQ(u::ReadErrorReplace::Incomplete, ret_replace.error()); + } + { + std::vector<uint8_t> literal{0xed, 0xa0, 0x81, 0xed, 0xb0}; + auto it = literal.begin(); + auto ret = umod8::read(it, literal.end()); + ASSERT_FALSE(ret.has_value()); + EXPECT_EQ(u::ReadError::Incomplete, ret.error()); + } +} + +TEST(umod8, invalid) { + { + std::vector<uint8_t> literal{0xf0, 0xf0, 0xf0, 0xf0}; + auto it = literal.begin(); + auto ret = umod8::read(it, literal.end()); + ASSERT_FALSE(ret.has_value()); + EXPECT_EQ(u::ReadError::Invalid, ret.error()); + it = literal.begin(); + auto ret_replace = umod8::read_replace(it, literal.end()); + ASSERT_TRUE(ret_replace.has_value()); + EXPECT_EQ(0xfffd, *ret_replace); + EXPECT_EQ(3, literal.end() - it); + } + { + std::vector<uint8_t> literal{0xa0}; + auto it = literal.begin(); + auto ret = umod8::read(it, literal.end()); + ASSERT_FALSE(ret.has_value()); + EXPECT_EQ(u::ReadError::Invalid, ret.error()); + it = literal.begin(); + auto ret_replace = umod8::read_replace(it, literal.end()); + ASSERT_TRUE(ret_replace.has_value()); + EXPECT_EQ(0xfffd, *ret_replace); + EXPECT_EQ(it, literal.end()); + } + { + std::vector<uint8_t> literal{0xce, 0xff}; + auto it = literal.begin(); + auto ret = umod8::read(it, literal.end()); + ASSERT_FALSE(ret.has_value()); + EXPECT_EQ(u::ReadError::Invalid, ret.error()); + it = literal.begin(); + auto ret_replace = umod8::read_replace(it, literal.end()); + ASSERT_TRUE(ret_replace.has_value()); + EXPECT_EQ(0xfffd, *ret_replace); + EXPECT_EQ(it, literal.end()); + } + { + std::vector<uint8_t> literal{0xec, 0xff, 0x84}; + auto it = literal.begin(); + auto ret = umod8::read(it, literal.end()); + ASSERT_FALSE(ret.has_value()); + EXPECT_EQ(u::ReadError::Invalid, ret.error()); + it = literal.begin(); + auto ret_replace = umod8::read_replace(it, literal.end()); + ASSERT_TRUE(ret_replace.has_value()); + EXPECT_EQ(0xfffd, *ret_replace); + EXPECT_EQ(it, literal.end()); + } + { + std::vector<uint8_t> literal{0xec, 0x9c, 0xff}; + auto it = literal.begin(); + auto ret = umod8::read(it, literal.end()); + ASSERT_FALSE(ret.has_value()); + EXPECT_EQ(u::ReadError::Invalid, ret.error()); + it = literal.begin(); + auto ret_replace = umod8::read_replace(it, literal.end()); + ASSERT_TRUE(ret_replace.has_value()); + EXPECT_EQ(0xfffd, *ret_replace); + EXPECT_EQ(it, literal.end()); + } + { + std::vector<uint8_t> literal{0xed, 0xb0, 0x80, 0xed, 0xa0, 0x81}; + auto it = literal.begin(); + auto ret = umod8::read(it, literal.end()); + ASSERT_FALSE(ret.has_value()); + EXPECT_EQ(u::ReadError::Invalid, ret.error()); + EXPECT_EQ(3, literal.end() - it); + } + { + std::vector<uint8_t> literal{0xed, 0xa0, 0x81}; + auto it = literal.begin(); + auto ret = umod8::read(it, literal.end()); + ASSERT_FALSE(ret.has_value()); + EXPECT_EQ(u::ReadError::Invalid, ret.error()); + EXPECT_EQ(it, literal.end()); + } + { + std::vector<uint8_t> literal{0xed, 0xa0, 0x81, 0xed, 0xff, 0x80}; + auto it = literal.begin(); + auto ret = umod8::read(it, literal.end()); + ASSERT_FALSE(ret.has_value()); + EXPECT_EQ(u::ReadError::Invalid, ret.error()); + EXPECT_EQ(3, literal.end() - it); + } + { + std::vector<uint8_t> literal{0xed, 0xa0, 0x81, 0xed, 0xb0, 0xff}; + auto it = literal.begin(); + auto ret = umod8::read(it, literal.end()); + ASSERT_FALSE(ret.has_value()); + EXPECT_EQ(u::ReadError::Invalid, ret.error()); + EXPECT_EQ(3, literal.end() - it); + } +} + +TEST(u16, empty) { + std::vector<uint16_t> empty; + auto it = empty.begin(); + auto ret = u16::read(it, empty.end()); + ASSERT_FALSE(ret.has_value()); + EXPECT_EQ(u::ReadError::End, ret.error()); + + auto ret_replace = u16::read_replace(it, empty.end()); + ASSERT_FALSE(ret_replace.has_value()); + EXPECT_EQ(u::ReadErrorReplace::End, ret_replace.error()); + + EXPECT_FALSE(u16::write(it, empty.end(), 0x40)); + + EXPECT_FALSE(u16::skip(it, empty.end())); +} + +TEST(u16, examples) { + { + std::vector<uint16_t> literal{0x24}; + auto it = literal.begin(); + auto ret = u16::read(it, literal.end()); + ASSERT_TRUE(ret.has_value()); + EXPECT_EQ(0x24, *ret); + EXPECT_EQ(it, literal.end()); + + it = literal.begin(); + EXPECT_TRUE(u16::skip(it, literal.end())); + EXPECT_EQ(it, literal.end()); + } + { + std::vector<uint16_t> literal{0x20ac}; + auto it = literal.begin(); + auto ret = u16::read(it, literal.end()); + ASSERT_TRUE(ret.has_value()); + EXPECT_EQ(0x20ac, *ret); + EXPECT_EQ(it, literal.end()); + + it = literal.begin(); + EXPECT_TRUE(u16::skip(it, literal.end())); + EXPECT_EQ(it, literal.end()); + } + { + std::vector<uint16_t> literal{0xd801, 0xdc37}; + auto it = literal.begin(); + auto ret = u16::read(it, literal.end()); + ASSERT_TRUE(ret.has_value()); + EXPECT_EQ(0x10437, *ret); + EXPECT_EQ(it, literal.end()); + + it = literal.begin(); + EXPECT_TRUE(u16::skip(it, literal.end())); + EXPECT_EQ(it, literal.end()); + } + { + std::vector<uint16_t> literal{0xd852, 0xdf62}; + auto it = literal.begin(); + auto ret = u16::read(it, literal.end()); + ASSERT_TRUE(ret.has_value()); + EXPECT_EQ(0x24b62, *ret); + EXPECT_EQ(it, literal.end()); + + it = literal.begin(); + auto ret_replace = u16::read_replace(it, literal.end()); + ASSERT_TRUE(ret_replace.has_value()); + EXPECT_EQ(0x24b62, *ret_replace); + EXPECT_EQ(it, literal.end()); + + it = literal.begin(); + EXPECT_TRUE(u16::skip(it, literal.end())); + EXPECT_EQ(it, literal.end()); + } + { + std::vector<uint16_t> literal(1, 0x0); + auto it = literal.begin(); + EXPECT_TRUE(u16::write(it, literal.end(), 0x24)); + EXPECT_EQ(0x24, literal[0]); + EXPECT_EQ(it, literal.end()); + } + { + std::vector<uint16_t> literal(1, 0x0); + auto it = literal.begin(); + EXPECT_TRUE(u16::write(it, literal.end(), 0x20ac)); + EXPECT_EQ(0x20ac, literal[0]); + EXPECT_EQ(it, literal.end()); + } + { + std::vector<uint16_t> literal(2, 0x0); + auto it = literal.begin(); + EXPECT_TRUE(u16::write(it, literal.end(), 0x10437)); + EXPECT_EQ(0xd801, literal[0]); + EXPECT_EQ(0xdc37, literal[1]); + EXPECT_EQ(it, literal.end()); + } + { + std::vector<uint16_t> literal(2, 0x0); + auto it = literal.begin(); + EXPECT_TRUE(u16::write(it, literal.end(), 0x24b62)); + EXPECT_EQ(0xd852, literal[0]); + EXPECT_EQ(0xdf62, literal[1]); + EXPECT_EQ(it, literal.end()); + } +} + +TEST(u16, incomplete) { + { + std::vector<uint16_t> literal{0xd801}; + auto it = literal.begin(); + auto ret = u16::read(it, literal.end()); + ASSERT_FALSE(ret.has_value()); + EXPECT_EQ(u::ReadError::Incomplete, ret.error()); + } + { + std::vector<uint16_t> literal{0xd852}; + auto it = literal.begin(); + auto ret = u16::read(it, literal.end()); + ASSERT_FALSE(ret.has_value()); + EXPECT_EQ(u::ReadError::Incomplete, ret.error()); + } +} + +TEST(u16, invalid) { + { + std::vector<uint16_t> literal{0xdc37, 0xd801}; + auto it = literal.begin(); + auto ret = u16::read(it, literal.end()); + ASSERT_FALSE(ret.has_value()); + EXPECT_EQ(u::ReadError::Invalid, ret.error()); + it = literal.begin(); + auto ret_replace = u16::read_replace(it, literal.end()); + ASSERT_TRUE(ret_replace.has_value()); + EXPECT_EQ(0xfffd, *ret_replace); + EXPECT_NE(it, literal.end()); + ret_replace = u16::read_replace(it, literal.end()); + ASSERT_FALSE(ret_replace.has_value()); + EXPECT_EQ(u::ReadErrorReplace::Incomplete, ret_replace.error()); + } + { + std::vector<uint16_t> literal{0xd852, 0xd852}; + auto it = literal.begin(); + auto ret = u16::read(it, literal.end()); + ASSERT_FALSE(ret.has_value()); + EXPECT_EQ(u::ReadError::Invalid, ret.error()); + it = literal.begin(); + auto ret_replace = u16::read_replace(it, literal.end()); + ASSERT_TRUE(ret_replace.has_value()); + EXPECT_EQ(0xfffd, *ret_replace); + EXPECT_NE(it, literal.end()); + ret_replace = u16::read_replace(it, literal.end()); + ASSERT_FALSE(ret_replace.has_value()); + EXPECT_EQ(u::ReadErrorReplace::Incomplete, ret_replace.error()); + } + { + std::vector<uint16_t> literal{0xdc37, 0xdf62}; + auto it = literal.begin(); + auto ret_replace = u16::read_replace(it, literal.end()); + ASSERT_TRUE(ret_replace.has_value()); + EXPECT_EQ(0xfffd, *ret_replace); + EXPECT_NE(it, literal.end()); + ret_replace = u16::read_replace(it, literal.end()); + ASSERT_TRUE(ret_replace.has_value()); + EXPECT_EQ(0xfffd, *ret_replace); + EXPECT_EQ(it, literal.end()); + } +} |