jordi-xml_struct 0.1.2 → 0.1.3

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

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

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

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

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

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