rroonga 9.0.3 → 11.0.0

data/test/run-test.rb

@@ -17,8 +17,6 @@
 
 $VERBOSE = true
 
-$KCODE = "u" if RUBY_VERSION < "1.9"
-
 base_dir = File.expand_path(File.join(File.dirname(__FILE__), ".."))
 ext_dir = File.join(base_dir, "ext", "groonga")
 lib_dir = File.join(base_dir, "lib")
@@ -39,7 +37,7 @@ end
 require "test-unit"
 require "test/unit/priority"
 
-Test::Unit::Priority.enable
+Test::Unit::Priority.enable unless ENV["CI"]
 
 
 groonga_command_dir = File.join(base_dir, "..", "groonga-command")

data/test/test-accessor.rb

@@ -19,12 +19,13 @@ class AccessorTest < Test::Unit::TestCase
 
   def setup
     setup_database
-    @posts = Groonga::Hash.create(:name => "Posts", :key_type => "ShortText")
+    @posts = Groonga::Hash.create(:name => "Posts",
+                                  :key_type => "ShortText",
+                                  :value_type => "UInt32")
+    @grouped_posts = @posts.group("_key")
     @id = @posts.column("_id")
-  end
-
-  def teardown
-    @id = nil
+    @key = @posts.column("_key")
+    @value = @posts.column("_value")
   end
 
   def test_name
@@ -51,9 +52,8 @@ class AccessorTest < Test::Unit::TestCase
 
   sub_test_case "#key_accessor?" do
     test "true" do
-      key = @posts.column("_key")
       assert do
-        key.key_accessor?
+        @key.key_accessor?
       end
     end
 
@@ -63,4 +63,60 @@ class AccessorTest < Test::Unit::TestCase
       end
     end
   end
+
+  sub_test_case "#id_accessor?" do
+    test "true" do
+      assert do
+        @id.id_accessor?
+      end
+    end
+
+    test "false" do
+      assert do
+        not @key.id_accessor?
+      end
+    end
+  end
+
+  sub_test_case "#value_accessor?" do
+    test "true" do
+      assert do
+        @value.value_accessor?
+      end
+    end
+
+    test "false" do
+      assert do
+        not @key.value_accessor?
+      end
+    end
+  end
+
+  sub_test_case "#score_accessor?" do
+    test "true" do
+      assert do
+        @posts.select.column("_score").score_accessor?
+      end
+    end
+
+    test "false" do
+      assert do
+        not @key.score_accessor?
+      end
+    end
+  end
+
+  sub_test_case "#n_sub_records_accessor?" do
+    test "true" do
+      assert do
+        @grouped_posts.column("_nsubrecs").n_sub_records_accessor?
+      end
+    end
+
+    test "false" do
+      assert do
+        not @key.n_sub_records_accessor?
+      end
+    end
+  end
 end

data/test/test-column.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2009-2016  Kouhei Sutou <kou@clear-code.com>
+# Copyright (C) 2009-2020  Sutou Kouhei <kou@clear-code.com>
 # Copyright (C) 2016  Masafumi Yokoyama <yokoyama@clear-code.com>
 #
 # This library is free software; you can redistribute it and/or
@@ -307,6 +307,17 @@ class ColumnTest < Test::Unit::TestCase
     assert_false(post["hidden"])
   end
 
+  def test_float32
+    need_groonga(10, 0, 2)
+
+    numbers = Groonga::Array.create(:name => "Numbers")
+    numbers.define_column("data", "Float32")
+
+    number = numbers.add
+    number["data"] = 1.1
+    assert_in_delta(1.1, number["data"])
+  end
+
   def test_indexes
     Groonga::Schema.define do |schema|
       schema.create_table("Comments") do |table|

data/test/test-context.rb

@@ -132,6 +132,31 @@ class ContextTest < Test::Unit::TestCase
     assert_equal(-1, context.match_escalation_threshold)
   end
 
+  sub_test_case("#force_match_escalation?") do
+    def setup
+      default_force_match_escalation = context.force_match_escalation?
+      begin
+        yield
+      ensure
+        context.force_match_escalation = default_force_match_escalation
+      end
+    end
+
+    def test_true
+      context.force_match_escalation = true
+      assert do
+        context.force_match_escalation?
+      end
+    end
+
+    def test_false
+      context.force_match_escalation = false
+      assert do
+        not context.force_match_escalation?
+      end
+    end
+  end
+
   def test_close
     context = Groonga::Context.new
     assert_false(context.closed?)

data/test/test-exception.rb

@@ -108,11 +108,16 @@ class TooManyOpenFilesTest < Test::Unit::TestCase
   include GroongaTestUtils
 
   def setup
+    @sub_context = nil
+    unless Process.const_defined?(:RLIMIT_NOFILE)
+      omit("No Process::RLIMIT_NOFILE")
+    end
     setup_database
     @sub_context = create_sub_context
   end
 
   def teardown
+    return if @sub_context.nil?
     @sub_context.database.close
     @sub_context.close
   end

data/test/test-flushable.rb

@@ -18,32 +18,77 @@ class FlushableTest < Test::Unit::TestCase
 
   setup :setup_database
 
+  def normalize_query_log(log)
+    log.lines.collect do |line|
+      line.chomp.gsub(/\A.*?:\d+ /, "")
+    end
+  end
+
   def test_flush_table
     table = Groonga::Hash.create
-    assert_nothing_raised do
+    log = collect_query_log do
       table.flush
     end
+    assert_equal([
+                   "flush[(anonymous:table:hash_key)]",
+                 ],
+                 normalize_query_log(log))
   end
 
   def test_flush_column
     table = Groonga::Hash.create(:name => "Users")
     column = table.define_column("name", "ShortText")
-    assert_nothing_raised do
+    log = collect_query_log do
       column.flush
     end
+    assert_equal([
+                   "flush[Users.name]",
+                 ],
+                 normalize_query_log(log))
   end
 
   def test_flush_database
-    assert_nothing_raised do
+    table = Groonga::Hash.create(:name => "Users")
+    table.define_column("name", "ShortText")
+    log = collect_query_log do
       @database.flush
     end
+    assert_equal([
+                   "flush[Users.name]",
+                   "flush[Users]",
+                   "flush[(anonymous:table:dat_key)]",
+                   "flush[(anonymous:column:var_size)]",
+                   "flush[(anonymous:table:hash_key)]",
+                   "flush[(anonymous:column:var_size)]",
+                   "flush[(DB)]",
+                 ],
+                 normalize_query_log(log))
   end
 
   def test_flush_not_recursive
-    table = Groonga::Hash.create
-    table.extend(Groonga::Flushable)
-    assert_nothing_raised do
+    table = Groonga::Hash.create(:name => "Users")
+    table.define_column("name", "ShortText")
+    log = collect_query_log do
       table.flush(:recursive => false)
     end
+    assert_equal([
+                   "flush[Users]",
+                 ],
+                 normalize_query_log(log))
+  end
+
+  def test_flush_dependent
+    referenced_table = Groonga::Hash.create(name: "Names")
+    table = Groonga::Hash.create(:name => "Users")
+    table.define_column("name", referenced_table)
+    log = collect_query_log do
+      table.flush(:recursive => false, :dependent => true)
+    end
+    assert_equal([
+                   "flush[Names]",
+                   "flush[Users.name]",
+                   "flush[Users]",
+                 ],
+                 normalize_query_log(log))
   end
 end

data/test/test-index-column.rb

@@ -1,6 +1,4 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2009-2016  Kouhei Sutou <kou@clear-code.com>
+# Copyright (C) 2009-2021  Sutou Kouhei <kou@clear-code.com>
 # Copyright (C) 2016  Masafumi Yokoyama <yokoyama@clear-code.com>
 #
 # This library is free software; you can redistribute it and/or
@@ -33,11 +31,11 @@ class IndexColumnTest < Test::Unit::TestCase
       articles = Groonga::Array.create(:name => "Articles")
       articles.define_column("content", "Text")
 
-      terms = Groonga::Hash.create(:name => "Terms",
-                                   :key_type => "ShortText",
-                                   :default_tokenizer => "TokenBigram")
-      @index = terms.define_index_column("content", articles,
-                                         :with_section => true)
+      @terms = Groonga::Hash.create(:name => "Terms",
+                                    :key_type => "ShortText",
+                                    :default_tokenizer => "TokenBigram")
+      @index = @terms.define_index_column("content", articles,
+                                          :with_section => true)
     end
 
     def test_index?
@@ -63,6 +61,20 @@ class IndexColumnTest < Test::Unit::TestCase
         not @index.data?
       end
     end
+
+    sub_test_case("#lexicon?") do
+      def test_true
+        assert do
+          @terms.lexicon?
+        end
+      end
+
+      def test_false
+        assert do
+          not @index.lexicon?
+        end
+      end
+    end
   end
 
   class CRUDTest < self
@@ -189,6 +201,8 @@ class IndexColumnTest < Test::Unit::TestCase
   end
 
   def test_reindex
+    check_mecab_availability
+
     Groonga::Schema.define do |schema|
       schema.create_table("Memos", :type => :array) do |table|
         table.short_text("title")
@@ -438,11 +452,35 @@ class IndexColumnTest < Test::Unit::TestCase
                      ])
       end
 
+      def test_large
+        Groonga::Schema.define do |schema|
+          schema.create_table("Tags",
+                              :type => :patricia_trie,
+                              :key_type => "ShortText") do |table|
+            table.index("Articles.tags",
+                        :name => "large",
+                        :size => :large)
+            table.index("Articles.tags",
+                        :name => "default")
+          end
+        end
+
+        assert_equal([
+                       true,
+                       false,
+                     ],
+                     [
+                       context["Tags.large"].large?,
+                       context["Tags.default"].large?,
+                     ])
+      end
+
       def test_invalid
         Groonga::Schema.create_table("Tags",
                                      :type => :patricia_trie,
                                      :key_type => "ShortText")
-        message = ":size must be nil, :small or :medium: <invalid>"
+        message =
+          ":size must be nil, :small, :medium or :large: <invalid>"
         assert_raise(ArgumentError.new(message)) do
           tags = context["Tags"]
           tags.define_index_column("small",
@@ -818,5 +856,28 @@ class IndexColumnTest < Test::Unit::TestCase
                    ">",
                    index.inspect)
     end
+
+    def test_large_size
+      Groonga::Schema.define do |schema|
+        schema.create_table("Tags",
+                            :type => :hash,
+                            :key_type => "ShortText") do |tags|
+          tags.index("Articles.tag", :size => :large)
+        end
+      end
+
+      index = context["Tags.Articles_tag"]
+      source_column_names = index.sources.collect(&:local_name).join(",")
+      assert_equal("\#<Groonga::IndexColumn " +
+                   "id: <#{index.id}>, " +
+                   "name: <#{index.name}>, " +
+                   "path: <#{index.path}>, " +
+                   "domain: <#{index.domain.name}>, " +
+                   "range: <#{index.range.name}>, " +
+                   "flags: <LARGE>, " +
+                   "sources: <#{source_column_names}>" +
+                   ">",
+                   index.inspect)
+    end
   end
 end

data/test/test-index-cursor.rb

@@ -1,4 +1,5 @@
 # Copyright (C) 2012-2017  Kouhei Sutou <kou@clear-code.com>
+# Copyright (C) 2019  Horimoto Yasuhiro <horimoto@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
@@ -155,6 +156,31 @@ class IndexCursorTest < Test::Unit::TestCase
     assert_equal("l", term.key)
   end
 
+  sub_test_case(".set_min?") do
+    def setup
+      default_set_min = Groonga::IndexCursor.set_min?
+      begin
+        yield
+      ensure
+        Groonga::IndexCursor.set_min = default_set_min
+      end
+    end
+
+    def test_true
+      Groonga::IndexCursor.set_min = true
+      assert do
+        Groonga::IndexCursor.set_min?
+      end
+    end
+
+    def test_false
+      Groonga::IndexCursor.set_min = false
+      assert do
+        not Groonga::IndexCursor.set_min?
+      end
+    end
+  end
+
   private
   def create_hashes(keys, values)
     hashes = []

data/test/test-logger.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2010-2018  Kouhei Sutou <kou@clear-code.com>
+# Copyright (C) 2010-2019  Kouhei Sutou <kou@clear-code.com>
 # Copyright (C) 2016  Masafumi Yokoyama <yokoyama@clear-code.com>
 #
 # This library is free software; you can redistribute it and/or
@@ -21,15 +21,18 @@ class LoggerTest < Test::Unit::TestCase
     @default_log_path = Groonga::Logger.path
     @default_log_max_level = Groonga::Logger.max_level
     @default_rotate_threshold_size = Groonga::Logger.rotate_threshold_size
+    @default_flags = Groonga::Logger.flags
   end
 
   def teardown
     Groonga::Logger.path = @default_log_path
     Groonga::Logger.max_level = @default_log_max_level
     Groonga::Logger.rotate_threshold_size = @default_rotate_threshold_size
+    Groonga::Logger.flags = @default_flags
   end
 
   def test_reopen
+    only_not_windows
     Groonga::Logger.unregister
     Groonga::Logger.path = @log_path.to_s
     if @log_path.exist?
@@ -46,12 +49,22 @@ class LoggerTest < Test::Unit::TestCase
     assert_equal(:debug, Groonga::Logger.max_level)
   end
 
-  def test_flags
-    default_flags = Groonga::Logger::Flags::TIME |
-                      Groonga::Logger::Flags::MESSAGE
-    assert_equal(default_flags, Groonga::Logger.flags)
-    Groonga::Logger.flags = Groonga::Logger::Flags::LOCATION
-    assert_equal(Groonga::Logger::Flags::LOCATION, Groonga::Logger.flags)
+  sub_test_case ".flags" do
+    def test_default
+      assert_equal(Groonga::Logger::Flags::TIME |
+                   Groonga::Logger::Flags::MESSAGE,
+                   Groonga::Logger.flags)
+    end
+
+    def test_location
+      Groonga::Logger.flags = Groonga::Logger::Flags::LOCATION
+      assert_equal(Groonga::Logger::Flags::LOCATION, Groonga::Logger.flags)
+    end
+
+    def test_thread_id
+      Groonga::Logger.flags = Groonga::Logger::Flags::THREAD_ID
+      assert_equal(Groonga::Logger::Flags::THREAD_ID, Groonga::Logger.flags)
+    end
   end
 
   sub_test_case ".log" do
@@ -89,7 +102,8 @@ class LoggerTest < Test::Unit::TestCase
 
     test "default location" do
       locations = []
-      Groonga::Logger.register do |event, level, time, title, message, location|
+      Groonga::Logger.register(thread_id: false) do |*args|
+        location = args[5]
         locations << location
       end
       Groonga::Logger.log("message"); line = __LINE__
@@ -102,7 +116,8 @@ class LoggerTest < Test::Unit::TestCase
 
     test ":file" do
       locations = []
-      Groonga::Logger.register do |event, level, time, title, message, location|
+      Groonga::Logger.register(thread_id: false) do |*args|
+        location = args[5]
         locations << location
       end
       Groonga::Logger.log("message", :file => "file.rb")
@@ -118,7 +133,8 @@ class LoggerTest < Test::Unit::TestCase
 
     test ":line" do
       locations = []
-      Groonga::Logger.register do |event, level, time, title, message, location|
+      Groonga::Logger.register(thread_id: false) do |*args|
+        location = args[5]
         locations << location
       end
       Groonga::Logger.log("message", :line => 100)
@@ -134,7 +150,8 @@ class LoggerTest < Test::Unit::TestCase
 
     test ":function" do
       locations = []
-      Groonga::Logger.register do |event, level, time, title, message, location|
+      Groonga::Logger.register(thread_id: false) do |*args|
+        location = args[5]
         locations << location
       end
       Groonga::Logger.log("message", :function => "method_name")
@@ -149,6 +166,34 @@ class LoggerTest < Test::Unit::TestCase
     end
   end
 
+  sub_test_case ".register" do
+    setup do
+      GC.disable
+    end
+
+    teardown do
+      Groonga::Logger.unregister
+      GC.enable
+    end
+
+    test ":thread_id" do
+      locations = []
+      Groonga::Logger.register(location: false,
+                               thread_id: true) do |*args|
+        location = args[5]
+        locations << location
+      end
+      Groonga::Logger.log("message")
+      locations = locations.collect do |location|
+        location.gsub(/\A([a-f\d]+)\z/, "THREAD_ID")
+      end
+      assert_equal([
+                     "THREAD_ID",
+                   ],
+                   locations)
+    end
+  end
+
   def test_rotate_threshold_size
     Groonga::Logger.unregister
     Groonga::Logger.path = @log_path.to_s