activegroonga 0.0.7 → 1.0.0

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

@@ -7,6 +7,7 @@ require 'test/unit'
 module Test
   module Unit
     class TestTestCase < TestCase
+      self.test_order = :random
       def test_creation
         tc = Class.new(TestCase) do
           def test_with_arguments(arg1, arg2)
@@ -469,25 +470,68 @@ module Test
       end
 
       def test_defined_order
-        keep_test_order do
-          test_case = Class.new(Test::Unit::TestCase) do
-            def test_z
-            end
+        test_case = Class.new(Test::Unit::TestCase) do
+          def test_z
+          end
 
-            def test_1
-            end
+          def test_1
+          end
 
-            def test_a
-            end
+          def test_a
+          end
+        end
+
+        assert_equal(["test_1", "test_a", "test_z"],
+                     test_case.suite.tests.collect {|test| test.method_name})
+
+        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
 
-          assert_equal(["test_1", "test_a", "test_z"],
-                       test_case.suite.tests.collect {|test| test.method_name})
+          test "include parenthesis" do
+          end
 
-          test_case.test_order = :defined
-          assert_equal(["test_z", "test_1", "test_a"],
-                       test_case.suite.tests.collect {|test| test.method_name})
+          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_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
@@ -495,13 +539,6 @@ module Test
         add_assertion
         raise AssertionFailedError.new(message) unless passed
       end
-
-      def keep_test_order
-        order = TestCase.test_order
-        yield
-      ensure
-        TestCase.test_order = order
-      end
     end
   end
 end

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'
@@ -248,32 +250,81 @@ 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
+
+      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
 
@@ -777,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)
         }
@@ -1063,8 +1120,66 @@ 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
+
+        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("<#{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)
+      def add_failure(message, location=caller, options=nil)
         unless @catch_assertions
           super
         end

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/active-groonga-test-utils.rb

@@ -2,8 +2,7 @@
 #
 # This library is free software; you can redistribute it and/or
 # modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
+# License version 2.1 as published by the Free Software Foundation.
 #
 # This library is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -33,14 +32,15 @@ module ActiveGroongaTestUtils
 
     setup_tmp_directory
     setup_database_directory
+    setup_database
     setup_tables_directory
     setup_metadata_directory
 
-    setup_database
     setup_users_table
     setup_bookmarks_table
     setup_bookmarks_index_tables
     setup_tasks_table
+    setup_sites_table
 
     setup_user_records
     setup_bookmark_records
@@ -54,66 +54,64 @@ module ActiveGroongaTestUtils
   end
 
   def setup_database_directory
-    @database_dir = @tmp_dir + "database"
+    @database_dir = @tmp_dir + "groonga"
     FileUtils.mkdir_p(@database_dir.to_s)
-    ActiveGroonga::Base.database_directory = @database_dir.to_s
+  end
+
+  def setup_database
+    @database_path = @database_dir + "database"
+    @database = Groonga::Database.create(:path => @database_path.to_s)
+    ActiveGroonga::Base.database_path = @database_path.to_s
   end
 
   def setup_tables_directory
-    @tables_dir = @database_dir + "tables"
+    @tables_dir = Pathname("#{@database_path}.tables")
     FileUtils.mkdir_p(@tables_dir.to_s)
   end
 
   def setup_metadata_directory
-    @metadata_dir = @database_dir + "metadata"
+    @metadata_dir = Pathname("#{@database_path}.metadata")
     FileUtils.mkdir_p(@metadata_dir.to_s)
   end
 
-  def setup_database
-    @database_path = @database_dir + "database.groonga"
-    @database = Groonga::Database.create(:path => @database_path.to_s)
-
-    ActiveGroonga::Schema.initialize_schema_management_tables
-  end
-
   def setup_users_table
-    @users_path = @tables_dir + "users.groonga"
+    @users_path = @tables_dir + "users"
     @users = Groonga::Array.create(:name => "users",
                                    :path => @users_path.to_s,
                                    :sub_records => true)
 
-    columns_dir = @tables_dir + "users" + "columns"
+    columns_dir = @tables_dir + "users.columns"
     columns_dir.mkpath
 
-    @name_column_path = columns_dir + "name.groonga"
+    @name_column_path = columns_dir + "name"
     @name_column = @users.define_column("name", "ShortText",
                                         :path => @name_column_path.to_s)
   end
 
   def setup_bookmarks_table
-    @bookmarks_path = @tables_dir + "bookmarks.groonga"
+    @bookmarks_path = @tables_dir + "bookmarks"
     @bookmarks = Groonga::Array.create(:name => "bookmarks",
                                        :path => @bookmarks_path.to_s,
                                        :sub_records => true)
 
-    columns_dir = @tables_dir + "bookmarks" + "columns"
+    columns_dir = @tables_dir + "bookmarks.columns"
     columns_dir.mkpath
 
-    @uri_column_path = columns_dir + "uri.groonga"
+    @uri_column_path = columns_dir + "uri"
     @uri_column = @bookmarks.define_column("uri", "ShortText",
                                            :path => @uri_column_path.to_s)
 
-    @comment_column_path = columns_dir + "comment.groonga"
+    @comment_column_path = columns_dir + "comment"
     @comment_column =
       @bookmarks.define_column("comment", "Text",
                                :path => @comment_column_path.to_s)
 
-    @content_column_path = columns_dir + "content.groonga"
+    @content_column_path = columns_dir + "content"
     @content_column =
       @bookmarks.define_column("content", "LongText",
                                :path => @content_column_path.to_s)
 
-    @user_column_path = columns_dir + "user.groonga"
+    @user_column_path = columns_dir + "user"
     @user_column =
       @bookmarks.define_column("user", @users,
                                :path => @user_column_path.to_s)
@@ -122,31 +120,28 @@ module ActiveGroongaTestUtils
   end
 
   def define_timestamp(table, columns_dir)
-    created_at_column_path = columns_dir + "created_at.groonga"
+    created_at_column_path = columns_dir + "created_at"
     table.define_column("created_at", "Time",
                         :path => created_at_column_path.to_s)
 
-    updated_at_column_path = columns_dir + "updated_at.groonga"
+    updated_at_column_path = columns_dir + "updated_at"
     table.define_column("updated_at", "Time",
                         :path => updated_at_column_path.to_s)
   end
 
   def setup_bookmarks_index_tables
-    @terms_path = @tables_dir + "terms.groonga"
+    @terms_path = @tables_dir + "terms"
     @terms = Groonga::PatriciaTrie.create(:name => "terms",
                                           :key_type => "ShortText",
                                           :path => @terms_path.to_s,
                                           :default_tokenizer => "TokenBigram")
 
-    columns_dir = @tables_dir + "terms" + "columns"
-    bookmarks_index_dir = columns_dir + "bookmarks"
-    bookmarks_index_dir.mkpath
-
-    @bookmarks_content_index_column_path =
-      bookmarks_index_dir + "content.groonga"
+    columns_dir = @tables_dir + "terms.columns"
+    columns_dir.mkpath
+    @bookmarks_content_index_column_path = columns_dir + "bookmarks_content"
     path = @bookmarks_content_index_column_path.to_s
     @bookmarks_content_index_column =
-      @terms.define_index_column("bookmarks/content", @bookmarks,
+      @terms.define_index_column("bookmarks_content", @bookmarks,
                                  :with_section => true,
                                  :with_weight => true,
                                  :with_position => true,
@@ -155,19 +150,36 @@ module ActiveGroongaTestUtils
   end
 
   def setup_tasks_table
-    @tasks_path = @tables_dir + "tasks.groonga"
+    @tasks_path = @tables_dir + "tasks"
     @tasks = Groonga::Array.create(:name => "tasks",
                                    :path => @tasks_path.to_s,
                                    :sub_records => true)
 
-    columns_dir = @tables_dir + "tasks" + "columns"
+    columns_dir = @tables_dir + "tasks.columns"
     columns_dir.mkpath
 
-    @name_column_path = columns_dir + "name.groonga"
+    @name_column_path = columns_dir + "name"
     @name_column = @tasks.define_column("name", "ShortText",
                                         :path => @name_column_path.to_s)
   end
 
+  def setup_sites_table
+    @sites_path = @tables_dir + "sites"
+    @sites = Groonga::Hash.create(:name => "sites",
+                                  :key_type => "ShortText",
+                                  :path => @sites_path.to_s)
+
+    columns_dir = @tables_dir + "sites.columns"
+    columns_dir.mkpath
+
+    @title_column_path = columns_dir + "title"
+    @title_column = @sites.define_column("title", "ShortText",
+                                         :path => @title_column_path.to_s)
+    @score_column_path = columns_dir + "score"
+    @score_column = @sites.define_column("score", "UInt32",
+                                         :path => @score_column_path.to_s)
+  end
+
   def setup_user_records
     @user_records = {}
 
@@ -197,10 +209,12 @@ module ActiveGroongaTestUtils
       remove_const(:User) if const_defined?(:User)
       remove_const(:Bookmark) if const_defined?(:Bookmark)
       remove_const(:Task) if const_defined?(:Task)
+      remove_const(:Site) if const_defined?(:Site)
     end
     load((base_dir + 'user.rb').to_s)
     load((base_dir + 'bookmark.rb').to_s)
     load((base_dir + 'task.rb').to_s)
+    load((base_dir + 'site.rb').to_s)
   end
 
   def teardown_sand_box