Skip to content

Commit 1675c09

Browse files
murraycumurraycu
committed
test_mem_fun: Rearrange into individual test functions.
1 parent 0093540 commit 1675c09

File tree

1 file changed

+96
-91
lines changed

1 file changed

+96
-91
lines changed

‎tests/test_mem_fun.cc

Lines changed: 96 additions & 91 deletions
Original file line numberDiff line numberDiff line change
@@ -8,24 +8,21 @@
88
#include <sstream>
99
#include <cstdlib>
1010

11-
//TODO: put something like #ifndef FORTE (some older version, I think) or AIX xlC... #else ... #endif around:
11+
// TODO: put something like #ifndef FORTE (some older version, I think) or AIX xlC... #else ...
12+
// #endif around:
1213
#define ENABLE_TEST_OF_OVERLOADED_FUNCTIONS 0
1314

1415
namespace
1516
{
17+
18+
TestUtilities* util = nullptr;
1619
std::ostringstream result_stream;
1720

1821
struct test
1922
{
20-
void foo(short i1)
21-
{
22-
result_stream << "test::foo(short " << i1 << ')';
23-
}
23+
void foo(short i1) { result_stream << "test::foo(short " << i1 << ')'; }
2424

25-
void foo_const(int i1) const
26-
{
27-
result_stream << "test::foo_const(int " << i1 << ')';
28-
}
25+
void foo_const(int i1) const { result_stream << "test::foo_const(int " << i1 << ')'; }
2926

3027
void foo_volatile(float i1) volatile
3128
{
@@ -37,10 +34,7 @@ struct test
3734
result_stream << "test::foo_const_volatile(double " << i1 << ')';
3835
}
3936

40-
void foo_overloaded(char i1)
41-
{
42-
result_stream << "test::foo_overloaded(char " << int(i1) << ')';
43-
}
37+
void foo_overloaded(char i1) { result_stream << "test::foo_overloaded(char " << int(i1) << ')'; }
4438

4539
#if ENABLE_TEST_OF_OVERLOADED_FUNCTIONS
4640
void foo_overloaded(short i1)
@@ -58,105 +52,116 @@ struct test
5852

5953
} // end anonymous namespace
6054

61-
int main(int argc, char* argv[])
55+
void test_non_const()
6256
{
63-
auto util = TestUtilities::get_instance();
64-
65-
if (!util->check_command_args(argc, argv))
66-
return util->get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE;
67-
68-
{ /* test non-const */
69-
test t;
70-
sigc::mem_fun(&test::foo)(t, 1); // on reference
71-
util->check_result(result_stream, "test::foo(short 1)");
57+
test t;
58+
sigc::mem_fun (&test::foo)(t, 1);
59+
util->check_result(result_stream, "test::foo(short 1)");
60+
}
7261

73-
sigc::mem_fun(&test::foo)(&t, 1); // on pointer
74-
util->check_result(result_stream, "test::foo(short 1)");
75-
}
76-
{ /* test const */
77-
test t;
78-
sigc::mem_fun(&test::foo_const)(t, 2);
79-
util->check_result(result_stream, "test::foo_const(int 2)");
62+
void test_const()
63+
{
64+
test t;
65+
sigc::mem_fun (&test::foo_const)(t, 2);
66+
util->check_result(result_stream, "test::foo_const(int 2)");
67+
}
8068

81-
sigc::mem_fun(&test::foo_const)(&t, 2);
82-
util->check_result(result_stream, "test::foo_const(int 2)");
83-
}
84-
{ /* test const with const object */
85-
const auto t = test();
86-
sigc::mem_fun(&test::foo_const)(t, 3);
87-
util->check_result(result_stream, "test::foo_const(int 3)");
69+
void test_const_with_const_object()
70+
{
71+
const auto t = test();
72+
sigc::mem_fun (&test::foo_const)(t, 3);
73+
util->check_result(result_stream, "test::foo_const(int 3)");
74+
}
8875

89-
sigc::mem_fun(&test::foo_const)(&t, 3);
90-
util->check_result(result_stream, "test::foo_const(int 3)");
91-
}
92-
{ /* test non-const volatile */
93-
test t;
94-
sigc::mem_fun(&test::foo_volatile)(t, 4); // on reference
95-
util->check_result(result_stream, "test::foo_volatile(float 4)");
76+
void test_non_const_volatile()
77+
{
78+
test t;
79+
sigc::mem_fun (&test::foo_volatile)(t, 4);
80+
util->check_result(result_stream, "test::foo_volatile(float 4)");
81+
}
9682

97-
sigc::mem_fun(&test::foo_volatile)(&t, 4); // on pointer
98-
util->check_result(result_stream, "test::foo_volatile(float 4)");
99-
}
100-
{ /* test const volatile */
101-
test t;
102-
sigc::mem_fun(&test::foo_const_volatile)(t, 5); // on reference
103-
util->check_result(result_stream, "test::foo_const_volatile(double 5)");
83+
void test_const_volatile()
84+
{
85+
test t;
86+
sigc::mem_fun (&test::foo_const_volatile)(t, 5);
87+
util->check_result(result_stream, "test::foo_const_volatile(double 5)");
88+
}
10489

105-
sigc::mem_fun(&test::foo_const_volatile)(&t, 5); // on pointer
106-
util->check_result(result_stream, "test::foo_const_volatile(double 5)");
107-
}
108-
{ /* test const volatile with const object */
109-
const auto t = test();
110-
sigc::mem_fun(&test::foo_const_volatile)(t, 6); // on reference
111-
util->check_result(result_stream, "test::foo_const_volatile(double 6)");
90+
void test_const_volatile_with_const_object()
91+
{
92+
const auto t = test();
93+
sigc::mem_fun (&test::foo_const_volatile)(t, 6);
94+
util->check_result(result_stream, "test::foo_const_volatile(double 6)");
95+
}
11296

113-
sigc::mem_fun(&test::foo_const_volatile)(&t, 6); // on pointer
114-
util->check_result(result_stream, "test::foo_const_volatile(double 6)");
115-
}
11697
#if ENABLE_TEST_OF_OVERLOADED_FUNCTIONS
117-
{ /* test overloaded */
118-
test t;
119-
sigc::mem_fun1<char>(&test::foo_overloaded)(&t, 7);
120-
util->check_result(result_stream, "test::foo_overloaded(char 7)");
98+
void test_overloaded()
99+
{
100+
test t;
101+
sigc::mem_fun<char> (&test::foo_overloaded)(t, 7);
102+
util->check_result(result_stream, "test::foo_overloaded(char 7)");
121103

122-
sigc::mem_fun1<short>(&test::foo_overloaded)(&t, 7);
123-
util->check_result(result_stream, "test::foo_overloaded(short 7)");
104+
sigc::mem_fun<short> (&test::foo_overloaded)(t, 7);
105+
util->check_result(result_stream, "test::foo_overloaded(short 7)");
124106

125-
//sigc::mem_fun1(&test::foo_overloaded)(&t, 7);
126-
//util->check_result(result_stream, "test::foo_overloaded(short 7)");
107+
// sigc::mem_fun(&test::foo_overloaded)(t, 7);
108+
// util->check_result(result_stream, "test::foo_overloaded(short 7)");
127109

128-
sigc::mem_fun2(&test::foo_overloaded)(&t, 7, 8);
129-
util->check_result(result_stream, "test::foo_overloaded(int 7, int 8)");
130-
}
110+
sigc::mem_fun (&test::foo_overloaded)(t, 7, 8);
111+
util->check_result(result_stream, "test::foo_overloaded(int 7, int 8)");
112+
}
131113
#endif
132-
{ /* test bound */
133-
test t;
134-
sigc::mem_fun(t, &test::foo)(9);
135-
util->check_result(result_stream, "test::foo(short 9)");
136114

137-
sigc::mem_fun(&t, &test::foo)(9);
138-
util->check_result(result_stream, "test::foo(short 9)");
115+
void test_bound()
116+
{
117+
test t;
118+
sigc::mem_fun(t, &test::foo)(9);
119+
util->check_result(result_stream, "test::foo(short 9)");
139120

140-
sigc::mem_fun(t, &test::foo_const)(9);
141-
util->check_result(result_stream, "test::foo_const(int 9)");
121+
sigc::mem_fun(t, &test::foo)(9);
122+
util->check_result(result_stream, "test::foo(short 9)");
142123

143-
sigc::mem_fun(&t, &test::foo_const)(9);
144-
util->check_result(result_stream, "test::foo_const(int 9)");
124+
sigc::mem_fun(t, &test::foo_const)(9);
125+
util->check_result(result_stream, "test::foo_const(int 9)");
145126

146-
sigc::mem_fun(t, &test::foo_volatile)(9);
147-
util->check_result(result_stream, "test::foo_volatile(float 9)");
127+
sigc::mem_fun(t, &test::foo_const)(9);
128+
util->check_result(result_stream, "test::foo_const(int 9)");
148129

149-
sigc::mem_fun(&t, &test::foo_volatile)(9);
150-
util->check_result(result_stream, "test::foo_volatile(float 9)");
130+
sigc::mem_fun(t, &test::foo_volatile)(9);
131+
util->check_result(result_stream, "test::foo_volatile(float 9)");
132+
133+
sigc::mem_fun(t, &test::foo_volatile)(9);
134+
util->check_result(result_stream, "test::foo_volatile(float 9)");
151135

152136
#if ENABLE_TEST_OF_OVERLOADED_FUNCTIONS
153-
sigc::mem_fun2(t, &test::foo_overloaded)(9, 10);
154-
util->check_result(result_stream, "test::foo_overloaded(int 9, int 10)");
137+
sigc::mem_fun(t, &test::foo_overloaded)(9, 10);
138+
util->check_result(result_stream, "test::foo_overloaded(int 9, int 10)");
155139

156-
sigc::mem_fun2(&t, &test::foo_overloaded)(9, 10);
157-
util->check_result(result_stream, "test::foo_overloaded(int 9, int 10)");
140+
sigc::mem_fun(t, &test::foo_overloaded)(9, 10);
141+
util->check_result(result_stream, "test::foo_overloaded(int 9, int 10)");
158142
#endif
159-
}
143+
}
144+
145+
int
146+
main(int argc, char* argv[])
147+
{
148+
util = TestUtilities::get_instance();
149+
150+
if (!util->check_command_args(argc, argv))
151+
return util->get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE;
152+
153+
test_non_const();
154+
test_const();
155+
test_const_with_const_object();
156+
test_non_const_volatile();
157+
test_const_volatile();
158+
test_const_volatile_with_const_object();
159+
160+
#if ENABLE_TEST_OF_OVERLOADED_FUNCTIONS
161+
test_overload();
162+
#endif
163+
164+
test_bound();
160165

161166
return util->get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE;
162167
}

0 commit comments

Comments
 (0)