test-unit 3.2.0 → 3.3.6

data/test/test-code-snippet.rb

@@ -1,3 +1,5 @@
+# coding: utf-8
+
 require "test-unit"
 require "testunit-test-util"
 
@@ -34,4 +36,44 @@ class TestCodeSnippet < Test::Unit::TestCase
       end
     end
   end
+
+  class TestDefaultExternal < self
+    def suppress_warning
+      verbose = $VERBOSE
+      begin
+        $VERBOSE = false
+        yield
+      ensure
+        $VERBOSE = verbose
+      end
+    end
+
+    def setup
+      suppress_warning do
+        @default_external = Encoding.default_external
+      end
+      @fetcher = Test::Unit::CodeSnippetFetcher.new
+    end
+
+    def teardown
+      suppress_warning do
+        Encoding.default_external = @default_external
+      end
+    end
+
+    def test_windows_31j
+      source = Tempfile.new(["test-code-snippet", ".rb"])
+      source.puts(<<-SOURCE)
+puts("あいうえお")
+      SOURCE
+      source.flush
+      suppress_warning do
+        Encoding.default_external = "Windows-31J"
+      end
+      assert_equal([
+                     [1, "puts(\"あいうえお\")", {:target_line? => false}],
+                   ],
+                   @fetcher.fetch(source.path, 0))
+    end
+  end
 end

data/test/test-data.rb

@@ -46,7 +46,7 @@ class TestData < Test::Unit::TestCase
     end
 
     class TestDynamicDataSet < TestCalc
-      data do
+      DATA_PROC = lambda do
         data_set = {}
         data_set["positive positive"] = {
           :expected => 3,
@@ -60,7 +60,8 @@ class TestData < Test::Unit::TestCase
         }
         data_set
       end
-      DATA_PROC = current_attribute(:data)[:value].first
+
+      data(&DATA_PROC)
       def test_plus(data)
         assert_equal(data[:expected],
                      @calc.plus(data[:augend], data[:addend]))
@@ -90,6 +91,48 @@ class TestData < Test::Unit::TestCase
         end
       end
     end
+
+    class TestMethod < TestCalc
+      def data_test_plus
+        {
+          "positive positive" => {:expected => 4, :augend => 3, :addend => 1},
+          "positive negative" => {:expected => -1, :augend => 1, :addend => -2},
+        }
+      end
+
+      def test_plus(data)
+        assert_equal(data[:expected],
+                     @calc.plus(data[:augend], data[:addend]))
+      end
+    end
+
+    class TestPatterns < TestCalc
+      data(:x, [-1, 1, 0])
+      data(:y, [-100, 100])
+      data(:z, ["a", "b", "c"])
+      def test_use_data(data)
+      end
+    end
+
+    class TestPatternsKeep < TestCalc
+      data(:x, [-1, 1, 0], keep: true)
+      data(:y, [-100, 100])
+      data(:z, ["a", "b", "c"], keep: true)
+      def test_use_data(data)
+      end
+
+      def test_use_data_keep(data)
+      end
+    end
+
+    class TestPatternsGroup < TestCalc
+      data(:a, [-1, 1, 0], group: 1)
+      data(:b, [:a, :b], group: 1)
+      data(:x, [2, 9], group: :z)
+      data(:y, ["a", "b", "c"], group: :z)
+      def test_use_data(data)
+      end
+    end
   end
 
   def setup
@@ -109,64 +152,90 @@ class TestData < Test::Unit::TestCase
   data("data set",
        {
          :test_case => TestCalc::TestDataSet,
-         :data_set => [{
-                         "positive positive" => {
-                           :expected => 4,
-                           :augend => 3,
-                           :addend => 1,
-                         },
-                         "positive negative" => {
-                           :expected => -1,
-                           :augend => 1,
-                           :addend => -2,
-                         },
-                       }],
+         :data_sets => [
+           {
+             "positive positive" => {
+               :expected => 4,
+               :augend => 3,
+               :addend => 1,
+             },
+             "positive negative" => {
+               :expected => -1,
+               :augend => 1,
+               :addend => -2,
+             },
+           },
+         ],
        })
   data("n-data",
        {
          :test_case => TestCalc::TestNData,
-         :data_set => [{
-                         "positive positive" => {
-                           :expected => 4,
-                           :augend => 3,
-                           :addend => 1,
-                         },
-                       },
-                       {
-                         "positive negative" => {
-                           :expected => -1,
-                           :augend => 1,
-                           :addend => -2,
-                         },
-                       }],
+         :data_sets => [
+           {
+             "positive positive" => {
+               :expected => 4,
+               :augend => 3,
+               :addend => 1,
+             },
+           },
+           {
+             "positive negative" => {
+               :expected => -1,
+               :augend => 1,
+               :addend => -2,
+             },
+           },
+         ],
        })
   data("dynamic-data-set",
        {
          :test_case => TestCalc::TestDynamicDataSet,
-         :data_set => [TestCalc::TestDynamicDataSet::DATA_PROC],
+         :data_sets => [TestCalc::TestDynamicDataSet::DATA_PROC],
        })
   data("load-data-set",
        {
          :test_case => TestCalc::TestLoadDataSet,
-         :data_set => [{
-                         "positive positive" => {
-                           "expected" => 4,
-                           "augend" => 3,
-                           "addend" => 1,
-                         },
-                       },
-                       {
-                         "positive negative" => {
-                           "expected" => -1,
-                           "augend" => 1,
-                           "addend" => -2,
-                         },
-                       }],
-         })
+         :data_sets => [
+           {
+             "positive positive" => {
+               "expected" => 4,
+               "augend" => 3,
+               "addend" => 1,
+             },
+           },
+           {
+             "positive negative" => {
+               "expected" => -1,
+               "augend" => 1,
+               "addend" => -2,
+             },
+           },
+         ],
+       })
   def test_data(data)
     test_plus = data[:test_case].new("test_plus")
-    assert_equal(data[:data_set], test_plus[:data])
-    assert_not_nil(data[:data_set])
+    data_sets = Test::Unit::DataSets.new
+    data[:data_sets].each do |data_set|
+      data_sets.add(data_set)
+    end
+    assert_equal(data_sets, test_plus[:data])
+  end
+
+  def test_data_patterns
+    test = TestCalc::TestPatterns.new("test_use_data")
+    data_sets = Test::Unit::DataSets.new
+    data_sets << [:x, [-1, 1, 0]]
+    data_sets << [:y, [-100, 100]]
+    data_sets << [:z, ["a", "b", "c"]]
+    assert_equal(data_sets, test[:data])
+  end
+
+  def test_data_patterns_keep
+    test = TestCalc::TestPatternsKeep.new("test_use_data_keep")
+    data_sets = Test::Unit::DataSets.new
+    data_sets.add([:x, [-1, 1, 0]], {keep: true})
+    data_sets.add([:z, ["a", "b", "c"]], {keep: true})
+    assert_equal(data_sets, test[:data])
   end
 
   data("data set"         => TestCalc::TestDataSet,
@@ -180,11 +249,58 @@ class TestData < Test::Unit::TestCase
                  suite.tests.collect {|test| test.name}.sort)
   end
 
+  def test_suite_patterns
+    test_case = TestCalc::TestPatterns
+    suite = test_case.suite
+    assert_equal([
+                   "test_use_data[x: -1, y: -100, z: \"a\"](#{test_case.name})",
+                   "test_use_data[x: -1, y: -100, z: \"b\"](#{test_case.name})",
+                   "test_use_data[x: -1, y: -100, z: \"c\"](#{test_case.name})",
+                   "test_use_data[x: -1, y: 100, z: \"a\"](#{test_case.name})",
+                   "test_use_data[x: -1, y: 100, z: \"b\"](#{test_case.name})",
+                   "test_use_data[x: -1, y: 100, z: \"c\"](#{test_case.name})",
+                   "test_use_data[x: 0, y: -100, z: \"a\"](#{test_case.name})",
+                   "test_use_data[x: 0, y: -100, z: \"b\"](#{test_case.name})",
+                   "test_use_data[x: 0, y: -100, z: \"c\"](#{test_case.name})",
+                   "test_use_data[x: 0, y: 100, z: \"a\"](#{test_case.name})",
+                   "test_use_data[x: 0, y: 100, z: \"b\"](#{test_case.name})",
+                   "test_use_data[x: 0, y: 100, z: \"c\"](#{test_case.name})",
+                   "test_use_data[x: 1, y: -100, z: \"a\"](#{test_case.name})",
+                   "test_use_data[x: 1, y: -100, z: \"b\"](#{test_case.name})",
+                   "test_use_data[x: 1, y: -100, z: \"c\"](#{test_case.name})",
+                   "test_use_data[x: 1, y: 100, z: \"a\"](#{test_case.name})",
+                   "test_use_data[x: 1, y: 100, z: \"b\"](#{test_case.name})",
+                   "test_use_data[x: 1, y: 100, z: \"c\"](#{test_case.name})",
+                 ],
+                 suite.tests.collect {|test| test.name}.sort)
+  end
+
+  def test_suite_patterns_group
+    test_case = TestCalc::TestPatternsGroup
+    suite = test_case.suite
+    assert_equal([
+                   "test_use_data[group: 1, a: -1, b: :a](#{test_case.name})",
+                   "test_use_data[group: 1, a: -1, b: :b](#{test_case.name})",
+                   "test_use_data[group: 1, a: 0, b: :a](#{test_case.name})",
+                   "test_use_data[group: 1, a: 0, b: :b](#{test_case.name})",
+                   "test_use_data[group: 1, a: 1, b: :a](#{test_case.name})",
+                   "test_use_data[group: 1, a: 1, b: :b](#{test_case.name})",
+                   "test_use_data[group: :z, x: 2, y: \"a\"](#{test_case.name})",
+                   "test_use_data[group: :z, x: 2, y: \"b\"](#{test_case.name})",
+                   "test_use_data[group: :z, x: 2, y: \"c\"](#{test_case.name})",
+                   "test_use_data[group: :z, x: 9, y: \"a\"](#{test_case.name})",
+                   "test_use_data[group: :z, x: 9, y: \"b\"](#{test_case.name})",
+                   "test_use_data[group: :z, x: 9, y: \"c\"](#{test_case.name})",
+                 ],
+                 suite.tests.collect {|test| test.name}.sort)
+  end
+
   data("data set"         => TestCalc::TestDataSet,
        "n-data"           => TestCalc::TestNData,
        "dynamic-data-set" => TestCalc::TestDynamicDataSet,
        "load-data-set"    => TestCalc::TestLoadDataSet,
-       "superclass"       => TestCalc::TestSuperclass)
+       "superclass"       => TestCalc::TestSuperclass,
+       "method"           => TestCalc::TestMethod)
   def test_run(test_case)
     result = _run_test(test_case)
     assert_equal("2 tests, 2 assertions, 0 failures, 0 errors, 0 pendings, " \
@@ -249,20 +365,20 @@ class TestData < Test::Unit::TestCase
              "tsv" => "header.tsv")
         def test_normal(file_name)
           self.class.load_data(fixture_file_path(file_name))
-          assert_equal([
-                         {
-                           "empty string" => {
-                             "expected" => true,
-                             "target"   => ""
-                           }
-                         },
-                         {
-                           "plain string" => {
-                             "expected" => false,
-                             "target"   => "hello"
-                           }
-                         }
-                       ],
+          data_sets = Test::Unit::DataSets.new
+          data_sets << {
+            "empty string" => {
+              "expected" => true,
+              "target"   => ""
+            }
+          }
+          data_sets << {
+            "plain string" => {
+              "expected" => false,
+              "target"   => "hello"
+            }
+          }
+          assert_equal(data_sets,
                        self.class.current_attribute(:data)[:value])
         end
 
@@ -270,20 +386,20 @@ class TestData < Test::Unit::TestCase
              "tsv" => "header-label.tsv")
         def test_label(file_name)
           self.class.load_data(fixture_file_path(file_name))
-          assert_equal([
-                         {
-                           "upper case" => {
-                             "expected" => "HELLO",
-                             "label"    => "HELLO"
-                           }
-                         },
-                         {
-                           "lower case" => {
-                             "expected" => "Hello",
-                             "label"    => "hello"
-                           }
-                         }
-                       ],
+          data_sets = Test::Unit::DataSets.new
+          data_sets << {
+            "upper case" => {
+              "expected" => "HELLO",
+              "label"    => "HELLO"
+            }
+          }
+          data_sets << {
+            "lower case" => {
+              "expected" => "Hello",
+              "label"    => "hello"
+            }
+          }
+          assert_equal(data_sets,
                        self.class.current_attribute(:data)[:value])
         end
       end
@@ -292,10 +408,10 @@ class TestData < Test::Unit::TestCase
            "tsv" => "no-header.tsv")
       def test_without_header(file_name)
         self.class.load_data(fixture_file_path(file_name))
-        assert_equal([
-                       {"empty string" => [true, ""]},
-                       {"plain string" => [false, "hello"]}
-                     ],
+        data_sets = Test::Unit::DataSets.new
+        data_sets << {"empty string" => [true, ""]}
+        data_sets << {"plain string" => [false, "hello"]}
+        assert_equal(data_sets,
                      self.class.current_attribute(:data)[:value])
       end
     end

data/test/test-priority.rb

@@ -104,7 +104,7 @@ class TestUnitPriority < Test::Unit::TestCase
 
   class TestClassName < self
     def test_colon
-      assert_escaped_name("Test__Priority", "Test::Priority")
+      assert_escaped_name("Test_colon__colon_Priority", "Test::Priority")
     end
 
     def test_space
@@ -119,6 +119,18 @@ class TestUnitPriority < Test::Unit::TestCase
       assert_escaped_name("test_priority", "test\/priority")
     end
 
+    def test_question
+      assert_escaped_name("#question.predicate", "#question?")
+    end
+
+    def test_exclamation
+      assert_escaped_name("#exclamation.destructive", "#exclamation!")
+    end
+
+    def test_equal
+      assert_escaped_name("#equal.equal", "#equal=")
+    end
+
     def assert_escaped_name(expected, class_name)
       checker = Checker.new(nil)
       escaped_class_name = checker.send(:escape_class_name, class_name)
@@ -148,19 +160,18 @@ class TestUnitPriority < Test::Unit::TestCase
     end
 
     def test_question
-      assert_escaped_name("test_question.predicate", "test_question?")
+      assert_escaped_name("test_colon__#question.predicate_case",
+                          "test: #question? case")
     end
 
     def test_exclamation
-      assert_escaped_name("test_exclamation.destructive", "test_exclamation!")
+      assert_escaped_name("test_colon__#exclamation.destructive_case",
+                          "test: #exclamation! case")
     end
 
     def test_equal
-      assert_escaped_name("test_equal.equal", "test_equal=")
-    end
-
-    def test_colon_and_space
-      assert_escaped_name("test_colon__have_space", "test: have space")
+      assert_escaped_name("test_colon__#equal.equal_case",
+                          "test: #equal= case")
     end
 
     def assert_escaped_name(expected, test_method_name)

data/test/test-test-case.rb

@@ -465,9 +465,6 @@ module Test
           end
         end
 
-        assert_equal(["test_1", "test_a", "test_z"],
-                     test_case.suite.tests.collect {|test| test.method_name})
-
         test_case.test_order = :defined
         assert_equal(["test_z", "test_1", "test_a"],
                      test_case.suite.tests.collect {|test| test.method_name})
@@ -513,6 +510,8 @@ module Test
 
       def test_redefine_method
         test_case = Class.new(Test::Unit::TestCase) do
+          self.test_order = :alphabetic
+
           def test_name
           end
           alias_method :test_name2, :test_name
@@ -543,6 +542,24 @@ module Test
         assert_predicate(test, :valid?)
       end
 
+      def test_data_driven_test_without_parameter
+        test_case = Class.new(TestCase) do
+          data("label" => "value")
+          def test_without_parameter
+            assert_equal("value", data)
+          end
+        end
+
+        suite = test_case.suite
+        assert_equal(["test_without_parameter"],
+                     suite.tests.collect {|test| test.method_name})
+        result = TestResult.new
+        suite.run(result) {}
+        assert_equal("1 tests, 1 assertions, 0 failures, " +
+                     "0 errors, 0 pendings, 0 omissions, 0 notifications",
+                     result.summary)
+      end
+
       private
       def check(message, passed)
         add_assertion
@@ -735,6 +752,21 @@ module Test
                              child_test_case.test_defined?(:line => line_child),
                            ])
             end
+
+            def test_with_setup
+              line = nil
+              test_case = Class.new(TestCase) do
+                setup do
+                end
+
+                line = __LINE__; test "with setup" do
+                end
+              end
+              assert do
+                test_case.test_defined?(:line => line,
+                                        :method_name => "test: with setup")
+              end
+            end
           end
         end
 
@@ -980,6 +1012,8 @@ module Test
               @parent_test_case = Class.new(TestCase) do
                 extend CallLogger
 
+                self.test_order = :alphabetic
+
                 class << self
                   def startup
                     called << :startup_parent
@@ -1164,6 +1198,80 @@ module Test
             assert_equal([:startup, :shutdown],
                          test_case.called)
           end
+
+          class TestName < self
+            def test_no_data
+              test_case = Class.new(TestCase) do
+                class << self
+                  def name
+                    "TestCase"
+                  end
+                end
+
+                def test_nothing
+                end
+              end
+
+              test = test_case.new("test_nothing")
+              assert_equal("test_nothing(TestCase)",
+                           test.name)
+            end
+
+            def test_data
+              test_case = Class.new(TestCase) do
+                class << self
+                  def name
+                    "TestCase"
+                  end
+                end
+
+                def test_nothing
+                end
+              end
+
+              test = test_case.new("test_nothing")
+              test.assign_test_data("(nil)", nil)
+              assert_equal("test_nothing[(nil)](TestCase)",
+                           test.name)
+            end
+          end
+
+          class TestLocalName < self
+            def test_no_data
+              test_case = Class.new(TestCase) do
+                class << self
+                  def name
+                    "TestCase"
+                  end
+                end
+
+                def test_nothing
+                end
+              end
+
+              test = test_case.new("test_nothing")
+              assert_equal("test_nothing",
+                           test.local_name)
+            end
+
+            def test_data
+              test_case = Class.new(TestCase) do
+                class << self
+                  def name
+                    "TestCase"
+                  end
+                end
+
+                def test_nothing
+                end
+              end
+
+              test = test_case.new("test_nothing")
+              test.assign_test_data("(nil)", nil)
+              assert_equal("test_nothing[(nil)]",
+                           test.local_name)
+            end
+          end
         end
       end
     end