drinkingtea/nostalgia
2
0
Fork 0
Code Issues 4 Pull Requests Actions Releases 13 Activity

[ox] Remove oxExpect macro
All checks were successful
Build / build (push) Successful in 1m9s
Details

Browse Source
This commit is contained in:
Gary Talent
2026-01-25 21:52:26 -06:00
parent 9ce4d3f8c7
commit 07688a2c29
5 changed files with 160 additions and 161 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
deps/ox/src/ox/claw/test/tests.cpp vendored
View File

@@ -135,7 +135,7 @@ static std::map<ox::StringView, ox::Error(*)()> tests = {
constexpr auto hdr = ox::StringLiteral("M2;com.drinkingtea.ox.claw.test.Header2;3;awefawf"); constexpr auto hdr = ox::StringLiteral("M2;com.drinkingtea.ox.claw.test.Header2;3;awefawf");
constexpr auto expected = ox::StringLiteral("com.drinkingtea.ox.claw.test.Header2;3"); constexpr auto expected = ox::StringLiteral("com.drinkingtea.ox.claw.test.Header2;3");
OX_REQUIRE(actual, ox::readClawTypeId({hdr.data(), hdr.size() + 1})); OX_REQUIRE(actual, ox::readClawTypeId({hdr.data(), hdr.size() + 1}));
oxExpect(actual, expected); ox::expect(actual, expected);
return ox::Error{}; return ox::Error{};
} }
}, },

4
deps/ox/src/ox/fs/test/tests.cpp vendored
View File

@@ -74,9 +74,9 @@ const std::map<ox::StringView, std::function<ox::Error(ox::StringView)>> tests =
ox::PathIterator it(path); ox::PathIterator it(path);
ox::StringView buff; ox::StringView buff;
oxAssert(it.next(buff), "PathIterator::next returned error"); oxAssert(it.next(buff), "PathIterator::next returned error");
oxExpect(buff, "usr"); ox::expect(buff, "usr");
oxAssert(it.next(buff), "PathIterator::next returned error"); oxAssert(it.next(buff), "PathIterator::next returned error");
oxExpect(buff, "share"); ox::expect(buff, "share");
return ox::Error(0); return ox::Error(0);
} }
}, },

2
deps/ox/src/ox/mc/test/tests.cpp vendored
View File

@@ -157,7 +157,7 @@ std::map<ox::StringView, ox::Error(*)()> tests = {
oxAssert(testIn.Int8 == testOut.Int8, "Int8 value mismatch"); oxAssert(testIn.Int8 == testOut.Int8, "Int8 value mismatch");
oxAssert(testIn.Union.Int == testOut.Union.Int, "Union.Int value mismatch"); oxAssert(testIn.Union.Int == testOut.Union.Int, "Union.Int value mismatch");
oxAssert(testIn.String == testOut.String, "String value mismatch"); oxAssert(testIn.String == testOut.String, "String value mismatch");
oxExpect(testIn.IString, testOut.IString); ox::expect(testIn.IString, testOut.IString);
oxAssert(testIn.List[0] == testOut.List[0], "List[0] value mismatch"); oxAssert(testIn.List[0] == testOut.List[0], "List[0] value mismatch");
oxAssert(testIn.List[1] == testOut.List[1], "List[1] value mismatch"); oxAssert(testIn.List[1] == testOut.List[1], "List[1] value mismatch");
oxAssert(testIn.List[2] == testOut.List[2], "List[2] value mismatch"); oxAssert(testIn.List[2] == testOut.List[2], "List[2] value mismatch");

2
deps/ox/src/ox/std/def.hpp vendored
View File

@@ -58,8 +58,6 @@ constexpr void oxAssert(bool, const char*) noexcept {}
constexpr void oxAssert(const ox::Error&, const char*) noexcept {} constexpr void oxAssert(const ox::Error&, const char*) noexcept {}
#endif #endif
#define oxExpect(actual, expected) ox::expect(actual, expected)
// Alloca // Alloca
#if defined(_MSC_VER) #if defined(_MSC_VER)

305
deps/ox/src/ox/std/test/tests.cpp vendored
View File

@@ -30,7 +30,7 @@ static uint64_t steadyNowMs() {
} }
template<typename Map = ox::SmallMap<ox::String, ox::UUID>> template<typename Map = ox::SmallMap<ox::String, ox::UUID>>
uint64_t timeMapStrToUuid(int elemCnt, int lookups, uint64_t seed = 4321) noexcept { uint64_t timeMapStrToUuid(int const elemCnt, int const lookups, uint64_t seed = 4321) noexcept {
ox::UUID::seedGenerator({1234, seed}); ox::UUID::seedGenerator({1234, seed});
Map map; Map map;
// setup test map // setup test map
@@ -45,13 +45,14 @@ uint64_t timeMapStrToUuid(int elemCnt, int lookups, uint64_t seed = 4321) noexce
for (int i = 0; i < lookups; ++i) { for (int i = 0; i < lookups; ++i) {
auto const &k = keys[rand.gen() % keys.size()]; auto const &k = keys[rand.gen() % keys.size()];
map[k]; map[k];
oxExpect(map[k], ox::UUID::fromString(k).unwrap()); ox::expect(map[k], ox::UUID::fromString(k).unwrap());
} }
return steadyNowMs() - startTime; return steadyNowMs() - startTime;
} }
template<typename Map = ox::SmallMap<ox::UUID, ox::String>> template<typename Map = ox::SmallMap<ox::UUID, ox::String>>
uint64_t timeMapUuidToStr(int elemCnt, int lookups, uint64_t seed = 4321) noexcept { [[nodiscard]]
uint64_t timeMapUuidToStr(int const elemCnt, int const lookups, uint64_t seed = 4321) noexcept {
ox::UUID::seedGenerator({1234, seed}); ox::UUID::seedGenerator({1234, seed});
Map map; Map map;
// setup test map // setup test map
@@ -65,12 +66,12 @@ uint64_t timeMapUuidToStr(int elemCnt, int lookups, uint64_t seed = 4321) noexce
auto const startTime = steadyNowMs(); auto const startTime = steadyNowMs();
for (int i = 0; i < lookups; ++i) { for (int i = 0; i < lookups; ++i) {
auto const &k = keys[rand.gen() % keys.size()]; auto const &k = keys[rand.gen() % keys.size()];
oxExpect(map[k], k.toString()); ox::expect(map[k], k.toString());
} }
return steadyNowMs() - startTime; return steadyNowMs() - startTime;
} }
static ox::Error compareMaps(int lookupCnt = 1'000'000) { static ox::Error compareMaps(int const lookupCnt = 1'000'000) {
auto const seed = steadyNowMs(); auto const seed = steadyNowMs();
uint64_t hashTime{}; uint64_t hashTime{};
uint64_t smallTime{}; uint64_t smallTime{};
@@ -126,7 +127,7 @@ OX_CLANG_NOWARN_BEGIN(-Wunsafe-buffer-usage)
OX_CLANG_NOWARN_END OX_CLANG_NOWARN_END
ox::heapmgr::free(a1); ox::heapmgr::free(a1);
ox::heapmgr::free(a2); ox::heapmgr::free(a2);
return ox::Error(0); return ox::Error{};
} }
}, },
{ {
@@ -135,13 +136,13 @@ OX_CLANG_NOWARN_END
ox::Array<char, 10> buff; ox::Array<char, 10> buff;
ox::CharBuffWriter bw(buff); ox::CharBuffWriter bw(buff);
oxAssert(ox::writeItoa(5, bw), "ox::writeItoa returned Error"); oxAssert(ox::writeItoa(5, bw), "ox::writeItoa returned Error");
oxExpect(ox::StringView(buff.data()), ox::StringView("5")); ox::expect(ox::StringView(buff.data()), ox::StringView("5"));
OX_RETURN_ERROR(bw.seekp(0)); OX_RETURN_ERROR(bw.seekp(0));
oxAssert(ox::writeItoa(50, bw), "ox::writeItoa returned Error"); oxAssert(ox::writeItoa(50, bw), "ox::writeItoa returned Error");
oxExpect(ox::StringView(buff.data()), ox::StringView("50")); ox::expect(ox::StringView(buff.data()), ox::StringView("50"));
OX_RETURN_ERROR(bw.seekp(0)); OX_RETURN_ERROR(bw.seekp(0));
oxAssert(ox::writeItoa(500, bw), "ox::writeItoa returned Error"); oxAssert(ox::writeItoa(500, bw), "ox::writeItoa returned Error");
oxExpect(ox::StringView(buff.data()), ox::StringView("500")); ox::expect(ox::StringView(buff.data()), ox::StringView("500"));
return ox::Error{}; return ox::Error{};
} }
}, },
@@ -184,7 +185,7 @@ OX_CLANG_NOWARN_END
oxAssert(s == "asdf", "String assign broken"); oxAssert(s == "asdf", "String assign broken");
oxAssert(s != "aoeu", "String assign broken"); oxAssert(s != "aoeu", "String assign broken");
oxAssert(s.size() == 4, "String assign broken"); oxAssert(s.size() == 4, "String assign broken");
return ox::Error(0); return ox::Error{};
} }
}, },
{ {
@@ -214,11 +215,11 @@ OX_CLANG_NOWARN_END
oxAssert(ox::StringView("Write") != ox::String(""), "String / StringView comparison broken"); oxAssert(ox::StringView("Write") != ox::String(""), "String / StringView comparison broken");
oxAssert(ox::String("Write") != ox::StringView(""), "String / StringView comparison broken"); oxAssert(ox::String("Write") != ox::StringView(""), "String / StringView comparison broken");
oxAssert(ox::String("Write") == ox::StringView("Write"), "String / StringView comparison broken"); oxAssert(ox::String("Write") == ox::StringView("Write"), "String / StringView comparison broken");
oxExpect(ox::String("asdf").substr(1, 3), "sd"); ox::expect(ox::String("asdf").substr(1, 3), "sd");
oxAssert( oxAssert(
ox::String(ox::StringView("Write")) == ox::StringView("Write"), ox::String(ox::StringView("Write")) == ox::StringView("Write"),
"String / StringView comparison broken"); "String / StringView comparison broken");
return ox::Error(0); return ox::Error{};
} }
}, },
{ {
@@ -227,16 +228,16 @@ OX_CLANG_NOWARN_END
ox::Vector<int> v; ox::Vector<int> v;
oxAssert(v.size() == 0, "Initial Vector size not 0"); oxAssert(v.size() == 0, "Initial Vector size not 0");
oxAssert(v.empty(), "Vector::empty() is broken"); oxAssert(v.empty(), "Vector::empty() is broken");
auto insertTest = [&v](int val, std::size_t size) { auto insertTest = [&v](int const val, std::size_t const size) {
v.push_back(val); v.push_back(val);
OX_RETURN_ERROR(ox::Error(v.size() != size, "Vector size incorrect")); OX_RETURN_ERROR(ox::Error(v.size() != size, "Vector size incorrect"));
OX_RETURN_ERROR(ox::Error(v[v.size() - 1] != val, "Vector value wrong")); OX_RETURN_ERROR(ox::Error(v[v.size() - 1] != val, "Vector value wrong"));
return ox::Error(0); return ox::Error{};
}; };
oxAssert(insertTest(42, 1), "Vector insertion failed"); oxAssert(insertTest(42, 1), "Vector insertion failed");
oxAssert(insertTest(100, 2), "Vector insertion failed"); oxAssert(insertTest(100, 2), "Vector insertion failed");
oxAssert(insertTest(102, 3), "Vector insertion failed"); oxAssert(insertTest(102, 3), "Vector insertion failed");
return ox::Error(0); return ox::Error{};
} }
}, },
{ {
@@ -249,9 +250,9 @@ OX_CLANG_NOWARN_END
v.emplace_back("aoeu"); v.emplace_back("aoeu");
auto const origData = v.data(); auto const origData = v.data();
v.shrink_to_fit(); v.shrink_to_fit();
oxExpect(v[0], "asdf"); ox::expect(v[0], "asdf");
oxExpect(v[1], "aoeu"); ox::expect(v[1], "aoeu");
oxExpect(v.capacity(), 2u); ox::expect(v.capacity(), 2u);
oxAssert(origData != v.data(), "shrink_to_fit did not create a new allocation"); oxAssert(origData != v.data(), "shrink_to_fit did not create a new allocation");
} }
{ {
@@ -261,9 +262,9 @@ OX_CLANG_NOWARN_END
v.emplace_back("aoeu"); v.emplace_back("aoeu");
auto const origData = v.data(); auto const origData = v.data();
v.shrink_to_fit(); v.shrink_to_fit();
oxExpect(v[0], "asdf"); ox::expect(v[0], "asdf");
oxExpect(v[1], "aoeu"); ox::expect(v[1], "aoeu");
oxExpect(v.capacity(), 2u); ox::expect(v.capacity(), 2u);
oxAssert(origData == v.data(), "shrink_to_fit inappropriately created a new allocation"); oxAssert(origData == v.data(), "shrink_to_fit inappropriately created a new allocation");
} }
return ox::Error{}; return ox::Error{};
@@ -273,13 +274,13 @@ OX_CLANG_NOWARN_END
"findIdx", "findIdx",
[] { [] {
ox::Vector<ox::IString<8>> const v {"zero", "one", "two", "three", "four"}; ox::Vector<ox::IString<8>> const v {"zero", "one", "two", "three", "four"};
oxExpect(ox::findIdx(v.begin(), v.end(), "zero").or_value(5), 0u); ox::expect(ox::findIdx(v.begin(), v.end(), "zero").or_value(5), 0u);
oxExpect(ox::findIdx(v.begin(), v.end(), "one").or_value(5), 1u); ox::expect(ox::findIdx(v.begin(), v.end(), "one").or_value(5), 1u);
oxExpect(ox::findIdx(v.begin(), v.end(), "two").or_value(5), 2u); ox::expect(ox::findIdx(v.begin(), v.end(), "two").or_value(5), 2u);
oxExpect(ox::findIdx(v.begin(), v.end(), "three").or_value(5), 3u); ox::expect(ox::findIdx(v.begin(), v.end(), "three").or_value(5), 3u);
oxExpect(ox::findIdx(v.begin(), v.end(), "four").or_value(5), 4u); ox::expect(ox::findIdx(v.begin(), v.end(), "four").or_value(5), 4u);
oxExpect(ox::findIdx(v.begin(), v.end(), "five").or_value(5), 5u); ox::expect(ox::findIdx(v.begin(), v.end(), "five").or_value(5), 5u);
oxExpect(ox::findIdx(v.begin(), v.end(), "six").or_value(6), 6u); ox::expect(ox::findIdx(v.begin(), v.end(), "six").or_value(6), 6u);
return ox::Error{}; return ox::Error{};
} }
}, },
@@ -288,19 +289,19 @@ OX_CLANG_NOWARN_END
[] { [] {
ox::SmallMap<ox::String, ox::String> map; ox::SmallMap<ox::String, ox::String> map;
map["asdf"] = "aoeu"; map["asdf"] = "aoeu";
oxExpect(map["asdf"], "aoeu"); ox::expect(map["asdf"], "aoeu");
oxExpect(map.size(), 1u); ox::expect(map.size(), 1u);
oxExpect(map["aoeu"], ""); ox::expect(map["aoeu"], "");
oxExpect(map.size(), 2u); ox::expect(map.size(), 2u);
ox::SmallMap<ox::String, ox::String> cmap; ox::SmallMap<ox::String, ox::String> cmap;
cmap["asdf"] = "aoeu"; cmap["asdf"] = "aoeu";
auto constexpr constTest = [](ox::SmallMap<ox::String, ox::String> const &map) { auto constexpr constTest = [](ox::SmallMap<ox::String, ox::String> const &map) {
OX_REQUIRE(asdf, map.at("asdf")); OX_REQUIRE(asdf, map.at("asdf"));
oxExpect(*asdf, "aoeu"); ox::expect(*asdf, "aoeu");
oxExpect(map.size(), 1u); ox::expect(map.size(), 1u);
auto const aoeu = map.at("aoeu"); auto const aoeu = map.at("aoeu");
oxExpect(aoeu.ok(), false); ox::expect(aoeu.ok(), false);
oxExpect(map.size(), 1u); ox::expect(map.size(), 1u);
return ox::Error{}; return ox::Error{};
}; };
return constTest(cmap); return constTest(cmap);
@@ -319,7 +320,7 @@ OX_CLANG_NOWARN_END
ii[5] = 100; ii[5] = 100;
oxAssert(ii[4] == 42, "4 != 42"); oxAssert(ii[4] == 42, "4 != 42");
oxAssert(ii[5] == 100, "5 != 100"); oxAssert(ii[5] == 100, "5 != 100");
return ox::Error(0); return ox::Error{};
} }
}, },
{ {
@@ -334,17 +335,17 @@ OX_CLANG_NOWARN_END
oxAssert(!si.contains("asdf"), "wrongly contains asdf"); oxAssert(!si.contains("asdf"), "wrongly contains asdf");
oxAssert(si.contains("aoeu"), "does not contains aoeu"); oxAssert(si.contains("aoeu"), "does not contains aoeu");
oxAssert(!si.at("asdf").ok(), "asdf != 0"); oxAssert(!si.at("asdf").ok(), "asdf != 0");
oxExpect(si["asdf"], 0); ox::expect(si["asdf"], 0);
oxAssert(si["aoeu"] == 100, "aoeu != 100"); oxAssert(si["aoeu"] == 100, "aoeu != 100");
auto si2 = si; auto si2 = si;
oxExpect(si2["asdf"], 0); ox::expect(si2["asdf"], 0);
oxAssert(si2["aoeu"] == 100, "aoeu != 100"); oxAssert(si2["aoeu"] == 100, "aoeu != 100");
ox::HashMap<int, int> ii; ox::HashMap<int, int> ii;
ii[4] = 42; ii[4] = 42;
ii[5] = 100; ii[5] = 100;
oxAssert(ii[4] == 42, "4 != 42"); oxAssert(ii[4] == 42, "4 != 42");
oxAssert(ii[5] == 100, "5 != 100"); oxAssert(ii[5] == 100, "5 != 100");
return ox::Error(0); return ox::Error{};
} }
}, },
{ {
@@ -377,15 +378,15 @@ OX_CLANG_NOWARN_END
static_cast<int>(actual[1]), static_cast<int>(actual[1]),
static_cast<int>(actual[2]), static_cast<int>(actual[2]),
static_cast<int>(actual[3])); static_cast<int>(actual[3]));
oxExpect(ox::serialize<int32_t>(4).unwrap(), BA({4, 0, 0, 0})); ox::expect(ox::serialize<int32_t>(4).unwrap(), BA({4, 0, 0, 0}));
oxExpect(ox::serialize<int32_t>(256).unwrap(), BA({0, 1, 0, 0})); ox::expect(ox::serialize<int32_t>(256).unwrap(), BA({0, 1, 0, 0}));
oxExpect(ox::serialize<int32_t>(257).unwrap(), BA({1, 1, 0, 0})); ox::expect(ox::serialize<int32_t>(257).unwrap(), BA({1, 1, 0, 0}));
oxExpect(ox::serialize<uint32_t>(4).unwrap(), BA({4, 0, 0, 0})); ox::expect(ox::serialize<uint32_t>(4).unwrap(), BA({4, 0, 0, 0}));
oxExpect(ox::serialize<uint32_t>(256).unwrap(), BA({0, 1, 0, 0})); ox::expect(ox::serialize<uint32_t>(256).unwrap(), BA({0, 1, 0, 0}));
oxExpect(ox::serialize<uint32_t>(257).unwrap(), BA({1, 1, 0, 0})); ox::expect(ox::serialize<uint32_t>(257).unwrap(), BA({1, 1, 0, 0}));
constexpr auto neg1 = static_cast<char>(-1); // ARM64 Linux assumes -1 literals are ints... constexpr auto neg1 = static_cast<char>(-1); // ARM64 Linux assumes -1 literals are ints...
oxExpect(ox::serialize<uint32_t>(0xffff'ffff).unwrap(), BA({neg1, neg1, neg1, neg1})); ox::expect(ox::serialize<uint32_t>(0xffff'ffff).unwrap(), BA({neg1, neg1, neg1, neg1}));
return ox::Error(0); return ox::Error{};
} }
}, },
{ {
@@ -394,58 +395,58 @@ OX_CLANG_NOWARN_END
ox::Buffer b; ox::Buffer b;
ox::BufferWriter w(&b); ox::BufferWriter w(&b);
oxAssert(w.write("asdf", 4), "write failed"); oxAssert(w.write("asdf", 4), "write failed");
oxExpect(b.size(), 4u); ox::expect(b.size(), 4u);
oxAssert(w.write("aoeu", 4), "write failed"); oxAssert(w.write("aoeu", 4), "write failed");
oxExpect(b.size(), 8u); ox::expect(b.size(), 8u);
oxExpect(ox::StringView(b.data(), b.size()), "asdfaoeu"); ox::expect(ox::StringView(b.data(), b.size()), "asdfaoeu");
ox::StringView constexpr qwerty = "qwerty"; ox::StringView constexpr qwerty = "qwerty";
oxAssert(w.write(qwerty.data(), qwerty.bytes()), "write failed"); oxAssert(w.write(qwerty.data(), qwerty.bytes()), "write failed");
oxExpect(b.size(), 14u); ox::expect(b.size(), 14u);
oxExpect(ox::StringView(b.data(), b.size()), "asdfaoeuqwerty"); ox::expect(ox::StringView(b.data(), b.size()), "asdfaoeuqwerty");
return ox::Error(0); return ox::Error{};
} }
}, },
{ {
"FromHex", "FromHex",
[] { [] {
oxExpect(ox::detail::fromHex("01").unwrap(), 0x01); ox::expect(ox::detail::fromHex("01").unwrap(), 0x01);
oxExpect(ox::detail::fromHex("02").unwrap(), 0x02); ox::expect(ox::detail::fromHex("02").unwrap(), 0x02);
oxExpect(ox::detail::fromHex("03").unwrap(), 0x03); ox::expect(ox::detail::fromHex("03").unwrap(), 0x03);
oxExpect(ox::detail::fromHex("04").unwrap(), 0x04); ox::expect(ox::detail::fromHex("04").unwrap(), 0x04);
oxExpect(ox::detail::fromHex("05").unwrap(), 0x05); ox::expect(ox::detail::fromHex("05").unwrap(), 0x05);
oxExpect(ox::detail::fromHex("06").unwrap(), 0x06); ox::expect(ox::detail::fromHex("06").unwrap(), 0x06);
oxExpect(ox::detail::fromHex("07").unwrap(), 0x07); ox::expect(ox::detail::fromHex("07").unwrap(), 0x07);
oxExpect(ox::detail::fromHex("08").unwrap(), 0x08); ox::expect(ox::detail::fromHex("08").unwrap(), 0x08);
oxExpect(ox::detail::fromHex("0d").unwrap(), 0x0d); ox::expect(ox::detail::fromHex("0d").unwrap(), 0x0d);
oxExpect(ox::detail::fromHex("0e").unwrap(), 0x0e); ox::expect(ox::detail::fromHex("0e").unwrap(), 0x0e);
oxExpect(ox::detail::fromHex("0f").unwrap(), 0x0f); ox::expect(ox::detail::fromHex("0f").unwrap(), 0x0f);
oxExpect(ox::detail::fromHex("0F").unwrap(), 0x0f); ox::expect(ox::detail::fromHex("0F").unwrap(), 0x0f);
oxExpect(ox::detail::fromHex("fF").unwrap(), 0xff); ox::expect(ox::detail::fromHex("fF").unwrap(), 0xff);
oxExpect(ox::detail::fromHex("ff").unwrap(), 0xff); ox::expect(ox::detail::fromHex("ff").unwrap(), 0xff);
oxExpect(ox::detail::fromHex("a0").unwrap(), 0xa0); ox::expect(ox::detail::fromHex("a0").unwrap(), 0xa0);
oxExpect(ox::detail::fromHex("93").unwrap(), 0x93); ox::expect(ox::detail::fromHex("93").unwrap(), 0x93);
oxExpect(ox::detail::fromHex("40").unwrap(), 0x40); ox::expect(ox::detail::fromHex("40").unwrap(), 0x40);
return ox::Error(0); return ox::Error{};
} }
}, },
{ {
"ToHex", "ToHex",
[] { [] {
oxExpect(ox::detail::toHex(0x01), "01"); ox::expect(ox::detail::toHex(0x01), "01");
oxExpect(ox::detail::toHex(0x02), "02"); ox::expect(ox::detail::toHex(0x02), "02");
oxExpect(ox::detail::toHex(0x03), "03"); ox::expect(ox::detail::toHex(0x03), "03");
oxExpect(ox::detail::toHex(0x04), "04"); ox::expect(ox::detail::toHex(0x04), "04");
oxExpect(ox::detail::toHex(0x05), "05"); ox::expect(ox::detail::toHex(0x05), "05");
oxExpect(ox::detail::toHex(0x06), "06"); ox::expect(ox::detail::toHex(0x06), "06");
oxExpect(ox::detail::toHex(0x07), "07"); ox::expect(ox::detail::toHex(0x07), "07");
oxExpect(ox::detail::toHex(0x08), "08"); ox::expect(ox::detail::toHex(0x08), "08");
oxExpect(ox::detail::toHex(0x0d), "0d"); ox::expect(ox::detail::toHex(0x0d), "0d");
oxExpect(ox::detail::toHex(0x0e), "0e"); ox::expect(ox::detail::toHex(0x0e), "0e");
oxExpect(ox::detail::toHex(0x0f), "0f"); ox::expect(ox::detail::toHex(0x0f), "0f");
oxExpect(ox::detail::toHex(0x93), "93"); ox::expect(ox::detail::toHex(0x93), "93");
oxExpect(ox::detail::toHex(0x40), "40"); ox::expect(ox::detail::toHex(0x40), "40");
oxExpect(ox::detail::toHex(0xf0), "f0"); ox::expect(ox::detail::toHex(0xf0), "f0");
return ox::Error(0); return ox::Error{};
} }
}, },
{ {
@@ -453,20 +454,20 @@ OX_CLANG_NOWARN_END
[] { [] {
constexpr ox::StringView uuidStr = "8d814442-f46e-4cc3-8edc-ca3c01cc86db"; constexpr ox::StringView uuidStr = "8d814442-f46e-4cc3-8edc-ca3c01cc86db";
OX_REQUIRE(uuid, ox::UUID::fromString(uuidStr)); OX_REQUIRE(uuid, ox::UUID::fromString(uuidStr));
oxExpect(uuid.toString(), uuidStr); ox::expect(uuid.toString(), uuidStr);
oxExpect(ox::UUID{}.isNull(), true); ox::expect(ox::UUID{}.isNull(), true);
oxExpect(ox::UUID::fromString(uuidStr).value.isNull(), false); ox::expect(ox::UUID::fromString(uuidStr).value.isNull(), false);
return ox::Error(0); return ox::Error{};
} }
}, },
{ {
"UUID::generate", "UUID::generate",
[] { [] {
ox::UUID::seedGenerator({1234, 4321}); ox::UUID::seedGenerator({1234, 4321});
oxExpect(ox::UUID::generate().unwrap().toString(), "5c3f4b5e-ccbf-4727-7f03-3053dedc8827"); ox::expect(ox::UUID::generate().unwrap().toString(), "5c3f4b5e-ccbf-4727-7f03-3053dedc8827");
oxExpect(ox::UUID::generate().unwrap().toString(), "90d0274a-2774-4afa-88e5-0c1d60ba3abf"); ox::expect(ox::UUID::generate().unwrap().toString(), "90d0274a-2774-4afa-88e5-0c1d60ba3abf");
oxExpect(ox::UUID::generate().unwrap().toString(), "7df77910-841c-48ba-ea2e-44521ac47c2e"); ox::expect(ox::UUID::generate().unwrap().toString(), "7df77910-841c-48ba-ea2e-44521ac47c2e");
return ox::Error(0); return ox::Error{};
} }
}, },
{ {
@@ -474,100 +475,100 @@ OX_CLANG_NOWARN_END
[] { [] {
ox::StringView sv = "ab.cd"; ox::StringView sv = "ab.cd";
auto list = ox::split(sv, "."); auto list = ox::split(sv, ".");
oxExpect(list.size(), 2u); ox::expect(list.size(), 2u);
oxExpect(list[0], "ab"); ox::expect(list[0], "ab");
oxExpect(list[1], "cd"); ox::expect(list[1], "cd");
sv = "ab.cd.fg"; sv = "ab.cd.fg";
list = ox::split(sv, "."); list = ox::split(sv, ".");
oxExpect(list.size(), 3u); ox::expect(list.size(), 3u);
oxExpect(list[0], "ab"); ox::expect(list[0], "ab");
oxExpect(list[1], "cd"); ox::expect(list[1], "cd");
oxExpect(list[2], "fg"); ox::expect(list[2], "fg");
sv = "ab.cd."; sv = "ab.cd.";
list = ox::split(sv, "."); list = ox::split(sv, ".");
oxExpect(list.size(), 2u); ox::expect(list.size(), 2u);
oxExpect(list[0], "ab"); ox::expect(list[0], "ab");
oxExpect(list[1], "cd"); ox::expect(list[1], "cd");
sv = ".ab.cd."; sv = ".ab.cd.";
list = ox::split(sv, "."); list = ox::split(sv, ".");
oxExpect(list.size(), 2u); ox::expect(list.size(), 2u);
oxExpect(list[0], "ab"); ox::expect(list[0], "ab");
oxExpect(list[1], "cd"); ox::expect(list[1], "cd");
sv = "."; sv = ".";
list = ox::split(sv, "."); list = ox::split(sv, ".");
oxExpect(list.size(), 0u); ox::expect(list.size(), 0u);
sv = "."; sv = ".";
list = ox::split(sv, "."); list = ox::split(sv, ".");
oxExpect(list.size(), 0u); ox::expect(list.size(), 0u);
sv = ""; sv = "";
list = ox::split(sv, "."); list = ox::split(sv, ".");
oxExpect(list.size(), 0u); ox::expect(list.size(), 0u);
// split by single char // split by single char
sv = "ab.cd"; sv = "ab.cd";
list = ox::split(sv, '.'); list = ox::split(sv, '.');
oxExpect(list.size(), 2u); ox::expect(list.size(), 2u);
oxExpect(list[0], "ab"); ox::expect(list[0], "ab");
oxExpect(list[1], "cd"); ox::expect(list[1], "cd");
sv = "ab.cd.fg"; sv = "ab.cd.fg";
list = ox::split(sv, '.'); list = ox::split(sv, '.');
oxExpect(list.size(), 3u); ox::expect(list.size(), 3u);
oxExpect(list[0], "ab"); ox::expect(list[0], "ab");
oxExpect(list[1], "cd"); ox::expect(list[1], "cd");
oxExpect(list[2], "fg"); ox::expect(list[2], "fg");
sv = "ab.cd."; sv = "ab.cd.";
list = ox::split(sv, '.'); list = ox::split(sv, '.');
oxExpect(list.size(), 2u); ox::expect(list.size(), 2u);
oxExpect(list[0], "ab"); ox::expect(list[0], "ab");
oxExpect(list[1], "cd"); ox::expect(list[1], "cd");
sv = ".ab.cd."; sv = ".ab.cd.";
list = ox::split(sv, '.'); list = ox::split(sv, '.');
oxExpect(list.size(), 2u); ox::expect(list.size(), 2u);
oxExpect(list[0], "ab"); ox::expect(list[0], "ab");
oxExpect(list[1], "cd"); ox::expect(list[1], "cd");
sv = "."; sv = ".";
list = ox::split(sv, '.'); list = ox::split(sv, '.');
oxExpect(list.size(), 0u); ox::expect(list.size(), 0u);
sv = "."; sv = ".";
list = ox::split(sv, '.'); list = ox::split(sv, '.');
oxExpect(list.size(), 0u); ox::expect(list.size(), 0u);
sv = ""; sv = "";
list = ox::split(sv, '.'); list = ox::split(sv, '.');
oxExpect(list.size(), 0u); ox::expect(list.size(), 0u);
return ox::Error(0); return ox::Error{};
} }
}, },
{ {
"intToStr", "intToStr",
[] { [] {
oxExpect(ox::intToStr<uint8_t>(255u), "255"); ox::expect(ox::intToStr<uint8_t>(255u), "255");
oxExpect(ox::intToStr<int8_t>(127), "127"); ox::expect(ox::intToStr<int8_t>(127), "127");
oxExpect(ox::intToStr<int8_t>(-128), "-128"); ox::expect(ox::intToStr<int8_t>(-128), "-128");
oxExpect(ox::intToStr<uint16_t>(65535u), "65535"); ox::expect(ox::intToStr<uint16_t>(65535u), "65535");
oxExpect(ox::intToStr<int16_t>(32767), "32767"); ox::expect(ox::intToStr<int16_t>(32767), "32767");
oxExpect(ox::intToStr<int16_t>(-32768), "-32768"); ox::expect(ox::intToStr<int16_t>(-32768), "-32768");
oxExpect(ox::intToStr<uint32_t>(4294967295u), "4294967295"); ox::expect(ox::intToStr<uint32_t>(4294967295u), "4294967295");
oxExpect(ox::intToStr<int32_t>(2147483647), "2147483647"); ox::expect(ox::intToStr<int32_t>(2147483647), "2147483647");
oxExpect(ox::intToStr<int32_t>(-2147483648), "-2147483648"); ox::expect(ox::intToStr<int32_t>(-2147483648), "-2147483648");
oxExpect(ox::intToStr<uint64_t>(18446744073709551615u), "18446744073709551615"); ox::expect(ox::intToStr<uint64_t>(18446744073709551615u), "18446744073709551615");
oxExpect(ox::intToStr<int64_t>(9223372036854775807), "9223372036854775807"); ox::expect(ox::intToStr<int64_t>(9223372036854775807), "9223372036854775807");
oxExpect(ox::intToStr<int64_t>(-9223372036854775807), "-9223372036854775807"); ox::expect(ox::intToStr<int64_t>(-9223372036854775807), "-9223372036854775807");
oxExpect(ox::intToStr<uint64_t>(0), "0"); ox::expect(ox::intToStr<uint64_t>(0), "0");
oxExpect(ox::intToStr<uint64_t>(5), "5"); ox::expect(ox::intToStr<uint64_t>(5), "5");
oxExpect(ox::intToStr(0), "0"); ox::expect(ox::intToStr(0), "0");
oxExpect(ox::intToStr(5), "5"); ox::expect(ox::intToStr(5), "5");
oxExpect(ox::intToStr(5000), "5000"); ox::expect(ox::intToStr(5000), "5000");
oxExpect(ox::intToStr(50000), "50000"); ox::expect(ox::intToStr(50000), "50000");
oxExpect(ox::intToStr(500000), "500000"); ox::expect(ox::intToStr(500000), "500000");
oxExpect(ox::intToStr(-5), "-5"); ox::expect(ox::intToStr(-5), "-5");
oxExpect(ox::intToStr(-5000), "-5000"); ox::expect(ox::intToStr(-5000), "-5000");
oxExpect(ox::intToStr(-50000), "-50000"); ox::expect(ox::intToStr(-50000), "-50000");
oxExpect(ox::intToStr(-500000), "-500000"); ox::expect(ox::intToStr(-500000), "-500000");
return ox::Error{}; return ox::Error{};
} }
}, },
}; };
int main(int argc, const char **argv) { int main(int const argc, const char **argv) {
if (argc < 2) { if (argc < 2) {
oxError("Must specify test to run"); oxError("Must specify test to run");
return -1; return -1;