1 /*
2 * Created by Phil on 29/11/2010.
3 * Copyright 2010 Two Blue Cubes Ltd. All rights reserved.
4 *
5 * Distributed under the Boost Software License, Version 1.0. (See accompanying
6 * file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
7 */
8
9 #include "catch.hpp"
10
11 #ifdef __clang__
12 # pragma clang diagnostic ignored "-Wc++98-compat"
13 # pragma clang diagnostic ignored "-Wc++98-compat-pedantic"
14 #endif
15
16
17 #include <iostream>
18 #include <cerrno>
19 #include <limits>
20 #include <sstream>
21 #include <array>
22
23 namespace { namespace MiscTests {
24
25 #ifndef MISC_TEST_HELPERS_INCLUDED // Don't compile this more than once per TU
26 #define MISC_TEST_HELPERS_INCLUDED
27
makeString(bool makeNull)28 inline const char* makeString( bool makeNull ) {
29 return makeNull ? nullptr : "valid string";
30 }
testCheckedIf(bool flag)31 inline bool testCheckedIf( bool flag ) {
32 CHECKED_IF( flag )
33 return true;
34 else
35 return false;
36 }
testCheckedElse(bool flag)37 inline bool testCheckedElse( bool flag ) {
38 CHECKED_ELSE( flag )
39 return false;
40
41 return true;
42 }
43
Factorial(unsigned int number)44 inline unsigned int Factorial( unsigned int number ) {
45 return number > 1 ? Factorial(number-1)*number : 1;
46 }
47
f()48 static int f() {
49 return 1;
50 }
51
manuallyRegisteredTestFunction()52 inline void manuallyRegisteredTestFunction() {
53 SUCCEED( "was called" );
54 }
55
56 struct AutoTestReg {
AutoTestReg__anon89a74b430111::MiscTests::AutoTestReg57 AutoTestReg() {
58 REGISTER_TEST_CASE( manuallyRegisteredTestFunction, "ManuallyRegistered" );
59 }
60 };
61
62 CATCH_INTERNAL_START_WARNINGS_SUPPRESSION
63 CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS
64 static AutoTestReg autoTestReg;
65 CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
66
67 template<typename T>
68 struct Foo {
size__anon89a74b430111::MiscTests::Foo69 size_t size() { return 0; }
70 };
71
72 template<typename T, size_t S>
73 struct Bar {
size__anon89a74b430111::MiscTests::Bar74 size_t size() { return S; }
75 };
76 #endif
77
78 TEST_CASE( "random SECTION tests", "[.][sections][failing]" ) {
79 int a = 1;
80 int b = 2;
81
82 SECTION( "doesn't equal" ) {
83 REQUIRE( a != b );
84 REQUIRE( b != a );
85 }
86
87 SECTION( "not equal" ) {
88 REQUIRE( a != b);
89 }
90 }
91
92 TEST_CASE( "nested SECTION tests", "[.][sections][failing]" ) {
93 int a = 1;
94 int b = 2;
95
96 SECTION( "doesn't equal" ) {
97 REQUIRE( a != b );
98 REQUIRE( b != a );
99
100 SECTION( "not equal" ) {
101 REQUIRE( a != b);
102 }
103 }
104 }
105
106 TEST_CASE( "more nested SECTION tests", "[sections][failing][.]" ) {
107 int a = 1;
108 int b = 2;
109
110 SECTION( "doesn't equal" ) {
111 SECTION( "equal" ) {
112 REQUIRE( a == b );
113 }
114
115 SECTION( "not equal" ) {
116 REQUIRE( a != b );
117 }
118 SECTION( "less than" ) {
119 REQUIRE( a < b );
120 }
121 }
122 }
123
124 TEST_CASE( "even more nested SECTION tests", "[sections]" ) {
125 SECTION( "c" ) {
126 SECTION( "d (leaf)" ) {
127 SUCCEED(); // avoid failing due to no tests
128 }
129
130 SECTION( "e (leaf)" ) {
131 SUCCEED(); // avoid failing due to no tests
132 }
133 }
134
135 SECTION( "f (leaf)" ) {
136 SUCCEED(); // avoid failing due to no tests
137 }
138 }
139
140 TEST_CASE( "looped SECTION tests", "[.][failing][sections]" ) {
141 int a = 1;
142
143 for( int b = 0; b < 10; ++b ) {
144 DYNAMIC_SECTION( "b is currently: " << b ) {
145 CHECK( b > a );
146 }
147 }
148 }
149
150 TEST_CASE( "looped tests", "[.][failing]" ) {
151 static const int fib[] = { 1, 1, 2, 3, 5, 8, 13, 21 };
152
153 for( std::size_t i=0; i < sizeof(fib)/sizeof(int); ++i ) {
154 INFO( "Testing if fib[" << i << "] (" << fib[i] << ") is even" );
155 CHECK( ( fib[i] % 2 ) == 0 );
156 }
157 }
158
159 TEST_CASE( "Sends stuff to stdout and stderr", "[.]" ) {
160 std::cout << "A string sent directly to stdout" << std::endl;
161 std::cerr << "A string sent directly to stderr" << std::endl;
162 std::clog << "A string sent to stderr via clog" << std::endl;
163 }
164
165 TEST_CASE( "null strings" ) {
166 REQUIRE( makeString( false ) != static_cast<char*>(nullptr));
167 REQUIRE( makeString( true ) == static_cast<char*>(nullptr));
168 }
169
170 TEST_CASE( "checkedIf" ) {
171 REQUIRE( testCheckedIf( true ) );
172 }
173
174 TEST_CASE( "checkedIf, failing", "[failing][.]" ) {
175 REQUIRE( testCheckedIf( false ) );
176 }
177
178 TEST_CASE( "checkedElse" ) {
179 REQUIRE( testCheckedElse( true ) );
180 }
181
182 TEST_CASE( "checkedElse, failing", "[failing][.]" ) {
183 REQUIRE( testCheckedElse( false ) );
184 }
185
186 TEST_CASE( "xmlentitycheck" ) {
187 SECTION( "embedded xml: <test>it should be possible to embed xml characters, such as <, \" or &, or even whole <xml>documents</xml> within an attribute</test>" ) {
188 SUCCEED(); // We need this here to stop it failing due to no tests
189 }
190 SECTION( "encoded chars: these should all be encoded: &&&\"\"\"<<<&\"<<&\"" ) {
191 SUCCEED(); // We need this here to stop it failing due to no tests
192 }
193 }
194
195 TEST_CASE( "send a single char to INFO", "[failing][.]" ) {
196 INFO(3);
197 REQUIRE(false);
198 }
199
200 TEST_CASE( "atomic if", "[failing][0]") {
201 std::size_t x = 0;
202
203 if( x )
204 REQUIRE(x > 0);
205 else
206 REQUIRE(x == 0);
207 }
208
209
210 TEST_CASE( "Factorials are computed", "[factorial]" ) {
211 REQUIRE( Factorial(0) == 1 );
212 REQUIRE( Factorial(1) == 1 );
213 REQUIRE( Factorial(2) == 2 );
214 REQUIRE( Factorial(3) == 6 );
215 REQUIRE( Factorial(10) == 3628800 );
216 }
217
218 TEST_CASE( "An empty test with no assertions", "[empty]" ) {}
219
220 TEST_CASE( "Nice descriptive name", "[tag1][tag2][tag3][.]" ) {
221 WARN( "This one ran" );
222 }
223 TEST_CASE( "first tag", "[tag1]" ) {}
224 TEST_CASE( "second tag", "[tag2]" ) {}
225
226 //
227 //TEST_CASE( "spawn a new process", "[.]" )
228 //{
229 // // !TBD Work in progress
230 // char line[200];
231 // FILE* output = popen("./CatchSelfTest ./failing/matchers/StartsWith", "r");
232 // while ( fgets(line, 199, output) )
233 // std::cout << line;
234 //}
235
236 TEST_CASE( "vectors can be sized and resized", "[vector]" ) {
237
238 std::vector<int> v( 5 );
239
240 REQUIRE( v.size() == 5 );
241 REQUIRE( v.capacity() >= 5 );
242
243 SECTION( "resizing bigger changes size and capacity" ) {
244 v.resize( 10 );
245
246 REQUIRE( v.size() == 10 );
247 REQUIRE( v.capacity() >= 10 );
248 }
249 SECTION( "resizing smaller changes size but not capacity" ) {
250 v.resize( 0 );
251
252 REQUIRE( v.size() == 0 );
253 REQUIRE( v.capacity() >= 5 );
254
255 SECTION( "We can use the 'swap trick' to reset the capacity" ) {
256 std::vector<int> empty;
257 empty.swap( v );
258
259 REQUIRE( v.capacity() == 0 );
260 }
261 }
262 SECTION( "reserving bigger changes capacity but not size" ) {
263 v.reserve( 10 );
264
265 REQUIRE( v.size() == 5 );
266 REQUIRE( v.capacity() >= 10 );
267 }
268 SECTION( "reserving smaller does not change size or capacity" ) {
269 v.reserve( 0 );
270
271 REQUIRE( v.size() == 5 );
272 REQUIRE( v.capacity() >= 5 );
273 }
274 }
275
276 TEMPLATE_TEST_CASE( "TemplateTest: vectors can be sized and resized", "[vector][template]", int, float, std::string, (std::tuple<int,float>) ) {
277
278 std::vector<TestType> v( 5 );
279
280 REQUIRE( v.size() == 5 );
281 REQUIRE( v.capacity() >= 5 );
282
283 SECTION( "resizing bigger changes size and capacity" ) {
284 v.resize( 10 );
285
286 REQUIRE( v.size() == 10 );
287 REQUIRE( v.capacity() >= 10 );
288 }
289 SECTION( "resizing smaller changes size but not capacity" ) {
290 v.resize( 0 );
291
292 REQUIRE( v.size() == 0 );
293 REQUIRE( v.capacity() >= 5 );
294
295 SECTION( "We can use the 'swap trick' to reset the capacity" ) {
296 std::vector<TestType> empty;
297 empty.swap( v );
298
299 REQUIRE( v.capacity() == 0 );
300 }
301 }
302 SECTION( "reserving bigger changes capacity but not size" ) {
303 v.reserve( 10 );
304
305 REQUIRE( v.size() == 5 );
306 REQUIRE( v.capacity() >= 10 );
307 }
308 SECTION( "reserving smaller does not change size or capacity" ) {
309 v.reserve( 0 );
310
311 REQUIRE( v.size() == 5 );
312 REQUIRE( v.capacity() >= 5 );
313 }
314 }
315
316 TEMPLATE_TEST_CASE_SIG("TemplateTestSig: vectors can be sized and resized", "[vector][template][nttp]", ((typename TestType, int V), TestType, V), (int,5), (float,4), (std::string,15), ((std::tuple<int, float>), 6)) {
317
318 std::vector<TestType> v(V);
319
320 REQUIRE(v.size() == V);
321 REQUIRE(v.capacity() >= V);
322
323 SECTION("resizing bigger changes size and capacity") {
324 v.resize(2 * V);
325
326 REQUIRE(v.size() == 2 * V);
327 REQUIRE(v.capacity() >= 2 * V);
328 }
329 SECTION("resizing smaller changes size but not capacity") {
330 v.resize(0);
331
332 REQUIRE(v.size() == 0);
333 REQUIRE(v.capacity() >= V);
334
335 SECTION("We can use the 'swap trick' to reset the capacity") {
336 std::vector<TestType> empty;
337 empty.swap(v);
338
339 REQUIRE(v.capacity() == 0);
340 }
341 }
342 SECTION("reserving bigger changes capacity but not size") {
343 v.reserve(2 * V);
344
345 REQUIRE(v.size() == V);
346 REQUIRE(v.capacity() >= 2 * V);
347 }
348 SECTION("reserving smaller does not change size or capacity") {
349 v.reserve(0);
350
351 REQUIRE(v.size() == V);
352 REQUIRE(v.capacity() >= V);
353 }
354 }
355
356 TEMPLATE_PRODUCT_TEST_CASE("A Template product test case", "[template][product]", (std::vector, Foo), (int, float)) {
357 TestType x;
358 REQUIRE(x.size() == 0);
359 }
360
361 TEMPLATE_PRODUCT_TEST_CASE_SIG("A Template product test case with array signature", "[template][product][nttp]", ((typename T, size_t S), T, S), (std::array, Bar), ((int, 9), (float, 42))) {
362 TestType x;
363 REQUIRE(x.size() > 0);
364 }
365
366 TEMPLATE_PRODUCT_TEST_CASE("Product with differing arities", "[template][product]", std::tuple, (int, (int, double), (int, double, float))) {
367 REQUIRE(std::tuple_size<TestType>::value >= 1);
368 }
369
370 using MyTypes = std::tuple<int, char, float>;
371 TEMPLATE_LIST_TEST_CASE("Template test case with test types specified inside std::tuple", "[template][list]", MyTypes)
372 {
373 REQUIRE(sizeof(TestType) > 0);
374 }
375
376 struct NonDefaultConstructibleType {
377 NonDefaultConstructibleType() = delete;
378 };
379
380 using MyNonDefaultConstructibleTypes = std::tuple<NonDefaultConstructibleType, float>;
381 TEMPLATE_LIST_TEST_CASE("Template test case with test types specified inside non-default-constructible std::tuple", "[template][list]", MyNonDefaultConstructibleTypes)
382 {
383 REQUIRE(sizeof(TestType) > 0);
384 }
385
386 struct NonCopyableAndNonMovableType {
387 NonCopyableAndNonMovableType() = default;
388
389 NonCopyableAndNonMovableType(NonCopyableAndNonMovableType const &) = delete;
390 NonCopyableAndNonMovableType(NonCopyableAndNonMovableType &&) = delete;
391 auto operator=(NonCopyableAndNonMovableType const &) -> NonCopyableAndNonMovableType & = delete;
392 auto operator=(NonCopyableAndNonMovableType &&) -> NonCopyableAndNonMovableType & = delete;
393 };
394
395 using NonCopyableAndNonMovableTypes = std::tuple<NonCopyableAndNonMovableType, float>;
396 TEMPLATE_LIST_TEST_CASE("Template test case with test types specified inside non-copyable and non-movable std::tuple", "[template][list]", NonCopyableAndNonMovableTypes)
397 {
398 REQUIRE(sizeof(TestType) > 0);
399 }
400
401 // https://github.com/philsquared/Catch/issues/166
402 TEST_CASE("A couple of nested sections followed by a failure", "[failing][.]") {
403 SECTION("Outer")
404 SECTION("Inner")
405 SUCCEED("that's not flying - that's failing in style");
406
407 FAIL("to infinity and beyond");
408 }
409
410 TEST_CASE("not allowed", "[!throws]") {
411 // This test case should not be included if you run with -e on the command line
412 SUCCEED();
413 }
414
415 //TEST_CASE( "Is big endian" ) {
416 // CHECK( Catch::Detail::Endianness::which() == Catch::Detail::Endianness::Little );
417 //}
418
419 TEST_CASE( "Tabs and newlines show in output", "[.][whitespace][failing]" ) {
420
421 // Based on issue #242
422 std::string s1 = "if ($b == 10) {\n\t\t$a\t= 20;\n}";
423 std::string s2 = "if ($b == 10) {\n\t$a = 20;\n}\n";
424 CHECK( s1 == s2 );
425 }
426
427
428 #ifdef CATCH_CONFIG_WCHAR
429 TEST_CASE( "toString on const wchar_t const pointer returns the string contents", "[toString]" ) {
430 const wchar_t * const s = L"wide load";
431 std::string result = ::Catch::Detail::stringify( s );
432 CHECK( result == "\"wide load\"" );
433 }
434
435 TEST_CASE( "toString on const wchar_t pointer returns the string contents", "[toString]" ) {
436 const wchar_t * s = L"wide load";
437 std::string result = ::Catch::Detail::stringify( s );
438 CHECK( result == "\"wide load\"" );
439 }
440
441 TEST_CASE( "toString on wchar_t const pointer returns the string contents", "[toString]" ) {
442 auto const s = const_cast<wchar_t*>( L"wide load" );
443 std::string result = ::Catch::Detail::stringify( s );
444 CHECK( result == "\"wide load\"" );
445 }
446
447 TEST_CASE( "toString on wchar_t returns the string contents", "[toString]" ) {
448 auto s = const_cast<wchar_t*>( L"wide load" );
449 std::string result = ::Catch::Detail::stringify( s );
450 CHECK( result == "\"wide load\"" );
451 }
452 #endif
453
454 TEST_CASE( "long long" ) {
455 long long l = std::numeric_limits<long long>::max();
456
457 REQUIRE( l == std::numeric_limits<long long>::max() );
458 }
459
460 TEST_CASE( "This test 'should' fail but doesn't", "[.][failing][!shouldfail]" ) {
461 SUCCEED( "oops!" );
462 }
463
464 TEST_CASE( "# A test name that starts with a #" ) {
465 SUCCEED( "yay" );
466 }
467
468 TEST_CASE( "#835 -- errno should not be touched by Catch", "[.][failing][!shouldfail]" ) {
469 errno = 1;
470 CHECK(f() == 0);
471 REQUIRE(errno == 1); // Check that f() doesn't touch errno.
472 }
473
474 TEST_CASE( "#961 -- Dynamically created sections should all be reported", "[.]" ) {
475 for (char i = '0'; i < '5'; ++i) {
476 SECTION(std::string("Looped section ") + i) {
477 SUCCEED( "Everything is OK" );
478 }
479 }
480 }
481
482 TEST_CASE( "#1175 - Hidden Test", "[.]" ) {
483 // Just for checking that hidden test is not listed by default
484 SUCCEED();
485 }
486
487 }} // namespace MiscTests
488