test-unit 2.5.5 → 3.0.0

data/test/test-attribute.rb

@@ -84,6 +84,17 @@ class TestUnitAttribute < Test::Unit::TestCase
                  changed_attributes)
   end
 
+  def test_attributes_with_prepended_module
+    omit("Module#prepend is needed") unless Module.respond_to?(:prepend, true)
+    test_case = Class.new(TestStack) do
+      prepend Module.new
+    end
+    assert_equal({
+                   "category" => :accessor,
+                 },
+                 test_case.attributes("test_peek"))
+  end
+
   class TestDescription < self
     def test_decoration_style
       test_case = Class.new(TestStack) do

data/test/{test-testcase.rb → test-test-case.rb}

@@ -1,5 +1,5 @@
 # Author:: Nathaniel Talbott.
-# Copyright:: Copyright (c) 2008-2012  Kouhei Sutou <kou@clear-code.com>
+# Copyright:: Copyright (c) 2008-2013  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.
@@ -299,135 +299,6 @@ module Test
         end
       end
 
-      def test_startup_shutdown
-        called = []
-        test_case = Class.new(TestCase) do
-          class << self
-            def called
-              @@called
-            end
-
-            def called=(called)
-              @@called = called
-            end
-
-            def startup
-              @@called << :startup
-            end
-
-            def shutdown
-              @@called << :shutdown
-            end
-          end
-          self.called = called
-
-          def setup
-            self.class.called << :setup
-          end
-
-          def teardown
-            self.class.called << :teardown
-          end
-
-          def test1
-          end
-
-          def test2
-          end
-        end
-
-        test_suite = test_case.suite
-        test_suite.run(TestResult.new) {}
-        check("startup/shutdown should be called once per test case" +
-              ": #{called.inspect}",
-              called == [:startup,
-                         :setup, :teardown,
-                         :setup, :teardown,
-                         :shutdown])
-      end
-
-      def test_error_on_startup
-        test_case = Class.new(TestCase) do
-          class << self
-            def startup
-              raise "from startup"
-            end
-          end
-
-          def test_nothing
-          end
-        end
-
-        test_suite = test_case.suite
-        result = TestResult.new
-        test_suite.run(result) {}
-        check("Should record an error on startup: #{result}",
-              result.error_count == 1)
-      end
-
-      def test_pass_through_error_on_startup
-        test_case = Class.new(TestCase) do
-          class << self
-            def startup
-              raise Interrupt, "from startup"
-            end
-          end
-
-          def test_nothing
-          end
-        end
-
-        test_suite = test_case.suite
-        begin
-          test_suite.run(TestResult.new) {}
-          check("Should not be reached", false)
-        rescue Exception
-          check("Interrupt should be passed through: #{$!}",
-                Interrupt === $!)
-        end
-      end
-
-      def test_error_on_shutdown
-        test_case = Class.new(TestCase) do
-          class << self
-            def shutdown
-              raise "from shutdown"
-            end
-          end
-
-          def test_nothing
-          end
-        end
-
-        test_suite = test_case.suite
-        result = TestResult.new
-        test_suite.run(result) {}
-        check("Should record an error on shutdown: #{result}",
-              result.error_count == 1)
-      end
-
-      def test_pass_through_error_on_shutdown
-        test_case = Class.new(TestCase) do
-          class << self
-            def shutdown
-              raise Interrupt, "from shutdown"
-            end
-          end
-
-          def test_nothing
-          end
-        end
-
-        test_suite = test_case.suite
-        begin
-          test_suite.run(TestResult.new) {}
-          check("Should not be reached", false)
-        rescue Exception
-          check("Interrupt should be passed through: #{$!}",
-                Interrupt === $!)
-        end
-      end
-
       def test_interrupted
         test_case = Class.new(TestCase) do
           def test_fail
@@ -590,7 +461,13 @@ module Test
 
       class TestTestDefined < self
         class TestNoQuery < self
-          def test_have_test
+          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
@@ -598,133 +475,270 @@ module Test
             assert_true(test_case.test_defined?({}))
           end
 
-          def test_no_test
+          def test_have_method_style_test
             test_case = Class.new(TestCase) do
+              test "nothing" do
+              end
             end
-            assert_false(test_case.test_defined?({}))
+            assert_true(test_case.test_defined?({}))
           end
         end
 
         class TestPath < self
-          def test_base_name
-            test_case = Class.new(TestCase) do
-              def test_nothing
+          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
-            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
+            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
-            assert_true(test_case.test_defined?(:path => __FILE__))
           end
 
-          def test_not_match
-            test_case = Class.new(TestCase) do
-              def test_nothing
+          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
-            assert_false(test_case.test_defined?(:path => "nonexistent.rb"))
           end
         end
 
         class TestLine < self
-          def test_before
-            line_before = nil
-            test_case = Class.new(TestCase) do
-              line_before = __LINE__
-              def test_nothing
+          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
-            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
+            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
-            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
+          class TestMethodStyle < self
+            def test_before
+              line_before = nil
+              test_case = Class.new(TestCase) do
+                line_before = __LINE__
+                test "nothing" do
+                end
               end
-              line_after = __LINE__
+              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
-            assert_true(test_case.test_defined?(:line => line_after))
           end
         end
 
         class TestMethodName < self
-          def test_match
-            test_case = Class.new(TestCase) do
-              def test_nothing
+          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
-            assert_true(test_case.test_defined?(:method_name => "test_nothing"))
           end
 
-          def test_not_match
-            test_case = Class.new(TestCase) do
-              def test_nothing
+          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
-            query = {:method_name => "test_nonexistent"}
-            assert_false(test_case.test_defined?(query))
           end
         end
 
         class TestCombine < self
-          def test_line_middle
-            line_middle = nil
-            test_case = Class.new(TestCase) do
-              def test_before
+          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
-              line_middle = __LINE__
-              def test_after
+              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
-            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
+          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_def = __LINE__; def test_after
+                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
-            query = {
-              :path => __FILE__,
-              :line => line_after_def,
-              :method_name => "test_before",
-            }
-            assert_false(test_case.test_defined?(query))
           end
         end
       end
 
       class TestSubTestCase < self
-        def test_name
-          test_case = Class.new(TestCase)
-          sub_test_case = test_case.sub_test_case("sub test case") do
+        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
-          assert_equal("sub test case", sub_test_case.name)
         end
 
         def test_suite
@@ -739,6 +753,229 @@ module Test
           assert_equal(["test_nothing"], 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
+
+                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
+        end
+      end
     end
   end
 end