win32-api 1.10.0 → 1.10.1

data/vendor/bundle/ruby/3.0.0/gems/test-unit-3.4.1/test/test-attribute-matcher.rb

@@ -0,0 +1,38 @@
+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/vendor/bundle/ruby/3.0.0/gems/test-unit-3.4.1/test/test-attribute.rb

@@ -0,0 +1,123 @@
+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/vendor/bundle/ruby/3.0.0/gems/test-unit-3.4.1/test/test-code-snippet.rb

@@ -0,0 +1,79 @@
+# 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/vendor/bundle/ruby/3.0.0/gems/test-unit-3.4.1/test/test-color-scheme.rb

@@ -0,0 +1,123 @@
+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/vendor/bundle/ruby/3.0.0/gems/test-unit-3.4.1/test/test-color.rb

@@ -0,0 +1,47 @@
+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/vendor/bundle/ruby/3.0.0/gems/test-unit-3.4.1/test/test-data.rb

@@ -0,0 +1,419 @@
+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