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

32
UnitTests/langid.cpp
View File

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

28
UnitTests/math.cpp
View File

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

126
UnitTests/parser.cpp
View File

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

12
UnitTests/stream.cpp
View File

@ -36,14 +36,14 @@ namespace UnitTests
writer << i; writer << i;
} }
} }
Assert::AreEqual<stdex::stream::fpos_t>(0, source.seekbeg(0)); Assert::IsTrue(source.seekbeg(0) == 0);
{ {
async_reader<50> reader(source); async_reader<50> reader(source);
uint32_t x; uint32_t x;
for (uint32_t i = 0; i < total; ++i) { for (uint32_t i = 0; i < total; ++i) {
reader >> x; reader >> x;
Assert::IsTrue(reader.ok()); Assert::IsTrue(reader.ok());
Assert::AreEqual(i, x); Assert::IsTrue(x == i);
} }
reader >> x; reader >> x;
Assert::IsFalse(reader.ok()); Assert::IsFalse(reader.ok());
@ -90,13 +90,13 @@ namespace UnitTests
for (uint32_t i = 0; i < total; ++i) { for (uint32_t i = 0; i < total; ++i) {
f1 >> x; f1 >> x;
Assert::IsTrue(f1.ok()); Assert::IsTrue(f1.ok());
Assert::AreEqual(i, x); Assert::IsTrue(x == i);
f2_buf >> x; f2_buf >> x;
Assert::IsTrue(f2_buf.ok()); Assert::IsTrue(f2_buf.ok());
Assert::AreEqual(i, x); Assert::IsTrue(x == i);
f3 >> x; f3 >> x;
Assert::IsTrue(f3.ok()); Assert::IsTrue(f3.ok());
Assert::AreEqual(i, x); Assert::IsTrue(x == i);
} }
f1 >> x; f1 >> x;
Assert::IsFalse(f1.ok()); Assert::IsFalse(f1.ok());
@ -139,7 +139,7 @@ namespace UnitTests
dat >> x; dat >> x;
if (!dat.ok()) if (!dat.ok())
break; break;
Assert::AreEqual(i, x % count); Assert::IsTrue(x % count == i);
} }
} }
dat.close(); 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")); 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(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("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(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()); 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"; str += "🐔Test🐮\r\n";
} }
Assert::AreEqual(wstr.c_str(), stdex::sprintf(L"%ls", locale, wstr.data()).c_str()); 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.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() void string::snprintf()

8
UnitTests/zlib.cpp
View File

@ -21,8 +21,8 @@ namespace UnitTests
zlib.write(inflated, sizeof(inflated) - sizeof(*inflated)); 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 }; 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::IsTrue(dat_deflated.size() == sizeof(deflated));
Assert::AreEqual(0, memcmp(deflated, dat_deflated.data(), sizeof(deflated))); Assert::IsTrue(memcmp(deflated, dat_deflated.data(), sizeof(deflated)) == 0);
dat_deflated.seekbeg(0); dat_deflated.seekbeg(0);
stdex::stream::memory_file dat_inflated; stdex::stream::memory_file dat_inflated;
@ -30,7 +30,7 @@ namespace UnitTests
stdex::zlib_reader zlib(dat_deflated, 3); stdex::zlib_reader zlib(dat_deflated, 3);
dat_inflated.write_stream(zlib); dat_inflated.write_stream(zlib);
} }
Assert::AreEqual<stdex::stream::fsize_t>(sizeof(inflated) - sizeof(*inflated), dat_inflated.size()); Assert::IsTrue(dat_inflated.size() == sizeof(inflated) - sizeof(*inflated));
Assert::AreEqual(0, memcmp(inflated, dat_inflated.data(), sizeof(inflated) - sizeof(*inflated))); Assert::IsTrue(memcmp(inflated, dat_inflated.data(), sizeof(inflated) - sizeof(*inflated)) == 0);
} }
} }