groonga 0.0.7 → 0.9.0

data/test-unit/lib/test/unit/ui/emacs/testrunner.rb

@@ -22,6 +22,20 @@ module Test
             end
           end
 
+          def output_fault_backtrace(fault)
+            backtrace = fault.location
+            if backtrace.size == 1
+              output(fault.test_name +
+                     backtrace[0].sub(/\A(.+:\d+).*/, ' [\\1]') +
+                     ":")
+            else
+              output(fault.test_name)
+              backtrace.each do |entry|
+                output(entry)
+              end
+            end
+          end
+
           def format_fault_failure(failure)
             if failure.location.size == 1
               location = failure.location[0]

data/test-unit/lib/test/unit/ui/testrunner.rb

@@ -14,6 +14,14 @@ module Test
           end
           @options = options
         end
+
+        def diff_target_string?(string)
+          Assertions::AssertionMessage.diff_target_string?(string)
+        end
+
+        def prepare_for_diff(from, to)
+          Assertions::AssertionMessage.prepare_for_diff(from, to)
+        end
       end
     end
   end

data/test-unit/lib/test/unit/version.rb

@@ -2,6 +2,6 @@
 # HACK: quick and dirty to get integrated into the new project - ryan
 module Test
   module Unit
-    VERSION = '2.0.3'
+    VERSION = '2.0.7'
   end
 end

data/test-unit/sample/{tc_adder.rb → test_adder.rb}

@@ -5,13 +5,15 @@
 require 'test/unit'
 require 'adder'
 
-class TC_Adder < Test::Unit::TestCase
+class TestAdder < Test::Unit::TestCase
   def setup
     @adder = Adder.new(5)
   end
+
   def test_add
     assert_equal(7, @adder.add(2), "Should have added correctly")
   end
+
   def teardown
     @adder = nil
   end

data/test-unit/sample/{tc_subtracter.rb → test_subtracter.rb}

@@ -5,13 +5,15 @@
 require 'test/unit'
 require 'subtracter'
 
-class TC_Subtracter < Test::Unit::TestCase
+class TestSubtracter < Test::Unit::TestCase
   def setup
     @subtracter = Subtracter.new(5)
   end
+
   def test_subtract
     assert_equal(3, @subtracter.subtract(2), "Should have subtracted correctly")
   end
+
   def teardown
     @subtracter = nil
   end

data/test-unit/sample/test_user.rb

@@ -1,4 +1,5 @@
 # nested test case example.
+require 'test/unit'
 
 class UserTest < Test::Unit::TestCase
   def setup

data/test-unit/test/collector/test-descendant.rb

@@ -66,7 +66,7 @@ class TestUnitCollectorDescendant < Test::Unit::TestCase
       collector.filter = [Proc.new {false}, Proc.new {true}]
     end
 
-    assert_collect(full_suite) do |collector|
+    assert_collect(empty_suite) do |collector|
       collector.filter = [Proc.new {true}, Proc.new {false}]
     end
 
@@ -90,13 +90,11 @@ class TestUnitCollectorDescendant < Test::Unit::TestCase
       end
     end
 
-    expected = empty_suite
     suite1 = Test::Unit::TestSuite.new(@test_case1.name)
     suite1 << @test_case1.new("test_1")
     suite2 = Test::Unit::TestSuite.new(@test_case2.name)
     suite2 << @test_case2.new("test_0")
-    expected << suite1 << suite2
-    assert_collect(expected) do |collector|
+    assert_collect(empty_suite) do |collector|
       filters = [Proc.new {|test| test.method_name == 'test_1' ? true : nil},
                  Proc.new {|test| test.method_name == 'test_0' ? true : nil},
                  Proc.new {false}]

data/test-unit/test/collector/test_objectspace.rb

@@ -72,7 +72,7 @@ module Test
           assert_equal(empty_suite, @c.collect)
 
           @c.filter = [proc{true}, proc{false}]
-          assert_equal(full_suite, @c.collect)
+          assert_equal(empty_suite, @c.collect)
 
           @c.filter = [proc{nil}, proc{false}]
           assert_equal(empty_suite, @c.collect)
@@ -87,10 +87,12 @@ module Test
           assert_equal(expected, @c.collect)
 
           expected = TestSuite.new(ObjectSpace::NAME)
-          expected << (TestSuite.new(@tc1.name) << @tc1.new('test_1'))
-          expected << (TestSuite.new(@tc2.name) << @tc2.new('test_0'))
-          @c.filter = [proc{|t| t.method_name == 'test_1' ? true : nil}, proc{|t| t.method_name == 'test_0' ? true : nil}, proc{false}]
-          assert_equal(expected, @c.collect)
+          TestSuite.new(@tc1.name) << @tc1.new('test_1')
+          TestSuite.new(@tc2.name) << @tc2.new('test_0')
+          @c.filter = [proc{|t| t.method_name == 'test_1' ? true : nil},
+                       proc{|t| t.method_name == 'test_0' ? true : nil},
+                       proc{false}]
+          assert_equal(empty_suite, @c.collect)
         end
       end
     end

data/test-unit/test/run-test.rb

@@ -2,6 +2,8 @@
 
 $VERBOSE = true
 
+$KCODE = "utf8" unless "".respond_to?(:encoding)
+
 base_dir = File.expand_path(File.join(File.dirname(__FILE__), ".."))
 lib_dir = File.join(base_dir, "lib")
 test_dir = File.join(base_dir, "test")

data/test-unit/test/test-color-scheme.rb

@@ -12,6 +12,13 @@ class TestUnitColorScheme < Test::Unit::TestCase
                              color("blue", :foreground => false),
                    "suite" => color("white", :bold => true) +
                               color("green", :foreground => false),
+                   "diff-inserted-tag" => color("red", :bold => true),
+                   "diff-deleted-tag" => color("green", :bold => true),
+                   "diff-difference-tag" => color("cyan", :bold => true),
+                   "diff-inserted" => color("red", :foreground => false) +
+                                      color("white", :bold => true),
+                   "diff-deleted" => color("green", :foreground => false) +
+                                     color("white", :bold => true),
                  },
                  Test::Unit::ColorScheme.default.to_hash)
   end

data/test-unit/test/test-diff.rb

@@ -1,4 +1,9 @@
 class TestUnitDiff < Test::Unit::TestCase
+  def test_binary_search_ranges
+    assert_found_binary_search_ranges(5, [1..2, 4..5, 7..9])
+    assert_not_found_binary_search_ranges(3, [1..2, 4..5, 7..9])
+  end
+
   def test_to_indexes
     assert_to_indexes({"abc def" => [0, 2], "abc" => [1]},
                       ["abc def", "abc", "abc def"])
@@ -189,6 +194,21 @@ class TestUnitDiff < Test::Unit::TestCase
     assert_ratio(0.80, "efg", "eg")
   end
 
+  def test_1_length_readable_diff
+    differ = Test::Unit::Diff::ReadableDiffer.new(["0"], ["1"])
+    def differ.cut_off_ratio
+      0
+    end
+    def differ.default_ratio
+      0
+    end
+    assert_equal("- 0\n" +
+                 "? ^\n" +
+                 "+ 1\n" +
+                 "? ^",
+                 differ.diff.join("\n"))
+  end
+
   def test_same_contents_readable_diff
     assert_readable_diff("  aaa", ["aaa"], ["aaa"])
     assert_readable_diff("  aaa\n" \
@@ -387,6 +407,18 @@ class TestUnitDiff < Test::Unit::TestCase
   end
 
   private
+  def assert_found_binary_search_ranges(numeric, ranges)
+    assert_true(Test::Unit::Diff::UTF8Line.send(:binary_search_ranges,
+                                                numeric,
+                                                ranges))
+  end
+
+  def assert_not_found_binary_search_ranges(numeric, ranges)
+    assert_false(Test::Unit::Diff::UTF8Line.send(:binary_search_ranges,
+                                                 numeric,
+                                                 ranges))
+  end
+
   def assert_to_indexes(expected, to, &junk_predicate)
     matcher = Test::Unit::Diff::SequenceMatcher.new([""], to, &junk_predicate)
     assert_equal(expected, matcher.instance_variable_get("@to_indexes"))
@@ -451,21 +483,30 @@ class TestUnitDiff < Test::Unit::TestCase
                         from_start, from_end,
                         to_start, to_end)
     differ = Test::Unit::Diff::ReadableDiffer.new(from, to)
-    assert_equal(expected, differ.send(:diff_lines,
-                                       from_start, from_end,
-                                       to_start, to_end))
+    result = []
+    differ.instance_variable_set("@result", result)
+    differ.send(:diff_lines,
+                from_start, from_end,
+                to_start, to_end)
+    assert_equal(expected, result)
   end
 
   def assert_diff_line(expected, from_line, to_line)
     differ = Test::Unit::Diff::ReadableDiffer.new([""], [""])
-    assert_equal(expected, differ.send(:diff_line, from_line, to_line))
+    result = []
+    differ.instance_variable_set("@result", result)
+    differ.send(:diff_line, from_line, to_line)
+    assert_equal(expected, result)
   end
 
   def assert_format_diff_point(expected, from_line, to_line, from_tags, to_tags)
     differ = Test::Unit::Diff::ReadableDiffer.new([""], [""])
-    assert_equal(expected, differ.send(:format_diff_point,
-                                       from_line, to_line,
-                                       from_tags, to_tags))
+    result = []
+    differ.instance_variable_set("@result", result)
+    differ.send(:format_diff_point,
+                from_line, to_line,
+                from_tags, to_tags)
+    assert_equal(expected, result)
   end
 
   def assert_interesting_line(expected, from, to, from_start, to_start)

data/test-unit/test/test-omission.rb

@@ -68,7 +68,7 @@ class TestUnitOmission < Test::Unit::TestCase
 
   def test_omit_with_condition_and_block
     result = _run_test("test_omit_with_block_and_condition")
-    assert_equal("1 tests, 1 assertions, 0 failures, 0 errors, 0 pendings, " \
+    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)

data/test-unit/test/test-testcase.rb

@@ -490,6 +490,53 @@ module Test
         end
       end
 
+      def test_declarative_style
+        keep_test_order do
+          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
+      end
+
+      def test_redefine_method
+        test_case = Class.new(Test::Unit::TestCase) do
+          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
+
       private
       def check(message, passed)
         add_assertion

data/test-unit/test/test_assertions.rb

@@ -248,32 +248,66 @@ EOM
 
       def test_assert_equal_with_large_string
         message = <<-EOM.chomp
-<#{("a\n" + "x" * 297).inspect}> expected but was
+<#{("a\n" + "x" * 997).inspect}> expected but was
 <#{"x".inspect}>.
 
 diff:
 + x
 - a
-- #{"x" * 297}
+- #{"x" * 997}
 
 folded diff:
 + x
 - a
-- #{"x" * 78}
-- #{"x" * 78}
-- #{"x" * 78}
-- #{"x" * 63}
+#{(["- " + ("x" * 78)] * 12).join("\n")}
+- #{"x" * 61}
 EOM
         check_fails(message) do
-          assert_equal("a\n" + "x" * 297, "x")
+          assert_equal("a\n" + "x" * 997, "x")
         end
 
         message = <<-EOM.chomp
-<#{("a\n" + "x" * 298).inspect}> expected but was
+<#{("a\n" + "x" * 998).inspect}> expected but was
 <#{"x".inspect}>.
 EOM
         check_fails(message) do
-          assert_equal("a\n" + "x" * 298, "x")
+          assert_equal("a\n" + "x" * 998, "x")
+        end
+      end
+
+      def test_assert_equal_with_max_diff_target_string_size
+        key = "TEST_UNIT_MAX_DIFF_TARGET_STRING_SIZE"
+        before_value = ENV[key]
+        ENV[key] = "100"
+        begin
+          message = <<-EOM.chomp
+<#{("a\n" + "x" * 97).inspect}> expected but was
+<#{"x".inspect}>.
+
+diff:
++ x
+- a
+- #{"x" * 97}
+
+folded diff:
++ x
+- a
+#{(["- " + ("x" * 78)]).join("\n")}
+- #{"x" * 19}
+EOM
+          check_fails(message) do
+            assert_equal("a\n" + "x" * 97, "x")
+          end
+
+          message = <<-EOM.chomp
+<#{("a\n" + "x" * 98).inspect}> expected but was
+<#{"x".inspect}>.
+EOM
+          check_fails(message) do
+            assert_equal("a\n" + "x" * 98, "x")
+          end
+        ensure
+          ENV[key] = before_value
         end
       end
 
@@ -1063,8 +1097,43 @@ EOM
         end
       end
 
+      def test_assert_alias_method
+        object = Object.new
+        class << object
+          def original_method
+          end
+          alias_method :alias_method, :original_method
+
+          def other
+          end
+        end
+
+        check_nothing_fails do
+          assert_alias_method(object, :alias_method, :original_method)
+        end
+
+        check_nothing_fails do
+          assert_alias_method(object, :original_method, :alias_method)
+        end
+
+        check_fails("<#{object.method(:other).inspect}> is alias of\n" +
+                    "<#{object.method(:original_method).inspect}> expected") do
+          assert_alias_method(object, :other, :original_method)
+        end
+
+        check_fails("<#{object.inspect}>.nonexistent doesn't exist\n" +
+                    "(Class: <Object>)") do
+          assert_alias_method(object, :nonexistent, :original_method)
+        end
+
+        check_fails("<#{object.inspect}>.nonexistent doesn't exist\n" +
+                    "(Class: <Object>)") do
+          assert_alias_method(object, :alias_method, :nonexistent)
+        end
+      end
+
       private
-      def add_failure(message, location=caller)
+      def add_failure(message, location=caller, options=nil)
         unless @catch_assertions
           super
         end

data/test/groonga-test-utils.rb

@@ -16,7 +16,12 @@
 require 'fileutils'
 require 'pathname'
 require 'time'
-require 'json'
+begin
+  require 'json'
+rescue LoadError
+  require 'rubygems'
+  require 'json'
+end
 require 'pkg-config'
 
 require 'groonga'