vtd_xml 0.0.3-java → 0.0.6-java

data/bundle/jruby/1.9/gems/shoulda-context-1.1.6/test/shoulda/context_test.rb

@@ -1,360 +0,0 @@
-require 'test_helper'
-
-class ContextTest < Test::Unit::TestCase # :nodoc:
-
-  def self.context_macro(&blk)
-    context "with a subcontext made by a macro" do
-      setup { @context_macro = :foo }
-
-      merge_block(&blk)
-    end
-  end
-
-  context "context with setup block" do
-    setup do
-      @blah = "blah"
-    end
-
-    should "run the setup block" do
-      assert_equal "blah", @blah
-    end
-
-    should "have name set right" do
-      assert_match(/^test: context with setup block/, self.to_s)
-    end
-
-    context "and a subcontext" do
-      setup do
-        @blah = "#{@blah} twice"
-      end
-
-      should "be named correctly" do
-        assert_match(/^test: context with setup block and a subcontext should be named correctly/, self.to_s)
-      end
-
-      should "run the setup blocks in order" do
-        assert_equal @blah, "blah twice"
-      end
-    end
-
-    context_macro do
-      should "have name set right" do
-        assert_match(/^test: context with setup block with a subcontext made by a macro should have name set right/, self.to_s)
-      end
-
-      should "run the setup block of that context macro" do
-        assert_equal :foo, @context_macro
-      end
-
-      should "run the setup block of the main context" do
-        assert_equal "blah", @blah
-      end
-    end
-
-  end
-
-  context "another context with setup block" do
-    setup do
-      @blah = "foo"
-    end
-
-    should "have @blah == 'foo'" do
-      assert_equal "foo", @blah
-    end
-
-    should "have name set right" do
-      assert_match(/^test: another context with setup block/, self.to_s)
-    end
-  end
-
-  context "context with method definition" do
-    setup do
-      def hello; "hi"; end
-    end
-
-    should "be able to read that method" do
-      assert_equal "hi", hello
-    end
-
-    should "have name set right" do
-      assert_match(/^test: context with method definition/, self.to_s)
-    end
-  end
-
-  context "another context" do
-    should "not define @blah" do
-      assert !instance_variable_defined?(:@blah)
-    end
-  end
-
-  context "context with multiple setups and/or teardowns" do
-
-    cleanup_count = 0
-
-    2.times do |i|
-      setup { cleanup_count += 1 }
-      teardown { cleanup_count -= 1 }
-    end
-
-    2.times do |i|
-      should "call all setups and all teardowns (check ##{i + 1})" do
-        assert_equal 2, cleanup_count
-      end
-    end
-
-    context "subcontexts" do
-
-      2.times do |i|
-        setup { cleanup_count += 1 }
-        teardown { cleanup_count -= 1 }
-      end
-
-      2.times do |i|
-        should "also call all setups and all teardowns in parent and subcontext (check ##{i + 1})" do
-          assert_equal 4, cleanup_count
-        end
-      end
-
-    end
-
-  end
-
-  should_eventually "pass, since it's unimplemented" do
-    flunk "what?"
-  end
-
-  should_eventually "not require a block when using should_eventually"
-  should "pass without a block, as that causes it to piggyback to should_eventually"
-
-  context "context for testing should piggybacking" do
-    should "call should_eventually as we are not passing a block"
-  end
-
-  context "context" do
-    context "with nested subcontexts" do
-      should_eventually "only print this statement once for a should_eventually"
-    end
-  end
-
-  class ::SomeModel; end
-
-  context "given a test named after a class" do
-    setup do
-      self.class.stubs(:name).returns("SomeModelTest")
-    end
-
-    should "determine the described type" do
-      assert_equal SomeModel, self.class.described_type
-    end
-
-    should "return a new instance of the described type as the subject if none exists" do
-      assert_kind_of SomeModel, subject
-    end
-
-    context "with an explicit subject block" do
-      setup { @expected = SomeModel.new }
-      subject { @expected }
-      should "return the result of the block as the subject" do
-        assert_equal @expected, subject
-      end
-
-      context "nested context block without a subject block" do
-        should "return the result of the parent context's subject block" do
-          assert_equal @expected, subject
-        end
-      end
-    end
-  end
-
-end
-
-class ::Some
-  class NestedModel; end
-end
-
-
-class Some::NestedModelTest < Test::Unit::TestCase
-  should "determine the described type for a nested model" do
-    assert_equal Some::NestedModel, self.class.described_type
-  end
-end
-
-class ShouldMatcherTest < Test::Unit::TestCase
-  class FakeMatcher
-    attr_reader :subject
-    attr_accessor :fail
-
-    def description
-      "do something"
-    end
-
-    def matches?(subject)
-      @subject = subject
-      !@fail
-    end
-
-    def failure_message_for_should
-      "failure message for should"
-    end
-
-    def failure_message_for_should_not
-      "failure message for should not"
-    end
-  end
-
-  def run_test_suite
-    @test_suite.run(@test_result) { |event, name| }
-  end
-
-  def setup
-    @matcher = FakeMatcher.new
-    @test_result = Test::Unit::TestResult.new
-    class << @test_result
-      def failure_messages
-        @failures.map { |failure| failure.message }
-      end
-    end
-  end
-
-  def create_test_suite(&definition)
-    test_class = Class.new(Test::Unit::TestCase, &definition)
-    test_class.suite
-  end
-
-  def assert_failed_with(message, test_result)
-    assert_equal 1, test_result.failure_count
-    assert_equal [message], test_result.failure_messages
-  end
-
-  def assert_passed(test_result)
-    assert_equal 0, test_result.failure_count
-  end
-
-  def assert_test_named(expected_name, test_suite)
-    name = test_suite.tests.map { |test| test.method_name }.first
-    assert name.include?(expected_name), "Expected #{name} to include #{expected_name}"
-  end
-
-  def self.should_use_positive_matcher
-    should "generate a test using the matcher's description" do
-      assert_test_named "should #{@matcher.description}", @test_suite
-    end
-
-    should "pass with a passing matcher" do
-      @matcher.fail = false
-      run_test_suite
-      assert_passed @test_result
-    end
-
-    should "fail with a failing matcher" do
-      @matcher.fail = true
-      run_test_suite
-      assert_failed_with "failure message for should", @test_result
-    end
-
-    should "provide the subject" do
-      @matcher.fail = false
-      run_test_suite
-      assert_equal 'a subject', @matcher.subject
-    end
-  end
-
-  def self.should_use_negative_matcher
-    should "generate a test using the matcher's description" do
-      assert_test_named "should not #{@matcher.description}", @test_suite
-    end
-
-    should "pass with a failing matcher" do
-      @matcher.fail = true
-      run_test_suite
-      assert_passed @test_result
-    end
-
-    should "fail with a passing matcher" do
-      @matcher.fail = false
-      run_test_suite
-      assert_failed_with "failure message for should not", @test_result
-    end
-
-    should "provide the subject" do
-      @matcher.fail = false
-      run_test_suite
-      assert_equal 'a subject', @matcher.subject
-    end
-  end
-
-  context "a should block with a matcher" do
-    setup do
-      matcher = @matcher
-      @test_suite = create_test_suite do
-        subject { 'a subject' }
-        should matcher
-      end
-    end
-
-    should_use_positive_matcher
-  end
-
-  context "a should block with a matcher within a context" do
-    setup do
-      matcher = @matcher
-      @test_suite = create_test_suite do
-        context "in context" do
-          subject { 'a subject' }
-          should matcher
-        end
-      end
-    end
-
-    should_use_positive_matcher
-  end
-
-  context "a should_not block with a matcher" do
-    setup do
-      matcher = @matcher
-      @test_suite = create_test_suite do
-        subject { 'a subject' }
-        should_not matcher
-      end
-    end
-
-    should_use_negative_matcher
-  end
-
-  context "a should_not block with a matcher within a context" do
-    setup do
-      matcher = @matcher
-      @test_suite = create_test_suite do
-        context "in context" do
-          subject { 'a subject' }
-          should_not matcher
-        end
-      end
-    end
-
-    should_use_negative_matcher
-  end
-end
-
-class Subject; end
-
-class SubjectTest < Test::Unit::TestCase
-
-  def setup
-    @expected = Subject.new
-  end
-
-  subject { @expected }
-
-  should "return a specified subject" do
-    assert_equal @expected, subject
-  end
-end
-
-class SubjectLazinessTest < Test::Unit::TestCase
-  subject { Subject.new }
-
-  should "only build the subject once" do
-    assert_equal subject, subject
-  end
-end

data/bundle/jruby/1.9/gems/shoulda-context-1.1.6/test/shoulda/convert_to_should_syntax_test.rb

@@ -1,63 +0,0 @@
-require 'test/unit'
-
-class ConvertToShouldSyntaxTest < Test::Unit::TestCase # :nodoc:
-
-  BEFORE_FIXTURE = <<-EOS
-    class DummyTest < Test::Unit::TestCase
-
-      should "Not change this_word_with_underscores" do
-      end
-
-      def test_should_be_working
-        assert true
-      end
-
-      def test_some_cool_stuff
-        assert true
-      end
-
-      def non_test_method
-      end
-
-    end
-  EOS
-
-  AFTER_FIXTURE = <<-EOS
-    class DummyTest < Test::Unit::TestCase
-
-      should "Not change this_word_with_underscores" do
-      end
-
-      should "be working" do
-        assert true
-      end
-
-      should "RENAME ME: test some cool stuff" do
-        assert true
-      end
-
-      def non_test_method
-      end
-
-    end
-  EOS
-
-  FIXTURE_PATH = "./convert_to_should_syntax_fixture.dat"
-
-  RUBY = ENV['RUBY'] || 'ruby'
-
-  def test_convert_to_should_syntax
-    File.open(FIXTURE_PATH, "w") {|f| f.write(BEFORE_FIXTURE)}
-    cmd = "#{RUBY} #{File.join(File.dirname(__FILE__), '../../bin/convert_to_should_syntax')} #{FIXTURE_PATH}"
-    output = `#{cmd}`
-    File.unlink($1) if output.match(/has been stored in '([^']+)/)
-    assert_match(/has been converted/, output)
-    result = IO.read(FIXTURE_PATH)
-    assert_equal result, AFTER_FIXTURE
-  end
-
-  def teardown
-    File.unlink(FIXTURE_PATH)
-  end
-
-end

data/bundle/jruby/1.9/gems/shoulda-context-1.1.6/test/shoulda/helpers_test.rb

@@ -1,190 +0,0 @@
-require 'test_helper'
-
-class HelpersTest < Test::Unit::TestCase # :nodoc:
-
-  context "an array of values" do
-    setup do
-      @a = ['abc', 'def', 3]
-    end
-
-    [/b/, 'abc', 3].each do |x|
-      should "contain #{x.inspect}" do
-        assert_raises(Test::Unit::AssertionFailedError) do
-          assert_does_not_contain @a, x
-        end
-        assert_contains @a, x
-      end
-    end
-
-    should "not contain 'wtf'" do
-      assert_raises(Test::Unit::AssertionFailedError) {assert_contains @a, 'wtf'}
-      assert_does_not_contain @a, 'wtf'
-    end
-
-    should "be the same as another array, ordered differently" do
-      assert_same_elements(@a, [3, "def", "abc"])
-      assert_raises(Test::Unit::AssertionFailedError) do
-        assert_same_elements(@a, [3, 3, "def", "abc"])
-      end
-      assert_same_elements([@a, "abc"].flatten, ["abc", 3, "def", "abc"])
-      assert_raises(Test::Unit::AssertionFailedError) do
-        assert_same_elements([@a, "abc"].flatten, [3, 3, "def", "abc"])
-      end
-    end
-
-    should "only count the number of occurrences once for each unique value" do
-      a1 = [@a, "abc"].flatten
-      a1.expects(:select).times(3).returns(["abc", "abc"], ["def"], [3])
-      assert_same_elements(a1, ["abc", 3, "def", "abc"])
-    end
-  end
-
-  context "a matching matcher" do
-    setup do
-      @matcher = stub('matcher', :matches?                       => true,
-                                 :failure_message_for_should     => 'bad failure message',
-                                 :failure_message_for_should_not => 'big time failure')
-    end
-
-    should "pass when given to assert_accepts with no message expectation" do
-      assert_accepts @matcher, 'target'
-    end
-
-    should "pass when given to assert_accepts with a matching message" do
-      assert_accepts @matcher, 'target', :message => /big time/
-    end
-
-    should "fail when given to assert_accepts with non-matching message" do
-      assert_raise Test::Unit::AssertionFailedError do
-        assert_accepts @matcher, 'target', :message => /small time/
-      end
-    end
-
-    context "when given to assert_rejects" do
-      context "and matcher has :does_not_match?" do
-        setup do
-          @error = nil
-          begin
-            @matcher.stubs(:matches?).returns(false)
-            @matcher.stubs(:does_not_match?).returns(true)
-            assert_rejects @matcher, 'target'
-          rescue Test::Unit::AssertionFailedError => @error
-          end
-        end
-
-        should "pass" do
-          assert_nil @error
-        end
-      end
-
-      context "and matcher does not have :does_not_match?" do
-        setup do
-          @error = nil
-          begin
-            assert_rejects @matcher, 'target'
-          rescue Test::Unit::AssertionFailedError => @error
-          end
-        end
-
-        should "fail" do
-          assert_not_nil @error
-        end
-
-        should "use the error message from the matcher" do
-          assert_equal 'big time failure', @error.message
-        end
-      end
-    end
-  end
-
-  context "a non-matching matcher" do
-    setup do
-      @matcher = stub('matcher', :matches?                       => false,
-                                 :failure_message_for_should     => 'big time failure',
-                                 :failure_message_for_should_not => 'bad failure message')
-    end
-
-    should "pass when given to assert_rejects with no message expectation" do
-      assert_rejects @matcher, 'target'
-    end
-
-    should "pass when given to assert_rejects with a matching message" do
-      assert_rejects @matcher, 'target', :message => /big time/
-    end
-
-    should "fail when given to assert_rejects with a non-matching message" do
-      assert_raise Test::Unit::AssertionFailedError do
-        assert_rejects @matcher, 'target', :message => /small time/
-      end
-    end
-
-    context "when given to assert_accepts" do
-      setup do
-        begin
-          assert_accepts @matcher, 'target'
-        rescue Test::Unit::AssertionFailedError => @error
-        end
-      end
-
-      should "fail" do
-        assert_not_nil @error
-      end
-
-      should "use the error message from the matcher" do
-        assert_equal 'big time failure', @error.message
-      end
-    end
-  end
-
-
-  context "a matcher using antiquated syntax" do
-    setup do
-      @matcher = stub('matcher', :matches?                 => false,
-                                 :failure_message          => 'big time failure',
-                                 :negative_failure_message => 'bad failure message')
-    end
-
-    should "pass when given to assert_rejects with no message expectation" do
-      assert_rejects @matcher, 'target'
-    end
-
-    should "pass when given to assert_rejects with a matching message" do
-      assert_rejects @matcher, 'target', :message => /big time/
-    end
-
-    should "fail when given to assert_rejects with a non-matching message" do
-      assert_raise Test::Unit::AssertionFailedError do
-        assert_rejects @matcher, 'target', :message => /small time/
-      end
-    end
-
-    context "when given to assert_accepts" do
-      setup do
-        begin
-          assert_accepts @matcher, 'target'
-        rescue Test::Unit::AssertionFailedError => @error
-        end
-      end
-
-      should "fail" do
-        assert_not_nil @error
-      end
-
-      should "use the error message from the matcher" do
-        assert_equal 'big time failure', @error.message
-      end
-    end
-  end
-
-  should "assign context to a support matching on assert_accepts" do
-    matcher = stub('matcher', :matches? => true)
-    matcher.expects(:in_context).with(self)
-    assert_accepts matcher, nil
-  end
-
-  should "assign context to a support matching on assert_rejects" do
-    matcher = stub('matcher', :matches? => false)
-    matcher.expects(:in_context).with(self)
-    assert_rejects matcher, nil
-  end
-end