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