aboutsummaryrefslogtreecommitdiff
path: root/unittests/Utility
diff options
context:
space:
mode:
Diffstat (limited to 'unittests/Utility')
-rw-r--r--unittests/Utility/CMakeLists.txt5
-rw-r--r--unittests/Utility/StringExtractorTest.cpp406
-rw-r--r--unittests/Utility/TaskPoolTest.cpp62
-rw-r--r--unittests/Utility/UriParserTest.cpp159
4 files changed, 632 insertions, 0 deletions
diff --git a/unittests/Utility/CMakeLists.txt b/unittests/Utility/CMakeLists.txt
new file mode 100644
index 000000000000..30936acce9dc
--- /dev/null
+++ b/unittests/Utility/CMakeLists.txt
@@ -0,0 +1,5 @@
+add_lldb_unittest(UtilityTests
+ StringExtractorTest.cpp
+ TaskPoolTest.cpp
+ UriParserTest.cpp
+ )
diff --git a/unittests/Utility/StringExtractorTest.cpp b/unittests/Utility/StringExtractorTest.cpp
new file mode 100644
index 000000000000..0eb6d1bda8bb
--- /dev/null
+++ b/unittests/Utility/StringExtractorTest.cpp
@@ -0,0 +1,406 @@
+#include <limits.h>
+#include "gtest/gtest.h"
+
+#include "lldb/Utility/StringExtractor.h"
+
+namespace
+{
+ class StringExtractorTest: public ::testing::Test
+ {
+ };
+}
+
+TEST_F (StringExtractorTest, InitEmpty)
+{
+ const char kEmptyString[] = "";
+ StringExtractor ex (kEmptyString);
+
+ ASSERT_EQ (true, ex.IsGood());
+ ASSERT_EQ (0u, ex.GetFilePos());
+ ASSERT_STREQ (kEmptyString, ex.GetStringRef().c_str());
+ ASSERT_EQ (true, ex.Empty());
+ ASSERT_EQ (0u, ex.GetBytesLeft());
+ ASSERT_EQ (nullptr, ex.Peek());
+}
+
+TEST_F (StringExtractorTest, InitMisc)
+{
+ const char kInitMiscString[] = "Hello, StringExtractor!";
+ StringExtractor ex (kInitMiscString);
+
+ ASSERT_EQ (true, ex.IsGood());
+ ASSERT_EQ (0u, ex.GetFilePos());
+ ASSERT_STREQ (kInitMiscString, ex.GetStringRef().c_str());
+ ASSERT_EQ (false, ex.Empty());
+ ASSERT_EQ (sizeof(kInitMiscString)-1, ex.GetBytesLeft());
+ ASSERT_EQ (kInitMiscString[0], *ex.Peek());
+}
+
+TEST_F (StringExtractorTest, DecodeHexU8_Underflow)
+{
+ const char kEmptyString[] = "";
+ StringExtractor ex (kEmptyString);
+
+ ASSERT_EQ (-1, ex.DecodeHexU8());
+ ASSERT_EQ (true, ex.IsGood());
+ ASSERT_EQ (0u, ex.GetFilePos());
+ ASSERT_EQ (true, ex.Empty());
+ ASSERT_EQ (0u, ex.GetBytesLeft());
+ ASSERT_EQ (nullptr, ex.Peek());
+}
+
+TEST_F (StringExtractorTest, DecodeHexU8_Underflow2)
+{
+ const char kEmptyString[] = "1";
+ StringExtractor ex (kEmptyString);
+
+ ASSERT_EQ (-1, ex.DecodeHexU8());
+ ASSERT_EQ (true, ex.IsGood());
+ ASSERT_EQ (0u, ex.GetFilePos());
+ ASSERT_EQ (1u, ex.GetBytesLeft());
+ ASSERT_EQ ('1', *ex.Peek());
+}
+
+TEST_F (StringExtractorTest, DecodeHexU8_InvalidHex)
+{
+ const char kInvalidHex[] = "xa";
+ StringExtractor ex (kInvalidHex);
+
+ ASSERT_EQ (-1, ex.DecodeHexU8());
+ ASSERT_EQ (true, ex.IsGood());
+ ASSERT_EQ (0u, ex.GetFilePos());
+ ASSERT_EQ (2u, ex.GetBytesLeft());
+ ASSERT_EQ ('x', *ex.Peek());
+}
+
+TEST_F (StringExtractorTest, DecodeHexU8_InvalidHex2)
+{
+ const char kInvalidHex[] = "ax";
+ StringExtractor ex (kInvalidHex);
+
+ ASSERT_EQ (-1, ex.DecodeHexU8());
+ ASSERT_EQ (true, ex.IsGood());
+ ASSERT_EQ (0u, ex.GetFilePos());
+ ASSERT_EQ (2u, ex.GetBytesLeft());
+ ASSERT_EQ ('a', *ex.Peek());
+}
+
+TEST_F (StringExtractorTest, DecodeHexU8_Exact)
+{
+ const char kValidHexPair[] = "12";
+ StringExtractor ex (kValidHexPair);
+
+ ASSERT_EQ (0x12, ex.DecodeHexU8());
+ ASSERT_EQ (true, ex.IsGood());
+ ASSERT_EQ (2u, ex.GetFilePos());
+ ASSERT_EQ (0u, ex.GetBytesLeft());
+ ASSERT_EQ (nullptr, ex.Peek());
+}
+
+TEST_F (StringExtractorTest, DecodeHexU8_Extra)
+{
+ const char kValidHexPair[] = "1234";
+ StringExtractor ex (kValidHexPair);
+
+ ASSERT_EQ (0x12, ex.DecodeHexU8());
+ ASSERT_EQ (true, ex.IsGood());
+ ASSERT_EQ (2u, ex.GetFilePos());
+ ASSERT_EQ (2u, ex.GetBytesLeft());
+ ASSERT_EQ ('3', *ex.Peek());
+}
+
+TEST_F (StringExtractorTest, GetHexU8_Underflow)
+{
+ const char kEmptyString[] = "";
+ StringExtractor ex (kEmptyString);
+
+ ASSERT_EQ (0xab, ex.GetHexU8(0xab));
+ ASSERT_EQ (false, ex.IsGood());
+ ASSERT_EQ (UINT64_MAX, ex.GetFilePos());
+ ASSERT_EQ (true, ex.Empty());
+ ASSERT_EQ (0u, ex.GetBytesLeft());
+ ASSERT_EQ (nullptr, ex.Peek());
+}
+
+TEST_F (StringExtractorTest, GetHexU8_Underflow2)
+{
+ const char kOneNibble[] = "1";
+ StringExtractor ex (kOneNibble);
+
+ ASSERT_EQ (0xbc, ex.GetHexU8(0xbc));
+ ASSERT_EQ (false, ex.IsGood());
+ ASSERT_EQ (UINT64_MAX, ex.GetFilePos());
+ ASSERT_EQ (0u, ex.GetBytesLeft());
+ ASSERT_EQ (nullptr, ex.Peek());
+}
+
+TEST_F (StringExtractorTest, GetHexU8_InvalidHex)
+{
+ const char kInvalidHex[] = "xx";
+ StringExtractor ex (kInvalidHex);
+
+ ASSERT_EQ (0xcd, ex.GetHexU8(0xcd));
+ ASSERT_EQ (false, ex.IsGood());
+ ASSERT_EQ (UINT64_MAX, ex.GetFilePos());
+ ASSERT_EQ (0u, ex.GetBytesLeft());
+ ASSERT_EQ (nullptr, ex.Peek());
+}
+
+TEST_F (StringExtractorTest, GetHexU8_Exact)
+{
+ const char kValidHexPair[] = "12";
+ StringExtractor ex (kValidHexPair);
+
+ ASSERT_EQ (0x12, ex.GetHexU8(0x12));
+ ASSERT_EQ (true, ex.IsGood());
+ ASSERT_EQ (2u, ex.GetFilePos());
+ ASSERT_EQ (0u, ex.GetBytesLeft());
+ ASSERT_EQ (nullptr, ex.Peek());
+}
+
+TEST_F (StringExtractorTest, GetHexU8_Extra)
+{
+ const char kValidHexPair[] = "1234";
+ StringExtractor ex (kValidHexPair);
+
+ ASSERT_EQ (0x12, ex.GetHexU8(0x12));
+ ASSERT_EQ (true, ex.IsGood());
+ ASSERT_EQ (2u, ex.GetFilePos());
+ ASSERT_EQ (2u, ex.GetBytesLeft());
+ ASSERT_EQ ('3', *ex.Peek());
+}
+
+TEST_F (StringExtractorTest, GetHexU8_Underflow_NoEof)
+{
+ const char kEmptyString[] = "";
+ StringExtractor ex (kEmptyString);
+ const bool kSetEofOnFail = false;
+
+ ASSERT_EQ (0xab, ex.GetHexU8(0xab, kSetEofOnFail));
+ ASSERT_EQ (false, ex.IsGood()); // this result seems inconsistent with kSetEofOnFail == false
+ ASSERT_EQ (UINT64_MAX, ex.GetFilePos());
+ ASSERT_EQ (true, ex.Empty());
+ ASSERT_EQ (0u, ex.GetBytesLeft());
+ ASSERT_EQ (nullptr, ex.Peek());
+}
+
+TEST_F (StringExtractorTest, GetHexU8_Underflow2_NoEof)
+{
+ const char kOneNibble[] = "1";
+ StringExtractor ex (kOneNibble);
+ const bool kSetEofOnFail = false;
+
+ ASSERT_EQ (0xbc, ex.GetHexU8(0xbc, kSetEofOnFail));
+ ASSERT_EQ (true, ex.IsGood());
+ ASSERT_EQ (0u, ex.GetFilePos());
+ ASSERT_EQ (1u, ex.GetBytesLeft());
+ ASSERT_EQ ('1', *ex.Peek());
+}
+
+TEST_F (StringExtractorTest, GetHexU8_InvalidHex_NoEof)
+{
+ const char kInvalidHex[] = "xx";
+ StringExtractor ex (kInvalidHex);
+ const bool kSetEofOnFail = false;
+
+ ASSERT_EQ (0xcd, ex.GetHexU8(0xcd, kSetEofOnFail));
+ ASSERT_EQ (true, ex.IsGood());
+ ASSERT_EQ (0u, ex.GetFilePos());
+ ASSERT_EQ (2u, ex.GetBytesLeft());
+ ASSERT_EQ ('x', *ex.Peek());
+}
+
+TEST_F (StringExtractorTest, GetHexU8_Exact_NoEof)
+{
+ const char kValidHexPair[] = "12";
+ StringExtractor ex (kValidHexPair);
+ const bool kSetEofOnFail = false;
+
+ ASSERT_EQ (0x12, ex.GetHexU8(0x12, kSetEofOnFail));
+ ASSERT_EQ (true, ex.IsGood());
+ ASSERT_EQ (2u, ex.GetFilePos());
+ ASSERT_EQ (0u, ex.GetBytesLeft());
+ ASSERT_EQ (nullptr, ex.Peek());
+}
+
+TEST_F (StringExtractorTest, GetHexU8_Extra_NoEof)
+{
+ const char kValidHexPair[] = "1234";
+ StringExtractor ex (kValidHexPair);
+ const bool kSetEofOnFail = false;
+
+ ASSERT_EQ (0x12, ex.GetHexU8(0x12, kSetEofOnFail));
+ ASSERT_EQ (true, ex.IsGood());
+ ASSERT_EQ (2u, ex.GetFilePos());
+ ASSERT_EQ (2u, ex.GetBytesLeft());
+ ASSERT_EQ ('3', *ex.Peek());
+}
+
+TEST_F (StringExtractorTest, GetHexBytes)
+{
+ const char kHexEncodedBytes[] = "abcdef0123456789xyzw";
+ const size_t kValidHexPairs = 8;
+ StringExtractor ex(kHexEncodedBytes);
+
+ uint8_t dst[kValidHexPairs];
+ ASSERT_EQ(kValidHexPairs, ex.GetHexBytes (dst, kValidHexPairs, 0xde));
+ EXPECT_EQ(0xab,dst[0]);
+ EXPECT_EQ(0xcd,dst[1]);
+ EXPECT_EQ(0xef,dst[2]);
+ EXPECT_EQ(0x01,dst[3]);
+ EXPECT_EQ(0x23,dst[4]);
+ EXPECT_EQ(0x45,dst[5]);
+ EXPECT_EQ(0x67,dst[6]);
+ EXPECT_EQ(0x89,dst[7]);
+
+ ASSERT_EQ(true, ex.IsGood());
+ ASSERT_EQ(2*kValidHexPairs, ex.GetFilePos());
+ ASSERT_EQ(false, ex.Empty());
+ ASSERT_EQ(4u, ex.GetBytesLeft());
+ ASSERT_EQ('x', *ex.Peek());
+}
+
+TEST_F (StringExtractorTest, GetHexBytes_Underflow)
+{
+ const char kHexEncodedBytes[] = "abcdef0123456789xyzw";
+ const size_t kValidHexPairs = 8;
+ StringExtractor ex(kHexEncodedBytes);
+
+ uint8_t dst[12];
+ ASSERT_EQ(kValidHexPairs, ex.GetHexBytes (dst, sizeof(dst), 0xde));
+ EXPECT_EQ(0xab,dst[0]);
+ EXPECT_EQ(0xcd,dst[1]);
+ EXPECT_EQ(0xef,dst[2]);
+ EXPECT_EQ(0x01,dst[3]);
+ EXPECT_EQ(0x23,dst[4]);
+ EXPECT_EQ(0x45,dst[5]);
+ EXPECT_EQ(0x67,dst[6]);
+ EXPECT_EQ(0x89,dst[7]);
+ // these bytes should be filled with fail_fill_value 0xde
+ EXPECT_EQ(0xde,dst[8]);
+ EXPECT_EQ(0xde,dst[9]);
+ EXPECT_EQ(0xde,dst[10]);
+ EXPECT_EQ(0xde,dst[11]);
+
+ ASSERT_EQ(false, ex.IsGood());
+ ASSERT_EQ(UINT64_MAX, ex.GetFilePos());
+ ASSERT_EQ(false, ex.Empty());
+ ASSERT_EQ(0u, ex.GetBytesLeft());
+ ASSERT_EQ(0, ex.Peek());
+}
+
+TEST_F (StringExtractorTest, GetHexBytes_Partial)
+{
+ const char kHexEncodedBytes[] = "abcdef0123456789xyzw";
+ const size_t kReadBytes = 4;
+ StringExtractor ex(kHexEncodedBytes);
+
+ uint8_t dst[12];
+ memset(dst, 0xab, sizeof(dst));
+ ASSERT_EQ(kReadBytes, ex.GetHexBytes (dst, kReadBytes, 0xde));
+ EXPECT_EQ(0xab,dst[0]);
+ EXPECT_EQ(0xcd,dst[1]);
+ EXPECT_EQ(0xef,dst[2]);
+ EXPECT_EQ(0x01,dst[3]);
+ // these bytes should be unchanged
+ EXPECT_EQ(0xab,dst[4]);
+ EXPECT_EQ(0xab,dst[5]);
+ EXPECT_EQ(0xab,dst[6]);
+ EXPECT_EQ(0xab,dst[7]);
+ EXPECT_EQ(0xab,dst[8]);
+ EXPECT_EQ(0xab,dst[9]);
+ EXPECT_EQ(0xab,dst[10]);
+ EXPECT_EQ(0xab,dst[11]);
+
+ ASSERT_EQ(true, ex.IsGood());
+ ASSERT_EQ(kReadBytes*2, ex.GetFilePos());
+ ASSERT_EQ(false, ex.Empty());
+ ASSERT_EQ(12u, ex.GetBytesLeft());
+ ASSERT_EQ('2', *ex.Peek());
+}
+
+TEST_F (StringExtractorTest, GetHexBytesAvail)
+{
+ const char kHexEncodedBytes[] = "abcdef0123456789xyzw";
+ const size_t kValidHexPairs = 8;
+ StringExtractor ex(kHexEncodedBytes);
+
+ uint8_t dst[kValidHexPairs];
+ ASSERT_EQ(kValidHexPairs, ex.GetHexBytesAvail (dst, kValidHexPairs));
+ EXPECT_EQ(0xab,dst[0]);
+ EXPECT_EQ(0xcd,dst[1]);
+ EXPECT_EQ(0xef,dst[2]);
+ EXPECT_EQ(0x01,dst[3]);
+ EXPECT_EQ(0x23,dst[4]);
+ EXPECT_EQ(0x45,dst[5]);
+ EXPECT_EQ(0x67,dst[6]);
+ EXPECT_EQ(0x89,dst[7]);
+
+ ASSERT_EQ(true, ex.IsGood());
+ ASSERT_EQ(2*kValidHexPairs, ex.GetFilePos());
+ ASSERT_EQ(false, ex.Empty());
+ ASSERT_EQ(4u, ex.GetBytesLeft());
+ ASSERT_EQ('x', *ex.Peek());
+}
+
+TEST_F (StringExtractorTest, GetHexBytesAvail_Underflow)
+{
+ const char kHexEncodedBytes[] = "abcdef0123456789xyzw";
+ const size_t kValidHexPairs = 8;
+ StringExtractor ex(kHexEncodedBytes);
+
+ uint8_t dst[12];
+ memset(dst, 0xef, sizeof(dst));
+ ASSERT_EQ(kValidHexPairs, ex.GetHexBytesAvail (dst, sizeof(dst)));
+ EXPECT_EQ(0xab,dst[0]);
+ EXPECT_EQ(0xcd,dst[1]);
+ EXPECT_EQ(0xef,dst[2]);
+ EXPECT_EQ(0x01,dst[3]);
+ EXPECT_EQ(0x23,dst[4]);
+ EXPECT_EQ(0x45,dst[5]);
+ EXPECT_EQ(0x67,dst[6]);
+ EXPECT_EQ(0x89,dst[7]);
+ // these bytes should be unchanged
+ EXPECT_EQ(0xef,dst[8]);
+ EXPECT_EQ(0xef,dst[9]);
+ EXPECT_EQ(0xef,dst[10]);
+ EXPECT_EQ(0xef,dst[11]);
+
+ ASSERT_EQ(true, ex.IsGood());
+ ASSERT_EQ(kValidHexPairs*2, ex.GetFilePos());
+ ASSERT_EQ(false, ex.Empty());
+ ASSERT_EQ(4u, ex.GetBytesLeft());
+ ASSERT_EQ('x', *ex.Peek());
+}
+
+TEST_F (StringExtractorTest, GetHexBytesAvail_Partial)
+{
+ const char kHexEncodedBytes[] = "abcdef0123456789xyzw";
+ const size_t kReadBytes = 4;
+ StringExtractor ex(kHexEncodedBytes);
+
+ uint8_t dst[12];
+ memset(dst, 0xab, sizeof(dst));
+ ASSERT_EQ(kReadBytes, ex.GetHexBytesAvail (dst, kReadBytes));
+ EXPECT_EQ(0xab,dst[0]);
+ EXPECT_EQ(0xcd,dst[1]);
+ EXPECT_EQ(0xef,dst[2]);
+ EXPECT_EQ(0x01,dst[3]);
+ // these bytes should be unchanged
+ EXPECT_EQ(0xab,dst[4]);
+ EXPECT_EQ(0xab,dst[5]);
+ EXPECT_EQ(0xab,dst[6]);
+ EXPECT_EQ(0xab,dst[7]);
+ EXPECT_EQ(0xab,dst[8]);
+ EXPECT_EQ(0xab,dst[9]);
+ EXPECT_EQ(0xab,dst[10]);
+ EXPECT_EQ(0xab,dst[11]);
+
+ ASSERT_EQ(true, ex.IsGood());
+ ASSERT_EQ(kReadBytes*2, ex.GetFilePos());
+ ASSERT_EQ(false, ex.Empty());
+ ASSERT_EQ(12u, ex.GetBytesLeft());
+ ASSERT_EQ('2', *ex.Peek());
+}
+
+
diff --git a/unittests/Utility/TaskPoolTest.cpp b/unittests/Utility/TaskPoolTest.cpp
new file mode 100644
index 000000000000..24431e2c7896
--- /dev/null
+++ b/unittests/Utility/TaskPoolTest.cpp
@@ -0,0 +1,62 @@
+#include "gtest/gtest.h"
+
+#include "lldb/Utility/TaskPool.h"
+
+TEST (TaskPoolTest, AddTask)
+{
+ auto fn = [](int x) { return x * x + 1; };
+
+ auto f1 = TaskPool::AddTask(fn, 1);
+ auto f2 = TaskPool::AddTask(fn, 2);
+ auto f3 = TaskPool::AddTask(fn, 3);
+ auto f4 = TaskPool::AddTask(fn, 4);
+
+ ASSERT_EQ (10, f3.get());
+ ASSERT_EQ ( 2, f1.get());
+ ASSERT_EQ (17, f4.get());
+ ASSERT_EQ ( 5, f2.get());
+}
+
+TEST (TaskPoolTest, RunTasks)
+{
+ std::vector<int> r(4);
+
+ auto fn = [](int x, int& y) { y = x * x + 1; };
+
+ TaskPool::RunTasks(
+ [fn, &r]() { fn(1, r[0]); },
+ [fn, &r]() { fn(2, r[1]); },
+ [fn, &r]() { fn(3, r[2]); },
+ [fn, &r]() { fn(4, r[3]); }
+ );
+
+ ASSERT_EQ ( 2, r[0]);
+ ASSERT_EQ ( 5, r[1]);
+ ASSERT_EQ (10, r[2]);
+ ASSERT_EQ (17, r[3]);
+}
+
+TEST (TaskPoolTest, TaskRunner)
+{
+ auto fn = [](int x) { return std::make_pair(x, x * x); };
+
+ TaskRunner<std::pair<int, int>> tr;
+ tr.AddTask(fn, 1);
+ tr.AddTask(fn, 2);
+ tr.AddTask(fn, 3);
+ tr.AddTask(fn, 4);
+
+ int count = 0;
+ while (true)
+ {
+ auto f = tr.WaitForNextCompletedTask();
+ if (!f.valid())
+ break;
+
+ ++count;
+ std::pair<int, int> v = f.get();
+ ASSERT_EQ (v.first * v.first, v.second);
+ }
+
+ ASSERT_EQ(4, count);
+}
diff --git a/unittests/Utility/UriParserTest.cpp b/unittests/Utility/UriParserTest.cpp
new file mode 100644
index 000000000000..fe0a6a70f212
--- /dev/null
+++ b/unittests/Utility/UriParserTest.cpp
@@ -0,0 +1,159 @@
+#include "gtest/gtest.h"
+#include "Utility/UriParser.h"
+
+namespace
+{
+ class UriParserTest: public ::testing::Test
+ {
+ };
+}
+
+// result strings (scheme/hostname/port/path) passed into UriParser::Parse
+// are initialized to kAsdf so we can verify that they are unmodified if the
+// URI is invalid
+static const char* kAsdf = "asdf";
+
+class UriTestCase
+{
+public:
+ UriTestCase(const char* uri, const char* scheme, const char* hostname, int port, const char* path) :
+ m_uri(uri),
+ m_result(true),
+ m_scheme(scheme),
+ m_hostname(hostname),
+ m_port(port),
+ m_path(path)
+ {
+ }
+
+ UriTestCase(const char* uri) :
+ m_uri(uri),
+ m_result(false),
+ m_scheme(kAsdf),
+ m_hostname(kAsdf),
+ m_port(1138),
+ m_path(kAsdf)
+ {
+ }
+
+ const char* m_uri;
+ bool m_result;
+ const char* m_scheme;
+ const char* m_hostname;
+ int m_port;
+ const char* m_path;
+};
+
+#define VALIDATE \
+ std::string scheme(kAsdf); \
+ std::string hostname(kAsdf); \
+ int port(1138); \
+ std::string path(kAsdf); \
+ EXPECT_EQ (testCase.m_result, UriParser::Parse(testCase.m_uri, scheme, hostname, port, path)); \
+ EXPECT_STREQ (testCase.m_scheme, scheme.c_str()); \
+ EXPECT_STREQ (testCase.m_hostname, hostname.c_str()); \
+ EXPECT_EQ (testCase.m_port, port); \
+ EXPECT_STREQ (testCase.m_path, path.c_str());
+
+TEST_F (UriParserTest, Minimal)
+{
+ const UriTestCase testCase("x://y", "x", "y", -1, "/");
+ VALIDATE
+}
+
+TEST_F (UriParserTest, MinimalPort)
+{
+ const UriTestCase testCase("x://y:1", "x", "y", 1, "/");
+ VALIDATE
+}
+
+TEST_F (UriParserTest, MinimalPath)
+{
+ const UriTestCase testCase("x://y/", "x", "y", -1, "/");
+ VALIDATE
+}
+
+TEST_F (UriParserTest, MinimalPortPath)
+{
+ const UriTestCase testCase("x://y:1/", "x", "y", 1, "/");
+ VALIDATE
+}
+
+TEST_F (UriParserTest, LongPath)
+{
+ const UriTestCase testCase("x://y/abc/def/xyz", "x", "y", -1, "/abc/def/xyz");
+ VALIDATE
+}
+
+TEST_F (UriParserTest, TypicalPortPath)
+{
+ const UriTestCase testCase("connect://192.168.100.132:5432/", "connect", "192.168.100.132", 5432, "/");
+ VALIDATE
+}
+
+TEST_F (UriParserTest, BracketedHostnamePort)
+{
+ const UriTestCase testCase("connect://[192.168.100.132]:5432/", "connect", "192.168.100.132", 5432, "/");
+ VALIDATE
+}
+
+TEST_F (UriParserTest, BracketedHostname)
+{
+ const UriTestCase testCase("connect://[192.168.100.132]", "connect", "192.168.100.132", -1, "/");
+ VALIDATE
+}
+
+TEST_F (UriParserTest, BracketedHostnameWithColon)
+{
+ const UriTestCase testCase("connect://[192.168.100.132:5555]:1234", "connect", "192.168.100.132:5555", 1234, "/");
+ VALIDATE
+}
+
+TEST_F (UriParserTest, SchemeHostSeparator)
+{
+ const UriTestCase testCase("x:/y");
+ VALIDATE
+}
+
+TEST_F (UriParserTest, SchemeHostSeparator2)
+{
+ const UriTestCase testCase("x:y");
+ VALIDATE
+}
+
+TEST_F (UriParserTest, SchemeHostSeparator3)
+{
+ const UriTestCase testCase("x//y");
+ VALIDATE
+}
+
+TEST_F (UriParserTest, SchemeHostSeparator4)
+{
+ const UriTestCase testCase("x/y");
+ VALIDATE
+}
+
+TEST_F (UriParserTest, BadPort)
+{
+ const UriTestCase testCase("x://y:a/");
+ VALIDATE
+}
+
+TEST_F (UriParserTest, BadPort2)
+{
+ const UriTestCase testCase("x://y:5432a/");
+ VALIDATE
+}
+
+TEST_F (UriParserTest, Empty)
+{
+ const UriTestCase testCase("");
+ VALIDATE
+}
+
+TEST_F (UriParserTest, PortOverflow)
+{
+ const UriTestCase testCase("x://y:0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789/");
+ VALIDATE
+}
+
generated by cgit v1.2.3 (git 2.25.1) at 2025-10-04 22:54:10 +0000