module Test::Unit::Attribute::ClassMethods - test-unit: Ruby Standard Library Documentation

attribute(name, value, options={}, *method_names) click to toggle source

Set an attribute to test methods.

@overload attribute(name, value)

@example
  attribute :speed, :slow
  def test_my_slow_method
    self[:speed] # => :slow
  end

@param [Object] name the attribute name
@param [Object] value the attribute value
@return [void]

@overload attribute(name, value, *method_names)

@example
  def test_my_slow_method1
    self[:speed] # => :slow
  end

  attribute :speed, :slow, :test_my_slow_method1, :test_my_slow_method2

  def test_my_slow_method2
    self[:speed] # => :slow
  end

@param [Object] name the attribute name
@param [Object] value the attribute value
@param [Array<Symbol, String>] method_names the test method names set the attribute
@return [void]

@overload attribute(name, value, options)

@example
  attribute :speed, :slow, keep: true
  def test_my_slow_method1
    self[:speed] # => :slow
  end

  def test_my_slow_method2
    self[:speed] # => :slow
  end

@param [Object] name the attribute name
@param [Object] value the attribute value
@option options [Boolean] :keep whether or not to set attribute to following test methods
@return [void]

@overload attribute(name, value, options, *method_names)

@example
  def test_my_slow_method1
    self[:speed] # => :slow
  end

  # There are no valid options for now.
  attribute :speed, :slow, {}, :test_my_slow_method1

  def test_my_slow_method2
    self[:speed] # => nil
  end

@param [Object] name the attribute name
@param [Object] value the attribute value
@param [Hash] options ignored
@param [Array<Symbol, String>] method_names the test method names set the attribute
@return [void]

# File test-unit-3.6.2/lib/test/unit/attribute.rb, line 120
def attribute(name, value, options={}, *method_names)
  unless options.is_a?(Hash)
    method_names << options
    options = {}
  end
  if method_names.empty?
    current_attributes[name] = options.merge(:value => value)
  else
    method_names.each do |method_name|
      set_attributes(method_name, {name => value})
    end
  end
end

attribute_observers(attribute_name) click to toggle source

# File test-unit-3.6.2/lib/test/unit/attribute.rb, line 214
def attribute_observers(attribute_name)
  @@attribute_observers[attribute_name]
end

attributes(method_name) click to toggle source

# File test-unit-3.6.2/lib/test/unit/attribute.rb, line 165
def attributes(method_name)
  attributes = attributes_table[method_name]
  ancestors.each do |ancestor|
    next if ancestor == self
    if ancestor.is_a?(Class) and ancestor < Test::Unit::Attribute
      parent_attributes = ancestor.attributes(method_name)
      if attributes
        attributes = (parent_attributes || {}).merge(attributes)
      else
        attributes = parent_attributes
      end
      break
    end
  end
  attributes || StringifyKeyHash.new
end

attributes_table() click to toggle source

Calls superclass method

# File test-unit-3.6.2/lib/test/unit/attribute.rb, line 142
def attributes_table
  @attributes_table ||= StringifyKeyHash.new
  super.merge(@attributes_table)
end

current_attribute(name) click to toggle source

# File test-unit-3.6.2/lib/test/unit/attribute.rb, line 138
def current_attribute(name)
  current_attributes[name] || StringifyKeyHash.new
end

current_attributes() click to toggle source

# File test-unit-3.6.2/lib/test/unit/attribute.rb, line 134
def current_attributes
  @current_attributes ||= StringifyKeyHash.new
end

find_attribute(method_name, name, options={}) click to toggle source

# File test-unit-3.6.2/lib/test/unit/attribute.rb, line 182
def find_attribute(method_name, name, options={})
  recursive_p = options[:recursive]
  recursive_p = true if recursive_p.nil?

  @attributes_table ||= StringifyKeyHash.new
  if @attributes_table.key?(method_name)
    attributes = @attributes_table[method_name]
    if attributes.key?(name)
      return attributes[name]
    end
  end

  return nil unless recursive_p
  return nil if self == TestCase

  @cached_parent_test_case ||= ancestors.find do |ancestor|
    ancestor != self and
      ancestor.is_a?(Class) and
      ancestor < Test::Unit::Attribute
  end
  return nil if @cached_parent_test_case.nil?

  @cached_parent_test_case.find_attribute(method_name, name, options)
end

method_added(name) click to toggle source

Calls superclass method

# File test-unit-3.6.2/lib/test/unit/attribute.rb, line 38
def method_added(name)
  super
  return unless defined?(@current_attributes)

  attributes = {}
  kept_attributes = StringifyKeyHash.new
  @current_attributes.each do |attribute_name, attribute|
    attributes[attribute_name] = attribute[:value]
    if attribute[:keep]
      keep_hook = attribute[:keep_hook]
      attribute = keep_hook.call(attribute) if keep_hook
      kept_attributes[attribute_name] = attribute
    end
  end
  set_attributes(name, attributes)
  @current_attributes = kept_attributes
end

register_attribute_observer(attribute_name, observer=nil, &block) click to toggle source

# File test-unit-3.6.2/lib/test/unit/attribute.rb, line 208
def register_attribute_observer(attribute_name, observer=nil, &block)
  observer ||= Proc.new(&block)
  @@attribute_observers[attribute_name] ||= []
  @@attribute_observers[attribute_name] << observer
end

set_attributes(method_name, new_attributes) click to toggle source

# File test-unit-3.6.2/lib/test/unit/attribute.rb, line 147
def set_attributes(method_name, new_attributes)
  return if new_attributes.empty?
  @attributes_table ||= StringifyKeyHash.new
  @attributes_table[method_name] ||= StringifyKeyHash.new
  current_attributes = @attributes_table[method_name]
  new_attributes.each do |key, value|
    observers = attribute_observers(key) || []
    observers.each do |observer|
      observer.call(self,
                    StringifyKeyHash.stringify(key),
                    (attributes(method_name) || {})[key],
                    value,
                    method_name)
    end
    current_attributes[key] = value
  end
end