jordi-xml_struct 0.1.2 → 0.1.3

data/test/vendor/test-spec/examples/stack_spec.rb

@@ -0,0 +1,119 @@
+# Copied with minor code changes (should_xxx -> should.xxx) from RSpec.
+
+require File.dirname(__FILE__) + '/../lib/test/spec'
+require File.dirname(__FILE__) + "/stack"
+
+context "A stack (in general)" do
+  setup do
+    @stack = Stack.new
+    ["a","b","c"].each { |x| @stack.push x }
+  end
+  
+  specify "should add to the top when sent 'push'" do
+    @stack.push "d"
+    @stack.peek.should.equal "d"
+  end
+  
+  specify "should return the top item when sent 'peek'" do
+    @stack.peek.should.equal "c"
+  end
+  
+  specify "should NOT remove the top item when sent 'peek'" do
+    @stack.peek.should.equal "c"
+    @stack.peek.should.equal "c"
+  end
+  
+  specify "should return the top item when sent 'pop'" do
+    @stack.pop.should.equal "c"
+  end
+  
+  specify "should remove the top item when sent 'pop'" do
+    @stack.pop.should.equal "c"
+    @stack.pop.should.equal "b"
+  end
+end
+
+context "An empty stack" do
+  setup do
+    @stack = Stack.new
+  end
+  
+  specify "should be empty" do
+    @stack.should.be.empty
+  end
+  
+  specify "should no longer be empty after 'push'" do
+    @stack.push "anything"
+    @stack.should.not.be.empty
+  end
+  
+  specify "should complain when sent 'peek'" do
+    lambda { @stack.peek }.should.raise StackUnderflowError
+  end
+  
+  specify "should complain when sent 'pop'" do
+    lambda { @stack.pop }.should.raise StackUnderflowError
+  end
+end
+
+context "An almost empty stack (with one item)" do
+  setup do
+    @stack = Stack.new
+    @stack.push 3
+  end
+  
+  specify "should not be empty" do
+    @stack.should.not.be.empty
+  end
+  
+  specify "should remain not empty after 'peek'" do
+    @stack.peek
+    @stack.should.not.be.empty
+  end
+  
+  specify "should become empty after 'pop'" do
+    @stack.pop
+    @stack.should.be.empty
+  end
+end
+
+context "An almost full stack (with one item less than capacity)" do
+  setup do
+    @stack = Stack.new
+    (1..9).each { |i| @stack.push i }
+  end
+  
+  specify "should not be full" do
+    @stack.should.not.be.full
+  end
+  
+  specify "should become full when sent 'push'" do
+    @stack.push Object.new
+    @stack.should.be.full
+  end
+end
+
+context "A full stack" do
+  setup do
+    @stack = Stack.new
+    (1..10).each { |i| @stack.push i }
+  end
+  
+  specify "should be full" do
+    @stack.should.be.full
+  end
+  
+  specify "should remain full after 'peek'" do
+    @stack.peek
+    @stack.should.be.full
+  end
+  
+  specify "should no longer be full after 'pop'" do
+    @stack.pop
+    @stack.should.not.be.full
+  end
+
+  specify "should complain on 'push'" do
+    lambda { @stack.push Object.new }.should.raise StackOverflowError
+  end
+end

data/test/vendor/test-spec/lib/test/spec/dox.rb

@@ -0,0 +1,148 @@
+require 'test/unit/ui/console/testrunner'
+
+module Test::Unit::UI           # :nodoc:
+  module SpecDox                # :nodoc:
+    class TestRunner < Test::Unit::UI::Console::TestRunner
+      protected
+      def setup_mediator
+        @mediator = create_mediator(@suite)
+      end
+
+      def add_fault(fault)
+        if fault.kind_of? Test::Spec::Disabled
+          @disabled += 1
+          output_no_nl " (disabled)"
+        elsif fault.kind_of? Test::Spec::Empty
+          @empty += 1
+          output_no_nl " (empty)"
+        else
+          @faults << fault
+          word = fault.class.name[/(.*::)?(.*)/, 2].upcase
+          output_no_nl " (#{word} - #{@faults.size})"
+        end
+      end
+      
+      def started(result)
+        @result = result
+        @context = nil
+        @contexts = []
+        @disabled = 0
+        @empty = 0
+        indent 0
+      end
+      
+      def finished(elapsed_time)
+        nl
+        output "Finished in #{elapsed_time} seconds."
+        @faults.each_with_index do |fault, index|
+          nl
+          output("%3d) %s" % [index + 1, fault.long_display])
+        end
+        nl
+        output_result
+      end
+
+      def output_result
+        if @disabled > 0
+          disabled = ", #{@disabled} disabled"
+        else
+          disabled = ""
+        end
+
+        if @empty > 0
+          empty = ", #{@empty} empty"
+        else
+          empty = ""
+        end
+
+        r = ("%d specifications#{disabled}#{empty} " +
+             "(%d requirements), %d failures") % [
+               @result.run_count, @result.assertion_count, @result.failure_count]
+        r << ", #{@result.error_count} errors"  if @result.error_count > 0
+        output r
+      end
+      
+      def test_started(name)
+        return  if special_test? name
+
+        contextname, @specname = unmangle name
+        return  if contextname.nil? || @specname.nil?
+
+        if @context != contextname
+          @context = contextname
+
+          @old_contexts = @contexts
+          @contexts = @context.split("\t")
+
+          common = 0
+          @contexts.zip(@old_contexts) { |a, b|
+            break  if a != b
+            common += 1
+          }
+
+          nl  if common == 0
+
+          @contexts[common..-1].each_with_index { |head, i|
+            indent common + i
+            output_heading head
+          }
+        end
+        
+        @assertions = @result.assertion_count
+        @prevdisabled = @disabled
+        output_item @specname
+      end
+      
+      def test_finished(name)
+        return  if special_test? name
+
+        # Did any assertion run?
+        if @assertions == @result.assertion_count && @prevdisabled == @disabled
+          add_fault Test::Spec::Empty.new(@specname)
+        end
+
+        # Don't let empty contexts clutter up the output.
+        nl  unless name =~ /\Adefault_test\(/
+      end
+
+      def output_no_nl(something, level=NORMAL)
+        @io.write(something) if (output?(level))
+        @io.flush
+      end
+
+      def output_item(item)
+        output_no_nl "#{@prefix}- #{item}"
+      end
+
+      def output_heading(heading)
+        output "#{@prefix}#{heading}"
+      end
+
+      def unmangle(name)
+        if name =~ /\Atest_spec \{(.*?)\} \d+ \[(.*)\]/
+          contextname = $1
+          specname = $2
+        elsif name =~ /test_(.*?)\((.*)\)$/
+          specname = $1
+          contextname = $2
+
+          contextname.gsub!(/^Test\B|\BTest$/, '')
+          specname.gsub!(/_/, ' ')
+        else
+          contextname = specname = nil
+        end
+
+        [contextname, specname]
+      end
+
+      def indent(depth)
+        @indent = depth
+        @prefix = "  " * depth
+      end
+
+      def special_test?(name)
+        name =~ /\Atest_spec \{.*?\} (-1 BEFORE|AFTER) ALL\(/
+      end
+    end
+  end
+end

data/test/vendor/test-spec/lib/test/spec/rdox.rb

@@ -0,0 +1,25 @@
+require 'test/spec/dox'
+
+module Test::Unit::UI           # :nodoc:
+  module RDox                   # :nodoc:
+    class TestRunner < Test::Unit::UI::SpecDox::TestRunner
+      def output_heading(heading)
+        output "#{@headprefix} #{heading}"
+      end
+      
+      def output_item(item)
+        output_no_nl "* #{item}"
+      end
+      
+      def finished(elapsed_time)
+        nl
+        output_result
+      end
+
+      def indent(depth)
+        @prefix = ""
+        @headprefix = "==" + "=" * depth
+      end
+    end
+  end
+end

data/test/vendor/test-spec/lib/test/spec/should-output.rb

@@ -0,0 +1,49 @@
+# Code adapted from rs, written by Eero Saynatkari.
+require 'fileutils'
+require 'tmpdir'
+
+class Test::Spec::Should
+  # Captures output from the IO given as
+  # the second argument (STDIN by default)
+  # and matches it against a String or 
+  # Regexp given as the first argument.
+  def output(expected, to = STDOUT)
+    # Store the old stream
+    old_to = to.dup
+
+    # Obtain a filehandle to replace (works with Readline)
+    to.reopen File.open(File.join(Dir.tmpdir, "should_output_#{$$}"), "w+")
+    
+    # Execute
+    @object.call
+
+    # Restore
+    out = to.dup
+    to.reopen old_to
+
+    # Grab the data
+    out.rewind
+    output = out.read
+
+    # Match up
+    case expected
+      when Regexp
+        output.should.match expected
+      else
+        output.should.equal expected
+    end                               # case expected
+
+  # Clean up
+  ensure
+    out.close
+
+    # STDIO redirection will break else
+    begin
+      to.seek 0, IO::SEEK_END
+    rescue Errno::ESPIPE
+    rescue Errno::EPIPE
+    end
+
+    FileUtils.rm_f out.path
+  end                                 # output
+end                                   # Test::Spec::Should

data/test/vendor/test-spec/lib/test/spec/version.rb

@@ -0,0 +1,8 @@
+# To load it externally, without activating Test::Unit.
+
+module Test
+  module Spec
+    VERSION = "0.9"
+  end
+end
+

data/test/vendor/test-spec/lib/test/spec.rb

@@ -0,0 +1,660 @@
+#
+# test/spec -- a BDD interface for Test::Unit
+#
+# Copyright (C) 2006, 2007, 2008  Christian Neukirchen <mailto:chneukirchen@gmail.com>
+#
+# This work is licensed under the same terms as Ruby itself.
+#
+
+require 'test/unit'
+
+class Test::Unit::AutoRunner    # :nodoc:
+  RUNNERS[:specdox] = lambda {
+    require 'test/spec/dox'
+    Test::Unit::UI::SpecDox::TestRunner
+  }
+
+  RUNNERS[:rdox] = lambda {
+    require 'test/spec/rdox'
+    Test::Unit::UI::RDox::TestRunner
+  }
+end
+
+module Test                     # :nodoc:
+end
+
+module Test::Spec
+  require 'test/spec/version'
+
+  CONTEXTS = {}                 # :nodoc:
+  SHARED_CONTEXTS = Hash.new { |h,k| h[k] = [] } # :nodoc:
+
+  class DefinitionError < StandardError
+  end
+
+  class Should
+    include Test::Unit::Assertions
+
+    def self.deprecated_alias(to, from)    # :nodoc:
+      define_method(to) { |*args|
+        warn "Test::Spec::Should##{to} is deprecated and will be removed in future versions."
+        __send__ from, *args
+      }
+    end
+
+    def initialize(object, message=nil)
+      @object = object
+      @message = message
+    end
+
+    $TEST_SPEC_TESTCASE = nil
+    def add_assertion
+      $TEST_SPEC_TESTCASE && $TEST_SPEC_TESTCASE.__send__(:add_assertion)
+    end
+
+
+    def an
+      self
+    end
+
+    def a
+      self
+    end
+
+    def not(*args)
+      case args.size
+      when 0
+        ShouldNot.new(@object, @message)
+      when 1
+        ShouldNot.new(@object, @message).pass(args.first)
+      else
+        raise ArgumentError, "#not takes zero or one argument(s)."
+      end
+    end
+
+    def messaging(message)
+      @message = message.to_s
+      self
+    end
+    alias blaming messaging
+
+    def satisfy(&block)
+      assert_block(@message || "satisfy block failed.") {
+        yield @object
+      }
+    end
+
+    def equal(value)
+      assert_equal value, @object, @message
+    end
+    alias == equal
+
+    def close(value, delta)
+      assert_in_delta value, @object, delta, @message
+    end
+    deprecated_alias :be_close, :close
+
+    def be(*value)
+      case value.size
+      when 0
+        self
+      when 1
+        if CustomShould === value.first 
+          pass value.first
+        else
+          assert_same value.first, @object, @message
+        end
+      else
+        raise ArgumentError, "should.be needs zero or one argument"
+      end
+    end
+
+    def match(value)
+      assert_match value, @object, @message
+    end
+    alias =~ match
+
+    def instance_of(klass)
+      assert_instance_of klass, @object, @message
+    end
+    deprecated_alias :be_an_instance_of, :instance_of
+
+    def kind_of(klass)
+      assert_kind_of klass, @object, @message
+    end
+    deprecated_alias :be_a_kind_of, :kind_of
+
+    def respond_to(method)
+      assert_respond_to @object, method, @message
+    end
+
+    def _raise(*args, &block)
+      args = [RuntimeError]  if args.empty?
+      block ||= @object
+      assert_raise(*(args + [@message]), &block)
+    end
+
+    def throw(*args)
+      assert_throws(*(args + [@message]), &@object)
+    end
+
+    def nil
+      assert_nil @object, @message
+    end
+    deprecated_alias :be_nil, :nil
+
+
+    def include(value)
+      msg = build_message(@message, "<?> expected to include ?, but it didn't.",
+                          @object, value)
+      assert_block(msg) { @object.include?(value) }
+    end
+
+    def >(value)
+      assert_operator @object, :>, value, @message
+    end
+
+    def >=(value)
+      assert_operator @object, :>=, value, @message
+    end
+
+    def <(value)
+      assert_operator @object, :<, value, @message
+    end
+
+    def <=(value)
+      assert_operator @object, :<=, value, @message
+    end
+
+    def ===(value)
+      assert_operator @object, :===, value, @message
+    end
+
+    def pass(custom)
+      _wrap_assertion {
+        assert_nothing_raised(Test::Unit::AssertionFailedError,
+                              @message || custom.failure_message) {
+          assert custom.matches?(@object), @message || custom.failure_message
+        }
+      }
+    end
+
+    def method_missing(name, *args, &block)
+      # This will make raise call Kernel.raise, and self.raise call _raise.
+      return _raise(*args, &block)  if name == :raise
+      
+      if @object.respond_to?("#{name}?")
+        assert @object.__send__("#{name}?", *args),
+          "#{name}? expected to be true. #{@message}"
+      else
+        if @object.respond_to?(name)
+          assert @object.__send__(name, *args),
+          "#{name} expected to be true. #{@message}"
+        else
+          super
+        end
+      end
+    end
+  end
+
+  class ShouldNot
+    include Test::Unit::Assertions
+
+    def initialize(object, message=nil)
+      @object = object
+      @message = message
+    end
+
+    def add_assertion
+      $TEST_SPEC_TESTCASE && $TEST_SPEC_TESTCASE.__send__(:add_assertion)
+    end
+
+
+    def satisfy(&block)
+      assert_block(@message || "not.satisfy block succeded.") {
+        not yield @object
+      }
+    end
+    
+    def equal(value)
+      assert_not_equal value, @object, @message
+    end
+    alias == equal
+
+    def be(*value)
+      case value.size
+      when 0
+        self
+      when 1
+        if CustomShould === value.first 
+          pass value.first
+        else
+          assert_not_same value.first, @object, @message
+        end
+      else
+        Kernel.raise ArgumentError, "should.be needs zero or one argument"
+      end
+    end
+
+    def match(value)
+      # Icky Regexp check
+      assert_no_match value, @object, @message
+    end
+    alias =~ match
+
+    def _raise(*args, &block)
+      block ||= @object
+      assert_nothing_raised(*(args+[@message]), &block)
+    end
+
+    def throw
+      assert_nothing_thrown(@message, &@object)
+    end
+
+    def nil
+      assert_not_nil @object, @message
+    end
+
+    def be_nil
+      warn "Test::Spec::ShouldNot#be_nil is deprecated and will be removed in future versions."
+      self.nil
+    end
+
+    def not(*args)
+      case args.size
+      when 0
+        Should.new(@object, @message)
+      when 1
+        Should.new(@object, @message).pass(args.first)
+      else
+        raise ArgumentError, "#not takes zero or one argument(s)."
+      end
+    end
+
+    def pass(custom)
+      _wrap_assertion {
+        begin
+          assert !custom.matches?(@object), @message || custom.failure_message
+        end
+      }
+    end
+
+    def method_missing(name, *args, &block)
+      # This will make raise call Kernel.raise, and self.raise call _raise.
+      return _raise(*args, &block)  if name == :raise
+
+      if @object.respond_to?("#{name}?")
+        assert_block("#{name}? expected to be false. #{@message}") {
+          not @object.__send__("#{name}?", *args)
+        }
+      else
+        if @object.respond_to?(name)
+          assert_block("#{name} expected to be false. #{@message}") {
+            not @object.__send__("#{name}", *args)
+          }
+        else
+          super
+        end
+      end
+    end
+    
+  end
+
+  class CustomShould
+    attr_accessor :object
+    
+    def initialize(obj)
+      self.object = obj
+    end
+
+    def failure_message
+      "#{self.class.name} failed"
+    end
+
+    def matches?(*args, &block)
+      assumptions(*args, &block)
+      true
+    end
+
+    def assumptions(*args, &block)
+      raise NotImplementedError, "you need to supply a #{self.class}#matches? method"
+    end
+  end
+end
+
+class Test::Spec::TestCase
+  attr_reader :testcase
+  attr_reader :name
+  attr_reader :position
+
+  module InstanceMethods
+    def setup                 # :nodoc:
+      $TEST_SPEC_TESTCASE = self
+      super
+      call_methods_including_parents(:setups)
+    end
+    
+    def teardown              # :nodoc:
+      super
+      call_methods_including_parents(:teardowns, :reverse)
+    end
+    
+    def before_all
+      call_methods_including_parents(:before_all)
+    end
+
+    def after_all
+      call_methods_including_parents(:after_all, :reverse)
+    end
+
+    def initialize(name)
+      super name
+
+      # Don't let the default_test clutter up the results and don't
+      # flunk if no tests given, either.
+      throw :invalid_test  if name.to_s == "default_test"
+    end
+
+    def position
+      self.class.position
+    end
+
+    def context(*args)
+      raise Test::Spec::DefinitionError,
+        "context definition is not allowed inside a specify-block"
+    end
+
+    alias :describe :context
+
+    private
+
+    def call_methods_including_parents(method, reverse=false, klass=self.class)
+      return  unless klass
+
+      if reverse
+        klass.send(method).each { |s| instance_eval(&s) }
+        call_methods_including_parents(method, reverse, klass.parent)
+      else
+        call_methods_including_parents(method, reverse, klass.parent)
+        klass.send(method).each { |s| instance_eval(&s) }
+      end
+    end
+  end
+
+  module ClassMethods
+    attr_accessor :count
+    attr_accessor :name
+    attr_accessor :position
+    attr_accessor :parent
+
+    attr_accessor :setups
+    attr_accessor :teardowns
+
+    attr_accessor :before_all
+    attr_accessor :after_all
+
+    # old-style (RSpec <1.0):
+
+    def context(name, superclass=Test::Unit::TestCase, klass=Test::Spec::TestCase, &block)
+      (Test::Spec::CONTEXTS[self.name + "\t" + name] ||= klass.new(name, self, superclass)).add(&block)
+    end
+
+    def xcontext(name, superclass=Test::Unit::TestCase, &block)
+      context(name, superclass, Test::Spec::DisabledTestCase, &block)
+    end
+    
+    def specify(specname, &block)
+      raise ArgumentError, "specify needs a block"  if block.nil?
+      
+      self.count += 1                 # Let them run in order of definition
+      
+      define_method("test_spec {%s} %03d [%s]" % [name, count, specname], &block)
+    end
+
+    def xspecify(specname, &block)
+      specify specname do
+        @_result.add_disabled(specname)
+      end
+    end
+    
+    def setup(&block)
+      setups << block
+    end
+    
+    def teardown(&block)
+      teardowns << block
+    end
+
+    def shared_context(name, &block)
+      Test::Spec::SHARED_CONTEXTS[self.name + "\t" + name] << block
+    end
+
+    def behaves_like(shared_context)
+      if Test::Spec::SHARED_CONTEXTS.include?(shared_context)
+        Test::Spec::SHARED_CONTEXTS[shared_context].each { |block|
+          instance_eval(&block)
+        }
+      elsif Test::Spec::SHARED_CONTEXTS.include?(self.name + "\t" + shared_context)
+        Test::Spec::SHARED_CONTEXTS[self.name + "\t" + shared_context].each { |block|
+          instance_eval(&block)
+        }
+      else
+        raise NameError, "Shared context #{shared_context} not found."
+      end
+    end
+    alias :it_should_behave_like :behaves_like
+
+    # new-style (RSpec 1.0+):
+
+    alias :describe :context
+    alias :describe_shared :shared_context
+    alias :it :specify
+    alias :xit :xspecify
+
+    def before(kind=:each, &block)
+      case kind
+      when :each
+        setup(&block)
+      when :all
+        before_all << block
+      else
+        raise ArgumentError, "invalid argument: before(#{kind.inspect})"
+      end
+    end
+
+    def after(kind=:each, &block)
+      case kind
+      when :each
+        teardown(&block)
+      when :all
+        after_all << block
+      else
+        raise ArgumentError, "invalid argument: after(#{kind.inspect})"
+      end
+    end
+
+
+    def init(name, position, parent)
+      self.position = position
+      self.parent = parent
+      
+      if parent
+        self.name = parent.name + "\t" + name
+      else
+        self.name = name
+      end
+
+      self.count = 0
+      self.setups = []
+      self.teardowns = []
+
+      self.before_all = []
+      self.after_all = []
+    end
+  end
+
+  @@POSITION = 0
+
+  def initialize(name, parent=nil, superclass=Test::Unit::TestCase)
+    @testcase = Class.new(superclass) {
+      include InstanceMethods
+      extend ClassMethods
+    }
+
+    @@POSITION = @@POSITION + 1
+    @testcase.init(name, @@POSITION, parent)
+  end
+
+  def add(&block)
+    raise ArgumentError, "context needs a block"  if block.nil?
+
+    @testcase.class_eval(&block)
+    self
+  end
+end
+
+(Test::Spec::DisabledTestCase = Test::Spec::TestCase.dup).class_eval do
+  alias :test_case_initialize :initialize
+
+  def initialize(*args, &block)
+    test_case_initialize(*args, &block)
+    @testcase.instance_eval do
+      alias :test_case_specify :specify
+
+      def specify(specname, &block)
+        test_case_specify(specname) { @_result.add_disabled(specname) }
+      end
+      alias :it :specify
+    end
+  end
+end
+
+class Test::Spec::Disabled < Test::Unit::Failure    # :nodoc:
+  def initialize(name)
+    @name = name
+  end
+
+  def single_character_display
+    "D"
+  end
+
+  def short_display
+    @name
+  end
+
+  def long_display
+    @name + " is disabled"
+  end
+end
+
+class Test::Spec::Empty < Test::Unit::Failure    # :nodoc:
+  def initialize(name)
+    @name = name
+  end
+
+  def single_character_display
+    ""
+  end
+
+  def short_display
+    @name
+  end
+
+  def long_display
+    @name + " is empty"
+  end
+end
+
+
+# Monkey-patch test/unit to run tests in an optionally specified order.
+module Test::Unit               # :nodoc:
+  class TestSuite               # :nodoc:
+    undef run
+    def run(result, &progress_block)
+      sort!
+      yield(STARTED, name)
+      @tests.first.before_all  if @tests.first.respond_to? :before_all
+      @tests.each do |test|
+        test.run(result, &progress_block)
+      end
+      @tests.last.after_all  if @tests.last.respond_to? :after_all
+      yield(FINISHED, name)
+    end
+    
+    def sort!
+      @tests = @tests.sort_by { |test|
+        test.respond_to?(:position) ? test.position : 0
+      }
+    end
+    
+    def position
+      @tests.first.respond_to?(:position) ? @tests.first.position : 0
+    end
+  end
+
+  class TestResult              # :nodoc:
+    # Records a disabled test.
+    def add_disabled(name)
+      notify_listeners(FAULT, Test::Spec::Disabled.new(name))
+      notify_listeners(CHANGED, self)
+    end  
+  end
+end
+
+
+# Hide Test::Spec interna in backtraces.
+module Test::Unit::Util::BacktraceFilter # :nodoc:
+  TESTSPEC_PREFIX = __FILE__.gsub(/spec\.rb\Z/, '')
+
+  # Vendor plugins like to be loaded several times, don't recurse
+  # infinitely then.
+  unless method_defined? "testspec_filter_backtrace"
+    alias :testspec_filter_backtrace :filter_backtrace
+  end
+
+  def filter_backtrace(backtrace, prefix=nil)
+    if prefix.nil?
+      testspec_filter_backtrace(testspec_filter_backtrace(backtrace),
+                                TESTSPEC_PREFIX)
+    else
+      testspec_filter_backtrace(backtrace, prefix)
+    end
+  end
+end
+
+
+#-- Global helpers
+
+class Object
+  def should(*args)
+    case args.size
+    when 0
+      Test::Spec::Should.new(self)
+    when 1
+      Test::Spec::Should.new(self).pass(args.first)
+    else
+      raise ArgumentError, "Object#should takes zero or one argument(s)."
+    end
+  end
+end
+
+module Kernel
+  def context(name, superclass=Test::Unit::TestCase, klass=Test::Spec::TestCase, &block)     # :doc:
+    (Test::Spec::CONTEXTS[name] ||= klass.new(name, nil, superclass)).add(&block)
+  end
+
+  def xcontext(name, superclass=Test::Unit::TestCase, &block)     # :doc:
+    context(name, superclass, Test::Spec::DisabledTestCase, &block)
+  end
+
+  def shared_context(name, &block)
+    Test::Spec::SHARED_CONTEXTS[name] << block
+  end
+
+  alias :describe :context
+  alias :xdescribe :xcontext
+  alias :describe_shared :shared_context
+
+  private :context, :xcontext, :shared_context
+  private :describe, :xdescribe, :describe_shared
+end