Skip to content

Commit f1d3ebc

Browse files
cpplearnercpplearner
authored
[libc++][test] Use LIBCPP_ASSERT in some system_category-related tests (#78834)
1 parent 8c33044 commit f1d3ebc

File tree

3 files changed

+119
-119
lines changed

3 files changed

+119
-119
lines changed

‎libcxx/test/std/diagnostics/syserr/syserr.compare/eq_error_code_error_code.pass.cpp

Lines changed: 73 additions & 74 deletions
Original file line numberDiff line numberDiff line change
@@ -22,88 +22,87 @@
2222

2323
#include "test_macros.h"
2424

25-
int main(int, char**)
26-
{
27-
std::error_code e_code1(5, std::generic_category());
28-
std::error_code e_code2(5, std::system_category());
29-
std::error_code e_code3(6, std::generic_category());
30-
std::error_code e_code4(6, std::system_category());
31-
std::error_condition e_condition1(5, std::generic_category());
32-
std::error_condition e_condition2(5, std::system_category());
33-
std::error_condition e_condition3(6, std::generic_category());
34-
std::error_condition e_condition4(6, std::system_category());
25+
int main(int, char**) {
26+
std::error_code e_code1(5, std::generic_category());
27+
std::error_code e_code2(5, std::system_category());
28+
std::error_code e_code3(6, std::generic_category());
29+
std::error_code e_code4(6, std::system_category());
30+
std::error_condition e_condition1(5, std::generic_category());
31+
std::error_condition e_condition2(5, std::system_category());
32+
std::error_condition e_condition3(6, std::generic_category());
33+
std::error_condition e_condition4(6, std::system_category());
3534

36-
assert(e_code1 == e_code1);
37-
assert(e_code1 != e_code2);
38-
assert(e_code1 != e_code3);
39-
assert(e_code1 != e_code4);
40-
assert(e_code1 == e_condition1);
41-
assert(e_code1 != e_condition2);
42-
assert(e_code1 != e_condition3);
43-
assert(e_code1 != e_condition4);
35+
assert(e_code1 == e_code1);
36+
assert(e_code1 != e_code2);
37+
assert(e_code1 != e_code3);
38+
assert(e_code1 != e_code4);
39+
assert(e_code1 == e_condition1);
40+
assert(e_code1 != e_condition2);
41+
assert(e_code1 != e_condition3);
42+
assert(e_code1 != e_condition4);
4443

45-
assert(e_code2 != e_code1);
46-
assert(e_code2 == e_code2);
47-
assert(e_code2 != e_code3);
48-
assert(e_code2 != e_code4);
49-
assert(e_code2 == e_condition1); // ?
50-
assert(e_code2 == e_condition2);
51-
assert(e_code2 != e_condition3);
52-
assert(e_code2 != e_condition4);
44+
assert(e_code2 != e_code1);
45+
assert(e_code2 == e_code2);
46+
assert(e_code2 != e_code3);
47+
assert(e_code2 != e_code4);
48+
LIBCPP_ASSERT(e_code2 == e_condition1);
49+
assert(e_code2 == e_condition2);
50+
LIBCPP_ASSERT(e_code2 != e_condition3);
51+
assert(e_code2 != e_condition4);
5352

54-
assert(e_code3 != e_code1);
55-
assert(e_code3 != e_code2);
56-
assert(e_code3 == e_code3);
57-
assert(e_code3 != e_code4);
58-
assert(e_code3 != e_condition1);
59-
assert(e_code3 != e_condition2);
60-
assert(e_code3 == e_condition3);
61-
assert(e_code3 != e_condition4);
53+
assert(e_code3 != e_code1);
54+
assert(e_code3 != e_code2);
55+
assert(e_code3 == e_code3);
56+
assert(e_code3 != e_code4);
57+
assert(e_code3 != e_condition1);
58+
assert(e_code3 != e_condition2);
59+
assert(e_code3 == e_condition3);
60+
assert(e_code3 != e_condition4);
6261

63-
assert(e_code4 != e_code1);
64-
assert(e_code4 != e_code2);
65-
assert(e_code4 != e_code3);
66-
assert(e_code4 == e_code4);
67-
assert(e_code4 != e_condition1);
68-
assert(e_code4 != e_condition2);
69-
assert(e_code4 == e_condition3); // ?
70-
assert(e_code4 == e_condition4);
62+
assert(e_code4 != e_code1);
63+
assert(e_code4 != e_code2);
64+
assert(e_code4 != e_code3);
65+
assert(e_code4 == e_code4);
66+
LIBCPP_ASSERT(e_code4 != e_condition1);
67+
assert(e_code4 != e_condition2);
68+
LIBCPP_ASSERT(e_code4 == e_condition3);
69+
assert(e_code4 == e_condition4);
7170

72-
assert(e_condition1 == e_code1);
73-
assert(e_condition1 == e_code2); // ?
74-
assert(e_condition1 != e_code3);
75-
assert(e_condition1 != e_code4);
76-
assert(e_condition1 == e_condition1);
77-
assert(e_condition1 != e_condition2);
78-
assert(e_condition1 != e_condition3);
79-
assert(e_condition1 != e_condition4);
71+
assert(e_condition1 == e_code1);
72+
LIBCPP_ASSERT(e_condition1 == e_code2);
73+
assert(e_condition1 != e_code3);
74+
LIBCPP_ASSERT(e_condition1 != e_code4);
75+
assert(e_condition1 == e_condition1);
76+
assert(e_condition1 != e_condition2);
77+
assert(e_condition1 != e_condition3);
78+
assert(e_condition1 != e_condition4);
8079

81-
assert(e_condition2 != e_code1);
82-
assert(e_condition2 == e_code2);
83-
assert(e_condition2 != e_code3);
84-
assert(e_condition2 != e_code4);
85-
assert(e_condition2 != e_condition1);
86-
assert(e_condition2 == e_condition2);
87-
assert(e_condition2 != e_condition3);
88-
assert(e_condition2 != e_condition4);
80+
assert(e_condition2 != e_code1);
81+
assert(e_condition2 == e_code2);
82+
assert(e_condition2 != e_code3);
83+
assert(e_condition2 != e_code4);
84+
assert(e_condition2 != e_condition1);
85+
assert(e_condition2 == e_condition2);
86+
assert(e_condition2 != e_condition3);
87+
assert(e_condition2 != e_condition4);
8988

90-
assert(e_condition3 != e_code1);
91-
assert(e_condition3 != e_code2);
92-
assert(e_condition3 == e_code3);
93-
assert(e_condition3 == e_code4); // ?
94-
assert(e_condition3 != e_condition1);
95-
assert(e_condition3 != e_condition2);
96-
assert(e_condition3 == e_condition3);
97-
assert(e_condition3 != e_condition4);
89+
assert(e_condition3 != e_code1);
90+
LIBCPP_ASSERT(e_condition3 != e_code2);
91+
assert(e_condition3 == e_code3);
92+
LIBCPP_ASSERT(e_condition3 == e_code4);
93+
assert(e_condition3 != e_condition1);
94+
assert(e_condition3 != e_condition2);
95+
assert(e_condition3 == e_condition3);
96+
assert(e_condition3 != e_condition4);
9897

99-
assert(e_condition4 != e_code1);
100-
assert(e_condition4 != e_code2);
101-
assert(e_condition4 != e_code3);
102-
assert(e_condition4 == e_code4);
103-
assert(e_condition4 != e_condition1);
104-
assert(e_condition4 != e_condition2);
105-
assert(e_condition4 != e_condition3);
106-
assert(e_condition4 == e_condition4);
98+
assert(e_condition4 != e_code1);
99+
assert(e_condition4 != e_code2);
100+
assert(e_condition4 != e_code3);
101+
assert(e_condition4 == e_code4);
102+
assert(e_condition4 != e_condition1);
103+
assert(e_condition4 != e_condition2);
104+
assert(e_condition4 != e_condition3);
105+
assert(e_condition4 == e_condition4);
107106

108107
return 0;
109108
}

‎libcxx/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.derived/message.pass.cpp

Lines changed: 11 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -20,18 +20,17 @@
2020

2121
#include "test_macros.h"
2222

23-
int main(int, char**)
24-
{
25-
const std::error_category& e_cat1 = std::generic_category();
26-
const std::error_category& e_cat2 = std::system_category();
27-
std::string m1 = e_cat1.message(5);
28-
std::string m2 = e_cat2.message(5);
29-
std::string m3 = e_cat2.message(6);
30-
assert(!m1.empty());
31-
assert(!m2.empty());
32-
assert(!m3.empty());
33-
assert(m1 == m2);
34-
assert(m1 != m3);
23+
int main(int, char**) {
24+
const std::error_category& e_cat1 = std::generic_category();
25+
const std::error_category& e_cat2 = std::system_category();
26+
std::string m1 = e_cat1.message(5);
27+
std::string m2 = e_cat2.message(5);
28+
std::string m3 = e_cat2.message(6);
29+
assert(!m1.empty());
30+
assert(!m2.empty());
31+
assert(!m3.empty());
32+
LIBCPP_ASSERT(m1 == m2);
33+
assert(m1 != m3);
3534

3635
return 0;
3736
}

‎libcxx/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.objects/system_category.pass.cpp

Lines changed: 35 additions & 33 deletions
Original file line numberDiff line numberDiff line change
@@ -23,47 +23,49 @@
2323

2424
// See https://llvm.org/D65667
2525
struct StaticInit {
26-
const std::error_category* ec;
27-
~StaticInit() {
28-
std::string str = ec->name();
29-
assert(str == "system") ;
30-
}
26+
const std::error_category* ec;
27+
~StaticInit() {
28+
std::string str = ec->name();
29+
assert(str == "system");
30+
}
3131
};
3232
static StaticInit foo;
3333

34-
int main(int, char**)
35-
{
36-
{
37-
const std::error_category& e_cat1 = std::system_category();
38-
std::error_condition e_cond = e_cat1.default_error_condition(5);
39-
assert(e_cond.value() == 5);
40-
assert(e_cond.category() == std::generic_category());
41-
e_cond = e_cat1.default_error_condition(5000);
42-
assert(e_cond.value() == 5000);
43-
assert(e_cond.category() == std::system_category());
44-
}
34+
int main(int, char**) {
35+
{
36+
const std::error_category& e_cat1 = std::system_category();
37+
std::error_condition e_cond = e_cat1.default_error_condition(5);
38+
LIBCPP_ASSERT(e_cond.value() == 5);
39+
LIBCPP_ASSERT(e_cond.category() == std::generic_category());
40+
assert(e_cat1.equivalent(5, e_cond));
4541

46-
// Test the result of message(int cond) when given a bad error condition
47-
{
48-
errno = E2BIG; // something that message will never generate
49-
const std::error_category& e_cat1 = std::system_category();
50-
const std::string msg = e_cat1.message(-1);
51-
// Exact message format varies by platform.
42+
e_cond = e_cat1.default_error_condition(5000);
43+
LIBCPP_ASSERT(e_cond.value() == 5000);
44+
LIBCPP_ASSERT(e_cond.category() == std::system_category());
45+
assert(e_cat1.equivalent(5000, e_cond));
46+
}
47+
48+
// Test the result of message(int cond) when given a bad error condition
49+
{
50+
errno = E2BIG; // something that message will never generate
51+
const std::error_category& e_cat1 = std::system_category();
52+
const std::string msg = e_cat1.message(-1);
53+
// Exact message format varies by platform.
5254
#if defined(_AIX)
53-
LIBCPP_ASSERT(msg.rfind("Error -1 occurred", 0) == 0);
55+
LIBCPP_ASSERT(msg.rfind("Error -1 occurred", 0) == 0);
5456
#elif defined(_NEWLIB_VERSION)
55-
LIBCPP_ASSERT(msg.empty());
57+
LIBCPP_ASSERT(msg.empty());
5658
#else
57-
LIBCPP_ASSERT(msg.rfind("Unknown error", 0) == 0);
59+
LIBCPP_ASSERT(msg.rfind("Unknown error", 0) == 0);
5860
#endif
59-
assert(errno == E2BIG);
60-
}
61+
assert(errno == E2BIG);
62+
}
6163

62-
{
63-
foo.ec = &std::system_category();
64-
std::string m = foo.ec->name();
65-
assert(m == "system");
66-
}
64+
{
65+
foo.ec = &std::system_category();
66+
std::string m = foo.ec->name();
67+
assert(m == "system");
68+
}
6769

68-
return 0;
70+
return 0;
6971
}

0 commit comments

Comments
 (0)