Amebis/stdex
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

UnitTest: Switch to Assert::IsTrue for primitive datatypes

Browse Source 
Visual Studio 2019 has issues compiling Assert::AreEqual<stdex::langid>.

Signed-off-by: Simon Rozman <simon@rozman.si>
This commit is contained in:
Simon Rozman 2025-03-28 15:30:05 +01:00
parent 51d472d8b2
commit 5fc35751a3
8 changed files with 109 additions and 109 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
UnitTests/hash.cpp
View File

@ -40,7 +40,7 @@ namespace UnitTests
static const char data[] = "This is a test.";
h.hash(data, sizeof(data) - sizeof(*data));
h.finalize();
Assert::AreEqual<stdex::crc32_t>(0xc6c3c95d, h);
Assert::IsTrue(h == 0xc6c3c95d);
}
void hash::md5()

32
UnitTests/langid.cpp
View File

@ -14,22 +14,22 @@ namespace UnitTests
{
void langid::from_rfc1766()
{
Assert::AreEqual<stdex::langid>(9, stdex::langid_from_rfc1766("en"));
Assert::AreEqual<stdex::langid>(1033, stdex::langid_from_rfc1766("en-US"));
Assert::AreEqual<stdex::langid>(1033, stdex::langid_from_rfc1766("en_US"));
Assert::AreEqual<stdex::langid>(2057, stdex::langid_from_rfc1766("en-GB"));
Assert::AreEqual<stdex::langid>(2057, stdex::langid_from_rfc1766("en_GB"));
Assert::AreEqual<stdex::langid>(9, stdex::langid_from_rfc1766("EN"));
Assert::AreEqual<stdex::langid>(1033, stdex::langid_from_rfc1766("EN-US"));
Assert::AreEqual<stdex::langid>(1033, stdex::langid_from_rfc1766("EN_US"));
Assert::AreEqual<stdex::langid>(2057, stdex::langid_from_rfc1766("EN-GB"));
Assert::AreEqual<stdex::langid>(2057, stdex::langid_from_rfc1766("EN_GB"));
Assert::IsTrue(stdex::langid_from_rfc1766("en") == 9);
Assert::IsTrue(stdex::langid_from_rfc1766("en-US") == 1033);
Assert::IsTrue(stdex::langid_from_rfc1766("en_US") == 1033);
Assert::IsTrue(stdex::langid_from_rfc1766("en-GB") == 2057);
Assert::IsTrue(stdex::langid_from_rfc1766("en_GB") == 2057);
Assert::IsTrue(stdex::langid_from_rfc1766("EN") == 9);
Assert::IsTrue(stdex::langid_from_rfc1766("EN-US") == 1033);
Assert::IsTrue(stdex::langid_from_rfc1766("EN_US") == 1033);
Assert::IsTrue(stdex::langid_from_rfc1766("EN-GB") == 2057);
Assert::IsTrue(stdex::langid_from_rfc1766("EN_GB") == 2057);
Assert::AreEqual<stdex::langid>(36, stdex::langid_from_rfc1766("sl"));
Assert::AreEqual<stdex::langid>(1060, stdex::langid_from_rfc1766("sl-SI"));
Assert::AreEqual<stdex::langid>(1060, stdex::langid_from_rfc1766("sl_SI"));
Assert::AreEqual<stdex::langid>(36, stdex::langid_from_rfc1766("SL"));
Assert::AreEqual<stdex::langid>(1060, stdex::langid_from_rfc1766("SL-SI"));
Assert::AreEqual<stdex::langid>(1060, stdex::langid_from_rfc1766("SL_SI"));
Assert::IsTrue(stdex::langid_from_rfc1766("sl") == 36);
Assert::IsTrue(stdex::langid_from_rfc1766("sl-SI") == 1060);
Assert::IsTrue(stdex::langid_from_rfc1766("sl_SI") == 1060);
Assert::IsTrue(stdex::langid_from_rfc1766("SL") == 36);
Assert::IsTrue(stdex::langid_from_rfc1766("SL-SI") == 1060);
Assert::IsTrue(stdex::langid_from_rfc1766("SL_SI") == 1060);
}
}

28
UnitTests/math.cpp
View File

@ -14,26 +14,26 @@ namespace UnitTests
{
void math::mul()
{
Assert::AreEqual<size_t>(10, stdex::mul(2, 5));
Assert::AreEqual<size_t>(10, stdex::mul(5, 2));
Assert::AreEqual<size_t>(0, stdex::mul(0, 10));
Assert::AreEqual<size_t>(0, stdex::mul(10, 0));
Assert::AreEqual<size_t>(0, stdex::mul(SIZE_MAX, 0));
Assert::AreEqual<size_t>(0, stdex::mul(0, SIZE_MAX));
Assert::AreEqual<size_t>(SIZE_MAX, stdex::mul(SIZE_MAX, 1));
Assert::AreEqual<size_t>(SIZE_MAX, stdex::mul(1, SIZE_MAX));
Assert::IsTrue(stdex::mul(2, 5) == 10);
Assert::IsTrue(stdex::mul(5, 2) == 10);
Assert::IsTrue(stdex::mul(0, 10) == 0);
Assert::IsTrue(stdex::mul(10, 0) == 0);
Assert::IsTrue(stdex::mul(SIZE_MAX, 0) == 0);
Assert::IsTrue(stdex::mul(0, SIZE_MAX) == 0);
Assert::IsTrue(stdex::mul(SIZE_MAX, 1) == SIZE_MAX);
Assert::IsTrue(stdex::mul(1, SIZE_MAX) == SIZE_MAX);
Assert::ExpectException<std::invalid_argument>([] { stdex::mul(SIZE_MAX, 2); });
Assert::ExpectException<std::invalid_argument>([] { stdex::mul(2, SIZE_MAX); });
}
void math::add()
{
Assert::AreEqual<size_t>(7, stdex::add(2, 5));
Assert::AreEqual<size_t>(7, stdex::add(5, 2));
Assert::AreEqual<size_t>(10, stdex::add(0, 10));
Assert::AreEqual<size_t>(10, stdex::add(10, 0));
Assert::AreEqual<size_t>(SIZE_MAX, stdex::add(SIZE_MAX, 0));
Assert::AreEqual<size_t>(SIZE_MAX, stdex::add(0, SIZE_MAX));
Assert::IsTrue(stdex::add(2, 5) == 7);
Assert::IsTrue(stdex::add(5, 2) == 7);
Assert::IsTrue(stdex::add(0, 10) == 10);
Assert::IsTrue(stdex::add(10, 0) == 10);
Assert::IsTrue(stdex::add(SIZE_MAX, 0) == SIZE_MAX);
Assert::IsTrue(stdex::add(0, SIZE_MAX) == SIZE_MAX);
Assert::ExpectException<std::invalid_argument>([] { stdex::add(SIZE_MAX, 1); });
Assert::ExpectException<std::invalid_argument>([] { stdex::add(1, SIZE_MAX); });
}

126
UnitTests/parser.cpp
View File

@ -36,55 +36,55 @@ namespace UnitTests
{
wnoop p;
Assert::IsTrue(p.match(text));
Assert::AreEqual((size_t)0, p.interval.start);
Assert::AreEqual((size_t)0, p.interval.end);
Assert::IsTrue(p.interval.start == 0);
Assert::IsTrue(p.interval.end == 0);
}
{
wcu p(L't');
Assert::IsFalse(p.match(text));
Assert::IsTrue(p.match(text, 0, _countof(text), match_case_insensitive));
Assert::AreEqual((size_t)0, p.interval.start);
Assert::AreEqual((size_t)1, p.interval.end);
Assert::IsTrue(p.interval.start == 0);
Assert::IsTrue(p.interval.end == 1);
}
{
wspace_cu p;
Assert::IsFalse(p.match(text));
Assert::IsTrue(p.match(text, 4));
Assert::AreEqual((size_t)4, p.interval.start);
Assert::AreEqual((size_t)5, p.interval.end);
Assert::IsTrue(p.interval.start == 4);
Assert::IsTrue(p.interval.end == 5);
}
{
wpunct_cu p;
Assert::IsFalse(p.match(text));
Assert::IsTrue(p.match(text, 14));
Assert::AreEqual((size_t)14, p.interval.start);
Assert::AreEqual((size_t)15, p.interval.end);
Assert::IsTrue(p.interval.start == 14);
Assert::IsTrue(p.interval.end == 15);
}
{
wspace_or_punct_cu p;
Assert::IsFalse(p.match(text));
Assert::IsTrue(p.match(text, 4));
Assert::AreEqual((size_t)4, p.interval.start);
Assert::AreEqual((size_t)5, p.interval.end);
Assert::IsTrue(p.interval.start == 4);
Assert::IsTrue(p.interval.end == 5);
Assert::IsTrue(p.match(text, 14));
Assert::AreEqual((size_t)14, p.interval.start);
Assert::AreEqual((size_t)15, p.interval.end);
Assert::IsTrue(p.interval.start == 14);
Assert::IsTrue(p.interval.end == 15);
}
{
wbol p;
Assert::IsTrue(p.match(text));
Assert::AreEqual((size_t)0, p.interval.start);
Assert::AreEqual((size_t)0, p.interval.end);
Assert::IsTrue(p.interval.start == 0);
Assert::IsTrue(p.interval.end == 0);
Assert::IsFalse(p.match(text, 1));
Assert::IsFalse(p.match(text, 15));
Assert::IsTrue(p.match(text, 16));
Assert::AreEqual((size_t)16, p.interval.start);
Assert::AreEqual((size_t)16, p.interval.end);
Assert::IsTrue(p.interval.start == 16);
Assert::IsTrue(p.interval.end == 16);
}
{
@ -92,8 +92,8 @@ namespace UnitTests
Assert::IsFalse(p.match(text));
Assert::IsFalse(p.match(text, 1));
Assert::IsTrue(p.match(text, 15));
Assert::AreEqual((size_t)15, p.interval.start);
Assert::AreEqual((size_t)15, p.interval.end);
Assert::IsTrue(p.interval.start == 15);
Assert::IsTrue(p.interval.end == 15);
Assert::IsFalse(p.match(text, 16));
}
@ -101,38 +101,38 @@ namespace UnitTests
wcu_set p(L"abcD");
Assert::IsFalse(p.match(text));
Assert::IsTrue(p.match(text, 8));
Assert::AreEqual((size_t)8, p.interval.start);
Assert::AreEqual((size_t)9, p.interval.end);
Assert::AreEqual((size_t)0, p.hit_offset);
Assert::IsTrue(p.interval.start == 8);
Assert::IsTrue(p.interval.end == 9);
Assert::IsTrue(p.hit_offset == 0);
Assert::IsFalse(p.match(text, 21));
Assert::IsTrue(p.match(text, 21, _countof(text), match_case_insensitive));
Assert::AreEqual((size_t)21, p.interval.start);
Assert::AreEqual((size_t)22, p.interval.end);
Assert::AreEqual((size_t)3, p.hit_offset);
Assert::IsTrue(p.interval.start == 21);
Assert::IsTrue(p.interval.end == 22);
Assert::IsTrue(p.hit_offset == 3);
}
{
stdex::parser::wstring p(L"this");
Assert::IsFalse(p.match(text));
Assert::IsTrue(p.match(text, 0, sizeof(text), match_case_insensitive));
Assert::AreEqual((size_t)0, p.interval.start);
Assert::AreEqual((size_t)4, p.interval.end);
Assert::IsTrue(p.interval.start == 0);
Assert::IsTrue(p.interval.end == 4);
}
{
wany_cu chr;
witerations p(make_shared_no_delete(&chr), 1, 5);
Assert::IsTrue(p.match(text));
Assert::AreEqual((size_t)0, p.interval.start);
Assert::AreEqual((size_t)5, p.interval.end);
Assert::IsTrue(p.interval.start == 0);
Assert::IsTrue(p.interval.end == 5);
}
{
wspace_cu nospace(true);
witerations p(make_shared_no_delete(&nospace), 1);
Assert::IsTrue(p.match(text));
Assert::AreEqual((size_t)0, p.interval.start);
Assert::AreEqual((size_t)4, p.interval.end);
Assert::IsTrue(p.interval.start == 0);
Assert::IsTrue(p.interval.end == 4);
}
{
@ -146,8 +146,8 @@ namespace UnitTests
make_shared_no_delete(&space) });
Assert::IsFalse(p.match(text));
Assert::IsTrue(p.match(text, 0, _countof(text), match_case_insensitive));
Assert::AreEqual((size_t)0, p.interval.start);
Assert::AreEqual((size_t)5, p.interval.end);
Assert::IsTrue(p.interval.start == 0);
Assert::IsTrue(p.interval.end == 5);
}
{
@ -160,18 +160,18 @@ namespace UnitTests
make_shared_no_delete(&space) });
Assert::IsFalse(p.match(text));
Assert::IsTrue(p.match(text, 0, _countof(text), match_case_insensitive));
Assert::AreEqual((size_t)2, p.hit_offset);
Assert::AreEqual((size_t)0, p.interval.start);
Assert::AreEqual((size_t)4, p.interval.end);
Assert::IsTrue(p.hit_offset == 2);
Assert::IsTrue(p.interval.start == 0);
Assert::IsTrue(p.interval.end == 4);
}
{
wstring_branch p(L"apple", L"orange", L"this", nullptr);
Assert::IsFalse(p.match(text));
Assert::IsTrue(p.match(text, 0, _countof(text), match_case_insensitive));
Assert::AreEqual((size_t)2, p.hit_offset);
Assert::AreEqual((size_t)0, p.interval.start);
Assert::AreEqual((size_t)4, p.interval.end);
Assert::IsTrue(p.hit_offset == 2);
Assert::IsTrue(p.interval.start == 0);
Assert::IsTrue(p.interval.end == 4);
}
{
@ -183,8 +183,8 @@ namespace UnitTests
make_shared_no_delete(&chr_t) });
Assert::IsFalse(p.match(text));
Assert::IsTrue(p.match(text, 0, _countof(text), match_case_insensitive));
Assert::AreEqual((size_t)0, p.interval.start);
Assert::AreEqual((size_t)4, p.interval.end);
Assert::IsTrue(p.interval.start == 0);
Assert::IsTrue(p.interval.end == 4);
}
{
@ -300,44 +300,44 @@ namespace UnitTests
{
sgml_noop p;
Assert::IsTrue(p.match(text));
Assert::AreEqual((size_t)0, p.interval.start);
Assert::AreEqual((size_t)0, p.interval.end);
Assert::IsTrue(p.interval.start == 0);
Assert::IsTrue(p.interval.end == 0);
}
{
sgml_cp p("v");
Assert::IsFalse(p.match(text));
Assert::IsTrue(p.match(text, 0, _countof(text), match_case_insensitive));
Assert::AreEqual((size_t)0, p.interval.start);
Assert::AreEqual((size_t)1, p.interval.end);
Assert::IsTrue(p.interval.start == 0);
Assert::IsTrue(p.interval.end == 1);
}
{
sgml_cp p("&Zcaron;", SIZE_MAX, false, locale_slSI);
Assert::IsFalse(p.match(text, 4));
Assert::IsTrue(p.match(text, 4, _countof(text), match_case_insensitive));
Assert::AreEqual((size_t)4, p.interval.start);
Assert::AreEqual((size_t)12, p.interval.end);
Assert::IsTrue(p.interval.start == 4);
Assert::IsTrue(p.interval.end == 12);
}
{
sgml_space_cp p(false, locale_slSI);
Assert::IsFalse(p.match(text));
Assert::IsTrue(p.match(text, 1));
Assert::AreEqual((size_t)1, p.interval.start);
Assert::AreEqual((size_t)2, p.interval.end);
Assert::IsTrue(p.interval.start == 1);
Assert::IsTrue(p.interval.end == 2);
Assert::IsTrue(p.match(text, 79));
Assert::AreEqual((size_t)79, p.interval.start);
Assert::AreEqual((size_t)85, p.interval.end);
Assert::IsTrue(p.interval.start == 79);
Assert::IsTrue(p.interval.end == 85);
}
{
sgml_string_branch p(locale_slSI, "apple", "orange", "Ko&Zcaron;u&Scaron;&ccaron;Ku", nullptr);
Assert::IsFalse(p.match(text, 2));
Assert::IsTrue(p.match(text, 2, _countof(text), match_case_insensitive));
Assert::AreEqual((size_t)2, p.hit_offset);
Assert::AreEqual((size_t)2, p.interval.start);
Assert::AreEqual((size_t)31, p.interval.end);
Assert::IsTrue(p.hit_offset == 2);
Assert::IsTrue(p.interval.start == 2);
Assert::IsTrue(p.interval.end == 31);
}
{
@ -432,15 +432,15 @@ namespace UnitTests
{
http_request p(locale);
Assert::IsTrue(p.match(request));
Assert::AreEqual((size_t)0, p.interval.start);
Assert::AreEqual((size_t)14, p.interval.end);
Assert::AreEqual((size_t)0, p.verb.start);
Assert::AreEqual((size_t)3, p.verb.end);
Assert::AreEqual((size_t)4, p.url.interval.start);
Assert::AreEqual((size_t)5, p.url.interval.end);
Assert::AreEqual((size_t)6, p.protocol.interval.start);
Assert::AreEqual((size_t)12, p.protocol.interval.end);
Assert::AreEqual((uint16_t)0x200, p.protocol.version);
Assert::IsTrue(p.interval.start == 0);
Assert::IsTrue(p.interval.end == 14);
Assert::IsTrue(p.verb.start == 0);
Assert::IsTrue(p.verb.end == 3);
Assert::IsTrue(p.url.interval.start == 4);
Assert::IsTrue(p.url.interval.end == 5);
Assert::IsTrue(p.protocol.interval.start == 6);
Assert::IsTrue(p.protocol.interval.end == 12);
Assert::IsTrue(p.protocol.version == 0x200);
}
{
@ -455,7 +455,7 @@ namespace UnitTests
else
break;
}
Assert::AreEqual((size_t)15, hdrs.size());
Assert::IsTrue(hdrs.size() == 15);
http_weighted_collection<http_weighted_value<http_language>> langs;
for (const auto& h : hdrs)
if (strnicmp(request + h.name.start, h.name.size(), "Accept-Language", SIZE_MAX, locale) == 0)

2
UnitTests/ring.cpp
View File

@ -52,7 +52,7 @@ namespace UnitTests
if (num_read > 7)
num_read = 7;
for (size_t i = 0; i < num_read; ++i)
Assert::AreEqual(seed++, ptr[i]);
Assert::IsTrue(ptr[i] == seed++);
ring.pop(num_read);
}
writer.join();

12
UnitTests/stream.cpp
View File

@ -36,14 +36,14 @@ namespace UnitTests
writer << i;
}
}
Assert::AreEqual<stdex::stream::fpos_t>(0, source.seekbeg(0));
Assert::IsTrue(source.seekbeg(0) == 0);
{
async_reader<50> reader(source);
uint32_t x;
for (uint32_t i = 0; i < total; ++i) {
reader >> x;
Assert::IsTrue(reader.ok());
Assert::AreEqual(i, x);
Assert::IsTrue(x == i);
}
reader >> x;
Assert::IsFalse(reader.ok());
@ -90,13 +90,13 @@ namespace UnitTests
for (uint32_t i = 0; i < total; ++i) {
f1 >> x;
Assert::IsTrue(f1.ok());
Assert::AreEqual(i, x);
Assert::IsTrue(x == i);
f2_buf >> x;
Assert::IsTrue(f2_buf.ok());
Assert::AreEqual(i, x);
Assert::IsTrue(x == i);
f3 >> x;
Assert::IsTrue(f3.ok());
Assert::AreEqual(i, x);
Assert::IsTrue(x == i);
}
f1 >> x;
Assert::IsFalse(f1.ok());
@ -139,7 +139,7 @@ namespace UnitTests
dat >> x;
if (!dat.ok())
break;
Assert::AreEqual(i, x % count);
Assert::IsTrue(x % count == i);
}
}
dat.close();

8
UnitTests/string.cpp
View File

@ -24,9 +24,9 @@ namespace UnitTests
stdex::locale locale(stdex::create_locale(LC_ALL, "en_US.UTF-8"));
Assert::AreEqual(L"This is a test.", stdex::sprintf(L"This is %ls.", locale, L"a test").c_str());
Assert::AreEqual<size_t>(15, stdex::sprintf(L"This is %ls.", locale, L"a test").size());
Assert::IsTrue(stdex::sprintf(L"This is %ls.", locale, L"a test").size() == 15);
Assert::AreEqual("This is a test.", stdex::sprintf("This is %s.", locale, "a test").c_str());
Assert::AreEqual<size_t>(15, stdex::sprintf("This is %s.", locale, "a test").size());
Assert::IsTrue(stdex::sprintf("This is %s.", locale, "a test").size() == 15);
Assert::AreEqual(L"This is a 🐔Test🐮.", stdex::sprintf(L"This is %ls.", locale, L"a 🐔Test🐮").c_str());
Assert::AreEqual("This is a 🐔Test🐮.", stdex::sprintf("This is %s.", locale, "a 🐔Test🐮").c_str());
@ -38,9 +38,9 @@ namespace UnitTests
str += "🐔Test🐮\r\n";
}
Assert::AreEqual(wstr.c_str(), stdex::sprintf(L"%ls", locale, wstr.data()).c_str());
Assert::AreEqual(wstr.size(), stdex::sprintf(L"%ls", locale, wstr.data()).size());
Assert::IsTrue(stdex::sprintf(L"%ls", locale, wstr.data()).size() == wstr.size());
Assert::AreEqual(str.c_str(), stdex::sprintf("%s", locale, str.data()).c_str());
Assert::AreEqual(str.size(), stdex::sprintf("%s", locale, str.data()).size());
Assert::IsTrue(stdex::sprintf("%s", locale, str.data()).size() == str.size());
}
void string::snprintf()

8
UnitTests/zlib.cpp
View File

@ -21,8 +21,8 @@ namespace UnitTests
zlib.write(inflated, sizeof(inflated) - sizeof(*inflated));
}
static const uint8_t deflated[] = { 0x78, 0xda, 0x0b, 0xc9, 0xc8, 0x2c, 0x56, 0x00, 0xa2, 0x44, 0x85, 0x92, 0xd4, 0xe2, 0x12, 0x3d, 0x00, 0x29, 0x97, 0x05, 0x24 };
Assert::AreEqual<stdex::stream::fsize_t>(sizeof(deflated), dat_deflated.size());
Assert::AreEqual(0, memcmp(deflated, dat_deflated.data(), sizeof(deflated)));
Assert::IsTrue(dat_deflated.size() == sizeof(deflated));
Assert::IsTrue(memcmp(deflated, dat_deflated.data(), sizeof(deflated)) == 0);
dat_deflated.seekbeg(0);
stdex::stream::memory_file dat_inflated;
@ -30,7 +30,7 @@ namespace UnitTests
stdex::zlib_reader zlib(dat_deflated, 3);
dat_inflated.write_stream(zlib);
}
Assert::AreEqual<stdex::stream::fsize_t>(sizeof(inflated) - sizeof(*inflated), dat_inflated.size());
Assert::AreEqual(0, memcmp(inflated, dat_inflated.data(), sizeof(inflated) - sizeof(*inflated)));
Assert::IsTrue(dat_inflated.size() == sizeof(inflated) - sizeof(*inflated));
Assert::IsTrue(memcmp(inflated, dat_inflated.data(), sizeof(inflated) - sizeof(*inflated)) == 0);
}
}