RubyGems - test-unit - Versions diffs - 3.2.9 → 3.5.5 - Mend

test-unit 3.2.9 → 3.5.5

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 (80) hide show

checksums.yaml +4 -4
data/BSDL +24 -0
data/COPYING +41 -44
data/README.md +18 -11
data/Rakefile +0 -23
data/doc/text/getting-started.md +2 -2
data/doc/text/news.md +329 -1
data/lib/test/unit/assertion-failed-error.rb +35 -0
data/lib/test/unit/assertions.rb +453 -161
data/lib/test/unit/attribute.rb +3 -1
data/lib/test/unit/autorunner.rb +78 -30
data/lib/test/unit/code-snippet-fetcher.rb +7 -7
data/lib/test/unit/collector/descendant.rb +1 -0
data/lib/test/unit/collector/dir.rb +4 -2
data/lib/test/unit/collector/load.rb +3 -3
data/lib/test/unit/collector/objectspace.rb +1 -0
data/lib/test/unit/collector.rb +31 -0
data/lib/test/unit/color-scheme.rb +20 -2
data/lib/test/unit/data-sets.rb +26 -15
data/lib/test/unit/data.rb +5 -5
data/lib/test/unit/diff.rb +2 -3
data/lib/test/unit/fixture.rb +6 -0
data/lib/test/unit/notification.rb +9 -7
data/lib/test/unit/omission.rb +34 -31
data/lib/test/unit/pending.rb +12 -11
data/lib/test/unit/priority.rb +7 -5
data/lib/test/unit/runner/console.rb +0 -17
data/lib/test/unit/testcase.rb +222 -146
data/lib/test/unit/testsuite.rb +1 -1
data/lib/test/unit/ui/console/testrunner.rb +58 -49
data/lib/test/unit/util/memory-usage.rb +47 -0
data/lib/test/unit/util/observable.rb +2 -2
data/lib/test/unit/util/output.rb +5 -4
data/lib/test/unit/version.rb +1 -1
data/lib/test/unit/warning.rb +3 -0
data/lib/test/unit.rb +177 -161
data/lib/test-unit.rb +2 -17
metadata +14 -91
data/GPL +0 -339
data/LGPL +0 -502
data/test/collector/test-descendant.rb +0 -182
data/test/collector/test-load.rb +0 -442
data/test/collector/test_dir.rb +0 -407
data/test/collector/test_objectspace.rb +0 -102
data/test/fixtures/header-label.csv +0 -3
data/test/fixtures/header-label.tsv +0 -3
data/test/fixtures/header.csv +0 -3
data/test/fixtures/header.tsv +0 -3
data/test/fixtures/no-header.csv +0 -2
data/test/fixtures/no-header.tsv +0 -2
data/test/fixtures/plus.csv +0 -3
data/test/run-test.rb +0 -22
data/test/test-assertions.rb +0 -2180
data/test/test-attribute-matcher.rb +0 -38
data/test/test-attribute.rb +0 -123
data/test/test-code-snippet.rb +0 -37
data/test/test-color-scheme.rb +0 -82
data/test/test-color.rb +0 -47
data/test/test-data.rb +0 -419
data/test/test-diff.rb +0 -518
data/test/test-emacs-runner.rb +0 -60
data/test/test-error.rb +0 -26
data/test/test-failure.rb +0 -33
data/test/test-fault-location-detector.rb +0 -163
data/test/test-fixture.rb +0 -713
data/test/test-notification.rb +0 -33
data/test/test-omission.rb +0 -81
data/test/test-pending.rb +0 -70
data/test/test-priority.rb +0 -173
data/test/test-test-case.rb +0 -1279
data/test/test-test-result.rb +0 -113
data/test/test-test-suite-creator.rb +0 -97
data/test/test-test-suite.rb +0 -151
data/test/testunit-test-util.rb +0 -31
data/test/ui/test_testrunmediator.rb +0 -20
data/test/util/test-method-owner-finder.rb +0 -38
data/test/util/test-output.rb +0 -11
data/test/util/test_backtracefilter.rb +0 -52
data/test/util/test_observable.rb +0 -102
data/test/util/test_procwrapper.rb +0 -36

data/test/test-data.rb DELETED Viewed

@@ -1,419 +0,0 @@
-require "testunit-test-util"
-class TestData < Test::Unit::TestCase
-  class Calc
-    def initialize
-    end
-    def plus(augend, addend)
-      augend + addend
-    end
-  end
-  class TestCalc < Test::Unit::TestCase
-    @@testing = false
-    class << self
-      def testing=(testing)
-        @@testing = testing
-      end
-    end
-    def valid?
-      @@testing
-    end
-    def setup
-      @calc = Calc.new
-    end
-    class TestDataSet < TestCalc
-      data("positive positive" => {:expected => 4, :augend => 3, :addend => 1},
-           "positive negative" => {:expected => -1, :augend => 1, :addend => -2})
-      def test_plus(data)
-        assert_equal(data[:expected],
-                     @calc.plus(data[:augend], data[:addend]))
-      end
-    end
-    class TestNData < TestCalc
-      data("positive positive", {:expected => 4, :augend => 3, :addend => 1})
-      data("positive negative", {:expected => -1, :augend => 1, :addend => -2})
-      def test_plus(data)
-        assert_equal(data[:expected],
-                     @calc.plus(data[:augend], data[:addend]))
-      end
-    end
-    class TestDynamicDataSet < TestCalc
-      DATA_PROC = lambda do
-        data_set = {}
-        data_set["positive positive"] = {
-          :expected => 3,
-          :augend => 1,
-          :addend => 2
-        }
-        data_set["positive negative"] = {
-          :expected => -1,
-          :augend => 1,
-          :addend => -2
-        }
-        data_set
-      end
-      data(&DATA_PROC)
-      def test_plus(data)
-        assert_equal(data[:expected],
-                     @calc.plus(data[:augend], data[:addend]))
-      end
-    end
-    class TestLoadDataSet < TestCalc
-      extend TestUnitTestUtil
-      load_data(fixture_file_path("plus.csv"))
-      def test_plus(data)
-        assert_equal(data["expected"],
-                     @calc.plus(data["augend"], data["addend"]))
-      end
-    end
-    class TestSuperclass < TestCalc
-      data("positive positive" => {:expected => 4, :augend => 3, :addend => 1},
-           "positive negative" => {:expected => -1, :augend => 1, :addend => -2})
-      def test_plus(data)
-        assert_equal(data[:expected],
-                     @calc.plus(data[:augend], data[:addend]))
-      end
-      class TestNormalTestInSubclass < self
-        def test_plus
-          assert_equal(2, @calc.plus(1, 1))
-        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
-    TestCalc.testing = true
-  end
-  def teardown
-    TestCalc.testing = false
-  end
-  def test_data_no_arguments_without_block
-    assert_raise(ArgumentError) do
-      self.class.data
-    end
-  end
-  data("data set",
-       {
-         :test_case => TestCalc::TestDataSet,
-         :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_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_sets => [TestCalc::TestDynamicDataSet::DATA_PROC],
-       })
-  data("load-data-set",
-       {
-         :test_case => TestCalc::TestLoadDataSet,
-         :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")
-    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,
-       "n-data"           => TestCalc::TestNData,
-       "dynamic-data-set" => TestCalc::TestDynamicDataSet,
-       "load-data-set"    => TestCalc::TestLoadDataSet)
-  def test_suite(test_case)
-    suite = test_case.suite
-    assert_equal(["test_plus[positive negative](#{test_case.name})",
-                  "test_plus[positive positive](#{test_case.name})"],
-                 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,
-       "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, " \
-                 "0 omissions, 0 notifications", result.to_s)
-  end
-  def test_run_normal_test_in_subclass
-    result = _run_test(TestCalc::TestSuperclass::TestNormalTestInSubclass)
-    assert_equal("1 tests, 1 assertions, 0 failures, 0 errors, 0 pendings, " \
-                 "0 omissions, 0 notifications", result.to_s)
-  end
-  data("data set"         => TestCalc::TestDataSet,
-       "n-data"           => TestCalc::TestNData,
-       "dynamic-data-set" => TestCalc::TestDynamicDataSet,
-       "load-data-set"    => TestCalc::TestLoadDataSet)
-  def test_equal(test_case)
-    suite = test_case.suite
-    positive_positive_test = suite.tests.find do |test|
-      test.data_label == "positive positive"
-    end
-    suite.tests.delete(positive_positive_test)
-    assert_equal(["test_plus[positive negative](#{test_case.name})"],
-                 suite.tests.collect {|test| test.name}.sort)
-  end
-  data("true"    => {:expected => true,    :target => "true"},
-       "false"   => {:expected => false,   :target => "false"},
-       "integer" => {:expected => 1,       :target => "1"},
-       "float"   => {:expected => 1.5,     :target => "1.5"},
-       "string"  => {:expected => "hello", :target => "hello"})
-  def test_normalize_value(data)
-    loader = Test::Unit::Data::ClassMethods::Loader.new(self)
-    assert_equal(data[:expected], loader.__send__(:normalize_value, data[:target]))
-  end
-  def _run_test(test_case)
-    result = Test::Unit::TestResult.new
-    test = test_case.suite
-    yield(test) if block_given?
-    test.run(result) {}
-    result
-  end
-  class TestLoadData < Test::Unit::TestCase
-    include TestUnitTestUtil
-    def test_invalid_csv_file_name
-      garbage = "X"
-      file_name = "data.csv#{garbage}"
-      assert_raise(ArgumentError, "unsupported file format: <#{file_name}>") do
-        self.class.load_data(file_name)
-      end
-    end
-    class TestFileFormat < self
-      def setup
-        self.class.current_attribute(:data).clear
-      end
-      class TestHeader < self
-        data("csv" => "header.csv",
-             "tsv" => "header.tsv")
-        def test_normal(file_name)
-          self.class.load_data(fixture_file_path(file_name))
-          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
-        data("csv" => "header-label.csv",
-             "tsv" => "header-label.tsv")
-        def test_label(file_name)
-          self.class.load_data(fixture_file_path(file_name))
-          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
-      data("csv" => "no-header.csv",
-           "tsv" => "no-header.tsv")
-      def test_without_header(file_name)
-        self.class.load_data(fixture_file_path(file_name))
-        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
-  end
-end