tap.sw.multi.approved.txt
1 # filters: "*" ~[!nonportable] ~[!benchmark] ~[approvals] 2 # rng-seed: 1 3 # # A test name that starts with a # 4 ok {test-number} - with 1 message: 'yay' 5 # #1027: Bitfields can be captured 6 ok {test-number} - y.v == 0 for: 0 == 0 7 # #1027: Bitfields can be captured 8 ok {test-number} - 0 == y.v for: 0 == 0 9 # #1147 10 ok {test-number} - t1 == t2 for: {?} == {?} 11 # #1147 12 ok {test-number} - t1 != t2 for: {?} != {?} 13 # #1147 14 ok {test-number} - t1 < t2 for: {?} < {?} 15 # #1147 16 ok {test-number} - t1 > t2 for: {?} > {?} 17 # #1147 18 ok {test-number} - t1 <= t2 for: {?} <= {?} 19 # #1147 20 ok {test-number} - t1 >= t2 for: {?} >= {?} 21 # #1175 - Hidden Test 22 ok {test-number} - 23 # #1238 24 ok {test-number} - std::memcmp(uarr, "123", sizeof(uarr)) == 0 for: 0 == 0 with 2 messages: 'uarr := "123"' and 'sarr := "456"' 25 # #1238 26 ok {test-number} - std::memcmp(sarr, "456", sizeof(sarr)) == 0 for: 0 == 0 with 2 messages: 'uarr := "123"' and 'sarr := "456"' 27 # #1245 28 ok {test-number} - 29 # #1319: Sections can have description (even if it is not saved 30 ok {test-number} - 31 # #1403 32 ok {test-number} - h1 == h2 for: [1403 helper] == [1403 helper] 33 # #1455 - INFO and WARN can start with a linebreak 34 warning {test-number} - ' 35 This info message starts with a linebreak' with 1 message: ' 36 This warning message starts with a linebreak' 37 # #1514: stderr/stdout is not captured in tests aborted by an exception 38 not ok {test-number} - explicitly with 1 message: '1514' 39 # #1548 40 ok {test-number} - std::is_same<TypeList<int>, TypeList<int>>::value for: true 41 # #1905 -- test spec parser properly clears internal state between compound tests 42 ok {test-number} - spec.matches(*fakeTestCase("spec . char")) for: true 43 # #1905 -- test spec parser properly clears internal state between compound tests 44 ok {test-number} - spec.matches(*fakeTestCase("spec , char")) for: true 45 # #1905 -- test spec parser properly clears internal state between compound tests 46 ok {test-number} - !(spec.matches(*fakeTestCase(R"(spec \, char)"))) for: !false 47 # #1912 -- test spec parser handles escaping 48 ok {test-number} - spec.matches(*fakeTestCase(R"(spec {a} char)")) for: true 49 # #1912 -- test spec parser handles escaping 50 ok {test-number} - spec.matches(*fakeTestCase(R"(spec [a] char)")) for: true 51 # #1912 -- test spec parser handles escaping 52 ok {test-number} - !(spec.matches(*fakeTestCase("differs but has similar tag", "[a]"))) for: !false 53 # #1912 -- test spec parser handles escaping 54 ok {test-number} - spec.matches(*fakeTestCase(R"(spec \ char)")) for: true 55 # #1913 - GENERATE inside a for loop should not keep recreating the generator 56 ok {test-number} - counter < 7 for: 3 < 7 57 # #1913 - GENERATE inside a for loop should not keep recreating the generator 58 ok {test-number} - counter < 7 for: 6 < 7 59 # #1913 - GENERATEs can share a line 60 ok {test-number} - i != j for: 1 != 3 61 # #1913 - GENERATEs can share a line 62 ok {test-number} - i != j for: 1 != 4 63 # #1913 - GENERATEs can share a line 64 ok {test-number} - i != j for: 2 != 3 65 # #1913 - GENERATEs can share a line 66 ok {test-number} - i != j for: 2 != 4 67 # #1938 - GENERATE after a section 68 ok {test-number} - with 1 message: 'A' 69 # #1938 - GENERATE after a section 70 ok {test-number} - m for: 1 71 # #1938 - GENERATE after a section 72 ok {test-number} - m for: 2 73 # #1938 - GENERATE after a section 74 ok {test-number} - m for: 3 75 # #1938 - Section followed by flat generate 76 ok {test-number} - 1 77 # #1938 - Section followed by flat generate 78 ok {test-number} - m for: 2 79 # #1938 - Section followed by flat generate 80 ok {test-number} - m for: 3 81 # #1938 - flat generate 82 ok {test-number} - m for: 1 83 # #1938 - flat generate 84 ok {test-number} - m for: 2 85 # #1938 - flat generate 86 ok {test-number} - m for: 3 87 # #1938 - mixed sections and generates 88 ok {test-number} - with 1 message: 'A' 89 # #1938 - mixed sections and generates 90 ok {test-number} - with 3 messages: 'i := 1' and 'j := 3' and 'k := 5' 91 # #1938 - mixed sections and generates 92 ok {test-number} - with 1 message: 'B' 93 # #1938 - mixed sections and generates 94 ok {test-number} - with 3 messages: 'i := 1' and 'j := 3' and 'k := 6' 95 # #1938 - mixed sections and generates 96 ok {test-number} - with 1 message: 'B' 97 # #1938 - mixed sections and generates 98 ok {test-number} - with 3 messages: 'i := 1' and 'j := 4' and 'k := 5' 99 # #1938 - mixed sections and generates 100 ok {test-number} - with 3 messages: 'i := 1' and 'j := 4' and 'k := 6' 101 # #1938 - mixed sections and generates 102 ok {test-number} - with 1 message: 'A' 103 # #1938 - mixed sections and generates 104 ok {test-number} - with 3 messages: 'i := 2' and 'j := 3' and 'k := 5' 105 # #1938 - mixed sections and generates 106 ok {test-number} - with 1 message: 'B' 107 # #1938 - mixed sections and generates 108 ok {test-number} - with 3 messages: 'i := 2' and 'j := 3' and 'k := 6' 109 # #1938 - mixed sections and generates 110 ok {test-number} - with 1 message: 'B' 111 # #1938 - mixed sections and generates 112 ok {test-number} - with 3 messages: 'i := 2' and 'j := 4' and 'k := 5' 113 # #1938 - mixed sections and generates 114 ok {test-number} - with 3 messages: 'i := 2' and 'j := 4' and 'k := 6' 115 # #1938 - nested generate 116 ok {test-number} - m for: 1 117 # #1938 - nested generate 118 ok {test-number} - n for: 1 119 # #1938 - nested generate 120 ok {test-number} - m for: 1 121 # #1938 - nested generate 122 ok {test-number} - n for: 2 123 # #1938 - nested generate 124 ok {test-number} - m for: 1 125 # #1938 - nested generate 126 ok {test-number} - n for: 3 127 # #1938 - nested generate 128 ok {test-number} - m for: 2 129 # #1938 - nested generate 130 ok {test-number} - n for: 1 131 # #1938 - nested generate 132 ok {test-number} - m for: 2 133 # #1938 - nested generate 134 ok {test-number} - n for: 2 135 # #1938 - nested generate 136 ok {test-number} - m for: 2 137 # #1938 - nested generate 138 ok {test-number} - n for: 3 139 # #1938 - nested generate 140 ok {test-number} - m for: 3 141 # #1938 - nested generate 142 ok {test-number} - n for: 1 143 # #1938 - nested generate 144 ok {test-number} - m for: 3 145 # #1938 - nested generate 146 ok {test-number} - n for: 2 147 # #1938 - nested generate 148 ok {test-number} - m for: 3 149 # #1938 - nested generate 150 ok {test-number} - n for: 3 151 # #1954 - 7 arg template test case sig compiles - 1, 1, 1, 1, 1, 0, 0 152 ok {test-number} - 153 # #1954 - 7 arg template test case sig compiles - 5, 1, 1, 1, 1, 0, 0 154 ok {test-number} - 155 # #1954 - 7 arg template test case sig compiles - 5, 3, 1, 1, 1, 0, 0 156 ok {test-number} - 157 # #2152 - ULP checks between differently signed values were wrong - double 158 ok {test-number} - smallest_non_zero, WithinULP( -smallest_non_zero, 2 ) for: 0.0 is within 2 ULPs of -4.9406564584124654e-324 ([-1.4821969375237396e-323, 4.9406564584124654e-324]) 159 # #2152 - ULP checks between differently signed values were wrong - double 160 ok {test-number} - smallest_non_zero, !WithinULP( -smallest_non_zero, 1 ) for: 0.0 not is within 1 ULPs of -4.9406564584124654e-324 ([-9.8813129168249309e-324, -0.0000000000000000e+00]) 161 # #2152 - ULP checks between differently signed values were wrong - float 162 ok {test-number} - smallest_non_zero, WithinULP( -smallest_non_zero, 2 ) for: 0.0f is within 2 ULPs of -1.40129846e-45f ([-4.20389539e-45, 1.40129846e-45]) 163 # #2152 - ULP checks between differently signed values were wrong - float 164 ok {test-number} - smallest_non_zero, !WithinULP( -smallest_non_zero, 1 ) for: 0.0f not is within 1 ULPs of -1.40129846e-45f ([-2.80259693e-45, -0.00000000e+00]) 165 # #2615 - Throwing in constructor generator fails test case but does not abort 166 not ok {test-number} - unexpected exception with message: 'failure to init' 167 # #748 - captures with unexpected exceptions 168 not ok {test-number} - unexpected exception with message: 'answer := 42' with 1 message: 'expected exception' 169 # #748 - captures with unexpected exceptions 170 not ok {test-number} - unexpected exception with message: 'answer := 42'; expression was: thisThrows() with 1 message: 'expected exception' 171 # #748 - captures with unexpected exceptions 172 ok {test-number} - thisThrows() with 1 message: 'answer := 42' 173 # #809 174 ok {test-number} - 42 == f for: 42 == {?} 175 # #833 176 ok {test-number} - a == t for: 3 == 3 177 # #833 178 ok {test-number} - a == t for: 3 == 3 179 # #833 180 ok {test-number} - throws_int(true) 181 # #833 182 ok {test-number} - throws_int(true), int 183 # #833 184 ok {test-number} - throws_int(false) 185 # #833 186 ok {test-number} - "aaa", Catch::Matchers::EndsWith("aaa") for: "aaa" ends with: "aaa" 187 # #833 188 ok {test-number} - templated_tests<int>(3) for: true 189 # #835 -- errno should not be touched by Catch2 190 not ok {test-number} - f() == 0 for: 1 == 0 191 # #835 -- errno should not be touched by Catch2 192 ok {test-number} - errno_after == 1 for: 1 == 1 193 # #872 194 ok {test-number} - x == 4 for: {?} == 4 with 1 message: 'dummy := 0' 195 # #961 -- Dynamically created sections should all be reported 196 ok {test-number} - with 1 message: 'Everything is OK' 197 # #961 -- Dynamically created sections should all be reported 198 ok {test-number} - with 1 message: 'Everything is OK' 199 # #961 -- Dynamically created sections should all be reported 200 ok {test-number} - with 1 message: 'Everything is OK' 201 # #961 -- Dynamically created sections should all be reported 202 ok {test-number} - with 1 message: 'Everything is OK' 203 # #961 -- Dynamically created sections should all be reported 204 ok {test-number} - with 1 message: 'Everything is OK' 205 # 'Not' checks that should fail 206 not ok {test-number} - false != false 207 # 'Not' checks that should fail 208 not ok {test-number} - true != true 209 # 'Not' checks that should fail 210 not ok {test-number} - !true for: false 211 # 'Not' checks that should fail 212 not ok {test-number} - !(true) for: !true 213 # 'Not' checks that should fail 214 not ok {test-number} - !trueValue for: false 215 # 'Not' checks that should fail 216 not ok {test-number} - !(trueValue) for: !true 217 # 'Not' checks that should fail 218 not ok {test-number} - !(1 == 1) for: false 219 # 'Not' checks that should fail 220 not ok {test-number} - !(1 == 1) 221 # 'Not' checks that should succeed 222 ok {test-number} - false == false 223 # 'Not' checks that should succeed 224 ok {test-number} - true == true 225 # 'Not' checks that should succeed 226 ok {test-number} - !false for: true 227 # 'Not' checks that should succeed 228 ok {test-number} - !(false) for: !false 229 # 'Not' checks that should succeed 230 ok {test-number} - !falseValue for: true 231 # 'Not' checks that should succeed 232 ok {test-number} - !(falseValue) for: !false 233 # 'Not' checks that should succeed 234 ok {test-number} - !(1 == 2) for: true 235 # 'Not' checks that should succeed 236 ok {test-number} - !(1 == 2) 237 # (unimplemented) static bools can be evaluated 238 ok {test-number} - is_true<true>::value == true for: true == true 239 # (unimplemented) static bools can be evaluated 240 ok {test-number} - true == is_true<true>::value for: true == true 241 # (unimplemented) static bools can be evaluated 242 ok {test-number} - is_true<false>::value == false for: false == false 243 # (unimplemented) static bools can be evaluated 244 ok {test-number} - false == is_true<false>::value for: false == false 245 # (unimplemented) static bools can be evaluated 246 ok {test-number} - !is_true<false>::value for: true 247 # (unimplemented) static bools can be evaluated 248 ok {test-number} - !!is_true<true>::value for: true 249 # (unimplemented) static bools can be evaluated 250 ok {test-number} - is_true<true>::value for: true 251 # (unimplemented) static bools can be evaluated 252 ok {test-number} - !(is_true<false>::value) for: !false 253 # 3x3x3 ints 254 ok {test-number} - x < y for: 1 < 4 255 # 3x3x3 ints 256 ok {test-number} - y < z for: 4 < 7 257 # 3x3x3 ints 258 ok {test-number} - x < z for: 1 < 7 259 # 3x3x3 ints 260 ok {test-number} - x < y for: 1 < 4 261 # 3x3x3 ints 262 ok {test-number} - y < z for: 4 < 8 263 # 3x3x3 ints 264 ok {test-number} - x < z for: 1 < 8 265 # 3x3x3 ints 266 ok {test-number} - x < y for: 1 < 4 267 # 3x3x3 ints 268 ok {test-number} - y < z for: 4 < 9 269 # 3x3x3 ints 270 ok {test-number} - x < z for: 1 < 9 271 # 3x3x3 ints 272 ok {test-number} - x < y for: 1 < 5 273 # 3x3x3 ints 274 ok {test-number} - y < z for: 5 < 7 275 # 3x3x3 ints 276 ok {test-number} - x < z for: 1 < 7 277 # 3x3x3 ints 278 ok {test-number} - x < y for: 1 < 5 279 # 3x3x3 ints 280 ok {test-number} - y < z for: 5 < 8 281 # 3x3x3 ints 282 ok {test-number} - x < z for: 1 < 8 283 # 3x3x3 ints 284 ok {test-number} - x < y for: 1 < 5 285 # 3x3x3 ints 286 ok {test-number} - y < z for: 5 < 9 287 # 3x3x3 ints 288 ok {test-number} - x < z for: 1 < 9 289 # 3x3x3 ints 290 ok {test-number} - x < y for: 1 < 6 291 # 3x3x3 ints 292 ok {test-number} - y < z for: 6 < 7 293 # 3x3x3 ints 294 ok {test-number} - x < z for: 1 < 7 295 # 3x3x3 ints 296 ok {test-number} - x < y for: 1 < 6 297 # 3x3x3 ints 298 ok {test-number} - y < z for: 6 < 8 299 # 3x3x3 ints 300 ok {test-number} - x < z for: 1 < 8 301 # 3x3x3 ints 302 ok {test-number} - x < y for: 1 < 6 303 # 3x3x3 ints 304 ok {test-number} - y < z for: 6 < 9 305 # 3x3x3 ints 306 ok {test-number} - x < z for: 1 < 9 307 # 3x3x3 ints 308 ok {test-number} - x < y for: 2 < 4 309 # 3x3x3 ints 310 ok {test-number} - y < z for: 4 < 7 311 # 3x3x3 ints 312 ok {test-number} - x < z for: 2 < 7 313 # 3x3x3 ints 314 ok {test-number} - x < y for: 2 < 4 315 # 3x3x3 ints 316 ok {test-number} - y < z for: 4 < 8 317 # 3x3x3 ints 318 ok {test-number} - x < z for: 2 < 8 319 # 3x3x3 ints 320 ok {test-number} - x < y for: 2 < 4 321 # 3x3x3 ints 322 ok {test-number} - y < z for: 4 < 9 323 # 3x3x3 ints 324 ok {test-number} - x < z for: 2 < 9 325 # 3x3x3 ints 326 ok {test-number} - x < y for: 2 < 5 327 # 3x3x3 ints 328 ok {test-number} - y < z for: 5 < 7 329 # 3x3x3 ints 330 ok {test-number} - x < z for: 2 < 7 331 # 3x3x3 ints 332 ok {test-number} - x < y for: 2 < 5 333 # 3x3x3 ints 334 ok {test-number} - y < z for: 5 < 8 335 # 3x3x3 ints 336 ok {test-number} - x < z for: 2 < 8 337 # 3x3x3 ints 338 ok {test-number} - x < y for: 2 < 5 339 # 3x3x3 ints 340 ok {test-number} - y < z for: 5 < 9 341 # 3x3x3 ints 342 ok {test-number} - x < z for: 2 < 9 343 # 3x3x3 ints 344 ok {test-number} - x < y for: 2 < 6 345 # 3x3x3 ints 346 ok {test-number} - y < z for: 6 < 7 347 # 3x3x3 ints 348 ok {test-number} - x < z for: 2 < 7 349 # 3x3x3 ints 350 ok {test-number} - x < y for: 2 < 6 351 # 3x3x3 ints 352 ok {test-number} - y < z for: 6 < 8 353 # 3x3x3 ints 354 ok {test-number} - x < z for: 2 < 8 355 # 3x3x3 ints 356 ok {test-number} - x < y for: 2 < 6 357 # 3x3x3 ints 358 ok {test-number} - y < z for: 6 < 9 359 # 3x3x3 ints 360 ok {test-number} - x < z for: 2 < 9 361 # 3x3x3 ints 362 ok {test-number} - x < y for: 3 < 4 363 # 3x3x3 ints 364 ok {test-number} - y < z for: 4 < 7 365 # 3x3x3 ints 366 ok {test-number} - x < z for: 3 < 7 367 # 3x3x3 ints 368 ok {test-number} - x < y for: 3 < 4 369 # 3x3x3 ints 370 ok {test-number} - y < z for: 4 < 8 371 # 3x3x3 ints 372 ok {test-number} - x < z for: 3 < 8 373 # 3x3x3 ints 374 ok {test-number} - x < y for: 3 < 4 375 # 3x3x3 ints 376 ok {test-number} - y < z for: 4 < 9 377 # 3x3x3 ints 378 ok {test-number} - x < z for: 3 < 9 379 # 3x3x3 ints 380 ok {test-number} - x < y for: 3 < 5 381 # 3x3x3 ints 382 ok {test-number} - y < z for: 5 < 7 383 # 3x3x3 ints 384 ok {test-number} - x < z for: 3 < 7 385 # 3x3x3 ints 386 ok {test-number} - x < y for: 3 < 5 387 # 3x3x3 ints 388 ok {test-number} - y < z for: 5 < 8 389 # 3x3x3 ints 390 ok {test-number} - x < z for: 3 < 8 391 # 3x3x3 ints 392 ok {test-number} - x < y for: 3 < 5 393 # 3x3x3 ints 394 ok {test-number} - y < z for: 5 < 9 395 # 3x3x3 ints 396 ok {test-number} - x < z for: 3 < 9 397 # 3x3x3 ints 398 ok {test-number} - x < y for: 3 < 6 399 # 3x3x3 ints 400 ok {test-number} - y < z for: 6 < 7 401 # 3x3x3 ints 402 ok {test-number} - x < z for: 3 < 7 403 # 3x3x3 ints 404 ok {test-number} - x < y for: 3 < 6 405 # 3x3x3 ints 406 ok {test-number} - y < z for: 6 < 8 407 # 3x3x3 ints 408 ok {test-number} - x < z for: 3 < 8 409 # 3x3x3 ints 410 ok {test-number} - x < y for: 3 < 6 411 # 3x3x3 ints 412 ok {test-number} - y < z for: 6 < 9 413 # 3x3x3 ints 414 ok {test-number} - x < z for: 3 < 9 415 # A METHOD_AS_TEST_CASE based test run that fails 416 not ok {test-number} - s == "world" for: "hello" == "world" 417 # A METHOD_AS_TEST_CASE based test run that succeeds 418 ok {test-number} - s == "hello" for: "hello" == "hello" 419 # A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - Template_Foo<float> 420 not ok {test-number} - Template_Fixture_2<TestType>::m_a.size() == 1 for: 0 == 1 421 # A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - Template_Foo<int> 422 not ok {test-number} - Template_Fixture_2<TestType>::m_a.size() == 1 for: 0 == 1 423 # A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - std::vector<float> 424 not ok {test-number} - Template_Fixture_2<TestType>::m_a.size() == 1 for: 0 == 1 425 # A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - std::vector<int> 426 not ok {test-number} - Template_Fixture_2<TestType>::m_a.size() == 1 for: 0 == 1 427 # A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that succeeds - Template_Foo<float> 428 ok {test-number} - Template_Fixture_2<TestType>::m_a.size() == 0 for: 0 == 0 429 # A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that succeeds - Template_Foo<int> 430 ok {test-number} - Template_Fixture_2<TestType>::m_a.size() == 0 for: 0 == 0 431 # A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that succeeds - std::vector<float> 432 ok {test-number} - Template_Fixture_2<TestType>::m_a.size() == 0 for: 0 == 0 433 # A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that succeeds - std::vector<int> 434 ok {test-number} - Template_Fixture_2<TestType>::m_a.size() == 0 for: 0 == 0 435 # A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - Template_Foo_2<float, 6> 436 not ok {test-number} - Template_Fixture_2<TestType>{}.m_a.size() < 2 for: 6 < 2 437 # A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - Template_Foo_2<int, 2> 438 not ok {test-number} - Template_Fixture_2<TestType>{}.m_a.size() < 2 for: 2 < 2 439 # A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - std::array<float, 6> 440 not ok {test-number} - Template_Fixture_2<TestType>{}.m_a.size() < 2 for: 6 < 2 441 # A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - std::array<int, 2> 442 not ok {test-number} - Template_Fixture_2<TestType>{}.m_a.size() < 2 for: 2 < 2 443 # A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that succeeds - Template_Foo_2<float,6> 444 ok {test-number} - Template_Fixture_2<TestType>{}.m_a.size() >= 2 for: 6 >= 2 445 # A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that succeeds - Template_Foo_2<int,2> 446 ok {test-number} - Template_Fixture_2<TestType>{}.m_a.size() >= 2 for: 2 >= 2 447 # A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that succeeds - std::array<float,6> 448 ok {test-number} - Template_Fixture_2<TestType>{}.m_a.size() >= 2 for: 6 >= 2 449 # A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that succeeds - std::array<int,2> 450 ok {test-number} - Template_Fixture_2<TestType>{}.m_a.size() >= 2 for: 2 >= 2 451 # A TEMPLATE_TEST_CASE_METHOD based test run that fails - double 452 not ok {test-number} - Template_Fixture<TestType>::m_a == 2 for: 1.0 == 2 453 # A TEMPLATE_TEST_CASE_METHOD based test run that fails - float 454 not ok {test-number} - Template_Fixture<TestType>::m_a == 2 for: 1.0f == 2 455 # A TEMPLATE_TEST_CASE_METHOD based test run that fails - int 456 not ok {test-number} - Template_Fixture<TestType>::m_a == 2 for: 1 == 2 457 # A TEMPLATE_TEST_CASE_METHOD based test run that succeeds - double 458 ok {test-number} - Template_Fixture<TestType>::m_a == 1 for: 1.0 == 1 459 # A TEMPLATE_TEST_CASE_METHOD based test run that succeeds - float 460 ok {test-number} - Template_Fixture<TestType>::m_a == 1 for: 1.0f == 1 461 # A TEMPLATE_TEST_CASE_METHOD based test run that succeeds - int 462 ok {test-number} - Template_Fixture<TestType>::m_a == 1 for: 1 == 1 463 # A TEMPLATE_TEST_CASE_METHOD_SIG based test run that fails - 1 464 not ok {test-number} - Nttp_Fixture<V>::value == 0 for: 1 == 0 465 # A TEMPLATE_TEST_CASE_METHOD_SIG based test run that fails - 3 466 not ok {test-number} - Nttp_Fixture<V>::value == 0 for: 3 == 0 467 # A TEMPLATE_TEST_CASE_METHOD_SIG based test run that fails - 6 468 not ok {test-number} - Nttp_Fixture<V>::value == 0 for: 6 == 0 469 # A TEMPLATE_TEST_CASE_METHOD_SIG based test run that succeeds - 1 470 ok {test-number} - Nttp_Fixture<V>::value > 0 for: 1 > 0 471 # A TEMPLATE_TEST_CASE_METHOD_SIG based test run that succeeds - 3 472 ok {test-number} - Nttp_Fixture<V>::value > 0 for: 3 > 0 473 # A TEMPLATE_TEST_CASE_METHOD_SIG based test run that succeeds - 6 474 ok {test-number} - Nttp_Fixture<V>::value > 0 for: 6 > 0 475 # A TEST_CASE_METHOD based test run that fails 476 not ok {test-number} - m_a == 2 for: 1 == 2 477 # A TEST_CASE_METHOD based test run that succeeds 478 ok {test-number} - m_a == 1 for: 1 == 1 479 # A Template product test case - Foo<float> 480 ok {test-number} - x.size() == 0 for: 0 == 0 481 # A Template product test case - Foo<int> 482 ok {test-number} - x.size() == 0 for: 0 == 0 483 # A Template product test case - std::vector<float> 484 ok {test-number} - x.size() == 0 for: 0 == 0 485 # A Template product test case - std::vector<int> 486 ok {test-number} - x.size() == 0 for: 0 == 0 487 # A Template product test case with array signature - Bar<float, 42> 488 ok {test-number} - x.size() > 0 for: 42 > 0 489 # A Template product test case with array signature - Bar<int, 9> 490 ok {test-number} - x.size() > 0 for: 9 > 0 491 # A Template product test case with array signature - std::array<float, 42> 492 ok {test-number} - x.size() > 0 for: 42 > 0 493 # A Template product test case with array signature - std::array<int, 9> 494 ok {test-number} - x.size() > 0 for: 9 > 0 495 # A comparison that uses literals instead of the normal constructor 496 ok {test-number} - d == 1.23_a for: 1.23 == Approx( 1.23 ) 497 # A comparison that uses literals instead of the normal constructor 498 ok {test-number} - d != 1.22_a for: 1.23 != Approx( 1.22 ) 499 # A comparison that uses literals instead of the normal constructor 500 ok {test-number} - -d == -1.23_a for: -1.23 == Approx( -1.23 ) 501 # A comparison that uses literals instead of the normal constructor 502 ok {test-number} - d == 1.2_a .epsilon(.1) for: 1.23 == Approx( 1.2 ) 503 # A comparison that uses literals instead of the normal constructor 504 ok {test-number} - d != 1.2_a .epsilon(.001) for: 1.23 != Approx( 1.2 ) 505 # A comparison that uses literals instead of the normal constructor 506 ok {test-number} - d == 1_a .epsilon(.3) for: 1.23 == Approx( 1.0 ) 507 # A couple of nested sections followed by a failure 508 ok {test-number} - with 1 message: 'that's not flying - that's failing in style' 509 # A couple of nested sections followed by a failure 510 not ok {test-number} - explicitly with 1 message: 'to infinity and beyond' 511 # A failing expression with a non streamable type is still captured 512 not ok {test-number} - &o1 == &o2 for: 0x<hex digits> == 0x<hex digits> 513 # A failing expression with a non streamable type is still captured 514 not ok {test-number} - o1 == o2 for: {?} == {?} 515 # Absolute margin 516 ok {test-number} - 104.0 != Approx(100.0) for: 104.0 != Approx( 100.0 ) 517 # Absolute margin 518 ok {test-number} - 104.0 == Approx(100.0).margin(5) for: 104.0 == Approx( 100.0 ) 519 # Absolute margin 520 ok {test-number} - 104.0 == Approx(100.0).margin(4) for: 104.0 == Approx( 100.0 ) 521 # Absolute margin 522 ok {test-number} - 104.0 != Approx(100.0).margin(3) for: 104.0 != Approx( 100.0 ) 523 # Absolute margin 524 ok {test-number} - 100.3 != Approx(100.0) for: 100.3 != Approx( 100.0 ) 525 # Absolute margin 526 ok {test-number} - 100.3 == Approx(100.0).margin(0.5) for: 100.3 == Approx( 100.0 ) 527 # An expression with side-effects should only be evaluated once 528 ok {test-number} - i++ == 7 for: 7 == 7 529 # An expression with side-effects should only be evaluated once 530 ok {test-number} - i++ == 8 for: 8 == 8 531 # An unchecked exception reports the line of the last assertion 532 ok {test-number} - 1 == 1 533 # An unchecked exception reports the line of the last assertion 534 not ok {test-number} - unexpected exception with message: 'unexpected exception'; expression was: {Unknown expression after the reported line} 535 # Anonymous test case 1 536 ok {test-number} - with 1 message: 'anonymous test case' 537 # Approx setters validate their arguments 538 ok {test-number} - Approx(0).margin(0) 539 # Approx setters validate their arguments 540 ok {test-number} - Approx(0).margin(1234656) 541 # Approx setters validate their arguments 542 ok {test-number} - Approx(0).margin(-2), std::domain_error 543 # Approx setters validate their arguments 544 ok {test-number} - Approx(0).epsilon(0) 545 # Approx setters validate their arguments 546 ok {test-number} - Approx(0).epsilon(1) 547 # Approx setters validate their arguments 548 ok {test-number} - Approx(0).epsilon(-0.001), std::domain_error 549 # Approx setters validate their arguments 550 ok {test-number} - Approx(0).epsilon(1.0001), std::domain_error 551 # Approx with exactly-representable margin 552 ok {test-number} - 0.25f == Approx(0.0f).margin(0.25f) for: 0.25f == Approx( 0.0 ) 553 # Approx with exactly-representable margin 554 ok {test-number} - 0.0f == Approx(0.25f).margin(0.25f) for: 0.0f == Approx( 0.25 ) 555 # Approx with exactly-representable margin 556 ok {test-number} - 0.5f == Approx(0.25f).margin(0.25f) for: 0.5f == Approx( 0.25 ) 557 # Approx with exactly-representable margin 558 ok {test-number} - 245.0f == Approx(245.25f).margin(0.25f) for: 245.0f == Approx( 245.25 ) 559 # Approx with exactly-representable margin 560 ok {test-number} - 245.5f == Approx(245.25f).margin(0.25f) for: 245.5f == Approx( 245.25 ) 561 # Approximate PI 562 ok {test-number} - divide( 22, 7 ) == Approx( 3.141 ).epsilon( 0.001 ) for: 3.1428571429 == Approx( 3.141 ) 563 # Approximate PI 564 ok {test-number} - divide( 22, 7 ) != Approx( 3.141 ).epsilon( 0.0001 ) for: 3.1428571429 != Approx( 3.141 ) 565 # Approximate comparisons with different epsilons 566 ok {test-number} - d != Approx( 1.231 ) for: 1.23 != Approx( 1.231 ) 567 # Approximate comparisons with different epsilons 568 ok {test-number} - d == Approx( 1.231 ).epsilon( 0.1 ) for: 1.23 == Approx( 1.231 ) 569 # Approximate comparisons with floats 570 ok {test-number} - 1.23f == Approx( 1.23f ) for: 1.23f == Approx( 1.2300000191 ) 571 # Approximate comparisons with floats 572 ok {test-number} - 0.0f == Approx( 0.0f ) for: 0.0f == Approx( 0.0 ) 573 # Approximate comparisons with ints 574 ok {test-number} - 1 == Approx( 1 ) for: 1 == Approx( 1.0 ) 575 # Approximate comparisons with ints 576 ok {test-number} - 0 == Approx( 0 ) for: 0 == Approx( 0.0 ) 577 # Approximate comparisons with mixed numeric types 578 ok {test-number} - 1.0f == Approx( 1 ) for: 1.0f == Approx( 1.0 ) 579 # Approximate comparisons with mixed numeric types 580 ok {test-number} - 0 == Approx( dZero) for: 0 == Approx( 0.0 ) 581 # Approximate comparisons with mixed numeric types 582 ok {test-number} - 0 == Approx( dSmall ).margin( 0.001 ) for: 0 == Approx( 0.00001 ) 583 # Approximate comparisons with mixed numeric types 584 ok {test-number} - 1.234f == Approx( dMedium ) for: 1.234f == Approx( 1.234 ) 585 # Approximate comparisons with mixed numeric types 586 ok {test-number} - dMedium == Approx( 1.234f ) for: 1.234 == Approx( 1.2339999676 ) 587 # Arbitrary predicate matcher 588 ok {test-number} - 1, Predicate<int>( alwaysTrue, "always true" ) for: 1 matches predicate: "always true" 589 # Arbitrary predicate matcher 590 ok {test-number} - 1, !Predicate<int>( alwaysFalse, "always false" ) for: 1 not matches predicate: "always false" 591 # Arbitrary predicate matcher 592 ok {test-number} - "Hello olleH", Predicate<std::string>( []( std::string const& str ) -> bool { return str.front() == str.back(); }, "First and last character should be equal" ) for: "Hello olleH" matches predicate: "First and last character should be equal" 593 # Arbitrary predicate matcher 594 ok {test-number} - "This wouldn't pass", !Predicate<std::string>( []( std::string const& str ) -> bool { return str.front() == str.back(); } ) for: "This wouldn't pass" not matches undescribed predicate 595 # Assertion macros support bit operators and bool conversions 596 ok {test-number} - lhs | rhs for: Val: 1 | Val: 2 597 # Assertion macros support bit operators and bool conversions 598 ok {test-number} - !(lhs & rhs) for: !(Val: 1 & Val: 2) 599 # Assertion macros support bit operators and bool conversions 600 ok {test-number} - HasBitOperators{ 1 } & HasBitOperators{ 1 } for: Val: 1 & Val: 1 601 # Assertion macros support bit operators and bool conversions 602 ok {test-number} - lhs ^ rhs for: Val: 1 ^ Val: 2 603 # Assertion macros support bit operators and bool conversions 604 ok {test-number} - !(lhs ^ lhs) for: !(Val: 1 ^ Val: 1) 605 # Assertions then sections 606 ok {test-number} - true 607 # Assertions then sections 608 ok {test-number} - true 609 # Assertions then sections 610 ok {test-number} - true 611 # Assertions then sections 612 ok {test-number} - true 613 # Assertions then sections 614 ok {test-number} - true 615 # Assertions then sections 616 ok {test-number} - true 617 # Basic use of the Contains range matcher 618 ok {test-number} - a, Contains(1) for: { 1, 2, 3 } contains element 1 619 # Basic use of the Contains range matcher 620 ok {test-number} - b, Contains(1) for: { 0, 1, 2 } contains element 1 621 # Basic use of the Contains range matcher 622 ok {test-number} - c, !Contains(1) for: { 4, 5, 6 } not contains element 1 623 # Basic use of the Contains range matcher 624 ok {test-number} - a, Contains(0, close_enough) for: { 1, 2, 3 } contains element 0 625 # Basic use of the Contains range matcher 626 ok {test-number} - b, Contains(0, close_enough) for: { 0, 1, 2 } contains element 0 627 # Basic use of the Contains range matcher 628 ok {test-number} - c, !Contains(0, close_enough) for: { 4, 5, 6 } not contains element 0 629 # Basic use of the Contains range matcher 630 ok {test-number} - a, Contains(4, [](auto&& lhs, size_t sz) { return lhs.size() == sz; }) for: { "abc", "abcd", "abcde" } contains element 4 631 # Basic use of the Contains range matcher 632 ok {test-number} - in, Contains(1) for: { 1, 2, 3, 4, 5 } contains element 1 633 # Basic use of the Contains range matcher 634 ok {test-number} - in, !Contains(8) for: { 1, 2, 3, 4, 5 } not contains element 8 635 # Basic use of the Contains range matcher 636 ok {test-number} - in, Contains(MoveOnlyTestElement{ 2 }) for: { 1, 2, 3 } contains element 2 637 # Basic use of the Contains range matcher 638 ok {test-number} - in, !Contains(MoveOnlyTestElement{ 9 }) for: { 1, 2, 3 } not contains element 9 639 # Basic use of the Contains range matcher 640 ok {test-number} - in, Contains(Catch::Matchers::WithinAbs(0.5, 0.5)) for: { 1.0, 2.0, 3.0, 0.0 } contains element matching is within 0.5 of 0.5 641 # Basic use of the Empty range matcher 642 ok {test-number} - empty_array, IsEmpty() for: { } is empty 643 # Basic use of the Empty range matcher 644 ok {test-number} - non_empty_array, !IsEmpty() for: { 0.0 } not is empty 645 # Basic use of the Empty range matcher 646 ok {test-number} - empty_vec, IsEmpty() for: { } is empty 647 # Basic use of the Empty range matcher 648 ok {test-number} - non_empty_vec, !IsEmpty() for: { 'a', 'b', 'c' } not is empty 649 # Basic use of the Empty range matcher 650 ok {test-number} - inner_lists_are_empty, !IsEmpty() for: { { } } not is empty 651 # Basic use of the Empty range matcher 652 ok {test-number} - inner_lists_are_empty.front(), IsEmpty() for: { } is empty 653 # Basic use of the Empty range matcher 654 ok {test-number} - has_empty{}, !IsEmpty() for: {?} not is empty 655 # Basic use of the Empty range matcher 656 ok {test-number} - unrelated::ADL_empty{}, IsEmpty() for: {?} is empty 657 # CAPTURE can deal with complex expressions 658 ok {test-number} - with 7 messages: 'a := 1' and 'b := 2' and 'c := 3' and 'a + b := 3' and 'a+b := 3' and 'c > b := true' and 'a == 1 := true' 659 # CAPTURE can deal with complex expressions involving commas 660 ok {test-number} - with 7 messages: 'custom_index_op<int>{1, 2, 3}[0, 1, 2] := 0' and 'custom_index_op<int>{1, 2, 3}[(0, 1)] := 0' and 'custom_index_op<int>{1, 2, 3}[0] := 0' and '(helper_1436<int, int>{12, -12}) := { 12, -12 }' and '(helper_1436<int, int>(-12, 12)) := { -12, 12 }' and '(1, 2) := 2' and '(2, 3) := 3' 661 # CAPTURE parses string and character constants 662 ok {test-number} - with 11 messages: '("comma, in string", "escaped, \", ") := "escaped, ", "' and '"single quote in string,'," := "single quote in string,',"' and '"some escapes, \\,\\\\" := "some escapes, \,\\"' and '"some, ), unmatched, } prenheses {[<" := "some, ), unmatched, } prenheses {[<"' and ''"' := '"'' and ''\'' := '''' and '',' := ','' and ''}' := '}'' and '')' := ')'' and ''(' := '('' and ''{' := '{'' 663 # Capture and info messages 664 ok {test-number} - true with 1 message: 'i := 2' 665 # Capture and info messages 666 ok {test-number} - true with 1 message: '3' 667 # CaseInsensitiveEqualsTo is case insensitive 668 ok {test-number} - eq( "", "" ) for: true 669 # CaseInsensitiveEqualsTo is case insensitive 670 ok {test-number} - !(eq( "", "a" )) for: !false 671 # CaseInsensitiveEqualsTo is case insensitive 672 ok {test-number} - eq( "a", "a" ) for: true 673 # CaseInsensitiveEqualsTo is case insensitive 674 ok {test-number} - eq( "a", "A" ) for: true 675 # CaseInsensitiveEqualsTo is case insensitive 676 ok {test-number} - eq( "A", "a" ) for: true 677 # CaseInsensitiveEqualsTo is case insensitive 678 ok {test-number} - eq( "A", "A" ) for: true 679 # CaseInsensitiveEqualsTo is case insensitive 680 ok {test-number} - !(eq( "a", "b" )) for: !false 681 # CaseInsensitiveEqualsTo is case insensitive 682 ok {test-number} - !(eq( "a", "B" )) for: !false 683 # CaseInsensitiveLess is case insensitive 684 ok {test-number} - lt( "", "a" ) for: true 685 # CaseInsensitiveLess is case insensitive 686 ok {test-number} - !(lt( "a", "a" )) for: !false 687 # CaseInsensitiveLess is case insensitive 688 ok {test-number} - !(lt( "", "" )) for: !false 689 # CaseInsensitiveLess is case insensitive 690 ok {test-number} - lt( "a", "b" ) for: true 691 # CaseInsensitiveLess is case insensitive 692 ok {test-number} - lt( "a", "B" ) for: true 693 # CaseInsensitiveLess is case insensitive 694 ok {test-number} - lt( "A", "b" ) for: true 695 # CaseInsensitiveLess is case insensitive 696 ok {test-number} - lt( "A", "B" ) for: true 697 # Character pretty printing 698 ok {test-number} - tab == '\t' for: '\t' == '\t' 699 # Character pretty printing 700 ok {test-number} - newline == '\n' for: '\n' == '\n' 701 # Character pretty printing 702 ok {test-number} - carr_return == '\r' for: '\r' == '\r' 703 # Character pretty printing 704 ok {test-number} - form_feed == '\f' for: '\f' == '\f' 705 # Character pretty printing 706 ok {test-number} - space == ' ' for: ' ' == ' ' 707 # Character pretty printing 708 ok {test-number} - c == chars[i] for: 'a' == 'a' 709 # Character pretty printing 710 ok {test-number} - c == chars[i] for: 'z' == 'z' 711 # Character pretty printing 712 ok {test-number} - c == chars[i] for: 'A' == 'A' 713 # Character pretty printing 714 ok {test-number} - c == chars[i] for: 'Z' == 'Z' 715 # Character pretty printing 716 ok {test-number} - null_terminator == '\0' for: 0 == 0 717 # Character pretty printing 718 ok {test-number} - c == i for: 2 == 2 719 # Character pretty printing 720 ok {test-number} - c == i for: 3 == 3 721 # Character pretty printing 722 ok {test-number} - c == i for: 4 == 4 723 # Character pretty printing 724 ok {test-number} - c == i for: 5 == 5 725 # Clara::Arg supports single-arg parse the way Opt does 726 ok {test-number} - name.empty() for: true 727 # Clara::Arg supports single-arg parse the way Opt does 728 ok {test-number} - name == "foo" for: "foo" == "foo" 729 # Clara::Opt supports accept-many lambdas 730 ok {test-number} - !(parse_result) for: !{?} 731 # Clara::Opt supports accept-many lambdas 732 ok {test-number} - parse_result for: {?} 733 # Clara::Opt supports accept-many lambdas 734 ok {test-number} - res == std::vector<std::string>{ "aaa", "bbb" } for: { "aaa", "bbb" } == { "aaa", "bbb" } 735 # ColourGuard behaviour 736 ok {test-number} - streamWrapper.str().empty() for: true 737 # ColourGuard behaviour 738 ok {test-number} - streamWrapper.str() == "1\nUsing code: 2\n2\nUsing code: 0\n3\n" for: "1 Using code: 2 2 Using code: 0 3 " == "1 Using code: 2 2 Using code: 0 3 " 739 # ColourGuard behaviour 740 ok {test-number} - streamWrapper.str() == "Using code: 2\nA\nB\nUsing code: 0\nC\n" for: "Using code: 2 A B Using code: 0 C " == "Using code: 2 A B Using code: 0 C " 741 # Combining MatchAllOfGeneric does not nest 742 ok {test-number} - with 1 message: 'std::is_same< decltype( ( MatcherA() && MatcherB() ) && MatcherC() ), Catch::Matchers::Detail:: MatchAllOfGeneric<MatcherA, MatcherB, MatcherC>>::value' 743 # Combining MatchAllOfGeneric does not nest 744 ok {test-number} - 1, ( MatcherA() && MatcherB() ) && MatcherC() for: 1 ( equals: (int) 1 or (string) "1" and equals: (long long) 1 and equals: (T) 1 ) 745 # Combining MatchAllOfGeneric does not nest 746 ok {test-number} - with 1 message: 'std::is_same< decltype( MatcherA() && ( MatcherB() && MatcherC() ) ), Catch::Matchers::Detail:: MatchAllOfGeneric<MatcherA, MatcherB, MatcherC>>::value' 747 # Combining MatchAllOfGeneric does not nest 748 ok {test-number} - 1, MatcherA() && ( MatcherB() && MatcherC() ) for: 1 ( equals: (int) 1 or (string) "1" and equals: (long long) 1 and equals: (T) 1 ) 749 # Combining MatchAllOfGeneric does not nest 750 ok {test-number} - with 1 message: 'std::is_same< decltype( ( MatcherA() && MatcherB() ) && ( MatcherC() && MatcherD() ) ), Catch::Matchers::Detail:: MatchAllOfGeneric<MatcherA, MatcherB, MatcherC, MatcherD>>:: value' 751 # Combining MatchAllOfGeneric does not nest 752 ok {test-number} - 1, ( MatcherA() && MatcherB() ) && ( MatcherC() && MatcherD() ) for: 1 ( equals: (int) 1 or (string) "1" and equals: (long long) 1 and equals: (T) 1 and equals: true ) 753 # Combining MatchAnyOfGeneric does not nest 754 ok {test-number} - with 1 message: 'std::is_same< decltype( ( MatcherA() || MatcherB() ) || MatcherC() ), Catch::Matchers::Detail:: MatchAnyOfGeneric<MatcherA, MatcherB, MatcherC>>::value' 755 # Combining MatchAnyOfGeneric does not nest 756 ok {test-number} - 1, ( MatcherA() || MatcherB() ) || MatcherC() for: 1 ( equals: (int) 1 or (string) "1" or equals: (long long) 1 or equals: (T) 1 ) 757 # Combining MatchAnyOfGeneric does not nest 758 ok {test-number} - with 1 message: 'std::is_same< decltype( MatcherA() || ( MatcherB() || MatcherC() ) ), Catch::Matchers::Detail:: MatchAnyOfGeneric<MatcherA, MatcherB, MatcherC>>::value' 759 # Combining MatchAnyOfGeneric does not nest 760 ok {test-number} - 1, MatcherA() || ( MatcherB() || MatcherC() ) for: 1 ( equals: (int) 1 or (string) "1" or equals: (long long) 1 or equals: (T) 1 ) 761 # Combining MatchAnyOfGeneric does not nest 762 ok {test-number} - with 1 message: 'std::is_same< decltype( ( MatcherA() || MatcherB() ) || ( MatcherC() || MatcherD() ) ), Catch::Matchers::Detail:: MatchAnyOfGeneric<MatcherA, MatcherB, MatcherC, MatcherD>>:: value' 763 # Combining MatchAnyOfGeneric does not nest 764 ok {test-number} - 1, ( MatcherA() || MatcherB() ) || ( MatcherC() || MatcherD() ) for: 1 ( equals: (int) 1 or (string) "1" or equals: (long long) 1 or equals: (T) 1 or equals: true ) 765 # Combining MatchNotOfGeneric does not nest 766 ok {test-number} - with 1 message: 'std::is_same< decltype( !MatcherA() ), Catch::Matchers::Detail::MatchNotOfGeneric<MatcherA>>::value' 767 # Combining MatchNotOfGeneric does not nest 768 ok {test-number} - 0, !MatcherA() for: 0 not equals: (int) 1 or (string) "1" 769 # Combining MatchNotOfGeneric does not nest 770 ok {test-number} - with 1 message: 'std::is_same<decltype( !!MatcherA() ), MatcherA const&>::value' 771 # Combining MatchNotOfGeneric does not nest 772 ok {test-number} - 1, !!MatcherA() for: 1 equals: (int) 1 or (string) "1" 773 # Combining MatchNotOfGeneric does not nest 774 ok {test-number} - with 1 message: 'std::is_same< decltype( !!!MatcherA() ), Catch::Matchers::Detail::MatchNotOfGeneric<MatcherA>>::value' 775 # Combining MatchNotOfGeneric does not nest 776 ok {test-number} - 0, !!!MatcherA() for: 0 not equals: (int) 1 or (string) "1" 777 # Combining MatchNotOfGeneric does not nest 778 ok {test-number} - with 1 message: 'std::is_same<decltype( !!!!MatcherA() ), MatcherA const&>::value' 779 # Combining MatchNotOfGeneric does not nest 780 ok {test-number} - 1, !!!!MatcherA() for: 1 equals: (int) 1 or (string) "1" 781 # Combining concrete matchers does not use templated matchers 782 ok {test-number} - with 1 message: 'std::is_same<decltype( StartsWith( "foo" ) || ( StartsWith( "bar" ) && EndsWith( "bar" ) && !EndsWith( "foo" ) ) ), Catch::Matchers::Detail::MatchAnyOf<std::string>>::value' 783 # Combining only templated matchers 784 ok {test-number} - with 1 message: 'std::is_same<decltype( MatcherA() || MatcherB() ), Catch::Matchers::Detail:: MatchAnyOfGeneric<MatcherA, MatcherB>>::value' 785 # Combining only templated matchers 786 ok {test-number} - 1, MatcherA() || MatcherB() for: 1 ( equals: (int) 1 or (string) "1" or equals: (long long) 1 ) 787 # Combining only templated matchers 788 ok {test-number} - with 1 message: 'std::is_same<decltype( MatcherA() && MatcherB() ), Catch::Matchers::Detail:: MatchAllOfGeneric<MatcherA, MatcherB>>::value' 789 # Combining only templated matchers 790 ok {test-number} - 1, MatcherA() && MatcherB() for: 1 ( equals: (int) 1 or (string) "1" and equals: (long long) 1 ) 791 # Combining only templated matchers 792 ok {test-number} - with 1 message: 'std::is_same< decltype( MatcherA() || !MatcherB() ), Catch::Matchers::Detail::MatchAnyOfGeneric< MatcherA, Catch::Matchers::Detail::MatchNotOfGeneric<MatcherB>>>::value' 793 # Combining only templated matchers 794 ok {test-number} - 1, MatcherA() || !MatcherB() for: 1 ( equals: (int) 1 or (string) "1" or not equals: (long long) 1 ) 795 # Combining templated and concrete matchers 796 ok {test-number} - vec, Predicate<std::vector<int>>( []( auto const& v ) { return std::all_of( v.begin(), v.end(), []( int elem ) { return elem % 2 == 1; } ); }, "All elements are odd" ) && !EqualsRange( a ) for: { 1, 3, 5 } ( matches predicate: "All elements are odd" and not Equals: { 5, 3, 1 } ) 797 # Combining templated and concrete matchers 798 ok {test-number} - str, StartsWith( "foo" ) && EqualsRange( arr ) && EndsWith( "bar" ) for: "foobar" ( starts with: "foo" and Equals: { 'f', 'o', 'o', 'b', 'a', 'r' } and ends with: "bar" ) 799 # Combining templated and concrete matchers 800 ok {test-number} - str, StartsWith( "foo" ) && !EqualsRange( bad_arr ) && EndsWith( "bar" ) for: "foobar" ( starts with: "foo" and not Equals: { 'o', 'o', 'f', 'b', 'a', 'r' } and ends with: "bar" ) 801 # Combining templated and concrete matchers 802 ok {test-number} - str, EqualsRange( arr ) && StartsWith( "foo" ) && EndsWith( "bar" ) for: "foobar" ( Equals: { 'f', 'o', 'o', 'b', 'a', 'r' } and starts with: "foo" and ends with: "bar" ) 803 # Combining templated and concrete matchers 804 ok {test-number} - str, !EqualsRange( bad_arr ) && StartsWith( "foo" ) && EndsWith( "bar" ) for: "foobar" ( not Equals: { 'o', 'o', 'f', 'b', 'a', 'r' } and starts with: "foo" and ends with: "bar" ) 805 # Combining templated and concrete matchers 806 ok {test-number} - str, EqualsRange( bad_arr ) || ( StartsWith( "foo" ) && EndsWith( "bar" ) ) for: "foobar" ( Equals: { 'o', 'o', 'f', 'b', 'a', 'r' } or ( starts with: "foo" and ends with: "bar" ) ) 807 # Combining templated and concrete matchers 808 ok {test-number} - str, ( StartsWith( "foo" ) && EndsWith( "bar" ) ) || EqualsRange( bad_arr ) for: "foobar" ( ( starts with: "foo" and ends with: "bar" ) or Equals: { 'o', 'o', 'f', 'b', 'a', 'r' } ) 809 # Combining templated matchers 810 ok {test-number} - container, EqualsRange( a ) || EqualsRange( b ) || EqualsRange( c ) for: { 1, 2, 3 } ( Equals: { 1, 2, 3 } or Equals: { 0, 1, 2 } or Equals: { 4, 5, 6 } ) 811 # Commas in various macros are allowed 812 ok {test-number} - std::vector<constructor_throws>{constructor_throws{}, constructor_throws{}} 813 # Commas in various macros are allowed 814 ok {test-number} - std::vector<constructor_throws>{constructor_throws{}, constructor_throws{}} 815 # Commas in various macros are allowed 816 ok {test-number} - std::vector<int>{1, 2, 3} == std::vector<int>{1, 2, 3} 817 # Commas in various macros are allowed 818 ok {test-number} - std::vector<int>{1, 2, 3} == std::vector<int>{1, 2, 3} 819 # Commas in various macros are allowed 820 ok {test-number} - std::vector<int>{1, 2} == std::vector<int>{1, 2} for: { 1, 2 } == { 1, 2 } 821 # Commas in various macros are allowed 822 ok {test-number} - std::vector<int>{1, 2} == std::vector<int>{1, 2} for: { 1, 2 } == { 1, 2 } 823 # Commas in various macros are allowed 824 ok {test-number} - !(std::vector<int>{1, 2} == std::vector<int>{1, 2, 3}) for: !({ 1, 2 } == { 1, 2, 3 }) 825 # Commas in various macros are allowed 826 ok {test-number} - !(std::vector<int>{1, 2} == std::vector<int>{1, 2, 3}) for: !({ 1, 2 } == { 1, 2, 3 }) 827 # Commas in various macros are allowed 828 ok {test-number} - std::vector<int>{1, 2} == std::vector<int>{1, 2} for: { 1, 2 } == { 1, 2 } 829 # Commas in various macros are allowed 830 ok {test-number} - std::vector<int>{1, 2} == std::vector<int>{1, 2} for: { 1, 2 } == { 1, 2 } 831 # Commas in various macros are allowed 832 ok {test-number} - true 833 # Commas in various macros are allowed 834 ok {test-number} - std::vector<int>{1, 2} == std::vector<int>{1, 2} for: { 1, 2 } == { 1, 2 } 835 # Comparing function pointers 836 ok {test-number} - a for: 0x<hex digits> 837 # Comparing function pointers 838 ok {test-number} - a == &foo for: 0x<hex digits> == 0x<hex digits> 839 # Comparison ops 840 ok {test-number} - SimplePcg32{} == SimplePcg32{} for: {?} == {?} 841 # Comparison ops 842 ok {test-number} - SimplePcg32{ 0 } != SimplePcg32{} for: {?} != {?} 843 # Comparison ops 844 ok {test-number} - !(SimplePcg32{ 1 } == SimplePcg32{ 2 }) for: !({?} == {?}) 845 # Comparison ops 846 ok {test-number} - !(SimplePcg32{ 1 } != SimplePcg32{ 1 }) for: !({?} != {?}) 847 # Comparison with explicitly convertible types 848 ok {test-number} - td == Approx(10.0) for: StrongDoubleTypedef(10) == Approx( 10.0 ) 849 # Comparison with explicitly convertible types 850 ok {test-number} - Approx(10.0) == td for: Approx( 10.0 ) == StrongDoubleTypedef(10) 851 # Comparison with explicitly convertible types 852 ok {test-number} - td != Approx(11.0) for: StrongDoubleTypedef(10) != Approx( 11.0 ) 853 # Comparison with explicitly convertible types 854 ok {test-number} - Approx(11.0) != td for: Approx( 11.0 ) != StrongDoubleTypedef(10) 855 # Comparison with explicitly convertible types 856 ok {test-number} - td <= Approx(10.0) for: StrongDoubleTypedef(10) <= Approx( 10.0 ) 857 # Comparison with explicitly convertible types 858 ok {test-number} - td <= Approx(11.0) for: StrongDoubleTypedef(10) <= Approx( 11.0 ) 859 # Comparison with explicitly convertible types 860 ok {test-number} - Approx(10.0) <= td for: Approx( 10.0 ) <= StrongDoubleTypedef(10) 861 # Comparison with explicitly convertible types 862 ok {test-number} - Approx(9.0) <= td for: Approx( 9.0 ) <= StrongDoubleTypedef(10) 863 # Comparison with explicitly convertible types 864 ok {test-number} - td >= Approx(9.0) for: StrongDoubleTypedef(10) >= Approx( 9.0 ) 865 # Comparison with explicitly convertible types 866 ok {test-number} - td >= Approx(td) for: StrongDoubleTypedef(10) >= Approx( 10.0 ) 867 # Comparison with explicitly convertible types 868 ok {test-number} - Approx(td) >= td for: Approx( 10.0 ) >= StrongDoubleTypedef(10) 869 # Comparison with explicitly convertible types 870 ok {test-number} - Approx(11.0) >= td for: Approx( 11.0 ) >= StrongDoubleTypedef(10) 871 # Comparisons between ints where one side is computed 872 ok {test-number} - 54 == 6*9 for: 54 == 54 873 # Comparisons between unsigned ints and negative signed ints match c++ standard behaviour 874 ok {test-number} - ( -1 > 2u ) for: true 875 # Comparisons between unsigned ints and negative signed ints match c++ standard behaviour 876 ok {test-number} - -1 > 2u for: -1 > 2 877 # Comparisons between unsigned ints and negative signed ints match c++ standard behaviour 878 ok {test-number} - ( 2u < -1 ) for: true 879 # Comparisons between unsigned ints and negative signed ints match c++ standard behaviour 880 ok {test-number} - 2u < -1 for: 2 < -1 881 # Comparisons between unsigned ints and negative signed ints match c++ standard behaviour 882 ok {test-number} - ( minInt > 2u ) for: true 883 # Comparisons between unsigned ints and negative signed ints match c++ standard behaviour 884 ok {test-number} - minInt > 2u for: -2147483648 > 2 885 # Comparisons with int literals don't warn when mixing signed/ unsigned 886 ok {test-number} - i == 1 for: 1 == 1 887 # Comparisons with int literals don't warn when mixing signed/ unsigned 888 ok {test-number} - ui == 2 for: 2 == 2 889 # Comparisons with int literals don't warn when mixing signed/ unsigned 890 ok {test-number} - l == 3 for: 3 == 3 891 # Comparisons with int literals don't warn when mixing signed/ unsigned 892 ok {test-number} - ul == 4 for: 4 == 4 893 # Comparisons with int literals don't warn when mixing signed/ unsigned 894 ok {test-number} - c == 5 for: 5 == 5 895 # Comparisons with int literals don't warn when mixing signed/ unsigned 896 ok {test-number} - uc == 6 for: 6 == 6 897 # Comparisons with int literals don't warn when mixing signed/ unsigned 898 ok {test-number} - 1 == i for: 1 == 1 899 # Comparisons with int literals don't warn when mixing signed/ unsigned 900 ok {test-number} - 2 == ui for: 2 == 2 901 # Comparisons with int literals don't warn when mixing signed/ unsigned 902 ok {test-number} - 3 == l for: 3 == 3 903 # Comparisons with int literals don't warn when mixing signed/ unsigned 904 ok {test-number} - 4 == ul for: 4 == 4 905 # Comparisons with int literals don't warn when mixing signed/ unsigned 906 ok {test-number} - 5 == c for: 5 == 5 907 # Comparisons with int literals don't warn when mixing signed/ unsigned 908 ok {test-number} - 6 == uc for: 6 == 6 909 # Comparisons with int literals don't warn when mixing signed/ unsigned 910 ok {test-number} - (std::numeric_limits<uint32_t>::max)() > ul for: 4294967295 (0x<hex digits>) > 4 911 # Composed generic matchers shortcircuit 912 ok {test-number} - !(matcher.match( 1 )) for: !false 913 # Composed generic matchers shortcircuit 914 ok {test-number} - first.matchCalled for: true 915 # Composed generic matchers shortcircuit 916 ok {test-number} - !second.matchCalled for: true 917 # Composed generic matchers shortcircuit 918 ok {test-number} - matcher.match( 1 ) for: true 919 # Composed generic matchers shortcircuit 920 ok {test-number} - first.matchCalled for: true 921 # Composed generic matchers shortcircuit 922 ok {test-number} - !second.matchCalled for: true 923 # Composed matchers shortcircuit 924 ok {test-number} - !(matcher.match( 1 )) for: !false 925 # Composed matchers shortcircuit 926 ok {test-number} - first.matchCalled for: true 927 # Composed matchers shortcircuit 928 ok {test-number} - !second.matchCalled for: true 929 # Composed matchers shortcircuit 930 ok {test-number} - matcher.match( 1 ) for: true 931 # Composed matchers shortcircuit 932 ok {test-number} - first.matchCalled for: true 933 # Composed matchers shortcircuit 934 ok {test-number} - !second.matchCalled for: true 935 # Contains string matcher 936 not ok {test-number} - testStringForMatching(), ContainsSubstring( "not there", Catch::CaseSensitive::No ) for: "this string contains 'abc' as a substring" contains: "not there" (case insensitive) 937 # Contains string matcher 938 not ok {test-number} - testStringForMatching(), ContainsSubstring( "STRING" ) for: "this string contains 'abc' as a substring" contains: "STRING" 939 # Copy and then generate a range 940 ok {test-number} - elem % 2 == 1 for: 1 == 1 941 # Copy and then generate a range 942 ok {test-number} - elem % 2 == 1 for: 1 == 1 943 # Copy and then generate a range 944 ok {test-number} - elem % 2 == 1 for: 1 == 1 945 # Copy and then generate a range 946 ok {test-number} - elem % 2 == 1 for: 1 == 1 947 # Copy and then generate a range 948 ok {test-number} - elem % 2 == 1 for: 1 == 1 949 # Copy and then generate a range 950 ok {test-number} - elem % 2 == 1 for: 1 == 1 951 # Copy and then generate a range 952 ok {test-number} - elem % 2 == 1 for: 1 == 1 953 # Copy and then generate a range 954 ok {test-number} - elem % 2 == 1 for: 1 == 1 955 # Copy and then generate a range 956 ok {test-number} - elem % 2 == 1 for: 1 == 1 957 # Copy and then generate a range 958 ok {test-number} - elem % 2 == 1 for: 1 == 1 959 # Copy and then generate a range 960 ok {test-number} - elem % 2 == 1 for: 1 == 1 961 # Copy and then generate a range 962 ok {test-number} - elem % 2 == 1 for: 1 == 1 963 # Copy and then generate a range 964 ok {test-number} - call_count == 1 for: 1 == 1 965 # Copy and then generate a range 966 ok {test-number} - make_data().size() == test_count for: 6 == 6 967 # Cout stream properly declares it writes to stdout 968 ok {test-number} - Catch::makeStream( "-" )->isConsole() for: true 969 # Custom exceptions can be translated when testing for nothrow 970 not ok {test-number} - unexpected exception with message: 'custom exception - not std'; expression was: throwCustom() 971 # Custom exceptions can be translated when testing for throwing as something else 972 not ok {test-number} - unexpected exception with message: 'custom exception - not std'; expression was: throwCustom(), std::exception 973 # Custom std-exceptions can be custom translated 974 not ok {test-number} - unexpected exception with message: 'custom std exception' 975 # Default scale is invisible to comparison 976 ok {test-number} - 101.000001 != Approx(100).epsilon(0.01) for: 101.000001 != Approx( 100.0 ) 977 # Default scale is invisible to comparison 978 ok {test-number} - std::pow(10, -5) != Approx(std::pow(10, -7)) for: 0.00001 != Approx( 0.0000001 ) 979 # Directly creating an EnumInfo 980 ok {test-number} - enumInfo->lookup(0) == "Value1" for: Value1 == "Value1" 981 # Directly creating an EnumInfo 982 ok {test-number} - enumInfo->lookup(1) == "Value2" for: Value2 == "Value2" 983 # Directly creating an EnumInfo 984 ok {test-number} - enumInfo->lookup(3) == "{** unexpected enum value **}" for: {** unexpected enum value **} == "{** unexpected enum value **}" 985 # Empty generators can SKIP in constructor 986 ok {test-number} - # SKIP 'This generator is empty' 987 # Empty stream name opens cout stream 988 ok {test-number} - Catch::makeStream( "" )->isConsole() for: true 989 # EndsWith string matcher 990 not ok {test-number} - testStringForMatching(), EndsWith( "Substring" ) for: "this string contains 'abc' as a substring" ends with: "Substring" 991 # EndsWith string matcher 992 not ok {test-number} - testStringForMatching(), EndsWith( "this", Catch::CaseSensitive::No ) for: "this string contains 'abc' as a substring" ends with: "this" (case insensitive) 993 # Enums can quickly have stringification enabled using REGISTER_ENUM 994 ok {test-number} - stringify( EnumClass3::Value1 ) == "Value1" for: "Value1" == "Value1" 995 # Enums can quickly have stringification enabled using REGISTER_ENUM 996 ok {test-number} - stringify( EnumClass3::Value2 ) == "Value2" for: "Value2" == "Value2" 997 # Enums can quickly have stringification enabled using REGISTER_ENUM 998 ok {test-number} - stringify( EnumClass3::Value3 ) == "Value3" for: "Value3" == "Value3" 999 # Enums can quickly have stringification enabled using REGISTER_ENUM 1000 ok {test-number} - stringify( EnumClass3::Value4 ) == "{** unexpected enum value **}" for: "{** unexpected enum value **}" == "{** unexpected enum value **}" 1001 # Enums can quickly have stringification enabled using REGISTER_ENUM 1002 ok {test-number} - stringify( ec3 ) == "Value2" for: "Value2" == "Value2" 1003 # Enums in namespaces can quickly have stringification enabled using REGISTER_ENUM 1004 ok {test-number} - stringify( Bikeshed::Colours::Red ) == "Red" for: "Red" == "Red" 1005 # Enums in namespaces can quickly have stringification enabled using REGISTER_ENUM 1006 ok {test-number} - stringify( Bikeshed::Colours::Blue ) == "Blue" for: "Blue" == "Blue" 1007 # Epsilon only applies to Approx's value 1008 ok {test-number} - 101.01 != Approx(100).epsilon(0.01) for: 101.01 != Approx( 100.0 ) 1009 # Equality checks that should fail 1010 not ok {test-number} - data.int_seven == 6 for: 7 == 6 1011 # Equality checks that should fail 1012 not ok {test-number} - data.int_seven == 8 for: 7 == 8 1013 # Equality checks that should fail 1014 not ok {test-number} - data.int_seven == 0 for: 7 == 0 1015 # Equality checks that should fail 1016 not ok {test-number} - data.float_nine_point_one == Approx( 9.11f ) for: 9.1f == Approx( 9.1099996567 ) 1017 # Equality checks that should fail 1018 not ok {test-number} - data.float_nine_point_one == Approx( 9.0f ) for: 9.1f == Approx( 9.0 ) 1019 # Equality checks that should fail 1020 not ok {test-number} - data.float_nine_point_one == Approx( 1 ) for: 9.1f == Approx( 1.0 ) 1021 # Equality checks that should fail 1022 not ok {test-number} - data.float_nine_point_one == Approx( 0 ) for: 9.1f == Approx( 0.0 ) 1023 # Equality checks that should fail 1024 not ok {test-number} - data.double_pi == Approx( 3.1415 ) for: 3.1415926535 == Approx( 3.1415 ) 1025 # Equality checks that should fail 1026 not ok {test-number} - data.str_hello == "goodbye" for: "hello" == "goodbye" 1027 # Equality checks that should fail 1028 not ok {test-number} - data.str_hello == "hell" for: "hello" == "hell" 1029 # Equality checks that should fail 1030 not ok {test-number} - data.str_hello == "hello1" for: "hello" == "hello1" 1031 # Equality checks that should fail 1032 not ok {test-number} - data.str_hello.size() == 6 for: 5 == 6 1033 # Equality checks that should fail 1034 not ok {test-number} - x == Approx( 1.301 ) for: 1.3 == Approx( 1.301 ) 1035 # Equality checks that should succeed 1036 ok {test-number} - data.int_seven == 7 for: 7 == 7 1037 # Equality checks that should succeed 1038 ok {test-number} - data.float_nine_point_one == Approx( 9.1f ) for: 9.1f == Approx( 9.1000003815 ) 1039 # Equality checks that should succeed 1040 ok {test-number} - data.double_pi == Approx( 3.1415926535 ) for: 3.1415926535 == Approx( 3.1415926535 ) 1041 # Equality checks that should succeed 1042 ok {test-number} - data.str_hello == "hello" for: "hello" == "hello" 1043 # Equality checks that should succeed 1044 ok {test-number} - "hello" == data.str_hello for: "hello" == "hello" 1045 # Equality checks that should succeed 1046 ok {test-number} - data.str_hello.size() == 5 for: 5 == 5 1047 # Equality checks that should succeed 1048 ok {test-number} - x == Approx( 1.3 ) for: 1.3 == Approx( 1.3 ) 1049 # Equals 1050 ok {test-number} - testStringForMatching(), Equals( "this string contains 'abc' as a substring" ) for: "this string contains 'abc' as a substring" equals: "this string contains 'abc' as a substring" 1051 # Equals 1052 ok {test-number} - testStringForMatching(), Equals( "this string contains 'ABC' as a substring", Catch::CaseSensitive::No ) for: "this string contains 'abc' as a substring" equals: "this string contains 'abc' as a substring" (case insensitive) 1053 # Equals string matcher 1054 not ok {test-number} - testStringForMatching(), Equals( "this string contains 'ABC' as a substring" ) for: "this string contains 'abc' as a substring" equals: "this string contains 'ABC' as a substring" 1055 # Equals string matcher 1056 not ok {test-number} - testStringForMatching(), Equals( "something else", Catch::CaseSensitive::No ) for: "this string contains 'abc' as a substring" equals: "something else" (case insensitive) 1057 # Exception as a value (e.g. in REQUIRE_THROWS_MATCHES) can be stringified 1058 ok {test-number} - ::Catch::Detail::stringify(WhatException{}) == "This exception has overridden what() method" for: "This exception has overridden what() method" == "This exception has overridden what() method" 1059 # Exception as a value (e.g. in REQUIRE_THROWS_MATCHES) can be stringified 1060 ok {test-number} - ::Catch::Detail::stringify(OperatorException{}) == "OperatorException" for: "OperatorException" == "OperatorException" 1061 # Exception as a value (e.g. in REQUIRE_THROWS_MATCHES) can be stringified 1062 ok {test-number} - ::Catch::Detail::stringify(StringMakerException{}) == "StringMakerException" for: "StringMakerException" == "StringMakerException" 1063 # Exception matchers that fail 1064 not ok {test-number} - expected exception, got none; expression was: doesNotThrow(), SpecialException, ExceptionMatcher{ 1 } 1065 # Exception matchers that fail 1066 not ok {test-number} - expected exception, got none; expression was: doesNotThrow(), SpecialException, ExceptionMatcher{ 1 } 1067 # Exception matchers that fail 1068 not ok {test-number} - unexpected exception with message: 'Unknown exception'; expression was: throwsAsInt( 1 ), SpecialException, ExceptionMatcher{ 1 } 1069 # Exception matchers that fail 1070 not ok {test-number} - unexpected exception with message: 'Unknown exception'; expression was: throwsAsInt( 1 ), SpecialException, ExceptionMatcher{ 1 } 1071 # Exception matchers that fail 1072 not ok {test-number} - throwsSpecialException( 3 ), SpecialException, ExceptionMatcher{ 1 } for: SpecialException::what special exception has value of 1 1073 # Exception matchers that fail 1074 not ok {test-number} - throwsSpecialException( 4 ), SpecialException, ExceptionMatcher{ 1 } for: SpecialException::what special exception has value of 1 1075 # Exception matchers that succeed 1076 ok {test-number} - throwsSpecialException( 1 ), SpecialException, ExceptionMatcher{ 1 } for: SpecialException::what special exception has value of 1 1077 # Exception matchers that succeed 1078 ok {test-number} - throwsSpecialException( 2 ), SpecialException, ExceptionMatcher{ 2 } for: SpecialException::what special exception has value of 2 1079 # Exception message can be matched 1080 ok {test-number} - throwsDerivedException(), DerivedException, MessageMatches( StartsWith( "Derived" ) ) for: DerivedException::what matches "starts with: "Derived"" 1081 # Exception message can be matched 1082 ok {test-number} - throwsDerivedException(), DerivedException, MessageMatches( EndsWith( "::what" ) ) for: DerivedException::what matches "ends with: "::what"" 1083 # Exception message can be matched 1084 ok {test-number} - throwsDerivedException(), DerivedException, MessageMatches( !StartsWith( "::what" ) ) for: DerivedException::what matches "not starts with: "::what"" 1085 # Exception message can be matched 1086 ok {test-number} - throwsSpecialException( 2 ), SpecialException, MessageMatches( StartsWith( "Special" ) ) for: SpecialException::what matches "starts with: "Special"" 1087 # Exception messages can be tested for 1088 ok {test-number} - thisThrows(), "expected exception" for: "expected exception" equals: "expected exception" 1089 # Exception messages can be tested for 1090 ok {test-number} - thisThrows(), Equals( "expecteD Exception", Catch::CaseSensitive::No ) for: "expected exception" equals: "expected exception" (case insensitive) 1091 # Exception messages can be tested for 1092 ok {test-number} - thisThrows(), StartsWith( "expected" ) for: "expected exception" starts with: "expected" 1093 # Exception messages can be tested for 1094 ok {test-number} - thisThrows(), EndsWith( "exception" ) for: "expected exception" ends with: "exception" 1095 # Exception messages can be tested for 1096 ok {test-number} - thisThrows(), ContainsSubstring( "except" ) for: "expected exception" contains: "except" 1097 # Exception messages can be tested for 1098 ok {test-number} - thisThrows(), ContainsSubstring( "exCept", Catch::CaseSensitive::No ) for: "expected exception" contains: "except" (case insensitive) 1099 # Exceptions matchers 1100 ok {test-number} - throwsDerivedException(), DerivedException, Message( "DerivedException::what" ) for: DerivedException::what exception message matches "DerivedException::what" 1101 # Exceptions matchers 1102 ok {test-number} - throwsDerivedException(), DerivedException, !Message( "derivedexception::what" ) for: DerivedException::what not exception message matches "derivedexception::what" 1103 # Exceptions matchers 1104 ok {test-number} - throwsSpecialException( 2 ), SpecialException, !Message( "DerivedException::what" ) for: SpecialException::what not exception message matches "DerivedException::what" 1105 # Exceptions matchers 1106 ok {test-number} - throwsSpecialException( 2 ), SpecialException, Message( "SpecialException::what" ) for: SpecialException::what exception message matches "SpecialException::what" 1107 # Expected exceptions that don't throw or unexpected exceptions fail the test 1108 not ok {test-number} - unexpected exception with message: 'expected exception'; expression was: thisThrows(), std::string 1109 # Expected exceptions that don't throw or unexpected exceptions fail the test 1110 not ok {test-number} - expected exception, got none; expression was: thisDoesntThrow(), std::domain_error 1111 # Expected exceptions that don't throw or unexpected exceptions fail the test 1112 not ok {test-number} - unexpected exception with message: 'expected exception'; expression was: thisThrows() 1113 # FAIL aborts the test 1114 not ok {test-number} - explicitly with 1 message: 'This is a failure' 1115 # FAIL does not require an argument 1116 not ok {test-number} - explicitly 1117 # FAIL_CHECK does not abort the test 1118 not ok {test-number} - explicitly with 1 message: 'This is a failure' 1119 # FAIL_CHECK does not abort the test 1120 warning {test-number} - 'This message appears in the output' 1121 # Factorials are computed 1122 ok {test-number} - Factorial(0) == 1 for: 1 == 1 1123 # Factorials are computed 1124 ok {test-number} - Factorial(1) == 1 for: 1 == 1 1125 # Factorials are computed 1126 ok {test-number} - Factorial(2) == 2 for: 2 == 2 1127 # Factorials are computed 1128 ok {test-number} - Factorial(3) == 6 for: 6 == 6 1129 # Factorials are computed 1130 ok {test-number} - Factorial(10) == 3628800 for: 3628800 (0x<hex digits>) == 3628800 (0x<hex digits>) 1131 # Filter generator throws exception for empty generator 1132 ok {test-number} - filter( []( int ) { return false; }, value( 3 ) ), Catch::GeneratorException 1133 # Floating point matchers: double 1134 ok {test-number} - 10., WithinRel( 11.1, 0.1 ) for: 10.0 and 11.1 are within 10% of each other 1135 # Floating point matchers: double 1136 ok {test-number} - 10., !WithinRel( 11.2, 0.1 ) for: 10.0 not and 11.2 are within 10% of each other 1137 # Floating point matchers: double 1138 ok {test-number} - 1., !WithinRel( 0., 0.99 ) for: 1.0 not and 0 are within 99% of each other 1139 # Floating point matchers: double 1140 ok {test-number} - -0., WithinRel( 0. ) for: -0.0 and 0 are within 2.22045e-12% of each other 1141 # Floating point matchers: double 1142 ok {test-number} - v1, WithinRel( v2 ) for: 0.0 and 2.22507e-308 are within 2.22045e-12% of each other 1143 # Floating point matchers: double 1144 ok {test-number} - 1., WithinAbs( 1., 0 ) for: 1.0 is within 0.0 of 1.0 1145 # Floating point matchers: double 1146 ok {test-number} - 0., WithinAbs( 1., 1 ) for: 0.0 is within 1.0 of 1.0 1147 # Floating point matchers: double 1148 ok {test-number} - 0., !WithinAbs( 1., 0.99 ) for: 0.0 not is within 0.99 of 1.0 1149 # Floating point matchers: double 1150 ok {test-number} - 0., !WithinAbs( 1., 0.99 ) for: 0.0 not is within 0.99 of 1.0 1151 # Floating point matchers: double 1152 ok {test-number} - 11., !WithinAbs( 10., 0.5 ) for: 11.0 not is within 0.5 of 10.0 1153 # Floating point matchers: double 1154 ok {test-number} - 10., !WithinAbs( 11., 0.5 ) for: 10.0 not is within 0.5 of 11.0 1155 # Floating point matchers: double 1156 ok {test-number} - -10., WithinAbs( -10., 0.5 ) for: -10.0 is within 0.5 of -10.0 1157 # Floating point matchers: double 1158 ok {test-number} - -10., WithinAbs( -9.6, 0.5 ) for: -10.0 is within 0.5 of -9.6 1159 # Floating point matchers: double 1160 ok {test-number} - 1., WithinULP( 1., 0 ) for: 1.0 is within 0 ULPs of 1.0000000000000000e+00 ([1.0000000000000000e+00, 1.0000000000000000e+00]) 1161 # Floating point matchers: double 1162 ok {test-number} - nextafter( 1., 2. ), WithinULP( 1., 1 ) for: 1.0 is within 1 ULPs of 1.0000000000000000e+00 ([9.9999999999999989e-01, 1.0000000000000002e+00]) 1163 # Floating point matchers: double 1164 ok {test-number} - 0., WithinULP( nextafter( 0., 1. ), 1 ) for: 0.0 is within 1 ULPs of 4.9406564584124654e-324 ([0.0000000000000000e+00, 9.8813129168249309e-324]) 1165 # Floating point matchers: double 1166 ok {test-number} - 1., WithinULP( nextafter( 1., 0. ), 1 ) for: 1.0 is within 1 ULPs of 9.9999999999999989e-01 ([9.9999999999999978e-01, 1.0000000000000000e+00]) 1167 # Floating point matchers: double 1168 ok {test-number} - 1., !WithinULP( nextafter( 1., 2. ), 0 ) for: 1.0 not is within 0 ULPs of 1.0000000000000002e+00 ([1.0000000000000002e+00, 1.0000000000000002e+00]) 1169 # Floating point matchers: double 1170 ok {test-number} - 1., WithinULP( 1., 0 ) for: 1.0 is within 0 ULPs of 1.0000000000000000e+00 ([1.0000000000000000e+00, 1.0000000000000000e+00]) 1171 # Floating point matchers: double 1172 ok {test-number} - -0., WithinULP( 0., 0 ) for: -0.0 is within 0 ULPs of 0.0000000000000000e+00 ([0.0000000000000000e+00, 0.0000000000000000e+00]) 1173 # Floating point matchers: double 1174 ok {test-number} - 1., WithinAbs( 1., 0.5 ) || WithinULP( 2., 1 ) for: 1.0 ( is within 0.5 of 1.0 or is within 1 ULPs of 2.0000000000000000e+00 ([1.9999999999999998e+00, 2.0000000000000004e+00]) ) 1175 # Floating point matchers: double 1176 ok {test-number} - 1., WithinAbs( 2., 0.5 ) || WithinULP( 1., 0 ) for: 1.0 ( is within 0.5 of 2.0 or is within 0 ULPs of 1.0000000000000000e+00 ([1.0000000000000000e+00, 1.0000000000000000e+00]) ) 1177 # Floating point matchers: double 1178 ok {test-number} - 0.0001, WithinAbs( 0., 0.001 ) || WithinRel( 0., 0.1 ) for: 0.0001 ( is within 0.001 of 0.0 or and 0 are within 10% of each other ) 1179 # Floating point matchers: double 1180 ok {test-number} - WithinAbs( 1., 0. ) 1181 # Floating point matchers: double 1182 ok {test-number} - WithinAbs( 1., -1. ), std::domain_error 1183 # Floating point matchers: double 1184 ok {test-number} - WithinULP( 1., 0 ) 1185 # Floating point matchers: double 1186 ok {test-number} - WithinRel( 1., 0. ) 1187 # Floating point matchers: double 1188 ok {test-number} - WithinRel( 1., -0.2 ), std::domain_error 1189 # Floating point matchers: double 1190 ok {test-number} - WithinRel( 1., 1. ), std::domain_error 1191 # Floating point matchers: double 1192 ok {test-number} - 1., !IsNaN() for: 1.0 not is NaN 1193 # Floating point matchers: float 1194 ok {test-number} - 10.f, WithinRel( 11.1f, 0.1f ) for: 10.0f and 11.1 are within 10% of each other 1195 # Floating point matchers: float 1196 ok {test-number} - 10.f, !WithinRel( 11.2f, 0.1f ) for: 10.0f not and 11.2 are within 10% of each other 1197 # Floating point matchers: float 1198 ok {test-number} - 1.f, !WithinRel( 0.f, 0.99f ) for: 1.0f not and 0 are within 99% of each other 1199 # Floating point matchers: float 1200 ok {test-number} - -0.f, WithinRel( 0.f ) for: -0.0f and 0 are within 0.00119209% of each other 1201 # Floating point matchers: float 1202 ok {test-number} - v1, WithinRel( v2 ) for: 0.0f and 1.17549e-38 are within 0.00119209% of each other 1203 # Floating point matchers: float 1204 ok {test-number} - 1.f, WithinAbs( 1.f, 0 ) for: 1.0f is within 0.0 of 1.0 1205 # Floating point matchers: float 1206 ok {test-number} - 0.f, WithinAbs( 1.f, 1 ) for: 0.0f is within 1.0 of 1.0 1207 # Floating point matchers: float 1208 ok {test-number} - 0.f, !WithinAbs( 1.f, 0.99f ) for: 0.0f not is within 0.9900000095 of 1.0 1209 # Floating point matchers: float 1210 ok {test-number} - 0.f, !WithinAbs( 1.f, 0.99f ) for: 0.0f not is within 0.9900000095 of 1.0 1211 # Floating point matchers: float 1212 ok {test-number} - 0.f, WithinAbs( -0.f, 0 ) for: 0.0f is within 0.0 of -0.0 1213 # Floating point matchers: float 1214 ok {test-number} - 11.f, !WithinAbs( 10.f, 0.5f ) for: 11.0f not is within 0.5 of 10.0 1215 # Floating point matchers: float 1216 ok {test-number} - 10.f, !WithinAbs( 11.f, 0.5f ) for: 10.0f not is within 0.5 of 11.0 1217 # Floating point matchers: float 1218 ok {test-number} - -10.f, WithinAbs( -10.f, 0.5f ) for: -10.0f is within 0.5 of -10.0 1219 # Floating point matchers: float 1220 ok {test-number} - -10.f, WithinAbs( -9.6f, 0.5f ) for: -10.0f is within 0.5 of -9.6000003815 1221 # Floating point matchers: float 1222 ok {test-number} - 1.f, WithinULP( 1.f, 0 ) for: 1.0f is within 0 ULPs of 1.00000000e+00f ([1.00000000e+00, 1.00000000e+00]) 1223 # Floating point matchers: float 1224 ok {test-number} - -1.f, WithinULP( -1.f, 0 ) for: -1.0f is within 0 ULPs of -1.00000000e+00f ([-1.00000000e+00, -1.00000000e+00]) 1225 # Floating point matchers: float 1226 ok {test-number} - nextafter( 1.f, 2.f ), WithinULP( 1.f, 1 ) for: 1.0f is within 1 ULPs of 1.00000000e+00f ([9.99999940e-01, 1.00000012e+00]) 1227 # Floating point matchers: float 1228 ok {test-number} - 0.f, WithinULP( nextafter( 0.f, 1.f ), 1 ) for: 0.0f is within 1 ULPs of 1.40129846e-45f ([0.00000000e+00, 2.80259693e-45]) 1229 # Floating point matchers: float 1230 ok {test-number} - 1.f, WithinULP( nextafter( 1.f, 0.f ), 1 ) for: 1.0f is within 1 ULPs of 9.99999940e-01f ([9.99999881e-01, 1.00000000e+00]) 1231 # Floating point matchers: float 1232 ok {test-number} - 1.f, !WithinULP( nextafter( 1.f, 2.f ), 0 ) for: 1.0f not is within 0 ULPs of 1.00000012e+00f ([1.00000012e+00, 1.00000012e+00]) 1233 # Floating point matchers: float 1234 ok {test-number} - 1.f, WithinULP( 1.f, 0 ) for: 1.0f is within 0 ULPs of 1.00000000e+00f ([1.00000000e+00, 1.00000000e+00]) 1235 # Floating point matchers: float 1236 ok {test-number} - -0.f, WithinULP( 0.f, 0 ) for: -0.0f is within 0 ULPs of 0.00000000e+00f ([0.00000000e+00, 0.00000000e+00]) 1237 # Floating point matchers: float 1238 ok {test-number} - 1.f, WithinAbs( 1.f, 0.5 ) || WithinULP( 1.f, 1 ) for: 1.0f ( is within 0.5 of 1.0 or is within 1 ULPs of 1.00000000e+00f ([9.99999940e-01, 1.00000012e+00]) ) 1239 # Floating point matchers: float 1240 ok {test-number} - 1.f, WithinAbs( 2.f, 0.5 ) || WithinULP( 1.f, 0 ) for: 1.0f ( is within 0.5 of 2.0 or is within 0 ULPs of 1.00000000e+00f ([1.00000000e+00, 1.00000000e+00]) ) 1241 # Floating point matchers: float 1242 ok {test-number} - 0.0001f, WithinAbs( 0.f, 0.001f ) || WithinRel( 0.f, 0.1f ) for: 0.0001f ( is within 0.001 of 0.0 or and 0 are within 10% of each other ) 1243 # Floating point matchers: float 1244 ok {test-number} - WithinAbs( 1.f, 0.f ) 1245 # Floating point matchers: float 1246 ok {test-number} - WithinAbs( 1.f, -1.f ), std::domain_error 1247 # Floating point matchers: float 1248 ok {test-number} - WithinULP( 1.f, 0 ) 1249 # Floating point matchers: float 1250 ok {test-number} - WithinULP( 1.f, static_cast<uint64_t>( -1 ) ), std::domain_error 1251 # Floating point matchers: float 1252 ok {test-number} - WithinRel( 1.f, 0.f ) 1253 # Floating point matchers: float 1254 ok {test-number} - WithinRel( 1.f, -0.2f ), std::domain_error 1255 # Floating point matchers: float 1256 ok {test-number} - WithinRel( 1.f, 1.f ), std::domain_error 1257 # Floating point matchers: float 1258 ok {test-number} - 1., !IsNaN() for: 1.0 not is NaN 1259 # GENERATE can combine literals and generators 1260 ok {test-number} - i % 2 == 0 for: 0 == 0 1261 # GENERATE can combine literals and generators 1262 ok {test-number} - i % 2 == 0 for: 0 == 0 1263 # GENERATE can combine literals and generators 1264 ok {test-number} - i % 2 == 0 for: 0 == 0 1265 # GENERATE can combine literals and generators 1266 ok {test-number} - i % 2 == 0 for: 0 == 0 1267 # Generators -- adapters 1268 ok {test-number} - i % 2 == 0 for: 0 == 0 1269 # Generators -- adapters 1270 ok {test-number} - i % 2 == 0 for: 0 == 0 1271 # Generators -- adapters 1272 ok {test-number} - i % 2 == 0 for: 0 == 0 1273 # Generators -- adapters 1274 ok {test-number} - filter([] (int) {return false; }, value(1)), Catch::GeneratorException 1275 # Generators -- adapters 1276 ok {test-number} - i < 4 for: 1 < 4 1277 # Generators -- adapters 1278 ok {test-number} - i < 4 for: 2 < 4 1279 # Generators -- adapters 1280 ok {test-number} - i < 4 for: 3 < 4 1281 # Generators -- adapters 1282 ok {test-number} - i % 2 == 0 for: 0 == 0 1283 # Generators -- adapters 1284 ok {test-number} - i % 2 == 0 for: 0 == 0 1285 # Generators -- adapters 1286 ok {test-number} - i % 2 == 0 for: 0 == 0 1287 # Generators -- adapters 1288 ok {test-number} - i.size() == 1 for: 1 == 1 1289 # Generators -- adapters 1290 ok {test-number} - i.size() == 1 for: 1 == 1 1291 # Generators -- adapters 1292 ok {test-number} - i.size() == 1 for: 1 == 1 1293 # Generators -- adapters 1294 ok {test-number} - i.size() == 1 for: 1 == 1 1295 # Generators -- adapters 1296 ok {test-number} - i.size() == 1 for: 1 == 1 1297 # Generators -- adapters 1298 ok {test-number} - i.size() == 1 for: 1 == 1 1299 # Generators -- adapters 1300 ok {test-number} - j > 0 for: 1 > 0 1301 # Generators -- adapters 1302 ok {test-number} - j > 0 for: 2 > 0 1303 # Generators -- adapters 1304 ok {test-number} - j > 0 for: 3 > 0 1305 # Generators -- adapters 1306 ok {test-number} - j > 0 for: 1 > 0 1307 # Generators -- adapters 1308 ok {test-number} - j > 0 for: 2 > 0 1309 # Generators -- adapters 1310 ok {test-number} - j > 0 for: 3 > 0 1311 # Generators -- adapters 1312 ok {test-number} - chunk2.size() == 2 for: 2 == 2 1313 # Generators -- adapters 1314 ok {test-number} - chunk2.front() == chunk2.back() for: 1 == 1 1315 # Generators -- adapters 1316 ok {test-number} - chunk2.size() == 2 for: 2 == 2 1317 # Generators -- adapters 1318 ok {test-number} - chunk2.front() == chunk2.back() for: 2 == 2 1319 # Generators -- adapters 1320 ok {test-number} - chunk2.size() == 2 for: 2 == 2 1321 # Generators -- adapters 1322 ok {test-number} - chunk2.front() == chunk2.back() for: 3 == 3 1323 # Generators -- adapters 1324 ok {test-number} - chunk2.size() == 2 for: 2 == 2 1325 # Generators -- adapters 1326 ok {test-number} - chunk2.front() == chunk2.back() for: 1 == 1 1327 # Generators -- adapters 1328 ok {test-number} - chunk2.front() < 3 for: 1 < 3 1329 # Generators -- adapters 1330 ok {test-number} - chunk2.size() == 2 for: 2 == 2 1331 # Generators -- adapters 1332 ok {test-number} - chunk2.front() == chunk2.back() for: 2 == 2 1333 # Generators -- adapters 1334 ok {test-number} - chunk2.front() < 3 for: 2 < 3 1335 # Generators -- adapters 1336 ok {test-number} - chunk2.size() == 0 for: 0 == 0 1337 # Generators -- adapters 1338 ok {test-number} - chunk2.size() == 0 for: 0 == 0 1339 # Generators -- adapters 1340 ok {test-number} - chunk2.size() == 0 for: 0 == 0 1341 # Generators -- adapters 1342 ok {test-number} - chunk(2, value(1)), Catch::GeneratorException 1343 # Generators -- simple 1344 ok {test-number} - j < i for: -3 < 1 1345 # Generators -- simple 1346 ok {test-number} - j < i for: -2 < 1 1347 # Generators -- simple 1348 ok {test-number} - j < i for: -1 < 1 1349 # Generators -- simple 1350 ok {test-number} - 4u * i > str.size() for: 4 > 1 1351 # Generators -- simple 1352 ok {test-number} - 4u * i > str.size() for: 4 > 2 1353 # Generators -- simple 1354 ok {test-number} - 4u * i > str.size() for: 4 > 3 1355 # Generators -- simple 1356 ok {test-number} - j < i for: -3 < 2 1357 # Generators -- simple 1358 ok {test-number} - j < i for: -2 < 2 1359 # Generators -- simple 1360 ok {test-number} - j < i for: -1 < 2 1361 # Generators -- simple 1362 ok {test-number} - 4u * i > str.size() for: 8 > 1 1363 # Generators -- simple 1364 ok {test-number} - 4u * i > str.size() for: 8 > 2 1365 # Generators -- simple 1366 ok {test-number} - 4u * i > str.size() for: 8 > 3 1367 # Generators -- simple 1368 ok {test-number} - j < i for: -3 < 3 1369 # Generators -- simple 1370 ok {test-number} - j < i for: -2 < 3 1371 # Generators -- simple 1372 ok {test-number} - j < i for: -1 < 3 1373 # Generators -- simple 1374 ok {test-number} - 4u * i > str.size() for: 12 > 1 1375 # Generators -- simple 1376 ok {test-number} - 4u * i > str.size() for: 12 > 2 1377 # Generators -- simple 1378 ok {test-number} - 4u * i > str.size() for: 12 > 3 1379 # Generators internals 1380 ok {test-number} - gen.get() == 123 for: 123 == 123 1381 # Generators internals 1382 ok {test-number} - !(gen.next()) for: !false 1383 # Generators internals 1384 ok {test-number} - gen.get() == 1 for: 1 == 1 1385 # Generators internals 1386 ok {test-number} - gen.next() for: true 1387 # Generators internals 1388 ok {test-number} - gen.get() == 3 for: 3 == 3 1389 # Generators internals 1390 ok {test-number} - gen.next() for: true 1391 # Generators internals 1392 ok {test-number} - gen.get() == 5 for: 5 == 5 1393 # Generators internals 1394 ok {test-number} - !(gen.next()) for: !false 1395 # Generators internals 1396 ok {test-number} - gen.get() == 1 for: 1 == 1 1397 # Generators internals 1398 ok {test-number} - gen.next() for: true 1399 # Generators internals 1400 ok {test-number} - gen.get() == 5 for: 5 == 5 1401 # Generators internals 1402 ok {test-number} - gen.next() for: true 1403 # Generators internals 1404 ok {test-number} - gen.get() == 2 for: 2 == 2 1405 # Generators internals 1406 ok {test-number} - gen.next() for: true 1407 # Generators internals 1408 ok {test-number} - gen.get() == 4 for: 4 == 4 1409 # Generators internals 1410 ok {test-number} - gen.next() for: true 1411 # Generators internals 1412 ok {test-number} - gen.get() == 0 for: 0 == 0 1413 # Generators internals 1414 ok {test-number} - !(gen.next()) for: !false 1415 # Generators internals 1416 ok {test-number} - gen.get().size() == 2 for: 2 == 2 1417 # Generators internals 1418 ok {test-number} - gen.get() == "aa" for: "aa" == "aa" 1419 # Generators internals 1420 ok {test-number} - gen.next() for: true 1421 # Generators internals 1422 ok {test-number} - gen.get() == "bb" for: "bb" == "bb" 1423 # Generators internals 1424 ok {test-number} - gen.next() for: true 1425 # Generators internals 1426 ok {test-number} - gen.get() == "cc" for: "cc" == "cc" 1427 # Generators internals 1428 ok {test-number} - !(gen.next()) for: !false 1429 # Generators internals 1430 ok {test-number} - gen.get() == 1 for: 1 == 1 1431 # Generators internals 1432 ok {test-number} - gen.next() for: true 1433 # Generators internals 1434 ok {test-number} - gen.get() == 3 for: 3 == 3 1435 # Generators internals 1436 ok {test-number} - !(gen.next()) for: !false 1437 # Generators internals 1438 ok {test-number} - gen.get() == 1 for: 1 == 1 1439 # Generators internals 1440 ok {test-number} - gen.next() for: true 1441 # Generators internals 1442 ok {test-number} - gen.get() == 3 for: 3 == 3 1443 # Generators internals 1444 ok {test-number} - !(gen.next()) for: !false 1445 # Generators internals 1446 ok {test-number} - filter([](int) { return false; }, value(1)), Catch::GeneratorException 1447 # Generators internals 1448 ok {test-number} - filter([](int) { return false; }, values({ 1, 2, 3 })), Catch::GeneratorException 1449 # Generators internals 1450 ok {test-number} - gen.get() == 1 for: 1 == 1 1451 # Generators internals 1452 ok {test-number} - gen.next() for: true 1453 # Generators internals 1454 ok {test-number} - gen.get() == 2 for: 2 == 2 1455 # Generators internals 1456 ok {test-number} - !(gen.next()) for: !false 1457 # Generators internals 1458 ok {test-number} - gen.get() == 1 for: 1 == 1 1459 # Generators internals 1460 ok {test-number} - !(gen.next()) for: !false 1461 # Generators internals 1462 ok {test-number} - gen.get() == 2.0 for: 2.0 == 2.0 1463 # Generators internals 1464 ok {test-number} - gen.next() for: true 1465 # Generators internals 1466 ok {test-number} - gen.get() == 4.0 for: 4.0 == 4.0 1467 # Generators internals 1468 ok {test-number} - gen.next() for: true 1469 # Generators internals 1470 ok {test-number} - gen.get() == 6.0 for: 6.0 == 6.0 1471 # Generators internals 1472 ok {test-number} - !(gen.next()) for: !false 1473 # Generators internals 1474 ok {test-number} - gen.get() == 2.0 for: 2.0 == 2.0 1475 # Generators internals 1476 ok {test-number} - gen.next() for: true 1477 # Generators internals 1478 ok {test-number} - gen.get() == 4.0 for: 4.0 == 4.0 1479 # Generators internals 1480 ok {test-number} - gen.next() for: true 1481 # Generators internals 1482 ok {test-number} - gen.get() == 6.0 for: 6.0 == 6.0 1483 # Generators internals 1484 ok {test-number} - !(gen.next()) for: !false 1485 # Generators internals 1486 ok {test-number} - gen.get() == 3 for: 3 == 3 1487 # Generators internals 1488 ok {test-number} - !(gen.next()) for: !false 1489 # Generators internals 1490 ok {test-number} - gen.get() == 1 for: 1 == 1 1491 # Generators internals 1492 ok {test-number} - gen.next() for: true 1493 # Generators internals 1494 ok {test-number} - gen.get() == 2 for: 2 == 2 1495 # Generators internals 1496 ok {test-number} - gen.next() for: true 1497 # Generators internals 1498 ok {test-number} - gen.get() == 3 for: 3 == 3 1499 # Generators internals 1500 ok {test-number} - gen.next() for: true 1501 # Generators internals 1502 ok {test-number} - gen.get() == 1 for: 1 == 1 1503 # Generators internals 1504 ok {test-number} - gen.next() for: true 1505 # Generators internals 1506 ok {test-number} - gen.get() == 2 for: 2 == 2 1507 # Generators internals 1508 ok {test-number} - gen.next() for: true 1509 # Generators internals 1510 ok {test-number} - gen.get() == 3 for: 3 == 3 1511 # Generators internals 1512 ok {test-number} - !(gen.next()) for: !false 1513 # Generators internals 1514 ok {test-number} - gen.get() == -2 for: -2 == -2 1515 # Generators internals 1516 ok {test-number} - gen.next() for: true 1517 # Generators internals 1518 ok {test-number} - gen.get() == -1 for: -1 == -1 1519 # Generators internals 1520 ok {test-number} - gen.next() for: true 1521 # Generators internals 1522 ok {test-number} - gen.get() == 0 for: 0 == 0 1523 # Generators internals 1524 ok {test-number} - gen.next() for: true 1525 # Generators internals 1526 ok {test-number} - gen.get() == 1 for: 1 == 1 1527 # Generators internals 1528 ok {test-number} - !(gen.next()) for: !false 1529 # Generators internals 1530 ok {test-number} - gen.get() == 2 for: 2 == 2 1531 # Generators internals 1532 ok {test-number} - gen.next() for: true 1533 # Generators internals 1534 ok {test-number} - gen.get() == 1 for: 1 == 1 1535 # Generators internals 1536 ok {test-number} - gen.next() for: true 1537 # Generators internals 1538 ok {test-number} - gen.get() == 0 for: 0 == 0 1539 # Generators internals 1540 ok {test-number} - gen.next() for: true 1541 # Generators internals 1542 ok {test-number} - gen.get() == -1 for: -1 == -1 1543 # Generators internals 1544 ok {test-number} - !(gen.next()) for: !false 1545 # Generators internals 1546 ok {test-number} - gen.get() == -7 for: -7 == -7 1547 # Generators internals 1548 ok {test-number} - gen.next() for: true 1549 # Generators internals 1550 ok {test-number} - gen.get() == -4 for: -4 == -4 1551 # Generators internals 1552 ok {test-number} - gen.next() for: true 1553 # Generators internals 1554 ok {test-number} - gen.get() == -1 for: -1 == -1 1555 # Generators internals 1556 ok {test-number} - gen.next() for: true 1557 # Generators internals 1558 ok {test-number} - gen.get() == 2 for: 2 == 2 1559 # Generators internals 1560 ok {test-number} - !(gen.next()) for: !false 1561 # Generators internals 1562 ok {test-number} - gen.get() == -7 for: -7 == -7 1563 # Generators internals 1564 ok {test-number} - gen.next() for: true 1565 # Generators internals 1566 ok {test-number} - gen.get() == -4 for: -4 == -4 1567 # Generators internals 1568 ok {test-number} - gen.next() for: true 1569 # Generators internals 1570 ok {test-number} - gen.get() == -1 for: -1 == -1 1571 # Generators internals 1572 ok {test-number} - gen.next() for: true 1573 # Generators internals 1574 ok {test-number} - gen.get() == 2 for: 2 == 2 1575 # Generators internals 1576 ok {test-number} - !(gen.next()) for: !false 1577 # Generators internals 1578 ok {test-number} - gen.get() == -7 for: -7 == -7 1579 # Generators internals 1580 ok {test-number} - gen.next() for: true 1581 # Generators internals 1582 ok {test-number} - gen.get() == -4 for: -4 == -4 1583 # Generators internals 1584 ok {test-number} - gen.next() for: true 1585 # Generators internals 1586 ok {test-number} - gen.get() == -1 for: -1 == -1 1587 # Generators internals 1588 ok {test-number} - gen.next() for: true 1589 # Generators internals 1590 ok {test-number} - gen.get() == 2 for: 2 == 2 1591 # Generators internals 1592 ok {test-number} - gen.next() for: true 1593 # Generators internals 1594 ok {test-number} - gen.get() == 5 for: 5 == 5 1595 # Generators internals 1596 ok {test-number} - !(gen.next()) for: !false 1597 # Generators internals 1598 ok {test-number} - gen.get() == Approx(expected) for: -1.0 == Approx( -1.0 ) with 1 message: 'Current expected value is -1' 1599 # Generators internals 1600 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is -1' 1601 # Generators internals 1602 ok {test-number} - gen.get() == Approx(expected) for: -0.9 == Approx( -0.9 ) with 1 message: 'Current expected value is -0.9' 1603 # Generators internals 1604 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is -0.9' 1605 # Generators internals 1606 ok {test-number} - gen.get() == Approx(expected) for: -0.8 == Approx( -0.8 ) with 1 message: 'Current expected value is -0.8' 1607 # Generators internals 1608 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is -0.8' 1609 # Generators internals 1610 ok {test-number} - gen.get() == Approx(expected) for: -0.7 == Approx( -0.7 ) with 1 message: 'Current expected value is -0.7' 1611 # Generators internals 1612 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is -0.7' 1613 # Generators internals 1614 ok {test-number} - gen.get() == Approx(expected) for: -0.6 == Approx( -0.6 ) with 1 message: 'Current expected value is -0.6' 1615 # Generators internals 1616 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is -0.6' 1617 # Generators internals 1618 ok {test-number} - gen.get() == Approx(expected) for: -0.5 == Approx( -0.5 ) with 1 message: 'Current expected value is -0.5' 1619 # Generators internals 1620 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is -0.5' 1621 # Generators internals 1622 ok {test-number} - gen.get() == Approx(expected) for: -0.4 == Approx( -0.4 ) with 1 message: 'Current expected value is -0.4' 1623 # Generators internals 1624 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is -0.4' 1625 # Generators internals 1626 ok {test-number} - gen.get() == Approx(expected) for: -0.3 == Approx( -0.3 ) with 1 message: 'Current expected value is -0.3' 1627 # Generators internals 1628 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is -0.3' 1629 # Generators internals 1630 ok {test-number} - gen.get() == Approx(expected) for: -0.2 == Approx( -0.2 ) with 1 message: 'Current expected value is -0.2' 1631 # Generators internals 1632 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is -0.2' 1633 # Generators internals 1634 ok {test-number} - gen.get() == Approx(expected) for: -0.1 == Approx( -0.1 ) with 1 message: 'Current expected value is -0.1' 1635 # Generators internals 1636 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is -0.1' 1637 # Generators internals 1638 ok {test-number} - gen.get() == Approx(expected) for: -0.0 == Approx( -0.0 ) with 1 message: 'Current expected value is -1.38778e-16' 1639 # Generators internals 1640 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is -1.38778e-16' 1641 # Generators internals 1642 ok {test-number} - gen.get() == Approx(expected) for: 0.1 == Approx( 0.1 ) with 1 message: 'Current expected value is 0.1' 1643 # Generators internals 1644 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is 0.1' 1645 # Generators internals 1646 ok {test-number} - gen.get() == Approx(expected) for: 0.2 == Approx( 0.2 ) with 1 message: 'Current expected value is 0.2' 1647 # Generators internals 1648 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is 0.2' 1649 # Generators internals 1650 ok {test-number} - gen.get() == Approx(expected) for: 0.3 == Approx( 0.3 ) with 1 message: 'Current expected value is 0.3' 1651 # Generators internals 1652 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is 0.3' 1653 # Generators internals 1654 ok {test-number} - gen.get() == Approx(expected) for: 0.4 == Approx( 0.4 ) with 1 message: 'Current expected value is 0.4' 1655 # Generators internals 1656 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is 0.4' 1657 # Generators internals 1658 ok {test-number} - gen.get() == Approx(expected) for: 0.5 == Approx( 0.5 ) with 1 message: 'Current expected value is 0.5' 1659 # Generators internals 1660 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is 0.5' 1661 # Generators internals 1662 ok {test-number} - gen.get() == Approx(expected) for: 0.6 == Approx( 0.6 ) with 1 message: 'Current expected value is 0.6' 1663 # Generators internals 1664 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is 0.6' 1665 # Generators internals 1666 ok {test-number} - gen.get() == Approx(expected) for: 0.7 == Approx( 0.7 ) with 1 message: 'Current expected value is 0.7' 1667 # Generators internals 1668 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is 0.7' 1669 # Generators internals 1670 ok {test-number} - gen.get() == Approx(expected) for: 0.8 == Approx( 0.8 ) with 1 message: 'Current expected value is 0.8' 1671 # Generators internals 1672 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is 0.8' 1673 # Generators internals 1674 ok {test-number} - gen.get() == Approx(expected) for: 0.9 == Approx( 0.9 ) with 1 message: 'Current expected value is 0.9' 1675 # Generators internals 1676 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is 0.9' 1677 # Generators internals 1678 ok {test-number} - gen.get() == Approx( rangeEnd ) for: 1.0 == Approx( 1.0 ) 1679 # Generators internals 1680 ok {test-number} - !(gen.next()) for: !false 1681 # Generators internals 1682 ok {test-number} - gen.get() == Approx(expected) for: -1.0 == Approx( -1.0 ) with 1 message: 'Current expected value is -1' 1683 # Generators internals 1684 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is -1' 1685 # Generators internals 1686 ok {test-number} - gen.get() == Approx(expected) for: -0.7 == Approx( -0.7 ) with 1 message: 'Current expected value is -0.7' 1687 # Generators internals 1688 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is -0.7' 1689 # Generators internals 1690 ok {test-number} - gen.get() == Approx(expected) for: -0.4 == Approx( -0.4 ) with 1 message: 'Current expected value is -0.4' 1691 # Generators internals 1692 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is -0.4' 1693 # Generators internals 1694 ok {test-number} - gen.get() == Approx(expected) for: -0.1 == Approx( -0.1 ) with 1 message: 'Current expected value is -0.1' 1695 # Generators internals 1696 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is -0.1' 1697 # Generators internals 1698 ok {test-number} - gen.get() == Approx(expected) for: 0.2 == Approx( 0.2 ) with 1 message: 'Current expected value is 0.2' 1699 # Generators internals 1700 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is 0.2' 1701 # Generators internals 1702 ok {test-number} - gen.get() == Approx(expected) for: 0.5 == Approx( 0.5 ) with 1 message: 'Current expected value is 0.5' 1703 # Generators internals 1704 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is 0.5' 1705 # Generators internals 1706 ok {test-number} - !(gen.next()) for: !false 1707 # Generators internals 1708 ok {test-number} - gen.get() == Approx(expected) for: -1.0 == Approx( -1.0 ) with 1 message: 'Current expected value is -1' 1709 # Generators internals 1710 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is -1' 1711 # Generators internals 1712 ok {test-number} - gen.get() == Approx(expected) for: -0.7 == Approx( -0.7 ) with 1 message: 'Current expected value is -0.7' 1713 # Generators internals 1714 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is -0.7' 1715 # Generators internals 1716 ok {test-number} - gen.get() == Approx(expected) for: -0.4 == Approx( -0.4 ) with 1 message: 'Current expected value is -0.4' 1717 # Generators internals 1718 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is -0.4' 1719 # Generators internals 1720 ok {test-number} - gen.get() == Approx(expected) for: -0.1 == Approx( -0.1 ) with 1 message: 'Current expected value is -0.1' 1721 # Generators internals 1722 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is -0.1' 1723 # Generators internals 1724 ok {test-number} - gen.get() == Approx(expected) for: 0.2 == Approx( 0.2 ) with 1 message: 'Current expected value is 0.2' 1725 # Generators internals 1726 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is 0.2' 1727 # Generators internals 1728 ok {test-number} - gen.get() == Approx(expected) for: 0.5 == Approx( 0.5 ) with 1 message: 'Current expected value is 0.5' 1729 # Generators internals 1730 ok {test-number} - gen.next() for: true with 1 message: 'Current expected value is 0.5' 1731 # Generators internals 1732 ok {test-number} - !(gen.next()) for: !false 1733 # Generators internals 1734 ok {test-number} - gen.get() == 5 for: 5 == 5 1735 # Generators internals 1736 ok {test-number} - gen.next() for: true 1737 # Generators internals 1738 ok {test-number} - gen.get() == 2 for: 2 == 2 1739 # Generators internals 1740 ok {test-number} - gen.next() for: true 1741 # Generators internals 1742 ok {test-number} - gen.get() == -1 for: -1 == -1 1743 # Generators internals 1744 ok {test-number} - gen.next() for: true 1745 # Generators internals 1746 ok {test-number} - gen.get() == -4 for: -4 == -4 1747 # Generators internals 1748 ok {test-number} - !(gen.next()) for: !false 1749 # Generators internals 1750 ok {test-number} - gen.get() == 5 for: 5 == 5 1751 # Generators internals 1752 ok {test-number} - gen.next() for: true 1753 # Generators internals 1754 ok {test-number} - gen.get() == 2 for: 2 == 2 1755 # Generators internals 1756 ok {test-number} - gen.next() for: true 1757 # Generators internals 1758 ok {test-number} - gen.get() == -1 for: -1 == -1 1759 # Generators internals 1760 ok {test-number} - gen.next() for: true 1761 # Generators internals 1762 ok {test-number} - gen.get() == -4 for: -4 == -4 1763 # Generators internals 1764 ok {test-number} - !(gen.next()) for: !false 1765 # Generators internals 1766 ok {test-number} - gen.get() == 5 for: 5 == 5 1767 # Generators internals 1768 ok {test-number} - gen.next() for: true 1769 # Generators internals 1770 ok {test-number} - gen.get() == 2 for: 2 == 2 1771 # Generators internals 1772 ok {test-number} - gen.next() for: true 1773 # Generators internals 1774 ok {test-number} - gen.get() == -1 for: -1 == -1 1775 # Generators internals 1776 ok {test-number} - gen.next() for: true 1777 # Generators internals 1778 ok {test-number} - gen.get() == -4 for: -4 == -4 1779 # Generators internals 1780 ok {test-number} - gen.next() for: true 1781 # Generators internals 1782 ok {test-number} - gen.get() == -7 for: -7 == -7 1783 # Generators internals 1784 ok {test-number} - !(gen.next()) for: !false 1785 # Greater-than inequalities with different epsilons 1786 ok {test-number} - d >= Approx( 1.22 ) for: 1.23 >= Approx( 1.22 ) 1787 # Greater-than inequalities with different epsilons 1788 ok {test-number} - d >= Approx( 1.23 ) for: 1.23 >= Approx( 1.23 ) 1789 # Greater-than inequalities with different epsilons 1790 ok {test-number} - !(d >= Approx( 1.24 )) for: !(1.23 >= Approx( 1.24 )) 1791 # Greater-than inequalities with different epsilons 1792 ok {test-number} - d >= Approx( 1.24 ).epsilon(0.1) for: 1.23 >= Approx( 1.24 ) 1793 # Hashers with different seed produce different hash with same test case 1794 ok {test-number} - h1( dummy ) != h2( dummy ) for: 3422778688 (0x<hex digits>) != 130711275 (0x<hex digits>) 1795 # Hashers with same seed produce same hash 1796 ok {test-number} - h1( dummy ) == h2( dummy ) for: 3422778688 (0x<hex digits>) == 3422778688 (0x<hex digits>) 1797 # Hashing different test cases produces different result 1798 ok {test-number} - h( dummy1 ) != h( dummy2 ) for: 2903002874 (0x<hex digits>) != 2668622104 (0x<hex digits>) 1799 # Hashing different test cases produces different result 1800 ok {test-number} - h( dummy1 ) != h( dummy2 ) for: 2673152918 (0x<hex digits>) != 3916075712 (0x<hex digits>) 1801 # Hashing different test cases produces different result 1802 ok {test-number} - h( dummy1 ) != h( dummy2 ) for: 2074929312 (0x<hex digits>) != 3429949824 (0x<hex digits>) 1803 # Hashing test case produces same hash across multiple calls 1804 ok {test-number} - h( dummy ) == h( dummy ) for: 3422778688 (0x<hex digits>) == 3422778688 (0x<hex digits>) 1805 # INFO and UNSCOPED_INFO can stream multiple arguments 1806 not ok {test-number} - explicitly with 3 messages: 'This info has multiple parts.' and 'This unscoped info has multiple parts.' and 'Show infos!' 1807 # INFO and WARN do not abort tests 1808 warning {test-number} - 'this is a message' with 1 message: 'this is a warning' 1809 # INFO gets logged on failure 1810 not ok {test-number} - a == 1 for: 2 == 1 with 2 messages: 'this message should be logged' and 'so should this' 1811 # INFO gets logged on failure, even if captured before successful assertions 1812 ok {test-number} - a == 2 for: 2 == 2 with 1 message: 'this message may be logged later' 1813 # INFO gets logged on failure, even if captured before successful assertions 1814 not ok {test-number} - a == 1 for: 2 == 1 with 2 messages: 'this message may be logged later' and 'this message should be logged' 1815 # INFO gets logged on failure, even if captured before successful assertions 1816 not ok {test-number} - a == 0 for: 2 == 0 with 3 messages: 'this message may be logged later' and 'this message should be logged' and 'and this, but later' 1817 # INFO gets logged on failure, even if captured before successful assertions 1818 ok {test-number} - a == 2 for: 2 == 2 with 4 messages: 'this message may be logged later' and 'this message should be logged' and 'and this, but later' and 'but not this' 1819 # INFO is reset for each loop 1820 ok {test-number} - i < 10 for: 0 < 10 with 2 messages: 'current counter 0' and 'i := 0' 1821 # INFO is reset for each loop 1822 ok {test-number} - i < 10 for: 1 < 10 with 2 messages: 'current counter 1' and 'i := 1' 1823 # INFO is reset for each loop 1824 ok {test-number} - i < 10 for: 2 < 10 with 2 messages: 'current counter 2' and 'i := 2' 1825 # INFO is reset for each loop 1826 ok {test-number} - i < 10 for: 3 < 10 with 2 messages: 'current counter 3' and 'i := 3' 1827 # INFO is reset for each loop 1828 ok {test-number} - i < 10 for: 4 < 10 with 2 messages: 'current counter 4' and 'i := 4' 1829 # INFO is reset for each loop 1830 ok {test-number} - i < 10 for: 5 < 10 with 2 messages: 'current counter 5' and 'i := 5' 1831 # INFO is reset for each loop 1832 ok {test-number} - i < 10 for: 6 < 10 with 2 messages: 'current counter 6' and 'i := 6' 1833 # INFO is reset for each loop 1834 ok {test-number} - i < 10 for: 7 < 10 with 2 messages: 'current counter 7' and 'i := 7' 1835 # INFO is reset for each loop 1836 ok {test-number} - i < 10 for: 8 < 10 with 2 messages: 'current counter 8' and 'i := 8' 1837 # INFO is reset for each loop 1838 ok {test-number} - i < 10 for: 9 < 10 with 2 messages: 'current counter 9' and 'i := 9' 1839 # INFO is reset for each loop 1840 not ok {test-number} - i < 10 for: 10 < 10 with 2 messages: 'current counter 10' and 'i := 10' 1841 # Incomplete AssertionHandler 1842 not ok {test-number} - unexpected exception with message: 'Exception translation was disabled by CATCH_CONFIG_FAST_COMPILE'; expression was: Dummy 1843 # Inequality checks that should fail 1844 not ok {test-number} - data.int_seven != 7 for: 7 != 7 1845 # Inequality checks that should fail 1846 not ok {test-number} - data.float_nine_point_one != Approx( 9.1f ) for: 9.1f != Approx( 9.1000003815 ) 1847 # Inequality checks that should fail 1848 not ok {test-number} - data.double_pi != Approx( 3.1415926535 ) for: 3.1415926535 != Approx( 3.1415926535 ) 1849 # Inequality checks that should fail 1850 not ok {test-number} - data.str_hello != "hello" for: "hello" != "hello" 1851 # Inequality checks that should fail 1852 not ok {test-number} - data.str_hello.size() != 5 for: 5 != 5 1853 # Inequality checks that should succeed 1854 ok {test-number} - data.int_seven != 6 for: 7 != 6 1855 # Inequality checks that should succeed 1856 ok {test-number} - data.int_seven != 8 for: 7 != 8 1857 # Inequality checks that should succeed 1858 ok {test-number} - data.float_nine_point_one != Approx( 9.11f ) for: 9.1f != Approx( 9.1099996567 ) 1859 # Inequality checks that should succeed 1860 ok {test-number} - data.float_nine_point_one != Approx( 9.0f ) for: 9.1f != Approx( 9.0 ) 1861 # Inequality checks that should succeed 1862 ok {test-number} - data.float_nine_point_one != Approx( 1 ) for: 9.1f != Approx( 1.0 ) 1863 # Inequality checks that should succeed 1864 ok {test-number} - data.float_nine_point_one != Approx( 0 ) for: 9.1f != Approx( 0.0 ) 1865 # Inequality checks that should succeed 1866 ok {test-number} - data.double_pi != Approx( 3.1415 ) for: 3.1415926535 != Approx( 3.1415 ) 1867 # Inequality checks that should succeed 1868 ok {test-number} - data.str_hello != "goodbye" for: "hello" != "goodbye" 1869 # Inequality checks that should succeed 1870 ok {test-number} - data.str_hello != "hell" for: "hello" != "hell" 1871 # Inequality checks that should succeed 1872 ok {test-number} - data.str_hello != "hello1" for: "hello" != "hello1" 1873 # Inequality checks that should succeed 1874 ok {test-number} - data.str_hello.size() != 6 for: 5 != 6 1875 # JsonWriter 1876 ok {test-number} - stream.str() == "" for: "" == "" 1877 # JsonWriter 1878 ok {test-number} - stream.str() == "{\n}" for: "{ }" == "{ }" 1879 # JsonWriter 1880 ok {test-number} - stream.str(), ContainsSubstring( "\"int\": 1," ) && ContainsSubstring( "\"double\": 1.5," ) && ContainsSubstring( "\"true\": true," ) && ContainsSubstring( "\"false\": false," ) && ContainsSubstring( "\"string\": \"this is a string\"," ) && ContainsSubstring( "\"array\": [\n 1,\n 2\n ]\n}" ) for: "{ "int": 1, "double": 1.5, "true": true, "false": false, "string": "this is a string", "array": [ 1, 2 ] }" ( contains: ""int": 1," and contains: ""double": 1.5," and contains: ""true": true," and contains: ""false": false," and contains: ""string": "this is a string"," and contains: ""array": [ 1, 2 ] }" ) 1881 # JsonWriter 1882 ok {test-number} - stream.str(), ContainsSubstring( "\"empty_object\": {\n }," ) && ContainsSubstring( "\"fully_object\": {\n \"key\": 1\n }" ) for: "{ "empty_object": { }, "fully_object": { "key": 1 } }" ( contains: ""empty_object": { }," and contains: ""fully_object": { "key": 1 }" ) 1883 # JsonWriter 1884 ok {test-number} - stream.str() == "[\n]" for: "[ ]" == "[ ]" 1885 # JsonWriter 1886 ok {test-number} - stream.str() == "[\n 1,\n 1.5,\n true,\n false,\n \"this is a string\",\n {\n \"object\": 42\n },\n [\n \"array\",\n 42.5\n ]\n]" for: "[ 1, 1.5, true, false, "this is a string", { "object": 42 }, [ "array", 42.5 ] ]" == "[ 1, 1.5, true, false, "this is a string", { "object": 42 }, [ "array", 42.5 ] ]" 1887 # JsonWriter 1888 ok {test-number} - stream.str() == "{\n}" for: "{ }" == "{ }" 1889 # JsonWriter 1890 ok {test-number} - stream.str() == "[\n]" for: "[ ]" == "[ ]" 1891 # JsonWriter 1892 ok {test-number} - stream.str() == "\"custom\"" for: ""custom"" == ""custom"" 1893 # JsonWriter escapes charaters in strings properly 1894 ok {test-number} - sstream.str() == "\"\\\"\"" for: ""\""" == ""\""" 1895 # JsonWriter escapes charaters in strings properly 1896 ok {test-number} - sstream.str() == "\"\\\\\"" for: ""\\"" == ""\\"" 1897 # JsonWriter escapes charaters in strings properly 1898 ok {test-number} - sstream.str() == "\"/\"" for: ""/"" == ""/"" 1899 # JsonWriter escapes charaters in strings properly 1900 ok {test-number} - sstream.str() == "\"\\b\"" for: ""\b"" == ""\b"" 1901 # JsonWriter escapes charaters in strings properly 1902 ok {test-number} - sstream.str() == "\"\\f\"" for: ""\f"" == ""\f"" 1903 # JsonWriter escapes charaters in strings properly 1904 ok {test-number} - sstream.str() == "\"\\n\"" for: ""\n"" == ""\n"" 1905 # JsonWriter escapes charaters in strings properly 1906 ok {test-number} - sstream.str() == "\"\\r\"" for: ""\r"" == ""\r"" 1907 # JsonWriter escapes charaters in strings properly 1908 ok {test-number} - sstream.str() == "\"\\t\"" for: ""\t"" == ""\t"" 1909 # JsonWriter escapes charaters in strings properly 1910 ok {test-number} - sstream.str() == "\"\\\\/\\t\\r\\n\"" for: ""\\/\t\r\n"" == ""\\/\t\r\n"" 1911 # Lambdas in assertions 1912 ok {test-number} - []() { return true; }() for: true 1913 # Less-than inequalities with different epsilons 1914 ok {test-number} - d <= Approx( 1.24 ) for: 1.23 <= Approx( 1.24 ) 1915 # Less-than inequalities with different epsilons 1916 ok {test-number} - d <= Approx( 1.23 ) for: 1.23 <= Approx( 1.23 ) 1917 # Less-than inequalities with different epsilons 1918 ok {test-number} - !(d <= Approx( 1.22 )) for: !(1.23 <= Approx( 1.22 )) 1919 # Less-than inequalities with different epsilons 1920 ok {test-number} - d <= Approx( 1.22 ).epsilon(0.1) for: 1.23 <= Approx( 1.22 ) 1921 # ManuallyRegistered 1922 ok {test-number} - with 1 message: 'was called' 1923 # Matchers can be (AllOf) composed with the && operator 1924 ok {test-number} - testStringForMatching(), ContainsSubstring( "string" ) && ContainsSubstring( "abc" ) && ContainsSubstring( "substring" ) && ContainsSubstring( "contains" ) for: "this string contains 'abc' as a substring" ( contains: "string" and contains: "abc" and contains: "substring" and contains: "contains" ) 1925 # Matchers can be (AnyOf) composed with the || operator 1926 ok {test-number} - testStringForMatching(), ContainsSubstring( "string" ) || ContainsSubstring( "different" ) || ContainsSubstring( "random" ) for: "this string contains 'abc' as a substring" ( contains: "string" or contains: "different" or contains: "random" ) 1927 # Matchers can be (AnyOf) composed with the || operator 1928 ok {test-number} - testStringForMatching2(), ContainsSubstring( "string" ) || ContainsSubstring( "different" ) || ContainsSubstring( "random" ) for: "some completely different text that contains one common word" ( contains: "string" or contains: "different" or contains: "random" ) 1929 # Matchers can be composed with both && and || 1930 ok {test-number} - testStringForMatching(), ( ContainsSubstring( "string" ) || ContainsSubstring( "different" ) ) && ContainsSubstring( "substring" ) for: "this string contains 'abc' as a substring" ( ( contains: "string" or contains: "different" ) and contains: "substring" ) 1931 # Matchers can be composed with both && and || - failing 1932 not ok {test-number} - testStringForMatching(), ( ContainsSubstring( "string" ) || ContainsSubstring( "different" ) ) && ContainsSubstring( "random" ) for: "this string contains 'abc' as a substring" ( ( contains: "string" or contains: "different" ) and contains: "random" ) 1933 # Matchers can be negated (Not) with the ! operator 1934 ok {test-number} - testStringForMatching(), !ContainsSubstring( "different" ) for: "this string contains 'abc' as a substring" not contains: "different" 1935 # Matchers can be negated (Not) with the ! operator - failing 1936 not ok {test-number} - testStringForMatching(), !ContainsSubstring( "substring" ) for: "this string contains 'abc' as a substring" not contains: "substring" 1937 # Mayfail test case with nested sections 1938 not ok {test-number} - explicitly 1939 # Mayfail test case with nested sections 1940 not ok {test-number} - explicitly 1941 # Mayfail test case with nested sections 1942 not ok {test-number} - explicitly 1943 # Mayfail test case with nested sections 1944 not ok {test-number} - explicitly 1945 # Mismatching exception messages failing the test 1946 ok {test-number} - thisThrows(), "expected exception" for: "expected exception" equals: "expected exception" 1947 # Mismatching exception messages failing the test 1948 not ok {test-number} - thisThrows(), "should fail" for: "expected exception" equals: "should fail" 1949 # Multireporter calls reporters and listeners in correct order 1950 ok {test-number} - records == expected for: { "Hello", "world", "Goodbye", "world" } == { "Hello", "world", "Goodbye", "world" } 1951 # Multireporter updates ReporterPreferences properly 1952 ok {test-number} - multiReporter.getPreferences().shouldRedirectStdOut == false for: false == false 1953 # Multireporter updates ReporterPreferences properly 1954 ok {test-number} - multiReporter.getPreferences().shouldReportAllAssertions == false for: false == false 1955 # Multireporter updates ReporterPreferences properly 1956 ok {test-number} - multiReporter.getPreferences().shouldRedirectStdOut == true for: true == true 1957 # Multireporter updates ReporterPreferences properly 1958 ok {test-number} - multiReporter.getPreferences().shouldReportAllAssertions == false for: false == false 1959 # Multireporter updates ReporterPreferences properly 1960 ok {test-number} - multiReporter.getPreferences().shouldRedirectStdOut == true for: true == true 1961 # Multireporter updates ReporterPreferences properly 1962 ok {test-number} - multiReporter.getPreferences().shouldReportAllAssertions == true for: true == true 1963 # Multireporter updates ReporterPreferences properly 1964 ok {test-number} - multiReporter.getPreferences().shouldRedirectStdOut == true for: true == true 1965 # Multireporter updates ReporterPreferences properly 1966 ok {test-number} - multiReporter.getPreferences().shouldReportAllAssertions == true for: true == true 1967 # Multireporter updates ReporterPreferences properly 1968 ok {test-number} - multiReporter.getPreferences().shouldRedirectStdOut == false for: false == false 1969 # Multireporter updates ReporterPreferences properly 1970 ok {test-number} - multiReporter.getPreferences().shouldReportAllAssertions == false for: false == false 1971 # Multireporter updates ReporterPreferences properly 1972 ok {test-number} - multiReporter.getPreferences().shouldRedirectStdOut == true for: true == true 1973 # Multireporter updates ReporterPreferences properly 1974 ok {test-number} - multiReporter.getPreferences().shouldReportAllAssertions == false for: false == false 1975 # Multireporter updates ReporterPreferences properly 1976 ok {test-number} - multiReporter.getPreferences().shouldRedirectStdOut == true for: true == true 1977 # Multireporter updates ReporterPreferences properly 1978 ok {test-number} - multiReporter.getPreferences().shouldReportAllAssertions == true for: true == true 1979 # Multireporter updates ReporterPreferences properly 1980 ok {test-number} - multiReporter.getPreferences().shouldRedirectStdOut == true for: true == true 1981 # Multireporter updates ReporterPreferences properly 1982 ok {test-number} - multiReporter.getPreferences().shouldReportAllAssertions == true for: true == true 1983 # Nested generators and captured variables 1984 ok {test-number} - values > -6 for: 3 > -6 1985 # Nested generators and captured variables 1986 ok {test-number} - values > -6 for: 4 > -6 1987 # Nested generators and captured variables 1988 ok {test-number} - values > -6 for: 5 > -6 1989 # Nested generators and captured variables 1990 ok {test-number} - values > -6 for: 6 > -6 1991 # Nested generators and captured variables 1992 ok {test-number} - values > -6 for: -5 > -6 1993 # Nested generators and captured variables 1994 ok {test-number} - values > -6 for: -4 > -6 1995 # Nested generators and captured variables 1996 ok {test-number} - values > -6 for: 90 > -6 1997 # Nested generators and captured variables 1998 ok {test-number} - values > -6 for: 91 > -6 1999 # Nested generators and captured variables 2000 ok {test-number} - values > -6 for: 92 > -6 2001 # Nested generators and captured variables 2002 ok {test-number} - values > -6 for: 93 > -6 2003 # Nested generators and captured variables 2004 ok {test-number} - values > -6 for: 94 > -6 2005 # Nested generators and captured variables 2006 ok {test-number} - values > -6 for: 95 > -6 2007 # Nested generators and captured variables 2008 ok {test-number} - values > -6 for: 96 > -6 2009 # Nested generators and captured variables 2010 ok {test-number} - values > -6 for: 97 > -6 2011 # Nested generators and captured variables 2012 ok {test-number} - values > -6 for: 98 > -6 2013 # Nested generators and captured variables 2014 ok {test-number} - values > -6 for: 99 > -6 2015 # Nice descriptive name 2016 warning {test-number} - 'This one ran' 2017 # Non-std exceptions can be translated 2018 not ok {test-number} - unexpected exception with message: 'custom exception' 2019 # Objects that evaluated in boolean contexts can be checked 2020 ok {test-number} - True for: {?} 2021 # Objects that evaluated in boolean contexts can be checked 2022 ok {test-number} - !False for: true 2023 # Objects that evaluated in boolean contexts can be checked 2024 ok {test-number} - !(False) for: !{?} 2025 # Optionally static assertions 2026 ok {test-number} - with 1 message: 'std::is_void<void>::value' 2027 # Optionally static assertions 2028 ok {test-number} - with 1 message: '!(std::is_void<int>::value)' 2029 # Optionally static assertions 2030 ok {test-number} - with 1 message: 'std::is_void<void>::value' 2031 # Optionally static assertions 2032 ok {test-number} - with 1 message: '!(std::is_void<int>::value)' 2033 # Ordering comparison checks that should fail 2034 not ok {test-number} - data.int_seven > 7 for: 7 > 7 2035 # Ordering comparison checks that should fail 2036 not ok {test-number} - data.int_seven < 7 for: 7 < 7 2037 # Ordering comparison checks that should fail 2038 not ok {test-number} - data.int_seven > 8 for: 7 > 8 2039 # Ordering comparison checks that should fail 2040 not ok {test-number} - data.int_seven < 6 for: 7 < 6 2041 # Ordering comparison checks that should fail 2042 not ok {test-number} - data.int_seven < 0 for: 7 < 0 2043 # Ordering comparison checks that should fail 2044 not ok {test-number} - data.int_seven < -1 for: 7 < -1 2045 # Ordering comparison checks that should fail 2046 not ok {test-number} - data.int_seven >= 8 for: 7 >= 8 2047 # Ordering comparison checks that should fail 2048 not ok {test-number} - data.int_seven <= 6 for: 7 <= 6 2049 # Ordering comparison checks that should fail 2050 not ok {test-number} - data.float_nine_point_one < 9 for: 9.1f < 9 2051 # Ordering comparison checks that should fail 2052 not ok {test-number} - data.float_nine_point_one > 10 for: 9.1f > 10 2053 # Ordering comparison checks that should fail 2054 not ok {test-number} - data.float_nine_point_one > 9.2 for: 9.1f > 9.2 2055 # Ordering comparison checks that should fail 2056 not ok {test-number} - data.str_hello > "hello" for: "hello" > "hello" 2057 # Ordering comparison checks that should fail 2058 not ok {test-number} - data.str_hello < "hello" for: "hello" < "hello" 2059 # Ordering comparison checks that should fail 2060 not ok {test-number} - data.str_hello > "hellp" for: "hello" > "hellp" 2061 # Ordering comparison checks that should fail 2062 not ok {test-number} - data.str_hello > "z" for: "hello" > "z" 2063 # Ordering comparison checks that should fail 2064 not ok {test-number} - data.str_hello < "hellm" for: "hello" < "hellm" 2065 # Ordering comparison checks that should fail 2066 not ok {test-number} - data.str_hello < "a" for: "hello" < "a" 2067 # Ordering comparison checks that should fail 2068 not ok {test-number} - data.str_hello >= "z" for: "hello" >= "z" 2069 # Ordering comparison checks that should fail 2070 not ok {test-number} - data.str_hello <= "a" for: "hello" <= "a" 2071 # Ordering comparison checks that should succeed 2072 ok {test-number} - data.int_seven < 8 for: 7 < 8 2073 # Ordering comparison checks that should succeed 2074 ok {test-number} - data.int_seven > 6 for: 7 > 6 2075 # Ordering comparison checks that should succeed 2076 ok {test-number} - data.int_seven > 0 for: 7 > 0 2077 # Ordering comparison checks that should succeed 2078 ok {test-number} - data.int_seven > -1 for: 7 > -1 2079 # Ordering comparison checks that should succeed 2080 ok {test-number} - data.int_seven >= 7 for: 7 >= 7 2081 # Ordering comparison checks that should succeed 2082 ok {test-number} - data.int_seven >= 6 for: 7 >= 6 2083 # Ordering comparison checks that should succeed 2084 ok {test-number} - data.int_seven <= 7 for: 7 <= 7 2085 # Ordering comparison checks that should succeed 2086 ok {test-number} - data.int_seven <= 8 for: 7 <= 8 2087 # Ordering comparison checks that should succeed 2088 ok {test-number} - data.float_nine_point_one > 9 for: 9.1f > 9 2089 # Ordering comparison checks that should succeed 2090 ok {test-number} - data.float_nine_point_one < 10 for: 9.1f < 10 2091 # Ordering comparison checks that should succeed 2092 ok {test-number} - data.float_nine_point_one < 9.2 for: 9.1f < 9.2 2093 # Ordering comparison checks that should succeed 2094 ok {test-number} - data.str_hello <= "hello" for: "hello" <= "hello" 2095 # Ordering comparison checks that should succeed 2096 ok {test-number} - data.str_hello >= "hello" for: "hello" >= "hello" 2097 # Ordering comparison checks that should succeed 2098 ok {test-number} - data.str_hello < "hellp" for: "hello" < "hellp" 2099 # Ordering comparison checks that should succeed 2100 ok {test-number} - data.str_hello < "zebra" for: "hello" < "zebra" 2101 # Ordering comparison checks that should succeed 2102 ok {test-number} - data.str_hello > "hellm" for: "hello" > "hellm" 2103 # Ordering comparison checks that should succeed 2104 ok {test-number} - data.str_hello > "a" for: "hello" > "a" 2105 # Our PCG implementation provides expected results for known seeds 2106 ok {test-number} - rng() == 0x<hex digits> for: 4242248763 (0x<hex digits>) == 4242248763 (0x<hex digits>) 2107 # Our PCG implementation provides expected results for known seeds 2108 ok {test-number} - rng() == 0x<hex digits> for: 1867888929 (0x<hex digits>) == 1867888929 (0x<hex digits>) 2109 # Our PCG implementation provides expected results for known seeds 2110 ok {test-number} - rng() == 0x<hex digits> for: 1276619030 (0x<hex digits>) == 1276619030 (0x<hex digits>) 2111 # Our PCG implementation provides expected results for known seeds 2112 ok {test-number} - rng() == 0x<hex digits> for: 1911218783 (0x<hex digits>) == 1911218783 (0x<hex digits>) 2113 # Our PCG implementation provides expected results for known seeds 2114 ok {test-number} - rng() == 0x<hex digits> for: 1827115164 (0x<hex digits>) == 1827115164 (0x<hex digits>) 2115 # Our PCG implementation provides expected results for known seeds 2116 ok {test-number} - rng() == 0x<hex digits> for: 1472234645 (0x<hex digits>) == 1472234645 (0x<hex digits>) 2117 # Our PCG implementation provides expected results for known seeds 2118 ok {test-number} - rng() == 0x<hex digits> for: 868832940 (0x<hex digits>) == 868832940 (0x<hex digits>) 2119 # Our PCG implementation provides expected results for known seeds 2120 ok {test-number} - rng() == 0x<hex digits> for: 570883446 (0x<hex digits>) == 570883446 (0x<hex digits>) 2121 # Our PCG implementation provides expected results for known seeds 2122 ok {test-number} - rng() == 0x<hex digits> for: 889299803 (0x<hex digits>) == 889299803 (0x<hex digits>) 2123 # Our PCG implementation provides expected results for known seeds 2124 ok {test-number} - rng() == 0x<hex digits> for: 4261393167 (0x<hex digits>) == 4261393167 (0x<hex digits>) 2125 # Our PCG implementation provides expected results for known seeds 2126 ok {test-number} - rng() == 0x<hex digits> for: 1472234645 (0x<hex digits>) == 1472234645 (0x<hex digits>) 2127 # Our PCG implementation provides expected results for known seeds 2128 ok {test-number} - rng() == 0x<hex digits> for: 868832940 (0x<hex digits>) == 868832940 (0x<hex digits>) 2129 # Our PCG implementation provides expected results for known seeds 2130 ok {test-number} - rng() == 0x<hex digits> for: 570883446 (0x<hex digits>) == 570883446 (0x<hex digits>) 2131 # Our PCG implementation provides expected results for known seeds 2132 ok {test-number} - rng() == 0x<hex digits> for: 889299803 (0x<hex digits>) == 889299803 (0x<hex digits>) 2133 # Our PCG implementation provides expected results for known seeds 2134 ok {test-number} - rng() == 0x<hex digits> for: 4261393167 (0x<hex digits>) == 4261393167 (0x<hex digits>) 2135 # Output from all sections is reported 2136 not ok {test-number} - explicitly with 1 message: 'Message from section one' 2137 # Output from all sections is reported 2138 not ok {test-number} - explicitly with 1 message: 'Message from section two' 2139 # Overloaded comma or address-of operators are not used 2140 ok {test-number} - ( EvilMatcher(), EvilMatcher() ), EvilCommaOperatorUsed 2141 # Overloaded comma or address-of operators are not used 2142 ok {test-number} - &EvilMatcher(), EvilAddressOfOperatorUsed 2143 # Overloaded comma or address-of operators are not used 2144 ok {test-number} - EvilMatcher() || ( EvilMatcher() && !EvilMatcher() ) 2145 # Overloaded comma or address-of operators are not used 2146 ok {test-number} - ( EvilMatcher() && EvilMatcher() ) || !EvilMatcher() 2147 # Parse uints 2148 ok {test-number} - parseUInt( "0" ) == Optional<unsigned int>{ 0 } for: {?} == {?} 2149 # Parse uints 2150 ok {test-number} - parseUInt( "100" ) == Optional<unsigned int>{ 100 } for: {?} == {?} 2151 # Parse uints 2152 ok {test-number} - parseUInt( "4294967295" ) == Optional<unsigned int>{ 4294967295 } for: {?} == {?} 2153 # Parse uints 2154 ok {test-number} - parseUInt( "0x<hex digits>", 16 ) == Optional<unsigned int>{ 255 } for: {?} == {?} 2155 # Parse uints 2156 ok {test-number} - !(parseUInt( "" )) for: !{?} 2157 # Parse uints 2158 ok {test-number} - !(parseUInt( "!!KJHF*#" )) for: !{?} 2159 # Parse uints 2160 ok {test-number} - !(parseUInt( "-1" )) for: !{?} 2161 # Parse uints 2162 ok {test-number} - !(parseUInt( "4294967296" )) for: !{?} 2163 # Parse uints 2164 ok {test-number} - !(parseUInt( "42949672964294967296429496729642949672964294967296" )) for: !{?} 2165 # Parse uints 2166 ok {test-number} - !(parseUInt( "2 4" )) for: !{?} 2167 # Parse uints 2168 ok {test-number} - !(parseUInt( "0x<hex digits>", 10 )) for: !{?} 2169 # Parsed tags are matched case insensitive 2170 ok {test-number} - spec.hasFilters() for: true 2171 # Parsed tags are matched case insensitive 2172 ok {test-number} - spec.getInvalidSpecs().empty() for: true 2173 # Parsed tags are matched case insensitive 2174 ok {test-number} - spec.matches( testCase ) for: true 2175 # Parsing sharding-related cli flags 2176 ok {test-number} - cli.parse({ "test", "--shard-count=8" }) for: {?} 2177 # Parsing sharding-related cli flags 2178 ok {test-number} - config.shardCount == 8 for: 8 == 8 2179 # Parsing sharding-related cli flags 2180 ok {test-number} - !(result) for: !{?} 2181 # Parsing sharding-related cli flags 2182 ok {test-number} - result.errorMessage(), ContainsSubstring( "Could not parse '-1' as shard count" ) for: "Could not parse '-1' as shard count" contains: "Could not parse '-1' as shard count" 2183 # Parsing sharding-related cli flags 2184 ok {test-number} - !(result) for: !{?} 2185 # Parsing sharding-related cli flags 2186 ok {test-number} - result.errorMessage(), ContainsSubstring( "Shard count must be positive" ) for: "Shard count must be positive" contains: "Shard count must be positive" 2187 # Parsing sharding-related cli flags 2188 ok {test-number} - cli.parse({ "test", "--shard-index=2" }) for: {?} 2189 # Parsing sharding-related cli flags 2190 ok {test-number} - config.shardIndex == 2 for: 2 == 2 2191 # Parsing sharding-related cli flags 2192 ok {test-number} - !(result) for: !{?} 2193 # Parsing sharding-related cli flags 2194 ok {test-number} - result.errorMessage(), ContainsSubstring( "Could not parse '-12' as shard index" ) for: "Could not parse '-12' as shard index" contains: "Could not parse '-12' as shard index" 2195 # Parsing sharding-related cli flags 2196 ok {test-number} - cli.parse({ "test", "--shard-index=0" }) for: {?} 2197 # Parsing sharding-related cli flags 2198 ok {test-number} - config.shardIndex == 0 for: 0 == 0 2199 # Parsing tags with non-alphabetical characters is pass-through 2200 ok {test-number} - spec.hasFilters() for: true with 1 message: 'tagString := "[tag with spaces]"' 2201 # Parsing tags with non-alphabetical characters is pass-through 2202 ok {test-number} - spec.getInvalidSpecs().empty() for: true with 1 message: 'tagString := "[tag with spaces]"' 2203 # Parsing tags with non-alphabetical characters is pass-through 2204 ok {test-number} - spec.matches( testCase ) for: true with 1 message: 'tagString := "[tag with spaces]"' 2205 # Parsing tags with non-alphabetical characters is pass-through 2206 ok {test-number} - spec.hasFilters() for: true with 1 message: 'tagString := "[I said "good day" sir!]"' 2207 # Parsing tags with non-alphabetical characters is pass-through 2208 ok {test-number} - spec.getInvalidSpecs().empty() for: true with 1 message: 'tagString := "[I said "good day" sir!]"' 2209 # Parsing tags with non-alphabetical characters is pass-through 2210 ok {test-number} - spec.matches( testCase ) for: true with 1 message: 'tagString := "[I said "good day" sir!]"' 2211 # Parsing warnings 2212 ok {test-number} - cli.parse( { "test", "-w", "NoAssertions" } ) for: {?} 2213 # Parsing warnings 2214 ok {test-number} - config.warnings == WarnAbout::NoAssertions for: 1 == 1 2215 # Parsing warnings 2216 ok {test-number} - !(cli.parse( { "test", "-w", "NoTests" } )) for: !{?} 2217 # Parsing warnings 2218 ok {test-number} - cli.parse( { "test", "--warn", "NoAssertions", "--warn", "UnmatchedTestSpec" } ) for: {?} 2219 # Parsing warnings 2220 ok {test-number} - config.warnings == ( WarnAbout::NoAssertions | WarnAbout::UnmatchedTestSpec ) for: 3 == 3 2221 # Pointers can be compared to null 2222 ok {test-number} - p == 0 for: 0 == 0 2223 # Pointers can be compared to null 2224 ok {test-number} - p == pNULL for: 0 == 0 2225 # Pointers can be compared to null 2226 ok {test-number} - p != 0 for: 0x<hex digits> != 0 2227 # Pointers can be compared to null 2228 ok {test-number} - cp != 0 for: 0x<hex digits> != 0 2229 # Pointers can be compared to null 2230 ok {test-number} - cpc != 0 for: 0x<hex digits> != 0 2231 # Pointers can be compared to null 2232 ok {test-number} - returnsNull() == 0 for: {null string} == 0 2233 # Pointers can be compared to null 2234 ok {test-number} - returnsConstNull() == 0 for: {null string} == 0 2235 # Pointers can be compared to null 2236 ok {test-number} - 0 != p for: 0 != 0x<hex digits> 2237 # Precision of floating point stringification can be set 2238 ok {test-number} - str1.size() == 3 + 5 for: 8 == 8 2239 # Precision of floating point stringification can be set 2240 ok {test-number} - str2.size() == 3 + 10 for: 13 == 13 2241 # Precision of floating point stringification can be set 2242 ok {test-number} - str1.size() == 2 + 5 for: 7 == 7 2243 # Precision of floating point stringification can be set 2244 ok {test-number} - str2.size() == 2 + 15 for: 17 == 17 2245 # Predicate matcher can accept const char* 2246 ok {test-number} - "foo", Predicate<const char*>( []( const char* const& ) { return true; } ) for: "foo" matches undescribed predicate 2247 # Process can be configured on command line 2248 ok {test-number} - result for: {?} 2249 # Process can be configured on command line 2250 ok {test-number} - config.processName == "" for: "" == "" 2251 # Process can be configured on command line 2252 ok {test-number} - result for: {?} 2253 # Process can be configured on command line 2254 ok {test-number} - config.processName == "test" for: "test" == "test" 2255 # Process can be configured on command line 2256 ok {test-number} - config.shouldDebugBreak == false for: false == false 2257 # Process can be configured on command line 2258 ok {test-number} - config.abortAfter == -1 for: -1 == -1 2259 # Process can be configured on command line 2260 ok {test-number} - config.noThrow == false for: false == false 2261 # Process can be configured on command line 2262 ok {test-number} - config.reporterSpecifications.empty() for: true 2263 # Process can be configured on command line 2264 ok {test-number} - !(cfg.hasTestFilters()) for: !false 2265 # Process can be configured on command line 2266 ok {test-number} - cfg.getReporterSpecs().size() == 1 for: 1 == 1 2267 # Process can be configured on command line 2268 ok {test-number} - cfg.getReporterSpecs()[0] == Catch::ReporterSpec{ expectedReporter, {}, {}, {} } for: {?} == {?} 2269 # Process can be configured on command line 2270 ok {test-number} - cfg.getProcessedReporterSpecs().size() == 1 for: 1 == 1 2271 # Process can be configured on command line 2272 ok {test-number} - cfg.getProcessedReporterSpecs()[0] == Catch::ProcessedReporterSpec{ expectedReporter, std::string{}, Catch::ColourMode::PlatformDefault, {} } for: {?} == {?} 2273 # Process can be configured on command line 2274 ok {test-number} - result for: {?} 2275 # Process can be configured on command line 2276 ok {test-number} - cfg.hasTestFilters() for: true 2277 # Process can be configured on command line 2278 ok {test-number} - cfg.testSpec().matches(*fakeTestCase("notIncluded")) == false for: false == false 2279 # Process can be configured on command line 2280 ok {test-number} - cfg.testSpec().matches(*fakeTestCase("test1")) for: true 2281 # Process can be configured on command line 2282 ok {test-number} - result for: {?} 2283 # Process can be configured on command line 2284 ok {test-number} - cfg.hasTestFilters() for: true 2285 # Process can be configured on command line 2286 ok {test-number} - cfg.testSpec().matches(*fakeTestCase("test1")) == false for: false == false 2287 # Process can be configured on command line 2288 ok {test-number} - cfg.testSpec().matches(*fakeTestCase("alwaysIncluded")) for: true 2289 # Process can be configured on command line 2290 ok {test-number} - result for: {?} 2291 # Process can be configured on command line 2292 ok {test-number} - cfg.hasTestFilters() for: true 2293 # Process can be configured on command line 2294 ok {test-number} - cfg.testSpec().matches(*fakeTestCase("test1")) == false for: false == false 2295 # Process can be configured on command line 2296 ok {test-number} - cfg.testSpec().matches(*fakeTestCase("alwaysIncluded")) for: true 2297 # Process can be configured on command line 2298 ok {test-number} - result for: {?} with 1 message: 'result.errorMessage() := ""' 2299 # Process can be configured on command line 2300 ok {test-number} - config.reporterSpecifications == vec_Specs{ { "console", {}, {}, {} } } for: { {?} } == { {?} } with 1 message: 'result.errorMessage() := ""' 2301 # Process can be configured on command line 2302 ok {test-number} - result for: {?} with 1 message: 'result.errorMessage() := ""' 2303 # Process can be configured on command line 2304 ok {test-number} - config.reporterSpecifications == vec_Specs{ { "xml", {}, {}, {} } } for: { {?} } == { {?} } with 1 message: 'result.errorMessage() := ""' 2305 # Process can be configured on command line 2306 ok {test-number} - result for: {?} with 1 message: 'result.errorMessage() := ""' 2307 # Process can be configured on command line 2308 ok {test-number} - config.reporterSpecifications == vec_Specs{ { "junit", {}, {}, {} } } for: { {?} } == { {?} } with 1 message: 'result.errorMessage() := ""' 2309 # Process can be configured on command line 2310 ok {test-number} - !result for: true 2311 # Process can be configured on command line 2312 ok {test-number} - result.errorMessage(), ContainsSubstring("Unrecognized reporter") for: "Unrecognized reporter, 'unsupported'. Check available with --list-reporters" contains: "Unrecognized reporter" 2313 # Process can be configured on command line 2314 ok {test-number} - result for: {?} with 1 message: 'result.errorMessage() := ""' 2315 # Process can be configured on command line 2316 ok {test-number} - config.reporterSpecifications == vec_Specs{ { "console", "out.txt"s, {}, {} } } for: { {?} } == { {?} } with 1 message: 'result.errorMessage() := ""' 2317 # Process can be configured on command line 2318 ok {test-number} - result for: {?} with 1 message: 'result.errorMessage() := ""' 2319 # Process can be configured on command line 2320 ok {test-number} - config.reporterSpecifications == vec_Specs{ { "console", "C:\\Temp\\out.txt"s, {}, {} } } for: { {?} } == { {?} } with 1 message: 'result.errorMessage() := ""' 2321 # Process can be configured on command line 2322 ok {test-number} - cli.parse({ "test", "-r", "xml::out=output.xml", "-r", "junit::out=output-junit.xml" }) for: {?} 2323 # Process can be configured on command line 2324 ok {test-number} - config.reporterSpecifications == vec_Specs{ { "xml", "output.xml"s, {}, {} }, { "junit", "output-junit.xml"s, {}, {} } } for: { {?}, {?} } == { {?}, {?} } 2325 # Process can be configured on command line 2326 ok {test-number} - cli.parse({ "test", "-r", "xml::out=output.xml", "-r", "console" }) for: {?} 2327 # Process can be configured on command line 2328 ok {test-number} - config.reporterSpecifications == vec_Specs{ { "xml", "output.xml"s, {}, {} }, { "console", {}, {}, {} } } for: { {?}, {?} } == { {?}, {?} } 2329 # Process can be configured on command line 2330 ok {test-number} - !result for: true 2331 # Process can be configured on command line 2332 ok {test-number} - result.errorMessage(), ContainsSubstring("Only one reporter may have unspecified output file.") for: "Only one reporter may have unspecified output file." contains: "Only one reporter may have unspecified output file." 2333 # Process can be configured on command line 2334 ok {test-number} - cli.parse({"test", "-b"}) for: {?} 2335 # Process can be configured on command line 2336 ok {test-number} - config.shouldDebugBreak == true for: true == true 2337 # Process can be configured on command line 2338 ok {test-number} - cli.parse({"test", "--break"}) for: {?} 2339 # Process can be configured on command line 2340 ok {test-number} - config.shouldDebugBreak for: true 2341 # Process can be configured on command line 2342 ok {test-number} - cli.parse({"test", "-a"}) for: {?} 2343 # Process can be configured on command line 2344 ok {test-number} - config.abortAfter == 1 for: 1 == 1 2345 # Process can be configured on command line 2346 ok {test-number} - cli.parse({"test", "-x", "2"}) for: {?} 2347 # Process can be configured on command line 2348 ok {test-number} - config.abortAfter == 2 for: 2 == 2 2349 # Process can be configured on command line 2350 ok {test-number} - !result for: true 2351 # Process can be configured on command line 2352 ok {test-number} - result.errorMessage(), ContainsSubstring("convert") && ContainsSubstring("oops") for: "Unable to convert 'oops' to destination type" ( contains: "convert" and contains: "oops" ) 2353 # Process can be configured on command line 2354 ok {test-number} - cli.parse({"test", "--wait-for-keypress", std::get<0>(input)}) for: {?} 2355 # Process can be configured on command line 2356 ok {test-number} - config.waitForKeypress == std::get<1>(input) for: 0 == 0 2357 # Process can be configured on command line 2358 ok {test-number} - cli.parse({"test", "--wait-for-keypress", std::get<0>(input)}) for: {?} 2359 # Process can be configured on command line 2360 ok {test-number} - config.waitForKeypress == std::get<1>(input) for: 1 == 1 2361 # Process can be configured on command line 2362 ok {test-number} - cli.parse({"test", "--wait-for-keypress", std::get<0>(input)}) for: {?} 2363 # Process can be configured on command line 2364 ok {test-number} - config.waitForKeypress == std::get<1>(input) for: 2 == 2 2365 # Process can be configured on command line 2366 ok {test-number} - cli.parse({"test", "--wait-for-keypress", std::get<0>(input)}) for: {?} 2367 # Process can be configured on command line 2368 ok {test-number} - config.waitForKeypress == std::get<1>(input) for: 3 == 3 2369 # Process can be configured on command line 2370 ok {test-number} - !result for: true 2371 # Process can be configured on command line 2372 ok {test-number} - result.errorMessage(), ContainsSubstring("never") && ContainsSubstring("both") for: "keypress argument must be one of: never, start, exit or both. 'sometimes' not recognised" ( contains: "never" and contains: "both" ) 2373 # Process can be configured on command line 2374 ok {test-number} - cli.parse({"test", "-e"}) for: {?} 2375 # Process can be configured on command line 2376 ok {test-number} - config.noThrow for: true 2377 # Process can be configured on command line 2378 ok {test-number} - cli.parse({"test", "--nothrow"}) for: {?} 2379 # Process can be configured on command line 2380 ok {test-number} - config.noThrow for: true 2381 # Process can be configured on command line 2382 ok {test-number} - cli.parse({"test", "-o", "filename.ext"}) for: {?} 2383 # Process can be configured on command line 2384 ok {test-number} - config.defaultOutputFilename == "filename.ext" for: "filename.ext" == "filename.ext" 2385 # Process can be configured on command line 2386 ok {test-number} - cli.parse({"test", "--out", "filename.ext"}) for: {?} 2387 # Process can be configured on command line 2388 ok {test-number} - config.defaultOutputFilename == "filename.ext" for: "filename.ext" == "filename.ext" 2389 # Process can be configured on command line 2390 ok {test-number} - cli.parse({"test", "-abe"}) for: {?} 2391 # Process can be configured on command line 2392 ok {test-number} - config.abortAfter == 1 for: 1 == 1 2393 # Process can be configured on command line 2394 ok {test-number} - config.shouldDebugBreak for: true 2395 # Process can be configured on command line 2396 ok {test-number} - config.noThrow == true for: true == true 2397 # Process can be configured on command line 2398 ok {test-number} - cli.parse({"test"}) for: {?} 2399 # Process can be configured on command line 2400 ok {test-number} - config.defaultColourMode == ColourMode::PlatformDefault for: 0 == 0 2401 # Process can be configured on command line 2402 ok {test-number} - cli.parse( { "test", "--colour-mode", "default" } ) for: {?} 2403 # Process can be configured on command line 2404 ok {test-number} - config.defaultColourMode == ColourMode::PlatformDefault for: 0 == 0 2405 # Process can be configured on command line 2406 ok {test-number} - cli.parse({"test", "--colour-mode", "ansi"}) for: {?} 2407 # Process can be configured on command line 2408 ok {test-number} - config.defaultColourMode == ColourMode::ANSI for: 1 == 1 2409 # Process can be configured on command line 2410 ok {test-number} - cli.parse({"test", "--colour-mode", "none"}) for: {?} 2411 # Process can be configured on command line 2412 ok {test-number} - config.defaultColourMode == ColourMode::None for: 3 == 3 2413 # Process can be configured on command line 2414 ok {test-number} - !result for: true 2415 # Process can be configured on command line 2416 ok {test-number} - result.errorMessage(), ContainsSubstring( "colour mode must be one of" ) for: "colour mode must be one of: default, ansi, win32, or none. 'wrong' is not recognised" contains: "colour mode must be one of" 2417 # Process can be configured on command line 2418 ok {test-number} - cli.parse({ "test", "--benchmark-samples=200" }) for: {?} 2419 # Process can be configured on command line 2420 ok {test-number} - config.benchmarkSamples == 200 for: 200 == 200 2421 # Process can be configured on command line 2422 ok {test-number} - cli.parse({ "test", "--benchmark-resamples=20000" }) for: {?} 2423 # Process can be configured on command line 2424 ok {test-number} - config.benchmarkResamples == 20000 for: 20000 (0x<hex digits>) == 20000 (0x<hex digits>) 2425 # Process can be configured on command line 2426 ok {test-number} - cli.parse({ "test", "--benchmark-confidence-interval=0.99" }) for: {?} 2427 # Process can be configured on command line 2428 ok {test-number} - config.benchmarkConfidenceInterval == Catch::Approx(0.99) for: 0.99 == Approx( 0.99 ) 2429 # Process can be configured on command line 2430 ok {test-number} - cli.parse({ "test", "--benchmark-no-analysis" }) for: {?} 2431 # Process can be configured on command line 2432 ok {test-number} - config.benchmarkNoAnalysis for: true 2433 # Process can be configured on command line 2434 ok {test-number} - cli.parse({ "test", "--benchmark-warmup-time=10" }) for: {?} 2435 # Process can be configured on command line 2436 ok {test-number} - config.benchmarkWarmupTime == 10 for: 10 == 10 2437 # Product with differing arities - std::tuple<int, double, float> 2438 ok {test-number} - std::tuple_size<TestType>::value >= 1 for: 3 >= 1 2439 # Product with differing arities - std::tuple<int, double> 2440 ok {test-number} - std::tuple_size<TestType>::value >= 1 for: 2 >= 1 2441 # Product with differing arities - std::tuple<int> 2442 ok {test-number} - std::tuple_size<TestType>::value >= 1 for: 1 >= 1 2443 # Random seed generation accepts known methods 2444 ok {test-number} - Catch::generateRandomSeed(method) 2445 # Random seed generation accepts known methods 2446 ok {test-number} - Catch::generateRandomSeed(method) 2447 # Random seed generation accepts known methods 2448 ok {test-number} - Catch::generateRandomSeed(method) 2449 # Random seed generation reports unknown methods 2450 ok {test-number} - Catch::generateRandomSeed(static_cast<Catch::GenerateFrom>(77)) 2451 # Range type with sentinel 2452 ok {test-number} - Catch::Detail::stringify(UsesSentinel{}) == "{ }" for: "{ }" == "{ }" 2453 # Reconstruction should be based on stringification: #914 2454 not ok {test-number} - truthy(false) for: Hey, its truthy! 2455 # Regex string matcher 2456 not ok {test-number} - testStringForMatching(), Matches( "this STRING contains 'abc' as a substring" ) for: "this string contains 'abc' as a substring" matches "this STRING contains 'abc' as a substring" case sensitively 2457 # Regex string matcher 2458 not ok {test-number} - testStringForMatching(), Matches( "contains 'abc' as a substring" ) for: "this string contains 'abc' as a substring" matches "contains 'abc' as a substring" case sensitively 2459 # Regex string matcher 2460 not ok {test-number} - testStringForMatching(), Matches( "this string contains 'abc' as a" ) for: "this string contains 'abc' as a substring" matches "this string contains 'abc' as a" case sensitively 2461 # Registering reporter with '::' in name fails 2462 ok {test-number} - registry.registerReporter( "with::doublecolons", Catch::Detail::make_unique<TestReporterFactory>() ), "'::' is not allowed in reporter name: 'with::doublecolons'" for: "'::' is not allowed in reporter name: 'with::doublecolons'" equals: "'::' is not allowed in reporter name: 'with::doublecolons'" 2463 # Regression test #1 2464 ok {test-number} - actual, !UnorderedEquals( expected ) for: { 'a', 'b' } not UnorderedEquals: { 'c', 'b' } 2465 # Reporter's write listings to provided stream 2466 ok {test-number} - !(factories.empty()) for: !false 2467 # Reporter's write listings to provided stream 2468 ok {test-number} - listingString, ContainsSubstring("fakeTag"s) for: "All available tags: 1 [fakeTag] 1 tag " contains: "fakeTag" with 1 message: 'Tested reporter: Automake' 2469 # Reporter's write listings to provided stream 2470 ok {test-number} - !(factories.empty()) for: !false 2471 # Reporter's write listings to provided stream 2472 ok {test-number} - listingString, ContainsSubstring("fake reporter"s) for: "Available reporters: fake reporter: fake description " contains: "fake reporter" with 1 message: 'Tested reporter: Automake' 2473 # Reporter's write listings to provided stream 2474 ok {test-number} - !(factories.empty()) for: !false 2475 # Reporter's write listings to provided stream 2476 ok {test-number} - listingString, ContainsSubstring( "fake test name"s ) && ContainsSubstring( "fakeTestTag"s ) for: "All available test cases: fake test name [fakeTestTag] 1 test case " ( contains: "fake test name" and contains: "fakeTestTag" ) with 1 message: 'Tested reporter: Automake' 2477 # Reporter's write listings to provided stream 2478 ok {test-number} - !(factories.empty()) for: !false 2479 # Reporter's write listings to provided stream 2480 ok {test-number} - listingString, ContainsSubstring("fakeTag"s) for: "All available tags: 1 [fakeTag] 1 tag " contains: "fakeTag" with 1 message: 'Tested reporter: compact' 2481 # Reporter's write listings to provided stream 2482 ok {test-number} - !(factories.empty()) for: !false 2483 # Reporter's write listings to provided stream 2484 ok {test-number} - listingString, ContainsSubstring("fake reporter"s) for: "Available reporters: fake reporter: fake description " contains: "fake reporter" with 1 message: 'Tested reporter: compact' 2485 # Reporter's write listings to provided stream 2486 ok {test-number} - !(factories.empty()) for: !false 2487 # Reporter's write listings to provided stream 2488 ok {test-number} - listingString, ContainsSubstring( "fake test name"s ) && ContainsSubstring( "fakeTestTag"s ) for: "All available test cases: fake test name [fakeTestTag] 1 test case " ( contains: "fake test name" and contains: "fakeTestTag" ) with 1 message: 'Tested reporter: compact' 2489 # Reporter's write listings to provided stream 2490 ok {test-number} - !(factories.empty()) for: !false 2491 # Reporter's write listings to provided stream 2492 ok {test-number} - listingString, ContainsSubstring("fakeTag"s) for: "All available tags: 1 [fakeTag] 1 tag " contains: "fakeTag" with 1 message: 'Tested reporter: console' 2493 # Reporter's write listings to provided stream 2494 ok {test-number} - !(factories.empty()) for: !false 2495 # Reporter's write listings to provided stream 2496 ok {test-number} - listingString, ContainsSubstring("fake reporter"s) for: "Available reporters: fake reporter: fake description " contains: "fake reporter" with 1 message: 'Tested reporter: console' 2497 # Reporter's write listings to provided stream 2498 ok {test-number} - !(factories.empty()) for: !false 2499 # Reporter's write listings to provided stream 2500 ok {test-number} - listingString, ContainsSubstring( "fake test name"s ) && ContainsSubstring( "fakeTestTag"s ) for: "All available test cases: fake test name [fakeTestTag] 1 test case " ( contains: "fake test name" and contains: "fakeTestTag" ) with 1 message: 'Tested reporter: console' 2501 # Reporter's write listings to provided stream 2502 ok {test-number} - !(factories.empty()) for: !false 2503 # Reporter's write listings to provided stream 2504 ok {test-number} - listingString, ContainsSubstring("fakeTag"s) for: "{ "version": 1, "metadata": { "name": "", "rng-seed": 1234, "catch2-version": "<version>" }, "listings": { "tags": [ { "aliases": [ "fakeTag" ], "count": 1 } ]" contains: "fakeTag" with 1 message: 'Tested reporter: JSON' 2505 # Reporter's write listings to provided stream 2506 ok {test-number} - !(factories.empty()) for: !false 2507 # Reporter's write listings to provided stream 2508 ok {test-number} - listingString, ContainsSubstring("fake reporter"s) for: "{ "version": 1, "metadata": { "name": "", "rng-seed": 1234, "catch2-version": "<version>" }, "listings": { "reporters": [ { "name": "fake reporter", "description": "fake description" } ]" contains: "fake reporter" with 1 message: 'Tested reporter: JSON' 2509 # Reporter's write listings to provided stream 2510 ok {test-number} - !(factories.empty()) for: !false 2511 # Reporter's write listings to provided stream 2512 ok {test-number} - listingString, ContainsSubstring( "fake test name"s ) && ContainsSubstring( "fakeTestTag"s ) for: "{ "version": 1, "metadata": { "name": "", "rng-seed": 1234, "catch2-version": "<version>" }, "listings": { "tests": [ { "name": "fake test name", "class-name": "", "tags": [ "fakeTestTag" ], "source-location": { "filename": "fake-file.cpp", "line": 123456789 } } ]" ( contains: "fake test name" and contains: "fakeTestTag" ) with 1 message: 'Tested reporter: JSON' 2513 # Reporter's write listings to provided stream 2514 ok {test-number} - !(factories.empty()) for: !false 2515 # Reporter's write listings to provided stream 2516 ok {test-number} - listingString, ContainsSubstring("fakeTag"s) for: "<?xml version="1.0" encoding="UTF-8"?> All available tags: 1 [fakeTag] 1 tag " contains: "fakeTag" with 1 message: 'Tested reporter: JUnit' 2517 # Reporter's write listings to provided stream 2518 ok {test-number} - !(factories.empty()) for: !false 2519 # Reporter's write listings to provided stream 2520 ok {test-number} - listingString, ContainsSubstring("fake reporter"s) for: "<?xml version="1.0" encoding="UTF-8"?> Available reporters: fake reporter: fake description " contains: "fake reporter" with 1 message: 'Tested reporter: JUnit' 2521 # Reporter's write listings to provided stream 2522 ok {test-number} - !(factories.empty()) for: !false 2523 # Reporter's write listings to provided stream 2524 ok {test-number} - listingString, ContainsSubstring( "fake test name"s ) && ContainsSubstring( "fakeTestTag"s ) for: "<?xml version="1.0" encoding="UTF-8"?> All available test cases: fake test name [fakeTestTag] 1 test case " ( contains: "fake test name" and contains: "fakeTestTag" ) with 1 message: 'Tested reporter: JUnit' 2525 # Reporter's write listings to provided stream 2526 ok {test-number} - !(factories.empty()) for: !false 2527 # Reporter's write listings to provided stream 2528 ok {test-number} - listingString, ContainsSubstring("fakeTag"s) for: "<?xml version="1.0" encoding="UTF-8"?> All available tags: 1 [fakeTag] 1 tag " contains: "fakeTag" with 1 message: 'Tested reporter: SonarQube' 2529 # Reporter's write listings to provided stream 2530 ok {test-number} - !(factories.empty()) for: !false 2531 # Reporter's write listings to provided stream 2532 ok {test-number} - listingString, ContainsSubstring("fake reporter"s) for: "<?xml version="1.0" encoding="UTF-8"?> Available reporters: fake reporter: fake description " contains: "fake reporter" with 1 message: 'Tested reporter: SonarQube' 2533 # Reporter's write listings to provided stream 2534 ok {test-number} - !(factories.empty()) for: !false 2535 # Reporter's write listings to provided stream 2536 ok {test-number} - listingString, ContainsSubstring( "fake test name"s ) && ContainsSubstring( "fakeTestTag"s ) for: "<?xml version="1.0" encoding="UTF-8"?> All available test cases: fake test name [fakeTestTag] 1 test case " ( contains: "fake test name" and contains: "fakeTestTag" ) with 1 message: 'Tested reporter: SonarQube' 2537 # Reporter's write listings to provided stream 2538 ok {test-number} - !(factories.empty()) for: !false 2539 # Reporter's write listings to provided stream 2540 ok {test-number} - listingString, ContainsSubstring("fakeTag"s) for: "All available tags: 1 [fakeTag] 1 tag " contains: "fakeTag" with 1 message: 'Tested reporter: TAP' 2541 # Reporter's write listings to provided stream 2542 ok {test-number} - !(factories.empty()) for: !false 2543 # Reporter's write listings to provided stream 2544 ok {test-number} - listingString, ContainsSubstring("fake reporter"s) for: "Available reporters: fake reporter: fake description " contains: "fake reporter" with 1 message: 'Tested reporter: TAP' 2545 # Reporter's write listings to provided stream 2546 ok {test-number} - !(factories.empty()) for: !false 2547 # Reporter's write listings to provided stream 2548 ok {test-number} - listingString, ContainsSubstring( "fake test name"s ) && ContainsSubstring( "fakeTestTag"s ) for: "All available test cases: fake test name [fakeTestTag] 1 test case " ( contains: "fake test name" and contains: "fakeTestTag" ) with 1 message: 'Tested reporter: TAP' 2549 # Reporter's write listings to provided stream 2550 ok {test-number} - !(factories.empty()) for: !false 2551 # Reporter's write listings to provided stream 2552 ok {test-number} - listingString, ContainsSubstring("fakeTag"s) for: "All available tags: 1 [fakeTag] 1 tag " contains: "fakeTag" with 1 message: 'Tested reporter: TeamCity' 2553 # Reporter's write listings to provided stream 2554 ok {test-number} - !(factories.empty()) for: !false 2555 # Reporter's write listings to provided stream 2556 ok {test-number} - listingString, ContainsSubstring("fake reporter"s) for: "Available reporters: fake reporter: fake description " contains: "fake reporter" with 1 message: 'Tested reporter: TeamCity' 2557 # Reporter's write listings to provided stream 2558 ok {test-number} - !(factories.empty()) for: !false 2559 # Reporter's write listings to provided stream 2560 ok {test-number} - listingString, ContainsSubstring( "fake test name"s ) && ContainsSubstring( "fakeTestTag"s ) for: "All available test cases: fake test name [fakeTestTag] 1 test case " ( contains: "fake test name" and contains: "fakeTestTag" ) with 1 message: 'Tested reporter: TeamCity' 2561 # Reporter's write listings to provided stream 2562 ok {test-number} - !(factories.empty()) for: !false 2563 # Reporter's write listings to provided stream 2564 ok {test-number} - listingString, ContainsSubstring("fakeTag"s) for: "<?xml version="1.0" encoding="UTF-8"?> <TagsFromMatchingTests> <Tag> <Count>1</Count> <Aliases> <Alias>fakeTag</Alias> </Aliases> </Tag> </TagsFromMatchingTests>" contains: "fakeTag" with 1 message: 'Tested reporter: XML' 2565 # Reporter's write listings to provided stream 2566 ok {test-number} - !(factories.empty()) for: !false 2567 # Reporter's write listings to provided stream 2568 ok {test-number} - listingString, ContainsSubstring("fake reporter"s) for: "<?xml version="1.0" encoding="UTF-8"?> <AvailableReporters> <Reporter> <Name>fake reporter</Name> <Description>fake description</Description> </Reporter> </AvailableReporters>" contains: "fake reporter" with 1 message: 'Tested reporter: XML' 2569 # Reporter's write listings to provided stream 2570 ok {test-number} - !(factories.empty()) for: !false 2571 # Reporter's write listings to provided stream 2572 ok {test-number} - listingString, ContainsSubstring( "fake test name"s ) && ContainsSubstring( "fakeTestTag"s ) for: "<?xml version="1.0" encoding="UTF-8"?> <MatchingTests> <TestCase> <Name>fake test name</Name> <ClassName/> <Tags>[fakeTestTag]</Tags> <SourceInfo> <File>fake-file.cpp</File> <Line>123456789</Line> </SourceInfo> </TestCase> </MatchingTests>" ( contains: "fake test name" and contains: "fakeTestTag" ) with 1 message: 'Tested reporter: XML' 2573 # Reproducer for #2309 - a very long description past 80 chars (default console width) with a late colon : blablabla 2574 ok {test-number} - 2575 # SUCCEED counts as a test pass 2576 ok {test-number} - with 1 message: 'this is a success' 2577 # SUCCEED does not require an argument 2578 ok {test-number} - 2579 # Scenario: BDD tests requiring Fixtures to provide commonly-accessed data or methods 2580 ok {test-number} - before == 0 for: 0 == 0 2581 # Scenario: BDD tests requiring Fixtures to provide commonly-accessed data or methods 2582 ok {test-number} - after > before for: 1 > 0 2583 # Scenario: Do that thing with the thing 2584 ok {test-number} - itDoesThis() for: true 2585 # Scenario: Do that thing with the thing 2586 ok {test-number} - itDoesThat() for: true 2587 # Scenario: This is a really long scenario name to see how the list command deals with wrapping 2588 ok {test-number} - with 1 message: 'boo!' 2589 # Scenario: Vector resizing affects size and capacity 2590 ok {test-number} - v.size() == 0 for: 0 == 0 2591 # Scenario: Vector resizing affects size and capacity 2592 ok {test-number} - v.size() == 10 for: 10 == 10 2593 # Scenario: Vector resizing affects size and capacity 2594 ok {test-number} - v.capacity() >= 10 for: 10 >= 10 2595 # Scenario: Vector resizing affects size and capacity 2596 ok {test-number} - v.size() == 5 for: 5 == 5 2597 # Scenario: Vector resizing affects size and capacity 2598 ok {test-number} - v.capacity() >= 10 for: 10 >= 10 2599 # Scenario: Vector resizing affects size and capacity 2600 ok {test-number} - v.size() == 0 for: 0 == 0 2601 # Scenario: Vector resizing affects size and capacity 2602 ok {test-number} - v.capacity() >= 10 for: 10 >= 10 2603 # Scenario: Vector resizing affects size and capacity 2604 ok {test-number} - v.size() == 0 for: 0 == 0 2605 # Some simple comparisons between doubles 2606 ok {test-number} - d == Approx( 1.23 ) for: 1.23 == Approx( 1.23 ) 2607 # Some simple comparisons between doubles 2608 ok {test-number} - d != Approx( 1.22 ) for: 1.23 != Approx( 1.22 ) 2609 # Some simple comparisons between doubles 2610 ok {test-number} - d != Approx( 1.24 ) for: 1.23 != Approx( 1.24 ) 2611 # Some simple comparisons between doubles 2612 ok {test-number} - d == 1.23_a for: 1.23 == Approx( 1.23 ) 2613 # Some simple comparisons between doubles 2614 ok {test-number} - d != 1.22_a for: 1.23 != Approx( 1.22 ) 2615 # Some simple comparisons between doubles 2616 ok {test-number} - Approx( d ) == 1.23 for: Approx( 1.23 ) == 1.23 2617 # Some simple comparisons between doubles 2618 ok {test-number} - Approx( d ) != 1.22 for: Approx( 1.23 ) != 1.22 2619 # Some simple comparisons between doubles 2620 ok {test-number} - Approx( d ) != 1.24 for: Approx( 1.23 ) != 1.24 2621 # StartsWith string matcher 2622 not ok {test-number} - testStringForMatching(), StartsWith( "This String" ) for: "this string contains 'abc' as a substring" starts with: "This String" 2623 # StartsWith string matcher 2624 not ok {test-number} - testStringForMatching(), StartsWith( "string", Catch::CaseSensitive::No ) for: "this string contains 'abc' as a substring" starts with: "string" (case insensitive) 2625 # Static arrays are convertible to string 2626 ok {test-number} - Catch::Detail::stringify(singular) == "{ 1 }" for: "{ 1 }" == "{ 1 }" 2627 # Static arrays are convertible to string 2628 ok {test-number} - Catch::Detail::stringify(arr) == "{ 3, 2, 1 }" for: "{ 3, 2, 1 }" == "{ 3, 2, 1 }" 2629 # Static arrays are convertible to string 2630 ok {test-number} - Catch::Detail::stringify(arr) == R"({ { "1:1", "1:2", "1:3" }, { "2:1", "2:2" } })" for: "{ { "1:1", "1:2", "1:3" }, { "2:1", "2:2" } }" == "{ { "1:1", "1:2", "1:3" }, { "2:1", "2:2" } }" 2631 # String matchers 2632 ok {test-number} - testStringForMatching(), ContainsSubstring( "string" ) for: "this string contains 'abc' as a substring" contains: "string" 2633 # String matchers 2634 ok {test-number} - testStringForMatching(), ContainsSubstring( "string", Catch::CaseSensitive::No ) for: "this string contains 'abc' as a substring" contains: "string" (case insensitive) 2635 # String matchers 2636 ok {test-number} - testStringForMatching(), ContainsSubstring( "abc" ) for: "this string contains 'abc' as a substring" contains: "abc" 2637 # String matchers 2638 ok {test-number} - testStringForMatching(), ContainsSubstring( "aBC", Catch::CaseSensitive::No ) for: "this string contains 'abc' as a substring" contains: "abc" (case insensitive) 2639 # String matchers 2640 ok {test-number} - testStringForMatching(), StartsWith( "this" ) for: "this string contains 'abc' as a substring" starts with: "this" 2641 # String matchers 2642 ok {test-number} - testStringForMatching(), StartsWith( "THIS", Catch::CaseSensitive::No ) for: "this string contains 'abc' as a substring" starts with: "this" (case insensitive) 2643 # String matchers 2644 ok {test-number} - testStringForMatching(), EndsWith( "substring" ) for: "this string contains 'abc' as a substring" ends with: "substring" 2645 # String matchers 2646 ok {test-number} - testStringForMatching(), EndsWith( " SuBsTrInG", Catch::CaseSensitive::No ) for: "this string contains 'abc' as a substring" ends with: " substring" (case insensitive) 2647 # StringRef 2648 ok {test-number} - empty.empty() for: true 2649 # StringRef 2650 ok {test-number} - empty.size() == 0 for: 0 == 0 2651 # StringRef 2652 ok {test-number} - std::strcmp( empty.data(), "" ) == 0 for: 0 == 0 2653 # StringRef 2654 ok {test-number} - s.empty() == false for: false == false 2655 # StringRef 2656 ok {test-number} - s.size() == 5 for: 5 == 5 2657 # StringRef 2658 ok {test-number} - std::strcmp( rawChars, "hello" ) == 0 for: 0 == 0 2659 # StringRef 2660 ok {test-number} - s.data() == rawChars for: "hello" == "hello" 2661 # StringRef 2662 ok {test-number} - original == "original" 2663 # StringRef 2664 ok {test-number} - original.data() 2665 # StringRef 2666 ok {test-number} - original.begin() == copy.begin() for: "original string" == "original string" 2667 # StringRef 2668 ok {test-number} - original.begin() == copy.begin() for: "original string" == "original string" 2669 # StringRef 2670 ok {test-number} - ss.empty() == false for: false == false 2671 # StringRef 2672 ok {test-number} - ss.size() == 5 for: 5 == 5 2673 # StringRef 2674 ok {test-number} - std::strncmp( ss.data(), "hello", 5 ) == 0 for: 0 == 0 2675 # StringRef 2676 ok {test-number} - ss == "hello" for: hello == "hello" 2677 # StringRef 2678 ok {test-number} - ss.size() == 6 for: 6 == 6 2679 # StringRef 2680 ok {test-number} - std::strcmp( ss.data(), "world!" ) == 0 for: 0 == 0 2681 # StringRef 2682 ok {test-number} - s.data() == s2.data() for: "hello world!" == "hello world!" 2683 # StringRef 2684 ok {test-number} - s.data() == ss.data() for: "hello world!" == "hello world!" 2685 # StringRef 2686 ok {test-number} - s.substr(s.size() + 1, 123).empty() for: true 2687 # StringRef 2688 ok {test-number} - std::strcmp(ss.data(), "world!") == 0 for: 0 == 0 2689 # StringRef 2690 ok {test-number} - s.substr(1'000'000, 1).empty() for: true 2691 # StringRef 2692 ok {test-number} - reinterpret_cast<char*>(buffer1) != reinterpret_cast<char*>(buffer2) for: "Hello" != "Hello" 2693 # StringRef 2694 ok {test-number} - left == right for: Hello == Hello 2695 # StringRef 2696 ok {test-number} - left != left.substr(0, 3) for: Hello != Hel 2697 # StringRef 2698 ok {test-number} - sr == "a standard string" for: a standard string == "a standard string" 2699 # StringRef 2700 ok {test-number} - sr.size() == stdStr.size() for: 17 == 17 2701 # StringRef 2702 ok {test-number} - sr == "a standard string" for: a standard string == "a standard string" 2703 # StringRef 2704 ok {test-number} - sr.size() == stdStr.size() for: 17 == 17 2705 # StringRef 2706 ok {test-number} - sr == "a standard string" for: a standard string == "a standard string" 2707 # StringRef 2708 ok {test-number} - sr.size() == stdStr.size() for: 17 == 17 2709 # StringRef 2710 ok {test-number} - stdStr == "a stringref" for: "a stringref" == "a stringref" 2711 # StringRef 2712 ok {test-number} - stdStr.size() == sr.size() for: 11 == 11 2713 # StringRef 2714 ok {test-number} - stdStr == "a stringref" for: "a stringref" == "a stringref" 2715 # StringRef 2716 ok {test-number} - stdStr.size() == sr.size() for: 11 == 11 2717 # StringRef 2718 ok {test-number} - lhs == "some string += the stringref contents" for: "some string += the stringref contents" == "some string += the stringref contents" 2719 # StringRef 2720 ok {test-number} - together == "abrakadabra" for: "abrakadabra" == "abrakadabra" 2721 # StringRef at compilation time 2722 ok {test-number} - with 1 message: 'empty.size() == 0' 2723 # StringRef at compilation time 2724 ok {test-number} - with 1 message: 'empty.begin() == empty.end()' 2725 # StringRef at compilation time 2726 ok {test-number} - with 1 message: 'stringref.size() == 3' 2727 # StringRef at compilation time 2728 ok {test-number} - with 1 message: 'stringref.data() == abc' 2729 # StringRef at compilation time 2730 ok {test-number} - with 1 message: 'stringref.begin() == abc' 2731 # StringRef at compilation time 2732 ok {test-number} - with 1 message: 'stringref.begin() != stringref.end()' 2733 # StringRef at compilation time 2734 ok {test-number} - with 1 message: 'stringref.substr(10, 0).empty()' 2735 # StringRef at compilation time 2736 ok {test-number} - with 1 message: 'stringref.substr(2, 1).data() == abc + 2' 2737 # StringRef at compilation time 2738 ok {test-number} - with 1 message: 'stringref[1] == 'b'' 2739 # StringRef at compilation time 2740 ok {test-number} - with 1 message: 'shortened.size() == 2' 2741 # StringRef at compilation time 2742 ok {test-number} - with 1 message: 'shortened.data() == abc' 2743 # StringRef at compilation time 2744 ok {test-number} - with 1 message: 'shortened.begin() != shortened.end()' 2745 # StringRef at compilation time 2746 ok {test-number} - with 1 message: '!(sr1.empty())' 2747 # StringRef at compilation time 2748 ok {test-number} - with 1 message: 'sr1.size() == 3' 2749 # StringRef at compilation time 2750 ok {test-number} - with 1 message: 'sr2.empty()' 2751 # StringRef at compilation time 2752 ok {test-number} - with 1 message: 'sr2.size() == 0' 2753 # Stringifying char arrays with statically known sizes - char 2754 ok {test-number} - ::Catch::Detail::stringify( with_null_terminator ) == R"("abc")"s for: ""abc"" == ""abc"" 2755 # Stringifying char arrays with statically known sizes - char 2756 ok {test-number} - ::Catch::Detail::stringify( no_null_terminator ) == R"("abc")"s for: ""abc"" == ""abc"" 2757 # Stringifying char arrays with statically known sizes - signed char 2758 ok {test-number} - ::Catch::Detail::stringify( with_null_terminator ) == R"("abc")"s for: ""abc"" == ""abc"" 2759 # Stringifying char arrays with statically known sizes - signed char 2760 ok {test-number} - ::Catch::Detail::stringify( no_null_terminator ) == R"("abc")"s for: ""abc"" == ""abc"" 2761 # Stringifying char arrays with statically known sizes - unsigned char 2762 ok {test-number} - ::Catch::Detail::stringify( with_null_terminator ) == R"("abc")"s for: ""abc"" == ""abc"" 2763 # Stringifying char arrays with statically known sizes - unsigned char 2764 ok {test-number} - ::Catch::Detail::stringify( no_null_terminator ) == R"("abc")"s for: ""abc"" == ""abc"" 2765 # Stringifying std::chrono::duration helpers 2766 ok {test-number} - minute == seconds for: 1 m == 60 s 2767 # Stringifying std::chrono::duration helpers 2768 ok {test-number} - hour != seconds for: 1 h != 60 s 2769 # Stringifying std::chrono::duration helpers 2770 ok {test-number} - micro != milli for: 1 us != 1 ms 2771 # Stringifying std::chrono::duration helpers 2772 ok {test-number} - nano != micro for: 1 ns != 1 us 2773 # Stringifying std::chrono::duration with weird ratios 2774 ok {test-number} - half_minute != femto_second for: 1 [30/1]s != 1 fs 2775 # Stringifying std::chrono::duration with weird ratios 2776 ok {test-number} - pico_second != atto_second for: 1 ps != 1 as 2777 # Stringifying std::chrono::time_point<system_clock> 2778 ok {test-number} - now != later for: {iso8601-timestamp} != {iso8601-timestamp} 2779 # Tabs and newlines show in output 2780 not ok {test-number} - s1 == s2 for: "if ($b == 10) { $a = 20; }" == "if ($b == 10) { $a = 20; } " 2781 # Tag alias can be registered against tag patterns 2782 ok {test-number} - what, ContainsSubstring( "[@zzz]" ) for: "error: tag alias, '[@zzz]' already registered. First seen at: file:2 Redefined at: file:10" contains: "[@zzz]" 2783 # Tag alias can be registered against tag patterns 2784 ok {test-number} - what, ContainsSubstring( "file" ) for: "error: tag alias, '[@zzz]' already registered. First seen at: file:2 Redefined at: file:10" contains: "file" 2785 # Tag alias can be registered against tag patterns 2786 ok {test-number} - what, ContainsSubstring( "2" ) for: "error: tag alias, '[@zzz]' already registered. First seen at: file:2 Redefined at: file:10" contains: "2" 2787 # Tag alias can be registered against tag patterns 2788 ok {test-number} - what, ContainsSubstring( "10" ) for: "error: tag alias, '[@zzz]' already registered. First seen at: file:2 Redefined at: file:10" contains: "10" 2789 # Tag alias can be registered against tag patterns 2790 ok {test-number} - registry.add( "[no ampersat]", "", Catch::SourceLineInfo( "file", 3 ) ) 2791 # Tag alias can be registered against tag patterns 2792 ok {test-number} - registry.add( "[the @ is not at the start]", "", Catch::SourceLineInfo( "file", 3 ) ) 2793 # Tag alias can be registered against tag patterns 2794 ok {test-number} - registry.add( "@no square bracket at start]", "", Catch::SourceLineInfo( "file", 3 ) ) 2795 # Tag alias can be registered against tag patterns 2796 ok {test-number} - registry.add( "[@no square bracket at end", "", Catch::SourceLineInfo( "file", 3 ) ) 2797 # Tags with spaces and non-alphanumerical characters are accepted 2798 ok {test-number} - testCase.tags.size() == 2 for: 2 == 2 2799 # Tags with spaces and non-alphanumerical characters are accepted 2800 ok {test-number} - testCase.tags, VectorContains( Tag( "tag with spaces" ) ) && VectorContains( Tag( "I said \"good day\" sir!"_catch_sr ) ) for: { {?}, {?} } ( Contains: {?} and Contains: {?} ) 2801 # Template test case method with test types specified inside std::tuple - MyTypes - 0 2802 ok {test-number} - Template_Fixture<TestType>::m_a == 1 for: 1 == 1 2803 # Template test case method with test types specified inside std::tuple - MyTypes - 1 2804 ok {test-number} - Template_Fixture<TestType>::m_a == 1 for: 1 == 1 2805 # Template test case method with test types specified inside std::tuple - MyTypes - 2 2806 ok {test-number} - Template_Fixture<TestType>::m_a == 1 for: 1.0 == 1 2807 # Template test case with test types specified inside non-copyable and non-movable std::tuple - NonCopyableAndNonMovableTypes - 0 2808 ok {test-number} - sizeof(TestType) > 0 for: 1 > 0 2809 # Template test case with test types specified inside non-copyable and non-movable std::tuple - NonCopyableAndNonMovableTypes - 1 2810 ok {test-number} - sizeof(TestType) > 0 for: 4 > 0 2811 # Template test case with test types specified inside non-default-constructible std::tuple - MyNonDefaultConstructibleTypes - 0 2812 ok {test-number} - sizeof(TestType) > 0 for: 1 > 0 2813 # Template test case with test types specified inside non-default-constructible std::tuple - MyNonDefaultConstructibleTypes - 1 2814 ok {test-number} - sizeof(TestType) > 0 for: 4 > 0 2815 # Template test case with test types specified inside std::tuple - MyTypes - 0 2816 ok {test-number} - sizeof(TestType) > 0 for: 4 > 0 2817 # Template test case with test types specified inside std::tuple - MyTypes - 1 2818 ok {test-number} - sizeof(TestType) > 0 for: 1 > 0 2819 # Template test case with test types specified inside std::tuple - MyTypes - 2 2820 ok {test-number} - sizeof(TestType) > 0 for: 4 > 0 2821 # TemplateTest: vectors can be sized and resized - float 2822 ok {test-number} - v.size() == 5 for: 5 == 5 2823 # TemplateTest: vectors can be sized and resized - float 2824 ok {test-number} - v.capacity() >= 5 for: 5 >= 5 2825 # TemplateTest: vectors can be sized and resized - float 2826 ok {test-number} - v.size() == 10 for: 10 == 10 2827 # TemplateTest: vectors can be sized and resized - float 2828 ok {test-number} - v.capacity() >= 10 for: 10 >= 10 2829 # TemplateTest: vectors can be sized and resized - float 2830 ok {test-number} - v.size() == 5 for: 5 == 5 2831 # TemplateTest: vectors can be sized and resized - float 2832 ok {test-number} - v.capacity() >= 5 for: 5 >= 5 2833 # TemplateTest: vectors can be sized and resized - float 2834 ok {test-number} - v.size() == 0 for: 0 == 0 2835 # TemplateTest: vectors can be sized and resized - float 2836 ok {test-number} - v.capacity() >= 5 for: 5 >= 5 2837 # TemplateTest: vectors can be sized and resized - float 2838 ok {test-number} - v.capacity() == 0 for: 0 == 0 2839 # TemplateTest: vectors can be sized and resized - float 2840 ok {test-number} - v.size() == 5 for: 5 == 5 2841 # TemplateTest: vectors can be sized and resized - float 2842 ok {test-number} - v.capacity() >= 5 for: 5 >= 5 2843 # TemplateTest: vectors can be sized and resized - float 2844 ok {test-number} - v.size() == 5 for: 5 == 5 2845 # TemplateTest: vectors can be sized and resized - float 2846 ok {test-number} - v.capacity() >= 10 for: 10 >= 10 2847 # TemplateTest: vectors can be sized and resized - float 2848 ok {test-number} - v.size() == 5 for: 5 == 5 2849 # TemplateTest: vectors can be sized and resized - float 2850 ok {test-number} - v.capacity() >= 5 for: 5 >= 5 2851 # TemplateTest: vectors can be sized and resized - float 2852 ok {test-number} - v.size() == 5 for: 5 == 5 2853 # TemplateTest: vectors can be sized and resized - float 2854 ok {test-number} - v.capacity() >= 5 for: 5 >= 5 2855 # TemplateTest: vectors can be sized and resized - int 2856 ok {test-number} - v.size() == 5 for: 5 == 5 2857 # TemplateTest: vectors can be sized and resized - int 2858 ok {test-number} - v.capacity() >= 5 for: 5 >= 5 2859 # TemplateTest: vectors can be sized and resized - int 2860 ok {test-number} - v.size() == 10 for: 10 == 10 2861 # TemplateTest: vectors can be sized and resized - int 2862 ok {test-number} - v.capacity() >= 10 for: 10 >= 10 2863 # TemplateTest: vectors can be sized and resized - int 2864 ok {test-number} - v.size() == 5 for: 5 == 5 2865 # TemplateTest: vectors can be sized and resized - int 2866 ok {test-number} - v.capacity() >= 5 for: 5 >= 5 2867 # TemplateTest: vectors can be sized and resized - int 2868 ok {test-number} - v.size() == 0 for: 0 == 0 2869 # TemplateTest: vectors can be sized and resized - int 2870 ok {test-number} - v.capacity() >= 5 for: 5 >= 5 2871 # TemplateTest: vectors can be sized and resized - int 2872 ok {test-number} - v.capacity() == 0 for: 0 == 0 2873 # TemplateTest: vectors can be sized and resized - int 2874 ok {test-number} - v.size() == 5 for: 5 == 5 2875 # TemplateTest: vectors can be sized and resized - int 2876 ok {test-number} - v.capacity() >= 5 for: 5 >= 5 2877 # TemplateTest: vectors can be sized and resized - int 2878 ok {test-number} - v.size() == 5 for: 5 == 5 2879 # TemplateTest: vectors can be sized and resized - int 2880 ok {test-number} - v.capacity() >= 10 for: 10 >= 10 2881 # TemplateTest: vectors can be sized and resized - int 2882 ok {test-number} - v.size() == 5 for: 5 == 5 2883 # TemplateTest: vectors can be sized and resized - int 2884 ok {test-number} - v.capacity() >= 5 for: 5 >= 5 2885 # TemplateTest: vectors can be sized and resized - int 2886 ok {test-number} - v.size() == 5 for: 5 == 5 2887 # TemplateTest: vectors can be sized and resized - int 2888 ok {test-number} - v.capacity() >= 5 for: 5 >= 5 2889 # TemplateTest: vectors can be sized and resized - std::string 2890 ok {test-number} - v.size() == 5 for: 5 == 5 2891 # TemplateTest: vectors can be sized and resized - std::string 2892 ok {test-number} - v.capacity() >= 5 for: 5 >= 5 2893 # TemplateTest: vectors can be sized and resized - std::string 2894 ok {test-number} - v.size() == 10 for: 10 == 10 2895 # TemplateTest: vectors can be sized and resized - std::string 2896 ok {test-number} - v.capacity() >= 10 for: 10 >= 10 2897 # TemplateTest: vectors can be sized and resized - std::string 2898 ok {test-number} - v.size() == 5 for: 5 == 5 2899 # TemplateTest: vectors can be sized and resized - std::string 2900 ok {test-number} - v.capacity() >= 5 for: 5 >= 5 2901 # TemplateTest: vectors can be sized and resized - std::string 2902 ok {test-number} - v.size() == 0 for: 0 == 0 2903 # TemplateTest: vectors can be sized and resized - std::string 2904 ok {test-number} - v.capacity() >= 5 for: 5 >= 5 2905 # TemplateTest: vectors can be sized and resized - std::string 2906 ok {test-number} - v.capacity() == 0 for: 0 == 0 2907 # TemplateTest: vectors can be sized and resized - std::string 2908 ok {test-number} - v.size() == 5 for: 5 == 5 2909 # TemplateTest: vectors can be sized and resized - std::string 2910 ok {test-number} - v.capacity() >= 5 for: 5 >= 5 2911 # TemplateTest: vectors can be sized and resized - std::string 2912 ok {test-number} - v.size() == 5 for: 5 == 5 2913 # TemplateTest: vectors can be sized and resized - std::string 2914 ok {test-number} - v.capacity() >= 10 for: 10 >= 10 2915 # TemplateTest: vectors can be sized and resized - std::string 2916 ok {test-number} - v.size() == 5 for: 5 == 5 2917 # TemplateTest: vectors can be sized and resized - std::string 2918 ok {test-number} - v.capacity() >= 5 for: 5 >= 5 2919 # TemplateTest: vectors can be sized and resized - std::string 2920 ok {test-number} - v.size() == 5 for: 5 == 5 2921 # TemplateTest: vectors can be sized and resized - std::string 2922 ok {test-number} - v.capacity() >= 5 for: 5 >= 5 2923 # TemplateTest: vectors can be sized and resized - std::tuple<int,float> 2924 ok {test-number} - v.size() == 5 for: 5 == 5 2925 # TemplateTest: vectors can be sized and resized - std::tuple<int,float> 2926 ok {test-number} - v.capacity() >= 5 for: 5 >= 5 2927 # TemplateTest: vectors can be sized and resized - std::tuple<int,float> 2928 ok {test-number} - v.size() == 10 for: 10 == 10 2929 # TemplateTest: vectors can be sized and resized - std::tuple<int,float> 2930 ok {test-number} - v.capacity() >= 10 for: 10 >= 10 2931 # TemplateTest: vectors can be sized and resized - std::tuple<int,float> 2932 ok {test-number} - v.size() == 5 for: 5 == 5 2933 # TemplateTest: vectors can be sized and resized - std::tuple<int,float> 2934 ok {test-number} - v.capacity() >= 5 for: 5 >= 5 2935 # TemplateTest: vectors can be sized and resized - std::tuple<int,float> 2936 ok {test-number} - v.size() == 0 for: 0 == 0 2937 # TemplateTest: vectors can be sized and resized - std::tuple<int,float> 2938 ok {test-number} - v.capacity() >= 5 for: 5 >= 5 2939 # TemplateTest: vectors can be sized and resized - std::tuple<int,float> 2940 ok {test-number} - v.capacity() == 0 for: 0 == 0 2941 # TemplateTest: vectors can be sized and resized - std::tuple<int,float> 2942 ok {test-number} - v.size() == 5 for: 5 == 5 2943 # TemplateTest: vectors can be sized and resized - std::tuple<int,float> 2944 ok {test-number} - v.capacity() >= 5 for: 5 >= 5 2945 # TemplateTest: vectors can be sized and resized - std::tuple<int,float> 2946 ok {test-number} - v.size() == 5 for: 5 == 5 2947 # TemplateTest: vectors can be sized and resized - std::tuple<int,float> 2948 ok {test-number} - v.capacity() >= 10 for: 10 >= 10 2949 # TemplateTest: vectors can be sized and resized - std::tuple<int,float> 2950 ok {test-number} - v.size() == 5 for: 5 == 5 2951 # TemplateTest: vectors can be sized and resized - std::tuple<int,float> 2952 ok {test-number} - v.capacity() >= 5 for: 5 >= 5 2953 # TemplateTest: vectors can be sized and resized - std::tuple<int,float> 2954 ok {test-number} - v.size() == 5 for: 5 == 5 2955 # TemplateTest: vectors can be sized and resized - std::tuple<int,float> 2956 ok {test-number} - v.capacity() >= 5 for: 5 >= 5 2957 # TemplateTestSig: vectors can be sized and resized - (std::tuple<int, float>), 6 2958 ok {test-number} - v.size() == V for: 6 == 6 2959 # TemplateTestSig: vectors can be sized and resized - (std::tuple<int, float>), 6 2960 ok {test-number} - v.capacity() >= V for: 6 >= 6 2961 # TemplateTestSig: vectors can be sized and resized - (std::tuple<int, float>), 6 2962 ok {test-number} - v.size() == 2 * V for: 12 == 12 2963 # TemplateTestSig: vectors can be sized and resized - (std::tuple<int, float>), 6 2964 ok {test-number} - v.capacity() >= 2 * V for: 12 >= 12 2965 # TemplateTestSig: vectors can be sized and resized - (std::tuple<int, float>), 6 2966 ok {test-number} - v.size() == V for: 6 == 6 2967 # TemplateTestSig: vectors can be sized and resized - (std::tuple<int, float>), 6 2968 ok {test-number} - v.capacity() >= V for: 6 >= 6 2969 # TemplateTestSig: vectors can be sized and resized - (std::tuple<int, float>), 6 2970 ok {test-number} - v.size() == 0 for: 0 == 0 2971 # TemplateTestSig: vectors can be sized and resized - (std::tuple<int, float>), 6 2972 ok {test-number} - v.capacity() >= V for: 6 >= 6 2973 # TemplateTestSig: vectors can be sized and resized - (std::tuple<int, float>), 6 2974 ok {test-number} - v.capacity() == 0 for: 0 == 0 2975 # TemplateTestSig: vectors can be sized and resized - (std::tuple<int, float>), 6 2976 ok {test-number} - v.size() == V for: 6 == 6 2977 # TemplateTestSig: vectors can be sized and resized - (std::tuple<int, float>), 6 2978 ok {test-number} - v.capacity() >= V for: 6 >= 6 2979 # TemplateTestSig: vectors can be sized and resized - (std::tuple<int, float>), 6 2980 ok {test-number} - v.size() == V for: 6 == 6 2981 # TemplateTestSig: vectors can be sized and resized - (std::tuple<int, float>), 6 2982 ok {test-number} - v.capacity() >= 2 * V for: 12 >= 12 2983 # TemplateTestSig: vectors can be sized and resized - (std::tuple<int, float>), 6 2984 ok {test-number} - v.size() == V for: 6 == 6 2985 # TemplateTestSig: vectors can be sized and resized - (std::tuple<int, float>), 6 2986 ok {test-number} - v.capacity() >= V for: 6 >= 6 2987 # TemplateTestSig: vectors can be sized and resized - (std::tuple<int, float>), 6 2988 ok {test-number} - v.size() == V for: 6 == 6 2989 # TemplateTestSig: vectors can be sized and resized - (std::tuple<int, float>), 6 2990 ok {test-number} - v.capacity() >= V for: 6 >= 6 2991 # TemplateTestSig: vectors can be sized and resized - float,4 2992 ok {test-number} - v.size() == V for: 4 == 4 2993 # TemplateTestSig: vectors can be sized and resized - float,4 2994 ok {test-number} - v.capacity() >= V for: 4 >= 4 2995 # TemplateTestSig: vectors can be sized and resized - float,4 2996 ok {test-number} - v.size() == 2 * V for: 8 == 8 2997 # TemplateTestSig: vectors can be sized and resized - float,4 2998 ok {test-number} - v.capacity() >= 2 * V for: 8 >= 8 2999 # TemplateTestSig: vectors can be sized and resized - float,4 3000 ok {test-number} - v.size() == V for: 4 == 4 3001 # TemplateTestSig: vectors can be sized and resized - float,4 3002 ok {test-number} - v.capacity() >= V for: 4 >= 4 3003 # TemplateTestSig: vectors can be sized and resized - float,4 3004 ok {test-number} - v.size() == 0 for: 0 == 0 3005 # TemplateTestSig: vectors can be sized and resized - float,4 3006 ok {test-number} - v.capacity() >= V for: 4 >= 4 3007 # TemplateTestSig: vectors can be sized and resized - float,4 3008 ok {test-number} - v.capacity() == 0 for: 0 == 0 3009 # TemplateTestSig: vectors can be sized and resized - float,4 3010 ok {test-number} - v.size() == V for: 4 == 4 3011 # TemplateTestSig: vectors can be sized and resized - float,4 3012 ok {test-number} - v.capacity() >= V for: 4 >= 4 3013 # TemplateTestSig: vectors can be sized and resized - float,4 3014 ok {test-number} - v.size() == V for: 4 == 4 3015 # TemplateTestSig: vectors can be sized and resized - float,4 3016 ok {test-number} - v.capacity() >= 2 * V for: 8 >= 8 3017 # TemplateTestSig: vectors can be sized and resized - float,4 3018 ok {test-number} - v.size() == V for: 4 == 4 3019 # TemplateTestSig: vectors can be sized and resized - float,4 3020 ok {test-number} - v.capacity() >= V for: 4 >= 4 3021 # TemplateTestSig: vectors can be sized and resized - float,4 3022 ok {test-number} - v.size() == V for: 4 == 4 3023 # TemplateTestSig: vectors can be sized and resized - float,4 3024 ok {test-number} - v.capacity() >= V for: 4 >= 4 3025 # TemplateTestSig: vectors can be sized and resized - int,5 3026 ok {test-number} - v.size() == V for: 5 == 5 3027 # TemplateTestSig: vectors can be sized and resized - int,5 3028 ok {test-number} - v.capacity() >= V for: 5 >= 5 3029 # TemplateTestSig: vectors can be sized and resized - int,5 3030 ok {test-number} - v.size() == 2 * V for: 10 == 10 3031 # TemplateTestSig: vectors can be sized and resized - int,5 3032 ok {test-number} - v.capacity() >= 2 * V for: 10 >= 10 3033 # TemplateTestSig: vectors can be sized and resized - int,5 3034 ok {test-number} - v.size() == V for: 5 == 5 3035 # TemplateTestSig: vectors can be sized and resized - int,5 3036 ok {test-number} - v.capacity() >= V for: 5 >= 5 3037 # TemplateTestSig: vectors can be sized and resized - int,5 3038 ok {test-number} - v.size() == 0 for: 0 == 0 3039 # TemplateTestSig: vectors can be sized and resized - int,5 3040 ok {test-number} - v.capacity() >= V for: 5 >= 5 3041 # TemplateTestSig: vectors can be sized and resized - int,5 3042 ok {test-number} - v.capacity() == 0 for: 0 == 0 3043 # TemplateTestSig: vectors can be sized and resized - int,5 3044 ok {test-number} - v.size() == V for: 5 == 5 3045 # TemplateTestSig: vectors can be sized and resized - int,5 3046 ok {test-number} - v.capacity() >= V for: 5 >= 5 3047 # TemplateTestSig: vectors can be sized and resized - int,5 3048 ok {test-number} - v.size() == V for: 5 == 5 3049 # TemplateTestSig: vectors can be sized and resized - int,5 3050 ok {test-number} - v.capacity() >= 2 * V for: 10 >= 10 3051 # TemplateTestSig: vectors can be sized and resized - int,5 3052 ok {test-number} - v.size() == V for: 5 == 5 3053 # TemplateTestSig: vectors can be sized and resized - int,5 3054 ok {test-number} - v.capacity() >= V for: 5 >= 5 3055 # TemplateTestSig: vectors can be sized and resized - int,5 3056 ok {test-number} - v.size() == V for: 5 == 5 3057 # TemplateTestSig: vectors can be sized and resized - int,5 3058 ok {test-number} - v.capacity() >= V for: 5 >= 5 3059 # TemplateTestSig: vectors can be sized and resized - std::string,15 3060 ok {test-number} - v.size() == V for: 15 == 15 3061 # TemplateTestSig: vectors can be sized and resized - std::string,15 3062 ok {test-number} - v.capacity() >= V for: 15 >= 15 3063 # TemplateTestSig: vectors can be sized and resized - std::string,15 3064 ok {test-number} - v.size() == 2 * V for: 30 == 30 3065 # TemplateTestSig: vectors can be sized and resized - std::string,15 3066 ok {test-number} - v.capacity() >= 2 * V for: 30 >= 30 3067 # TemplateTestSig: vectors can be sized and resized - std::string,15 3068 ok {test-number} - v.size() == V for: 15 == 15 3069 # TemplateTestSig: vectors can be sized and resized - std::string,15 3070 ok {test-number} - v.capacity() >= V for: 15 >= 15 3071 # TemplateTestSig: vectors can be sized and resized - std::string,15 3072 ok {test-number} - v.size() == 0 for: 0 == 0 3073 # TemplateTestSig: vectors can be sized and resized - std::string,15 3074 ok {test-number} - v.capacity() >= V for: 15 >= 15 3075 # TemplateTestSig: vectors can be sized and resized - std::string,15 3076 ok {test-number} - v.capacity() == 0 for: 0 == 0 3077 # TemplateTestSig: vectors can be sized and resized - std::string,15 3078 ok {test-number} - v.size() == V for: 15 == 15 3079 # TemplateTestSig: vectors can be sized and resized - std::string,15 3080 ok {test-number} - v.capacity() >= V for: 15 >= 15 3081 # TemplateTestSig: vectors can be sized and resized - std::string,15 3082 ok {test-number} - v.size() == V for: 15 == 15 3083 # TemplateTestSig: vectors can be sized and resized - std::string,15 3084 ok {test-number} - v.capacity() >= 2 * V for: 30 >= 30 3085 # TemplateTestSig: vectors can be sized and resized - std::string,15 3086 ok {test-number} - v.size() == V for: 15 == 15 3087 # TemplateTestSig: vectors can be sized and resized - std::string,15 3088 ok {test-number} - v.capacity() >= V for: 15 >= 15 3089 # TemplateTestSig: vectors can be sized and resized - std::string,15 3090 ok {test-number} - v.size() == V for: 15 == 15 3091 # TemplateTestSig: vectors can be sized and resized - std::string,15 3092 ok {test-number} - v.capacity() >= V for: 15 >= 15 3093 # Test case with identical tags keeps just one 3094 ok {test-number} - testCase.tags.size() == 1 for: 1 == 1 3095 # Test case with identical tags keeps just one 3096 ok {test-number} - testCase.tags[0] == Tag( "tag1" ) for: {?} == {?} 3097 # Test case with one argument 3098 ok {test-number} - with 1 message: 'no assertions' 3099 # Test enum bit values 3100 ok {test-number} - 0x<hex digits> == bit30and31 for: 3221225472 (0x<hex digits>) == 3221225472 3101 # Test with special, characters "in name 3102 ok {test-number} - 3103 # Testing checked-if 3104 ok {test-number} - true 3105 # Testing checked-if 3106 ok {test-number} - 3107 # Testing checked-if 3108 ok {test-number} - false # TODO 3109 # Testing checked-if 3110 ok {test-number} - true 3111 # Testing checked-if 3112 ok {test-number} - false # TODO 3113 # Testing checked-if 3114 ok {test-number} - 3115 # Testing checked-if 2 3116 ok {test-number} - true 3117 # Testing checked-if 2 3118 not ok {test-number} - explicitly 3119 # Testing checked-if 3 3120 ok {test-number} - false # TODO 3121 # Testing checked-if 3 3122 not ok {test-number} - explicitly 3123 # Testing checked-if 4 3124 ok {test-number} - true 3125 # Testing checked-if 4 3126 not ok {test-number} - unexpected exception with message: 'Uncaught exception should fail!'; expression was: {Unknown expression after the reported line} 3127 # Testing checked-if 5 3128 ok {test-number} - false # TODO 3129 # Testing checked-if 5 3130 not ok {test-number} - unexpected exception with message: 'Uncaught exception should fail!'; expression was: {Unknown expression after the reported line} 3131 # The NO_FAIL macro reports a failure but does not fail the test 3132 ok {test-number} - 1 == 2 # TODO 3133 # The default listing implementation write to provided stream 3134 ok {test-number} - listingString, ContainsSubstring("[fakeTag]"s) for: "All available tags: 1 [fakeTag] 1 tag " contains: "[fakeTag]" 3135 # The default listing implementation write to provided stream 3136 ok {test-number} - listingString, ContainsSubstring( "fake reporter"s ) && ContainsSubstring( "fake description"s ) for: "Available reporters: fake reporter: fake description " ( contains: "fake reporter" and contains: "fake description" ) 3137 # The default listing implementation write to provided stream 3138 ok {test-number} - listingString, ContainsSubstring( "fake test name"s ) && ContainsSubstring( "fakeTestTag"s ) for: "All available test cases: fake test name [fakeTestTag] 1 test case " ( contains: "fake test name" and contains: "fakeTestTag" ) 3139 # The default listing implementation write to provided stream 3140 ok {test-number} - listingString, ContainsSubstring( "fakeListener"s ) && ContainsSubstring( "fake description"s ) for: "Registered listeners: fakeListener: fake description " ( contains: "fakeListener" and contains: "fake description" ) 3141 # This test 'should' fail but doesn't 3142 ok {test-number} - with 1 message: 'oops!' 3143 # Thrown string literals are translated 3144 not ok {test-number} - unexpected exception with message: 'For some reason someone is throwing a string literal!' 3145 # Tracker 3146 ok {test-number} - testCase.isOpen() for: true 3147 # Tracker 3148 ok {test-number} - s1.isOpen() for: true 3149 # Tracker 3150 ok {test-number} - s1.isSuccessfullyCompleted() for: true 3151 # Tracker 3152 ok {test-number} - testCase.isComplete() == false for: false == false 3153 # Tracker 3154 ok {test-number} - ctx.completedCycle() for: true 3155 # Tracker 3156 ok {test-number} - testCase.isSuccessfullyCompleted() for: true 3157 # Tracker 3158 ok {test-number} - testCase.isOpen() for: true 3159 # Tracker 3160 ok {test-number} - s1.isOpen() for: true 3161 # Tracker 3162 ok {test-number} - s1.isComplete() for: true 3163 # Tracker 3164 ok {test-number} - s1.isSuccessfullyCompleted() == false for: false == false 3165 # Tracker 3166 ok {test-number} - testCase.isComplete() == false for: false == false 3167 # Tracker 3168 ok {test-number} - ctx.completedCycle() for: true 3169 # Tracker 3170 ok {test-number} - testCase.isSuccessfullyCompleted() == false for: false == false 3171 # Tracker 3172 ok {test-number} - testCase2.isOpen() for: true 3173 # Tracker 3174 ok {test-number} - s1b.isOpen() == false for: false == false 3175 # Tracker 3176 ok {test-number} - ctx.completedCycle() for: true 3177 # Tracker 3178 ok {test-number} - testCase.isComplete() for: true 3179 # Tracker 3180 ok {test-number} - testCase.isSuccessfullyCompleted() for: true 3181 # Tracker 3182 ok {test-number} - testCase.isOpen() for: true 3183 # Tracker 3184 ok {test-number} - s1.isOpen() for: true 3185 # Tracker 3186 ok {test-number} - s1.isComplete() for: true 3187 # Tracker 3188 ok {test-number} - s1.isSuccessfullyCompleted() == false for: false == false 3189 # Tracker 3190 ok {test-number} - testCase.isComplete() == false for: false == false 3191 # Tracker 3192 ok {test-number} - ctx.completedCycle() for: true 3193 # Tracker 3194 ok {test-number} - testCase.isSuccessfullyCompleted() == false for: false == false 3195 # Tracker 3196 ok {test-number} - testCase2.isOpen() for: true 3197 # Tracker 3198 ok {test-number} - s1b.isOpen() == false for: false == false 3199 # Tracker 3200 ok {test-number} - s2.isOpen() for: true 3201 # Tracker 3202 ok {test-number} - ctx.completedCycle() for: true 3203 # Tracker 3204 ok {test-number} - testCase.isComplete() for: true 3205 # Tracker 3206 ok {test-number} - testCase.isSuccessfullyCompleted() for: true 3207 # Tracker 3208 ok {test-number} - testCase.isOpen() for: true 3209 # Tracker 3210 ok {test-number} - s1.isOpen() for: true 3211 # Tracker 3212 ok {test-number} - s2.isOpen() == false for: false == false 3213 # Tracker 3214 ok {test-number} - testCase.isComplete() == false for: false == false 3215 # Tracker 3216 ok {test-number} - testCase2.isOpen() for: true 3217 # Tracker 3218 ok {test-number} - s1b.isOpen() == false for: false == false 3219 # Tracker 3220 ok {test-number} - s2b.isOpen() for: true 3221 # Tracker 3222 ok {test-number} - ctx.completedCycle() == false for: false == false 3223 # Tracker 3224 ok {test-number} - ctx.completedCycle() for: true 3225 # Tracker 3226 ok {test-number} - s2b.isSuccessfullyCompleted() for: true 3227 # Tracker 3228 ok {test-number} - testCase2.isComplete() == false for: false == false 3229 # Tracker 3230 ok {test-number} - testCase2.isSuccessfullyCompleted() for: true 3231 # Tracker 3232 ok {test-number} - testCase.isOpen() for: true 3233 # Tracker 3234 ok {test-number} - s1.isOpen() for: true 3235 # Tracker 3236 ok {test-number} - s2.isOpen() == false for: false == false 3237 # Tracker 3238 ok {test-number} - testCase.isComplete() == false for: false == false 3239 # Tracker 3240 ok {test-number} - testCase2.isOpen() for: true 3241 # Tracker 3242 ok {test-number} - s1b.isOpen() == false for: false == false 3243 # Tracker 3244 ok {test-number} - s2b.isOpen() for: true 3245 # Tracker 3246 ok {test-number} - ctx.completedCycle() == false for: false == false 3247 # Tracker 3248 ok {test-number} - ctx.completedCycle() for: true 3249 # Tracker 3250 ok {test-number} - s2b.isComplete() for: true 3251 # Tracker 3252 ok {test-number} - s2b.isSuccessfullyCompleted() == false for: false == false 3253 # Tracker 3254 ok {test-number} - testCase2.isSuccessfullyCompleted() == false for: false == false 3255 # Tracker 3256 ok {test-number} - testCase3.isOpen() for: true 3257 # Tracker 3258 ok {test-number} - s1c.isOpen() == false for: false == false 3259 # Tracker 3260 ok {test-number} - s2c.isOpen() == false for: false == false 3261 # Tracker 3262 ok {test-number} - testCase3.isSuccessfullyCompleted() for: true 3263 # Tracker 3264 ok {test-number} - testCase.isOpen() for: true 3265 # Tracker 3266 ok {test-number} - s1.isOpen() for: true 3267 # Tracker 3268 ok {test-number} - s2.isOpen() for: true 3269 # Tracker 3270 ok {test-number} - s2.isComplete() for: true 3271 # Tracker 3272 ok {test-number} - s1.isComplete() == false for: false == false 3273 # Tracker 3274 ok {test-number} - s1.isComplete() for: true 3275 # Tracker 3276 ok {test-number} - testCase.isComplete() == false for: false == false 3277 # Tracker 3278 ok {test-number} - testCase.isComplete() for: true 3279 # Trim strings 3280 ok {test-number} - trim(std::string(no_whitespace)) == no_whitespace for: "There is no extra whitespace here" == "There is no extra whitespace here" 3281 # Trim strings 3282 ok {test-number} - trim(std::string(leading_whitespace)) == no_whitespace for: "There is no extra whitespace here" == "There is no extra whitespace here" 3283 # Trim strings 3284 ok {test-number} - trim(std::string(trailing_whitespace)) == no_whitespace for: "There is no extra whitespace here" == "There is no extra whitespace here" 3285 # Trim strings 3286 ok {test-number} - trim(std::string(whitespace_at_both_ends)) == no_whitespace for: "There is no extra whitespace here" == "There is no extra whitespace here" 3287 # Trim strings 3288 ok {test-number} - trim(StringRef(no_whitespace)) == StringRef(no_whitespace) for: There is no extra whitespace here == There is no extra whitespace here 3289 # Trim strings 3290 ok {test-number} - trim(StringRef(leading_whitespace)) == StringRef(no_whitespace) for: There is no extra whitespace here == There is no extra whitespace here 3291 # Trim strings 3292 ok {test-number} - trim(StringRef(trailing_whitespace)) == StringRef(no_whitespace) for: There is no extra whitespace here == There is no extra whitespace here 3293 # Trim strings 3294 ok {test-number} - trim(StringRef(whitespace_at_both_ends)) == StringRef(no_whitespace) for: There is no extra whitespace here == There is no extra whitespace here 3295 # Type conversions of RangeEquals and similar 3296 ok {test-number} - array_int_a, RangeEquals( c_array ) for: { 1, 2, 3 } elements are { 1, 2, 3 } 3297 # Type conversions of RangeEquals and similar 3298 ok {test-number} - array_int_a, UnorderedRangeEquals( c_array ) for: { 1, 2, 3 } unordered elements are { 1, 2, 3 } 3299 # Type conversions of RangeEquals and similar 3300 ok {test-number} - array_int_3, !RangeEquals( array_int_4 ) for: { 1, 2, 3 } not elements are { 1, 2, 3, 4 } 3301 # Type conversions of RangeEquals and similar 3302 ok {test-number} - array_int_3, !UnorderedRangeEquals( array_int_4 ) for: { 1, 2, 3 } not unordered elements are { 1, 2, 3, 4 } 3303 # Type conversions of RangeEquals and similar 3304 ok {test-number} - array_int_a, RangeEquals( vector_char_a ) for: { 1, 2, 3 } elements are { 1, 2, 3 } 3305 # Type conversions of RangeEquals and similar 3306 ok {test-number} - array_int_a, UnorderedRangeEquals( vector_char_a ) for: { 1, 2, 3 } unordered elements are { 1, 2, 3 } 3307 # Type conversions of RangeEquals and similar 3308 ok {test-number} - with 1 message: 'ContainerIsRandomAccess( array_int_a ) != ContainerIsRandomAccess( list_char_a )' 3309 # Type conversions of RangeEquals and similar 3310 ok {test-number} - array_int_a, RangeEquals( list_char_a ) for: { 1, 2, 3 } elements are { 1, 2, 3 } 3311 # Type conversions of RangeEquals and similar 3312 ok {test-number} - array_int_a, UnorderedRangeEquals( list_char_a ) for: { 1, 2, 3 } unordered elements are { 1, 2, 3 } 3313 # Type conversions of RangeEquals and similar 3314 ok {test-number} - vector_int_a, RangeEquals( vector_char_a ) for: { 1, 2, 3 } elements are { 1, 2, 3 } 3315 # Type conversions of RangeEquals and similar 3316 ok {test-number} - vector_int_a, UnorderedRangeEquals( vector_char_a ) for: { 1, 2, 3 } unordered elements are { 1, 2, 3 } 3317 # Type conversions of RangeEquals and similar 3318 ok {test-number} - vector_int_a, !RangeEquals( vector_char_b ) for: { 1, 2, 3 } not elements are { 1, 2, 2 } 3319 # Type conversions of RangeEquals and similar 3320 ok {test-number} - vector_int_a, !UnorderedRangeEquals( vector_char_b ) for: { 1, 2, 3 } not unordered elements are { 1, 2, 2 } 3321 # Type conversions of RangeEquals and similar 3322 ok {test-number} - a, !RangeEquals( b ) for: { 1, 2, 3 } not elements are { 3, 2, 1 } 3323 # Type conversions of RangeEquals and similar 3324 ok {test-number} - a, UnorderedRangeEquals( b ) for: { 1, 2, 3 } unordered elements are { 3, 2, 1 } 3325 # Type conversions of RangeEquals and similar 3326 ok {test-number} - vector_a, RangeEquals( array_a_plus_1, close_enough ) for: { 1, 2, 3 } elements are { 2, 3, 4 } 3327 # Type conversions of RangeEquals and similar 3328 ok {test-number} - vector_a, UnorderedRangeEquals( array_a_plus_1, close_enough ) for: { 1, 2, 3 } unordered elements are { 2, 3, 4 } 3329 # Unexpected exceptions can be translated 3330 not ok {test-number} - unexpected exception with message: '3.14' 3331 # Upcasting special member functions 3332 ok {test-number} - bptr->i == 3 for: 3 == 3 3333 # Upcasting special member functions 3334 ok {test-number} - bptr->i == 3 for: 3 == 3 3335 # Usage of AllMatch range matcher 3336 ok {test-number} - data, AllMatch(SizeIs(5)) for: { { 0, 1, 2, 3, 5 }, { 4, -3, -2, 5, 0 }, { 0, 0, 0, 5, 0 }, { 0, -5, 0, 5, 0 }, { 1, 0, 0, -1, 5 } } all match has size == 5 3337 # Usage of AllMatch range matcher 3338 ok {test-number} - data, !AllMatch(Contains(0) && Contains(1)) for: { { 0, 1, 2, 3, 5 }, { 4, -3, -2, 5, 0 }, { 0, 0, 0, 5, 0 }, { 0, -5, 0, 5, 0 }, { 1, 0, 0, -1, 5 } } not all match ( contains element 0 and contains element 1 ) 3339 # Usage of AllMatch range matcher 3340 ok {test-number} - needs_adl, AllMatch( Predicate<int>( []( int elem ) { return elem < 6; } ) ) for: { 1, 2, 3, 4, 5 } all match matches undescribed predicate 3341 # Usage of AllMatch range matcher 3342 ok {test-number} - mocked, allMatch for: { 1, 2, 3, 4, 5 } all match matches undescribed predicate 3343 # Usage of AllMatch range matcher 3344 ok {test-number} - mocked.m_derefed[0] for: true 3345 # Usage of AllMatch range matcher 3346 ok {test-number} - mocked.m_derefed[1] for: true 3347 # Usage of AllMatch range matcher 3348 ok {test-number} - mocked.m_derefed[2] for: true 3349 # Usage of AllMatch range matcher 3350 ok {test-number} - mocked.m_derefed[3] for: true 3351 # Usage of AllMatch range matcher 3352 ok {test-number} - mocked.m_derefed[4] for: true 3353 # Usage of AllMatch range matcher 3354 ok {test-number} - mocked, !allMatch for: { 1, 2, 3, 4, 5 } not all match matches undescribed predicate 3355 # Usage of AllMatch range matcher 3356 ok {test-number} - mocked.m_derefed[0] for: true 3357 # Usage of AllMatch range matcher 3358 ok {test-number} - mocked.m_derefed[1] for: true 3359 # Usage of AllMatch range matcher 3360 ok {test-number} - mocked.m_derefed[2] for: true 3361 # Usage of AllMatch range matcher 3362 ok {test-number} - !(mocked.m_derefed[3]) for: !false 3363 # Usage of AllMatch range matcher 3364 ok {test-number} - !(mocked.m_derefed[4]) for: !false 3365 # Usage of AllTrue range matcher 3366 ok {test-number} - data, AllTrue() for: { true, true, true, true, true } contains only true 3367 # Usage of AllTrue range matcher 3368 ok {test-number} - data, AllTrue() for: { } contains only true 3369 # Usage of AllTrue range matcher 3370 ok {test-number} - data, !AllTrue() for: { true, true, false, true, true } not contains only true 3371 # Usage of AllTrue range matcher 3372 ok {test-number} - data, !AllTrue() for: { false, false, false, false, false } not contains only true 3373 # Usage of AllTrue range matcher 3374 ok {test-number} - data, AllTrue() for: { true, true, true, true, true } contains only true 3375 # Usage of AllTrue range matcher 3376 ok {test-number} - data, !AllTrue() for: { true, true, false, true, true } not contains only true 3377 # Usage of AllTrue range matcher 3378 ok {test-number} - data, !AllTrue() for: { false, false, false, false, false } not contains only true 3379 # Usage of AllTrue range matcher 3380 ok {test-number} - mocked, AllTrue() for: { true, true, true, true, true } contains only true 3381 # Usage of AllTrue range matcher 3382 ok {test-number} - mocked.m_derefed[0] for: true 3383 # Usage of AllTrue range matcher 3384 ok {test-number} - mocked.m_derefed[1] for: true 3385 # Usage of AllTrue range matcher 3386 ok {test-number} - mocked.m_derefed[2] for: true 3387 # Usage of AllTrue range matcher 3388 ok {test-number} - mocked.m_derefed[3] for: true 3389 # Usage of AllTrue range matcher 3390 ok {test-number} - mocked.m_derefed[4] for: true 3391 # Usage of AllTrue range matcher 3392 ok {test-number} - mocked, !AllTrue() for: { true, true, false, true, true } not contains only true 3393 # Usage of AllTrue range matcher 3394 ok {test-number} - mocked.m_derefed[0] for: true 3395 # Usage of AllTrue range matcher 3396 ok {test-number} - mocked.m_derefed[1] for: true 3397 # Usage of AllTrue range matcher 3398 ok {test-number} - mocked.m_derefed[2] for: true 3399 # Usage of AllTrue range matcher 3400 ok {test-number} - !(mocked.m_derefed[3]) for: !false 3401 # Usage of AllTrue range matcher 3402 ok {test-number} - !(mocked.m_derefed[4]) for: !false 3403 # Usage of AnyMatch range matcher 3404 ok {test-number} - data, AnyMatch(SizeIs(5)) for: { { 0, 1, 2, 3, 5 }, { 4, -3, -2, 5, 0 }, { 0, 0, 0, 5, 0 }, { 0, -5, 0, 5, 0 }, { 1, 0, 0, -1, 5 } } any match has size == 5 3405 # Usage of AnyMatch range matcher 3406 ok {test-number} - data, !AnyMatch(Contains(0) && Contains(10)) for: { { 0, 1, 2, 3, 5 }, { 4, -3, -2, 5, 0 }, { 0, 0, 0, 5, 0 }, { 0, -5, 0, 5, 0 }, { 1, 0, 0, -1, 5 } } not any match ( contains element 0 and contains element 10 ) 3407 # Usage of AnyMatch range matcher 3408 ok {test-number} - needs_adl, AnyMatch( Predicate<int>( []( int elem ) { return elem < 3; } ) ) for: { 1, 2, 3, 4, 5 } any match matches undescribed predicate 3409 # Usage of AnyMatch range matcher 3410 ok {test-number} - mocked, !anyMatch for: { 1, 2, 3, 4, 5 } not any match matches undescribed predicate 3411 # Usage of AnyMatch range matcher 3412 ok {test-number} - mocked.m_derefed[0] for: true 3413 # Usage of AnyMatch range matcher 3414 ok {test-number} - mocked.m_derefed[1] for: true 3415 # Usage of AnyMatch range matcher 3416 ok {test-number} - mocked.m_derefed[2] for: true 3417 # Usage of AnyMatch range matcher 3418 ok {test-number} - mocked.m_derefed[3] for: true 3419 # Usage of AnyMatch range matcher 3420 ok {test-number} - mocked.m_derefed[4] for: true 3421 # Usage of AnyMatch range matcher 3422 ok {test-number} - mocked, anyMatch for: { 1, 2, 3, 4, 5 } any match matches undescribed predicate 3423 # Usage of AnyMatch range matcher 3424 ok {test-number} - mocked.m_derefed[0] for: true 3425 # Usage of AnyMatch range matcher 3426 ok {test-number} - !(mocked.m_derefed[1]) for: !false 3427 # Usage of AnyMatch range matcher 3428 ok {test-number} - !(mocked.m_derefed[2]) for: !false 3429 # Usage of AnyMatch range matcher 3430 ok {test-number} - !(mocked.m_derefed[3]) for: !false 3431 # Usage of AnyMatch range matcher 3432 ok {test-number} - !(mocked.m_derefed[4]) for: !false 3433 # Usage of AnyTrue range matcher 3434 ok {test-number} - data, AnyTrue() for: { true, true, true, true, true } contains at least one true 3435 # Usage of AnyTrue range matcher 3436 ok {test-number} - data, !AnyTrue() for: { } not contains at least one true 3437 # Usage of AnyTrue range matcher 3438 ok {test-number} - data, AnyTrue() for: { false, false, true, false, false } contains at least one true 3439 # Usage of AnyTrue range matcher 3440 ok {test-number} - data, !AnyTrue() for: { false, false, false, false, false } not contains at least one true 3441 # Usage of AnyTrue range matcher 3442 ok {test-number} - data, AnyTrue() for: { true, true, true, true, true } contains at least one true 3443 # Usage of AnyTrue range matcher 3444 ok {test-number} - data, AnyTrue() for: { false, false, true, false, false } contains at least one true 3445 # Usage of AnyTrue range matcher 3446 ok {test-number} - data, !AnyTrue() for: { false, false, false, false, false } not contains at least one true 3447 # Usage of AnyTrue range matcher 3448 ok {test-number} - mocked, AnyTrue() for: { false, false, false, false, true } contains at least one true 3449 # Usage of AnyTrue range matcher 3450 ok {test-number} - mocked.m_derefed[0] for: true 3451 # Usage of AnyTrue range matcher 3452 ok {test-number} - mocked.m_derefed[1] for: true 3453 # Usage of AnyTrue range matcher 3454 ok {test-number} - mocked.m_derefed[2] for: true 3455 # Usage of AnyTrue range matcher 3456 ok {test-number} - mocked.m_derefed[3] for: true 3457 # Usage of AnyTrue range matcher 3458 ok {test-number} - mocked.m_derefed[4] for: true 3459 # Usage of AnyTrue range matcher 3460 ok {test-number} - mocked, AnyTrue() for: { false, false, true, true, true } contains at least one true 3461 # Usage of AnyTrue range matcher 3462 ok {test-number} - mocked.m_derefed[0] for: true 3463 # Usage of AnyTrue range matcher 3464 ok {test-number} - mocked.m_derefed[1] for: true 3465 # Usage of AnyTrue range matcher 3466 ok {test-number} - mocked.m_derefed[2] for: true 3467 # Usage of AnyTrue range matcher 3468 ok {test-number} - !(mocked.m_derefed[3]) for: !false 3469 # Usage of AnyTrue range matcher 3470 ok {test-number} - !(mocked.m_derefed[4]) for: !false 3471 # Usage of NoneMatch range matcher 3472 ok {test-number} - data, NoneMatch(SizeIs(6)) for: { { 0, 1, 2, 3, 5 }, { 4, -3, -2, 5, 0 }, { 0, 0, 0, 5, 0 }, { 0, -5, 0, 5, 0 }, { 1, 0, 0, -1, 5 } } none match has size == 6 3473 # Usage of NoneMatch range matcher 3474 ok {test-number} - data, !NoneMatch(Contains(0) && Contains(1)) for: { { 0, 1, 2, 3, 5 }, { 4, -3, -2, 5, 0 }, { 0, 0, 0, 5, 0 }, { 0, -5, 0, 5, 0 }, { 1, 0, 0, -1, 5 } } not none match ( contains element 0 and contains element 1 ) 3475 # Usage of NoneMatch range matcher 3476 ok {test-number} - needs_adl, NoneMatch( Predicate<int>( []( int elem ) { return elem > 6; } ) ) for: { 1, 2, 3, 4, 5 } none match matches undescribed predicate 3477 # Usage of NoneMatch range matcher 3478 ok {test-number} - mocked, noneMatch for: { 1, 2, 3, 4, 5 } none match matches undescribed predicate 3479 # Usage of NoneMatch range matcher 3480 ok {test-number} - mocked.m_derefed[0] for: true 3481 # Usage of NoneMatch range matcher 3482 ok {test-number} - mocked.m_derefed[1] for: true 3483 # Usage of NoneMatch range matcher 3484 ok {test-number} - mocked.m_derefed[2] for: true 3485 # Usage of NoneMatch range matcher 3486 ok {test-number} - mocked.m_derefed[3] for: true 3487 # Usage of NoneMatch range matcher 3488 ok {test-number} - mocked.m_derefed[4] for: true 3489 # Usage of NoneMatch range matcher 3490 ok {test-number} - mocked, !noneMatch for: { 1, 2, 3, 4, 5 } not none match matches undescribed predicate 3491 # Usage of NoneMatch range matcher 3492 ok {test-number} - mocked.m_derefed[0] for: true 3493 # Usage of NoneMatch range matcher 3494 ok {test-number} - !(mocked.m_derefed[1]) for: !false 3495 # Usage of NoneMatch range matcher 3496 ok {test-number} - !(mocked.m_derefed[2]) for: !false 3497 # Usage of NoneMatch range matcher 3498 ok {test-number} - !(mocked.m_derefed[3]) for: !false 3499 # Usage of NoneMatch range matcher 3500 ok {test-number} - !(mocked.m_derefed[4]) for: !false 3501 # Usage of NoneTrue range matcher 3502 ok {test-number} - data, !NoneTrue() for: { true, true, true, true, true } not contains no true 3503 # Usage of NoneTrue range matcher 3504 ok {test-number} - data, NoneTrue() for: { } contains no true 3505 # Usage of NoneTrue range matcher 3506 ok {test-number} - data, !NoneTrue() for: { false, false, true, false, false } not contains no true 3507 # Usage of NoneTrue range matcher 3508 ok {test-number} - data, NoneTrue() for: { false, false, false, false, false } contains no true 3509 # Usage of NoneTrue range matcher 3510 ok {test-number} - data, !NoneTrue() for: { true, true, true, true, true } not contains no true 3511 # Usage of NoneTrue range matcher 3512 ok {test-number} - data, !NoneTrue() for: { false, false, true, false, false } not contains no true 3513 # Usage of NoneTrue range matcher 3514 ok {test-number} - data, NoneTrue() for: { false, false, false, false, false } contains no true 3515 # Usage of NoneTrue range matcher 3516 ok {test-number} - mocked, NoneTrue() for: { false, false, false, false, false } contains no true 3517 # Usage of NoneTrue range matcher 3518 ok {test-number} - mocked.m_derefed[0] for: true 3519 # Usage of NoneTrue range matcher 3520 ok {test-number} - mocked.m_derefed[1] for: true 3521 # Usage of NoneTrue range matcher 3522 ok {test-number} - mocked.m_derefed[2] for: true 3523 # Usage of NoneTrue range matcher 3524 ok {test-number} - mocked.m_derefed[3] for: true 3525 # Usage of NoneTrue range matcher 3526 ok {test-number} - mocked.m_derefed[4] for: true 3527 # Usage of NoneTrue range matcher 3528 ok {test-number} - mocked, !NoneTrue() for: { false, false, true, true, true } not contains no true 3529 # Usage of NoneTrue range matcher 3530 ok {test-number} - mocked.m_derefed[0] for: true 3531 # Usage of NoneTrue range matcher 3532 ok {test-number} - mocked.m_derefed[1] for: true 3533 # Usage of NoneTrue range matcher 3534 ok {test-number} - mocked.m_derefed[2] for: true 3535 # Usage of NoneTrue range matcher 3536 ok {test-number} - !(mocked.m_derefed[3]) for: !false 3537 # Usage of NoneTrue range matcher 3538 ok {test-number} - !(mocked.m_derefed[4]) for: !false 3539 # Usage of RangeEquals range matcher 3540 ok {test-number} - empty_vector, RangeEquals( empty_vector ) for: { } elements are { } 3541 # Usage of RangeEquals range matcher 3542 ok {test-number} - empty_vector, !RangeEquals( non_empty_vector ) for: { } not elements are { 1 } 3543 # Usage of RangeEquals range matcher 3544 ok {test-number} - non_empty_vector, !RangeEquals( empty_vector ) for: { 1 } not elements are { } 3545 # Usage of RangeEquals range matcher 3546 ok {test-number} - non_empty_array, RangeEquals( non_empty_array ) for: { 1 } elements are { 1 } 3547 # Usage of RangeEquals range matcher 3548 ok {test-number} - array_a, RangeEquals( array_a ) for: { 1, 2, 3 } elements are { 1, 2, 3 } 3549 # Usage of RangeEquals range matcher 3550 ok {test-number} - array_a, !RangeEquals( array_b ) for: { 1, 2, 3 } not elements are { 2, 2, 3 } 3551 # Usage of RangeEquals range matcher 3552 ok {test-number} - array_a, !RangeEquals( array_c ) for: { 1, 2, 3 } not elements are { 1, 2, 2 } 3553 # Usage of RangeEquals range matcher 3554 ok {test-number} - vector_a, !RangeEquals( vector_b ) for: { 1, 2, 3 } not elements are { 1, 2, 3, 4 } 3555 # Usage of RangeEquals range matcher 3556 ok {test-number} - vector_a, RangeEquals( vector_a_plus_1, close_enough ) for: { 1, 2, 3 } elements are { 2, 3, 4 } 3557 # Usage of RangeEquals range matcher 3558 ok {test-number} - vector_a, !RangeEquals( vector_b, close_enough ) for: { 1, 2, 3 } not elements are { 3, 3, 4 } 3559 # Usage of RangeEquals range matcher 3560 ok {test-number} - needs_adl1, RangeEquals( needs_adl2 ) for: { 1, 2, 3, 4, 5 } elements are { 1, 2, 3, 4, 5 } 3561 # Usage of RangeEquals range matcher 3562 ok {test-number} - needs_adl1, RangeEquals( needs_adl3, []( int l, int r ) { return l + 1 == r; } ) for: { 1, 2, 3, 4, 5 } elements are { 2, 3, 4, 5, 6 } 3563 # Usage of RangeEquals range matcher 3564 ok {test-number} - mocked1, !RangeEquals( arr ) for: { 1, 2, 3, 4 } not elements are { 1, 2, 4, 4 } 3565 # Usage of RangeEquals range matcher 3566 ok {test-number} - mocked1.m_derefed[0] for: true 3567 # Usage of RangeEquals range matcher 3568 ok {test-number} - mocked1.m_derefed[1] for: true 3569 # Usage of RangeEquals range matcher 3570 ok {test-number} - mocked1.m_derefed[2] for: true 3571 # Usage of RangeEquals range matcher 3572 ok {test-number} - !(mocked1.m_derefed[3]) for: !false 3573 # Usage of RangeEquals range matcher 3574 ok {test-number} - mocked1, RangeEquals( arr ) for: { 1, 2, 3, 4 } elements are { 1, 2, 3, 4 } 3575 # Usage of RangeEquals range matcher 3576 ok {test-number} - mocked1.m_derefed[0] for: true 3577 # Usage of RangeEquals range matcher 3578 ok {test-number} - mocked1.m_derefed[1] for: true 3579 # Usage of RangeEquals range matcher 3580 ok {test-number} - mocked1.m_derefed[2] for: true 3581 # Usage of RangeEquals range matcher 3582 ok {test-number} - mocked1.m_derefed[3] for: true 3583 # Usage of UnorderedRangeEquals range matcher 3584 ok {test-number} - empty_vector, UnorderedRangeEquals( empty_vector ) for: { } unordered elements are { } 3585 # Usage of UnorderedRangeEquals range matcher 3586 ok {test-number} - empty_vector, !UnorderedRangeEquals( non_empty_vector ) for: { } not unordered elements are { 1 } 3587 # Usage of UnorderedRangeEquals range matcher 3588 ok {test-number} - non_empty_vector, !UnorderedRangeEquals( empty_vector ) for: { 1 } not unordered elements are { } 3589 # Usage of UnorderedRangeEquals range matcher 3590 ok {test-number} - non_empty_array, UnorderedRangeEquals( non_empty_array ) for: { 1 } unordered elements are { 1 } 3591 # Usage of UnorderedRangeEquals range matcher 3592 ok {test-number} - array_a, UnorderedRangeEquals( array_a ) for: { 1, 2, 3 } unordered elements are { 1, 2, 3 } 3593 # Usage of UnorderedRangeEquals range matcher 3594 ok {test-number} - array_a, !UnorderedRangeEquals( array_b ) for: { 1, 2, 3 } not unordered elements are { 2, 2, 3 } 3595 # Usage of UnorderedRangeEquals range matcher 3596 ok {test-number} - vector_a, !UnorderedRangeEquals( vector_b ) for: { 1, 2, 3 } not unordered elements are { 1, 2, 3, 4 } 3597 # Usage of UnorderedRangeEquals range matcher 3598 ok {test-number} - vector_a, UnorderedRangeEquals( vector_a_plus_1, close_enough ) for: { 1, 10, 20 } unordered elements are { 11, 21, 2 } 3599 # Usage of UnorderedRangeEquals range matcher 3600 ok {test-number} - vector_a, !UnorderedRangeEquals( vector_b, close_enough ) for: { 1, 10, 21 } not unordered elements are { 11, 21, 3 } 3601 # Usage of UnorderedRangeEquals range matcher 3602 ok {test-number} - needs_adl1, UnorderedRangeEquals( needs_adl2 ) for: { 1, 2, 3, 4, 5 } unordered elements are { 1, 2, 3, 4, 5 } 3603 # Usage of the SizeIs range matcher 3604 ok {test-number} - empty_vec, SizeIs(0) for: { } has size == 0 3605 # Usage of the SizeIs range matcher 3606 ok {test-number} - empty_vec, !SizeIs(2) for: { } not has size == 2 3607 # Usage of the SizeIs range matcher 3608 ok {test-number} - empty_vec, SizeIs(Lt(2)) for: { } size matches is less than 2 3609 # Usage of the SizeIs range matcher 3610 ok {test-number} - arr, SizeIs(2) for: { 0, 0 } has size == 2 3611 # Usage of the SizeIs range matcher 3612 ok {test-number} - arr, SizeIs( Lt(3)) for: { 0, 0 } size matches is less than 3 3613 # Usage of the SizeIs range matcher 3614 ok {test-number} - arr, !SizeIs(!Lt(3)) for: { 0, 0 } not size matches not is less than 3 3615 # Usage of the SizeIs range matcher 3616 ok {test-number} - map, SizeIs(3) for: { {?}, {?}, {?} } has size == 3 3617 # Usage of the SizeIs range matcher 3618 ok {test-number} - unrelated::ADL_size{}, SizeIs(12) for: {?} has size == 12 3619 # Usage of the SizeIs range matcher 3620 ok {test-number} - has_size{}, SizeIs(13) for: {?} has size == 13 3621 # Use a custom approx 3622 ok {test-number} - d == approx( 1.23 ) for: 1.23 == Approx( 1.23 ) 3623 # Use a custom approx 3624 ok {test-number} - d == approx( 1.22 ) for: 1.23 == Approx( 1.22 ) 3625 # Use a custom approx 3626 ok {test-number} - d == approx( 1.24 ) for: 1.23 == Approx( 1.24 ) 3627 # Use a custom approx 3628 ok {test-number} - d != approx( 1.25 ) for: 1.23 != Approx( 1.25 ) 3629 # Use a custom approx 3630 ok {test-number} - approx( d ) == 1.23 for: Approx( 1.23 ) == 1.23 3631 # Use a custom approx 3632 ok {test-number} - approx( d ) == 1.22 for: Approx( 1.23 ) == 1.22 3633 # Use a custom approx 3634 ok {test-number} - approx( d ) == 1.24 for: Approx( 1.23 ) == 1.24 3635 # Use a custom approx 3636 ok {test-number} - approx( d ) != 1.25 for: Approx( 1.23 ) != 1.25 3637 # Variadic macros 3638 ok {test-number} - with 1 message: 'no assertions' 3639 # Vector Approx matcher 3640 ok {test-number} - empty, Approx( empty ) for: { } is approx: { } 3641 # Vector Approx matcher 3642 ok {test-number} - v1, Approx( v1 ) for: { 1.0, 2.0, 3.0 } is approx: { 1.0, 2.0, 3.0 } 3643 # Vector Approx matcher 3644 ok {test-number} - v1, Approx<double>( { 1., 2., 3. } ) for: { 1.0, 2.0, 3.0 } is approx: { 1.0, 2.0, 3.0 } 3645 # Vector Approx matcher 3646 ok {test-number} - v1, !Approx( temp ) for: { 1.0, 2.0, 3.0 } not is approx: { 1.0, 2.0, 3.0, 4.0 } 3647 # Vector Approx matcher 3648 ok {test-number} - v1, !Approx( v2 ) for: { 1.0, 2.0, 3.0 } not is approx: { 1.5, 2.5, 3.5 } 3649 # Vector Approx matcher 3650 ok {test-number} - v1, Approx( v2 ).margin( 0.5 ) for: { 1.0, 2.0, 3.0 } is approx: { 1.5, 2.5, 3.5 } 3651 # Vector Approx matcher 3652 ok {test-number} - v1, Approx( v2 ).epsilon( 0.5 ) for: { 1.0, 2.0, 3.0 } is approx: { 1.5, 2.5, 3.5 } 3653 # Vector Approx matcher 3654 ok {test-number} - v1, Approx( v2 ).epsilon( 0.1 ).scale( 500 ) for: { 1.0, 2.0, 3.0 } is approx: { 1.5, 2.5, 3.5 } 3655 # Vector Approx matcher -- failing 3656 not ok {test-number} - empty, Approx( t1 ) for: { } is approx: { 1.0, 2.0 } 3657 # Vector Approx matcher -- failing 3658 not ok {test-number} - v1, Approx( v2 ) for: { 2.0, 4.0, 6.0 } is approx: { 1.0, 3.0, 5.0 } 3659 # Vector matchers 3660 ok {test-number} - v, VectorContains( 1 ) for: { 1, 2, 3 } Contains: 1 3661 # Vector matchers 3662 ok {test-number} - v, VectorContains( 2 ) for: { 1, 2, 3 } Contains: 2 3663 # Vector matchers 3664 ok {test-number} - v5, ( VectorContains<int, CustomAllocator<int>>( 2 ) ) for: { 1, 2, 3 } Contains: 2 3665 # Vector matchers 3666 ok {test-number} - v, Contains( v2 ) for: { 1, 2, 3 } Contains: { 1, 2 } 3667 # Vector matchers 3668 ok {test-number} - v, Contains<int>( { 1, 2 } ) for: { 1, 2, 3 } Contains: { 1, 2 } 3669 # Vector matchers 3670 ok {test-number} - v5, ( Contains<int, std::allocator<int>, CustomAllocator<int>>( v2 ) ) for: { 1, 2, 3 } Contains: { 1, 2 } 3671 # Vector matchers 3672 ok {test-number} - v, Contains( v2 ) for: { 1, 2, 3 } Contains: { 1, 2, 3 } 3673 # Vector matchers 3674 ok {test-number} - v, Contains( empty ) for: { 1, 2, 3 } Contains: { } 3675 # Vector matchers 3676 ok {test-number} - empty, Contains( empty ) for: { } Contains: { } 3677 # Vector matchers 3678 ok {test-number} - v5, ( Contains<int, std::allocator<int>, CustomAllocator<int>>( v2 ) ) for: { 1, 2, 3 } Contains: { 1, 2, 3 } 3679 # Vector matchers 3680 ok {test-number} - v5, Contains( v6 ) for: { 1, 2, 3 } Contains: { 1, 2 } 3681 # Vector matchers 3682 ok {test-number} - v, VectorContains( 1 ) && VectorContains( 2 ) for: { 1, 2, 3 } ( Contains: 1 and Contains: 2 ) 3683 # Vector matchers 3684 ok {test-number} - v, Equals( v ) for: { 1, 2, 3 } Equals: { 1, 2, 3 } 3685 # Vector matchers 3686 ok {test-number} - empty, Equals( empty ) for: { } Equals: { } 3687 # Vector matchers 3688 ok {test-number} - v, Equals<int>( { 1, 2, 3 } ) for: { 1, 2, 3 } Equals: { 1, 2, 3 } 3689 # Vector matchers 3690 ok {test-number} - v, Equals( v2 ) for: { 1, 2, 3 } Equals: { 1, 2, 3 } 3691 # Vector matchers 3692 ok {test-number} - v5, ( Equals<int, std::allocator<int>, CustomAllocator<int>>( v2 ) ) for: { 1, 2, 3 } Equals: { 1, 2, 3 } 3693 # Vector matchers 3694 ok {test-number} - v5, Equals( v6 ) for: { 1, 2, 3 } Equals: { 1, 2, 3 } 3695 # Vector matchers 3696 ok {test-number} - v, UnorderedEquals( v ) for: { 1, 2, 3 } UnorderedEquals: { 1, 2, 3 } 3697 # Vector matchers 3698 ok {test-number} - v, UnorderedEquals<int>( { 3, 2, 1 } ) for: { 1, 2, 3 } UnorderedEquals: { 3, 2, 1 } 3699 # Vector matchers 3700 ok {test-number} - empty, UnorderedEquals( empty ) for: { } UnorderedEquals: { } 3701 # Vector matchers 3702 ok {test-number} - permuted, UnorderedEquals( v ) for: { 1, 3, 2 } UnorderedEquals: { 1, 2, 3 } 3703 # Vector matchers 3704 ok {test-number} - permuted, UnorderedEquals( v ) for: { 2, 3, 1 } UnorderedEquals: { 1, 2, 3 } 3705 # Vector matchers 3706 ok {test-number} - v5, ( UnorderedEquals<int, std::allocator<int>, CustomAllocator<int>>( permuted ) ) for: { 1, 2, 3 } UnorderedEquals: { 2, 3, 1 } 3707 # Vector matchers 3708 ok {test-number} - v5_permuted, UnorderedEquals( v5 ) for: { 1, 3, 2 } UnorderedEquals: { 1, 2, 3 } 3709 # Vector matchers that fail 3710 not ok {test-number} - v, VectorContains( -1 ) for: { 1, 2, 3 } Contains: -1 3711 # Vector matchers that fail 3712 not ok {test-number} - empty, VectorContains( 1 ) for: { } Contains: 1 3713 # Vector matchers that fail 3714 not ok {test-number} - empty, Contains( v ) for: { } Contains: { 1, 2, 3 } 3715 # Vector matchers that fail 3716 not ok {test-number} - v, Contains( v2 ) for: { 1, 2, 3 } Contains: { 1, 2, 4 } 3717 # Vector matchers that fail 3718 not ok {test-number} - v, Equals( v2 ) for: { 1, 2, 3 } Equals: { 1, 2 } 3719 # Vector matchers that fail 3720 not ok {test-number} - v2, Equals( v ) for: { 1, 2 } Equals: { 1, 2, 3 } 3721 # Vector matchers that fail 3722 not ok {test-number} - empty, Equals( v ) for: { } Equals: { 1, 2, 3 } 3723 # Vector matchers that fail 3724 not ok {test-number} - v, Equals( empty ) for: { 1, 2, 3 } Equals: { } 3725 # Vector matchers that fail 3726 not ok {test-number} - v, UnorderedEquals( empty ) for: { 1, 2, 3 } UnorderedEquals: { } 3727 # Vector matchers that fail 3728 not ok {test-number} - empty, UnorderedEquals( v ) for: { } UnorderedEquals: { 1, 2, 3 } 3729 # Vector matchers that fail 3730 not ok {test-number} - permuted, UnorderedEquals( v ) for: { 1, 3 } UnorderedEquals: { 1, 2, 3 } 3731 # Vector matchers that fail 3732 not ok {test-number} - permuted, UnorderedEquals( v ) for: { 3, 1 } UnorderedEquals: { 1, 2, 3 } 3733 # When checked exceptions are thrown they can be expected or unexpected 3734 ok {test-number} - thisThrows(), std::domain_error 3735 # When checked exceptions are thrown they can be expected or unexpected 3736 ok {test-number} - thisDoesntThrow() 3737 # When checked exceptions are thrown they can be expected or unexpected 3738 ok {test-number} - thisThrows() 3739 # When unchecked exceptions are thrown directly they are always failures 3740 not ok {test-number} - unexpected exception with message: 'unexpected exception' 3741 # When unchecked exceptions are thrown during a CHECK the test should continue 3742 not ok {test-number} - unexpected exception with message: 'expected exception'; expression was: thisThrows() == 0 3743 # When unchecked exceptions are thrown during a REQUIRE the test should abort fail 3744 not ok {test-number} - unexpected exception with message: 'expected exception'; expression was: thisThrows() == 0 3745 # When unchecked exceptions are thrown from functions they are always failures 3746 not ok {test-number} - unexpected exception with message: 'expected exception'; expression was: thisThrows() == 0 3747 # When unchecked exceptions are thrown from sections they are always failures 3748 not ok {test-number} - unexpected exception with message: 'unexpected exception' 3749 # X/level/0/a 3750 ok {test-number} - 3751 # X/level/0/b 3752 ok {test-number} - 3753 # X/level/1/a 3754 ok {test-number} - 3755 # X/level/1/b 3756 ok {test-number} - 3757 # XmlEncode 3758 ok {test-number} - encode( "normal string" ) == "normal string" for: "normal string" == "normal string" 3759 # XmlEncode 3760 ok {test-number} - encode( "" ) == "" for: "" == "" 3761 # XmlEncode 3762 ok {test-number} - encode( "smith & jones" ) == "smith & jones" for: "smith & jones" == "smith & jones" 3763 # XmlEncode 3764 ok {test-number} - encode( "smith < jones" ) == "smith < jones" for: "smith < jones" == "smith < jones" 3765 # XmlEncode 3766 ok {test-number} - encode( "smith > jones" ) == "smith > jones" for: "smith > jones" == "smith > jones" 3767 # XmlEncode 3768 ok {test-number} - encode( "smith ]]> jones" ) == "smith ]]> jones" for: "smith ]]> jones" == "smith ]]> jones" 3769 # XmlEncode 3770 ok {test-number} - encode( stringWithQuotes ) == stringWithQuotes for: "don't "quote" me on that" == "don't "quote" me on that" 3771 # XmlEncode 3772 ok {test-number} - encode( stringWithQuotes, Catch::XmlEncode::ForAttributes ) == "don't "quote" me on that" for: "don't "quote" me on that" == "don't "quote" me on that" 3773 # XmlEncode 3774 ok {test-number} - encode( "[\x01]" ) == "[\\x01]" for: "[\x01]" == "[\x01]" 3775 # XmlEncode 3776 ok {test-number} - encode( "[\x7F]" ) == "[\\x7F]" for: "[\x7F]" == "[\x7F]" 3777 # XmlWriter writes boolean attributes as true/false 3778 ok {test-number} - stream.str(), ContainsSubstring(R"(attr1="true")") && ContainsSubstring(R"(attr2="false")") for: "<?xml version="1.0" encoding="UTF-8"?> <Element1 attr1="true" attr2="false"/> " ( contains: "attr1="true"" and contains: "attr2="false"" ) 3779 # a succeeding test can still be skipped 3780 ok {test-number} - 3781 # a succeeding test can still be skipped 3782 ok {test-number} - # SKIP 3783 # analyse no analysis 3784 ok {test-number} - analysis.mean.point.count() == 23 for: 23.0 == 23 3785 # analyse no analysis 3786 ok {test-number} - analysis.mean.lower_bound.count() == 23 for: 23.0 == 23 3787 # analyse no analysis 3788 ok {test-number} - analysis.mean.upper_bound.count() == 23 for: 23.0 == 23 3789 # analyse no analysis 3790 ok {test-number} - analysis.standard_deviation.point.count() == 0 for: 0.0 == 0 3791 # analyse no analysis 3792 ok {test-number} - analysis.standard_deviation.lower_bound.count() == 0 for: 0.0 == 0 3793 # analyse no analysis 3794 ok {test-number} - analysis.standard_deviation.upper_bound.count() == 0 for: 0.0 == 0 3795 # analyse no analysis 3796 ok {test-number} - analysis.outliers.total() == 0 for: 0 == 0 3797 # analyse no analysis 3798 ok {test-number} - analysis.outliers.low_mild == 0 for: 0 == 0 3799 # analyse no analysis 3800 ok {test-number} - analysis.outliers.low_severe == 0 for: 0 == 0 3801 # analyse no analysis 3802 ok {test-number} - analysis.outliers.high_mild == 0 for: 0 == 0 3803 # analyse no analysis 3804 ok {test-number} - analysis.outliers.high_severe == 0 for: 0 == 0 3805 # analyse no analysis 3806 ok {test-number} - analysis.outliers.samples_seen == 0 for: 0 == 0 3807 # analyse no analysis 3808 ok {test-number} - analysis.outlier_variance == 0 for: 0.0 == 0 3809 # array<int, N> -> toString 3810 ok {test-number} - Catch::Detail::stringify( empty ) == "{ }" for: "{ }" == "{ }" 3811 # array<int, N> -> toString 3812 ok {test-number} - Catch::Detail::stringify( oneValue ) == "{ 42 }" for: "{ 42 }" == "{ 42 }" 3813 # array<int, N> -> toString 3814 ok {test-number} - Catch::Detail::stringify( twoValues ) == "{ 42, 250 }" for: "{ 42, 250 }" == "{ 42, 250 }" 3815 # benchmark function call 3816 ok {test-number} - model.started == 1 for: 1 == 1 3817 # benchmark function call 3818 ok {test-number} - model.finished == 0 for: 0 == 0 3819 # benchmark function call 3820 ok {test-number} - model.started == 1 for: 1 == 1 3821 # benchmark function call 3822 ok {test-number} - model.finished == 1 for: 1 == 1 3823 # benchmark function call 3824 ok {test-number} - called == 1 for: 1 == 1 3825 # benchmark function call 3826 ok {test-number} - model.started == 0 for: 0 == 0 3827 # benchmark function call 3828 ok {test-number} - model.finished == 0 for: 0 == 0 3829 # benchmark function call 3830 ok {test-number} - model.started == 0 for: 0 == 0 3831 # benchmark function call 3832 ok {test-number} - model.finished == 0 for: 0 == 0 3833 # benchmark function call 3834 ok {test-number} - called == 1 for: 1 == 1 3835 # boolean member 3836 ok {test-number} - obj.prop != 0 for: 0x<hex digits> != 0 3837 # checkedElse 3838 ok {test-number} - flag for: true 3839 # checkedElse 3840 ok {test-number} - testCheckedElse( true ) for: true 3841 # checkedElse, failing 3842 ok {test-number} - flag for: false # TODO 3843 # checkedElse, failing 3844 not ok {test-number} - testCheckedElse( false ) for: false 3845 # checkedIf 3846 ok {test-number} - flag for: true 3847 # checkedIf 3848 ok {test-number} - testCheckedIf( true ) for: true 3849 # checkedIf, failing 3850 ok {test-number} - flag for: false # TODO 3851 # checkedIf, failing 3852 not ok {test-number} - testCheckedIf( false ) for: false 3853 # classify_outliers 3854 ok {test-number} - o.samples_seen == static_cast<int>(x.size()) for: 6 == 6 3855 # classify_outliers 3856 ok {test-number} - o.low_severe == los for: 0 == 0 3857 # classify_outliers 3858 ok {test-number} - o.low_mild == lom for: 0 == 0 3859 # classify_outliers 3860 ok {test-number} - o.high_mild == him for: 0 == 0 3861 # classify_outliers 3862 ok {test-number} - o.high_severe == his for: 0 == 0 3863 # classify_outliers 3864 ok {test-number} - o.total() == los + lom + him + his for: 0 == 0 3865 # classify_outliers 3866 ok {test-number} - o.samples_seen == static_cast<int>(x.size()) for: 6 == 6 3867 # classify_outliers 3868 ok {test-number} - o.low_severe == los for: 1 == 1 3869 # classify_outliers 3870 ok {test-number} - o.low_mild == lom for: 0 == 0 3871 # classify_outliers 3872 ok {test-number} - o.high_mild == him for: 0 == 0 3873 # classify_outliers 3874 ok {test-number} - o.high_severe == his for: 0 == 0 3875 # classify_outliers 3876 ok {test-number} - o.total() == los + lom + him + his for: 1 == 1 3877 # classify_outliers 3878 ok {test-number} - o.samples_seen == static_cast<int>(x.size()) for: 6 == 6 3879 # classify_outliers 3880 ok {test-number} - o.low_severe == los for: 0 == 0 3881 # classify_outliers 3882 ok {test-number} - o.low_mild == lom for: 1 == 1 3883 # classify_outliers 3884 ok {test-number} - o.high_mild == him for: 0 == 0 3885 # classify_outliers 3886 ok {test-number} - o.high_severe == his for: 0 == 0 3887 # classify_outliers 3888 ok {test-number} - o.total() == los + lom + him + his for: 1 == 1 3889 # classify_outliers 3890 ok {test-number} - o.samples_seen == static_cast<int>(x.size()) for: 6 == 6 3891 # classify_outliers 3892 ok {test-number} - o.low_severe == los for: 0 == 0 3893 # classify_outliers 3894 ok {test-number} - o.low_mild == lom for: 0 == 0 3895 # classify_outliers 3896 ok {test-number} - o.high_mild == him for: 1 == 1 3897 # classify_outliers 3898 ok {test-number} - o.high_severe == his for: 0 == 0 3899 # classify_outliers 3900 ok {test-number} - o.total() == los + lom + him + his for: 1 == 1 3901 # classify_outliers 3902 ok {test-number} - o.samples_seen == static_cast<int>(x.size()) for: 6 == 6 3903 # classify_outliers 3904 ok {test-number} - o.low_severe == los for: 0 == 0 3905 # classify_outliers 3906 ok {test-number} - o.low_mild == lom for: 0 == 0 3907 # classify_outliers 3908 ok {test-number} - o.high_mild == him for: 0 == 0 3909 # classify_outliers 3910 ok {test-number} - o.high_severe == his for: 1 == 1 3911 # classify_outliers 3912 ok {test-number} - o.total() == los + lom + him + his for: 1 == 1 3913 # classify_outliers 3914 ok {test-number} - o.samples_seen == static_cast<int>(x.size()) for: 6 == 6 3915 # classify_outliers 3916 ok {test-number} - o.low_severe == los for: 1 == 1 3917 # classify_outliers 3918 ok {test-number} - o.low_mild == lom for: 0 == 0 3919 # classify_outliers 3920 ok {test-number} - o.high_mild == him for: 1 == 1 3921 # classify_outliers 3922 ok {test-number} - o.high_severe == his for: 0 == 0 3923 # classify_outliers 3924 ok {test-number} - o.total() == los + lom + him + his for: 2 == 2 3925 # comparisons between const int variables 3926 ok {test-number} - unsigned_char_var == 1 for: 1 == 1 3927 # comparisons between const int variables 3928 ok {test-number} - unsigned_short_var == 1 for: 1 == 1 3929 # comparisons between const int variables 3930 ok {test-number} - unsigned_int_var == 1 for: 1 == 1 3931 # comparisons between const int variables 3932 ok {test-number} - unsigned_long_var == 1 for: 1 == 1 3933 # comparisons between int variables 3934 ok {test-number} - long_var == unsigned_char_var for: 1 == 1 3935 # comparisons between int variables 3936 ok {test-number} - long_var == unsigned_short_var for: 1 == 1 3937 # comparisons between int variables 3938 ok {test-number} - long_var == unsigned_int_var for: 1 == 1 3939 # comparisons between int variables 3940 ok {test-number} - long_var == unsigned_long_var for: 1 == 1 3941 # convertToBits 3942 ok {test-number} - convertToBits( 0.f ) == 0 for: 0 == 0 3943 # convertToBits 3944 ok {test-number} - convertToBits( -0.f ) == ( 1ULL << 31 ) for: 2147483648 (0x<hex digits>) == 2147483648 (0x<hex digits>) 3945 # convertToBits 3946 ok {test-number} - convertToBits( 0. ) == 0 for: 0 == 0 3947 # convertToBits 3948 ok {test-number} - convertToBits( -0. ) == ( 1ULL << 63 ) for: 9223372036854775808 (0x<hex digits>) == 9223372036854775808 (0x<hex digits>) 3949 # convertToBits 3950 ok {test-number} - convertToBits( std::numeric_limits<float>::denorm_min() ) == 1 for: 1 == 1 3951 # convertToBits 3952 ok {test-number} - convertToBits( std::numeric_limits<double>::denorm_min() ) == 1 for: 1 == 1 3953 # dynamic skipping works with generators 3954 ok {test-number} - # SKIP 'skipping because answer = 41' 3955 # dynamic skipping works with generators 3956 ok {test-number} - 3957 # dynamic skipping works with generators 3958 ok {test-number} - # SKIP 'skipping because answer = 43' 3959 # empty tags are not allowed 3960 ok {test-number} - Catch::TestCaseInfo("", { "test with an empty tag", "[]" }, dummySourceLineInfo) 3961 # erfc_inv 3962 ok {test-number} - erfc_inv(1.103560) == Approx(-0.09203687623843015) for: -0.0920368762 == Approx( -0.0920368762 ) 3963 # erfc_inv 3964 ok {test-number} - erfc_inv(1.067400) == Approx(-0.05980291115763361) for: -0.0598029112 == Approx( -0.0598029112 ) 3965 # erfc_inv 3966 ok {test-number} - erfc_inv(0.050000) == Approx(1.38590382434967796) for: 1.3859038243 == Approx( 1.3859038243 ) 3967 # estimate_clock_resolution 3968 ok {test-number} - res.mean.count() == rate for: 2000.0 == 2000 (0x<hex digits>) 3969 # estimate_clock_resolution 3970 ok {test-number} - res.outliers.total() == 0 for: 0 == 0 3971 # even more nested SECTION tests 3972 ok {test-number} - 3973 # even more nested SECTION tests 3974 ok {test-number} - 3975 # even more nested SECTION tests 3976 ok {test-number} - 3977 # failed assertions before SKIP cause test case to fail 3978 not ok {test-number} - 3 == 4 3979 # failed assertions before SKIP cause test case to fail 3980 ok {test-number} - # SKIP 3981 # failing for some generator values causes entire test case to fail 3982 not ok {test-number} - explicitly 3983 # failing for some generator values causes entire test case to fail 3984 ok {test-number} - # SKIP 3985 # failing for some generator values causes entire test case to fail 3986 not ok {test-number} - explicitly 3987 # failing for some generator values causes entire test case to fail 3988 ok {test-number} - # SKIP 3989 # failing in some unskipped sections causes entire test case to fail 3990 ok {test-number} - # SKIP 3991 # failing in some unskipped sections causes entire test case to fail 3992 not ok {test-number} - explicitly 3993 # is_unary_function 3994 ok {test-number} - with 1 message: 'Catch::Clara::Detail::is_unary_function<decltype(unary1)>::value' 3995 # is_unary_function 3996 ok {test-number} - with 1 message: 'Catch::Clara::Detail::is_unary_function<decltype(unary2)>::value' 3997 # is_unary_function 3998 ok {test-number} - with 1 message: 'Catch::Clara::Detail::is_unary_function<decltype(unary3)>::value' 3999 # is_unary_function 4000 ok {test-number} - with 1 message: 'Catch::Clara::Detail::is_unary_function<decltype(unary4)>::value' 4001 # is_unary_function 4002 ok {test-number} - with 1 message: 'Catch::Clara::Detail::is_unary_function<decltype(unary5)>::value' 4003 # is_unary_function 4004 ok {test-number} - with 1 message: 'Catch::Clara::Detail::is_unary_function<decltype(unary6)>::value' 4005 # is_unary_function 4006 ok {test-number} - with 1 message: '!(Catch::Clara::Detail::is_unary_function<decltype(binary1)>::value)' 4007 # is_unary_function 4008 ok {test-number} - with 1 message: '!(Catch::Clara::Detail::is_unary_function<decltype(binary2)>::value)' 4009 # is_unary_function 4010 ok {test-number} - with 1 message: '!(Catch::Clara::Detail::is_unary_function<decltype(nullary1)>::value)' 4011 # is_unary_function 4012 ok {test-number} - with 1 message: '!(Catch::Clara::Detail::is_unary_function<decltype(nullary2)>::value)' 4013 # is_unary_function 4014 ok {test-number} - with 1 message: '!(Catch::Clara::Detail::is_unary_function<int>::value)' 4015 # is_unary_function 4016 ok {test-number} - with 1 message: '!(Catch::Clara::Detail::is_unary_function<std::string const&>::value)' 4017 # just failure 4018 not ok {test-number} - explicitly with 1 message: 'Previous info should not be seen' 4019 # just failure after unscoped info 4020 not ok {test-number} - explicitly with 1 message: 'previous unscoped info SHOULD not be seen' 4021 # long long 4022 ok {test-number} - l == std::numeric_limits<long long>::max() for: 9223372036854775807 (0x<hex digits>) == 9223372036854775807 (0x<hex digits>) 4023 # looped SECTION tests 4024 not ok {test-number} - b > a for: 0 > 1 4025 # looped SECTION tests 4026 not ok {test-number} - b > a for: 1 > 1 4027 # looped SECTION tests 4028 ok {test-number} - b > a for: 2 > 1 4029 # looped SECTION tests 4030 ok {test-number} - b > a for: 3 > 1 4031 # looped SECTION tests 4032 ok {test-number} - b > a for: 4 > 1 4033 # looped SECTION tests 4034 ok {test-number} - b > a for: 5 > 1 4035 # looped SECTION tests 4036 ok {test-number} - b > a for: 6 > 1 4037 # looped SECTION tests 4038 ok {test-number} - b > a for: 7 > 1 4039 # looped SECTION tests 4040 ok {test-number} - b > a for: 8 > 1 4041 # looped SECTION tests 4042 ok {test-number} - b > a for: 9 > 1 4043 # looped tests 4044 not ok {test-number} - ( fib[i] % 2 ) == 0 for: 1 == 0 with 1 message: 'Testing if fib[0] (1) is even' 4045 # looped tests 4046 not ok {test-number} - ( fib[i] % 2 ) == 0 for: 1 == 0 with 1 message: 'Testing if fib[1] (1) is even' 4047 # looped tests 4048 ok {test-number} - ( fib[i] % 2 ) == 0 for: 0 == 0 with 1 message: 'Testing if fib[2] (2) is even' 4049 # looped tests 4050 not ok {test-number} - ( fib[i] % 2 ) == 0 for: 1 == 0 with 1 message: 'Testing if fib[3] (3) is even' 4051 # looped tests 4052 not ok {test-number} - ( fib[i] % 2 ) == 0 for: 1 == 0 with 1 message: 'Testing if fib[4] (5) is even' 4053 # looped tests 4054 ok {test-number} - ( fib[i] % 2 ) == 0 for: 0 == 0 with 1 message: 'Testing if fib[5] (8) is even' 4055 # looped tests 4056 not ok {test-number} - ( fib[i] % 2 ) == 0 for: 1 == 0 with 1 message: 'Testing if fib[6] (13) is even' 4057 # looped tests 4058 not ok {test-number} - ( fib[i] % 2 ) == 0 for: 1 == 0 with 1 message: 'Testing if fib[7] (21) is even' 4059 # makeStream recognizes %debug stream name 4060 ok {test-number} - Catch::makeStream( "%debug" ) 4061 # make_unique reimplementation 4062 ok {test-number} - !(lval.has_moved) for: !false 4063 # make_unique reimplementation 4064 ok {test-number} - rval.has_moved for: true 4065 # make_unique reimplementation 4066 ok {test-number} - *ptr == std::tuple<int, double, int>{1, 2., 3} for: {?} == {?} 4067 # mean 4068 ok {test-number} - m == 19. for: 19.0 == 19.0 4069 # measure 4070 ok {test-number} - x == 17 for: 17 == 17 4071 # measure 4072 ok {test-number} - x == 23 for: 23 == 23 4073 # measure 4074 ok {test-number} - r.elapsed.count() == 42 for: 42 == 42 4075 # measure 4076 ok {test-number} - r.result == 23 for: 23 == 23 4077 # measure 4078 ok {test-number} - r.iterations == 1 for: 1 == 1 4079 # measure 4080 ok {test-number} - s.elapsed.count() == 69 for: 69 == 69 4081 # measure 4082 ok {test-number} - s.result == 17 for: 17 == 17 4083 # measure 4084 ok {test-number} - s.iterations == 1 for: 1 == 1 4085 # mix info, unscoped info and warning 4086 warning {test-number} - 'info' with 2 messages: 'unscoped info' and 'and warn may mix' 4087 # mix info, unscoped info and warning 4088 warning {test-number} - 'info' with 2 messages: 'unscoped info' and 'they are not cleared after warnings' 4089 # more nested SECTION tests 4090 not ok {test-number} - a == b for: 1 == 2 4091 # more nested SECTION tests 4092 ok {test-number} - a != b for: 1 != 2 4093 # more nested SECTION tests 4094 ok {test-number} - a < b for: 1 < 2 4095 # nested SECTION tests 4096 ok {test-number} - a != b for: 1 != 2 4097 # nested SECTION tests 4098 ok {test-number} - b != a for: 2 != 1 4099 # nested SECTION tests 4100 ok {test-number} - a != b for: 1 != 2 4101 # nested sections can be skipped dynamically at runtime 4102 ok {test-number} - # SKIP 4103 # non streamable - with conv. op 4104 ok {test-number} - s == "7" for: "7" == "7" 4105 # non-copyable objects 4106 ok {test-number} - ti == typeid(int) for: {?} == {?} 4107 # normal_cdf 4108 ok {test-number} - normal_cdf(0.000000) == Approx(0.50000000000000000) for: 0.5 == Approx( 0.5 ) 4109 # normal_cdf 4110 ok {test-number} - normal_cdf(1.000000) == Approx(0.84134474606854293) for: 0.8413447461 == Approx( 0.8413447461 ) 4111 # normal_cdf 4112 ok {test-number} - normal_cdf(-1.000000) == Approx(0.15865525393145705) for: 0.1586552539 == Approx( 0.1586552539 ) 4113 # normal_cdf 4114 ok {test-number} - normal_cdf(2.809729) == Approx(0.99752083845315409) for: 0.9975208385 == Approx( 0.9975208385 ) 4115 # normal_cdf 4116 ok {test-number} - normal_cdf(-1.352570) == Approx(0.08809652095066035) for: 0.088096521 == Approx( 0.088096521 ) 4117 # normal_quantile 4118 ok {test-number} - normal_quantile(0.551780) == Approx(0.13015979861484198) for: 0.1301597986 == Approx( 0.1301597986 ) 4119 # normal_quantile 4120 ok {test-number} - normal_quantile(0.533700) == Approx(0.08457408802851875) for: 0.084574088 == Approx( 0.084574088 ) 4121 # normal_quantile 4122 ok {test-number} - normal_quantile(0.025000) == Approx(-1.95996398454005449) for: -1.9599639845 == Approx( -1.9599639845 ) 4123 # not allowed 4124 ok {test-number} - 4125 # not prints unscoped info from previous failures 4126 ok {test-number} - true with 1 message: 'this MAY be seen only for the FIRST assertion IF info is printed for passing assertions' 4127 # not prints unscoped info from previous failures 4128 ok {test-number} - true with 1 message: 'this MAY be seen only for the SECOND assertion IF info is printed for passing assertions' 4129 # not prints unscoped info from previous failures 4130 not ok {test-number} - false with 1 message: 'this SHOULD be seen' 4131 # null strings 4132 ok {test-number} - makeString( false ) != static_cast<char*>(0) for: "valid string" != {null string} 4133 # null strings 4134 ok {test-number} - makeString( true ) == static_cast<char*>(0) for: {null string} == {null string} 4135 # null_ptr 4136 ok {test-number} - ptr.get() == 0 for: 0 == 0 4137 # pair<pair<int,const char *,pair<std::string,int> > -> toString 4138 ok {test-number} - ::Catch::Detail::stringify( pair ) == "{ { 42, \"Arthur\" }, { \"Ford\", 24 } }" for: "{ { 42, "Arthur" }, { "Ford", 24 } }" == "{ { 42, "Arthur" }, { "Ford", 24 } }" 4139 # parseEnums 4140 ok {test-number} - parseEnums( "" ), Equals( std::vector<Catch::StringRef>{} ) for: { } Equals: { } 4141 # parseEnums 4142 ok {test-number} - parseEnums( "ClassName::EnumName::Value1" ), Equals(std::vector<Catch::StringRef>{"Value1"} ) for: { Value1 } Equals: { Value1 } 4143 # parseEnums 4144 ok {test-number} - parseEnums( "Value1" ), Equals( std::vector<Catch::StringRef>{"Value1"} ) for: { Value1 } Equals: { Value1 } 4145 # parseEnums 4146 ok {test-number} - parseEnums( "EnumName::Value1" ), Equals(std::vector<Catch::StringRef>{"Value1"} ) for: { Value1 } Equals: { Value1 } 4147 # parseEnums 4148 ok {test-number} - parseEnums( "ClassName::EnumName::Value1, ClassName::EnumName::Value2" ), Equals( std::vector<Catch::StringRef>{"Value1", "Value2"} ) for: { Value1, Value2 } Equals: { Value1, Value2 } 4149 # parseEnums 4150 ok {test-number} - parseEnums( "ClassName::EnumName::Value1, ClassName::EnumName::Value2, ClassName::EnumName::Value3" ), Equals( std::vector<Catch::StringRef>{"Value1", "Value2", "Value3"} ) for: { Value1, Value2, Value3 } Equals: { Value1, Value2, Value3 } 4151 # parseEnums 4152 ok {test-number} - parseEnums( "ClassName::EnumName::Value1,ClassName::EnumName::Value2 , ClassName::EnumName::Value3" ), Equals( std::vector<Catch::StringRef>{"Value1", "Value2", "Value3"} ) for: { Value1, Value2, Value3 } Equals: { Value1, Value2, Value3 } 4153 # pointer to class 4154 ok {test-number} - p == 0 for: 0 == 0 4155 # print unscoped info if passing unscoped info is printed 4156 ok {test-number} - true with 1 message: 'this MAY be seen IF info is printed for passing assertions' 4157 # prints unscoped info on failure 4158 not ok {test-number} - false with 2 messages: 'this SHOULD be seen' and 'this SHOULD also be seen' 4159 # prints unscoped info only for the first assertion 4160 not ok {test-number} - false with 1 message: 'this SHOULD be seen only ONCE' 4161 # prints unscoped info only for the first assertion 4162 ok {test-number} - true 4163 # prints unscoped info only for the first assertion 4164 ok {test-number} - true with 1 message: 'this MAY also be seen only ONCE IF info is printed for passing assertions' 4165 # prints unscoped info only for the first assertion 4166 ok {test-number} - true 4167 # random SECTION tests 4168 ok {test-number} - a != b for: 1 != 2 4169 # random SECTION tests 4170 ok {test-number} - b != a for: 2 != 1 4171 # random SECTION tests 4172 ok {test-number} - a != b for: 1 != 2 4173 # replaceInPlace 4174 ok {test-number} - Catch::replaceInPlace(letters, "b", "z") for: true 4175 # replaceInPlace 4176 ok {test-number} - letters == "azcdefcg" for: "azcdefcg" == "azcdefcg" 4177 # replaceInPlace 4178 ok {test-number} - Catch::replaceInPlace(letters, "c", "z") for: true 4179 # replaceInPlace 4180 ok {test-number} - letters == "abzdefzg" for: "abzdefzg" == "abzdefzg" 4181 # replaceInPlace 4182 ok {test-number} - Catch::replaceInPlace(letters, "a", "z") for: true 4183 # replaceInPlace 4184 ok {test-number} - letters == "zbcdefcg" for: "zbcdefcg" == "zbcdefcg" 4185 # replaceInPlace 4186 ok {test-number} - Catch::replaceInPlace(letters, "g", "z") for: true 4187 # replaceInPlace 4188 ok {test-number} - letters == "abcdefcz" for: "abcdefcz" == "abcdefcz" 4189 # replaceInPlace 4190 ok {test-number} - Catch::replaceInPlace(letters, letters, "replaced") for: true 4191 # replaceInPlace 4192 ok {test-number} - letters == "replaced" for: "replaced" == "replaced" 4193 # replaceInPlace 4194 ok {test-number} - !(Catch::replaceInPlace(letters, "x", "z")) for: !false 4195 # replaceInPlace 4196 ok {test-number} - letters == letters for: "abcdefcg" == "abcdefcg" 4197 # replaceInPlace 4198 ok {test-number} - Catch::replaceInPlace(s, "'", "|'") for: true 4199 # replaceInPlace 4200 ok {test-number} - s == "didn|'t" for: "didn|'t" == "didn|'t" 4201 # request an unknown %-starting stream fails 4202 ok {test-number} - Catch::makeStream( "%somestream" ) 4203 # resolution 4204 ok {test-number} - res.size() == count for: 10 == 10 4205 # resolution 4206 ok {test-number} - res[i] == rate for: 1000.0 == 1000 (0x<hex digits>) 4207 # resolution 4208 ok {test-number} - res[i] == rate for: 1000.0 == 1000 (0x<hex digits>) 4209 # resolution 4210 ok {test-number} - res[i] == rate for: 1000.0 == 1000 (0x<hex digits>) 4211 # resolution 4212 ok {test-number} - res[i] == rate for: 1000.0 == 1000 (0x<hex digits>) 4213 # resolution 4214 ok {test-number} - res[i] == rate for: 1000.0 == 1000 (0x<hex digits>) 4215 # resolution 4216 ok {test-number} - res[i] == rate for: 1000.0 == 1000 (0x<hex digits>) 4217 # resolution 4218 ok {test-number} - res[i] == rate for: 1000.0 == 1000 (0x<hex digits>) 4219 # resolution 4220 ok {test-number} - res[i] == rate for: 1000.0 == 1000 (0x<hex digits>) 4221 # resolution 4222 ok {test-number} - res[i] == rate for: 1000.0 == 1000 (0x<hex digits>) 4223 # run_for_at_least, chronometer 4224 ok {test-number} - meter.runs() >= old_runs for: 1 >= 1 4225 # run_for_at_least, chronometer 4226 ok {test-number} - meter.runs() >= old_runs for: 2 >= 1 4227 # run_for_at_least, chronometer 4228 ok {test-number} - meter.runs() >= old_runs for: 4 >= 2 4229 # run_for_at_least, chronometer 4230 ok {test-number} - meter.runs() >= old_runs for: 8 >= 4 4231 # run_for_at_least, chronometer 4232 ok {test-number} - meter.runs() >= old_runs for: 16 >= 8 4233 # run_for_at_least, chronometer 4234 ok {test-number} - meter.runs() >= old_runs for: 32 >= 16 4235 # run_for_at_least, chronometer 4236 ok {test-number} - meter.runs() >= old_runs for: 64 >= 32 4237 # run_for_at_least, chronometer 4238 ok {test-number} - meter.runs() >= old_runs for: 128 >= 64 4239 # run_for_at_least, chronometer 4240 ok {test-number} - Timing.elapsed >= time for: 128 ns >= 100 ns 4241 # run_for_at_least, chronometer 4242 ok {test-number} - Timing.result == Timing.iterations + 17 for: 145 == 145 4243 # run_for_at_least, chronometer 4244 ok {test-number} - Timing.iterations >= time.count() for: 128 >= 100 4245 # run_for_at_least, int 4246 ok {test-number} - x >= old_x for: 1 >= 1 4247 # run_for_at_least, int 4248 ok {test-number} - x >= old_x for: 2 >= 1 4249 # run_for_at_least, int 4250 ok {test-number} - x >= old_x for: 4 >= 2 4251 # run_for_at_least, int 4252 ok {test-number} - x >= old_x for: 8 >= 4 4253 # run_for_at_least, int 4254 ok {test-number} - x >= old_x for: 16 >= 8 4255 # run_for_at_least, int 4256 ok {test-number} - x >= old_x for: 32 >= 16 4257 # run_for_at_least, int 4258 ok {test-number} - x >= old_x for: 64 >= 32 4259 # run_for_at_least, int 4260 ok {test-number} - x >= old_x for: 128 >= 64 4261 # run_for_at_least, int 4262 ok {test-number} - Timing.elapsed >= time for: 128 ns >= 100 ns 4263 # run_for_at_least, int 4264 ok {test-number} - Timing.result == Timing.iterations + 17 for: 145 == 145 4265 # run_for_at_least, int 4266 ok {test-number} - Timing.iterations >= time.count() for: 128 >= 100 4267 # sections can be skipped dynamically at runtime 4268 ok {test-number} - 4269 # sections can be skipped dynamically at runtime 4270 ok {test-number} - # SKIP 4271 # sections can be skipped dynamically at runtime 4272 ok {test-number} - 4273 # send a single char to INFO 4274 not ok {test-number} - false with 1 message: '3' 4275 # sends information to INFO 4276 not ok {test-number} - false with 2 messages: 'hi' and 'i := 7' 4277 # shortened hide tags are split apart 4278 ok {test-number} - testcase.tags, VectorContains( Tag( "magic-tag" ) ) && VectorContains( Tag( "."_catch_sr ) ) for: { {?}, {?} } ( Contains: {?} and Contains: {?} ) 4279 # skipped tests can optionally provide a reason 4280 ok {test-number} - # SKIP 'skipping because answer = 43' 4281 # splitString 4282 ok {test-number} - splitStringRef("", ','), Equals(std::vector<StringRef>()) for: { } Equals: { } 4283 # splitString 4284 ok {test-number} - splitStringRef("abc", ','), Equals(std::vector<StringRef>{"abc"}) for: { abc } Equals: { abc } 4285 # splitString 4286 ok {test-number} - splitStringRef("abc,def", ','), Equals(std::vector<StringRef>{"abc", "def"}) for: { abc, def } Equals: { abc, def } 4287 # stacks unscoped info in loops 4288 not ok {test-number} - false with 4 messages: 'Count 1 to 3...' and '1' and '2' and '3' 4289 # stacks unscoped info in loops 4290 not ok {test-number} - false with 4 messages: 'Count 4 to 6...' and '4' and '5' and '6' 4291 # startsWith 4292 ok {test-number} - !(startsWith("", 'c')) for: !false 4293 # startsWith 4294 ok {test-number} - startsWith(std::string("abc"), 'a') for: true 4295 # startsWith 4296 ok {test-number} - startsWith("def"_catch_sr, 'd') for: true 4297 # std::map is convertible string 4298 ok {test-number} - Catch::Detail::stringify( emptyMap ) == "{ }" for: "{ }" == "{ }" 4299 # std::map is convertible string 4300 ok {test-number} - Catch::Detail::stringify( map ) == "{ { \"one\", 1 } }" for: "{ { "one", 1 } }" == "{ { "one", 1 } }" 4301 # std::map is convertible string 4302 ok {test-number} - Catch::Detail::stringify( map ) == "{ { \"abc\", 1 }, { \"def\", 2 }, { \"ghi\", 3 } }" for: "{ { "abc", 1 }, { "def", 2 }, { "ghi", 3 } }" == "{ { "abc", 1 }, { "def", 2 }, { "ghi", 3 } }" 4303 # std::pair<int,const std::string> -> toString 4304 ok {test-number} - ::Catch::Detail::stringify(value) == "{ 34, \"xyzzy\" }" for: "{ 34, "xyzzy" }" == "{ 34, "xyzzy" }" 4305 # std::pair<int,std::string> -> toString 4306 ok {test-number} - ::Catch::Detail::stringify( value ) == "{ 34, \"xyzzy\" }" for: "{ 34, "xyzzy" }" == "{ 34, "xyzzy" }" 4307 # std::set is convertible string 4308 ok {test-number} - Catch::Detail::stringify( emptySet ) == "{ }" for: "{ }" == "{ }" 4309 # std::set is convertible string 4310 ok {test-number} - Catch::Detail::stringify( set ) == "{ \"one\" }" for: "{ "one" }" == "{ "one" }" 4311 # std::set is convertible string 4312 ok {test-number} - Catch::Detail::stringify( set ) == "{ \"abc\", \"def\", \"ghi\" }" for: "{ "abc", "def", "ghi" }" == "{ "abc", "def", "ghi" }" 4313 # std::vector<std::pair<std::string,int> > -> toString 4314 ok {test-number} - ::Catch::Detail::stringify( pr ) == "{ { \"green\", 55 } }" for: "{ { "green", 55 } }" == "{ { "green", 55 } }" 4315 # stdout and stderr streams have %-starting name 4316 ok {test-number} - Catch::makeStream( "%stderr" )->isConsole() for: true 4317 # stdout and stderr streams have %-starting name 4318 ok {test-number} - Catch::makeStream( "%stdout" )->isConsole() for: true 4319 # stringify ranges 4320 ok {test-number} - ::Catch::Detail::stringify(streamable_range{}) == "op<<(streamable_range)" for: "op<<(streamable_range)" == "op<<(streamable_range)" 4321 # stringify ranges 4322 ok {test-number} - ::Catch::Detail::stringify(stringmaker_range{}) == "stringmaker(streamable_range)" for: "stringmaker(streamable_range)" == "stringmaker(streamable_range)" 4323 # stringify ranges 4324 ok {test-number} - ::Catch::Detail::stringify(just_range{}) == "{ 1, 2, 3, 4 }" for: "{ 1, 2, 3, 4 }" == "{ 1, 2, 3, 4 }" 4325 # stringify ranges 4326 ok {test-number} - ::Catch::Detail::stringify(disabled_range{}) == "{?}" for: "{?}" == "{?}" 4327 # stringify( has_maker ) 4328 ok {test-number} - ::Catch::Detail::stringify( item ) == "StringMaker<has_maker>" for: "StringMaker<has_maker>" == "StringMaker<has_maker>" 4329 # stringify( has_maker_and_operator ) 4330 ok {test-number} - ::Catch::Detail::stringify( item ) == "StringMaker<has_maker_and_operator>" for: "StringMaker<has_maker_and_operator>" == "StringMaker<has_maker_and_operator>" 4331 # stringify( has_neither ) 4332 ok {test-number} - ::Catch::Detail::stringify(item) == "{?}" for: "{?}" == "{?}" 4333 # stringify( has_operator ) 4334 ok {test-number} - ::Catch::Detail::stringify( item ) == "operator<<( has_operator )" for: "operator<<( has_operator )" == "operator<<( has_operator )" 4335 # stringify( has_template_operator ) 4336 ok {test-number} - ::Catch::Detail::stringify( item ) == "operator<<( has_template_operator )" for: "operator<<( has_template_operator )" == "operator<<( has_template_operator )" 4337 # stringify( vectors<has_maker> ) 4338 ok {test-number} - ::Catch::Detail::stringify( v ) == "{ StringMaker<has_maker> }" for: "{ StringMaker<has_maker> }" == "{ StringMaker<has_maker> }" 4339 # stringify( vectors<has_maker_and_operator> ) 4340 ok {test-number} - ::Catch::Detail::stringify( v ) == "{ StringMaker<has_maker_and_operator> }" for: "{ StringMaker<has_maker_and_operator> }" == "{ StringMaker<has_maker_and_operator> }" 4341 # stringify( vectors<has_operator> ) 4342 ok {test-number} - ::Catch::Detail::stringify( v ) == "{ operator<<( has_operator ) }" for: "{ operator<<( has_operator ) }" == "{ operator<<( has_operator ) }" 4343 # strlen3 4344 ok {test-number} - data.str.size() == data.len for: 3 == 3 4345 # strlen3 4346 ok {test-number} - data.str.size() == data.len for: 3 == 3 4347 # strlen3 4348 ok {test-number} - data.str.size() == data.len for: 5 == 5 4349 # strlen3 4350 ok {test-number} - data.str.size() == data.len for: 4 == 4 4351 # tables 4352 ok {test-number} - strlen(std::get<0>(data)) == static_cast<size_t>(std::get<1>(data)) for: 5 == 5 4353 # tables 4354 ok {test-number} - strlen(std::get<0>(data)) == static_cast<size_t>(std::get<1>(data)) for: 6 == 6 4355 # tables 4356 ok {test-number} - strlen(std::get<0>(data)) == static_cast<size_t>(std::get<1>(data)) for: 5 == 5 4357 # tables 4358 ok {test-number} - strlen(std::get<0>(data)) == static_cast<size_t>(std::get<1>(data)) for: 6 == 6 4359 # tags with dots in later positions are not parsed as hidden 4360 ok {test-number} - testcase.tags.size() == 1 for: 1 == 1 4361 # tags with dots in later positions are not parsed as hidden 4362 ok {test-number} - testcase.tags[0].original == "magic.tag"_catch_sr for: magic.tag == magic.tag 4363 # tests can be skipped dynamically at runtime 4364 ok {test-number} - # SKIP 4365 # thrown std::strings are translated 4366 not ok {test-number} - unexpected exception with message: 'Why would you throw a std::string?' 4367 # toString on const wchar_t const pointer returns the string contents 4368 ok {test-number} - result == "\"wide load\"" for: ""wide load"" == ""wide load"" 4369 # toString on const wchar_t pointer returns the string contents 4370 ok {test-number} - result == "\"wide load\"" for: ""wide load"" == ""wide load"" 4371 # toString on wchar_t const pointer returns the string contents 4372 ok {test-number} - result == "\"wide load\"" for: ""wide load"" == ""wide load"" 4373 # toString on wchar_t returns the string contents 4374 ok {test-number} - result == "\"wide load\"" for: ""wide load"" == ""wide load"" 4375 # toString(enum class w/operator<<) 4376 ok {test-number} - ::Catch::Detail::stringify(e0) == "E2/V0" for: "E2/V0" == "E2/V0" 4377 # toString(enum class w/operator<<) 4378 ok {test-number} - ::Catch::Detail::stringify(e1) == "E2/V1" for: "E2/V1" == "E2/V1" 4379 # toString(enum class w/operator<<) 4380 ok {test-number} - ::Catch::Detail::stringify(e3) == "Unknown enum value 10" for: "Unknown enum value 10" == "Unknown enum value 10" 4381 # toString(enum class) 4382 ok {test-number} - ::Catch::Detail::stringify(e0) == "0" for: "0" == "0" 4383 # toString(enum class) 4384 ok {test-number} - ::Catch::Detail::stringify(e1) == "1" for: "1" == "1" 4385 # toString(enum w/operator<<) 4386 ok {test-number} - ::Catch::Detail::stringify(e0) == "E2{0}" for: "E2{0}" == "E2{0}" 4387 # toString(enum w/operator<<) 4388 ok {test-number} - ::Catch::Detail::stringify(e1) == "E2{1}" for: "E2{1}" == "E2{1}" 4389 # toString(enum) 4390 ok {test-number} - ::Catch::Detail::stringify(e0) == "0" for: "0" == "0" 4391 # toString(enum) 4392 ok {test-number} - ::Catch::Detail::stringify(e1) == "1" for: "1" == "1" 4393 # tuple<> 4394 ok {test-number} - "{ }" == ::Catch::Detail::stringify(type{}) for: "{ }" == "{ }" 4395 # tuple<> 4396 ok {test-number} - "{ }" == ::Catch::Detail::stringify(value) for: "{ }" == "{ }" 4397 # tuple<float,int> 4398 ok {test-number} - "1.2f" == ::Catch::Detail::stringify(float(1.2)) for: "1.2f" == "1.2f" 4399 # tuple<float,int> 4400 ok {test-number} - "{ 1.2f, 0 }" == ::Catch::Detail::stringify(type{1.2f,0}) for: "{ 1.2f, 0 }" == "{ 1.2f, 0 }" 4401 # tuple<int> 4402 ok {test-number} - "{ 0 }" == ::Catch::Detail::stringify(type{0}) for: "{ 0 }" == "{ 0 }" 4403 # tuple<string,string> 4404 ok {test-number} - "{ \"hello\", \"world\" }" == ::Catch::Detail::stringify(type{"hello","world"}) for: "{ "hello", "world" }" == "{ "hello", "world" }" 4405 # tuple<tuple<int>,tuple<>,float> 4406 ok {test-number} - "{ { 42 }, { }, 1.2f }" == ::Catch::Detail::stringify(value) for: "{ { 42 }, { }, 1.2f }" == "{ { 42 }, { }, 1.2f }" 4407 # uniform samples 4408 ok {test-number} - e.point == 23 for: 23.0 == 23 4409 # uniform samples 4410 ok {test-number} - e.upper_bound == 23 for: 23.0 == 23 4411 # uniform samples 4412 ok {test-number} - e.lower_bound == 23 for: 23.0 == 23 4413 # uniform samples 4414 ok {test-number} - e.confidence_interval == 0.95 for: 0.95 == 0.95 4415 # uniform_integer_distribution can return the bounds 4416 ok {test-number} - dist.a() == -10 for: -10 == -10 4417 # uniform_integer_distribution can return the bounds 4418 ok {test-number} - dist.b() == 10 for: 10 == 10 4419 # unique_ptr reimplementation: basic functionality 4420 ok {test-number} - !(ptr) for: !{?} 4421 # unique_ptr reimplementation: basic functionality 4422 ok {test-number} - ptr.get() == 0 for: 0 == 0 4423 # unique_ptr reimplementation: basic functionality 4424 ok {test-number} - ptr for: {?} 4425 # unique_ptr reimplementation: basic functionality 4426 ok {test-number} - *ptr == 0 for: 0 == 0 4427 # unique_ptr reimplementation: basic functionality 4428 ok {test-number} - ptr.get() == naked_ptr for: 0x<hex digits> == 0x<hex digits> 4429 # unique_ptr reimplementation: basic functionality 4430 ok {test-number} - !(ptr) for: !{?} 4431 # unique_ptr reimplementation: basic functionality 4432 ok {test-number} - ptr.get() == 0 for: 0 == 0 4433 # unique_ptr reimplementation: basic functionality 4434 ok {test-number} - ptr for: {?} 4435 # unique_ptr reimplementation: basic functionality 4436 ok {test-number} - *ptr == 0 for: 0 == 0 4437 # unique_ptr reimplementation: basic functionality 4438 ok {test-number} - ptr.get() == naked_ptr for: 0x<hex digits> == 0x<hex digits> 4439 # unique_ptr reimplementation: basic functionality 4440 ok {test-number} - ptr for: {?} 4441 # unique_ptr reimplementation: basic functionality 4442 ok {test-number} - ptr.get() != 0 for: 0x<hex digits> != 0 4443 # unique_ptr reimplementation: basic functionality 4444 ok {test-number} - *ptr == 2 for: 2 == 2 4445 # unique_ptr reimplementation: basic functionality 4446 ok {test-number} - !(ptr) for: !{?} 4447 # unique_ptr reimplementation: basic functionality 4448 ok {test-number} - ptr.get() == 0 for: 0 == 0 4449 # unique_ptr reimplementation: basic functionality 4450 ok {test-number} - !(ptr1) for: !{?} 4451 # unique_ptr reimplementation: basic functionality 4452 ok {test-number} - ptr2 for: {?} 4453 # unique_ptr reimplementation: basic functionality 4454 ok {test-number} - *ptr2 == 1 for: 1 == 1 4455 # unique_ptr reimplementation: basic functionality 4456 ok {test-number} - !(ptr2) for: !{?} 4457 # unique_ptr reimplementation: basic functionality 4458 ok {test-number} - ptr1 for: {?} 4459 # unique_ptr reimplementation: basic functionality 4460 ok {test-number} - *ptr1 == 2 for: 2 == 2 4461 # unique_ptr reimplementation: basic functionality 4462 ok {test-number} - *ptr1 == 2 for: 2 == 2 4463 # unique_ptr reimplementation: basic functionality 4464 ok {test-number} - *ptr2 == 1 for: 1 == 1 4465 # vec<vec<string,alloc>> -> toString 4466 ok {test-number} - ::Catch::Detail::stringify(v) == "{ }" for: "{ }" == "{ }" 4467 # vec<vec<string,alloc>> -> toString 4468 ok {test-number} - ::Catch::Detail::stringify(v) == "{ { \"hello\" }, { \"world\" } }" for: "{ { "hello" }, { "world" } }" == "{ { "hello" }, { "world" } }" 4469 # vector<bool> -> toString 4470 ok {test-number} - ::Catch::Detail::stringify(bools) == "{ }" for: "{ }" == "{ }" 4471 # vector<bool> -> toString 4472 ok {test-number} - ::Catch::Detail::stringify(bools) == "{ true }" for: "{ true }" == "{ true }" 4473 # vector<bool> -> toString 4474 ok {test-number} - ::Catch::Detail::stringify(bools) == "{ true, false }" for: "{ true, false }" == "{ true, false }" 4475 # vector<int,allocator> -> toString 4476 ok {test-number} - ::Catch::Detail::stringify(vv) == "{ }" for: "{ }" == "{ }" 4477 # vector<int,allocator> -> toString 4478 ok {test-number} - ::Catch::Detail::stringify(vv) == "{ 42 }" for: "{ 42 }" == "{ 42 }" 4479 # vector<int,allocator> -> toString 4480 ok {test-number} - ::Catch::Detail::stringify(vv) == "{ 42, 250 }" for: "{ 42, 250 }" == "{ 42, 250 }" 4481 # vector<int> -> toString 4482 ok {test-number} - ::Catch::Detail::stringify(vv) == "{ }" for: "{ }" == "{ }" 4483 # vector<int> -> toString 4484 ok {test-number} - ::Catch::Detail::stringify(vv) == "{ 42 }" for: "{ 42 }" == "{ 42 }" 4485 # vector<int> -> toString 4486 ok {test-number} - ::Catch::Detail::stringify(vv) == "{ 42, 250 }" for: "{ 42, 250 }" == "{ 42, 250 }" 4487 # vector<string> -> toString 4488 ok {test-number} - ::Catch::Detail::stringify(vv) == "{ }" for: "{ }" == "{ }" 4489 # vector<string> -> toString 4490 ok {test-number} - ::Catch::Detail::stringify(vv) == "{ \"hello\" }" for: "{ "hello" }" == "{ "hello" }" 4491 # vector<string> -> toString 4492 ok {test-number} - ::Catch::Detail::stringify(vv) == "{ \"hello\", \"world\" }" for: "{ "hello", "world" }" == "{ "hello", "world" }" 4493 # vectors can be sized and resized 4494 ok {test-number} - v.size() == 5 for: 5 == 5 4495 # vectors can be sized and resized 4496 ok {test-number} - v.capacity() >= 5 for: 5 >= 5 4497 # vectors can be sized and resized 4498 ok {test-number} - v.size() == 10 for: 10 == 10 4499 # vectors can be sized and resized 4500 ok {test-number} - v.capacity() >= 10 for: 10 >= 10 4501 # vectors can be sized and resized 4502 ok {test-number} - v.size() == 5 for: 5 == 5 4503 # vectors can be sized and resized 4504 ok {test-number} - v.capacity() >= 5 for: 5 >= 5 4505 # vectors can be sized and resized 4506 ok {test-number} - v.size() == 0 for: 0 == 0 4507 # vectors can be sized and resized 4508 ok {test-number} - v.capacity() >= 5 for: 5 >= 5 4509 # vectors can be sized and resized 4510 ok {test-number} - v.capacity() == 0 for: 0 == 0 4511 # vectors can be sized and resized 4512 ok {test-number} - v.size() == 5 for: 5 == 5 4513 # vectors can be sized and resized 4514 ok {test-number} - v.capacity() >= 5 for: 5 >= 5 4515 # vectors can be sized and resized 4516 ok {test-number} - v.size() == 5 for: 5 == 5 4517 # vectors can be sized and resized 4518 ok {test-number} - v.capacity() >= 10 for: 10 >= 10 4519 # vectors can be sized and resized 4520 ok {test-number} - v.size() == 5 for: 5 == 5 4521 # vectors can be sized and resized 4522 ok {test-number} - v.capacity() >= 5 for: 5 >= 5 4523 # vectors can be sized and resized 4524 ok {test-number} - v.size() == 5 for: 5 == 5 4525 # vectors can be sized and resized 4526 ok {test-number} - v.capacity() >= 5 for: 5 >= 5 4527 # warmup 4528 ok {test-number} - (iterations * rate) > Catch::Benchmark::Detail::warmup_time.count() for: 160000000 (0x<hex digits>) > 100 4529 # warmup 4530 ok {test-number} - (end - start) > Catch::Benchmark::Detail::warmup_time for: 310016000 ns > 100 ms 4531 # weighted_average_quantile 4532 ok {test-number} - q1 == 14.5 for: 14.5 == 14.5 4533 # weighted_average_quantile 4534 ok {test-number} - med == 18. for: 18.0 == 18.0 4535 # weighted_average_quantile 4536 ok {test-number} - q3 == 23. for: 23.0 == 23.0 4537 # xmlentitycheck 4538 ok {test-number} - 4539 # xmlentitycheck 4540 ok {test-number} - 4541 1..2272 4542