Test::Unit::Data::ClassMethods

Public Instance Methods

data(*arguments, &block) click to toggle source

This method provides Data-Driven-Test functionality.

Define test data in the test code.

@overload data(label, data, options={})

@param [String] label specify test case name.
@param data specify test data.
@param [Hash] options specify options.
@option options [Boolean] :keep whether or not to use
  this data in the following test methods

@example data(label, data)
  data("empty string", [true, ""])
  data("plain string", [false, "hello"])
  def test_empty?(data)
    expected, target = data
    assert_equal(expected, target.empty?)
  end

@overload data(variable, patterns, options={})

@param [Symbol] variable specify test pattern variable name.
@param [Array] patterns specify test patterns for the variable.
@param [Hash] options specify options.
@option options [Boolean] :keep whether or not to use
  this data in the following test methods
@option options [Object] :group the test pattern group.
  Test matrix is generated for each test pattern group separately.

@example data(variable, patterns)
  data(:x, [1, 2, 3])
  data(:y, ["a", "b"])
  def test_patterns(data)
    # 3 * 2 times executed
    # 3: the number of patterns of :x
    # 2: the number of patterns of :y
    p data
      # => {:x => 1, :y => "a"}
      # => {:x => 1, :y => "b"}
      # => {:x => 2, :y => "a"}
      # => {:x => 2, :y => "b"}
      # => {:x => 3, :y => "a"}
      # => {:x => 3, :y => "b"}
  end

Generates test matrix from variable and patterns pairs.

@overload data(data_set, options={})

@param [Hash] data_set specify test data as a Hash that
  key is test label and value is test data.
@param [Hash] options specify options.
@option options [Boolean] :keep whether or not to use
  this data in the following test methods

@example data(data_set)
  data("empty string" => [true, ""],
       "plain string" => [false, "hello"])
  def test_empty?(data)
    expected, target = data
    assert_equal(expected, target.empty?)
  end

@overload data(options={}, &block)

@param [Hash] options specify options.
@option options [Boolean] :keep whether or not to use
  this data in the following test methods
@yieldreturn [Hash<String, Object>] return test data set
  as a Hash that key is test label and value is test data.

@example data(&block)
  data do
    data_set = {}
    data_set["empty string"] = [true, ""]
    data_set["plain string"] = [false, "hello"]
    data_set
  end
  def test_empty?(data)
    expected, target = data
    assert_equal(expected, target.empty?)
  end

@overload data(options={}, &block)

@param [Hash] options specify options.
@option options [Boolean] :keep whether or not to use
  this data in the following test methods
@yieldreturn [Array<Symbol, Array>] return test data set
  as an Array of variable and patterns.

@example data(&block)
  data do
    patterns = 3.times.to_a
    [:x, patterns]
  end
  data do
    patterns = []
    character = "a"
    2.times.each do
      patterns << character
      character = character.succ
    end
    [:y, patterns]
  end
  def test_patterns(data)
    # 3 * 2 times executed
    # 3: the number of patterns of :x
    # 2: the number of patterns of :y
    p data
      # => {:x => 0, :y => "a"}
      # => {:x => 0, :y => "b"}
      # => {:x => 1, :y => "a"}
      # => {:x => 1, :y => "b"}
      # => {:x => 2, :y => "a"}
      # => {:x => 2, :y => "b"}
  end

Generates test matrix from variable and patterns pairs.

 
               # File test-unit-3.3.4/lib/test/unit/data.rb, line 129
def data(*arguments, &block)
  options = nil
  n_arguments = arguments.size
  case n_arguments
  when 0
    raise ArgumentError, "no block is given" unless block_given?
    data_set = block
  when 1
    if block_given?
      data_set = block
      options = arguments[1]
    else
      data_set = arguments[0]
    end
  when 2
    case arguments[0]
    when String
      data_set = {arguments[0] => arguments[1]}
    when Hash
      data_set = arguments[0]
      options = arguments[1]
    else
      variable = arguments[0]
      patterns = arguments[1]
      data_set = [variable, patterns]
    end
  when 3
    case arguments[0]
    when String
      data_set = {arguments[0] => arguments[1]}
      options = arguments[2]
    else
      variable = arguments[0]
      patterns = arguments[1]
      data_set = [variable, patterns]
      options = arguments[2]
    end
  else
    message = "wrong number arguments(#{n_arguments} for 0..3)"
    raise ArgumentError, message
  end
  options ||= {}
  data_sets = current_attribute(:data)[:value] || DataSets.new
  data_sets.add(data_set, options)
  if options[:keep]
    keep_hook = lambda do |attr|
      attr.merge(value: attr[:value].keep)
    end
    options = options.merge(keep_hook: keep_hook)
  end
  attribute(:data, data_sets, options)
end

load_data(file_name) click to toggle source

This method provides Data-Driven-Test functionality.

Load test data from the file. This is shorthand to load test data from file. If you want to load complex file, you can use {#data} with block.

@param [String] file_name full path to test data file.

File format is automatically detected from filename extension.

@raise [ArgumentError] if `file_name` is not supported file format. @see Loader#load

@example Load data from CSV file

load_data("/path/to/test-data.csv")
def test_empty?(data)
  assert_equal(data["expected"], data["target"].empty?)
end

 
               # File test-unit-3.3.4/lib/test/unit/data.rb, line 199
def load_data(file_name)
  loader = Loader.new(self)
  loader.load(file_name)
end