1# encoding: utf-8 2###################################################################### 3# This file is imported from the minitest project. 4# DO NOT make modifications in this repo. They _will_ be reverted! 5# File a patch instead and assign it to Ryan Davis. 6###################################################################### 7 8require 'pathname' 9require 'minitest/metametameta' 10 11module MyModule; end 12class AnError < StandardError; include MyModule; end 13class ImmutableString < String; def inspect; super.freeze; end; end 14 15class TestMiniTestUnit < MetaMetaMetaTestCase 16 parallelize_me! if ENV["PARALLEL"] 17 18 pwd = Pathname.new File.expand_path Dir.pwd 19 basedir = Pathname.new(File.expand_path "lib/minitest") + 'mini' 20 basedir = basedir.relative_path_from(pwd).to_s 21 MINITEST_BASE_DIR = basedir[/\A\./] ? basedir : "./#{basedir}" 22 BT_MIDDLE = ["#{MINITEST_BASE_DIR}/test.rb:161:in `each'", 23 "#{MINITEST_BASE_DIR}/test.rb:158:in `each'", 24 "#{MINITEST_BASE_DIR}/test.rb:139:in `run'", 25 "#{MINITEST_BASE_DIR}/test.rb:106:in `run'"] 26 27 def test_wtf 28 $hook_value = nil 29 30 capture_io do # don't care about deprecation 31 MiniTest::Unit::TestCase.add_setup_hook do 32 $hook_value = 42 33 end 34 end 35 36 run_setup_hooks 37 38 assert_equal 42, $hook_value 39 assert_equal [Proc], MiniTest::Unit::TestCase.setup_hooks.map(&:class) 40 MiniTest::Unit::TestCase.reset_setup_teardown_hooks 41 assert_equal [], MiniTest::Unit::TestCase.setup_hooks.map(&:class) 42 end 43 44 def test_class_puke_with_assertion_failed 45 exception = MiniTest::Assertion.new "Oh no!" 46 exception.set_backtrace ["unhappy"] 47 assert_equal 'F', @tu.puke('SomeClass', 'method_name', exception) 48 assert_equal 1, @tu.failures 49 assert_match(/^Failure.*Oh no!/m, @tu.report.first) 50 assert_match("method_name(SomeClass) [unhappy]", @tu.report.first) 51 end 52 53 def test_class_puke_with_assertion_failed_and_long_backtrace 54 bt = (["test/test_some_class.rb:615:in `method_name'", 55 "#{MINITEST_BASE_DIR}/unit.rb:140:in `assert_raises'", 56 "test/test_some_class.rb:615:in `each'", 57 "test/test_some_class.rb:614:in `test_method_name'", 58 "#{MINITEST_BASE_DIR}/test.rb:165:in `__send__'"] + 59 BT_MIDDLE + 60 ["#{MINITEST_BASE_DIR}/test.rb:29"]) 61 bt = util_expand_bt bt 62 63 ex_location = util_expand_bt(["test/test_some_class.rb:615"]).first 64 65 exception = MiniTest::Assertion.new "Oh no!" 66 exception.set_backtrace bt 67 assert_equal 'F', @tu.puke('TestSomeClass', 'test_method_name', exception) 68 assert_equal 1, @tu.failures 69 assert_match(/^Failure.*Oh no!/m, @tu.report.first) 70 assert_match("test_method_name(TestSomeClass) [#{ex_location}]", @tu.report.first) 71 end 72 73 def test_class_puke_with_assertion_failed_and_user_defined_assertions 74 bt = (["lib/test/my/util.rb:16:in `another_method_name'", 75 "#{MINITEST_BASE_DIR}/unit.rb:140:in `assert_raises'", 76 "lib/test/my/util.rb:15:in `block in assert_something'", 77 "lib/test/my/util.rb:14:in `each'", 78 "lib/test/my/util.rb:14:in `assert_something'", 79 "test/test_some_class.rb:615:in `each'", 80 "test/test_some_class.rb:614:in `test_method_name'", 81 "#{MINITEST_BASE_DIR}/test.rb:165:in `__send__'"] + 82 BT_MIDDLE + 83 ["#{MINITEST_BASE_DIR}/test.rb:29"]) 84 bt = util_expand_bt bt 85 86 ex_location = util_expand_bt(["test/test_some_class.rb:615"]).first 87 88 exception = MiniTest::Assertion.new "Oh no!" 89 exception.set_backtrace bt 90 assert_equal 'F', @tu.puke('TestSomeClass', 'test_method_name', exception) 91 assert_equal 1, @tu.failures 92 assert_match(/^Failure.*Oh no!/m, @tu.report.first) 93 assert_match("test_method_name(TestSomeClass) [#{ex_location}]", @tu.report.first) 94 end 95 96 def test_class_puke_with_failure_and_flunk_in_backtrace 97 exception = begin 98 MiniTest::Unit::TestCase.new('fake tc').flunk 99 rescue MiniTest::Assertion => failure 100 failure 101 end 102 assert_equal 'F', @tu.puke('SomeClass', 'method_name', exception) 103 refute @tu.report.any?{|line| line =~ /in .flunk/} 104 end 105 106 def test_class_puke_with_flunk_and_user_defined_assertions 107 bt = (["lib/test/my/util.rb:16:in `flunk'", 108 "#{MINITEST_BASE_DIR}/unit.rb:140:in `assert_raises'", 109 "lib/test/my/util.rb:15:in `block in assert_something'", 110 "lib/test/my/util.rb:14:in `each'", 111 "lib/test/my/util.rb:14:in `assert_something'", 112 "test/test_some_class.rb:615:in `each'", 113 "test/test_some_class.rb:614:in `test_method_name'", 114 "#{MINITEST_BASE_DIR}/test.rb:165:in `__send__'"] + 115 BT_MIDDLE + 116 ["#{MINITEST_BASE_DIR}/test.rb:29"]) 117 bt = util_expand_bt bt 118 119 ex_location = util_expand_bt(["test/test_some_class.rb:615"]).first 120 121 exception = MiniTest::Assertion.new "Oh no!" 122 exception.set_backtrace bt 123 assert_equal 'F', @tu.puke('TestSomeClass', 'test_method_name', exception) 124 assert_equal 1, @tu.failures 125 assert_match(/^Failure.*Oh no!/m, @tu.report.first) 126 assert_match("test_method_name(TestSomeClass) [#{ex_location}]", @tu.report.first) 127 end 128 129 def test_class_puke_with_non_failure_exception 130 exception = Exception.new("Oh no again!") 131 assert_equal 'E', @tu.puke('SomeClass', 'method_name', exception) 132 assert_equal 1, @tu.errors 133 assert_match(/^Exception.*Oh no again!/m, @tu.report.first) 134 end 135 136 def test_filter_backtrace 137 # this is a semi-lame mix of relative paths. 138 # I cheated by making the autotest parts not have ./ 139 bt = (["lib/autotest.rb:571:in `add_exception'", 140 "test/test_autotest.rb:62:in `test_add_exception'", 141 "#{MINITEST_BASE_DIR}/test.rb:165:in `__send__'"] + 142 BT_MIDDLE + 143 ["#{MINITEST_BASE_DIR}/test.rb:29", 144 "test/test_autotest.rb:422"]) 145 bt = util_expand_bt bt 146 147 ex = ["lib/autotest.rb:571:in `add_exception'", 148 "test/test_autotest.rb:62:in `test_add_exception'"] 149 ex = util_expand_bt ex 150 151 fu = MiniTest::filter_backtrace(bt) 152 153 assert_equal ex, fu 154 end 155 156 def test_filter_backtrace_all_unit 157 bt = (["#{MINITEST_BASE_DIR}/test.rb:165:in `__send__'"] + 158 BT_MIDDLE + 159 ["#{MINITEST_BASE_DIR}/test.rb:29"]) 160 ex = bt.clone 161 fu = MiniTest::filter_backtrace(bt) 162 assert_equal ex, fu 163 end 164 165 def test_filter_backtrace_unit_starts 166 bt = (["#{MINITEST_BASE_DIR}/test.rb:165:in `__send__'"] + 167 BT_MIDDLE + 168 ["#{MINITEST_BASE_DIR}/mini/test.rb:29", 169 "-e:1"]) 170 171 bt = util_expand_bt bt 172 173 ex = ["-e:1"] 174 fu = MiniTest::filter_backtrace bt 175 assert_equal ex, fu 176 end 177 178 def test_default_runner_is_minitest_unit 179 assert_instance_of MiniTest::Unit, MiniTest::Unit.runner 180 end 181 182 def with_overridden_include 183 Class.class_eval do 184 def inherited_with_hacks klass 185 throw :inherited_hook 186 end 187 188 alias inherited_without_hacks inherited 189 alias inherited inherited_with_hacks 190 alias IGNORE_ME! inherited # 1.8 bug. god I love venture bros 191 end 192 193 yield 194 ensure 195 Class.class_eval do 196 alias inherited inherited_without_hacks 197 198 undef_method :inherited_with_hacks 199 undef_method :inherited_without_hacks 200 end 201 202 refute_respond_to Class, :inherited_with_hacks 203 refute_respond_to Class, :inherited_without_hacks 204 end 205 206 def test_inherited_hook_plays_nice_with_others 207 with_overridden_include do 208 assert_throws :inherited_hook do 209 Class.new MiniTest::Unit::TestCase 210 end 211 end 212 end 213 214 def test_passed_eh_teardown_good 215 test_class = Class.new MiniTest::Unit::TestCase do 216 def teardown; assert true; end 217 def test_omg; assert true; end 218 end 219 220 test = test_class.new :test_omg 221 test.run @tu 222 assert test.passed? 223 end 224 225 def test_passed_eh_teardown_flunked 226 test_class = Class.new MiniTest::Unit::TestCase do 227 def teardown; flunk; end 228 def test_omg; assert true; end 229 end 230 231 test = test_class.new :test_omg 232 test.run @tu 233 refute test.passed? 234 end 235 236 def util_expand_bt bt 237 if RUBY_VERSION >= '1.9.0' then 238 bt.map { |f| (f =~ /^\./) ? File.expand_path(f) : f } 239 else 240 bt 241 end 242 end 243end 244 245class TestMiniTestRunner < MetaMetaMetaTestCase 246 # do not parallelize this suite... it just can't handle it. 247 248 def test_class_test_suites 249 @assertion_count = 0 250 251 tc = Class.new(MiniTest::Unit::TestCase) 252 253 assert_equal 1, MiniTest::Unit::TestCase.test_suites.size 254 assert_equal [tc], MiniTest::Unit::TestCase.test_suites 255 end 256 257 def test_run_test 258 Class.new MiniTest::Unit::TestCase do 259 attr_reader :foo 260 261 def run_test name 262 @foo = "hi mom!" 263 super 264 @foo = "okay" 265 end 266 267 def test_something 268 assert_equal "hi mom!", foo 269 end 270 end 271 272 expected = clean <<-EOM 273 . 274 275 Finished tests in 0.00 276 277 1 tests, 1 assertions, 0 failures, 0 errors, 0 skips 278 EOM 279 280 assert_report expected 281 end 282 283 def test_run_error 284 Class.new MiniTest::Unit::TestCase do 285 def test_something 286 assert true 287 end 288 289 def test_error 290 raise "unhandled exception" 291 end 292 end 293 294 expected = clean <<-EOM 295 E. 296 297 Finished tests in 0.00 298 299 1) Error: 300 test_error(#<Class:0xXXX>): 301 RuntimeError: unhandled exception 302 FILE:LINE:in `test_error' 303 304 2 tests, 1 assertions, 0 failures, 1 errors, 0 skips 305 EOM 306 307 assert_report expected 308 end 309 310 def test_run_error_teardown 311 Class.new MiniTest::Unit::TestCase do 312 def test_something 313 assert true 314 end 315 316 def teardown 317 raise "unhandled exception" 318 end 319 end 320 321 expected = clean <<-EOM 322 E 323 324 Finished tests in 0.00 325 326 1) Error: 327 test_something(#<Class:0xXXX>): 328 RuntimeError: unhandled exception 329 FILE:LINE:in `teardown' 330 331 1 tests, 1 assertions, 0 failures, 1 errors, 0 skips 332 EOM 333 334 assert_report expected 335 end 336 337 def test_run_failing 338 Class.new MiniTest::Unit::TestCase do 339 def test_something 340 assert true 341 end 342 343 def test_failure 344 assert false 345 end 346 end 347 348 expected = clean <<-EOM 349 F. 350 351 Finished tests in 0.00 352 353 1) Failure: 354 test_failure(#<Class:0xXXX>) [FILE:LINE]: 355 Failed assertion, no message given. 356 357 2 tests, 2 assertions, 1 failures, 0 errors, 0 skips 358 EOM 359 360 assert_report expected 361 end 362 363 def test_run_failing_filtered 364 Class.new MiniTest::Unit::TestCase do 365 def test_something 366 assert true 367 end 368 369 def test_failure 370 assert false 371 end 372 end 373 374 expected = clean <<-EOM 375 . 376 377 Finished tests in 0.00 378 379 1 tests, 1 assertions, 0 failures, 0 errors, 0 skips 380 EOM 381 382 assert_report expected, %w[--name /some|thing/ --seed 42] 383 end 384 385 def test_run_passing 386 Class.new MiniTest::Unit::TestCase do 387 def test_something 388 assert true 389 end 390 end 391 392 expected = clean <<-EOM 393 . 394 395 Finished tests in 0.00 396 397 1 tests, 1 assertions, 0 failures, 0 errors, 0 skips 398 EOM 399 400 assert_report expected 401 end 402 403 def test_run_skip 404 Class.new MiniTest::Unit::TestCase do 405 def test_something 406 assert true 407 end 408 409 def test_skip 410 skip "not yet" 411 end 412 end 413 414 expected = clean <<-EOM 415 S. 416 417 Finished tests in 0.00 418 419 2 tests, 1 assertions, 0 failures, 0 errors, 1 skips 420 EOM 421 422 assert_report expected 423 end 424 425 def test_run_skip_verbose 426 Class.new MiniTest::Unit::TestCase do 427 def test_something 428 assert true 429 end 430 431 def test_skip 432 skip "not yet" 433 end 434 end 435 436 expected = clean <<-EOM 437 #<Class:0xXXX>#test_skip = 0.00 s = S 438 #<Class:0xXXX>#test_something = 0.00 s = . 439 440 441 Finished tests in 0.00 442 443 1) Skipped: 444 test_skip(#<Class:0xXXX>) [FILE:LINE]: 445 not yet 446 447 2 tests, 1 assertions, 0 failures, 0 errors, 1 skips 448 EOM 449 450 assert_report expected, %w[--seed 42 --verbose] 451 end 452 453 def test_run_with_other_runner 454 MiniTest::Unit.runner = Class.new MiniTest::Unit do 455 def _run_suite suite, type 456 suite.before_suite # Run once before each suite 457 super suite, type 458 end 459 end.new 460 461 Class.new MiniTest::Unit::TestCase do 462 def self.name; "wacky!" end 463 464 def self.before_suite 465 MiniTest::Unit.output.puts "Running #{self.name} tests" 466 @@foo = 1 467 end 468 469 def test_something 470 assert_equal 1, @@foo 471 end 472 473 def test_something_else 474 assert_equal 1, @@foo 475 end 476 end 477 478 expected = clean <<-EOM 479 Running wacky! tests 480 .. 481 482 Finished tests in 0.00 483 484 2 tests, 2 assertions, 0 failures, 0 errors, 0 skips 485 EOM 486 487 assert_report expected 488 end 489 490 require 'monitor' 491 492 class Latch 493 def initialize count = 1 494 @count = count 495 @lock = Monitor.new 496 @cv = @lock.new_cond 497 end 498 499 def release 500 @lock.synchronize do 501 @count -= 1 if @count > 0 502 @cv.broadcast if @count == 0 503 end 504 end 505 506 def await 507 @lock.synchronize { @cv.wait_while { @count > 0 } } 508 end 509 end 510 511 def test_run_parallel 512 test_count = 2 513 test_latch = Latch.new test_count 514 main_latch = Latch.new 515 516 thread = Thread.new { 517 Thread.current.abort_on_exception = true 518 519 # This latch waits until both test latches have been released. Both 520 # latches can't be released unless done in separate threads because 521 # `main_latch` keeps the test method from finishing. 522 test_latch.await 523 main_latch.release 524 } 525 526 Class.new MiniTest::Unit::TestCase do 527 parallelize_me! 528 529 test_count.times do |i| 530 define_method :"test_wait_on_main_thread_#{i}" do 531 test_latch.release 532 533 # This latch blocks until the "main thread" releases it. The main 534 # thread can't release this latch until both test latches have 535 # been released. This forces the latches to be released in separate 536 # threads. 537 main_latch.await 538 assert true 539 end 540 end 541 end 542 543 expected = clean <<-EOM 544 .. 545 546 Finished tests in 0.00 547 548 2 tests, 2 assertions, 0 failures, 0 errors, 0 skips 549 EOM 550 551 assert_report expected 552 assert thread.join 553 end 554end 555 556class TestMiniTestUnitOrder < MetaMetaMetaTestCase 557 # do not parallelize this suite... it just can't handle it. 558 559 def test_before_setup 560 call_order = [] 561 Class.new MiniTest::Unit::TestCase do 562 define_method :setup do 563 super() 564 call_order << :setup 565 end 566 567 define_method :before_setup do 568 call_order << :before_setup 569 end 570 571 def test_omg; assert true; end 572 end 573 574 with_output do 575 @tu.run %w[--seed 42] 576 end 577 578 expected = [:before_setup, :setup] 579 assert_equal expected, call_order 580 end 581 582 def test_after_teardown 583 call_order = [] 584 Class.new MiniTest::Unit::TestCase do 585 define_method :teardown do 586 super() 587 call_order << :teardown 588 end 589 590 define_method :after_teardown do 591 call_order << :after_teardown 592 end 593 594 def test_omg; assert true; end 595 end 596 597 with_output do 598 @tu.run %w[--seed 42] 599 end 600 601 expected = [:teardown, :after_teardown] 602 assert_equal expected, call_order 603 end 604 605 def test_all_teardowns_are_guaranteed_to_run 606 call_order = [] 607 Class.new MiniTest::Unit::TestCase do 608 define_method :after_teardown do 609 super() 610 call_order << :after_teardown 611 raise 612 end 613 614 define_method :teardown do 615 super() 616 call_order << :teardown 617 raise 618 end 619 620 define_method :before_teardown do 621 super() 622 call_order << :before_teardown 623 raise 624 end 625 626 def test_omg; assert true; end 627 end 628 629 with_output do 630 @tu.run %w[--seed 42] 631 end 632 633 expected = [:before_teardown, :teardown, :after_teardown] 634 assert_equal expected, call_order 635 end 636 637 def test_setup_and_teardown_survive_inheritance 638 call_order = [] 639 640 parent = Class.new MiniTest::Spec do 641 before do 642 call_order << :setup_method 643 end 644 645 after do 646 call_order << :teardown_method 647 end 648 649 define_method :test_something do 650 call_order << :test 651 end 652 end 653 654 _ = Class.new parent 655 656 with_output do 657 @tu.run %w[--seed 42] 658 end 659 660 # Once for the parent class, once for the child 661 expected = [:setup_method, :test, :teardown_method] * 2 662 663 assert_equal expected, call_order 664 end 665end 666 667class TestMiniTestUnitTestCase < MiniTest::Unit::TestCase 668 parallelize_me! if ENV["PARALLEL"] 669 670 RUBY18 = ! defined? Encoding 671 672 def setup 673 super 674 675 MiniTest::Unit::TestCase.reset 676 677 @tc = MiniTest::Unit::TestCase.new 'fake tc' 678 @zomg = "zomg ponies!" 679 @assertion_count = 1 680 end 681 682 def teardown 683 assert_equal(@assertion_count, @tc._assertions, 684 "expected #{@assertion_count} assertions to be fired during the test, not #{@tc._assertions}") if @tc._assertions 685 end 686 687 def non_verbose 688 orig_verbose = $VERBOSE 689 $VERBOSE = false 690 691 yield 692 ensure 693 $VERBOSE = orig_verbose 694 end 695 696 def test_assert 697 @assertion_count = 2 698 699 @tc.assert_equal true, @tc.assert(true), "returns true on success" 700 end 701 702 def test_assert__triggered 703 util_assert_triggered "Failed assertion, no message given." do 704 @tc.assert false 705 end 706 end 707 708 def test_assert__triggered_message 709 util_assert_triggered @zomg do 710 @tc.assert false, @zomg 711 end 712 end 713 714 def test_assert_block 715 exp = ["NOTE: MiniTest::Unit::TestCase#assert_block is deprecated,", 716 "use assert. It will be removed on 2013-01-01."].join " " 717 718 out, err = capture_io do 719 @tc.assert_block do 720 true 721 end 722 end 723 724 assert_equal "", out 725 assert_match exp, err 726 end 727 728 def test_assert_block_triggered 729 assert_output do 730 util_assert_triggered "blah.\nExpected block to return true value." do 731 @tc.assert_block "blah" do 732 false 733 end 734 end 735 end 736 end 737 738 def test_assert_empty 739 @assertion_count = 2 740 741 @tc.assert_empty [] 742 end 743 744 def test_assert_empty_triggered 745 @assertion_count = 2 746 747 util_assert_triggered "Expected [1] to be empty." do 748 @tc.assert_empty [1] 749 end 750 end 751 752 def test_assert_equal 753 @tc.assert_equal 1, 1 754 end 755 756 def test_assert_equal_different_collection_array_hex_invisible 757 object1 = Object.new 758 object2 = Object.new 759 msg = "No visible difference in the Array#inspect output. 760 You should look at the implementation of #== on Array or its members. 761 [#<Object:0xXXXXXX>]".gsub(/^ +/, "") 762 util_assert_triggered msg do 763 @tc.assert_equal [object1], [object2] 764 end 765 end 766 767 def test_assert_equal_different_collection_hash_hex_invisible 768 h1, h2 = {}, {} 769 h1[1] = Object.new 770 h2[1] = Object.new 771 msg = "No visible difference in the Hash#inspect output. 772 You should look at the implementation of #== on Hash or its members. 773 {1=>#<Object:0xXXXXXX>}".gsub(/^ +/, "") 774 775 util_assert_triggered msg do 776 @tc.assert_equal h1, h2 777 end 778 end 779 780 def test_assert_equal_different_diff_deactivated 781 without_diff do 782 util_assert_triggered util_msg("haha" * 10, "blah" * 10) do 783 o1 = "haha" * 10 784 o2 = "blah" * 10 785 786 @tc.assert_equal o1, o2 787 end 788 end 789 end 790 791 def test_assert_equal_different_hex 792 c = Class.new do 793 def initialize s; @name = s; end 794 end 795 796 o1 = c.new "a" 797 o2 = c.new "b" 798 msg = "--- expected 799 +++ actual 800 @@ -1 +1 @@ 801 -#<#<Class:0xXXXXXX>:0xXXXXXX @name=\"a\"> 802 +#<#<Class:0xXXXXXX>:0xXXXXXX @name=\"b\"> 803 ".gsub(/^ +/, "") 804 805 util_assert_triggered msg do 806 @tc.assert_equal o1, o2 807 end 808 end 809 810 def test_assert_equal_different_hex_invisible 811 o1 = Object.new 812 o2 = Object.new 813 814 msg = "No visible difference in the Object#inspect output. 815 You should look at the implementation of #== on Object or its members. 816 #<Object:0xXXXXXX>".gsub(/^ +/, "") 817 818 util_assert_triggered msg do 819 @tc.assert_equal o1, o2 820 end 821 end 822 823 def test_assert_equal_different_long 824 msg = "--- expected 825 +++ actual 826 @@ -1 +1 @@ 827 -\"hahahahahahahahahahahahahahahahahahahaha\" 828 +\"blahblahblahblahblahblahblahblahblahblah\" 829 ".gsub(/^ +/, "") 830 831 util_assert_triggered msg do 832 o1 = "haha" * 10 833 o2 = "blah" * 10 834 835 @tc.assert_equal o1, o2 836 end 837 end 838 839 def test_assert_equal_different_long_invisible 840 msg = "No visible difference in the String#inspect output. 841 You should look at the implementation of #== on String or its members. 842 \"blahblahblahblahblahblahblahblahblahblah\"".gsub(/^ +/, "") 843 844 util_assert_triggered msg do 845 o1 = "blah" * 10 846 o2 = "blah" * 10 847 def o1.== o 848 false 849 end 850 @tc.assert_equal o1, o2 851 end 852 end 853 854 def test_assert_equal_different_long_msg 855 msg = "message. 856 --- expected 857 +++ actual 858 @@ -1 +1 @@ 859 -\"hahahahahahahahahahahahahahahahahahahaha\" 860 +\"blahblahblahblahblahblahblahblahblahblah\" 861 ".gsub(/^ +/, "") 862 863 util_assert_triggered msg do 864 o1 = "haha" * 10 865 o2 = "blah" * 10 866 @tc.assert_equal o1, o2, "message" 867 end 868 end 869 870 def test_assert_equal_different_short 871 util_assert_triggered util_msg(1, 2) do 872 @tc.assert_equal 1, 2 873 end 874 end 875 876 def test_assert_equal_different_short_msg 877 util_assert_triggered util_msg(1, 2, "message") do 878 @tc.assert_equal 1, 2, "message" 879 end 880 end 881 882 def test_assert_equal_different_short_multiline 883 msg = "--- expected\n+++ actual\n@@ -1,2 +1,2 @@\n \"a\n-b\"\n+c\"\n" 884 util_assert_triggered msg do 885 @tc.assert_equal "a\nb", "a\nc" 886 end 887 end 888 889 def test_assert_in_delta 890 @tc.assert_in_delta 0.0, 1.0 / 1000, 0.1 891 end 892 893 def test_assert_in_delta_triggered 894 util_assert_triggered 'Expected |0.0 - 0.001| (0.001) to be < 1.0e-06.' do 895 @tc.assert_in_delta 0.0, 1.0 / 1000, 0.000001 896 end 897 end 898 899 def test_assert_in_epsilon 900 @assertion_count = 10 901 902 @tc.assert_in_epsilon 10000, 9991 903 @tc.assert_in_epsilon 9991, 10000 904 @tc.assert_in_epsilon 1.0, 1.001 905 @tc.assert_in_epsilon 1.001, 1.0 906 907 @tc.assert_in_epsilon 10000, 9999.1, 0.0001 908 @tc.assert_in_epsilon 9999.1, 10000, 0.0001 909 @tc.assert_in_epsilon 1.0, 1.0001, 0.0001 910 @tc.assert_in_epsilon 1.0001, 1.0, 0.0001 911 912 @tc.assert_in_epsilon(-1, -1) 913 @tc.assert_in_epsilon(-10000, -9991) 914 end 915 916 def test_assert_in_epsilon_triggered 917 util_assert_triggered 'Expected |10000 - 9990| (10) to be < 9.99.' do 918 @tc.assert_in_epsilon 10000, 9990 919 end 920 end 921 922 def test_assert_in_epsilon_triggered_negative_case 923 x = RUBY18 ? "0.1" : "0.10000000000000009" 924 util_assert_triggered "Expected |-1.1 - -1| (#{x}) to be < 0.1." do 925 @tc.assert_in_epsilon(-1.1, -1, 0.1) 926 end 927 end 928 929 def test_assert_includes 930 @assertion_count = 2 931 932 @tc.assert_includes [true], true 933 end 934 935 def test_assert_includes_triggered 936 @assertion_count = 3 937 938 e = @tc.assert_raises MiniTest::Assertion do 939 @tc.assert_includes [true], false 940 end 941 942 expected = "Expected [true] to include false." 943 assert_equal expected, e.message 944 end 945 946 def test_assert_instance_of 947 @tc.assert_instance_of String, "blah" 948 end 949 950 def test_assert_instance_of_triggered 951 util_assert_triggered 'Expected "blah" to be an instance of Array, not String.' do 952 @tc.assert_instance_of Array, "blah" 953 end 954 end 955 956 def test_assert_kind_of 957 @tc.assert_kind_of String, "blah" 958 end 959 960 def test_assert_kind_of_triggered 961 util_assert_triggered 'Expected "blah" to be a kind of Array, not String.' do 962 @tc.assert_kind_of Array, "blah" 963 end 964 end 965 966 def test_assert_match 967 @assertion_count = 2 968 @tc.assert_match(/\w+/, "blah blah blah") 969 end 970 971 def test_assert_match_matcher_object 972 @assertion_count = 2 973 974 pattern = Object.new 975 def pattern.=~(other) true end 976 977 @tc.assert_match pattern, 5 978 end 979 980 def test_assert_match_matchee_to_str 981 @assertion_count = 2 982 983 obj = Object.new 984 def obj.to_str; "blah" end 985 986 @tc.assert_match "blah", obj 987 end 988 989 def test_assert_match_object_triggered 990 @assertion_count = 2 991 992 pattern = Object.new 993 def pattern.=~(other) false end 994 def pattern.inspect; "[Object]" end 995 996 util_assert_triggered 'Expected [Object] to match 5.' do 997 @tc.assert_match pattern, 5 998 end 999 end 1000 1001 def test_assert_match_triggered 1002 @assertion_count = 2 1003 util_assert_triggered 'Expected /\d+/ to match "blah blah blah".' do 1004 @tc.assert_match(/\d+/, "blah blah blah") 1005 end 1006 end 1007 1008 def test_assert_nil 1009 @tc.assert_nil nil 1010 end 1011 1012 def test_assert_nil_triggered 1013 util_assert_triggered 'Expected 42 to be nil.' do 1014 @tc.assert_nil 42 1015 end 1016 end 1017 1018 def test_assert_operator 1019 @tc.assert_operator 2, :>, 1 1020 end 1021 1022 def test_assert_operator_bad_object 1023 bad = Object.new 1024 def bad.==(other) true end 1025 1026 @tc.assert_operator bad, :equal?, bad 1027 end 1028 1029 def test_assert_operator_triggered 1030 util_assert_triggered "Expected 2 to be < 1." do 1031 @tc.assert_operator 2, :<, 1 1032 end 1033 end 1034 1035 def test_assert_output_both 1036 @assertion_count = 2 1037 1038 @tc.assert_output "yay", "blah" do 1039 print "yay" 1040 $stderr.print "blah" 1041 end 1042 end 1043 1044 def test_assert_output_both_regexps 1045 @assertion_count = 4 1046 1047 @tc.assert_output(/y.y/, /bl.h/) do 1048 print "yay" 1049 $stderr.print "blah" 1050 end 1051 end 1052 1053 def test_assert_output_err 1054 @tc.assert_output nil, "blah" do 1055 $stderr.print "blah" 1056 end 1057 end 1058 1059 def test_assert_output_neither 1060 @assertion_count = 0 1061 1062 @tc.assert_output do 1063 # do nothing 1064 end 1065 end 1066 1067 def test_assert_output_out 1068 @tc.assert_output "blah" do 1069 print "blah" 1070 end 1071 end 1072 1073 def test_assert_output_triggered_both 1074 util_assert_triggered util_msg("blah", "blah blah", "In stderr") do 1075 @tc.assert_output "yay", "blah" do 1076 print "boo" 1077 $stderr.print "blah blah" 1078 end 1079 end 1080 end 1081 1082 def test_assert_output_triggered_err 1083 util_assert_triggered util_msg("blah", "blah blah", "In stderr") do 1084 @tc.assert_output nil, "blah" do 1085 $stderr.print "blah blah" 1086 end 1087 end 1088 end 1089 1090 def test_assert_output_triggered_out 1091 util_assert_triggered util_msg("blah", "blah blah", "In stdout") do 1092 @tc.assert_output "blah" do 1093 print "blah blah" 1094 end 1095 end 1096 end 1097 1098 def test_assert_predicate 1099 @tc.assert_predicate "", :empty? 1100 end 1101 1102 def test_assert_predicate_triggered 1103 util_assert_triggered 'Expected "blah" to be empty?.' do 1104 @tc.assert_predicate "blah", :empty? 1105 end 1106 end 1107 1108 def test_assert_raises 1109 @tc.assert_raises RuntimeError do 1110 raise "blah" 1111 end 1112 end 1113 1114 def test_assert_raises_module 1115 @tc.assert_raises MyModule do 1116 raise AnError 1117 end 1118 end 1119 1120 ## 1121 # *sigh* This is quite an odd scenario, but it is from real (albeit 1122 # ugly) test code in ruby-core: 1123 # 1124 # http://svn.ruby-lang.org/cgi-bin/viewvc.cgi?view=rev&revision=29259 1125 1126 def test_assert_raises_skip 1127 @assertion_count = 0 1128 1129 util_assert_triggered "skipped", MiniTest::Skip do 1130 @tc.assert_raises ArgumentError do 1131 begin 1132 raise "blah" 1133 rescue 1134 skip "skipped" 1135 end 1136 end 1137 end 1138 end 1139 1140 def test_assert_raises_triggered_different 1141 e = assert_raises MiniTest::Assertion do 1142 @tc.assert_raises RuntimeError do 1143 raise SyntaxError, "icky" 1144 end 1145 end 1146 1147 expected = clean <<-EOM.chomp 1148 [RuntimeError] exception expected, not 1149 Class: <SyntaxError> 1150 Message: <\"icky\"> 1151 ---Backtrace--- 1152 FILE:LINE:in `test_assert_raises_triggered_different' 1153 --------------- 1154 EOM 1155 1156 actual = e.message.gsub(/^.+:\d+/, 'FILE:LINE') 1157 actual.gsub!(/block \(\d+ levels\) in /, '') if RUBY_VERSION >= '1.9.0' 1158 1159 assert_equal expected, actual 1160 end 1161 1162 def test_assert_raises_triggered_different_msg 1163 e = assert_raises MiniTest::Assertion do 1164 @tc.assert_raises RuntimeError, "XXX" do 1165 raise SyntaxError, "icky" 1166 end 1167 end 1168 1169 expected = clean <<-EOM 1170 XXX. 1171 [RuntimeError] exception expected, not 1172 Class: <SyntaxError> 1173 Message: <\"icky\"> 1174 ---Backtrace--- 1175 FILE:LINE:in `test_assert_raises_triggered_different_msg' 1176 --------------- 1177 EOM 1178 1179 actual = e.message.gsub(/^.+:\d+/, 'FILE:LINE') 1180 actual.gsub!(/block \(\d+ levels\) in /, '') if RUBY_VERSION >= '1.9.0' 1181 1182 assert_equal expected.chomp, actual 1183 end 1184 1185 def test_assert_raises_triggered_none 1186 e = assert_raises MiniTest::Assertion do 1187 @tc.assert_raises MiniTest::Assertion do 1188 # do nothing 1189 end 1190 end 1191 1192 expected = "MiniTest::Assertion expected but nothing was raised." 1193 1194 assert_equal expected, e.message 1195 end 1196 1197 def test_assert_raises_triggered_none_msg 1198 e = assert_raises MiniTest::Assertion do 1199 @tc.assert_raises MiniTest::Assertion, "XXX" do 1200 # do nothing 1201 end 1202 end 1203 1204 expected = "XXX.\nMiniTest::Assertion expected but nothing was raised." 1205 1206 assert_equal expected, e.message 1207 end 1208 1209 def test_assert_raises_triggered_subclass 1210 e = assert_raises MiniTest::Assertion do 1211 @tc.assert_raises StandardError do 1212 raise AnError 1213 end 1214 end 1215 1216 expected = clean <<-EOM.chomp 1217 [StandardError] exception expected, not 1218 Class: <AnError> 1219 Message: <\"AnError\"> 1220 ---Backtrace--- 1221 FILE:LINE:in `test_assert_raises_triggered_subclass' 1222 --------------- 1223 EOM 1224 1225 actual = e.message.gsub(/^.+:\d+/, 'FILE:LINE') 1226 actual.gsub!(/block \(\d+ levels\) in /, '') if RUBY_VERSION >= '1.9.0' 1227 1228 assert_equal expected, actual 1229 end 1230 1231 def test_assert_respond_to 1232 @tc.assert_respond_to "blah", :empty? 1233 end 1234 1235 def test_assert_respond_to_triggered 1236 util_assert_triggered 'Expected "blah" (String) to respond to #rawr!.' do 1237 @tc.assert_respond_to "blah", :rawr! 1238 end 1239 end 1240 1241 def test_assert_same 1242 @assertion_count = 3 1243 1244 o = "blah" 1245 @tc.assert_same 1, 1 1246 @tc.assert_same :blah, :blah 1247 @tc.assert_same o, o 1248 end 1249 1250 def test_assert_same_triggered 1251 @assertion_count = 2 1252 1253 util_assert_triggered 'Expected 2 (oid=N) to be the same as 1 (oid=N).' do 1254 @tc.assert_same 1, 2 1255 end 1256 1257 s1 = "blah" 1258 s2 = "blah" 1259 1260 util_assert_triggered 'Expected "blah" (oid=N) to be the same as "blah" (oid=N).' do 1261 @tc.assert_same s1, s2 1262 end 1263 end 1264 1265 def test_assert_send 1266 @tc.assert_send [1, :<, 2] 1267 end 1268 1269 def test_assert_send_bad 1270 util_assert_triggered "Expected 1.>(*[2]) to return true." do 1271 @tc.assert_send [1, :>, 2] 1272 end 1273 end 1274 1275 def test_assert_silent 1276 @assertion_count = 2 1277 1278 @tc.assert_silent do 1279 # do nothing 1280 end 1281 end 1282 1283 def test_assert_silent_triggered_err 1284 util_assert_triggered util_msg("", "blah blah", "In stderr") do 1285 @tc.assert_silent do 1286 $stderr.print "blah blah" 1287 end 1288 end 1289 end 1290 1291 def test_assert_silent_triggered_out 1292 @assertion_count = 2 1293 1294 util_assert_triggered util_msg("", "blah blah", "In stdout") do 1295 @tc.assert_silent do 1296 print "blah blah" 1297 end 1298 end 1299 end 1300 1301 def test_assert_throws 1302 @tc.assert_throws :blah do 1303 throw :blah 1304 end 1305 end 1306 1307 def test_assert_throws_different 1308 util_assert_triggered 'Expected :blah to have been thrown, not :not_blah.' do 1309 @tc.assert_throws :blah do 1310 throw :not_blah 1311 end 1312 end 1313 end 1314 1315 def test_assert_throws_unthrown 1316 util_assert_triggered 'Expected :blah to have been thrown.' do 1317 @tc.assert_throws :blah do 1318 # do nothing 1319 end 1320 end 1321 end 1322 1323 def test_capture_io 1324 @assertion_count = 0 1325 1326 non_verbose do 1327 out, err = capture_io do 1328 puts 'hi' 1329 warn 'bye!' 1330 end 1331 1332 assert_equal "hi\n", out 1333 assert_equal "bye!\n", err 1334 end 1335 end 1336 1337 def test_capture_subprocess_io 1338 @assertion_count = 0 1339 skip "Dunno why but the parallel run of this fails" 1340 1341 non_verbose do 1342 out, err = capture_subprocess_io do 1343 system("echo 'hi'") 1344 system("echo 'bye!' 1>&2") 1345 end 1346 1347 assert_equal "hi\n", out 1348 assert_equal "bye!\n", err 1349 end 1350 end 1351 1352 def test_class_asserts_match_refutes 1353 @assertion_count = 0 1354 1355 methods = MiniTest::Assertions.public_instance_methods 1356 methods.map! { |m| m.to_s } if Symbol === methods.first 1357 1358 # These don't have corresponding refutes _on purpose_. They're 1359 # useless and will never be added, so don't bother. 1360 ignores = %w[assert_block assert_output assert_raises assert_send 1361 assert_silent assert_throws] 1362 1363 # These are test/unit methods. I'm not actually sure why they're still here 1364 ignores += %w[assert_no_match assert_not_equal assert_not_nil 1365 assert_not_same assert_nothing_raised 1366 assert_nothing_thrown assert_raise] 1367 1368 asserts = methods.grep(/^assert/).sort - ignores 1369 refutes = methods.grep(/^refute/).sort - ignores 1370 1371 assert_empty refutes.map { |n| n.sub(/^refute/, 'assert') } - asserts 1372 assert_empty asserts.map { |n| n.sub(/^assert/, 'refute') } - refutes 1373 end 1374 1375 def test_expectation 1376 @assertion_count = 2 1377 1378 @tc.assert_equal true, 1.must_equal(1) 1379 end 1380 1381 def test_expectation_triggered 1382 util_assert_triggered "Expected: 2\n Actual: 1" do 1383 1.must_equal 2 1384 end 1385 end 1386 1387 def test_expectation_with_a_message 1388 util_assert_triggered "Expected: 2\n Actual: 1" do 1389 1.must_equal 2, '' 1390 end 1391 end 1392 1393 def test_flunk 1394 util_assert_triggered 'Epic Fail!' do 1395 @tc.flunk 1396 end 1397 end 1398 1399 def test_flunk_message 1400 util_assert_triggered @zomg do 1401 @tc.flunk @zomg 1402 end 1403 end 1404 1405 def test_message 1406 @assertion_count = 0 1407 1408 assert_equal "blah2.", @tc.message { "blah2" }.call 1409 assert_equal "blah2.", @tc.message("") { "blah2" }.call 1410 assert_equal "blah1.\nblah2.", @tc.message(:blah1) { "blah2" }.call 1411 assert_equal "blah1.\nblah2.", @tc.message("blah1") { "blah2" }.call 1412 end 1413 1414 def test_pass 1415 @tc.pass 1416 end 1417 1418 def test_prints 1419 printer = Class.new { extend MiniTest::Assertions } 1420 @tc.assert_equal '"test"', printer.mu_pp(ImmutableString.new 'test') 1421 end 1422 1423 def test_refute 1424 @assertion_count = 2 1425 1426 @tc.assert_equal false, @tc.refute(false), "returns false on success" 1427 end 1428 1429 def test_refute_empty 1430 @assertion_count = 2 1431 1432 @tc.refute_empty [1] 1433 end 1434 1435 def test_refute_empty_triggered 1436 @assertion_count = 2 1437 1438 util_assert_triggered "Expected [] to not be empty." do 1439 @tc.refute_empty [] 1440 end 1441 end 1442 1443 def test_refute_equal 1444 @tc.refute_equal "blah", "yay" 1445 end 1446 1447 def test_refute_equal_triggered 1448 util_assert_triggered 'Expected "blah" to not be equal to "blah".' do 1449 @tc.refute_equal "blah", "blah" 1450 end 1451 end 1452 1453 def test_refute_in_delta 1454 @tc.refute_in_delta 0.0, 1.0 / 1000, 0.000001 1455 end 1456 1457 def test_refute_in_delta_triggered 1458 util_assert_triggered 'Expected |0.0 - 0.001| (0.001) to not be < 0.1.' do 1459 @tc.refute_in_delta 0.0, 1.0 / 1000, 0.1 1460 end 1461 end 1462 1463 def test_refute_in_epsilon 1464 @tc.refute_in_epsilon 10000, 9990 1465 end 1466 1467 def test_refute_in_epsilon_triggered 1468 util_assert_triggered 'Expected |10000 - 9991| (9) to not be < 10.0.' do 1469 @tc.refute_in_epsilon 10000, 9991 1470 fail 1471 end 1472 end 1473 1474 def test_refute_includes 1475 @assertion_count = 2 1476 1477 @tc.refute_includes [true], false 1478 end 1479 1480 def test_refute_includes_triggered 1481 @assertion_count = 3 1482 1483 e = @tc.assert_raises MiniTest::Assertion do 1484 @tc.refute_includes [true], true 1485 end 1486 1487 expected = "Expected [true] to not include true." 1488 assert_equal expected, e.message 1489 end 1490 1491 def test_refute_instance_of 1492 @tc.refute_instance_of Array, "blah" 1493 end 1494 1495 def test_refute_instance_of_triggered 1496 util_assert_triggered 'Expected "blah" to not be an instance of String.' do 1497 @tc.refute_instance_of String, "blah" 1498 end 1499 end 1500 1501 def test_refute_kind_of 1502 @tc.refute_kind_of Array, "blah" 1503 end 1504 1505 def test_refute_kind_of_triggered 1506 util_assert_triggered 'Expected "blah" to not be a kind of String.' do 1507 @tc.refute_kind_of String, "blah" 1508 end 1509 end 1510 1511 def test_refute_match 1512 @assertion_count = 2 1513 @tc.refute_match(/\d+/, "blah blah blah") 1514 end 1515 1516 def test_refute_match_matcher_object 1517 @assertion_count = 2 1518 @tc.refute_match Object.new, 5 # default #=~ returns false 1519 end 1520 1521 def test_refute_match_object_triggered 1522 @assertion_count = 2 1523 1524 pattern = Object.new 1525 def pattern.=~(other) true end 1526 def pattern.inspect; "[Object]" end 1527 1528 util_assert_triggered 'Expected [Object] to not match 5.' do 1529 @tc.refute_match pattern, 5 1530 end 1531 end 1532 1533 def test_refute_match_triggered 1534 @assertion_count = 2 1535 util_assert_triggered 'Expected /\w+/ to not match "blah blah blah".' do 1536 @tc.refute_match(/\w+/, "blah blah blah") 1537 end 1538 end 1539 1540 def test_refute_nil 1541 @tc.refute_nil 42 1542 end 1543 1544 def test_refute_nil_triggered 1545 util_assert_triggered 'Expected nil to not be nil.' do 1546 @tc.refute_nil nil 1547 end 1548 end 1549 1550 def test_refute_predicate 1551 @tc.refute_predicate "42", :empty? 1552 end 1553 1554 def test_refute_predicate_triggered 1555 util_assert_triggered 'Expected "" to not be empty?.' do 1556 @tc.refute_predicate "", :empty? 1557 end 1558 end 1559 1560 def test_refute_operator 1561 @tc.refute_operator 2, :<, 1 1562 end 1563 1564 def test_refute_operator_bad_object 1565 bad = Object.new 1566 def bad.==(other) true end 1567 1568 @tc.refute_operator true, :equal?, bad 1569 end 1570 1571 def test_refute_operator_triggered 1572 util_assert_triggered "Expected 2 to not be > 1." do 1573 @tc.refute_operator 2, :>, 1 1574 end 1575 end 1576 1577 def test_refute_respond_to 1578 @tc.refute_respond_to "blah", :rawr! 1579 end 1580 1581 def test_refute_respond_to_triggered 1582 util_assert_triggered 'Expected "blah" to not respond to empty?.' do 1583 @tc.refute_respond_to "blah", :empty? 1584 end 1585 end 1586 1587 def test_refute_same 1588 @tc.refute_same 1, 2 1589 end 1590 1591 def test_refute_same_triggered 1592 util_assert_triggered 'Expected 1 (oid=N) to not be the same as 1 (oid=N).' do 1593 @tc.refute_same 1, 1 1594 end 1595 end 1596 1597 def test_skip 1598 @assertion_count = 0 1599 1600 util_assert_triggered "haha!", MiniTest::Skip do 1601 @tc.skip "haha!" 1602 end 1603 end 1604 1605 def test_test_methods_random 1606 @assertion_count = 0 1607 1608 sample_test_case = Class.new MiniTest::Unit::TestCase do 1609 def self.test_order; :random; end 1610 def test_test1; assert "does not matter" end 1611 def test_test2; assert "does not matter" end 1612 def test_test3; assert "does not matter" end 1613 end 1614 1615 srand 42 1616 expected = %w(test_test2 test_test1 test_test3) 1617 assert_equal expected, sample_test_case.test_methods 1618 end 1619 1620 def test_test_methods_sorted 1621 @assertion_count = 0 1622 1623 sample_test_case = Class.new MiniTest::Unit::TestCase do 1624 def self.test_order; :sorted end 1625 def test_test3; assert "does not matter" end 1626 def test_test2; assert "does not matter" end 1627 def test_test1; assert "does not matter" end 1628 end 1629 1630 expected = %w(test_test1 test_test2 test_test3) 1631 assert_equal expected, sample_test_case.test_methods 1632 end 1633 1634 def test_i_suck_and_my_tests_are_order_dependent_bang_sets_test_order_alpha 1635 @assertion_count = 0 1636 1637 shitty_test_case = Class.new MiniTest::Unit::TestCase 1638 1639 shitty_test_case.i_suck_and_my_tests_are_order_dependent! 1640 1641 assert_equal :alpha, shitty_test_case.test_order 1642 end 1643 1644 def test_i_suck_and_my_tests_are_order_dependent_bang_does_not_warn 1645 @assertion_count = 0 1646 1647 shitty_test_case = Class.new MiniTest::Unit::TestCase 1648 1649 def shitty_test_case.test_order ; :lol end 1650 1651 assert_silent do 1652 shitty_test_case.i_suck_and_my_tests_are_order_dependent! 1653 end 1654 end 1655 1656 def util_assert_triggered expected, klass = MiniTest::Assertion 1657 e = assert_raises klass do 1658 yield 1659 end 1660 1661 msg = e.message.sub(/(---Backtrace---).*/m, '\1') 1662 msg.gsub!(/\(oid=[-0-9]+\)/, '(oid=N)') 1663 1664 assert_equal expected, msg 1665 end 1666 1667 def util_msg exp, act, msg = nil 1668 s = "Expected: #{exp.inspect}\n Actual: #{act.inspect}" 1669 s = "#{msg}.\n#{s}" if msg 1670 s 1671 end 1672 1673 def without_diff 1674 old_diff = MiniTest::Assertions.diff 1675 MiniTest::Assertions.diff = nil 1676 1677 yield 1678 ensure 1679 MiniTest::Assertions.diff = old_diff 1680 end 1681end 1682 1683class TestMiniTestGuard < MiniTest::Unit::TestCase 1684 parallelize_me! if ENV["PARALLEL"] 1685 1686 def test_mri_eh 1687 assert self.class.mri? "ruby blah" 1688 assert self.mri? "ruby blah" 1689 end 1690 1691 def test_jruby_eh 1692 assert self.class.jruby? "java" 1693 assert self.jruby? "java" 1694 end 1695 1696 def test_rubinius_eh 1697 assert self.class.rubinius? "rbx" 1698 assert self.rubinius? "rbx" 1699 end 1700 1701 def test_windows_eh 1702 assert self.class.windows? "mswin" 1703 assert self.windows? "mswin" 1704 end 1705end 1706