1# ========================================== 2# CMock Project - Automatic Mock Generation for C 3# Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams 4# [Released under MIT License. Please refer to license.txt for details] 5# ========================================== 6 7require '../auto/generate_test_runner.rb' 8 9$generate_test_runner_tests = 0 10$generate_test_runner_failures = 0 11 12OUT_FILE = 'build/testsample_' 13 14RUNNER_TESTS = [ 15 { :name => 'DefaultsThroughOptions', 16 :testfile => 'testdata/testRunnerGenerator.c', 17 :testdefines => ['TEST'], 18 :options => nil, #defaults 19 :expected => { 20 :to_pass => [ 'test_ThisTestAlwaysPasses', 21 'spec_ThisTestPassesWhenNormalSetupRan', 22 'spec_ThisTestPassesWhenNormalTeardownRan', 23 'test_NotBeConfusedByLongComplicatedStrings', 24 'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings', 25 'test_StillNotBeConfusedByLongComplicatedStrings', 26 'should_RunTestsStartingWithShouldByDefault', 27 'spec_ThisTestPassesWhenNormalSuiteSetupAndTeardownRan', 28 ], 29 :to_fail => [ 'test_ThisTestAlwaysFails' ], 30 :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], 31 } 32 }, 33 34 { :name => 'DefaultsThroughCommandLine', 35 :testfile => 'testdata/testRunnerGenerator.c', 36 :testdefines => ['TEST'], 37 :cmdline => "", #defaults 38 :expected => { 39 :to_pass => [ 'test_ThisTestAlwaysPasses', 40 'spec_ThisTestPassesWhenNormalSetupRan', 41 'spec_ThisTestPassesWhenNormalTeardownRan', 42 'test_NotBeConfusedByLongComplicatedStrings', 43 'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings', 44 'test_StillNotBeConfusedByLongComplicatedStrings', 45 'should_RunTestsStartingWithShouldByDefault', 46 'spec_ThisTestPassesWhenNormalSuiteSetupAndTeardownRan', 47 ], 48 :to_fail => [ 'test_ThisTestAlwaysFails' ], 49 :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], 50 } 51 }, 52 53 { :name => 'DefaultsThroughYAMLFile', 54 :testfile => 'testdata/testRunnerGenerator.c', 55 :testdefines => ['TEST'], 56 :cmdline => "", #defaults 57 :yaml => {}, #defaults 58 :expected => { 59 :to_pass => [ 'test_ThisTestAlwaysPasses', 60 'spec_ThisTestPassesWhenNormalSetupRan', 61 'spec_ThisTestPassesWhenNormalTeardownRan', 62 'test_NotBeConfusedByLongComplicatedStrings', 63 'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings', 64 'test_StillNotBeConfusedByLongComplicatedStrings', 65 'should_RunTestsStartingWithShouldByDefault', 66 'spec_ThisTestPassesWhenNormalSuiteSetupAndTeardownRan', 67 ], 68 :to_fail => [ 'test_ThisTestAlwaysFails' ], 69 :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], 70 } 71 }, 72 73 { :name => 'ShorterFilterOfJustTest', 74 :testfile => 'testdata/testRunnerGenerator.c', 75 :testdefines => ['TEST'], 76 :options => { 77 :test_prefix => "test", 78 }, 79 :expected => { 80 :to_pass => [ 'test_ThisTestAlwaysPasses', 81 'test_NotBeConfusedByLongComplicatedStrings', 82 'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings', 83 'test_StillNotBeConfusedByLongComplicatedStrings', 84 ], 85 :to_fail => [ 'test_ThisTestAlwaysFails' ], 86 :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], 87 } 88 }, 89 90 { :name => 'ShorterFilterOfJustShould', 91 :testfile => 'testdata/testRunnerGenerator.c', 92 :testdefines => ['TEST'], 93 :options => { 94 :test_prefix => "should", 95 }, 96 :expected => { 97 :to_pass => [ 'should_RunTestsStartingWithShouldByDefault' ], 98 :to_fail => [ ], 99 :to_ignore => [ ], 100 } 101 }, 102 103 { :name => 'ShorterFilterOfJustSpec', 104 :testfile => 'testdata/testRunnerGenerator.c', 105 :testdefines => ['TEST'], 106 :options => { 107 :test_prefix => "spec", 108 }, 109 :expected => { 110 :to_pass => [ 'spec_ThisTestPassesWhenNormalSetupRan', 111 'spec_ThisTestPassesWhenNormalTeardownRan', 112 'spec_ThisTestPassesWhenNormalSuiteSetupAndTeardownRan', 113 ], 114 :to_fail => [ ], 115 :to_ignore => [ ], 116 } 117 }, 118 119 { :name => 'InjectIncludes', 120 :testfile => 'testdata/testRunnerGenerator.c', 121 :testdefines => ['TEST'], 122 :options => { 123 :includes => ['Defs.h'], 124 }, 125 :expected => { 126 :to_pass => [ 'test_ThisTestAlwaysPasses', 127 'spec_ThisTestPassesWhenNormalSetupRan', 128 'spec_ThisTestPassesWhenNormalTeardownRan', 129 'test_NotBeConfusedByLongComplicatedStrings', 130 'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings', 131 'test_StillNotBeConfusedByLongComplicatedStrings', 132 'should_RunTestsStartingWithShouldByDefault', 133 'spec_ThisTestPassesWhenNormalSuiteSetupAndTeardownRan', 134 ], 135 :to_fail => [ 'test_ThisTestAlwaysFails' ], 136 :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], 137 } 138 }, 139 140 { :name => 'ParameterizedThroughOptions', 141 :testfile => 'testdata/testRunnerGenerator.c', 142 :testdefines => ['TEST'], 143 :options => { 144 :test_prefix => "paratest", 145 :use_param_tests => true, 146 }, 147 :features => [ :parameterized ], 148 :expected => { 149 :to_pass => [ 'paratest_ShouldHandleParameterizedTests\(25\)', 150 'paratest_ShouldHandleParameterizedTests\(125\)', 151 'paratest_ShouldHandleParameterizedTests\(5\)', 152 'paratest_ShouldHandleParameterizedTests2\(7\)', 153 'paratest_ShouldHandleNonParameterizedTestsWhenParameterizationValid', 154 ], 155 :to_fail => [ 'paratest_ShouldHandleParameterizedTestsThatFail\(17\)' ], 156 :to_ignore => [ ], 157 } 158 }, 159 160 { :name => 'ParameterizedThroughCommandLine', 161 :testfile => 'testdata/testRunnerGenerator.c', 162 :testdefines => ['TEST'], 163 :cmdline => " --test_prefix=\"paratest\" --use_param_tests=1", 164 :features => [ :parameterized ], 165 :expected => { 166 :to_pass => [ 'paratest_ShouldHandleParameterizedTests\(25\)', 167 'paratest_ShouldHandleParameterizedTests\(125\)', 168 'paratest_ShouldHandleParameterizedTests\(5\)', 169 'paratest_ShouldHandleParameterizedTests2\(7\)', 170 'paratest_ShouldHandleNonParameterizedTestsWhenParameterizationValid', 171 ], 172 :to_fail => [ 'paratest_ShouldHandleParameterizedTestsThatFail\(17\)' ], 173 :to_ignore => [ ], 174 } 175 }, 176 177 { :name => 'ParameterizedThroughCommandLineAndYaml', 178 :testfile => 'testdata/testRunnerGenerator.c', 179 :testdefines => ['TEST'], 180 :cmdline => "--use_param_tests=1", 181 :yaml => { 182 :test_prefix => "paratest" 183 }, 184 :features => [ :parameterized ], 185 :expected => { 186 :to_pass => [ 'paratest_ShouldHandleParameterizedTests\(25\)', 187 'paratest_ShouldHandleParameterizedTests\(125\)', 188 'paratest_ShouldHandleParameterizedTests\(5\)', 189 'paratest_ShouldHandleParameterizedTests2\(7\)', 190 'paratest_ShouldHandleNonParameterizedTestsWhenParameterizationValid', 191 ], 192 :to_fail => [ 'paratest_ShouldHandleParameterizedTestsThatFail\(17\)' ], 193 :to_ignore => [ ], 194 } 195 }, 196 197 { :name => 'CException', 198 :testfile => 'testdata/testRunnerGenerator.c', 199 :testdefines => ['TEST', 'USE_CEXCEPTION'], 200 :options => { 201 :test_prefix => "extest", 202 :plugins => [ :cexception ], 203 }, 204 :expected => { 205 :to_pass => [ 'extest_ShouldHandleCExceptionInTest' ], 206 :to_fail => [ ], 207 :to_ignore => [ ], 208 } 209 }, 210 211 { :name => 'CustomSetupAndTeardownThroughOptions', 212 :testfile => 'testdata/testRunnerGenerator.c', 213 :testdefines => ['TEST'], 214 :options => { 215 :test_prefix => "custtest|test", 216 :setup_name => "custom_setup", 217 :teardown_name => "custom_teardown", 218 }, 219 :expected => { 220 :to_pass => [ 'test_ThisTestAlwaysPasses', 221 'test_NotBeConfusedByLongComplicatedStrings', 222 'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings', 223 'test_StillNotBeConfusedByLongComplicatedStrings', 224 'custtest_ThisTestPassesWhenCustomSetupRan', 225 'custtest_ThisTestPassesWhenCustomTeardownRan', 226 ], 227 :to_fail => [ 'test_ThisTestAlwaysFails' ], 228 :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], 229 } 230 }, 231 232 { :name => 'CustomSetupAndTeardownThroughCommandLine', 233 :testfile => 'testdata/testRunnerGenerator.c', 234 :testdefines => ['TEST'], 235 :cmdline => " --test_prefix=\"custtest|test\" --setup_name=\"custom_setup\" --teardown_name=\"custom_teardown\"", 236 :expected => { 237 :to_pass => [ 'test_ThisTestAlwaysPasses', 238 'test_NotBeConfusedByLongComplicatedStrings', 239 'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings', 240 'test_StillNotBeConfusedByLongComplicatedStrings', 241 'custtest_ThisTestPassesWhenCustomSetupRan', 242 'custtest_ThisTestPassesWhenCustomTeardownRan', 243 ], 244 :to_fail => [ 'test_ThisTestAlwaysFails' ], 245 :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], 246 } 247 }, 248 249 { :name => 'CustomSetupAndTeardownThroughYaml', 250 :testfile => 'testdata/testRunnerGenerator.c', 251 :testdefines => ['TEST'], 252 :cmdline => " --test_prefix=\"custtest|test\"", 253 :yaml => { 254 :setup_name => "custom_setup", 255 :teardown_name => "custom_teardown", 256 }, 257 :expected => { 258 :to_pass => [ 'test_ThisTestAlwaysPasses', 259 'test_NotBeConfusedByLongComplicatedStrings', 260 'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings', 261 'test_StillNotBeConfusedByLongComplicatedStrings', 262 'custtest_ThisTestPassesWhenCustomSetupRan', 263 'custtest_ThisTestPassesWhenCustomTeardownRan', 264 ], 265 :to_fail => [ 'test_ThisTestAlwaysFails' ], 266 :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], 267 } 268 }, 269 270 { :name => 'CustomMain', 271 :testfile => 'testdata/testRunnerGenerator.c', 272 :testdefines => ['TEST', "USE_ANOTHER_MAIN"], 273 :options => { 274 :main_name => "custom_main", 275 }, 276 :expected => { 277 :to_pass => [ 'test_ThisTestAlwaysPasses', 278 'spec_ThisTestPassesWhenNormalSetupRan', 279 'spec_ThisTestPassesWhenNormalTeardownRan', 280 'test_NotBeConfusedByLongComplicatedStrings', 281 'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings', 282 'test_StillNotBeConfusedByLongComplicatedStrings', 283 'should_RunTestsStartingWithShouldByDefault', 284 'spec_ThisTestPassesWhenNormalSuiteSetupAndTeardownRan', 285 ], 286 :to_fail => [ 'test_ThisTestAlwaysFails' ], 287 :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], 288 } 289 }, 290 291 { :name => 'CustomSuiteSetupAndTeardown', 292 :testfile => 'testdata/testRunnerGenerator.c', 293 :testdefines => ['TEST'], 294 :includes => ['Defs.h'], 295 :options => { 296 :test_prefix => "suitetest|test", 297 :suite_setup => " CounterSuiteSetup = 1;", 298 :suite_teardown => " return num_failures;", 299 }, 300 :expected => { 301 :to_pass => [ 'test_ThisTestAlwaysPasses', 302 'test_NotBeConfusedByLongComplicatedStrings', 303 'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings', 304 'test_StillNotBeConfusedByLongComplicatedStrings', 305 'suitetest_ThisTestPassesWhenCustomSuiteSetupAndTeardownRan', 306 ], 307 :to_fail => [ 'test_ThisTestAlwaysFails' ], 308 :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], 309 } 310 }, 311 312 { :name => 'MainExternDeclaration', 313 :testfile => 'testdata/testRunnerGenerator.c', 314 :testdefines => ['TEST'], 315 :includes => ['Defs.h'], 316 :options => { 317 :main_export_decl => "EXTERN_DECL", 318 }, 319 :expected => { 320 :to_pass => [ 'test_ThisTestAlwaysPasses', 321 'spec_ThisTestPassesWhenNormalSetupRan', 322 'spec_ThisTestPassesWhenNormalTeardownRan', 323 'test_NotBeConfusedByLongComplicatedStrings', 324 'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings', 325 'test_StillNotBeConfusedByLongComplicatedStrings', 326 'should_RunTestsStartingWithShouldByDefault', 327 'spec_ThisTestPassesWhenNormalSuiteSetupAndTeardownRan', 328 ], 329 :to_fail => [ 'test_ThisTestAlwaysFails' ], 330 :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], 331 } 332 }, 333 334 335 #### WITH MOCKS ########################################## 336 337 { :name => 'DefaultsThroughOptions', 338 :testfile => 'testdata/testRunnerGeneratorWithMocks.c', 339 :testdefines => ['TEST'], 340 :options => nil, #defaults 341 :expected => { 342 :to_pass => [ 'test_ThisTestAlwaysPasses', 343 'spec_ThisTestPassesWhenNormalSetupRan', 344 'spec_ThisTestPassesWhenNormalTeardownRan', 345 'test_NotBeConfusedByLongComplicatedStrings', 346 'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings', 347 'test_StillNotBeConfusedByLongComplicatedStrings', 348 'should_RunTestsStartingWithShouldByDefault', 349 'spec_ThisTestPassesWhenNormalSuiteSetupAndTeardownRan', 350 'test_ShouldCallMockInitAndVerifyFunctionsForEachTest', 351 ], 352 :to_fail => [ 'test_ThisTestAlwaysFails' ], 353 :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], 354 } 355 }, 356 357 { :name => 'DefaultsThroughCommandLine', 358 :testfile => 'testdata/testRunnerGeneratorWithMocks.c', 359 :testdefines => ['TEST'], 360 :cmdline => "", #defaults 361 :expected => { 362 :to_pass => [ 'test_ThisTestAlwaysPasses', 363 'spec_ThisTestPassesWhenNormalSetupRan', 364 'spec_ThisTestPassesWhenNormalTeardownRan', 365 'test_NotBeConfusedByLongComplicatedStrings', 366 'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings', 367 'test_StillNotBeConfusedByLongComplicatedStrings', 368 'should_RunTestsStartingWithShouldByDefault', 369 'spec_ThisTestPassesWhenNormalSuiteSetupAndTeardownRan', 370 'test_ShouldCallMockInitAndVerifyFunctionsForEachTest', 371 ], 372 :to_fail => [ 'test_ThisTestAlwaysFails' ], 373 :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], 374 } 375 }, 376 377 { :name => 'DefaultsThroughYAMLFile', 378 :testfile => 'testdata/testRunnerGeneratorWithMocks.c', 379 :testdefines => ['TEST'], 380 :cmdline => "", #defaults 381 :yaml => {}, #defaults 382 :expected => { 383 :to_pass => [ 'test_ThisTestAlwaysPasses', 384 'spec_ThisTestPassesWhenNormalSetupRan', 385 'spec_ThisTestPassesWhenNormalTeardownRan', 386 'test_NotBeConfusedByLongComplicatedStrings', 387 'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings', 388 'test_StillNotBeConfusedByLongComplicatedStrings', 389 'should_RunTestsStartingWithShouldByDefault', 390 'spec_ThisTestPassesWhenNormalSuiteSetupAndTeardownRan', 391 'test_ShouldCallMockInitAndVerifyFunctionsForEachTest', 392 ], 393 :to_fail => [ 'test_ThisTestAlwaysFails' ], 394 :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], 395 } 396 }, 397 398 { :name => 'ShorterFilterOfJustTest', 399 :testfile => 'testdata/testRunnerGeneratorWithMocks.c', 400 :testdefines => ['TEST'], 401 :options => { 402 :test_prefix => "test", 403 }, 404 :expected => { 405 :to_pass => [ 'test_ThisTestAlwaysPasses', 406 'test_NotBeConfusedByLongComplicatedStrings', 407 'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings', 408 'test_StillNotBeConfusedByLongComplicatedStrings', 409 'test_ShouldCallMockInitAndVerifyFunctionsForEachTest', 410 ], 411 :to_fail => [ 'test_ThisTestAlwaysFails' ], 412 :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], 413 } 414 }, 415 416 { :name => 'ShorterFilterOfJustShould', 417 :testfile => 'testdata/testRunnerGeneratorWithMocks.c', 418 :testdefines => ['TEST'], 419 :options => { 420 :test_prefix => "should", 421 }, 422 :expected => { 423 :to_pass => [ 'should_RunTestsStartingWithShouldByDefault' ], 424 :to_fail => [ ], 425 :to_ignore => [ ], 426 } 427 }, 428 429 { :name => 'ShorterFilterOfJustSpec', 430 :testfile => 'testdata/testRunnerGeneratorWithMocks.c', 431 :testdefines => ['TEST'], 432 :options => { 433 :test_prefix => "spec", 434 }, 435 :expected => { 436 :to_pass => [ 'spec_ThisTestPassesWhenNormalSetupRan', 437 'spec_ThisTestPassesWhenNormalTeardownRan', 438 'spec_ThisTestPassesWhenNormalSuiteSetupAndTeardownRan', 439 ], 440 :to_fail => [ ], 441 :to_ignore => [ ], 442 } 443 }, 444 445 { :name => 'InjectIncludes', 446 :testfile => 'testdata/testRunnerGeneratorWithMocks.c', 447 :testdefines => ['TEST'], 448 :options => { 449 :includes => ['Defs.h'], 450 }, 451 :expected => { 452 :to_pass => [ 'test_ThisTestAlwaysPasses', 453 'spec_ThisTestPassesWhenNormalSetupRan', 454 'spec_ThisTestPassesWhenNormalTeardownRan', 455 'test_NotBeConfusedByLongComplicatedStrings', 456 'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings', 457 'test_StillNotBeConfusedByLongComplicatedStrings', 458 'should_RunTestsStartingWithShouldByDefault', 459 'spec_ThisTestPassesWhenNormalSuiteSetupAndTeardownRan', 460 'test_ShouldCallMockInitAndVerifyFunctionsForEachTest', 461 ], 462 :to_fail => [ 'test_ThisTestAlwaysFails' ], 463 :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], 464 } 465 }, 466 467 { :name => 'ParameterizedThroughOptions', 468 :testfile => 'testdata/testRunnerGeneratorWithMocks.c', 469 :testdefines => ['TEST'], 470 :options => { 471 :test_prefix => "paratest", 472 :use_param_tests => true, 473 }, 474 :features => [ :parameterized ], 475 :expected => { 476 :to_pass => [ 'paratest_ShouldHandleParameterizedTests\(25\)', 477 'paratest_ShouldHandleParameterizedTests\(125\)', 478 'paratest_ShouldHandleParameterizedTests\(5\)', 479 'paratest_ShouldHandleParameterizedTests2\(7\)', 480 'paratest_ShouldHandleNonParameterizedTestsWhenParameterizationValid', 481 ], 482 :to_fail => [ 'paratest_ShouldHandleParameterizedTestsThatFail\(17\)' ], 483 :to_ignore => [ ], 484 } 485 }, 486 487 { :name => 'ParameterizedThroughCommandLine', 488 :testfile => 'testdata/testRunnerGeneratorWithMocks.c', 489 :testdefines => ['TEST'], 490 :cmdline => " --test_prefix=\"paratest\" --use_param_tests=1", 491 :features => [ :parameterized ], 492 :expected => { 493 :to_pass => [ 'paratest_ShouldHandleParameterizedTests\(25\)', 494 'paratest_ShouldHandleParameterizedTests\(125\)', 495 'paratest_ShouldHandleParameterizedTests\(5\)', 496 'paratest_ShouldHandleParameterizedTests2\(7\)', 497 'paratest_ShouldHandleNonParameterizedTestsWhenParameterizationValid', 498 ], 499 :to_fail => [ 'paratest_ShouldHandleParameterizedTestsThatFail\(17\)' ], 500 :to_ignore => [ ], 501 } 502 }, 503 504 { :name => 'ParameterizedThroughCommandLineAndYaml', 505 :testfile => 'testdata/testRunnerGeneratorWithMocks.c', 506 :testdefines => ['TEST'], 507 :cmdline => "--use_param_tests=1", 508 :yaml => { 509 :test_prefix => "paratest" 510 }, 511 :features => [ :parameterized ], 512 :expected => { 513 :to_pass => [ 'paratest_ShouldHandleParameterizedTests\(25\)', 514 'paratest_ShouldHandleParameterizedTests\(125\)', 515 'paratest_ShouldHandleParameterizedTests\(5\)', 516 'paratest_ShouldHandleParameterizedTests2\(7\)', 517 'paratest_ShouldHandleNonParameterizedTestsWhenParameterizationValid', 518 ], 519 :to_fail => [ 'paratest_ShouldHandleParameterizedTestsThatFail\(17\)' ], 520 :to_ignore => [ ], 521 } 522 }, 523 524 { :name => 'CException', 525 :testfile => 'testdata/testRunnerGeneratorWithMocks.c', 526 :testdefines => ['TEST', 'USE_CEXCEPTION'], 527 :options => { 528 :test_prefix => "extest", 529 :plugins => [ :cexception ], 530 }, 531 :expected => { 532 :to_pass => [ 'extest_ShouldHandleCExceptionInTest' ], 533 :to_fail => [ ], 534 :to_ignore => [ ], 535 } 536 }, 537 538 { :name => 'CustomSetupAndTeardownThroughOptions', 539 :testfile => 'testdata/testRunnerGeneratorWithMocks.c', 540 :testdefines => ['TEST'], 541 :options => { 542 :test_prefix => "custtest|test", 543 :setup_name => "custom_setup", 544 :teardown_name => "custom_teardown", 545 }, 546 :expected => { 547 :to_pass => [ 'test_ThisTestAlwaysPasses', 548 'test_NotBeConfusedByLongComplicatedStrings', 549 'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings', 550 'test_StillNotBeConfusedByLongComplicatedStrings', 551 'custtest_ThisTestPassesWhenCustomSetupRan', 552 'custtest_ThisTestPassesWhenCustomTeardownRan', 553 'test_ShouldCallMockInitAndVerifyFunctionsForEachTest', 554 ], 555 :to_fail => [ 'test_ThisTestAlwaysFails' ], 556 :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], 557 } 558 }, 559 560 { :name => 'CustomSetupAndTeardownThroughCommandLine', 561 :testfile => 'testdata/testRunnerGeneratorWithMocks.c', 562 :testdefines => ['TEST'], 563 :cmdline => " --test_prefix=\"custtest|test\" --setup_name=\"custom_setup\" --teardown_name=\"custom_teardown\"", 564 :expected => { 565 :to_pass => [ 'test_ThisTestAlwaysPasses', 566 'test_NotBeConfusedByLongComplicatedStrings', 567 'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings', 568 'test_StillNotBeConfusedByLongComplicatedStrings', 569 'custtest_ThisTestPassesWhenCustomSetupRan', 570 'custtest_ThisTestPassesWhenCustomTeardownRan', 571 'test_ShouldCallMockInitAndVerifyFunctionsForEachTest', 572 ], 573 :to_fail => [ 'test_ThisTestAlwaysFails' ], 574 :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], 575 } 576 }, 577 578 { :name => 'CustomSetupAndTeardownThroughYaml', 579 :testfile => 'testdata/testRunnerGeneratorWithMocks.c', 580 :testdefines => ['TEST'], 581 :cmdline => " --test_prefix=\"custtest|test\"", 582 :yaml => { 583 :setup_name => "custom_setup", 584 :teardown_name => "custom_teardown", 585 }, 586 :expected => { 587 :to_pass => [ 'test_ThisTestAlwaysPasses', 588 'test_NotBeConfusedByLongComplicatedStrings', 589 'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings', 590 'test_StillNotBeConfusedByLongComplicatedStrings', 591 'custtest_ThisTestPassesWhenCustomSetupRan', 592 'custtest_ThisTestPassesWhenCustomTeardownRan', 593 'test_ShouldCallMockInitAndVerifyFunctionsForEachTest', 594 ], 595 :to_fail => [ 'test_ThisTestAlwaysFails' ], 596 :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], 597 } 598 }, 599 600 { :name => 'CustomMain', 601 :testfile => 'testdata/testRunnerGeneratorWithMocks.c', 602 :testdefines => ['TEST', "USE_ANOTHER_MAIN"], 603 :options => { 604 :main_name => "custom_main", 605 }, 606 :expected => { 607 :to_pass => [ 'test_ThisTestAlwaysPasses', 608 'spec_ThisTestPassesWhenNormalSetupRan', 609 'spec_ThisTestPassesWhenNormalTeardownRan', 610 'test_NotBeConfusedByLongComplicatedStrings', 611 'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings', 612 'test_StillNotBeConfusedByLongComplicatedStrings', 613 'should_RunTestsStartingWithShouldByDefault', 614 'spec_ThisTestPassesWhenNormalSuiteSetupAndTeardownRan', 615 'test_ShouldCallMockInitAndVerifyFunctionsForEachTest', 616 ], 617 :to_fail => [ 'test_ThisTestAlwaysFails' ], 618 :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], 619 } 620 }, 621 622 { :name => 'CustomSuiteSetupAndTeardown', 623 :testfile => 'testdata/testRunnerGeneratorWithMocks.c', 624 :testdefines => ['TEST'], 625 :includes => ['Defs.h'], 626 :options => { 627 :test_prefix => "suitetest|test", 628 :suite_setup => " CounterSuiteSetup = 1;", 629 :suite_teardown => " return num_failures;", 630 }, 631 :expected => { 632 :to_pass => [ 'test_ThisTestAlwaysPasses', 633 'test_NotBeConfusedByLongComplicatedStrings', 634 'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings', 635 'test_StillNotBeConfusedByLongComplicatedStrings', 636 'suitetest_ThisTestPassesWhenCustomSuiteSetupAndTeardownRan', 637 'test_ShouldCallMockInitAndVerifyFunctionsForEachTest', 638 ], 639 :to_fail => [ 'test_ThisTestAlwaysFails' ], 640 :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], 641 } 642 }, 643 644 { :name => 'MainExternDeclaration', 645 :testfile => 'testdata/testRunnerGeneratorWithMocks.c', 646 :testdefines => ['TEST'], 647 :includes => ['Defs.h'], 648 :options => { 649 :main_export_decl => "EXTERN_DECL", 650 }, 651 :expected => { 652 :to_pass => [ 'test_ThisTestAlwaysPasses', 653 'spec_ThisTestPassesWhenNormalSetupRan', 654 'spec_ThisTestPassesWhenNormalTeardownRan', 655 'test_NotBeConfusedByLongComplicatedStrings', 656 'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings', 657 'test_StillNotBeConfusedByLongComplicatedStrings', 658 'should_RunTestsStartingWithShouldByDefault', 659 'spec_ThisTestPassesWhenNormalSuiteSetupAndTeardownRan', 660 'test_ShouldCallMockInitAndVerifyFunctionsForEachTest', 661 ], 662 :to_fail => [ 'test_ThisTestAlwaysFails' ], 663 :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], 664 } 665 }, 666 667 668 669 #### WITH ARGS ########################################## 670 671 { :name => 'ArgsThroughOptions', 672 :testfile => 'testdata/testRunnerGenerator.c', 673 :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'], 674 :options => { 675 :cmdline_args => true, 676 }, 677 :expected => { 678 :to_pass => [ 'test_ThisTestAlwaysPasses', 679 'spec_ThisTestPassesWhenNormalSetupRan', 680 'spec_ThisTestPassesWhenNormalTeardownRan', 681 'test_NotBeConfusedByLongComplicatedStrings', 682 'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings', 683 'test_StillNotBeConfusedByLongComplicatedStrings', 684 'should_RunTestsStartingWithShouldByDefault', 685 'spec_ThisTestPassesWhenNormalSuiteSetupAndTeardownRan', 686 ], 687 :to_fail => [ 'test_ThisTestAlwaysFails' ], 688 :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], 689 } 690 }, 691 692 { :name => 'ArgsThroughCommandLine', 693 :testfile => 'testdata/testRunnerGenerator.c', 694 :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'], 695 :cmdline => "--cmdline_args=1", 696 :expected => { 697 :to_pass => [ 'test_ThisTestAlwaysPasses', 698 'spec_ThisTestPassesWhenNormalSetupRan', 699 'spec_ThisTestPassesWhenNormalTeardownRan', 700 'test_NotBeConfusedByLongComplicatedStrings', 701 'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings', 702 'test_StillNotBeConfusedByLongComplicatedStrings', 703 'should_RunTestsStartingWithShouldByDefault', 704 'spec_ThisTestPassesWhenNormalSuiteSetupAndTeardownRan', 705 ], 706 :to_fail => [ 'test_ThisTestAlwaysFails' ], 707 :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], 708 } 709 }, 710 711 { :name => 'ArgsThroughYAMLFile', 712 :testfile => 'testdata/testRunnerGenerator.c', 713 :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'], 714 :cmdline => "", 715 :yaml => { 716 :cmdline_args => true, 717 }, 718 :expected => { 719 :to_pass => [ 'test_ThisTestAlwaysPasses', 720 'spec_ThisTestPassesWhenNormalSetupRan', 721 'spec_ThisTestPassesWhenNormalTeardownRan', 722 'test_NotBeConfusedByLongComplicatedStrings', 723 'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings', 724 'test_StillNotBeConfusedByLongComplicatedStrings', 725 'should_RunTestsStartingWithShouldByDefault', 726 'spec_ThisTestPassesWhenNormalSuiteSetupAndTeardownRan', 727 ], 728 :to_fail => [ 'test_ThisTestAlwaysFails' ], 729 :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], 730 } 731 }, 732 733 { :name => 'ArgsNameFilterJustTest', 734 :testfile => 'testdata/testRunnerGenerator.c', 735 :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'], 736 :options => { 737 :cmdline_args => true, 738 }, 739 :cmdline_args => "-n test_", 740 :expected => { 741 :to_pass => [ 'test_ThisTestAlwaysPasses', 742 'test_NotBeConfusedByLongComplicatedStrings', 743 'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings', 744 'test_StillNotBeConfusedByLongComplicatedStrings', 745 ], 746 :to_fail => [ 'test_ThisTestAlwaysFails' ], 747 :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], 748 } 749 }, 750 751 { :name => 'ArgsNameFilterJustShould', 752 :testfile => 'testdata/testRunnerGenerator.c', 753 :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'], 754 :options => { 755 :cmdline_args => true, 756 }, 757 :cmdline_args => "-n should_", 758 :expected => { 759 :to_pass => [ 'should_RunTestsStartingWithShouldByDefault' ], 760 :to_fail => [ ], 761 :to_ignore => [ ], 762 } 763 }, 764 765 { :name => 'ArgsNameFilterTestAndShould', 766 :testfile => 'testdata/testRunnerGenerator.c', 767 :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'], 768 :options => { 769 :cmdline_args => true, 770 }, 771 :cmdline_args => "-n should_,test_", 772 :expected => { 773 :to_pass => [ 'test_ThisTestAlwaysPasses', 774 'test_NotBeConfusedByLongComplicatedStrings', 775 'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings', 776 'test_StillNotBeConfusedByLongComplicatedStrings', 777 'should_RunTestsStartingWithShouldByDefault' ], 778 :to_fail => [ 'test_ThisTestAlwaysFails' ], 779 :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], 780 } 781 }, 782 783 { :name => 'ArgsNameFilterWithWildcardOnFile', 784 :testfile => 'testdata/testRunnerGeneratorSmall.c', 785 :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'], 786 :options => { 787 :cmdline_args => true, 788 }, 789 :cmdline_args => "-n=testRunnerGeneratorSma*", 790 :expected => { 791 :to_pass => [ 'test_ThisTestAlwaysPasses', 792 'spec_ThisTestPassesWhenNormalSetupRan', 793 'spec_ThisTestPassesWhenNormalTeardownRan' ], 794 :to_fail => [ 'test_ThisTestAlwaysFails' ], 795 :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], 796 } 797 }, 798 799 { :name => 'ArgsNameFilterWithWildcardAsName', 800 :testfile => 'testdata/testRunnerGeneratorSmall.c', 801 :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'], 802 :options => { 803 :cmdline_args => true, 804 }, 805 :cmdline_args => "-n testRunnerGeneratorSmall:*", 806 :expected => { 807 :to_pass => [ 'test_ThisTestAlwaysPasses', 808 'spec_ThisTestPassesWhenNormalSetupRan', 809 'spec_ThisTestPassesWhenNormalTeardownRan' ], 810 :to_fail => [ 'test_ThisTestAlwaysFails' ], 811 :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], 812 } 813 }, 814 815 { :name => 'ArgsNameFilterWithWildcardOnName', 816 :testfile => 'testdata/testRunnerGeneratorSmall.c', 817 :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'], 818 :options => { 819 :cmdline_args => true, 820 }, 821 :cmdline_args => "-n testRunnerGeneratorSmall:test_*", 822 :expected => { 823 :to_pass => [ 'test_ThisTestAlwaysPasses' ], 824 :to_fail => [ 'test_ThisTestAlwaysFails' ], 825 :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], 826 } 827 }, 828 829 { :name => 'ArgsNameFilterWithWildcardAndShortName', 830 :testfile => 'testdata/testRunnerGeneratorSmall.c', 831 :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'], 832 :options => { 833 :cmdline_args => true, 834 }, 835 :cmdline_args => "-n testRunnerGeneratorSmall:te*", 836 :expected => { 837 :to_pass => [ 'test_ThisTestAlwaysPasses' ], 838 :to_fail => [ 'test_ThisTestAlwaysFails' ], 839 :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], 840 } 841 }, 842 843 { :name => 'ArgsNameFilterWithWildcardOnBoth', 844 :testfile => 'testdata/testRunnerGeneratorSmall.c', 845 :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'], 846 :options => { 847 :cmdline_args => true, 848 }, 849 :cmdline_args => "-n testRunnerGeneratorSm*:*", 850 :expected => { 851 :to_pass => [ 'test_ThisTestAlwaysPasses', 852 'spec_ThisTestPassesWhenNormalSetupRan', 853 'spec_ThisTestPassesWhenNormalTeardownRan' ], 854 :to_fail => [ 'test_ThisTestAlwaysFails' ], 855 :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], 856 } 857 }, 858 859 { :name => 'ArgsExcludeFilterJustTest', 860 :testfile => 'testdata/testRunnerGenerator.c', 861 :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'], 862 :options => { 863 :cmdline_args => true, 864 }, 865 :cmdline_args => "-x test_", 866 :expected => { 867 :to_pass => [ 'spec_ThisTestPassesWhenNormalSetupRan', 868 'spec_ThisTestPassesWhenNormalTeardownRan', 869 'spec_ThisTestPassesWhenNormalSuiteSetupAndTeardownRan', 870 'should_RunTestsStartingWithShouldByDefault', 871 ], 872 :to_fail => [ ], 873 :to_ignore => [ ], 874 } 875 }, 876 877 { :name => 'ArgsIncludeAndExcludeFilter', 878 :testfile => 'testdata/testRunnerGenerator.c', 879 :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'], 880 :options => { 881 :cmdline_args => true, 882 :includes => ['Defs.h'], 883 }, 884 :cmdline_args => "-n test_ -x Ignored", 885 :expected => { 886 :to_pass => [ 'test_ThisTestAlwaysPasses', 887 'test_NotBeConfusedByLongComplicatedStrings', 888 'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings', 889 'test_StillNotBeConfusedByLongComplicatedStrings', 890 ], 891 :to_fail => [ 'test_ThisTestAlwaysFails' ], 892 :to_ignore => [ ], 893 } 894 }, 895 896 { :name => 'ArgsIncludeSingleTest', 897 :testfile => 'testdata/testRunnerGenerator.c', 898 :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'], 899 :options => { 900 :cmdline_args => true, 901 }, 902 :cmdline_args => "-n ThisTestAlwaysPasses", 903 :expected => { 904 :to_pass => [ 'test_ThisTestAlwaysPasses' ], 905 :to_fail => [ ], 906 :to_ignore => [ ], 907 } 908 }, 909 910 { :name => 'ArgsIncludeSingleTestInSpecificFile', 911 :testfile => 'testdata/testRunnerGenerator.c', 912 :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'], 913 :options => { 914 :cmdline_args => true, 915 }, 916 :cmdline_args => "-n testRunnerGenerator:ThisTestAlwaysPasses", 917 :expected => { 918 :to_pass => [ 'test_ThisTestAlwaysPasses' ], 919 :to_fail => [ ], 920 :to_ignore => [ ], 921 } 922 }, 923 924 { :name => 'ArgsIncludeTestFileWithExtension', 925 :testfile => 'testdata/testRunnerGenerator.c', 926 :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'], 927 :options => { 928 :cmdline_args => true, 929 }, 930 :cmdline_args => "-n testRunnerGenerator.c:ThisTestAlwaysPasses", 931 :expected => { 932 :to_pass => [ 'test_ThisTestAlwaysPasses' ], 933 :to_fail => [ ], 934 :to_ignore => [ ], 935 } 936 }, 937 938 { :name => 'ArgsIncludeDoubleQuotes', 939 :testfile => 'testdata/testRunnerGenerator.c', 940 :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'], 941 :options => { 942 :cmdline_args => true, 943 }, 944 :cmdline_args => "-n \"testRunnerGenerator:ThisTestAlwaysPasses,test_ThisTestAlwaysFails\"", 945 :expected => { 946 :to_pass => [ 'test_ThisTestAlwaysPasses' ], 947 :to_fail => [ 'test_ThisTestAlwaysFails' ], 948 :to_ignore => [ ], 949 } 950 }, 951 952 { :name => 'ArgsIncludeSingleQuotes', 953 :testfile => 'testdata/testRunnerGenerator.c', 954 :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'], 955 :options => { 956 :cmdline_args => true, 957 }, 958 :cmdline_args => "-n 'testRunnerGenerator:ThisTestAlwaysPasses,test_ThisTestAlwaysFails'", 959 :expected => { 960 :to_pass => [ 'test_ThisTestAlwaysPasses' ], 961 :to_fail => [ 'test_ThisTestAlwaysFails' ], 962 :to_ignore => [ ], 963 } 964 }, 965 966 { :name => 'ArgsIncludeAValidTestForADifferentFile', 967 :testfile => 'testdata/testRunnerGenerator.c', 968 :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'], 969 :options => { 970 :cmdline_args => true, 971 }, 972 :cmdline_args => "-n AnotherFile:ThisTestDoesNotExist", 973 :expected => { 974 :to_pass => [ ], 975 :to_fail => [ ], 976 :to_ignore => [ ], 977 } 978 }, 979 980 { :name => 'ArgsIncludeNoTests', 981 :testfile => 'testdata/testRunnerGenerator.c', 982 :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'], 983 :options => { 984 :cmdline_args => true, 985 }, 986 :cmdline_args => "-n ThisTestDoesNotExist", 987 :expected => { 988 :to_pass => [ ], 989 :to_fail => [ ], 990 :to_ignore => [ ], 991 } 992 }, 993 994 { :name => 'ArgsExcludeAllTests', 995 :testfile => 'testdata/testRunnerGenerator.c', 996 :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'], 997 :options => { 998 :cmdline_args => true, 999 }, 1000 :cmdline_args => "-x _", 1001 :expected => { 1002 :to_pass => [ ], 1003 :to_fail => [ ], 1004 :to_ignore => [ ], 1005 } 1006 }, 1007 1008 { :name => 'ArgsIncludeFullFile', 1009 :testfile => 'testdata/testRunnerGenerator.c', 1010 :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'], 1011 :options => { 1012 :cmdline_args => true, 1013 }, 1014 :cmdline_args => "-n testRunnerGenerator", 1015 :expected => { 1016 :to_pass => [ 'test_ThisTestAlwaysPasses', 1017 'spec_ThisTestPassesWhenNormalSetupRan', 1018 'spec_ThisTestPassesWhenNormalTeardownRan', 1019 'test_NotBeConfusedByLongComplicatedStrings', 1020 'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings', 1021 'test_StillNotBeConfusedByLongComplicatedStrings', 1022 'should_RunTestsStartingWithShouldByDefault', 1023 'spec_ThisTestPassesWhenNormalSuiteSetupAndTeardownRan', 1024 ], 1025 :to_fail => [ 'test_ThisTestAlwaysFails' ], 1026 :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], 1027 } 1028 }, 1029 1030 { :name => 'ArgsIncludeWithAlternateFlag', 1031 :testfile => 'testdata/testRunnerGenerator.c', 1032 :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'], 1033 :options => { 1034 :cmdline_args => true, 1035 }, 1036 :cmdline_args => "-f=\"testRunnerGenerator:ThisTestAlwaysPasses,test_ThisTestAlwaysFails\"", 1037 :expected => { 1038 :to_pass => [ 'test_ThisTestAlwaysPasses' ], 1039 :to_fail => [ 'test_ThisTestAlwaysFails' ], 1040 :to_ignore => [ ], 1041 } 1042 }, 1043 1044 { :name => 'ArgsIncludeWithParameterized', 1045 :testfile => 'testdata/testRunnerGenerator.c', 1046 :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'], 1047 :cmdline => "--use_param_tests=1", 1048 :yaml => { 1049 :cmdline_args => true, 1050 :test_prefix => "paratest" 1051 }, 1052 :cmdline_args => "-n ShouldHandleParameterizedTests", 1053 :features => [ :parameterized ], 1054 :expected => { 1055 :to_pass => [ 'paratest_ShouldHandleParameterizedTests\(25\)', 1056 'paratest_ShouldHandleParameterizedTests\(125\)', 1057 'paratest_ShouldHandleParameterizedTests\(5\)', 1058 'paratest_ShouldHandleParameterizedTests2\(7\)', 1059 ], 1060 :to_fail => [ 'paratest_ShouldHandleParameterizedTestsThatFail\(17\)' ], 1061 :to_ignore => [ ], 1062 } 1063 }, 1064 1065 { :name => 'ArgsList', 1066 :testfile => 'testdata/testRunnerGenerator.c', 1067 :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'], 1068 :options => { 1069 :cmdline_args => true, 1070 }, 1071 :cmdline_args => "-l", 1072 :expected => { 1073 :to_pass => [ ], 1074 :to_fail => [ ], 1075 :to_ignore => [ ], 1076 :text => [ "testRunnerGenerator", 1077 "test_ThisTestAlwaysPasses", 1078 "test_ThisTestAlwaysFails", 1079 "test_ThisTestAlwaysIgnored", 1080 "spec_ThisTestPassesWhenNormalSuiteSetupAndTeardownRan", 1081 "spec_ThisTestPassesWhenNormalSetupRan", 1082 "spec_ThisTestPassesWhenNormalTeardownRan", 1083 "test_NotBeConfusedByLongComplicatedStrings", 1084 "test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings", 1085 "test_StillNotBeConfusedByLongComplicatedStrings", 1086 "should_RunTestsStartingWithShouldByDefault" 1087 ] 1088 } 1089 }, 1090 1091 { :name => 'ArgsListParameterized', 1092 :testfile => 'testdata/testRunnerGenerator.c', 1093 :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'], 1094 :options => { 1095 :test_prefix => "paratest", 1096 :use_param_tests => true, 1097 :cmdline_args => true, 1098 }, 1099 :cmdline_args => "-l", 1100 :features => [ :parameterized ], 1101 :expected => { 1102 :to_pass => [ ], 1103 :to_fail => [ ], 1104 :to_ignore => [ ], 1105 :text => [ "testRunnerGenerator", 1106 'paratest_ShouldHandleParameterizedTests\(25\)', 1107 'paratest_ShouldHandleParameterizedTests\(125\)', 1108 'paratest_ShouldHandleParameterizedTests\(5\)', 1109 'paratest_ShouldHandleParameterizedTests2\(7\)', 1110 'paratest_ShouldHandleNonParameterizedTestsWhenParameterizationValid', 1111 'paratest_ShouldHandleParameterizedTestsThatFail\(17\)' 1112 ], 1113 } 1114 }, 1115 1116 { :name => 'ArgsIncompleteIncludeFlags', 1117 :testfile => 'testdata/testRunnerGenerator.c', 1118 :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'], 1119 :options => { 1120 :cmdline_args => true, 1121 }, 1122 :cmdline_args => "-n", 1123 :expected => { 1124 :to_pass => [ ], 1125 :to_fail => [ ], 1126 :to_ignore => [ ], 1127 :text => [ "ERROR: No Test String to Include Matches For" ], 1128 } 1129 }, 1130 1131 { :name => 'ArgsIncompleteExcludeFlags', 1132 :testfile => 'testdata/testRunnerGenerator.c', 1133 :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'], 1134 :options => { 1135 :cmdline_args => true, 1136 }, 1137 :cmdline_args => "-x", 1138 :expected => { 1139 :to_pass => [ ], 1140 :to_fail => [ ], 1141 :to_ignore => [ ], 1142 :text => [ "ERROR: No Test String to Exclude Matches For" ], 1143 } 1144 }, 1145 1146 { :name => 'ArgsIllegalFlags', 1147 :testfile => 'testdata/testRunnerGenerator.c', 1148 :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'], 1149 :options => { 1150 :cmdline_args => true, 1151 }, 1152 :cmdline_args => "-z", 1153 :expected => { 1154 :to_pass => [ ], 1155 :to_fail => [ ], 1156 :to_ignore => [ ], 1157 :text => [ "ERROR: Unknown Option z" ], 1158 } 1159 }, 1160] 1161 1162def runner_test(test, runner, expected, test_defines, cmdline_args, features) 1163 # Tack on TEST define for compiling unit tests 1164 load_configuration($cfg_file) 1165 1166 # Drop Out if we're skipping this type of test 1167 if $cfg[:skip_tests] && features 1168 if $cfg[:skip_tests].include?(:parameterized) && features.include?(:parameterized) 1169 report("Skipping Parameterized Tests for this Target:IGNORE") 1170 return true 1171 end 1172 end 1173 1174 #compile objects 1175 obj_list = [ 1176 compile(runner, test_defines), 1177 compile(test, test_defines), 1178 compile('../src/unity.c', test_defines), 1179 ] 1180 1181 # Link the test executable 1182 test_base = File.basename(test, C_EXTENSION) 1183 link_it(test_base, obj_list) 1184 1185 # Execute unit test and generate results file 1186 output = runtest(test_base, true, cmdline_args) 1187 1188 #compare to the expected pass/fail 1189 allgood = expected[:to_pass].inject(true) {|s,v| s && verify_match(/#{v}:PASS/, output) } 1190 allgood = expected[:to_fail].inject(allgood) {|s,v| s && verify_match(/#{v}:FAIL/, output) } 1191 allgood = expected[:to_ignore].inject(allgood) {|s,v| s && verify_match(/#{v}:IGNORE/, output) } 1192 1193 #verify there weren't more pass/fail/etc than expected 1194 allgood &&= verify_number( expected[:to_pass], /(:PASS)/, output) 1195 allgood &&= verify_number( expected[:to_fail], /(:FAIL)/, output) 1196 allgood &&= verify_number( expected[:to_ignore], /(:IGNORE)/, output) 1197 1198 #if we care about any other text, check that too 1199 if (expected[:text]) 1200 allgood = expected[:text].inject(allgood) {|s,v| s && verify_match(/#{v}/, output) } 1201 allgood &&= verify_number( expected[:text], /.+/, output ) 1202 end 1203 1204 report output if (!allgood && !$verbose) #report failures if not already reporting everything 1205 return allgood 1206end 1207 1208def verify_match(expression, output) 1209 if (expression =~ output) 1210 return true 1211 else 1212 report " FAIL: No Match For /#{expression.to_s}/" 1213 return false 1214 end 1215end 1216 1217def verify_number(expected, expression, output) 1218 exp = expected.length 1219 act = output.scan(expression).length 1220 if (exp == act) 1221 return true 1222 else 1223 report " FAIL: Expected #{exp} Matches For /#{expression.to_s}/. Was #{act}" 1224 return false 1225 end 1226end 1227 1228RUNNER_TESTS.each do |testset| 1229 basename = File.basename(testset[:testfile], C_EXTENSION) 1230 testset_name = "Runner_#{basename}_#{testset[:name]}" 1231 should testset_name do 1232 runner_name = OUT_FILE + testset[:name] + '_runner.c' 1233 1234 #create a yaml file first if required 1235 yaml_option = "" 1236 if (testset[:yaml]) 1237 File.open("build/runner_options.yml",'w') {|f| f << { :unity => testset[:yaml] }.to_yaml } 1238 yaml_option = "build/runner_options.yml" 1239 end 1240 1241 #run script via command line or through hash function call, as requested 1242 if (testset[:cmdline]) 1243 cmdstr = "ruby ../auto/generate_test_runner.rb #{yaml_option} #{testset[:cmdline]} \"#{testset[:testfile]}\" \"#{runner_name}\"" 1244 `#{cmdstr}` 1245 else 1246 UnityTestRunnerGenerator.new(testset[:options]).run(testset[:testfile], runner_name) 1247 end 1248 1249 #test the script against the specified test file and check results 1250 if (runner_test(testset[:testfile], runner_name, testset[:expected], testset[:testdefines], testset[:cmdline_args], testset[:features])) 1251 report "#{testset_name}:PASS" 1252 else 1253 report "#{testset_name}:FAIL" 1254 $generate_test_runner_failures += 1 1255 end 1256 $generate_test_runner_tests += 1 1257 end 1258end 1259 1260raise "There were #{$generate_test_runner_failures.to_s} failures while testing generate_test_runner.rb" if ($generate_test_runner_failures > 0) 1261