fluent-plugin-detect-memb-exceptions 0.0.1

data/vendor/bundle/ruby/2.0.0/gems/test-unit-3.2.3/test/test-notification.rb

@@ -0,0 +1,33 @@
+require 'test/unit'
+require 'testunit-test-util'
+
+class TestUnitNotification < Test::Unit::TestCase
+  include TestUnitTestUtil
+
+  class TestCase < Test::Unit::TestCase
+    class << self
+      def suite
+        Test::Unit::TestSuite.new(name)
+      end
+    end
+
+    def test_notify
+      notify("1st notify")
+      notify("2nd notify. Reach here.")
+    end
+  end
+
+  def test_notify
+    result = _run_test("test_notify")
+    assert_equal("1 tests, 0 assertions, 0 failures, 0 errors, 0 pendings, " \
+                 "0 omissions, 2 notifications",
+                 result.to_s)
+    assert_fault_messages(["1st notify", "2nd notify. Reach here."],
+                          result.notifications)
+  end
+
+  private
+  def _run_test(name)
+    super(TestCase, name)
+  end
+end

data/vendor/bundle/ruby/2.0.0/gems/test-unit-3.2.3/test/test-omission.rb

@@ -0,0 +1,81 @@
+require 'test/unit'
+require 'testunit-test-util'
+
+class TestUnitOmission < Test::Unit::TestCase
+  include TestUnitTestUtil
+
+  class TestCase < Test::Unit::TestCase
+    class << self
+      def suite
+        Test::Unit::TestSuite.new(name)
+      end
+    end
+
+    def test_omit
+      omit("1st omit")
+      omit("2nd omit. Should not be reached here.")
+      assert(true, "Should not be reached here too.")
+    end
+
+    def test_omit_with_condition
+      omit_if(false, "Never omit.")
+      omit_unless(true, "Never omit too.")
+      omit_if(true, "Should omit.")
+      omit("The last omit. Should not be reached here.")
+    end
+
+    def test_omit_with_block
+      omit("Omit block") do
+        flunk("Should not be reached here.")
+      end
+      assert(true, "Should be reached here.")
+    end
+
+    def test_omit_with_block_and_condition
+      omit_if(false, "Never omit.") do
+        assert(true, "Should be reached here.")
+      end
+      omit_if(true, "Should omit.") do
+        flunk("Never reached here.")
+      end
+      assert(true, "Should be reached here too.")
+    end
+  end
+
+  def test_omit
+    result = _run_test("test_omit")
+    assert_equal("1 tests, 0 assertions, 0 failures, 0 errors, 0 pendings, " \
+                 "1 omissions, 0 notifications",
+                 result.to_s)
+    assert_fault_messages(["1st omit"], result.omissions)
+  end
+
+  def test_omit_with_condition
+    result = _run_test("test_omit_with_condition")
+    assert_equal("1 tests, 0 assertions, 0 failures, 0 errors, 0 pendings, " \
+                 "1 omissions, 0 notifications",
+                 result.to_s)
+    assert_fault_messages(["Should omit."], result.omissions)
+  end
+
+  def test_omit_with_block
+    result = _run_test("test_omit_with_block")
+    assert_equal("1 tests, 1 assertions, 0 failures, 0 errors, 0 pendings, " \
+                 "1 omissions, 0 notifications",
+                 result.to_s)
+    assert_fault_messages(["Omit block"], result.omissions)
+  end
+
+  def test_omit_with_condition_and_block
+    result = _run_test("test_omit_with_block_and_condition")
+    assert_equal("1 tests, 2 assertions, 0 failures, 0 errors, 0 pendings, " \
+                 "1 omissions, 0 notifications",
+                 result.to_s)
+    assert_fault_messages(["Should omit."], result.omissions)
+  end
+
+  private
+  def _run_test(name)
+    super(TestCase, name)
+  end
+end

data/vendor/bundle/ruby/2.0.0/gems/test-unit-3.2.3/test/test-pending.rb

@@ -0,0 +1,70 @@
+require 'test/unit'
+require 'testunit-test-util'
+
+class TestUnitPending < Test::Unit::TestCase
+  include TestUnitTestUtil
+
+  class TestCase < Test::Unit::TestCase
+    class << self
+      def suite
+        Test::Unit::TestSuite.new(name)
+      end
+    end
+
+    def test_pend
+      pend("1st pend")
+      pend("2nd pend. Should not be reached here.")
+      assert(true, "Should not be reached here too.")
+    end
+
+    def test_pend_with_failure_in_block
+      pend("Wait a minute") do
+        raise "Not implemented yet"
+      end
+      assert(true, "Reached here.")
+    end
+
+    def test_pend_with_no_failure_in_block
+      pend("Wait a minute") do
+        "Nothing raised"
+      end
+      assert(true, "Not reached here.")
+    end
+  end
+
+  def test_pend
+    test = nil
+    result = _run_test("test_pend") {|t| test = t}
+    assert_equal("1 tests, 0 assertions, 0 failures, 0 errors, 1 pendings, " \
+                 "0 omissions, 0 notifications",
+                 result.to_s)
+    assert_fault_messages(["1st pend"], result.pendings)
+    assert_true(test.interrupted?)
+  end
+
+  def test_pend_with_failure_in_block
+    test = nil
+    result = _run_test("test_pend_with_failure_in_block") {|t| test = t}
+    assert_equal("1 tests, 1 assertions, 0 failures, 0 errors, 1 pendings, " \
+                 "0 omissions, 0 notifications",
+                 result.to_s)
+    assert_fault_messages(["Wait a minute"], result.pendings)
+    assert_false(test.interrupted?)
+  end
+
+  def test_pend_with_no_failure_in_block
+    test = nil
+    result = _run_test("test_pend_with_no_failure_in_block") {|t| test = t}
+    assert_equal("1 tests, 1 assertions, 1 failures, 0 errors, 0 pendings, " \
+                 "0 omissions, 0 notifications",
+                 result.to_s)
+    assert_fault_messages(["Pending block should not be passed: Wait a minute."],
+                          result.failures)
+    assert_true(test.interrupted?)
+  end
+
+  private
+  def _run_test(name, &block)
+    super(TestCase, name, &block)
+  end
+end

data/vendor/bundle/ruby/2.0.0/gems/test-unit-3.2.3/test/test-priority.rb

@@ -0,0 +1,173 @@
+require 'test/unit'
+
+class TestUnitPriority < Test::Unit::TestCase
+  class TestCase < Test::Unit::TestCase
+    class << self
+      def suite
+        Test::Unit::TestSuite.new(name)
+      end
+    end
+
+    priority :must
+    def test_must
+      assert(true)
+    end
+
+    def test_must_inherited
+      assert(true)
+    end
+
+    priority :important
+    def test_important
+      assert(true)
+    end
+
+    def test_important_inherited
+      assert(true)
+    end
+
+    priority :high
+    def test_high
+      assert(true)
+    end
+
+    def test_high_inherited
+      assert(true)
+    end
+
+    priority :normal
+    def test_normal
+      assert(true)
+    end
+
+    def test_normal_inherited
+      assert(true)
+    end
+
+    priority :low
+    def test_low
+      assert(true)
+    end
+
+    def test_low_inherited
+      assert(true)
+    end
+
+    priority :never
+    def test_never
+      assert(true)
+    end
+
+    def test_never_inherited
+      assert(true)
+    end
+  end
+
+  def test_priority_must
+    assert_priority("must", 1.0, 0.0001)
+  end
+
+  def test_priority_important
+    assert_priority("important", 0.9, 0.09)
+  end
+
+  def test_priority_high
+    assert_priority("high", 0.70, 0.1)
+  end
+
+  def test_priority_normal
+    assert_priority("normal", 0.5, 0.1)
+  end
+
+  def test_priority_low
+    assert_priority("low", 0.25, 0.1)
+  end
+
+  def test_priority_never
+    assert_priority("never", 0.0, 0.0001)
+  end
+
+  def assert_priority(priority, expected, delta)
+    assert_need_to_run("test_#{priority}", expected, delta)
+    assert_need_to_run("test_#{priority}_inherited", expected, delta)
+  end
+
+  def assert_need_to_run(test_name, expected, delta)
+    test = TestCase.new(test_name)
+    n = 1000
+    n_need_to_run = 0
+    n.times do |i|
+      n_need_to_run += 1 if Test::Unit::Priority::Checker.need_to_run?(test)
+    end
+    assert_in_delta(expected, n_need_to_run.to_f / n, delta)
+  end
+
+  class TestClassName < self
+    def test_colon
+      assert_escaped_name("Test__Priority", "Test::Priority")
+    end
+
+    def test_space
+      assert_escaped_name("test_priority", "test priority")
+    end
+
+    def test_slash
+      assert_escaped_name("test_priority", "test/priority")
+    end
+
+    def test_back_slash
+      assert_escaped_name("test_priority", "test\/priority")
+    end
+
+    def assert_escaped_name(expected, class_name)
+      checker = Checker.new(nil)
+      escaped_class_name = checker.send(:escape_class_name, class_name)
+      assert_equal(expected, escaped_class_name)
+    end
+  end
+
+  class TestFileName < self
+    class SpecialNameTestCase < Test::Unit::TestCase
+      class << self
+        def suite
+          Test::Unit::TestSuite.new(name)
+        end
+      end
+
+      def test_question?
+      end
+
+      def test_exclamation!
+      end
+
+      def test_equal=
+      end
+
+      test "have space" do
+      end
+    end
+
+    def test_question
+      assert_escaped_name("test_question.predicate", "test_question?")
+    end
+
+    def test_exclamation
+      assert_escaped_name("test_exclamation.destructive", "test_exclamation!")
+    end
+
+    def test_equal
+      assert_escaped_name("test_equal.equal", "test_equal=")
+    end
+
+    def test_colon_and_space
+      assert_escaped_name("test_colon__have_space", "test: have space")
+    end
+
+    def assert_escaped_name(expected, test_method_name)
+      checker = Checker.new(SpecialNameTestCase.new(test_method_name))
+      passed_file = checker.send(:passed_file)
+      method_name_component = File.basename(File.dirname(passed_file))
+      assert_equal(expected, method_name_component)
+    end
+  end
+end

data/vendor/bundle/ruby/2.0.0/gems/test-unit-3.2.3/test/test-test-case.rb

@@ -0,0 +1,1204 @@
+# Author:: Nathaniel Talbott.
+# Copyright:: Copyright (c) 2008-2014  Kouhei Sutou <kou@clear-code.com>
+# Copyright:: Copyright (c) 2011  Haruka Yoshihara <yoshihara@clear-code.com>
+# Copyright:: Copyright (c) 2000-2002  Nathaniel Talbott
+# License:: Ruby license.
+
+require 'test/unit'
+
+module Test
+  module Unit
+    class TestTestCase < TestCase
+      self.test_order = :random
+      def test_creation
+        test_case = Class.new(TestCase) do
+          def test_with_arguments(arg1, arg2)
+          end
+        end
+
+        test = test_case.new(:test_with_arguments)
+        check("Should have caught an invalid test when there are arguments",
+              !test.valid?)
+
+        test = test_case.new(:non_existent_test)
+        check("Should have caught an invalid test when the method does not exist",
+              !test.valid?)
+      end
+
+      def setup
+        @tc_failure_error = Class.new(TestCase) do
+          def test_failure
+            assert_block("failure") do
+              false
+            end
+          end
+          def test_error
+            1 / 0
+          end
+          def test_nested_failure
+            nested
+          end
+          def nested
+            assert_block("nested") do
+              false
+            end
+          end
+          def return_passed?
+            return passed?
+          end
+        end
+
+        def @tc_failure_error.name
+          "TC_FailureError"
+        end
+      end
+
+      def jruby_backtrace_entry?(entry)
+        entry.start_with?("org/jruby/")
+      end
+
+      def rubinius_backtrace_entry?(entry)
+        entry.start_with?("kernel/")
+      end
+
+      def normalize_location(location)
+        filtered_location = location.reject do |entry|
+          jruby_backtrace_entry?(entry) or
+            rubinius_backtrace_entry?(entry)
+        end
+        filtered_location.collect do |entry|
+          entry.sub(/:\d+:/, ":0:")
+        end
+      end
+
+      def test_add_failed_assertion
+        test_case = @tc_failure_error.new(:test_failure)
+        assert do
+          test_case.passed?
+        end
+
+        result = TestResult.new
+        faults = []
+        result.add_listener(TestResult::FAULT) do |fault|
+          faults << fault
+        end
+        progress = []
+        test_case.run(result) do |*arguments|
+          progress << arguments
+        end
+        fault_details = faults.collect do |fault|
+          {
+            :class     => fault.class,
+            :message   => fault.message,
+            :test_name => fault.test_name,
+            :location  => normalize_location(fault.location),
+          }
+        end
+        assert_equal([
+                       {
+                         :class     => Failure,
+                         :message   => "failure",
+                         :test_name => "test_failure(TC_FailureError)",
+                         :location  => [
+                           "#{__FILE__}:0:in `test_failure'",
+                           "#{__FILE__}:0:in `#{__method__}'",
+                         ],
+                       },
+                     ],
+                     fault_details)
+
+        assert do
+          not test_case.passed?
+        end
+        assert_equal([
+                       [TestCase::STARTED,         test_case.name],
+                       [TestCase::STARTED_OBJECT,  test_case],
+                       [TestCase::FINISHED,        test_case.name],
+                       [TestCase::FINISHED_OBJECT, test_case],
+                     ],
+                     progress)
+      end
+
+      def test_add_failure_nested
+        test_case = @tc_failure_error.new(:test_nested_failure)
+        assert do
+          test_case.passed?
+        end
+
+        result = TestResult.new
+        faults = []
+        result.add_listener(TestResult::FAULT) do |fault|
+          faults << fault
+        end
+        test_case.run(result) do
+        end
+        fault_details = faults.collect do |fault|
+          {
+            :class     => fault.class,
+            :message   => fault.message,
+            :test_name => fault.test_name,
+            :location  => normalize_location(fault.location),
+          }
+        end
+        assert_equal([
+                       {
+                         :class     => Failure,
+                         :message   => "nested",
+                         :test_name => "test_nested_failure(TC_FailureError)",
+                         :location  => [
+                           "#{__FILE__}:0:in `nested'",
+                           "#{__FILE__}:0:in `test_nested_failure'",
+                           "#{__FILE__}:0:in `#{__method__}'",
+                         ],
+                       },
+                     ],
+                     fault_details)
+
+        assert do
+          not test_case.passed?
+        end
+      end
+
+      def jruby?
+        defined?(JRUBY_VERSION)
+      end
+
+      def rubinius?
+        false # TODO
+      end
+
+      def cruby?
+        (not jruby?) and (not rubinius?)
+      end
+
+      def test_add_error
+        test_case = @tc_failure_error.new(:test_error)
+        assert do
+          test_case.passed?
+        end
+
+        result = TestResult.new
+        faults = []
+        result.add_listener(TestResult::FAULT) do |fault|
+          faults << fault
+        end
+        test_case.run(result) do
+        end
+        fault_details = faults.collect do |fault|
+          {
+            :class     => fault.class,
+            :message   => fault.message,
+            :test_name => fault.test_name,
+            :location  => normalize_location(fault.location),
+          }
+        end
+        location = []
+        location << "#{__FILE__}:0:in `/'" if cruby?
+        location << "#{__FILE__}:0:in `test_error'"
+        location << "#{__FILE__}:0:in `#{__method__}'"
+        assert_equal([
+                       {
+                         :class     => Error,
+                         :message   => "ZeroDivisionError: divided by 0",
+                         :test_name => "test_error(TC_FailureError)",
+                         :location  => location,
+                       },
+                     ],
+                     fault_details)
+
+        assert do
+          not test_case.passed?
+        end
+      end
+
+      def test_no_tests
+        suite = TestCase.suite
+        check("Should have a test suite", suite.instance_of?(TestSuite))
+        check("Should have one test", suite.size == 1)
+        check("Should have the default test", suite.tests.first.name == "default_test(Test::Unit::TestCase)")
+
+        result = TestResult.new
+        suite.run(result) {}
+        check("Should have had one test run", result.run_count == 1)
+        check("Should have had one test failure", result.failure_count == 1)
+        check("Should have had no errors", result.error_count == 0)
+      end
+
+      def test_suite
+        tc = Class.new(TestCase) do
+          def test_succeed
+            assert_block {true}
+          end
+          def test_fail
+            assert_block {false}
+          end
+          def test_error
+            1/0
+          end
+          def dont_run
+            assert_block {true}
+          end
+          def test_dont_run(argument)
+            assert_block {true}
+          end
+          def test
+            assert_block {true}
+          end
+        end
+
+        suite = tc.suite
+        check("Should have a test suite", suite.instance_of?(TestSuite))
+        check("Should have three tests", suite.size == 3)
+
+        result = TestResult.new
+        suite.run(result) {}
+        check("Should have had three test runs", result.run_count == 3)
+        check("Should have had one test failure", result.failure_count == 1)
+        check("Should have had one test error", result.error_count == 1)
+      end
+
+      def test_setup_teardown
+        tc = Class.new(TestCase) do
+          attr_reader(:setup_called, :teardown_called)
+          def initialize(test)
+            super(test)
+            @setup_called = false
+            @teardown_called = false
+          end
+          def setup
+            @setup_called = true
+          end
+          def teardown
+            @teardown_called = true
+          end
+          def test_succeed
+            assert_block {true}
+          end
+          def test_fail
+            assert_block {false}
+          end
+          def test_error
+            raise "Error!"
+          end
+        end
+        result = TestResult.new
+
+        test = tc.new(:test_succeed)
+        test.run(result) {}
+        check("Should have called setup the correct number of times", test.setup_called)
+        check("Should have called teardown the correct number of times", test.teardown_called)
+
+        test = tc.new(:test_fail)
+        test.run(result) {}
+        check("Should have called setup the correct number of times", test.setup_called)
+        check("Should have called teardown the correct number of times", test.teardown_called)
+
+        test = tc.new(:test_error)
+        test.run(result) {}
+        check("Should have called setup the correct number of times", test.setup_called)
+        check("Should have called teardown the correct number of times", test.teardown_called)
+
+        check("Should have had two test runs", result.run_count == 3)
+        check("Should have had a test failure", result.failure_count == 1)
+        check("Should have had a test error", result.error_count == 1)
+      end
+
+      def test_assertion_failed_not_called
+        tc = Class.new(TestCase) do
+          def test_thing
+            raise AssertionFailedError.new
+          end
+        end
+
+        suite = tc.suite
+        check("Should have one test", suite.size == 1)
+        result = TestResult.new
+        suite.run(result) {}
+        check("Should have had one test run", result.run_count == 1)
+        check("Should have had one assertion failure", result.failure_count == 1)
+        check("Should not have any assertion errors but had #{result.error_count}", result.error_count == 0)
+      end
+
+      def test_equality
+        tc1 = Class.new(TestCase) do
+          def test_1
+          end
+          def test_2
+          end
+        end
+
+        tc2 = Class.new(TestCase) do
+          def test_1
+          end
+        end
+
+        test1 = tc1.new('test_1')
+        test2 = tc1.new('test_1')
+        check("Should be equal", test1 == test2)
+        check("Should be equal", test2 == test1)
+
+        test1 = tc1.new('test_2')
+        check("Should not be equal", test1 != test2)
+        check("Should not be equal", test2 != test1)
+
+        test2 = tc1.new('test_2')
+        check("Should be equal", test1 == test2)
+        check("Should be equal", test2 == test1)
+
+        test1 = tc1.new('test_1')
+        test2 = tc2.new('test_1')
+        check("Should not be equal", test1 != test2)
+        check("Should not be equal", test2 != test1)
+
+        check("Should not be equal", test1 != Object.new)
+        check("Should not be equal", Object.new != test1)
+      end
+
+      def test_re_raise_exception
+        test_case = Class.new(TestCase) do
+          def test_raise_interrupt
+            raise Interrupt, "from test"
+          end
+        end
+
+        test = test_case.new("test_raise_interrupt")
+        begin
+          test.run(TestResult.new) {}
+          check("Should not be reached", false)
+        rescue Exception
+          check("Interrupt exception should be re-raised", $!.class == Interrupt)
+        end
+      end
+
+      def test_timeout_error
+        test_case = Class.new(TestCase) do
+          def test_raise_timeout_error
+            require "timeout"
+            raise Timeout::Error
+          end
+        end
+
+        test_suite = test_case.suite
+        result = TestResult.new
+        begin
+          test_suite.run(result) {}
+          check("Timeout::Error should be handled as error",
+                result.error_count == 1)
+        rescue Exception
+          check("Timeout::Error should not be passed through: #{$!}", false)
+        end
+      end
+
+      def test_interrupted
+        test_case = Class.new(TestCase) do
+          def test_fail
+            flunk
+          end
+
+          def test_nothing
+          end
+        end
+
+        failed_test = test_case.new(:test_fail)
+        failed_test.run(TestResult.new) {}
+        check("Should be interrupted", failed_test.interrupted?)
+
+        success_test = test_case.new(:test_nothing)
+        success_test.run(TestResult.new) {}
+        check("Should not be interrupted", !success_test.interrupted?)
+      end
+
+      def test_inherited_test_should_be_ignored
+        test_case = Class.new(TestCase) do
+          def test_nothing
+          end
+        end
+
+        sub_test_case = Class.new(test_case) do
+          def test_fail
+            flunk
+          end
+        end
+
+        test = test_case.new("test_nothing")
+        assert_predicate(test, :valid?)
+
+        test = sub_test_case.new("test_fail")
+        assert_predicate(test, :valid?)
+
+        test = sub_test_case.new("test_nothing")
+        assert_not_predicate(test, :valid?)
+      end
+
+      def test_mixin_test_should_not_be_ignored
+        test_module = Module.new do
+          def test_nothing
+          end
+        end
+
+        test_case = Class.new(Test::Unit::TestCase) do
+          include test_module
+
+          def test_fail
+            flunk
+          end
+        end
+
+        assert_nothing_thrown do
+          test_case.new("test_nothing")
+        end
+
+        assert_nothing_thrown do
+          test_case.new("test_fail")
+        end
+      end
+
+      def test_defined_order
+        test_case = Class.new(Test::Unit::TestCase) do
+          def test_z
+          end
+
+          def test_1
+          end
+
+          def test_a
+          end
+        end
+
+        test_case.test_order = :defined
+        assert_equal(["test_z", "test_1", "test_a"],
+                     test_case.suite.tests.collect {|test| test.method_name})
+      end
+
+      def test_declarative_style
+        test_case = Class.new(Test::Unit::TestCase) do
+          test "declarative style test definition" do
+          end
+
+          test "include parenthesis" do
+          end
+
+          test "1 + 2 = 3" do
+          end
+        end
+
+        test_case.test_order = :defined
+
+        assert_equal(["test: declarative style test definition",
+                      "test: include parenthesis",
+                      "test: 1 + 2 = 3"],
+                     test_case.suite.tests.collect {|test| test.method_name})
+
+        assert_equal(["declarative style test definition",
+                      "include parenthesis",
+                      "1 + 2 = 3"],
+                     test_case.suite.tests.collect {|test| test.description})
+      end
+
+      def test_test_mark
+        test_case = Class.new(Test::Unit::TestCase) do
+          test
+          def my_test_method
+          end
+        end
+
+        test_case.test_order = :defined
+
+        assert_equal(["my_test_method"],
+                     test_case.suite.tests.collect {|test| test.method_name})
+      end
+
+      def test_redefine_method
+        test_case = Class.new(Test::Unit::TestCase) do
+          self.test_order = :alphabetic
+
+          def test_name
+          end
+          alias_method :test_name2, :test_name
+
+          def test_name
+          end
+        end
+
+        suite = test_case.suite
+        assert_equal(["test_name", "test_name2"],
+                     suite.tests.collect {|test| test.method_name})
+        result = TestResult.new
+        suite.run(result) {}
+        assert_equal("2 tests, 0 assertions, 0 failures, " +
+                     "0 errors, 0 pendings, 0 omissions, 1 notifications",
+                     result.summary)
+      end
+
+      def test_data_driven_test
+        test_case = Class.new(TestCase) do
+          def test_with_data(data)
+          end
+        end
+
+        test = test_case.new("test_with_data")
+        assert_not_predicate(test, :valid?)
+        test.assign_test_data("label1", :test_data1)
+        assert_predicate(test, :valid?)
+      end
+
+      def test_data_driven_test_without_parameter
+        test_case = Class.new(TestCase) do
+          data("label" => "value")
+          def test_without_parameter
+          end
+        end
+
+        suite = test_case.suite
+        assert_equal(["test_without_parameter"],
+                     suite.tests.collect {|test| test.method_name})
+        result = TestResult.new
+        suite.run(result) {}
+        assert_equal("1 tests, 0 assertions, 0 failures, " +
+                     "0 errors, 0 pendings, 0 omissions, 1 notifications",
+                     result.summary)
+      end
+
+      private
+      def check(message, passed)
+        add_assertion
+        raise AssertionFailedError.new(message) unless passed
+      end
+
+      class TestTestDefined < self
+        class TestNoQuery < self
+          def test_no_test
+            test_case = Class.new(TestCase) do
+            end
+            assert_false(test_case.test_defined?({}))
+          end
+
+          def test_have_def_style_test
+            test_case = Class.new(TestCase) do
+              def test_nothing
+              end
+            end
+            assert_true(test_case.test_defined?({}))
+          end
+
+          def test_have_method_style_test
+            test_case = Class.new(TestCase) do
+              test "nothing" do
+              end
+            end
+            assert_true(test_case.test_defined?({}))
+          end
+        end
+
+        class TestPath < self
+          class TestDefStyle < self
+            def test_base_name
+              test_case = Class.new(TestCase) do
+                def test_nothing
+                end
+              end
+              base_name = File.basename(__FILE__)
+              assert_true(test_case.test_defined?(:path => base_name))
+            end
+
+            def test_absolute_path
+              test_case = Class.new(TestCase) do
+                def test_nothing
+                end
+              end
+              assert_true(test_case.test_defined?(:path => __FILE__))
+            end
+
+            def test_not_match
+              test_case = Class.new(TestCase) do
+                def test_nothing
+                end
+              end
+              assert_false(test_case.test_defined?(:path => "nonexistent.rb"))
+            end
+          end
+
+          class TestMethodStyle < self
+            def test_base_name
+              test_case = Class.new(TestCase) do
+                test "nothing" do
+                end
+              end
+              base_name = File.basename(__FILE__)
+              assert_true(test_case.test_defined?(:path => base_name))
+            end
+
+            def test_absolute_path
+              test_case = Class.new(TestCase) do
+                test "nothing" do
+                end
+              end
+              assert_true(test_case.test_defined?(:path => __FILE__))
+            end
+
+            def test_not_match
+              test_case = Class.new(TestCase) do
+                test "nothing" do
+                end
+              end
+              assert_false(test_case.test_defined?(:path => "nonexistent.rb"))
+            end
+          end
+        end
+
+        class TestLine < self
+          class TestDefStyle < self
+            def test_before
+              line_before = nil
+              test_case = Class.new(TestCase) do
+                line_before = __LINE__
+                def test_nothing
+                end
+              end
+              assert_false(test_case.test_defined?(:line => line_before))
+            end
+
+            def test_def
+              line_def = nil
+              test_case = Class.new(TestCase) do
+                line_def = __LINE__; def test_nothing
+                end
+              end
+              assert_true(test_case.test_defined?(:line => line_def))
+            end
+
+            def test_after
+              line_after = nil
+              test_case = Class.new(TestCase) do
+                def test_nothing
+                end
+                line_after = __LINE__
+              end
+              assert_true(test_case.test_defined?(:line => line_after))
+            end
+
+            def test_child
+              child_test_case = nil
+              line_child = nil
+              parent_test_case = Class.new(TestCase) do
+                test "parent" do
+                end
+
+                child_test_case = Class.new(self) do
+                  line_child = __LINE__; test "child" do
+                  end
+                end
+              end
+              assert_equal([
+                             false,
+                             true,
+                           ],
+                           [
+                             parent_test_case.test_defined?(:line => line_child),
+                             child_test_case.test_defined?(:line => line_child),
+                           ])
+            end
+          end
+
+          class TestMethodStyle < self
+            def test_before
+              line_before = nil
+              test_case = Class.new(TestCase) do
+                line_before = __LINE__
+                test "nothing" do
+                end
+              end
+              assert_false(test_case.test_defined?(:line => line_before))
+            end
+
+            def test_method
+              line_method = nil
+              test_case = Class.new(TestCase) do
+                line_method = __LINE__; test "nothing" do
+                end
+              end
+              assert_true(test_case.test_defined?(:line => line_method))
+            end
+
+            def test_after
+              line_after = nil
+              test_case = Class.new(TestCase) do
+                test "nothing" do
+                end
+                line_after = __LINE__
+              end
+              assert_true(test_case.test_defined?(:line => line_after))
+            end
+
+            def test_child
+              child_test_case = nil
+              line_child = nil
+              parent_test_case = Class.new(TestCase) do
+                test "parent" do
+                end
+
+                child_test_case = Class.new(self) do
+                  line_child = __LINE__; test "child" do
+                  end
+                end
+              end
+              assert_equal([
+                             false,
+                             true,
+                           ],
+                           [
+                             parent_test_case.test_defined?(:line => line_child),
+                             child_test_case.test_defined?(:line => line_child),
+                           ])
+            end
+
+            def test_with_setup
+              line = nil
+              test_case = Class.new(TestCase) do
+                setup do
+                end
+
+                line = __LINE__; test "with setup" do
+                end
+              end
+              assert do
+                test_case.test_defined?(:line => line,
+                                        :method_name => "test: with setup")
+              end
+            end
+          end
+        end
+
+        class TestMethodName < self
+          class TestDefStyle < self
+            def test_match
+              test_case = Class.new(TestCase) do
+                def test_nothing
+                end
+              end
+              query = {:method_name => "test_nothing"}
+              assert_true(test_case.test_defined?(query))
+            end
+
+            def test_not_match
+              test_case = Class.new(TestCase) do
+                def test_nothing
+                end
+              end
+              query = {:method_name => "test_nonexistent"}
+              assert_false(test_case.test_defined?(query))
+            end
+          end
+
+          class TestMethodStyle < self
+            def test_match
+              test_case = Class.new(TestCase) do
+                test "nothing" do
+                end
+              end
+              query = {:method_name => "test: nothing"}
+              assert_true(test_case.test_defined?(query))
+            end
+
+            def test_not_match
+              test_case = Class.new(TestCase) do
+                test "nothing" do
+                end
+              end
+              query = {:method_name => "test: nonexistent"}
+              assert_false(test_case.test_defined?(query))
+            end
+          end
+        end
+
+        class TestCombine < self
+          class TestDefStyle < self
+            def test_line_middle
+              line_middle = nil
+              test_case = Class.new(TestCase) do
+                def test_before
+                end
+                line_middle = __LINE__
+                def test_after
+                end
+              end
+              query = {
+                :path => __FILE__,
+                :line => line_middle,
+                :method_name => "test_before",
+              }
+              assert_true(test_case.test_defined?(query))
+            end
+
+            def test_line_after_def
+              line_after_def = nil
+              test_case = Class.new(TestCase) do
+                def test_before
+                end
+
+                line_after_def = __LINE__; def test_after
+                end
+              end
+              query = {
+                :path => __FILE__,
+                :line => line_after_def,
+                :method_name => "test_before",
+              }
+              assert_false(test_case.test_defined?(query))
+            end
+          end
+
+          class TestMethodStyle < self
+            def test_line_middle
+              line_middle = nil
+              test_case = Class.new(TestCase) do
+                test "before" do
+                end
+                line_middle = __LINE__
+                test "after" do
+                end
+              end
+              query = {
+                :path => __FILE__,
+                :line => line_middle,
+                :method_name => "test: before",
+              }
+              assert_true(test_case.test_defined?(query))
+            end
+
+            def test_line_after_method
+              line_after_method = nil
+              test_case = Class.new(TestCase) do
+                test "before" do
+                end
+
+                line_after_method = __LINE__; test "after" do
+                end
+              end
+              query = {
+                :path => __FILE__,
+                :line => line_after_method,
+                :method_name => "test: before",
+              }
+              assert_false(test_case.test_defined?(query))
+            end
+          end
+        end
+      end
+
+      class TestSubTestCase < self
+        class TestName < self
+          def test_anonymous
+            test_case = Class.new(TestCase)
+            sub_test_case = test_case.sub_test_case("sub test case") do
+            end
+            assert_equal("sub test case", sub_test_case.name)
+          end
+
+          def test_named
+            test_case = Class.new(TestCase)
+            def test_case.name
+              "ParentTestCase"
+            end
+            sub_test_case = test_case.sub_test_case("sub test case") do
+            end
+            assert_equal("ParentTestCase::sub test case", sub_test_case.name)
+          end
+        end
+
+        def test_suite
+          test_case = Class.new(TestCase)
+          sub_test_case = test_case.sub_test_case("sub test case") do
+            def test_nothing
+            end
+          end
+          test_method_names = sub_test_case.suite.tests.collect do |test|
+            test.method_name
+          end
+          assert_equal(["test_nothing"], test_method_names)
+        end
+
+        def test_duplicated_name
+          test_case = Class.new(TestCase) do
+            def test_nothing
+            end
+          end
+          sub_test_case = test_case.sub_test_case("sub test case") do
+            def test_nothing
+            end
+          end
+
+          test_method_names = test_case.suite.tests.collect do |test|
+            test.method_name
+          end
+          sub_test_method_names = sub_test_case.suite.tests.collect do |test|
+            test.method_name
+          end
+
+          assert_equal([
+                         ["test_nothing"],
+                         ["test_nothing"],
+                       ],
+                       [
+                         test_method_names,
+                         sub_test_method_names,
+                       ])
+        end
+      end
+
+      class TestStartupShutdown < self
+        class TestOrder < self
+          module CallLogger
+            def called
+              @@called ||= []
+            end
+          end
+
+          def call_order(test_case)
+            test_case.called.clear
+            test_suite = test_case.suite
+            test_suite.run(TestResult.new) {}
+            test_case.called
+          end
+
+          class TestNoInheritance < self
+            def setup
+              @test_case = Class.new(TestCase) do
+                extend CallLogger
+
+                class << self
+                  def startup
+                    called << :startup
+                  end
+
+                  def shutdown
+                    called << :shutdown
+                  end
+                end
+
+                def setup
+                  self.class.called << :setup
+                end
+
+                def teardown
+                  self.class.called << :teardown
+                end
+
+                def test1
+                end
+
+                def test2
+                end
+              end
+            end
+
+            def test_call_order
+              assert_equal([
+                             :startup,
+                             :setup, :teardown,
+                             :setup, :teardown,
+                             :shutdown,
+                           ],
+                           call_order(@test_case))
+            end
+          end
+
+          class TestInheritance < self
+            def setup
+              @original_descendants = TestCase::DESCENDANTS.dup
+              TestCase::DESCENDANTS.clear
+
+              @parent_test_case = Class.new(TestCase) do
+                extend CallLogger
+
+                self.test_order = :alphabetic
+
+                class << self
+                  def startup
+                    called << :startup_parent
+                  end
+
+                  def shutdown
+                    called << :shutdown_parent
+                  end
+                end
+
+                def setup
+                  self.class.called << :setup_parent
+                end
+
+                def teardown
+                  self.class.called << :teardown_parent
+                end
+
+                def test1_parent
+                  self.class.called << :test1_parent
+                end
+
+                def test2_parent
+                  self.class.called << :test2_parent
+                end
+              end
+
+              @child_test_case = Class.new(@parent_test_case) do
+                class << self
+                  def startup
+                    called << :startup_child
+                  end
+
+                  def shutdown
+                    called << :shutdown_child
+                  end
+                end
+
+                def setup
+                  self.class.called << :setup_child
+                end
+
+                def teardown
+                  self.class.called << :teardown_child
+                end
+
+                def test1_child
+                  self.class.called << :test1_child
+                end
+
+                def test2_child
+                  self.class.called << :test2_child
+                end
+              end
+            end
+
+            def teardown
+              TestCase::DESCENDANTS.replace(@original_descendants)
+            end
+
+            def test_call_order
+              collector = Collector::Descendant.new
+              test_suite = collector.collect
+              test_suite.run(TestResult.new) {}
+              called = @parent_test_case.called
+              assert_equal([
+                             :startup_parent,
+                             :setup_parent, :test1_parent, :teardown_parent,
+                             :setup_parent, :test2_parent, :teardown_parent,
+                             :startup_child,
+                             :setup_child, :test1_child, :teardown_child,
+                             :setup_child, :test2_child, :teardown_child,
+                             :shutdown_child,
+                             :shutdown_parent,
+                           ],
+                           called)
+            end
+          end
+        end
+
+        class TestError < self
+          def run_test_case(test_case)
+            test_suite = test_case.suite
+            result = TestResult.new
+            test_suite.run(result) {}
+            result
+          end
+
+          def error_count(test_case)
+            run_test_case(test_case).error_count
+          end
+
+          def test_on_startup
+            test_case = Class.new(TestCase) do
+              class << self
+                def startup
+                  raise "from startup"
+                end
+              end
+
+              def test_nothing
+              end
+            end
+
+            assert_equal(1, error_count(test_case))
+          end
+
+          def test_pass_through_on_startup
+            test_case = Class.new(TestCase) do
+              class << self
+                def startup
+                  raise Interrupt, "from startup"
+                end
+              end
+
+              def test_nothing
+              end
+            end
+
+            assert_raise(Interrupt) do
+              run_test_case(test_case)
+            end
+          end
+
+          def test_on_shutdown
+            test_case = Class.new(TestCase) do
+              class << self
+                def shutdown
+                  raise "from shutdown"
+                end
+              end
+
+              def test_nothing
+              end
+            end
+
+            assert_equal(1, error_count(test_case))
+          end
+
+          def test_pass_through_on_shutdown
+            test_case = Class.new(TestCase) do
+              class << self
+                def shutdown
+                  raise Interrupt, "from shutdown"
+                end
+              end
+
+              def test_nothing
+              end
+            end
+
+            assert_raise(Interrupt) do
+              run_test_case(test_case)
+            end
+          end
+
+          def test_pass_through_in_test
+            test_case = Class.new(TestCase) do
+              @called = []
+              class << self
+                def called
+                  @called
+                end
+
+                def startup
+                  @called << :startup
+                end
+
+                def shutdown
+                  @called << :shutdown
+                end
+              end
+
+              def test_error
+                raise Interrupt, "from test"
+              end
+            end
+
+            assert_raise(Interrupt) do
+              run_test_case(test_case)
+            end
+            assert_equal([:startup, :shutdown],
+                         test_case.called)
+          end
+        end
+      end
+    end
+  end
+end