jordi-xml_struct 0.2.1 → 0.9.0

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

@@ -1,39 +0,0 @@
-require 'test/spec'
-
-require 'test/spec/dox'
-
-context "SpecDox" do
-  setup do
-    r = Test::Unit::UI::SpecDox::TestRunner.new(nil)
-    @unmangler = r.method(:unmangle)
-  end
-  
-  specify "can unmangle Test::Unit names correctly" do
-    @unmangler["test_foo_bar(TestFoo)"].should.equal ["Foo", "foo bar"]
-    @unmangler["test_foo_bar(FooTest)"].should.equal ["Foo", "foo bar"]
-    @unmangler["test_he_he(Foo)"].should.equal ["Foo", "he he"]
-    @unmangler["test_heh(Foo)"].should.equal ["Foo", "heh"]
-
-    @unmangler["test_heh(Test::Unit::TC_Assertions)"].
-      should.equal ["Test::Unit::TC_Assertions", "heh"]
-
-    @unmangler["test_heh(Foo::Bar::Test)"].
-      should.equal ["Foo::Bar::Test", "heh"]
-  end
-
-  specify "can unmangle Test::Spec names correctly" do
-    @unmangler["test_spec {context} 007 [whee]()"].
-      should.equal ["context", "whee"]
-    @unmangler["test_spec {a bit longish context} 069 [and more text]()"].
-      should.equal ["a bit longish context", "and more text"]
-    @unmangler["test_spec {special chars !\"/&%$} 2 [special chars !\"/&%$]()"].
-      should.equal ["special chars !\"/&%$", "special chars !\"/&%$"]
-    @unmangler["test_spec {[]} 666666 [{}]()"].
-      should.equal ["[]", "{}"]
-  end
-
-  specify "has sensible fallbacks" do
-    @unmangler["weird"].should.equal [nil, nil]
-  end
-end
-  

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

@@ -1,209 +0,0 @@
-# Adapted from flexmock (http://onestepback.org/software/flexmock).
-#
-# Copyright 2006 by Jim Weirich (jweirich@one.net).
-# All rights reserved.
-
-# Permission is granted for use, copying, modification, distribution,
-# and distribution of modified versions of this work as long as the
-# above copyright notice is included.
-
-
-require 'test/spec'
-
-begin
-  require 'flexmock'
-rescue LoadError
-  context "flexmock" do
-    specify "can not be found.  BAIL OUT!" do
-    end
-  end
-else
-
-context "flexmock" do
-  include FlexMock::TestCase
-    
-  setup do
-    @mock = FlexMock.new
-  end
-
-  specify "should receive and return" do
-    args = nil
-    @mock.should_receive(:hi).and_return { |a, b| args = [a,b] }
-    @mock.hi(1,2)
-    args.should.equal [1,2]
-  end
-
-  specify "should receive without a block" do
-    lambda {
-      @mock.should_receive(:blip)
-      @mock.blip
-    }.should.not.raise
-  end
-
-  specify "should receive and return with a block" do
-    called = false
-    @mock.should_receive(:blip).and_return { |block| block.call }
-    @mock.blip { called = true }
-    called.should.be true
-  end
-
-  specify "should have a return value" do
-    @mock.should_receive(:blip).and_return { 10 }
-    @mock.blip.should.equal 10
-  end
-
-  specify "should handle missing methods" do
-    ex = lambda {
-      @mock.not_defined
-    }.should.raise(NoMethodError)
-    ex.message.should.match(/not_defined/)
-  end
-
-  specify "should ignore missing methods" do
-    lambda {
-      @mock.should_ignore_missing
-      @mock.blip
-    }.should.not.raise
-  end
-
-  specify "should count correctly" do
-    @mock.should_receive(:blip).times(3)
-    @mock.blip
-    @mock.blip
-    @mock.blip
-    lambda { @mock.flexmock_verify }.should.not.raise Test::Unit::AssertionFailedError
-  end
-
-  specify "should raise on bad counts" do
-    @mock.should_receive(:blip).times(3)
-    @mock.blip
-    @mock.blip
-    lambda { @mock.flexmock_verify }.should.raise Test::Unit::AssertionFailedError
-  end
-
-  specify "should handle undetermined counts" do
-    lambda {
-      FlexMock.use('fs') { |m|
-        m.should_receive(:blip)
-        m.blip
-        m.blip
-        m.blip
-      }
-    }.should.not.raise Test::Unit::AssertionFailedError
-  end
-
-  specify "should handle zero counts" do
-    lambda {
-      FlexMock.use { |m|
-        m.should_receive(:blip).never
-        m.blip
-      }
-    }.should.raise Test::Unit::AssertionFailedError
-  end
-
-  specify "should have file IO with use" do
-    file = FlexMock.use do |m|
-      filedata = ["line 1", "line 2"]
-      m.should_receive(:gets).times(3).and_return { filedata.shift }
-      count_lines(m).should.equal 2
-    end
-  end
-
-  def count_lines(stream)
-    result = 0
-    while line = stream.gets
-      result += 1
-    end
-    result    
-  end
-
-  specify "should have use" do
-    lambda {
-      FlexMock.use do |m|
-	m.should_receive(:blip).times(2)
-	m.blip
-      end
-    }.should.raise Test::Unit::AssertionFailedError
-  end
-
-  specify "should handle failures during use" do
-    ex = lambda {
-      FlexMock.use do |m|
-	m.should_receive(:blip).times(2)
-	xyz
-      end
-    }.should.raise NameError
-    ex.message.should.match(/undefined local variable or method/)
-  end
-
-  specify "should deal with sequential values" do
-    values = [1,4,9,16]
-    @mock.should_receive(:get).and_return { values.shift }
-    @mock.get.should.equal 1
-    @mock.get.should.equal 4
-    @mock.get.should.equal 9
-    @mock.get.should.equal 16
-  end
-  
-  specify "respond_to? should return false for non handled methods" do
-    @mock.should.not.respond_to :blah
-  end
-
-  specify "respond_to? should return true for explicit methods" do
-    @mock.should_receive(:xyz)
-    @mock.should.respond_to :xyz
-  end
-  
-  specify "respond_to? should return true for missing_methods when should_ignore_missing" do
-    @mock.should_ignore_missing
-    @mock.should.respond_to :yada
-  end
-
-  specify "should raise error on unknown method proc" do
-    lambda {
-      @mock.method(:xyzzy)
-    }.should.raise NameError
-  end
-
-  specify "should return callable proc on method" do
-    got_it = false
-    @mock.should_receive(:xyzzy).and_return { got_it = true }
-    method_proc = @mock.method(:xyzzy)
-    method_proc.should.not.be.nil
-    method_proc.call
-    got_it.should.be true
-  end
-
-  specify "should return do nothing proc for missing methods" do
-    @mock.should_ignore_missing
-    method_proc = @mock.method(:plugh)
-    method_proc.should.not.be.nil
-    lambda { method_proc.call }.should.not.raise
-  end
-end
-
-
-class TemperatureSampler
-  def initialize(sensor)
-    @sensor = sensor
-  end
-
-  def average_temp
-    total = (0...3).collect { @sensor.read_temperature }.inject { |i, s| i + s }
-    total / 3.0
-  end
-end
-
-context "flexmock" do
-  include FlexMock::TestCase
-
-  specify "works with test/spec" do
-    sensor = flexmock("temp")
-    sensor.should_receive(:read_temperature).times(3).and_return(10, 12, 14)
-
-    sampler = TemperatureSampler.new(sensor)
-    sampler.average_temp.should.equal 12
-  end
-end
-
-end                             # if not rescue LoadError

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

@@ -1,104 +0,0 @@
-# Adapted from mocha (http://mocha.rubyforge.org/).
-#
-# Copyright (C) 2006 Revieworld Ltd.
-#
-# You may use, copy and redistribute this library under the same terms
-# as Ruby itself (see www.ruby-lang.org/en/LICENSE.txt) or under the
-# MIT license (see MIT-LICENSE file).
-
-require 'test/spec'
-
-begin
-  require 'mocha'
-rescue LoadError
-  context "mocha" do
-    specify "can not be found.  BAIL OUT!" do
-    end
-  end
-else
-
-context "mocha" do
-  specify "works with test/spec" do
-    object = mock()
-    object.expects(:expected_method).with(:p1, :p2).returns(:result)
-    object.expected_method(:p1, :p2).should.equal :result
-  end
-end
-
-class Enterprise
-  def initialize(dilithium)
-    @dilithium = dilithium
-  end
-
-  def go(warp_factor)
-    warp_factor.times { @dilithium.nuke(:anti_matter) }
-  end
-end
-
-context "mocha" do
-  specify "works with test/spec and Enterprise example" do
-    dilithium = mock()
-    dilithium.expects(:nuke).with(:anti_matter).at_least_once  # auto-verified at end of test
-    enterprise = Enterprise.new(dilithium)
-    enterprise.go(2)
-  end
-end
-
-class Order
-  attr_accessor :shipped_on
-
-  def total_cost
-    line_items.inject(0) { |total, line_item| total + line_item.price } + shipping_cost
-  end
-
-  def total_weight
-    line_items.inject(0) { |total, line_item| total + line_item.weight }
-  end
-
-  def shipping_cost
-    total_weight * 5 + 10
-  end
-
-  class << self
-
-    def find_all
-      # Database.connection.execute('select * from orders...
-    end
-
-    def number_shipped_since(date)
-      find_all.select { |order| order.shipped_on > date }.size
-    end
-
-    def unshipped_value
-      find_all.inject(0) { |total, order| order.shipped_on ? total : total + order.total_cost }
-    end
-
-  end
-
-end
-
-context "stubba" do
-  specify "works with test/spec and instance method stubbing" do
-    order = Order.new
-    order.stubs(:total_weight).returns(10)
-    order.shipping_cost.should.equal 60
-  end
-
-  specify "works with test/spec and class method stubbing" do
-    now = Time.now; week_in_secs = 7 * 24 * 60 * 60
-    order_1 = Order.new; order_1.shipped_on = now - 1 * week_in_secs
-    order_2 = Order.new; order_2.shipped_on = now - 3 * week_in_secs
-    Order.stubs(:find_all).returns([order_1, order_2])
-    Order.number_shipped_since(now - 2 * week_in_secs).should.equal 1
-  end
-
-  specify "works with test/spec and global instance method stubbing" do
-    Order.stubs(:find_all).returns([Order.new, Order.new, Order.new])
-    Order.any_instance.stubs(:shipped_on).returns(nil)
-    Order.any_instance.stubs(:total_cost).returns(10)
-    Order.unshipped_value.should.equal 30
-  end
-end
-
-end                             # if not rescue LoadError
-

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

@@ -1,26 +0,0 @@
-require 'test/spec'
-
-context "Empty context" do
-  # should.not.raise
-end
-
-context "Outer context" do
-  context "Inner context" do
-    specify "is nested" do
-    end
-    specify "has multiple empty specifications" do
-    end
-  end
-  context "Second Inner context" do
-    context "Inmost context" do
-      specify "works too!" do
-      end
-      specify "whoo!" do
-      end
-    end
-    specify "is indented properly" do
-    end
-    specify "still runs in order of definition" do
-    end
-  end
-end

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

@@ -1,80 +0,0 @@
-describe_shared "A new-style shared description" do
-  it "should work as well with shared descriptions" do
-    true.should.be true
-  end
-end
-
-describe "A new-style description" do
-  before do
-    @before = true
-    @a = 2
-  end
-
-  before(:each) do
-    @before_each = true
-  end
-
-  before(:all) do
-    $before_all = true
-  end
-
-  it "should run before-clauses" do
-    $before_all.should.be true
-    @before.should.be true
-    @before_each.should.be true
-  end
-
-  it "should behave like context/specify" do
-    (1+1).should.equal 2
-  end
-
-  xit "this is disabled" do
-    bla
-  end
-
-  after do
-    @a.should.equal 2
-    @a = 3
-  end
-
-  after(:each) do
-    @a.should.equal 3
-  end
-
-  after(:all) do
-    @b = 1
-  end
-
-  after(:all) do
-    @b.should.equal 1
-  end
-
-  $describescope = self
-  it "should raise on unimplement{ed,able} before/after" do
-    lambda {
-      $describescope.before(:foo) {}
-    }.should.raise(ArgumentError)
-    lambda {
-      $describescope.after(:foo) {}
-    }.should.raise(ArgumentError)
-
-    lambda {
-      context "foo" do
-      end
-    }.should.raise(Test::Spec::DefinitionError)
-  end
-
-  describe "when nested" do
-    it "should work" do
-    end
-  end
-
-  behaves_like "A new-style shared description"
-end
-
-describe "An empty description" do
-end
-
-xdescribe "An disabled description" do
-  it "should not be run"
-end