test-unit 3.2.0 → 3.3.6

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.
Files changed (41) hide show
  1. checksums.yaml +5 -5
  2. data/COPYING +4 -1
  3. data/README.md +11 -11
  4. data/Rakefile +10 -1
  5. data/doc/text/getting-started.md +246 -0
  6. data/doc/text/news.md +372 -1
  7. data/lib/test/unit.rb +171 -157
  8. data/lib/test/unit/assertions.rb +187 -149
  9. data/lib/test/unit/attribute.rb +71 -2
  10. data/lib/test/unit/autorunner.rb +65 -32
  11. data/lib/test/unit/code-snippet-fetcher.rb +7 -7
  12. data/lib/test/unit/collector/load.rb +8 -13
  13. data/lib/test/unit/data-sets.rb +116 -0
  14. data/lib/test/unit/data.rb +121 -12
  15. data/lib/test/unit/diff.rb +11 -11
  16. data/lib/test/unit/fixture.rb +3 -0
  17. data/lib/test/unit/notification.rb +9 -7
  18. data/lib/test/unit/omission.rb +34 -31
  19. data/lib/test/unit/pending.rb +12 -11
  20. data/lib/test/unit/priority.rb +7 -3
  21. data/lib/test/unit/runner/console.rb +25 -0
  22. data/lib/test/unit/test-suite-creator.rb +22 -8
  23. data/lib/test/unit/testcase.rb +270 -182
  24. data/lib/test/unit/ui/console/testrunner.rb +90 -35
  25. data/lib/test/unit/ui/emacs/testrunner.rb +5 -5
  26. data/lib/test/unit/util/observable.rb +2 -2
  27. data/lib/test/unit/util/output.rb +5 -4
  28. data/lib/test/unit/util/procwrapper.rb +4 -4
  29. data/lib/test/unit/version.rb +1 -1
  30. data/test/collector/test-descendant.rb +4 -0
  31. data/test/collector/test-load.rb +35 -2
  32. data/test/collector/test_dir.rb +5 -4
  33. data/test/collector/test_objectspace.rb +7 -5
  34. data/test/test-assertions.rb +128 -101
  35. data/test/test-code-snippet.rb +42 -0
  36. data/test/test-data.rb +195 -79
  37. data/test/test-priority.rb +19 -8
  38. data/test/test-test-case.rb +111 -3
  39. data/test/test-test-suite.rb +1 -0
  40. data/test/testunit-test-util.rb +2 -0
  41. metadata +38 -37
@@ -1,3 +1,5 @@
1
+ # coding: utf-8
2
+
1
3
  require "test-unit"
2
4
  require "testunit-test-util"
3
5
 
@@ -34,4 +36,44 @@ class TestCodeSnippet < Test::Unit::TestCase
34
36
  end
35
37
  end
36
38
  end
39
+
40
+ class TestDefaultExternal < self
41
+ def suppress_warning
42
+ verbose = $VERBOSE
43
+ begin
44
+ $VERBOSE = false
45
+ yield
46
+ ensure
47
+ $VERBOSE = verbose
48
+ end
49
+ end
50
+
51
+ def setup
52
+ suppress_warning do
53
+ @default_external = Encoding.default_external
54
+ end
55
+ @fetcher = Test::Unit::CodeSnippetFetcher.new
56
+ end
57
+
58
+ def teardown
59
+ suppress_warning do
60
+ Encoding.default_external = @default_external
61
+ end
62
+ end
63
+
64
+ def test_windows_31j
65
+ source = Tempfile.new(["test-code-snippet", ".rb"])
66
+ source.puts(<<-SOURCE)
67
+ puts("あいうえお")
68
+ SOURCE
69
+ source.flush
70
+ suppress_warning do
71
+ Encoding.default_external = "Windows-31J"
72
+ end
73
+ assert_equal([
74
+ [1, "puts(\"あいうえお\")", {:target_line? => false}],
75
+ ],
76
+ @fetcher.fetch(source.path, 0))
77
+ end
78
+ end
37
79
  end
@@ -46,7 +46,7 @@ class TestData < Test::Unit::TestCase
46
46
  end
47
47
 
48
48
  class TestDynamicDataSet < TestCalc
49
- data do
49
+ DATA_PROC = lambda do
50
50
  data_set = {}
51
51
  data_set["positive positive"] = {
52
52
  :expected => 3,
@@ -60,7 +60,8 @@ class TestData < Test::Unit::TestCase
60
60
  }
61
61
  data_set
62
62
  end
63
- DATA_PROC = current_attribute(:data)[:value].first
63
+
64
+ data(&DATA_PROC)
64
65
  def test_plus(data)
65
66
  assert_equal(data[:expected],
66
67
  @calc.plus(data[:augend], data[:addend]))
@@ -90,6 +91,48 @@ class TestData < Test::Unit::TestCase
90
91
  end
91
92
  end
92
93
  end
94
+
95
+ class TestMethod < TestCalc
96
+ def data_test_plus
97
+ {
98
+ "positive positive" => {:expected => 4, :augend => 3, :addend => 1},
99
+ "positive negative" => {:expected => -1, :augend => 1, :addend => -2},
100
+ }
101
+ end
102
+
103
+ def test_plus(data)
104
+ assert_equal(data[:expected],
105
+ @calc.plus(data[:augend], data[:addend]))
106
+ end
107
+ end
108
+
109
+ class TestPatterns < TestCalc
110
+ data(:x, [-1, 1, 0])
111
+ data(:y, [-100, 100])
112
+ data(:z, ["a", "b", "c"])
113
+ def test_use_data(data)
114
+ end
115
+ end
116
+
117
+ class TestPatternsKeep < TestCalc
118
+ data(:x, [-1, 1, 0], keep: true)
119
+ data(:y, [-100, 100])
120
+ data(:z, ["a", "b", "c"], keep: true)
121
+ def test_use_data(data)
122
+ end
123
+
124
+ def test_use_data_keep(data)
125
+ end
126
+ end
127
+
128
+ class TestPatternsGroup < TestCalc
129
+ data(:a, [-1, 1, 0], group: 1)
130
+ data(:b, [:a, :b], group: 1)
131
+ data(:x, [2, 9], group: :z)
132
+ data(:y, ["a", "b", "c"], group: :z)
133
+ def test_use_data(data)
134
+ end
135
+ end
93
136
  end
94
137
 
95
138
  def setup
@@ -109,64 +152,90 @@ class TestData < Test::Unit::TestCase
109
152
  data("data set",
110
153
  {
111
154
  :test_case => TestCalc::TestDataSet,
112
- :data_set => [{
113
- "positive positive" => {
114
- :expected => 4,
115
- :augend => 3,
116
- :addend => 1,
117
- },
118
- "positive negative" => {
119
- :expected => -1,
120
- :augend => 1,
121
- :addend => -2,
122
- },
123
- }],
155
+ :data_sets => [
156
+ {
157
+ "positive positive" => {
158
+ :expected => 4,
159
+ :augend => 3,
160
+ :addend => 1,
161
+ },
162
+ "positive negative" => {
163
+ :expected => -1,
164
+ :augend => 1,
165
+ :addend => -2,
166
+ },
167
+ },
168
+ ],
124
169
  })
125
170
  data("n-data",
126
171
  {
127
172
  :test_case => TestCalc::TestNData,
128
- :data_set => [{
129
- "positive positive" => {
130
- :expected => 4,
131
- :augend => 3,
132
- :addend => 1,
133
- },
134
- },
135
- {
136
- "positive negative" => {
137
- :expected => -1,
138
- :augend => 1,
139
- :addend => -2,
140
- },
141
- }],
173
+ :data_sets => [
174
+ {
175
+ "positive positive" => {
176
+ :expected => 4,
177
+ :augend => 3,
178
+ :addend => 1,
179
+ },
180
+ },
181
+ {
182
+ "positive negative" => {
183
+ :expected => -1,
184
+ :augend => 1,
185
+ :addend => -2,
186
+ },
187
+ },
188
+ ],
142
189
  })
143
190
  data("dynamic-data-set",
144
191
  {
145
192
  :test_case => TestCalc::TestDynamicDataSet,
146
- :data_set => [TestCalc::TestDynamicDataSet::DATA_PROC],
193
+ :data_sets => [TestCalc::TestDynamicDataSet::DATA_PROC],
147
194
  })
148
195
  data("load-data-set",
149
196
  {
150
197
  :test_case => TestCalc::TestLoadDataSet,
151
- :data_set => [{
152
- "positive positive" => {
153
- "expected" => 4,
154
- "augend" => 3,
155
- "addend" => 1,
156
- },
157
- },
158
- {
159
- "positive negative" => {
160
- "expected" => -1,
161
- "augend" => 1,
162
- "addend" => -2,
163
- },
164
- }],
165
- })
198
+ :data_sets => [
199
+ {
200
+ "positive positive" => {
201
+ "expected" => 4,
202
+ "augend" => 3,
203
+ "addend" => 1,
204
+ },
205
+ },
206
+ {
207
+ "positive negative" => {
208
+ "expected" => -1,
209
+ "augend" => 1,
210
+ "addend" => -2,
211
+ },
212
+ },
213
+ ],
214
+ })
166
215
  def test_data(data)
167
216
  test_plus = data[:test_case].new("test_plus")
168
- assert_equal(data[:data_set], test_plus[:data])
169
- assert_not_nil(data[:data_set])
217
+ data_sets = Test::Unit::DataSets.new
218
+ data[:data_sets].each do |data_set|
219
+ data_sets.add(data_set)
220
+ end
221
+ assert_equal(data_sets, test_plus[:data])
222
+ end
223
+
224
+ def test_data_patterns
225
+ test = TestCalc::TestPatterns.new("test_use_data")
226
+ data_sets = Test::Unit::DataSets.new
227
+ data_sets << [:x, [-1, 1, 0]]
228
+ data_sets << [:y, [-100, 100]]
229
+ data_sets << [:z, ["a", "b", "c"]]
230
+ assert_equal(data_sets, test[:data])
231
+ end
232
+
233
+ def test_data_patterns_keep
234
+ test = TestCalc::TestPatternsKeep.new("test_use_data_keep")
235
+ data_sets = Test::Unit::DataSets.new
236
+ data_sets.add([:x, [-1, 1, 0]], {keep: true})
237
+ data_sets.add([:z, ["a", "b", "c"]], {keep: true})
238
+ assert_equal(data_sets, test[:data])
170
239
  end
171
240
 
172
241
  data("data set" => TestCalc::TestDataSet,
@@ -180,11 +249,58 @@ class TestData < Test::Unit::TestCase
180
249
  suite.tests.collect {|test| test.name}.sort)
181
250
  end
182
251
 
252
+ def test_suite_patterns
253
+ test_case = TestCalc::TestPatterns
254
+ suite = test_case.suite
255
+ assert_equal([
256
+ "test_use_data[x: -1, y: -100, z: \"a\"](#{test_case.name})",
257
+ "test_use_data[x: -1, y: -100, z: \"b\"](#{test_case.name})",
258
+ "test_use_data[x: -1, y: -100, z: \"c\"](#{test_case.name})",
259
+ "test_use_data[x: -1, y: 100, z: \"a\"](#{test_case.name})",
260
+ "test_use_data[x: -1, y: 100, z: \"b\"](#{test_case.name})",
261
+ "test_use_data[x: -1, y: 100, z: \"c\"](#{test_case.name})",
262
+ "test_use_data[x: 0, y: -100, z: \"a\"](#{test_case.name})",
263
+ "test_use_data[x: 0, y: -100, z: \"b\"](#{test_case.name})",
264
+ "test_use_data[x: 0, y: -100, z: \"c\"](#{test_case.name})",
265
+ "test_use_data[x: 0, y: 100, z: \"a\"](#{test_case.name})",
266
+ "test_use_data[x: 0, y: 100, z: \"b\"](#{test_case.name})",
267
+ "test_use_data[x: 0, y: 100, z: \"c\"](#{test_case.name})",
268
+ "test_use_data[x: 1, y: -100, z: \"a\"](#{test_case.name})",
269
+ "test_use_data[x: 1, y: -100, z: \"b\"](#{test_case.name})",
270
+ "test_use_data[x: 1, y: -100, z: \"c\"](#{test_case.name})",
271
+ "test_use_data[x: 1, y: 100, z: \"a\"](#{test_case.name})",
272
+ "test_use_data[x: 1, y: 100, z: \"b\"](#{test_case.name})",
273
+ "test_use_data[x: 1, y: 100, z: \"c\"](#{test_case.name})",
274
+ ],
275
+ suite.tests.collect {|test| test.name}.sort)
276
+ end
277
+
278
+ def test_suite_patterns_group
279
+ test_case = TestCalc::TestPatternsGroup
280
+ suite = test_case.suite
281
+ assert_equal([
282
+ "test_use_data[group: 1, a: -1, b: :a](#{test_case.name})",
283
+ "test_use_data[group: 1, a: -1, b: :b](#{test_case.name})",
284
+ "test_use_data[group: 1, a: 0, b: :a](#{test_case.name})",
285
+ "test_use_data[group: 1, a: 0, b: :b](#{test_case.name})",
286
+ "test_use_data[group: 1, a: 1, b: :a](#{test_case.name})",
287
+ "test_use_data[group: 1, a: 1, b: :b](#{test_case.name})",
288
+ "test_use_data[group: :z, x: 2, y: \"a\"](#{test_case.name})",
289
+ "test_use_data[group: :z, x: 2, y: \"b\"](#{test_case.name})",
290
+ "test_use_data[group: :z, x: 2, y: \"c\"](#{test_case.name})",
291
+ "test_use_data[group: :z, x: 9, y: \"a\"](#{test_case.name})",
292
+ "test_use_data[group: :z, x: 9, y: \"b\"](#{test_case.name})",
293
+ "test_use_data[group: :z, x: 9, y: \"c\"](#{test_case.name})",
294
+ ],
295
+ suite.tests.collect {|test| test.name}.sort)
296
+ end
297
+
183
298
  data("data set" => TestCalc::TestDataSet,
184
299
  "n-data" => TestCalc::TestNData,
185
300
  "dynamic-data-set" => TestCalc::TestDynamicDataSet,
186
301
  "load-data-set" => TestCalc::TestLoadDataSet,
187
- "superclass" => TestCalc::TestSuperclass)
302
+ "superclass" => TestCalc::TestSuperclass,
303
+ "method" => TestCalc::TestMethod)
188
304
  def test_run(test_case)
189
305
  result = _run_test(test_case)
190
306
  assert_equal("2 tests, 2 assertions, 0 failures, 0 errors, 0 pendings, " \
@@ -249,20 +365,20 @@ class TestData < Test::Unit::TestCase
249
365
  "tsv" => "header.tsv")
250
366
  def test_normal(file_name)
251
367
  self.class.load_data(fixture_file_path(file_name))
252
- assert_equal([
253
- {
254
- "empty string" => {
255
- "expected" => true,
256
- "target" => ""
257
- }
258
- },
259
- {
260
- "plain string" => {
261
- "expected" => false,
262
- "target" => "hello"
263
- }
264
- }
265
- ],
368
+ data_sets = Test::Unit::DataSets.new
369
+ data_sets << {
370
+ "empty string" => {
371
+ "expected" => true,
372
+ "target" => ""
373
+ }
374
+ }
375
+ data_sets << {
376
+ "plain string" => {
377
+ "expected" => false,
378
+ "target" => "hello"
379
+ }
380
+ }
381
+ assert_equal(data_sets,
266
382
  self.class.current_attribute(:data)[:value])
267
383
  end
268
384
 
@@ -270,20 +386,20 @@ class TestData < Test::Unit::TestCase
270
386
  "tsv" => "header-label.tsv")
271
387
  def test_label(file_name)
272
388
  self.class.load_data(fixture_file_path(file_name))
273
- assert_equal([
274
- {
275
- "upper case" => {
276
- "expected" => "HELLO",
277
- "label" => "HELLO"
278
- }
279
- },
280
- {
281
- "lower case" => {
282
- "expected" => "Hello",
283
- "label" => "hello"
284
- }
285
- }
286
- ],
389
+ data_sets = Test::Unit::DataSets.new
390
+ data_sets << {
391
+ "upper case" => {
392
+ "expected" => "HELLO",
393
+ "label" => "HELLO"
394
+ }
395
+ }
396
+ data_sets << {
397
+ "lower case" => {
398
+ "expected" => "Hello",
399
+ "label" => "hello"
400
+ }
401
+ }
402
+ assert_equal(data_sets,
287
403
  self.class.current_attribute(:data)[:value])
288
404
  end
289
405
  end
@@ -292,10 +408,10 @@ class TestData < Test::Unit::TestCase
292
408
  "tsv" => "no-header.tsv")
293
409
  def test_without_header(file_name)
294
410
  self.class.load_data(fixture_file_path(file_name))
295
- assert_equal([
296
- {"empty string" => [true, ""]},
297
- {"plain string" => [false, "hello"]}
298
- ],
411
+ data_sets = Test::Unit::DataSets.new
412
+ data_sets << {"empty string" => [true, ""]}
413
+ data_sets << {"plain string" => [false, "hello"]}
414
+ assert_equal(data_sets,
299
415
  self.class.current_attribute(:data)[:value])
300
416
  end
301
417
  end
@@ -104,7 +104,7 @@ class TestUnitPriority < Test::Unit::TestCase
104
104
 
105
105
  class TestClassName < self
106
106
  def test_colon
107
- assert_escaped_name("Test__Priority", "Test::Priority")
107
+ assert_escaped_name("Test_colon__colon_Priority", "Test::Priority")
108
108
  end
109
109
 
110
110
  def test_space
@@ -119,6 +119,18 @@ class TestUnitPriority < Test::Unit::TestCase
119
119
  assert_escaped_name("test_priority", "test\/priority")
120
120
  end
121
121
 
122
+ def test_question
123
+ assert_escaped_name("#question.predicate", "#question?")
124
+ end
125
+
126
+ def test_exclamation
127
+ assert_escaped_name("#exclamation.destructive", "#exclamation!")
128
+ end
129
+
130
+ def test_equal
131
+ assert_escaped_name("#equal.equal", "#equal=")
132
+ end
133
+
122
134
  def assert_escaped_name(expected, class_name)
123
135
  checker = Checker.new(nil)
124
136
  escaped_class_name = checker.send(:escape_class_name, class_name)
@@ -148,19 +160,18 @@ class TestUnitPriority < Test::Unit::TestCase
148
160
  end
149
161
 
150
162
  def test_question
151
- assert_escaped_name("test_question.predicate", "test_question?")
163
+ assert_escaped_name("test_colon__#question.predicate_case",
164
+ "test: #question? case")
152
165
  end
153
166
 
154
167
  def test_exclamation
155
- assert_escaped_name("test_exclamation.destructive", "test_exclamation!")
168
+ assert_escaped_name("test_colon__#exclamation.destructive_case",
169
+ "test: #exclamation! case")
156
170
  end
157
171
 
158
172
  def test_equal
159
- assert_escaped_name("test_equal.equal", "test_equal=")
160
- end
161
-
162
- def test_colon_and_space
163
- assert_escaped_name("test_colon__have_space", "test: have space")
173
+ assert_escaped_name("test_colon__#equal.equal_case",
174
+ "test: #equal= case")
164
175
  end
165
176
 
166
177
  def assert_escaped_name(expected, test_method_name)
@@ -465,9 +465,6 @@ module Test
465
465
  end
466
466
  end
467
467
 
468
- assert_equal(["test_1", "test_a", "test_z"],
469
- test_case.suite.tests.collect {|test| test.method_name})
470
-
471
468
  test_case.test_order = :defined
472
469
  assert_equal(["test_z", "test_1", "test_a"],
473
470
  test_case.suite.tests.collect {|test| test.method_name})
@@ -513,6 +510,8 @@ module Test
513
510
 
514
511
  def test_redefine_method
515
512
  test_case = Class.new(Test::Unit::TestCase) do
513
+ self.test_order = :alphabetic
514
+
516
515
  def test_name
517
516
  end
518
517
  alias_method :test_name2, :test_name
@@ -543,6 +542,24 @@ module Test
543
542
  assert_predicate(test, :valid?)
544
543
  end
545
544
 
545
+ def test_data_driven_test_without_parameter
546
+ test_case = Class.new(TestCase) do
547
+ data("label" => "value")
548
+ def test_without_parameter
549
+ assert_equal("value", data)
550
+ end
551
+ end
552
+
553
+ suite = test_case.suite
554
+ assert_equal(["test_without_parameter"],
555
+ suite.tests.collect {|test| test.method_name})
556
+ result = TestResult.new
557
+ suite.run(result) {}
558
+ assert_equal("1 tests, 1 assertions, 0 failures, " +
559
+ "0 errors, 0 pendings, 0 omissions, 0 notifications",
560
+ result.summary)
561
+ end
562
+
546
563
  private
547
564
  def check(message, passed)
548
565
  add_assertion
@@ -735,6 +752,21 @@ module Test
735
752
  child_test_case.test_defined?(:line => line_child),
736
753
  ])
737
754
  end
755
+
756
+ def test_with_setup
757
+ line = nil
758
+ test_case = Class.new(TestCase) do
759
+ setup do
760
+ end
761
+
762
+ line = __LINE__; test "with setup" do
763
+ end
764
+ end
765
+ assert do
766
+ test_case.test_defined?(:line => line,
767
+ :method_name => "test: with setup")
768
+ end
769
+ end
738
770
  end
739
771
  end
740
772
 
@@ -980,6 +1012,8 @@ module Test
980
1012
  @parent_test_case = Class.new(TestCase) do
981
1013
  extend CallLogger
982
1014
 
1015
+ self.test_order = :alphabetic
1016
+
983
1017
  class << self
984
1018
  def startup
985
1019
  called << :startup_parent
@@ -1164,6 +1198,80 @@ module Test
1164
1198
  assert_equal([:startup, :shutdown],
1165
1199
  test_case.called)
1166
1200
  end
1201
+
1202
+ class TestName < self
1203
+ def test_no_data
1204
+ test_case = Class.new(TestCase) do
1205
+ class << self
1206
+ def name
1207
+ "TestCase"
1208
+ end
1209
+ end
1210
+
1211
+ def test_nothing
1212
+ end
1213
+ end
1214
+
1215
+ test = test_case.new("test_nothing")
1216
+ assert_equal("test_nothing(TestCase)",
1217
+ test.name)
1218
+ end
1219
+
1220
+ def test_data
1221
+ test_case = Class.new(TestCase) do
1222
+ class << self
1223
+ def name
1224
+ "TestCase"
1225
+ end
1226
+ end
1227
+
1228
+ def test_nothing
1229
+ end
1230
+ end
1231
+
1232
+ test = test_case.new("test_nothing")
1233
+ test.assign_test_data("(nil)", nil)
1234
+ assert_equal("test_nothing[(nil)](TestCase)",
1235
+ test.name)
1236
+ end
1237
+ end
1238
+
1239
+ class TestLocalName < self
1240
+ def test_no_data
1241
+ test_case = Class.new(TestCase) do
1242
+ class << self
1243
+ def name
1244
+ "TestCase"
1245
+ end
1246
+ end
1247
+
1248
+ def test_nothing
1249
+ end
1250
+ end
1251
+
1252
+ test = test_case.new("test_nothing")
1253
+ assert_equal("test_nothing",
1254
+ test.local_name)
1255
+ end
1256
+
1257
+ def test_data
1258
+ test_case = Class.new(TestCase) do
1259
+ class << self
1260
+ def name
1261
+ "TestCase"
1262
+ end
1263
+ end
1264
+
1265
+ def test_nothing
1266
+ end
1267
+ end
1268
+
1269
+ test = test_case.new("test_nothing")
1270
+ test.assign_test_data("(nil)", nil)
1271
+ assert_equal("test_nothing[(nil)]",
1272
+ test.local_name)
1273
+ end
1274
+ end
1167
1275
  end
1168
1276
  end
1169
1277
  end