rroonga 2.0.4-x86-mingw32 → 2.0.7-x86-mingw32

data/test/test-patricia-trie.rb

@@ -0,0 +1,440 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2009-2012  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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+class PatriciaTrieTest < Test::Unit::TestCase
+  include GroongaTestUtils
+  include ERB::Util
+
+  setup :setup_database
+
+  def test_support_key?
+    assert_predicate(Groonga::PatriciaTrie.create(:name => "Users",
+                                                  :key_type => "ShortText"),
+                     :support_key?)
+  end
+
+  def test_encoding
+    assert_equal(Groonga::Encoding.default,
+                 Groonga::PatriciaTrie.create.encoding)
+  end
+
+  def test_tokenizer
+    trie = Groonga::PatriciaTrie.create
+    assert_nil(trie.default_tokenizer)
+    trie.default_tokenizer = "TokenTrigram"
+    assert_equal(Groonga::Context.default["TokenTrigram"],
+                 trie.default_tokenizer)
+  end
+
+  def test_search
+    users = Groonga::Array.create(:name => "Users")
+    users.define_column("name", "ShortText")
+
+    bookmarks = Groonga::PatriciaTrie.create(:name => "Bookmarks",
+                                             :key_type => "ShortText")
+    bookmarks.define_column("user_id", users)
+
+    daijiro = users.add
+    daijiro["name"] = "daijiro"
+    gunyarakun = users.add
+    gunyarakun["name"] = "gunyarakun"
+
+    groonga = bookmarks.add("http://groonga.org/")
+    groonga["user_id"] = daijiro
+
+    records = bookmarks.search("http://groonga.org/")
+    assert_equal(["daijiro"],
+                 records.records.collect {|record| record[".user_id.name"]})
+  end
+
+  def test_add
+    users = Groonga::PatriciaTrie.create(:name => "Users")
+    users.define_column("address", "Text")
+    me = users.add("me", :address => "me@example.com")
+    assert_equal("me@example.com", me[:address])
+  end
+
+  def test_default_tokenizer_on_create
+    terms = Groonga::PatriciaTrie.create(:name => "Terms",
+                                         :default_tokenizer => "TokenUnigram")
+    assert_equal(context[Groonga::Type::UNIGRAM],
+                 terms.default_tokenizer)
+  end
+
+  def test_duplicated_name
+    Groonga::PatriciaTrie.create(:name => "Users")
+    assert_raise(Groonga::InvalidArgument) do
+      Groonga::PatriciaTrie.create(:name => "Users")
+    end
+  end
+
+  def test_has_key?
+    users = Groonga::PatriciaTrie.create(:name => "Users")
+    assert_false(users.has_key?("morita"))
+    users.add("morita")
+    assert_true(users.has_key?("morita"))
+  end
+
+  def test_scan
+    Groonga::Context.default_options = {:encoding => "utf-8"}
+    words = Groonga::PatriciaTrie.create(:key_type => "ShortText",
+                                         :key_normalize => true)
+    words.add("リンク")
+    arupaka = words.add("アルパカ")
+    words.add("アルパカ(生物)")
+    adventure_of_link = words.add('リンクの冒険')
+    words.add('冒険')
+    gaxtu = words.add('ｶﾞｯ')
+    muteki = words.add('ＭＵＴＥＫＩ')
+    assert_equal([[muteki, "muTEki", 0, 6],
+                  [adventure_of_link, "リンクの冒険", 7, 18],
+                  [arupaka, "アルパカ", 42, 12],
+                  [gaxtu, "ガッ", 55, 6]],
+                 words.scan('muTEki リンクの冒険 ミリバール アルパカ ガッ'))
+  end
+
+  def test_tag_keys
+    Groonga::Context.default_options = {:encoding => "utf-8"}
+    words = Groonga::PatriciaTrie.create(:key_type => "ShortText",
+                                         :key_normalize => true)
+    words.add('リンク')
+    words.add('リンクの冒険')
+    words.add('冒険')
+    words.add('㍊')
+    words.add('ｶﾞｯ')
+    words.add('ＭＵＴＥＫＩ')
+
+    text = 'muTEki リンクの冒険 マッチしない ミリバール ガッ おわり'
+    actual = words.tag_keys(text) do |record, word|
+      "<#{word}(#{record.key})>"
+    end
+    assert_equal("<muTEki(muteki)> " +
+                 "<リンクの冒険(リンクの冒険)> " +
+                 "マッチしない " +
+                 "<ミリバール(ミリバール)> " +
+                 "<ガッ(ガッ)> " +
+                 "おわり",
+                 actual)
+  end
+
+  def test_tag_keys_other_text_handler
+    Groonga::Context.default_options = {:encoding => "utf-8"}
+    words = Groonga::PatriciaTrie.create(:key_type => "ShortText",
+                                         :key_normalize => true)
+    words.add('ｶﾞｯ')
+    words.add('ＭＵＴＥＫＩ')
+
+    text = 'muTEki マッチしない <> ガッ'
+    other_text_handler = Proc.new do |string|
+      h(string)
+    end
+    options = {:other_text_handler => other_text_handler}
+    actual = words.tag_keys(text, options) do |record, word|
+      "<span class=\"keyword\">#{h(word)}(#{h(record.key)})</span>\n"
+    end
+    assert_equal("<span class=\"keyword\">muTEki(muteki)</span>\n" +
+                 " マッチしない &lt;&gt; " +
+                 "<span class=\"keyword\">ガッ(ガッ)</span>\n",
+                 actual)
+  end
+
+  def test_tag_keys_with_last_match
+    Groonga::Context.default_options = {:encoding => "utf-8"}
+    words = Groonga::PatriciaTrie.create(:key_type => "ShortText",
+                                         :key_normalize => true)
+    words.add('ｶﾞｯ')
+    words.add('ＭＵＴＥＫＩ')
+
+    text = 'muTEki マッチしない ガッ'
+    actual = words.tag_keys(text) do |record, word|
+      "<#{word}(#{record.key})>"
+    end
+    assert_equal("<muTEki(muteki)> " +
+                 "マッチしない " +
+                 "<ガッ(ガッ)>",
+                 actual)
+  end
+
+  def test_tag_keys_with_no_match
+    Groonga::Context.default_options = {:encoding => "utf-8"}
+    words = Groonga::PatriciaTrie.create(:key_type => "ShortText",
+                                         :key_normalize => true)
+
+    words.add('無敵')
+    words.add('ＢＯＵＫＥＮ')
+
+    text = 'muTEki リンクの冒険'
+    actual = words.tag_keys(text) do |record, word|
+      "<#{word}(#{record.key})>"
+    end
+    assert_equal(text, actual)
+  end
+
+  def test_prefix_search
+    paths = Groonga::PatriciaTrie.create(:name => "Paths",
+                                         :key_type => 'ShortText')
+    paths.add('/')
+    paths.add('/tmp')
+    paths.add('/usr/bin')
+    paths.add('/usr/local/bin')
+
+    records = paths.prefix_search('/')
+    assert_equal(["/usr/local/bin", "/usr/bin", "/tmp", "/"],
+                 records.records.collect {|record| record["._key"]})
+
+    records = paths.prefix_search('/usr')
+    assert_equal(["/usr/local/bin", "/usr/bin"],
+                 records.records.collect {|record| record["._key"]})
+
+    records = paths.prefix_search('/usr/local')
+    assert_equal(["/usr/local/bin"],
+                 records.records.collect {|record| record["._key"]})
+
+    records = paths.prefix_search('nonexistent')
+    assert_equal([],
+                 records.records.collect {|record| record["._key"]})
+  end
+
+
+  def test_prefix_cursor
+    paths = Groonga::PatriciaTrie.create(:name => "Paths",
+                                         :key_type => 'ShortText')
+    paths.add('/')
+    paths.add('/tmp')
+    paths.add('/usr/bin')
+    paths.add('/usr/local/bin')
+
+    assert_prefix_cursor(["/usr/local/bin", "/usr/bin", "/tmp", "/"],
+                         paths, "/", {:order => :desc})
+    assert_prefix_cursor(["/", "/tmp", "/usr/bin", "/usr/local/bin"],
+                         paths, "/")
+    assert_prefix_cursor(["/usr/local/bin", "/usr/bin"],
+                         paths, "/usr/local",
+                         {:key_bytes => "/usr".size, :order => :desc})
+    assert_prefix_cursor(["/tmp", "/usr/bin"],
+                         paths, "/",
+                         {:offset => 1, :limit => 2})
+  end
+
+  def assert_prefix_cursor(expected, tables, prefix, options={})
+    actual = []
+    tables.open_prefix_cursor(prefix, options) do |cursor|
+      cursor.each do |record|
+        actual << record.key
+      end
+    end
+    assert_equal(expected, actual)
+  end
+
+  def test_rk_cursor
+    terms = Groonga::PatriciaTrie.create(:name => "Terms",
+                                         :key_type => 'ShortText')
+    ["インデックス",
+     "エヌグラム",
+     "エンジン",
+     "カネソナエタ",
+     "カノウ",
+     "キノウ",
+     "キョウカ",
+     "クミコミ",
+     "クミコム",
+     "グルンガ",
+     "ケンサク",
+     "ケンサクヨウキュウ",
+     "ゲンゴ",
+     "コウセイド",
+     "コウソク",
+     "コンパクト",
+     "サクセイ",
+     "ショリ",
+     "ショリケイ",
+     "ジッソウ",
+     "ジュンスイ",
+     "スクリプト",
+     "セッケイ",
+     "ゼンブン",
+     "タイプ",
+     "タンゴ",
+     "ダイキボ",
+     "テンチ",
+     "ディービーエムエス",
+     "トウ",
+     "トクチョウ",
+     "ブンショリョウ",
+     "ヨウキュウ"].each do |term|
+      terms.add(term)
+    end
+
+    assert_rk_cursor(["カネソナエタ",
+                      "カノウ",
+                      "キノウ",
+                      "キョウカ",
+                      "クミコミ",
+                      "クミコム",
+                      "ケンサク",
+                      "ケンサクヨウキュウ",
+                      "コウセイド",
+                      "コウソク",
+                      "コンパクト"],
+                     terms, "k")
+  end
+
+  def assert_rk_cursor(expected, tables, prefix, options={})
+    actual = []
+    tables.open_rk_cursor(prefix, options) do |cursor|
+      cursor.each do |record|
+        actual << record.key
+      end
+    end
+    assert_equal(expected, actual.sort)
+  end
+
+  def test_near_cursor
+    points = Groonga::PatriciaTrie.create(:name => "Points",
+                                          :key_type => 'WGS84GeoPoint')
+    ["130322053x504985073",
+     "130285021x504715091",
+     "130117012x504390088",
+     "130335016x504662007",
+     "130308044x504536008",
+     "130306053x504530043",
+     "130205016x505331054",
+     "130222054x505270050",
+     "130255017x504266011",
+     "130239038x504251015",
+     "129885039x503653023",
+     "129809022x504597055",
+     "130015001x504266057",
+     "130089012x505045070",
+     "130208017x504315098",
+     "130347036x504325073",
+     "130380061x505202034",
+     "129903045x504648034",
+     "130094061x505025099",
+     "130133052x505120058",
+     "130329069x505188046",
+     "130226001x503769013",
+     "129866001x504328017",
+     "129786048x504792049",
+     "129845056x504853081",
+     "130055008x504968095",
+     "130086003x504480071",
+     "129680021x504441006",
+     "129855010x504452003",
+     "130280013x505208029",
+     "129721099x504685024",
+     "129690039x504418033",
+     "130019020x505027021",
+     "130046026x505082073",
+     "130038025x505066028",
+     "129917001x504675017"].each do |point|
+      points.add(point)
+    end
+
+    assert_near_cursor(["129885039x503653023",
+                        "129866001x504328017",
+                        "130015001x504266057",
+                        "129690039x504418033",
+                        "129680021x504441006",
+                        "129721099x504685024",
+                        "129855010x504452003",
+                        "129809022x504597055",
+                        "129786048x504792049",
+                        "129845056x504853081"],
+                       points,
+                       "129786048x504792049",
+                       {:limit => 10})
+  end
+
+  def assert_near_cursor(expected, tables, prefix, options={})
+    actual = []
+    tables.open_near_cursor(prefix, options) do |cursor|
+      cursor.each do |record|
+        actual << record.key.to_s
+      end
+    end
+    assert_equal(expected, actual)
+  end
+
+  def test_add_uint_key
+    numbers = Groonga::PatriciaTrie.create(:name => "Numbers",
+                                           :key_type => "UInt32")
+    numbers.add(1)
+    numbers.add(2)
+    numbers.add(5)
+    numbers.add(7)
+    assert_equal([1, 2, 5, 7], numbers.collect {|number| number.key})
+  end
+
+  def test_added?
+    users = Groonga::PatriciaTrie.create(:name => "Users",
+                                         :key_type => "ShortText")
+    bob = users.add("bob")
+    assert_predicate(bob, :added?)
+    bob_again = users.add("bob")
+    assert_not_predicate(bob_again, :added?)
+  end
+
+  def test_defrag
+    users = Groonga::PatriciaTrie.create(:name => "Users",
+                                         :key_type => "ShortText")
+    users.define_column("name", "ShortText")
+    users.define_column("address", "ShortText")
+    1000.times do |i|
+      users.add("user #{i}",
+                :name => "user #{i}" * 1000,
+                :address => "address #{i}" * 1000)
+    end
+    assert_equal(7, users.defrag)
+  end
+
+  def test_rename
+    users = Groonga::PatriciaTrie.create(:name => "Users",
+                                         :key_type => "ShortText")
+    name = users.define_column("name", "ShortText")
+    address = users.define_column("address", "ShortText")
+
+    users.rename("People")
+    assert_equal(["People", "People.name", "People.address"],
+                 [users.name, name.name, address.name])
+  end
+
+  def test_each
+    users = Groonga::PatriciaTrie.create(:name => "Users",
+                                         :key_type => "ShortText")
+    users.add("Alice")
+    users.add("Bob")
+    users.add("Carl")
+
+    user_names = []
+    users.each do |user|
+      user_names << user.key
+    end
+    assert_equal(["Alice", "Bob", "Carl"], user_names)
+  end
+
+  def test_each_without_block
+    users = Groonga::PatriciaTrie.create(:name => "Users",
+                                         :key_type => "ShortText")
+    users.add("Alice")
+    users.add("Bob")
+    users.add("Carl")
+
+    user_names = users.each.collect(&:key)
+    assert_equal(["Alice", "Bob", "Carl"], user_names)
+  end
+end

data/test/test-plugin.rb

@@ -0,0 +1,35 @@
+# Copyright (C) 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
+# 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+class PluginTest < Test::Unit::TestCase
+  include GroongaTestUtils
+
+  setup :setup_sandbox
+  setup :setup_database
+  teardown :teardown_sandbox
+
+  def test_register
+    context = Groonga::Context.default
+    assert_nil(context["suggest"])
+    context.register_plugin("suggest/suggest")
+    assert_not_nil(context["suggest"])
+  end
+
+  def test_system_plugins_dir
+    suggest_plugin_path = "#{Groonga::Plugin.system_plugins_dir}/"
+    suggest_plugin_path << "suggest/suggest#{Groonga::Plugin.suffix}"
+    assert_send([File, :exist?, suggest_plugin_path])
+  end
+end

data/test/test-procedure.rb

@@ -0,0 +1,37 @@
+# Copyright (C) 2009  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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+class ProcedureTest < Test::Unit::TestCase
+  include GroongaTestUtils
+
+  setup :setup_database
+
+  def test_builtins
+    assert_equal_procedure("TokenDelimit", Groonga::Procedure::DELIMIT)
+    assert_equal_procedure("TokenUnigram", Groonga::Procedure::UNIGRAM)
+    assert_equal_procedure("TokenBigram", Groonga::Procedure::BIGRAM)
+    assert_equal_procedure("TokenTrigram", Groonga::Procedure::TRIGRAM)
+    assert_equal_procedure("TokenMecab", Groonga::Procedure::MECAB,
+                           :accept_nil => true)
+  end
+
+  private
+  def assert_equal_procedure(expected_name, id, options={})
+    procedure = Groonga::Context.default[id]
+    expected_name = nil if procedure.nil? and options[:accept_nil]
+    assert_equal(expected_name,
+                 procedure ? procedure.name : procedure)
+  end
+end