rroonga 1.0.8 → 1.0.9

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

@@ -1,7 +1,7 @@
 #--
 #
 # Author:: Kouhei Sutou.
-# Copyright:: Copyright (c) 2009-2010 Kouhei Sutou <kou@clear-code.com>.
+# Copyright:: Copyright (c) 2009 Kouhei Sutou <kou@clear-code.com>.
 # License:: Ruby license.
 
 require 'test/unit/ui/testrunner'
@@ -24,7 +24,8 @@ module Test
 
           # Begins the test run.
           def start
-            result = super
+            setup_mediator
+            result = start_mediator
             def result.passed?
               true # for prove commend :<
             end
@@ -32,6 +33,11 @@ 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))
@@ -40,6 +46,10 @@ 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,7 +6,6 @@ module Test
       class TestRunner
         extend TestRunnerUtilities
 
-        attr_reader :listeners
         def initialize(suite, options={})
           if suite.respond_to?(:suite)
             @suite = suite.suite
@@ -14,30 +13,6 @@ 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,7 +9,6 @@ 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/version.rb

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

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

@@ -1,10 +1,8 @@
 class TestUnitColorScheme < Test::Unit::TestCase
   def test_default
     assert_equal({
-                   "pass" => color("green", :foreground => false) +
-                                color("white", :bold => true),
-                   "failure" => color("red", :foreground => false) +
-                                color("white", :bold => true),
+                   "success" => color("green", :bold => true),
+                   "failure" => color("red", :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,8 +1,6 @@
-# -*- coding: utf-8 -*-
-#
 # Author:: Nathaniel Talbott.
 # Copyright:: Copyright (c) 2000-2002 Nathaniel Talbott. All rights reserved.
-#             Copyright (c) 2009-2010 Kouhei Sutou. All rights reserved.
+#             Copyright (c) 2009 Kouhei Sutou.
 # License:: Ruby license.
 
 require 'test/unit'
@@ -313,21 +311,6 @@ 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
@@ -828,19 +811,13 @@ EOM
           end
           assert_in_delta(0.1, float_thing, 0.1)
         }
-        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)>") {
+        check_fails("message.\n<0.5> and\n<0.4> expected to be within\n<0.05> of each other.") {
           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" +
-                    "<#{inspected_object}>.respond_to?(:to_f) expected\n" +
+                    "<#{object.inspect}>.respond_to?(:to_f) expected\n" +
                     "(Class: <Object>)") {
           assert_in_delta(object, 0.4, 0.1)
         }
@@ -1144,40 +1121,17 @@ EOM
           assert_alias_method(object, :other, :original_method)
         end
 
-        inspected_object = AssertionMessage.convert(object)
-        check_fails("<#{inspected_object}>.nonexistent doesn't exist\n" +
+        check_fails("<#{object.inspect}>.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" +
+        check_fails("<#{object.inspect}>.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/test-column.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2009-2010  Kouhei Sutou <kou@clear-code.com>
+# Copyright (C) 2009-2011  Kouhei Sutou <kou@clear-code.com>
 #
 # This library is free software; you can redistribute it and/or
 # modify it under the terms of the GNU Lesser General Public
@@ -286,6 +286,36 @@ class ColumnTest < Test::Unit::TestCase
     assert_false(post["hidden"])
   end
 
+  def test_indexes
+    Groonga::Schema.define do |schema|
+      schema.create_table("Comments") do |table|
+        table.short_text("title")
+      end
+    end
+    title = Groonga["Comments.title"]
+    assert_equal([], title.indexes)
+
+    Groonga::Schema.define do |schema|
+      schema.create_table("Terms",
+                          :type => :patricia_trie,
+                          :default_tokenizer => "TokenBigram") do |table|
+        table.index("Comments.title")
+      end
+    end
+    assert_equal([Groonga["Terms.Comments_title"]],
+                 title.indexes)
+
+    Groonga::Schema.define do |schema|
+      schema.create_table("Titles",
+                          :type => :hash) do |table|
+        table.index("Comments.title")
+      end
+    end
+    assert_equal([Groonga["Titles.Comments_title"],
+                  Groonga["Terms.Comments_title"]],
+                 title.indexes)
+  end
+
   private
   def assert_content_search(expected_records, term)
     records = @bookmarks_index_content.search(term).records

data/test/test-context-select.rb

@@ -19,35 +19,58 @@ class ContextSelectTest < Test::Unit::TestCase
   setup :setup_database
   setup
   def setup_data
-    @books = Groonga::Hash.create(:name => "Books", :key_type => "ShortText")
-    @books.define_column("published", "Time")
-    @users = Groonga::Hash.create(:name => "Users", :key_type => "ShortText")
-    @users.define_column("book", "Books")
+    Groonga::Schema.define do |schema|
+      schema.create_table("Books",
+                          :type => :hash, :key_type => "ShortText") do |table|
+        table.time("published")
+      end
+
+      schema.create_table("Users",
+                          :type => :hash, :key_type => "ShortText") do |table|
+        table.reference("book", "Books")
+      end
+
+      schema.create_table("Bigram",
+                          :type => :patricia_trie,
+                          :key_type => "ShortText",
+                          :default_tokenizer => "TokenBigramSplitSymbolAlpha") do |table|
+        table.index("Books._key")
+      end
+    end
+
+    @books = Groonga["Books"]
+    @users = Groonga["Users"]
 
     @books.add("the groonga book", :published => Time.parse("2010/04/01"))
+    @books.add("the groonga book (2)", :published => Time.parse("2011/04/01"))
+
     @users.add("morita", :book => "the groonga book")
     @users.add("gunyara-kun", :book => "the groonga book")
     @users.add("yu")
+    @users.add("ryoqun", :book => "the groonga book (2)")
   end
 
   def test_no_option
     result = context.select(@users)
-    assert_equal([3,
+    assert_equal([4,
                   [{"_id" => 1, "_key" => "morita",
                      "book" => "the groonga book"},
                    {"_id" => 2, "_key" => "gunyara-kun",
                      "book" => "the groonga book"},
                    {"_id" => 3, "_key" => "yu",
-                     "book" => ""}]],
+                     "book" => ""},
+                   {"_id" => 4, "_key" => "ryoqun",
+                     "book" => "the groonga book (2)"}]],
                  [result.n_hits, result.records])
   end
 
   def test_output_columns
     result = context.select(@users, :output_columns => ["_key"])
-    assert_equal([3,
+    assert_equal([4,
                   [{"_key" => "morita"},
                    {"_key" => "gunyara-kun"},
-                   {"_key" => "yu"}]],
+                   {"_key" => "yu"},
+                   {"_key" => "ryoqun"}]],
                  [result.n_hits, result.records])
   end
 
@@ -58,15 +81,18 @@ class ContextSelectTest < Test::Unit::TestCase
                             :drill_down_output_columns => "_key",
                             :drill_down_limit => 10)
     drill_down = normalize_drill_down(result.drill_down)
-    assert_equal([3,
+    assert_equal([4,
                   [{"_key" => "morita"},
                    {"_key" => "gunyara-kun"},
-                   {"_key" => "yu"}],
+                   {"_key" => "yu"},
+                   {"_key" => "ryoqun"}],
                   {
-                    "_key" => [3, [{"_key" => "morita"},
+                    "_key" => [4, [{"_key" => "morita"},
                                    {"_key" => "gunyara-kun"},
-                                   {"_key" => "yu"}]],
-                    "book" => [1, [{"_key" => "the groonga book"}]],
+                                   {"_key" => "yu"},
+                                   {"_key" => "ryoqun"}]],
+                    "book" => [2, [{"_key" => "the groonga book"},
+                                   {"_key" => "the groonga book (2)"}]],
                   },
                  ],
                  [result.n_hits, result.records, drill_down])
@@ -95,11 +121,16 @@ class ContextSelectTest < Test::Unit::TestCase
                     "_id" => 1,
                     "_key" => "the groonga book",
                     "published" => Time.parse("2010/04/01"),
+                  },
+                  {
+                    "_id" => 2,
+                    "_key" => "the groonga book (2)",
+                    "published" => Time.parse("2011/04/01"),
                   }],
                  result.records)
   end
 
-  def test_invalid_select
+  def test_invalid
     assert_raise(Groonga::SyntaxError) do
       context.select(@books, :query => "<")
     end

data/test/test-context.rb

@@ -29,6 +29,42 @@ class ContextTest < Test::Unit::TestCase
     assert_equal(Groonga::Encoding::UTF8, context.encoding)
   end
 
+  def test_create_database
+    db_path = @tmp_dir + "db"
+    assert_not_predicate(db_path, :exist?)
+    context = Groonga::Context.new
+    assert_equal(nil, context.database)
+    database = context.create_database(db_path.to_s)
+    assert_predicate(db_path, :exist?)
+    assert_not_predicate(database, :closed?)
+    assert_equal(database, context.database)
+  end
+
+  def test_create_temporary_database
+    before_files = @tmp_dir.children
+    context = Groonga::Context.new
+    database = context.create_database
+    assert_nil(database.name)
+    assert_equal(before_files, @tmp_dir.children)
+  end
+
+  def test_open_database
+    db_path = @tmp_dir + "db"
+    database = Groonga::Database.create(:path => db_path.to_s)
+    database.close
+
+    assert_predicate(database, :closed?)
+    called = false
+    context = Groonga::Context.new
+    context.open_database(db_path.to_s) do |_database|
+      database = _database
+      assert_not_predicate(database, :closed?)
+      called = true
+    end
+    assert_true(called)
+    assert_predicate(database, :closed?)
+  end
+
   def test_encoding
     context = Groonga::Context.new
     assert_equal(Groonga::Encoding.default, context.encoding)

data/test/test-database.rb

@@ -38,7 +38,9 @@ class DatabaseTest < Test::Unit::TestCase
   def test_open
     db_path = @tmp_dir + "db"
     database = Groonga::Database.create(:path => db_path.to_s)
+    database.close
 
+    assert_predicate(database, :closed?)
     called = false
     Groonga::Database.open(db_path.to_s) do |_database|
       database = _database
@@ -49,6 +51,17 @@ class DatabaseTest < Test::Unit::TestCase
     assert_predicate(database, :closed?)
   end
 
+  def test_close
+    db_path = @tmp_dir + "db"
+    database = Groonga::Database.create(:path => db_path.to_s)
+    database.close
+
+    database = Groonga::Database.open(db_path.to_s)
+    assert_not_predicate(database, :closed?)
+    database.close
+    assert_predicate(database, :closed?)
+  end
+
   def test_new
     db_path = @tmp_dir + "db"
     assert_raise(Groonga::NoSuchFileOrDirectory) do

data/test/test-expression-builder.rb

@@ -24,30 +24,41 @@ class ExpressionBuilderTest < Test::Unit::TestCase
     @pets = Groonga::Hash.create(:name => "Pets", :key_type => "ShortText")
     @pets.define_column("name", "ShortText")
 
+    @sections = Groonga::PatriciaTrie.create(:name => "Sections",
+                                             :key_type => "ShortText")
+
     @users = Groonga::Hash.create(:name => "Users", :key_type => "ShortText")
     @name = @users.define_column("name", "ShortText")
     @hp = @users.define_column("hp", "UInt32")
-    @users.define_column("pet", @pets)
+    @user_pet = @users.define_column("pet", @pets)
+    @user_section = @users.define_column("section", @sections)
 
     @terms = Groonga::PatriciaTrie.create(:name => "Terms",
-                                          :default_tokenizer => "TokenBigram")
+                                          :default_tokenizer => "TokenBigram",
+                                          :key_type => "ShortText")
     @terms.define_index_column("user_name", @users, :source => @name)
 
     @bookmarks = Groonga::Array.create(:name => "Bookmarks")
     @bookmarks.define_column("user", @users)
     @bookmarks.define_column("uri", "ShortText")
+
+    @sections.define_index_column("user_section", @users,
+                                  :source => @user_section)
   end
 
   def setup_data
     @morita = @users.add("morita",
                          :name => "mori daijiro",
-                         :hp => 100)
+                         :hp => 100,
+                         :section => "search/core")
     @gunyara_kun = @users.add("gunyara-kun",
                               :name => "Tasuku SUENAGA",
-                              :hp => 150)
+                              :hp => 150,
+                              :section => "suggest/all")
     @yu = @users.add("yu",
                      :name => "Yutaro Shimamura",
-                     :hp => 200)
+                     :hp => 200,
+                     :section => "search/all")
 
     @groonga = @bookmarks.add(:user => @morita, :uri => "http://groonga.org/")
     @ruby = @bookmarks.add(:user => @morita, :uri => "http://ruby-lang.org/")
@@ -118,6 +129,22 @@ class ExpressionBuilderTest < Test::Unit::TestCase
                  result.collect {|record| record.key.key})
   end
 
+  def test_prefix_saerch
+    result = @users.select do |record|
+      record.section.prefix_search("search")
+    end
+    assert_equal(["morita", "yu"].sort,
+                 result.collect {|record| record.key.key}.sort)
+  end
+
+  def test_suffix_search
+    result = @users.select do |record|
+      record.name.suffix_search("jiro")
+    end
+    assert_equal(["morita"].sort,
+                 result.collect {|record| record.key.key}.sort)
+  end
+
   def test_query_string
     result = @users.select("name:@ro")
     assert_equal(["morita", "yu"],