test-unit 3.1.5 → 3.6.1

data/test/test-attribute-matcher.rb

@@ -1,38 +0,0 @@
-require 'test/unit'
-require 'testunit-test-util'
-
-class TestAttributeMatcher < Test::Unit::TestCase
-  include TestUnitTestUtil
-
-  def setup
-    @test = {}
-    @matcher = Test::Unit::AttributeMatcher.new(@test)
-  end
-
-  def test_nonexistent
-    assert_false(@matcher.match?("nonexistent"))
-  end
-
-  def test_existent
-    @test[:existent] = true
-    assert_true(@matcher.match?("existent"))
-  end
-
-  def test_and
-    @test[:slow] = true
-    @test[:important] = true
-    assert_true(@matcher.match?("important and slow"))
-  end
-
-  def test_complex
-    @test[:tags] = [:slow, :web]
-    @test[:bug] = "2929"
-    assert_true(@matcher.match?("tags.include?(:web) or bug == '29'"))
-  end
-
-  def test_exception
-    assert_raise(NoMethodError) do
-      @matcher.match?("nonexistent > 100")
-    end
-  end
-end

data/test/test-attribute.rb

@@ -1,123 +0,0 @@
-class TestUnitAttribute < Test::Unit::TestCase
-  class TestStack < Test::Unit::TestCase
-    class << self
-      def suite
-        Test::Unit::TestSuite.new(name)
-      end
-    end
-
-    class Stack
-      def initialize
-        @data = []
-      end
-
-      def push(data)
-        @data.push(data)
-      end
-
-      def peek
-        @data[-2]
-      end
-
-      def empty?
-        @data.empty?
-      end
-
-      def size
-        @data.size + 11
-      end
-    end
-
-    def setup
-      @stack = Stack.new
-    end
-
-    attribute :category, :accessor
-    def test_peek
-      @stack.push(1)
-      @stack.push(2)
-      assert_equal(2, @stack.peek)
-    end
-
-    attribute :bug, 1234
-    def test_bug_1234
-      assert_equal(0, @stack.size)
-    end
-
-    def test_no_attributes
-      assert(@stack.empty?)
-      @stack.push(1)
-      assert(!@stack.empty?)
-      assert_equal(1, @stack.size)
-    end
-  end
-
-  def test_set_attributes
-    test_for_accessor_category = TestStack.new("test_peek")
-    assert_equal({"category" => :accessor},
-                 test_for_accessor_category.attributes)
-
-    test_for_bug_1234 = TestStack.new("test_bug_1234")
-    assert_equal({"bug" => 1234}, test_for_bug_1234.attributes)
-
-    test_no_attributes = TestStack.new("test_no_attributes")
-    assert_equal({}, test_no_attributes.attributes)
-  end
-
-  def test_callback
-    changed_attributes = []
-    observer = Proc.new do |test_case, key, old_value, value, method_name|
-      changed_attributes << [test_case, key, old_value, value, method_name]
-    end
-
-    test_case = Class.new(TestStack) do
-      register_attribute_observer(:bug, &observer)
-      attribute("bug", 9876, "test_bug_1234")
-      attribute(:description, "Test for peek", "test_peek")
-      attribute(:bug, 29, "test_peek")
-    end
-
-    assert_equal([
-                  [test_case, "bug", 1234, 9876, "test_bug_1234"],
-                  [test_case, "bug", nil, 29, "test_peek"],
-                 ],
-                 changed_attributes)
-  end
-
-  def test_attributes_with_prepended_module
-    omit("Module#prepend is needed") unless Module.respond_to?(:prepend, true)
-    test_case = Class.new(TestStack) do
-      prepend Module.new
-    end
-    assert_equal({
-                   "category" => :accessor,
-                 },
-                 test_case.attributes("test_peek"))
-  end
-
-  class TestDescription < self
-    def test_decoration_style
-      test_case = Class.new(TestStack) do
-        description "Test for push"
-        def test_push
-        end
-      end
-
-      test_push = test_case.new("test_push")
-      assert_equal({"description" => "Test for push"},
-                   test_push.attributes)
-    end
-
-    def test_explicit_test_name_style
-      test_case = Class.new(TestStack) do
-        def test_push
-        end
-        description "Test for push", :test_push
-      end
-
-      test_push = test_case.new("test_push")
-      assert_equal({"description" => "Test for push"},
-                   test_push.attributes)
-    end
-  end
-end

data/test/test-code-snippet.rb

@@ -1,37 +0,0 @@
-require "test-unit"
-require "testunit-test-util"
-
-class TestCodeSnippet < Test::Unit::TestCase
-  include TestUnitTestUtil
-
-  class TestJRuby < self
-    def test_error_inside_jruby
-      jruby_only_test
-
-      backtrace = backtrace_from_jruby
-      no_rb_entries = backtrace.find_all do |(file, _, _)|
-        File.extname(file) != ".rb"
-      end
-
-      fetcher = Test::Unit::CodeSnippetFetcher.new
-      snippets = no_rb_entries.collect do |(file, line, _)|
-        fetcher.fetch(file, line)
-      end
-      assert_equal([[]] * no_rb_entries.size,
-                   snippets)
-    end
-
-    private
-    def backtrace_from_jruby
-      begin
-        java.util.Vector.new(-1)
-      rescue Exception
-        $@.collect do |entry|
-          entry.split(/:/, 3)
-        end
-      else
-        flunk("failed to raise an exception from JRuby.")
-      end
-    end
-  end
-end

data/test/test-color-scheme.rb

@@ -1,82 +0,0 @@
-class TestUnitColorScheme < Test::Unit::TestCase
-  def test_register
-    inverted_scheme_spec = {
-      "success" => {:name => "red"},
-      "failure" => {:name => "green"},
-    }
-    Test::Unit::ColorScheme["inverted"] = inverted_scheme_spec
-    assert_equal({
-                   "success" => color("red"),
-                   "failure" => color("green"),
-                 },
-                 Test::Unit::ColorScheme["inverted"].to_hash)
-  end
-
-  def test_new_with_colors
-    scheme = Test::Unit::ColorScheme.new(:success => color("blue"),
-                                         "failure" => color("green",
-                                                            :underline => true))
-    assert_equal({
-                   "success" => color("blue"),
-                   "failure" => color("green", :underline => true),
-                 },
-                 scheme.to_hash)
-  end
-
-  def test_new_with_spec
-    scheme = Test::Unit::ColorScheme.new(:success => {
-                                           :name => "blue",
-                                           :bold => true
-                                         },
-                                         "failure" => {:name => "green"})
-    assert_equal({
-                   "success" => color("blue", :bold => true),
-                   "failure" => color("green"),
-                 },
-                 scheme.to_hash)
-  end
-
-  private
-  def color(name, options={})
-    Test::Unit::Color.new(name, options)
-  end
-
-  class TestFor8Colors < self
-    def setup
-      @original_term, ENV["TERM"] = ENV["TERM"], nil
-      @original_color_term, ENV["COLORTERM"] = ENV["COLORTERM"], nil
-      ENV["TERM"] = "xterm"
-    end
-
-    def teardown
-      ENV["TERM"] = @original_term
-      ENV["COLORTERM"] = @original_color_term
-    end
-
-    def test_default
-      expected_schema_keys = [
-        "pass",
-        "pass-marker",
-        "failure",
-        "failure-marker",
-        "pending",
-        "pending-marker",
-        "omission",
-        "omission-marker",
-        "notification",
-        "notification-marker",
-        "error",
-        "error-marker",
-        "case",
-        "suite",
-        "diff-inserted-tag",
-        "diff-deleted-tag",
-        "diff-difference-tag",
-        "diff-inserted",
-        "diff-deleted",
-      ]
-      assert_equal(expected_schema_keys.sort,
-                   Test::Unit::ColorScheme.default.to_hash.keys.sort)
-    end
-  end
-end

data/test/test-color.rb

@@ -1,47 +0,0 @@
-class TestUnitColor < Test::Unit::TestCase
-  def test_color_escape_sequence
-    assert_escape_sequence(["31"], color("red"))
-    assert_escape_sequence(["32", "1"], color("green", :bold => true))
-    assert_escape_sequence(["0"], color("reset"))
-    assert_escape_sequence(["45"], color("magenta", :background => true))
-  end
-
-  def test_mix_color_escape_sequence
-    assert_escape_sequence(["34", "1"],
-                           mix_color([color("blue"),
-                                      color("none", :bold => true)]))
-    assert_escape_sequence(["34", "1", "4"],
-                           mix_color([color("blue"),
-                                      color("none", :bold => true)]) +
-                           color("none", :underline => true))
-    assert_escape_sequence(["34", "1", "4"],
-                           color("blue") +
-                           color("none", :bold => true) +
-                           color("none", :underline => true))
-  end
-
-  def test_equal
-    red = color("red")
-    red_bold = color("red", :bold => true)
-
-    assert_operator(red, :==, red)
-    assert_not_equal(red, nil)
-    assert_equal(red, color("red"))
-    assert_not_equal(red, red_bold)
-  end
-
-  private
-  def color(name, options={})
-    Test::Unit::Color.new(name, options)
-  end
-
-  def mix_color(colors)
-    Test::Unit::MixColor.new(colors)
-  end
-
-  def assert_escape_sequence(expected, color)
-    assert_equal(expected, color.sequence)
-    assert_match(/\e\[(?:\d+;)*\d+m/, color.escape_sequence)
-    assert_equal(expected, color.escape_sequence[2..-2].split(";"))
-  end
-end

data/test/test-data.rb

@@ -1,281 +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 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_PROC = current_attribute(:data)[:value].first
-      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
-  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_set => [{
-                         "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("dynamic-data-set",
-       {
-         :test_case => TestCalc::TestDynamicDataSet,
-         :data_set => [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,
-                         },
-                       }],
-         })
-  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])
-  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
-
-  data("data set"         => TestCalc::TestDataSet,
-       "n-data"           => TestCalc::TestNData,
-       "dynamic-data-set" => TestCalc::TestDynamicDataSet,
-       "load-data-set"    => TestCalc::TestLoadDataSet)
-  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
-
-  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))
-          assert_equal([
-                         {
-                           "empty string" => {
-                             "expected" => true,
-                             "target"   => ""
-                           }
-                         },
-                         {
-                           "plain string" => {
-                             "expected" => false,
-                             "target"   => "hello"
-                           }
-                         }
-                       ],
-                       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))
-          assert_equal([
-                         {
-                           "upper case" => {
-                             "expected" => "HELLO",
-                             "label"    => "HELLO"
-                           }
-                         },
-                         {
-                           "lower case" => {
-                             "expected" => "Hello",
-                             "label"    => "hello"
-                           }
-                         }
-                       ],
-                       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))
-        assert_equal([
-                       {"empty string" => [true, ""]},
-                       {"plain string" => [false, "hello"]}
-                     ],
-                     self.class.current_attribute(:data)[:value])
-      end
-    end
-  end
-end