From 0513cdd9511423ea97b12378035bb562316a7626 Mon Sep 17 00:00:00 2001
From: Joel Klinghed <the_jk@spawned.biz>
Date: Thu, 23 Oct 2025 00:20:56 +0200
Subject: uri & u8: Improve unit test coverage

---
 test/u8.cc | 276 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 276 insertions(+)
 create mode 100644 test/u8.cc

(limited to 'test/u8.cc')

diff --git a/test/u8.cc b/test/u8.cc
new file mode 100644
index 0000000..4378d9c
--- /dev/null
+++ b/test/u8.cc
@@ -0,0 +1,276 @@
+#include "u8.hh"
+
+#include <gtest/gtest.h>
+#include <iterator>
+#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(), false);
+  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(), false);
+    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(), false);
+    ASSERT_FALSE(ret_replace.has_value());
+    EXPECT_EQ(u::ReadErrorReplace::Incomplete, ret_replace.error());
+
+    it = literal.begin();
+    ret_replace = u8::read_replace(it, literal.end(), true);
+    ASSERT_TRUE(ret_replace.has_value());
+    EXPECT_EQ(0xfffd, ret_replace.value());
+  }
+  {
+    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(), false);
+    ASSERT_TRUE(ret_replace.has_value());
+    EXPECT_EQ(0xfffd, *ret_replace);
+    EXPECT_EQ(it, std::next(literal.begin()));
+  }
+  {
+    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(), false);
+    ASSERT_TRUE(ret_replace.has_value());
+    EXPECT_EQ(0xfffd, *ret_replace);
+    EXPECT_EQ(it, std::next(literal.begin()));
+  }
+  {
+    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(), false);
+    ASSERT_TRUE(ret_replace.has_value());
+    EXPECT_EQ(0xfffd, *ret_replace);
+    EXPECT_EQ(it, std::next(literal.begin()));
+  }
+  {
+    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(), false);
+    ASSERT_TRUE(ret_replace.has_value());
+    EXPECT_EQ(0xfffd, *ret_replace);
+    EXPECT_EQ(it, std::next(literal.begin()));
+  }
+  {
+    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(), false);
+    ASSERT_TRUE(ret_replace.has_value());
+    EXPECT_EQ(0xfffd, *ret_replace);
+    EXPECT_EQ(it, std::next(literal.begin()));
+  }
+  {
+    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(), false);
+    ASSERT_TRUE(ret_replace.has_value());
+    EXPECT_EQ(0xfffd, *ret_replace);
+    EXPECT_EQ(it, std::next(literal.begin()));
+  }
+  {
+    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(), false);
+    ASSERT_TRUE(ret_replace.has_value());
+    EXPECT_EQ(0xfffd, *ret_replace);
+    EXPECT_EQ(it, std::next(literal.begin()));
+  }
+  {
+    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(), false);
+    ASSERT_TRUE(ret_replace.has_value());
+    EXPECT_EQ(0xfffd, *ret_replace);
+    EXPECT_EQ(it, std::next(literal.begin()));
+  }
+}
-- 
cgit v1.2.3-70-g09d2