rroonga 5.0.0-x86-mingw32 → 5.0.1-x86-mingw32

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

data/test/test-procedure.rb

@@ -27,6 +27,30 @@ class ProcedureTest < Test::Unit::TestCase
                            :accept_nil => true)
   end
 
+  def test_procedure?
+    assert do
+      Groonga["TokenBigram"].procedure?
+    end
+  end
+
+  def test_function_procedure?
+    assert do
+      Groonga["rand"].function_procedure?
+    end
+  end
+
+  def test_selector_procedure?
+    assert do
+      Groonga["between"].selector_procedure?
+    end
+  end
+
+  def test_scorer_procedure?
+    assert do
+      Groonga["scorer_tf_idf"].scorer_procedure?
+    end
+  end
+
   private
   def assert_equal_procedure(expected_name, id, options={})
     procedure = Groonga::Context.default[id]
@@ -40,5 +64,10 @@ class ProcedureTest < Test::Unit::TestCase
       tokenizer = Groonga["TokenBigram"]
       assert_equal(Groonga::ProcedureType::TOKENIZER, tokenizer.type)
     end
+
+    def test_scorer
+      scorer = Groonga["scorer_tf_idf"]
+      assert_equal(Groonga::ProcedureType::SCORER, scorer.type)
+    end
   end
 end

data/test/test-schema-type.rb

@@ -205,4 +205,18 @@ class SchemaTypeTest < Test::Unit::TestCase
   def assert_normalize_type(expected, type)
     assert_equal(expected, Groonga::Schema.normalize_type(type))
   end
+
+  class RegexpTest < self
+    def test_normalize_short_name
+      assert_normalize_type("TokenRegexp", "regexp")
+    end
+
+    def test_normalize_snake_case
+      assert_normalize_type("TokenRegexp", "token_regexp")
+    end
+
+    def test_normalize_camel_case
+      assert_normalize_type("TokenRegexp", "TokenRegexp")
+    end
+  end
 end

data/test/test-table-select-mecab.rb

@@ -20,10 +20,7 @@ class TableSelectMecabTest < Test::Unit::TestCase
 
   setup :setup_database
 
-  setup
-  def check_mecab_availability
-    omit("MeCab isn't available") if context["TokenMecab"].nil?
-  end
+  setup :check_mecab_availability
 
   setup
   def setup_tables

data/test/test-table.rb

@@ -630,6 +630,13 @@ class TableTest < Test::Unit::TestCase
     assert_not_predicate(bookmarks, :builtin?)
   end
 
+  def test_table?
+    bookmarks = Groonga::PatriciaTrie.create(:name => "Bookmarks")
+    assert do
+      bookmarks.table?
+    end
+  end
+
   class OtherProcessTest < self
     def test_create
       by_other_process do

data/test/test-token-regexp.rb

@@ -0,0 +1,30 @@
+# Copyright (C) 2015  Masafumi Yokoyama <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 TokenRegexpTest < Test::Unit::TestCase
+  include GroongaTestUtils
+
+  def setup
+    setup_database
+  end
+
+  def test_default_tokenizer
+    terms = Groonga::PatriciaTrie.create(:name => "Terms",
+                                         :key_type => "ShortText",
+                                         :default_tokenizer => "TokenRegexp")
+    assert_equal(context["TokenRegexp"],
+                 terms.default_tokenizer)
+  end
+end

data/test/test-type.rb

@@ -1,4 +1,5 @@
 # Copyright (C) 2009-2012  Kouhei Sutou <kou@clear-code.com>
+# Copyright (C) 2015  Masafumi Yokoyama <yokoyama@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
@@ -133,4 +134,27 @@ class TypeTest < Test::Unit::TestCase
     assert_equal(expected_name,
                  type ? type.name : type)
   end
+
+  class TokenizerTest < self
+    def test_delimit
+      assert_equal_type("TokenDelimit", Groonga::Type::DELIMIT)
+    end
+
+    def test_unigram
+      assert_equal_type("TokenUnigram", Groonga::Type::UNIGRAM)
+    end
+
+    def test_bigram
+      assert_equal_type("TokenBigram", Groonga::Type::BIGRAM)
+    end
+
+    def test_trigram
+      assert_equal_type("TokenTrigram", Groonga::Type::TRIGRAM)
+    end
+
+    def test_mecab
+      check_mecab_availability
+      assert_equal_type("TokenMecab",  Groonga::Type::MECAB)
+    end
+  end
 end

data/vendor/local/bin/mecab-config

@@ -1,6 +1,6 @@
 #!/bin/sh
 
-prefix=/home/kenhys/work/groonga/groonga.clean/packages/windows/dist-x86
+prefix=/home/myokoym/work/groonga/groonga.clean/packages/windows/dist-x86
 exec_prefix=${prefix}
 exec_prefix_set=no
 
@@ -107,7 +107,7 @@ while test $# -gt 0; do
 	;;
 
     --libexecdir)
-       	echo /home/kenhys/work/groonga/groonga.clean/packages/windows/dist-x86/libexec/mecab
+       	echo /home/myokoym/work/groonga/groonga.clean/packages/windows/dist-x86/libexec/mecab
        	;;
 	
     --sysconfdir)