test-unit 1.2.3 → 2.0.0

data/test/run-test.rb

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+
+$VERBOSE = true
+
+base_dir = File.expand_path(File.join(File.dirname(__FILE__), ".."))
+lib_dir = File.join(base_dir, "lib")
+test_dir = File.join(base_dir, "test")
+
+$LOAD_PATH.unshift(lib_dir)
+
+require 'test/unit'
+
+exit Test::Unit::AutoRunner.run(true, test_dir)

data/test/test_assertions.rb

@@ -9,12 +9,11 @@ module Test
     class TC_Assertions < TestCase
       def check(value, message="")
         add_assertion
-        if (!value)
-          raise AssertionFailedError.new(message)
-        end
+        raise AssertionFailedError.new(message) unless value
       end
 
-      def check_assertions(expect_fail, expected_message="", return_value_expected=false)
+      def check_assertions(expect_fail, expected_message="",
+                           return_value_expected=false)
         @actual_assertion_count = 0
         failed = true
         actual_message = nil
@@ -27,35 +26,65 @@ module Test
           actual_message = error.message
         end
         @catch_assertions = false
-        check(expect_fail == failed, (expect_fail ? "Should have failed, but didn't" : "Should not have failed, but did with message\n<#{actual_message}>"))
-        check(1 == @actual_assertion_count, "Should have made one assertion but made <#{@actual_assertion_count}>")
-        if (expect_fail)
+
+        if expect_fail
+          message = "Should have failed, but didn't"
+        else
+          message = "Should not have failed, but did with message\n" +
+            "<#{actual_message}>"
+        end
+        check(expect_fail == failed, message)
+
+        message = "Should have made one assertion but made\n" +
+          "<#{@actual_assertion_count}>"
+        check(1 == @actual_assertion_count, message)
+
+        if expect_fail
           case expected_message
-            when String
-              check(actual_message == expected_message, "Should have the correct message.\n<#{expected_message.inspect}> expected but was\n<#{actual_message.inspect}>")
-            when Regexp
-              check(actual_message =~ expected_message, "The message should match correctly.\n</#{expected_message.source}/> expected to match\n<#{actual_message.inspect}>")
-            else
-              check(false, "Incorrect expected message type in assert_nothing_failed")
+          when String
+            check(actual_message == expected_message,
+                  "Should have the correct message.\n" +
+                  "<#{expected_message.inspect}> expected but was\n" +
+                  "<#{actual_message.inspect}>")
+          when Regexp
+            check(actual_message =~ expected_message,
+                  "The message should match correctly.\n" +
+                  "</#{expected_message.source}/> expected to match\n" +
+                  "<#{actual_message.inspect}>")
+          else
+            check(false,
+                  "Incorrect expected message type in assert_nothing_failed")
           end
         else
-          if (!return_value_expected)
-            check(return_value.nil?, "Should not return a value but returned <#{return_value}>")
-          else
+          if return_value_expected
             check(!return_value.nil?, "Should return a value")
+          else
+            check(return_value.nil?,
+                  "Should not return a value but returned <#{return_value}>")
           end
         end
-        return return_value
+
+        return_value
       end
-      
+
       def check_nothing_fails(return_value_expected=false, &proc)
         check_assertions(false, "", return_value_expected, &proc)
       end
-      
+
       def check_fails(expected_message="", &proc)
         check_assertions(true, expected_message, &proc)
       end
-      
+
+      def inspect_tag(tag)
+        begin
+          throw tag
+        rescue NameError
+          tag.to_s.inspect
+        rescue ArgumentError
+          tag.inspect
+        end
+      end
+
       def test_assert_block
         check_nothing_fails {
           assert_block {true}
@@ -93,17 +122,87 @@ module Test
         check_nothing_fails {
           assert_equal("string1", "string1", "successful assert_equal")
         }
-        check_fails(%Q{<"string1"> expected but was\n<"string2">.}) {
+
+        message = <<-EOM.chomp
+<"string1"> expected but was
+<"string2">.
+
+diff:
+- string1
+?       ^
++ string2
+?       ^
+EOM
+        check_fails(message) {
           assert_equal("string1", "string2")
         }
-        check_fails(%Q{failed assert_equal.\n<"string1"> expected but was\n<"string2">.}) {
+
+        message = <<-EOM.chomp
+failed assert_equal.
+<"string1"> expected but was
+<"string2">.
+
+diff:
+- string1
+?       ^
++ string2
+?       ^
+EOM
+        check_fails(message) {
           assert_equal("string1", "string2", "failed assert_equal")
         }
-        check_fails(%Q{<"1"> expected but was\n<1>.}) do
-          assert_equal("1", 1)
+
+        message = <<-EOM.chomp
+<"111111"> expected but was
+<111111>.
+
+diff:
+- "111111"
+? -      -
++ 111111
+EOM
+        check_fails(message) do
+          assert_equal("111111", 111111)
         end
       end
-      
+
+      def test_assert_equal_for_too_small_difference
+        message = <<-EOM.chomp
+<1> expected but was
+<2>.
+EOM
+        check_fails(message) do
+          assert_equal(1, 2)
+        end
+      end
+
+      def test_assert_equal_for_same_inspected_objects
+        now = Time.now
+        now_without_usec = Time.at(now.to_i)
+        message = <<-EOM.chomp
+<#{now.inspect}> expected but was
+<#{now.inspect}>.
+EOM
+        check_fails(message) do
+          assert_equal(now, now_without_usec)
+        end
+      end
+
+      def test_assert_equal_with_multi_lines_result
+        message = <<-EOM.chomp
+<#{"a\nb".inspect}> expected but was
+<#{"x".inspect}>.
+
+diff:
++ x
+- a
+- b
+EOM
+        check_fails(message) do
+          assert_equal("a\nb", "x")
+        end
+      end
+
       def test_assert_raise
         return_value = nil
         check_nothing_fails(true) {
@@ -211,10 +310,10 @@ Message: <"Error">
         check_nothing_fails {
           assert_nil(nil, "successful assert_nil")
         }
-        check_fails(%Q{<nil> expected but was\n<"string">.}) {
+        check_fails(%Q{<"string"> expected to be nil.}) {
           assert_nil("string")
         }
-        check_fails(%Q{failed assert_nil.\n<nil> expected but was\n<"string">.}) {
+        check_fails(%Q{failed assert_nil.\n<"string"> expected to be nil.}) {
           assert_nil("string", "failed assert_nil")
         }
       end
@@ -398,34 +497,43 @@ Message: <"Error">
       end
       
       def test_assert_throws
-        check_nothing_fails {
-          assert_throws(:thing, "message") {
+        check_nothing_fails do
+          assert_throws(:thing, "message") do
             throw :thing
-          }
-        }
-        check_fails("message.\n<:thing> expected to be thrown but\n<:thing2> was thrown.") {
-          assert_throws(:thing, "message") {
+          end
+        end
+
+        tag = :thing2
+        check_fails("message.\n" +
+                    "<:thing> expected to be thrown but\n" +
+                    "<#{inspect_tag(tag)}> was thrown.") do
+          assert_throws(:thing, "message") do
             throw :thing2
-          }
-        }
-        check_fails("message.\n<:thing> should have been thrown.") {
-          assert_throws(:thing, "message") {
+          end
+        end
+        check_fails("message.\n" +
+                    "<:thing> should have been thrown.") do
+          assert_throws(:thing, "message") do
             1 + 1
-          }
-        }
+          end
+        end
       end
       
       def test_assert_nothing_thrown
-        check_nothing_fails {
-          assert_nothing_thrown("message") {
+        check_nothing_fails do
+          assert_nothing_thrown("message") do
             1 + 1
-          }
-        }
-        check_fails("message.\n<:thing> was thrown when nothing was expected.") {
-          assert_nothing_thrown("message") {
-            throw :thing
-          }
-        }
+          end
+        end
+
+        tag = :thing
+        inspected = inspect_tag(tag)
+        check_fails("message.\n" +
+                    "<#{inspected}> was thrown when nothing was expected.") do
+          assert_nothing_thrown("message") do
+            throw tag
+          end
+        end
       end
       
       def test_assert_operator
@@ -505,22 +613,79 @@ Message: <"Error">
           @changed ||= false
           return (!@changed)
         end
-        check_nothing_fails {
+        check_nothing_fails do
           assert_equal(object, object, "message")
-        }
+        end
+      end
+
+      def test_assert_boolean
+        check_nothing_fails do
+          assert_boolean(true)
+        end
+        check_nothing_fails do
+          assert_boolean(false)
+        end
+
+        check_fails("<true> or <false> expected but was\n<1>") do
+          assert_boolean(1)
+        end
+
+        check_fails("<true> or <false> expected but was\n<nil>") do
+          assert_boolean(nil)
+        end
+
+        check_fails("message.\n<true> or <false> expected but was\n<\"XXX\">") do
+          assert_boolean("XXX", "message")
+        end
       end
-  
+
+      def test_assert_true
+        check_nothing_fails do
+          assert_true(true)
+        end
+
+        check_fails("<true> expected but was\n<false>") do
+          assert_true(false)
+        end
+
+        check_fails("<true> expected but was\n<1>") do
+          assert_true(1)
+        end
+
+        check_fails("message.\n<true> expected but was\n<nil>") do
+          assert_true(nil, "message")
+        end
+      end
+
+      def test_assert_false
+        check_nothing_fails do
+          assert_false(false)
+        end
+
+        check_fails("<false> expected but was\n<true>") do
+          assert_false(true)
+        end
+
+        check_fails("<false> expected but was\n<nil>") do
+          assert_false(nil)
+        end
+
+        check_fails("message.\n<false> expected but was\n<:false>") do
+          assert_false(:false, "message")
+        end
+      end
+
       def add_failure(message, location=caller)
-        if (!@catch_assertions)
+        unless @catch_assertions
           super
         end
       end
-      
+
       def add_assertion
-        if (!@catch_assertions)
-          super
-        else
+        if @catch_assertions
           @actual_assertion_count += 1
+        else
+          super
         end
       end
     end

data/test/test_attribute.rb

@@ -0,0 +1,86 @@
+class TestUnitAttribute < Test::Unit::TestCase
+  class TestStack < Test::Unit::TestCase
+    class << self
+      def suite
+        Test::Unit::TestSuite.new(name)
+      end
+    end
+
+    class Stack
+      def initialize
+        @data = []
+      end
+
+      def push(data)
+        @data.push(data)
+      end
+
+      def peek
+        @data[-2]
+      end
+
+      def empty?
+        @data.empty?
+      end
+
+      def size
+        @data.size + 11
+      end
+    end
+
+    def setup
+      @stack = Stack.new
+    end
+
+    attribute :category, :accessor
+    def test_peek
+      @stack.push(1)
+      @stack.push(2)
+      assert_equal(2, @stack.peek)
+    end
+
+    attribute :bug, 1234
+    def test_bug_1234
+      assert_equal(0, @stack.size)
+    end
+
+    def test_no_attributes
+      assert(@stack.empty?)
+      @stack.push(1)
+      assert(!@stack.empty?)
+      assert_equal(1, @stack.size)
+    end
+  end
+
+  def test_set_attributes
+    test_for_accessor_category = TestStack.new("test_peek")
+    assert_equal({"category" => :accessor},
+                 test_for_accessor_category.attributes)
+
+    test_for_bug_1234 = TestStack.new("test_bug_1234")
+    assert_equal({"bug" => 1234}, test_for_bug_1234.attributes)
+
+    test_no_attributes = TestStack.new("test_no_attributes")
+    assert_equal({}, test_no_attributes.attributes)
+  end
+
+  def test_callback
+    changed_attributes = []
+    observer = Proc.new do |test_case, key, old_value, value, method_name|
+      changed_attributes << [test_case, key, old_value, value, method_name]
+    end
+
+    test_case = Class.new(TestStack) do
+      register_attribute_observer(:bug, &observer)
+      attribute("bug", 9876, "test_bug_1234")
+      attribute(:description, "Test for peek", "test_peek")
+      attribute(:bug, 29, "test_peek")
+    end
+
+    assert_equal([
+                  [test_case, "bug", 1234, 9876, "test_bug_1234"],
+                  [test_case, "bug", nil, 29, "test_peek"],
+                 ],
+                 changed_attributes)
+  end
+end