rroonga 0.9.5 → 1.0.0

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

@@ -1,7 +1,7 @@
 #--
 #
 # Author:: Kouhei Sutou.
-# Copyright:: Copyright (c) 2009 Kouhei Sutou <kou@clear-code.com>.
+# Copyright:: Copyright (c) 2009-2010 Kouhei Sutou <kou@clear-code.com>.
 # License:: Ruby license.
 
 require 'test/unit/ui/testrunner'
@@ -24,8 +24,7 @@ module Test
 
           # Begins the test run.
           def start
-            setup_mediator
-            result = start_mediator
+            result = super
             def result.passed?
               true # for prove commend :<
             end
@@ -33,11 +32,6 @@ module Test
           end
 
           private
-          def setup_mediator
-            @mediator = TestRunnerMediator.new(@suite)
-            attach_to_mediator
-          end
-
           def attach_to_mediator
             @mediator.add_listener(TestResult::FAULT, &method(:add_fault))
             @mediator.add_listener(TestRunnerMediator::STARTED, &method(:started))
@@ -46,10 +40,6 @@ module Test
             @mediator.add_listener(TestCase::FINISHED, &method(:test_finished))
           end
 
-          def start_mediator
-            @mediator.run_suite
-          end
-
           def add_fault(fault)
             puts("not ok #{@n_tests} - #{fault.short_display}")
             fault.long_display.each_line do |line|

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

@@ -6,6 +6,7 @@ module Test
       class TestRunner
         extend TestRunnerUtilities
 
+        attr_reader :listeners
         def initialize(suite, options={})
           if suite.respond_to?(:suite)
             @suite = suite.suite
@@ -13,6 +14,30 @@ module Test
             @suite = suite
           end
           @options = options
+          @listeners = @options[:listeners] || []
+        end
+
+        # Begins the test run.
+        def start
+          setup_mediator
+          attach_to_mediator
+          attach_listeners
+          start_mediator
+        end
+
+        private
+        def setup_mediator
+          @mediator = TestRunnerMediator.new(@suite)
+        end
+
+        def attach_listeners
+          @listeners.each do |listener|
+            listener.attach_to_mediator(@mediator)
+          end
+        end
+
+        def start_mediator
+          @mediator.run_suite
         end
 
         def diff_target_string?(string)

data/test-unit/lib/test/unit/util/backtracefilter.rb

@@ -9,6 +9,7 @@ module Test
         module_function
         def filter_backtrace(backtrace, prefix=nil)
           return ["No backtrace"] unless(backtrace)
+          return backtrace if ENV["TEST_UNIT_ALL_BACKTRACE"]
           split_p = if(prefix)
             prefix.split(TESTUNIT_FILE_SEPARATORS)
           else

data/test-unit/lib/test/unit/util/output.rb

@@ -0,0 +1,31 @@
+module Test
+  module Unit
+    module Util
+      module Output
+        ##
+        # Returns output for standard output and standard
+        # error as string.
+        #
+        # Example:
+        #   capture_output do
+        #     puts("stdout")
+        #     warn("stderr")
+        #   end # -> ["stdout\n", "stderr\n"]
+        def capture_output
+          require 'stringio'
+
+          output = StringIO.new
+          error = StringIO.new
+          stdout_save, stderr_save = $stdout, $stderr
+          $stdout, $stderr = output, error
+          begin
+            yield
+            [output.string, error.string]
+          ensure
+            $stdout, $stderr = stdout_save, stderr_save
+          end
+        end
+      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.8'
+    VERSION = '2.1.2'
   end
 end

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

@@ -1,8 +1,10 @@
 class TestUnitColorScheme < Test::Unit::TestCase
   def test_default
     assert_equal({
-                   "success" => color("green", :bold => true),
-                   "failure" => color("red", :bold => true),
+                   "pass" => color("green", :foreground => false) +
+                                color("white", :bold => true),
+                   "failure" => color("red", :foreground => false) +
+                                color("white", :bold => true),
                    "pending" => color("magenta", :bold => true),
                    "omission" => color("blue", :bold => true),
                    "notification" => color("cyan", :bold => true),

data/test-unit/test/test_assertions.rb

@@ -1,6 +1,8 @@
+# -*- coding: utf-8 -*-
+#
 # Author:: Nathaniel Talbott.
 # Copyright:: Copyright (c) 2000-2002 Nathaniel Talbott. All rights reserved.
-#             Copyright (c) 2009 Kouhei Sutou.
+#             Copyright (c) 2009-2010 Kouhei Sutou. All rights reserved.
 # License:: Ruby license.
 
 require 'test/unit'
@@ -311,6 +313,21 @@ EOM
         end
       end
 
+      def test_assert_equal_with_different_encoding
+        utf8_string = "こんにちは"
+        unless utf8_string.respond_to?(:force_encoding)
+          omit("encoding test is for Ruby >= 1.9")
+        end
+        ascii_8bit_string = utf8_string.dup.force_encoding("ascii-8bit")
+        message = <<-EOM.chomp
+<"こんにちは">("UTF-8") expected but was
+<#{ascii_8bit_string.inspect}>("ASCII-8BIT").
+EOM
+        check_fails(message) do
+          assert_equal(utf8_string, ascii_8bit_string)
+        end
+      end
+
       def test_assert_raise_success
         return_value = nil
         check_nothing_fails(true) do
@@ -811,13 +828,19 @@ EOM
           end
           assert_in_delta(0.1, float_thing, 0.1)
         }
-        check_fails("message.\n<0.5> and\n<0.4> expected to be within\n<0.05> of each other.") {
+        check_fails("message.\n" +
+                    "<0.5> expected but was\n" +
+                    "<0.4> (tolerance <0.05>).\n" +
+                    "\n" +
+                    "Relation:\n" +
+                    "<<0.4> < <0.5>-<0.05>(0.45) <= <0.5>+<0.05>(0.55)>") {
           assert_in_delta(0.5, 0.4, 0.05, "message")
         }
         object = Object.new
+        inspected_object = AssertionMessage.convert(object)
         check_fails("The arguments must respond to to_f; " +
                     "the first float did not.\n" +
-                    "<#{object.inspect}>.respond_to?(:to_f) expected\n" +
+                    "<#{inspected_object}>.respond_to?(:to_f) expected\n" +
                     "(Class: <Object>)") {
           assert_in_delta(object, 0.4, 0.1)
         }
@@ -1121,17 +1144,40 @@ EOM
           assert_alias_method(object, :other, :original_method)
         end
 
-        check_fails("<#{object.inspect}>.nonexistent doesn't exist\n" +
+        inspected_object = AssertionMessage.convert(object)
+        check_fails("<#{inspected_object}>.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" +
+        check_fails("<#{inspected_object}>.nonexistent doesn't exist\n" +
                     "(Class: <Object>)") do
           assert_alias_method(object, :alias_method, :nonexistent)
         end
       end
 
+      def test_assert_path_exist
+        check_nothing_fails do
+          assert_path_exist(__FILE__)
+        end
+
+        nonexistent_file = __FILE__ + ".nonexistent"
+        check_fails("<#{nonexistent_file.inspect}> expected to exist") do
+          assert_path_exist(nonexistent_file)
+        end
+      end
+
+      def test_assert_path_not_exist
+        nonexistent_file = __FILE__ + ".nonexistent"
+        check_nothing_fails do
+          assert_path_not_exist(nonexistent_file)
+        end
+
+        check_fails("<#{__FILE__.inspect}> expected to not exist") do
+          assert_path_not_exist(__FILE__)
+        end
+      end
+
       private
       def add_failure(message, location=caller, options=nil)
         unless @catch_assertions

data/test-unit/test/ui/test_tap.rb

@@ -0,0 +1,33 @@
+require 'stringio'
+require 'test/unit/ui/tap/testrunner'
+
+class TestTap < Test::Unit::TestCase
+  def test_run
+    fail_line = nil
+    test_case = Class.new(Test::Unit::TestCase) do
+      def test_success
+        assert_equal(3, 1 + 2)
+      end
+
+      def test_fail; assert_equal(3, 1 - 2); end; fail_line = __LINE__
+    end
+    output = StringIO.new
+    runner = Test::Unit::UI::Tap::TestRunner.new(test_case.suite,
+                                                 :output => output)
+    result = runner.start; start_line = __LINE__
+    assert_equal(<<-EOR, output.string.gsub(/[\d\.]+ seconds/, "0.001 seconds"))
+1..2
+not ok 1 - test_fail(): <3> expected but was
+# Failure:
+# test_fail()
+#     [#{__FILE__}:#{fail_line}:in `test_fail'
+#      #{__FILE__}:#{start_line}:in `test_run']:
+# <3> expected but was
+# <-1>.
+ok 2 - test_success()
+# Finished in 0.001 seconds.
+# 2 tests, 2 assertions, 1 failures, 0 errors, 0 pendings, 0 omissions, 0 notifications
+EOR
+    assert_true(result.passed?)
+  end
+end

data/test-unit/test/util/test-output.rb

@@ -0,0 +1,11 @@
+require 'test/unit'
+
+class TestUnitOutput < Test::Unit::TestCase
+  def test_capture_output
+    assert_equal(["stdout\n", "stderr\n"],
+                 capture_output do
+                   puts("stdout")
+                   warn("stderr")
+                 end)
+  end
+end

data/test/test-patricia-trie.rb

@@ -202,4 +202,165 @@ class PatriciaTrieTest < Test::Unit::TestCase
     assert_equal([],
                  records.records.collect {|record| record["._key"]})
   end
+
+
+  def test_prefix_cursor
+    paths = Groonga::PatriciaTrie.create(:name => "Paths",
+                                         :key_type => 'ShortText')
+    root_path = paths.add('/')
+    tmp_path = paths.add('/tmp')
+    usr_bin_path = paths.add('/usr/bin')
+    usr_local_bin_path = paths.add('/usr/local/bin')
+
+    assert_prefix_cursor(["/usr/local/bin", "/usr/bin", "/tmp", "/"],
+                         paths, "/", {:order => :desc})
+    assert_prefix_cursor(["/", "/tmp", "/usr/bin", "/usr/local/bin"],
+                         paths, "/")
+    assert_prefix_cursor(["/usr/local/bin", "/usr/bin"],
+                         paths, "/usr/local",
+                         {:key_bytes => "/usr".size, :order => :desc})
+    assert_prefix_cursor(["/tmp", "/usr/bin"],
+                         paths, "/",
+                         {:offset => 1, :limit => 2})
+  end
+
+  def assert_prefix_cursor(expected, tables, prefix, options={})
+    actual = []
+    tables.open_prefix_cursor(prefix, options) do |cursor|
+      cursor.each do |record|
+        actual << record.key
+      end
+    end
+    assert_equal(expected, actual)
+  end
+
+  def test_rk_cursor
+    terms = Groonga::PatriciaTrie.create(:name => "Terms",
+                                         :key_type => 'ShortText')
+    ["インデックス",
+     "エヌグラム",
+     "エンジン",
+     "カネソナエタ",
+     "カノウ",
+     "キノウ",
+     "キョウカ",
+     "クミコミ",
+     "クミコム",
+     "グルンガ",
+     "ケンサク",
+     "ケンサクヨウキュウ",
+     "ゲンゴ",
+     "コウセイド",
+     "コウソク",
+     "コンパクト",
+     "サクセイ",
+     "ショリ",
+     "ショリケイ",
+     "ジッソウ",
+     "ジュンスイ",
+     "スクリプト",
+     "セッケイ",
+     "ゼンブン",
+     "タイプ",
+     "タンゴ",
+     "ダイキボ",
+     "テンチ",
+     "ディービーエムエス",
+     "トウ",
+     "トクチョウ",
+     "ブンショリョウ",
+     "ヨウキュウ"].each do |term|
+      terms.add(term)
+    end
+
+    assert_rk_cursor(["カネソナエタ",
+                      "カノウ",
+                      "キノウ",
+                      "キョウカ",
+                      "クミコミ",
+                      "クミコム",
+                      "ケンサク",
+                      "ケンサクヨウキュウ",
+                      "コウセイド",
+                      "コウソク",
+                      "コンパクト"],
+                     terms, "k")
+  end
+
+  def assert_rk_cursor(expected, tables, prefix, options={})
+    actual = []
+    tables.open_rk_cursor(prefix, options) do |cursor|
+      cursor.each do |record|
+        actual << record.key
+      end
+    end
+    assert_equal(expected, actual.sort)
+  end
+
+  def test_near_cursor
+    points = Groonga::PatriciaTrie.create(:name => "Points",
+                                          :key_type => 'WGS84GeoPoint')
+    ["130322053x504985073",
+     "130285021x504715091",
+     "130117012x504390088",
+     "130335016x504662007",
+     "130308044x504536008",
+     "130306053x504530043",
+     "130205016x505331054",
+     "130222054x505270050",
+     "130255017x504266011",
+     "130239038x504251015",
+     "129885039x503653023",
+     "129809022x504597055",
+     "130015001x504266057",
+     "130089012x505045070",
+     "130208017x504315098",
+     "130347036x504325073",
+     "130380061x505202034",
+     "129903045x504648034",
+     "130094061x505025099",
+     "130133052x505120058",
+     "130329069x505188046",
+     "130226001x503769013",
+     "129866001x504328017",
+     "129786048x504792049",
+     "129845056x504853081",
+     "130055008x504968095",
+     "130086003x504480071",
+     "129680021x504441006",
+     "129855010x504452003",
+     "130280013x505208029",
+     "129721099x504685024",
+     "129690039x504418033",
+     "130019020x505027021",
+     "130046026x505082073",
+     "130038025x505066028",
+     "129917001x504675017"].each do |point|
+      points.add(point)
+    end
+
+    assert_near_cursor(["129680021x504441006",
+                        "129690039x504418033",
+                        "129721099x504685024",
+                        "129786048x504792049",
+                        "129809022x504597055",
+                        "129845056x504853081",
+                        "129855010x504452003",
+                        "129866001x504328017",
+                        "129885039x503653023",
+                        "129903045x504648034"],
+                       points,
+                       "129786048x504792049",
+                       {:limit => 10})
+  end
+
+  def assert_near_cursor(expected, tables, prefix, options={})
+    actual = []
+    tables.open_near_cursor(prefix, options) do |cursor|
+      cursor.each do |record|
+        actual << record.key
+      end
+    end
+    assert_equal(expected, actual)
+  end
 end