betatest 0.0.1

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