rroonga 2.0.2-x86-mingw32 → 2.0.3-x86-mingw32

data/test/test-pagination.rb

@@ -1,249 +0,0 @@
-# Copyright (C) 2010  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 PaginationTest < Test::Unit::TestCase
-  include GroongaTestUtils
-
-  setup :setup_database
-
-  setup
-  def setup_data
-    Groonga::Schema.define do |schema|
-      schema.create_table("Users",
-                          :type => :hash,
-                          :key_type => "ShortText") do |table|
-        table.uint32(:number)
-      end
-    end
-    @users = context["Users"]
-    150.times do |i|
-      @users.add("user#{i + 1}", :number => i + 1)
-    end
-  end
-
-  def test_default
-    assert_paginate({
-                      :current_page => 1,
-                      :page_size => 10,
-                      :n_pages => 15,
-                      :n_records => 150,
-                      :start_offset => 1,
-                      :end_offset => 10,
-                      :have_previous_page? => false,
-                      :previous_page => nil,
-                      :have_next_page? => true,
-                      :next_page => 2,
-                      :first_page? => true,
-                      :last_page? => false,
-                      :have_pages? => true,
-                    })
-  end
-
-  def test_no_entries
-    @users.each do |user|
-      user.delete
-    end
-    assert_paginate({
-                      :current_page => 1,
-                      :page_size => 10,
-                      :n_pages => 1,
-                      :n_records => 0,
-                      :start_offset => nil,
-                      :end_offset => nil,
-                      :have_previous_page? => false,
-                      :previous_page => nil,
-                      :have_next_page? => false,
-                      :next_page => nil,
-                      :first_page? => true,
-                      :last_page? => true,
-                      :have_pages? => false,
-                      :keys => [],
-                    })
-  end
-
-  def test_page
-    assert_paginate({
-                      :current_page => 6,
-                      :page_size => 10,
-                      :n_pages => 15,
-                      :n_records => 150,
-                      :start_offset => 51,
-                      :end_offset => 60,
-                      :have_previous_page? => true,
-                      :previous_page => 5,
-                      :have_next_page? => true,
-                      :next_page => 7,
-                      :first_page? => false,
-                      :last_page? => false,
-                      :have_pages? => true,
-                    },
-                    :page => 6)
-  end
-
-  def test_max_page
-    assert_paginate({
-                      :current_page => 15,
-                      :page_size => 10,
-                      :n_pages => 15,
-                      :n_records => 150,
-                      :start_offset => 141,
-                      :end_offset => 150,
-                      :have_previous_page? => true,
-                      :previous_page => 14,
-                      :have_next_page? => false,
-                      :next_page => nil,
-                      :first_page? => false,
-                      :last_page? => true,
-                      :have_pages? => true,
-                    },
-                    :page => 15)
-  end
-
-  def test_too_large_page
-    assert_raise(Groonga::TooLargePage) do
-      assert_paginate({},
-                      :page => 16)
-    end
-  end
-
-  def test_zero_page
-    assert_raise(Groonga::TooSmallPage) do
-      assert_paginate({},
-                      :page => 0)
-    end
-  end
-
-  def test_negative_page
-    assert_raise(Groonga::TooSmallPage) do
-      assert_paginate({},
-                      :page => -1)
-    end
-  end
-
-  def test_size
-    assert_paginate({
-                      :current_page => 1,
-                      :page_size => 7,
-                      :n_pages => 22,
-                      :n_records => 150,
-                      :start_offset => 1,
-                      :end_offset => 7,
-                      :have_previous_page? => false,
-                      :previous_page => nil,
-                      :have_next_page? => true,
-                      :next_page => 2,
-                      :first_page? => true,
-                      :last_page? => false,
-                      :have_pages? => true,
-                    },
-                    :size => 7)
-  end
-
-  def test_max_size
-    assert_paginate({
-                      :current_page => 1,
-                      :page_size => 150,
-                      :n_pages => 1,
-                      :n_records => 150,
-                      :start_offset => 1,
-                      :end_offset => 150,
-                      :have_previous_page? => false,
-                      :previous_page => nil,
-                      :have_next_page? => false,
-                      :next_page => nil,
-                      :first_page? => true,
-                      :last_page? => true,
-                      :have_pages? => false,
-                    },
-                    :size => 150)
-  end
-
-  def test_too_large_size
-    assert_paginate({
-                      :current_page => 1,
-                      :page_size => 151,
-                      :n_pages => 1,
-                      :n_records => 150,
-                      :start_offset => 1,
-                      :end_offset => 150,
-                      :have_previous_page? => false,
-                      :previous_page => nil,
-                      :have_next_page? => false,
-                      :next_page => nil,
-                      :first_page? => true,
-                      :last_page? => true,
-                      :have_pages? => false,
-                    },
-                    :size => 151)
-  end
-
-  def test_zero_size
-    assert_raise(Groonga::TooSmallPageSize) do
-      assert_paginate({},
-                      :size => 0)
-    end
-  end
-
-  def test_negative_size
-    assert_raise(Groonga::TooSmallPageSize) do
-      assert_paginate({},
-                      :size => -1)
-    end
-  end
-
-  def test_full
-    assert_paginate({
-                      :current_page => 2,
-                      :page_size => 50,
-                      :n_pages => 3,
-                      :n_records => 150,
-                      :start_offset => 51,
-                      :end_offset => 100,
-                      :have_previous_page? => true,
-                      :previous_page => 1,
-                      :have_next_page? => true,
-                      :next_page => 3,
-                      :first_page? => false,
-                      :last_page? => false,
-                      :have_pages? => true,
-                    },
-                    :page => 2,
-                    :size => 50)
-  end
-
-  private
-  def assert_paginate(expected, options={})
-    users = @users.paginate([["number"]], options)
-    if expected[:keys].nil?
-      range = (expected[:start_offset]..expected[:end_offset])
-      expected[:keys] = range.collect {|i| "user#{i}"}
-    end
-    assert_equal(expected,
-                 :current_page => users.current_page,
-                 :page_size => users.page_size,
-                 :n_pages => users.n_pages,
-                 :n_records => users.n_records,
-                 :start_offset => users.start_offset,
-                 :end_offset => users.end_offset,
-                 :previous_page => users.previous_page,
-                 :have_previous_page? => users.have_previous_page?,
-                 :next_page => users.next_page,
-                 :have_next_page? => users.have_next_page?,
-                 :first_page? => users.first_page?,
-                 :last_page? => users.last_page?,
-                 :have_pages? => users.have_pages?,
-                 :keys => users.collect(&:key))
-  end
-end

data/test/test-patricia-trie.rb

@@ -1,415 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# 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
-# 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(["129680021x504441006",
-                        "129690039x504418033",
-                        "129721099x504685024",
-                        "129786048x504792049",
-                        "129809022x504597055",
-                        "129845056x504853081",
-                        "129855010x504452003",
-                        "129866001x504328017",
-                        "129885039x503653023",
-                        "129903045x504648034"],
-                       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
-      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
-end

data/test/test-plugin.rb

@@ -1,35 +0,0 @@
-# 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