Magic-Mirror/llvm-capstone
1
0
Fork 0
mirror of https://github.com/capstone-engine/llvm-capstone.git synced 2024-11-23 05:40:09 +00:00
Code Issues Actions 2 Packages Projects Releases Wiki Activity

[libc++][test] Use LIBCPP_ASSERT in some system_category-related tests (#78834)

Browse Source
This commit is contained in:
S. B. Tam 2024-01-23 13:25:13 +08:00 committed by GitHub
parent 8c3304453c
commit f1d3ebc991
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
3 changed files with 119 additions and 119 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

147
libcxx/test/std/diagnostics/syserr/syserr.compare/eq_error_code_error_code.pass.cpp
View File

@ -22,88 +22,87 @@
#include "test_macros.h"
int main(int, char**)
{
std::error_code e_code1(5, std::generic_category());
std::error_code e_code2(5, std::system_category());
std::error_code e_code3(6, std::generic_category());
std::error_code e_code4(6, std::system_category());
std::error_condition e_condition1(5, std::generic_category());
std::error_condition e_condition2(5, std::system_category());
std::error_condition e_condition3(6, std::generic_category());
std::error_condition e_condition4(6, std::system_category());
int main(int, char**) {
std::error_code e_code1(5, std::generic_category());
std::error_code e_code2(5, std::system_category());
std::error_code e_code3(6, std::generic_category());
std::error_code e_code4(6, std::system_category());
std::error_condition e_condition1(5, std::generic_category());
std::error_condition e_condition2(5, std::system_category());
std::error_condition e_condition3(6, std::generic_category());
std::error_condition e_condition4(6, std::system_category());
assert(e_code1 == e_code1);
assert(e_code1 != e_code2);
assert(e_code1 != e_code3);
assert(e_code1 != e_code4);
assert(e_code1 == e_condition1);
assert(e_code1 != e_condition2);
assert(e_code1 != e_condition3);
assert(e_code1 != e_condition4);
assert(e_code1 == e_code1);
assert(e_code1 != e_code2);
assert(e_code1 != e_code3);
assert(e_code1 != e_code4);
assert(e_code1 == e_condition1);
assert(e_code1 != e_condition2);
assert(e_code1 != e_condition3);
assert(e_code1 != e_condition4);
assert(e_code2 != e_code1);
assert(e_code2 == e_code2);
assert(e_code2 != e_code3);
assert(e_code2 != e_code4);
assert(e_code2 == e_condition1); // ?
assert(e_code2 == e_condition2);
assert(e_code2 != e_condition3);
assert(e_code2 != e_condition4);
assert(e_code2 != e_code1);
assert(e_code2 == e_code2);
assert(e_code2 != e_code3);
assert(e_code2 != e_code4);
LIBCPP_ASSERT(e_code2 == e_condition1);
assert(e_code2 == e_condition2);
LIBCPP_ASSERT(e_code2 != e_condition3);
assert(e_code2 != e_condition4);
assert(e_code3 != e_code1);
assert(e_code3 != e_code2);
assert(e_code3 == e_code3);
assert(e_code3 != e_code4);
assert(e_code3 != e_condition1);
assert(e_code3 != e_condition2);
assert(e_code3 == e_condition3);
assert(e_code3 != e_condition4);
assert(e_code3 != e_code1);
assert(e_code3 != e_code2);
assert(e_code3 == e_code3);
assert(e_code3 != e_code4);
assert(e_code3 != e_condition1);
assert(e_code3 != e_condition2);
assert(e_code3 == e_condition3);
assert(e_code3 != e_condition4);
assert(e_code4 != e_code1);
assert(e_code4 != e_code2);
assert(e_code4 != e_code3);
assert(e_code4 == e_code4);
assert(e_code4 != e_condition1);
assert(e_code4 != e_condition2);
assert(e_code4 == e_condition3); // ?
assert(e_code4 == e_condition4);
assert(e_code4 != e_code1);
assert(e_code4 != e_code2);
assert(e_code4 != e_code3);
assert(e_code4 == e_code4);
LIBCPP_ASSERT(e_code4 != e_condition1);
assert(e_code4 != e_condition2);
LIBCPP_ASSERT(e_code4 == e_condition3);
assert(e_code4 == e_condition4);
assert(e_condition1 == e_code1);
assert(e_condition1 == e_code2); // ?
assert(e_condition1 != e_code3);
assert(e_condition1 != e_code4);
assert(e_condition1 == e_condition1);
assert(e_condition1 != e_condition2);
assert(e_condition1 != e_condition3);
assert(e_condition1 != e_condition4);
assert(e_condition1 == e_code1);
LIBCPP_ASSERT(e_condition1 == e_code2);
assert(e_condition1 != e_code3);
LIBCPP_ASSERT(e_condition1 != e_code4);
assert(e_condition1 == e_condition1);
assert(e_condition1 != e_condition2);
assert(e_condition1 != e_condition3);
assert(e_condition1 != e_condition4);
assert(e_condition2 != e_code1);
assert(e_condition2 == e_code2);
assert(e_condition2 != e_code3);
assert(e_condition2 != e_code4);
assert(e_condition2 != e_condition1);
assert(e_condition2 == e_condition2);
assert(e_condition2 != e_condition3);
assert(e_condition2 != e_condition4);
assert(e_condition2 != e_code1);
assert(e_condition2 == e_code2);
assert(e_condition2 != e_code3);
assert(e_condition2 != e_code4);
assert(e_condition2 != e_condition1);
assert(e_condition2 == e_condition2);
assert(e_condition2 != e_condition3);
assert(e_condition2 != e_condition4);
assert(e_condition3 != e_code1);
assert(e_condition3 != e_code2);
assert(e_condition3 == e_code3);
assert(e_condition3 == e_code4); // ?
assert(e_condition3 != e_condition1);
assert(e_condition3 != e_condition2);
assert(e_condition3 == e_condition3);
assert(e_condition3 != e_condition4);
assert(e_condition3 != e_code1);
LIBCPP_ASSERT(e_condition3 != e_code2);
assert(e_condition3 == e_code3);
LIBCPP_ASSERT(e_condition3 == e_code4);
assert(e_condition3 != e_condition1);
assert(e_condition3 != e_condition2);
assert(e_condition3 == e_condition3);
assert(e_condition3 != e_condition4);
assert(e_condition4 != e_code1);
assert(e_condition4 != e_code2);
assert(e_condition4 != e_code3);
assert(e_condition4 == e_code4);
assert(e_condition4 != e_condition1);
assert(e_condition4 != e_condition2);
assert(e_condition4 != e_condition3);
assert(e_condition4 == e_condition4);
assert(e_condition4 != e_code1);
assert(e_condition4 != e_code2);
assert(e_condition4 != e_code3);
assert(e_condition4 == e_code4);
assert(e_condition4 != e_condition1);
assert(e_condition4 != e_condition2);
assert(e_condition4 != e_condition3);
assert(e_condition4 == e_condition4);
return 0;
}

23
libcxx/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.derived/message.pass.cpp
View File

@ -20,18 +20,17 @@
#include "test_macros.h"
int main(int, char**)
{
const std::error_category& e_cat1 = std::generic_category();
const std::error_category& e_cat2 = std::system_category();
std::string m1 = e_cat1.message(5);
std::string m2 = e_cat2.message(5);
std::string m3 = e_cat2.message(6);
assert(!m1.empty());
assert(!m2.empty());
assert(!m3.empty());
assert(m1 == m2);
assert(m1 != m3);
int main(int, char**) {
const std::error_category& e_cat1 = std::generic_category();
const std::error_category& e_cat2 = std::system_category();
std::string m1 = e_cat1.message(5);
std::string m2 = e_cat2.message(5);
std::string m3 = e_cat2.message(6);
assert(!m1.empty());
assert(!m2.empty());
assert(!m3.empty());
LIBCPP_ASSERT(m1 == m2);
assert(m1 != m3);
return 0;
}

68
libcxx/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.objects/system_category.pass.cpp
View File

@ -23,47 +23,49 @@
// See https://llvm.org/D65667
struct StaticInit {
const std::error_category* ec;
~StaticInit() {
std::string str = ec->name();
assert(str == "system") ;
}
const std::error_category* ec;
~StaticInit() {
std::string str = ec->name();
assert(str == "system");
}
};
static StaticInit foo;
int main(int, char**)
{
{
const std::error_category& e_cat1 = std::system_category();
std::error_condition e_cond = e_cat1.default_error_condition(5);
assert(e_cond.value() == 5);
assert(e_cond.category() == std::generic_category());
e_cond = e_cat1.default_error_condition(5000);
assert(e_cond.value() == 5000);
assert(e_cond.category() == std::system_category());
}
int main(int, char**) {
{
const std::error_category& e_cat1 = std::system_category();
std::error_condition e_cond = e_cat1.default_error_condition(5);
LIBCPP_ASSERT(e_cond.value() == 5);
LIBCPP_ASSERT(e_cond.category() == std::generic_category());
assert(e_cat1.equivalent(5, e_cond));
// Test the result of message(int cond) when given a bad error condition
{
errno = E2BIG; // something that message will never generate
const std::error_category& e_cat1 = std::system_category();
const std::string msg = e_cat1.message(-1);
// Exact message format varies by platform.
e_cond = e_cat1.default_error_condition(5000);
LIBCPP_ASSERT(e_cond.value() == 5000);
LIBCPP_ASSERT(e_cond.category() == std::system_category());
assert(e_cat1.equivalent(5000, e_cond));
}
// Test the result of message(int cond) when given a bad error condition
{
errno = E2BIG; // something that message will never generate
const std::error_category& e_cat1 = std::system_category();
const std::string msg = e_cat1.message(-1);
// Exact message format varies by platform.
#if defined(_AIX)
LIBCPP_ASSERT(msg.rfind("Error -1 occurred", 0) == 0);
LIBCPP_ASSERT(msg.rfind("Error -1 occurred", 0) == 0);
#elif defined(_NEWLIB_VERSION)
LIBCPP_ASSERT(msg.empty());
LIBCPP_ASSERT(msg.empty());
#else
LIBCPP_ASSERT(msg.rfind("Unknown error", 0) == 0);
LIBCPP_ASSERT(msg.rfind("Unknown error", 0) == 0);
#endif
assert(errno == E2BIG);
}
assert(errno == E2BIG);
}
{
foo.ec = &std::system_category();
std::string m = foo.ec->name();
assert(m == "system");
}
{
foo.ec = &std::system_category();
std::string m = foo.ec->name();
assert(m == "system");
}
return 0;
return 0;
}