rroonga 5.0.0-x64-mingw32 → 5.0.1-x64-mingw32

data/test/test-expression.rb

@@ -78,15 +78,14 @@ class ExpressionTest < Test::Unit::TestCase
     expression.compile
 
     assert_equal(<<-INSPECTED.chomp, expression.inspect)
-#<Groonga::Expression #<expr
+#<Groonga::Expression
   vars:{
   },
   codes:{
-    0:<push(), modify:2, value:1>,
-    1:<push(), modify:0, value:1>,
-    2:<plus(), modify:0, value:(NULL)>
-  }
->>
+    0:<push n_args:1, flags:0, modify:2, value:1>,
+    1:<push n_args:1, flags:0, modify:0, value:1>,
+    2:<plus n_args:2, flags:0, modify:0, value:(NULL)>
+  }>
     INSPECTED
   end
 
@@ -172,26 +171,24 @@ class ExpressionTest < Test::Unit::TestCase
                                   Groonga::Operator::PUSH,
                                   1)
         assert_equal(<<-INSPECTED.chomp, @expression.inspect)
-#<Groonga::Expression #<expr
+#<Groonga::Expression
   vars:{
   },
   codes:{
-    0:<push(), modify:0, value:#<proc:tokenizer TokenBigram arguments:[$1, $2, $3]>>
-  }
->>
+    0:<push n_args:1, flags:0, modify:0, value:#<proc:tokenizer TokenBigram arguments:[$1, $2, $3]>>
+  }>
         INSPECTED
       end
 
       def test_name
         @expression.append_object(Groonga["TokenBigram"], "push", 1)
         assert_equal(<<-INSPECTED.chomp, @expression.inspect)
-#<Groonga::Expression #<expr
+#<Groonga::Expression
   vars:{
   },
   codes:{
-    0:<push(), modify:0, value:#<proc:tokenizer TokenBigram arguments:[$1, $2, $3]>>
-  }
->>
+    0:<push n_args:1, flags:0, modify:0, value:#<proc:tokenizer TokenBigram arguments:[$1, $2, $3]>>
+  }>
         INSPECTED
       end
     end
@@ -207,67 +204,102 @@ class ExpressionTest < Test::Unit::TestCase
       def test_constant
         @expression.append_constant(29, Groonga::Operator::PUSH, 1)
         assert_equal(<<-INSPECTED.chomp, @expression.inspect)
-#<Groonga::Expression #<expr
+#<Groonga::Expression
   vars:{
   },
   codes:{
-    0:<push(), modify:0, value:29>
-  }
->>
+    0:<push n_args:1, flags:0, modify:0, value:29>
+  }>
         INSPECTED
       end
 
       def test_name
         @expression.append_constant(29, "push", 1)
         assert_equal(<<-INSPECTED.chomp, @expression.inspect)
-#<Groonga::Expression #<expr
+#<Groonga::Expression
   vars:{
   },
   codes:{
-    0:<push(), modify:0, value:29>
-  }
->>
+    0:<push n_args:1, flags:0, modify:0, value:29>
+  }>
         INSPECTED
       end
     end
   end
 
   class AppendOperatorTest < self
-    setup
-    def setup_expression
-      @expression = Groonga::Expression.new
-      @expression.append_constant(29)
-      @expression.append_constant(92)
-    end
+    class PlusTest < self
+      setup
+      def setup_expression
+        @expression = Groonga::Expression.new
+        @expression.append_constant(29)
+        @expression.append_constant(92)
+      end
+
+      def test_constant
+        @expression.append_operation(Groonga::Operator::PLUS, 2)
+        assert_equal(<<-INSPECTED.chomp, @expression.inspect)
+#<Groonga::Expression
+  vars:{
+  },
+  codes:{
+    0:<push n_args:1, flags:0, modify:2, value:29>,
+    1:<push n_args:1, flags:0, modify:0, value:92>,
+    2:<plus n_args:2, flags:0, modify:0, value:(NULL)>
+  }>
+        INSPECTED
+      end
 
-    def test_constant
-      @expression.append_operation(Groonga::Operator::PLUS, 2)
-      assert_equal(<<-INSPECTED.chomp, @expression.inspect)
-#<Groonga::Expression #<expr
+      def test_name
+        @expression.append_operation("plus", 2)
+        assert_equal(<<-INSPECTED.chomp, @expression.inspect)
+#<Groonga::Expression
   vars:{
   },
   codes:{
-    0:<push(), modify:2, value:29>,
-    1:<push(), modify:0, value:92>,
-    2:<plus(), modify:0, value:(NULL)>
-  }
->>
-      INSPECTED
+    0:<push n_args:1, flags:0, modify:2, value:29>,
+    1:<push n_args:1, flags:0, modify:0, value:92>,
+    2:<plus n_args:2, flags:0, modify:0, value:(NULL)>
+  }>
+        INSPECTED
+      end
     end
 
-    def test_name
-      @expression.append_operation("plus", 2)
-      assert_equal(<<-INSPECTED.chomp, @expression.inspect)
-#<Groonga::Expression #<expr
+    class RegexpTest < self
+      setup
+      def setup_expression
+        @expression = Groonga::Expression.new
+        @expression.append_constant("Alice")
+        @expression.append_constant(/\A[aA].*l/.source)
+      end
+
+      def test_constant
+        @expression.append_operation(Groonga::Operator::REGEXP, 2)
+        assert_equal(<<-INSPECTED.chomp, @expression.inspect)
+#<Groonga::Expression
   vars:{
   },
   codes:{
-    0:<push(), modify:2, value:29>,
-    1:<push(), modify:0, value:92>,
-    2:<plus(), modify:0, value:(NULL)>
-  }
->>
-      INSPECTED
+    0:<push n_args:1, flags:0, modify:2, value:"Alice">,
+    1:<push n_args:1, flags:0, modify:0, value:"\\\\A[aA].*l">,
+    2:<regexp n_args:2, flags:0, modify:0, value:(NULL)>
+  }>
+        INSPECTED
+      end
+
+      def test_name
+        @expression.append_operation("regexp", 2)
+        assert_equal(<<-INSPECTED.chomp, @expression.inspect)
+#<Groonga::Expression
+  vars:{
+  },
+  codes:{
+    0:<push n_args:1, flags:0, modify:2, value:"Alice">,
+    1:<push n_args:1, flags:0, modify:0, value:"\\\\A[aA].*l">,
+    2:<regexp n_args:2, flags:0, modify:0, value:(NULL)>
+  }>
+        INSPECTED
+      end
     end
   end
 

data/test/test-index-column.rb

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 #
-# Copyright (C) 2009-2014  Kouhei Sutou <kou@clear-code.com>
+# Copyright (C) 2009-2015  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
@@ -502,43 +502,116 @@ class IndexColumnTest < Test::Unit::TestCase
   end
 
   class EstimateSizeTest < self
-    setup
-    def setup_schema
-      Groonga::Schema.define do |schema|
-        schema.create_table("Articles") do |table|
-          table.text("content")
-        end
+    sub_test_case "token ID" do
+      setup
+      def setup_schema
+        Groonga::Schema.define do |schema|
+          schema.create_table("Articles") do |table|
+            table.text("content")
+          end
 
-        schema.create_table("Terms",
-                            :type => :hash,
-                            :key_type => "ShortText",
-                            :default_tokenizer => "TokenBigram",
-                            :normalizer => "NormalizerAuto") do |table|
-          table.index("Articles.content",
-                      :name => "articles_content",
-                      :with_position => true,
-                      :with_section => true)
+          schema.create_table("Terms",
+                              :type => :hash,
+                              :key_type => "ShortText",
+                              :default_tokenizer => "TokenBigram",
+                              :normalizer => "NormalizerAuto") do |table|
+            table.index("Articles.content",
+                        :name => "articles_content",
+                        :with_position => true,
+                        :with_section => true)
+          end
         end
+
+        @articles = Groonga["Articles"]
+        @terms = Groonga["Terms"]
+        @index = Groonga["Terms.articles_content"]
       end
 
-      @articles = Groonga["Articles"]
-      @terms = Groonga["Terms"]
-      @index = Groonga["Terms.articles_content"]
-    end
+      setup
+      def setup_data
+        @articles.add(:content => "Groonga is fast")
+        @articles.add(:content => "Rroonga is fast")
+        @articles.add(:content => "Mroonga is fast")
+      end
 
-    setup
-    def setup_data
-      @articles.add(:content => "Groonga is fast")
-      @articles.add(:content => "Rroonga is fast")
-      @articles.add(:content => "Mroonga is fast")
+      def test_id
+        assert_equal(7, @index.estimate_size(@terms["fast"].id))
+      end
+
+      def test_record
+        assert_equal(7, @index.estimate_size(@terms["fast"]))
+      end
     end
 
-    def test_id
-      assert_equal(7, @index.estimate_size(@terms["fast"].id))
+    sub_test_case "query" do
+      setup
+      def setup_schema
+        Groonga::Schema.define do |schema|
+          schema.create_table("Articles") do |table|
+            table.text("content")
+          end
+
+          schema.create_table("Terms",
+                              :type => :hash,
+                              :key_type => "ShortText",
+                              :default_tokenizer => "TokenBigramSplitSymbolAlpha",
+                              :normalizer => "NormalizerAuto") do |table|
+            table.index("Articles.content",
+                        :name => "articles_content",
+                        :with_position => true,
+                        :with_section => true)
+          end
+        end
+
+        @articles = Groonga["Articles"]
+        @index = Groonga["Terms.articles_content"]
+      end
+
+      setup
+      def setup_data
+        @articles.add(:content => "Groonga is fast")
+        @articles.add(:content => "Rroonga is fast")
+        @articles.add(:content => "Mroonga is fast")
+      end
+
+      def test_query
+        assert_equal(6, @index.estimate_size("roonga"))
+      end
     end
 
-    def test_record
-      assert_equal(7, @index.estimate_size(@terms["fast"]))
+    sub_test_case "lexicon cursor" do
+      setup
+      def setup_schema
+        Groonga::Schema.define do |schema|
+          schema.create_table("Memos") do |table|
+            table.short_text("tags", :type => :vector)
+          end
+
+          schema.create_table("Tags",
+                              :type => :patricia_trie,
+                              :key_type => "ShortText") do |table|
+            table.index("Memos.tags",
+                        :name => "memos_tags")
+          end
+        end
+
+        @memos = Groonga["Memos"]
+        @tags = Groonga["Tags"]
+        @index = Groonga["Tags.memos_tags"]
+      end
+
+      setup
+      def setup_data
+        @memos.add(:tags => ["Groonga"])
+        @memos.add(:tags => ["Rroonga", "Ruby"])
+        @memos.add(:tags => ["grndump", "Rroonga"])
+      end
+
+      def test_query
+        @tags.open_prefix_cursor("R") do |cursor|
+          assert_equal(5, @index.estimate_size(cursor))
+        end
+      end
     end
   end
 end

data/test/test-normalizer.rb

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 #
-# Copyright (C) 2012  Kouhei Sutou <kou@clear-code.com>
+# Copyright (C) 2012-2015  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
@@ -20,33 +20,39 @@ class NormalizerTest < Test::Unit::TestCase
 
   setup :setup_database
 
-  def test_normalize
-    assert_equal("abc", Groonga::Normalizer.normalize("AbC"))
-  end
-
-  def test_normalize_with_space
-    assert_equal("abcdefgh", Groonga::Normalizer.normalize("AbC Def　gh"))
-  end
-
-  def test_normalize_with_space_explicitly
-    assert_equal("abcdefgh",
-                 Groonga::Normalizer.normalize("AbC Def　gh",
-                                               :remove_blank => true))
-  end
-
-  def test_normalize_group_text
-    assert_equal("キロメートルキロメートルキロメートルキロメートル",
-                 Groonga::Normalizer.normalize("㌖㌖㌖㌖"));
-  end
-
-  def test_normalize_keep_space
-    # full width space => half width space
-    assert_equal("abc def gh",
-                 Groonga::Normalizer.normalize("AbC Def　gh",
-                                               :remove_blank => false))
-  end
-
-  def test_normalize_tilda
-    assert_equal("~~~", Groonga::Normalizer.normalize("~～〜"))
+  sub_test_case(".normalize") do
+    def test_normal
+      assert_equal("abc", Groonga::Normalizer.normalize("AbC"))
+    end
+
+    def test_space
+      assert_equal("abcdefgh", Groonga::Normalizer.normalize("AbC Def　gh"))
+    end
+
+    def test_remove_blank
+      assert_equal("abcdefgh",
+                   Groonga::Normalizer.normalize("AbC Def　gh",
+                                                 :remove_blank => true))
+    end
+
+    def test_group_text
+      assert_equal("キロメートルキロメートルキロメートルキロメートル",
+                   Groonga::Normalizer.normalize("㌖㌖㌖㌖"));
+    end
+
+    def test_keep_space
+      # full width space => half width space
+      assert_equal("abc def gh",
+                   Groonga::Normalizer.normalize("AbC Def　gh",
+                                                 :remove_blank => false))
+    end
+
+    def test_tilda
+      assert_equal("~~~", Groonga::Normalizer.normalize("~～〜"))
+    end
+
+    def test_empty
+      assert_equal("", Groonga::Normalizer.normalize(""))
+    end
   end
 end

data/test/test-operator.rb

@@ -0,0 +1,214 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2015  Masafumi Yokoyama <yokoyama@clear-code.com>
+# Copyright (C) 2015  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
+# 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
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+class OperatorTest < Test::Unit::TestCase
+  include GroongaTestUtils
+
+  setup :setup_database
+
+  sub_test_case "#to_s" do
+    test "equal" do
+      assert_equal("equal", Groonga::Operator::EQUAL.to_s)
+    end
+  end
+
+  sub_test_case "equal" do
+    sub_test_case "#exec" do
+      test "equal" do
+        assert_true(Groonga::Operator::EQUAL.exec("hello",
+                                                  "hello"))
+      end
+
+      test "not equal" do
+        assert_false(Groonga::Operator::EQUAL.exec("hello",
+                                                   "Hello"))
+      end
+
+      test ":context" do
+        context = Groonga::Context.new
+        assert_true(Groonga::Operator::EQUAL.exec("hello",
+                                                  "hello",
+                                                  :context => context))
+      end
+    end
+  end
+
+  sub_test_case "not-equal" do
+    sub_test_case "#exec" do
+      test "not equal" do
+        assert_true(Groonga::Operator::NOT_EQUAL.exec("hello",
+                                                      "Hello"))
+      end
+
+      test "equal" do
+        assert_false(Groonga::Operator::NOT_EQUAL.exec("hello",
+                                                       "hello"))
+      end
+
+      test ":context" do
+        context = Groonga::Context.new
+        assert_true(Groonga::Operator::NOT_EQUAL.exec("hello",
+                                                      "Hello",
+                                                      :context => context))
+      end
+    end
+  end
+
+  sub_test_case "less" do
+    sub_test_case "#exec" do
+      test "less" do
+        assert_true(Groonga::Operator::LESS.exec(1, 2))
+      end
+
+      test "greater" do
+        assert_false(Groonga::Operator::LESS.exec(2, 1))
+      end
+
+      test ":context" do
+        context = Groonga::Context.new
+        assert_true(Groonga::Operator::LESS.exec(1, 2,
+                                                 :context => context))
+      end
+    end
+  end
+
+  sub_test_case "greater" do
+    sub_test_case "#exec" do
+      test "greater" do
+        assert_true(Groonga::Operator::GREATER.exec(2, 1))
+      end
+
+      test "less" do
+        assert_false(Groonga::Operator::GREATER.exec(1, 2))
+      end
+
+      test ":context" do
+        context = Groonga::Context.new
+        assert_true(Groonga::Operator::GREATER.exec(2, 1,
+                                                    :context => context))
+      end
+    end
+  end
+
+  sub_test_case "less-equal" do
+    sub_test_case "#exec" do
+      test "equal" do
+        assert_true(Groonga::Operator::LESS_EQUAL.exec(1, 1))
+      end
+
+      test "less" do
+        assert_true(Groonga::Operator::LESS_EQUAL.exec(1, 2))
+      end
+
+      test "greater" do
+        assert_false(Groonga::Operator::LESS_EQUAL.exec(2, 1))
+      end
+
+      test ":context" do
+        context = Groonga::Context.new
+        assert_true(Groonga::Operator::LESS_EQUAL.exec(1, 2,
+                                                       :context => context))
+      end
+    end
+  end
+
+  sub_test_case "greater-equal" do
+    sub_test_case "#exec" do
+      test "equal" do
+        assert_true(Groonga::Operator::GREATER_EQUAL.exec(1, 1))
+      end
+
+      test "greater" do
+        assert_true(Groonga::Operator::GREATER_EQUAL.exec(2, 1))
+      end
+
+      test "less" do
+        assert_false(Groonga::Operator::GREATER_EQUAL.exec(1, 2))
+      end
+
+      test ":context" do
+        context = Groonga::Context.new
+        assert_true(Groonga::Operator::GREATER_EQUAL.exec(2, 1,
+                                                          :context => context))
+      end
+    end
+  end
+
+  sub_test_case "match" do
+    sub_test_case "#exec" do
+      test "match" do
+        assert_true(Groonga::Operator::MATCH.exec("Hello Rroonga",
+                                                  "Rroonga"))
+      end
+
+      test "not match" do
+        assert_false(Groonga::Operator::MATCH.exec("Hello Rroonga",
+                                                   "Groonga"))
+      end
+
+      test ":context" do
+        context = Groonga::Context.new
+        assert_true(Groonga::Operator::MATCH.exec("Hello Rroonga",
+                                                  "Rroonga",
+                                                  :context => context))
+      end
+    end
+  end
+
+  sub_test_case "prefix" do
+    sub_test_case "#exec" do
+      test "have prefix" do
+        assert_true(Groonga::Operator::PREFIX.exec("Hello Rroonga",
+                                                   "Hello"))
+      end
+
+      test "not have prefix" do
+        assert_false(Groonga::Operator::PREFIX.exec("Hello Rroonga",
+                                                    "Rroonga"))
+      end
+
+      test ":context" do
+        context = Groonga::Context.new
+        assert_true(Groonga::Operator::PREFIX.exec("Hello Rroonga",
+                                                   "Hello",
+                                                   :context => context))
+      end
+    end
+  end
+
+  sub_test_case "regexp" do
+    sub_test_case "#exec" do
+      test "match" do
+        assert_true(Groonga::Operator::REGEXP.exec("Hello Rroonga",
+                                                   /Rro+nga/))
+      end
+
+      test "not match" do
+        assert_false(Groonga::Operator::REGEXP.exec("Hello Rroonga",
+                                                    /Gro+nga/))
+      end
+
+      test ":context" do
+        context = Groonga::Context.new
+        assert_true(Groonga::Operator::REGEXP.exec("Hello Rroonga",
+                                                   /Rro+nga/,
+                                                   :context => context))
+      end
+    end
+  end
+end

data/test/test-plugin.rb

@@ -22,16 +22,34 @@ class PluginTest < Test::Unit::TestCase
 
   def test_register
     context = Groonga::Context.default
-    assert_nil(context["suggest"])
-    context.register_plugin("suggest/suggest")
-    assert_not_nil(context["suggest"])
+    assert_nil(context["TokenFilterStopWord"])
+    context.register_plugin("token_filters/stop_word")
+    assert_not_nil(context["TokenFilterStopWord"])
   end
 
   def test_system_plugins_dir
-    suggest_plugin_path = "#{Groonga::Plugin.system_plugins_dir}/"
-    suggest_plugin_path << "suggest/suggest#{Groonga::Plugin.suffix}"
+    plugin_path = "#{Groonga::Plugin.system_plugins_dir}/"
+    plugin_path << "token_filters/stop_word#{Groonga::Plugin.suffix}"
     assert do
-      File.exist?(suggest_plugin_path)
+      File.exist?(plugin_path)
+    end
+  end
+
+  class UnregisterTest < self
+    def test_by_name
+      context.register_plugin("token_filters/stop_word")
+      assert_not_nil(context["TokenFilterStopWord"])
+      context.unregister_plugin("token_filters/stop_word")
+      assert_nil(context["TokenFilterStopWord"])
+    end
+
+    def test_by_path
+      context.register_plugin("token_filters/stop_word")
+      assert_not_nil(context["TokenFilterStopWord"])
+      plugin_path = "#{Groonga::Plugin.system_plugins_dir}/"
+      plugin_path << "token_filters/stop_word#{Groonga::Plugin.suffix}"
+      context.unregister_plugin(plugin_path)
+      assert_nil(context["TokenFilterStopWord"])
     end
   end
 end