test-unit 3.4.1 → 3.4.5

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,79 +0,0 @@
-# coding: utf-8
-
-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
-
-  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-color-scheme.rb

@@ -1,123 +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
-
-  module CleanEnvironment
-    def setup
-      @original_term, ENV["TERM"] = ENV["TERM"], nil
-      @original_color_term, ENV["COLORTERM"] = ENV["COLORTERM"], nil
-      @original_vte_version, ENV["VTE_VERSION"] = ENV["VTE_VERSION"], nil
-      ENV["TERM"] = "xterm"
-    end
-
-    def teardown
-      ENV["TERM"] = @original_term
-      ENV["COLORTERM"] = @original_color_term
-      ENV["VTE_VERSION"] = @original_vte_version
-    end
-  end
-
-  class TestFor8Colors < self
-    include CleanEnvironment
-
-    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
-
-  class TestGuessAvailableColors < self
-    include CleanEnvironment
-    {
-      "rxvt"                 => 8,
-      "xterm-color"          => 8,
-      "alacritty"            => 256,
-      "iTerm.app"            => 256,
-      "screen-256color"      => 256,
-      "screenxterm-256color" => 256,
-      "tmux-256color"        => 256,
-      "vte-256color"         => 256,
-      "vscode-direct"        => 2**24,
-      "vte-direct"           => 2**24,
-      "xterm-direct"         => 2**24,
-    }.each do |term, colors|
-      data("%20s => %8d" % [term, colors], {term: term, colors: colors})
-    end
-    def test_term_env(data)
-      ENV["TERM"] = data[:term]
-      assert_equal(data[:colors],
-                   Test::Unit::ColorScheme.available_colors,
-                   "Incorrect available_colors for TERM=%s" % [data[:term]])
-    end
-  end
-
-  class TestDefaultScheme < self
-    include CleanEnvironment
-
-    def test_direct_color
-      ENV["TERM"] = "xterm-direct"
-      assert_equal(Test::Unit::ColorScheme.default_for_256_colors,
-                   Test::Unit::ColorScheme.default)
-    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,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