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

data/test/test-database-dumper.rb

@@ -1,259 +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 DatabaseDumperTest < Test::Unit::TestCase
-  include GroongaTestUtils
-
-  setup :setup_database, :before => :append
-
-  setup
-  def setup_tables
-    Groonga::Schema.define do |schema|
-      schema.create_table("Tags",
-                          :type => :hash,
-                          :key_type => :short_text,
-                          :default_tokenizer => :delimit) do |table|
-        table.text("name")
-      end
-
-      schema.create_table("Users",
-                          :type => :hash,
-                          :key_type => "ShortText") do |table|
-        table.text("name")
-      end
-
-      schema.create_table("Posts") do |table|
-        table.text("title")
-        table.reference("author", "Users")
-        table.integer("rank")
-        table.unsigned_integer("n_goods")
-        table.short_text("tag_text")
-        table.reference("tags", "Tags", :type => :vector)
-        table.boolean("published")
-        table.time("created_at")
-      end
-
-      schema.change_table("Users") do |table|
-        table.index("Posts.author")
-      end
-
-      schema.change_table("Tags") do |table|
-        table.index("Posts.tag_text")
-      end
-    end
-  end
-
-  private
-  def dump(options={})
-    Groonga::DatabaseDumper.new(options).dump
-  end
-
-  def posts
-    context["Posts"]
-  end
-
-  def dumped_schema
-    <<-EOS
-table_create Posts TABLE_NO_KEY
-column_create Posts created_at COLUMN_SCALAR Time
-column_create Posts n_goods COLUMN_SCALAR UInt32
-column_create Posts published COLUMN_SCALAR Bool
-column_create Posts rank COLUMN_SCALAR Int32
-column_create Posts tag_text COLUMN_SCALAR ShortText
-column_create Posts title COLUMN_SCALAR Text
-
-table_create Tags TABLE_HASH_KEY --key_type ShortText --default_tokenizer TokenDelimit
-column_create Tags name COLUMN_SCALAR Text
-
-table_create Users TABLE_HASH_KEY --key_type ShortText
-column_create Users name COLUMN_SCALAR Text
-
-column_create Posts author COLUMN_SCALAR Users
-column_create Posts tags COLUMN_VECTOR Tags
-
-column_create Tags Posts_tag_text COLUMN_INDEX Posts tag_text
-
-column_create Users Posts_author COLUMN_INDEX Posts author
-EOS
-  end
-
-  class EmptyTest < DatabaseDumperTest
-    def test_default
-      assert_equal(dumped_schema, dump)
-    end
-  end
-
-  class HaveDataTest < DatabaseDumperTest
-    setup
-    def setup_data
-      posts.add(:author => "mori",
-                :created_at => Time.parse("2010-03-08 16:52 JST"),
-                :n_goods => 4,
-                :published => true,
-                :rank => 10,
-                :tag_text => "search mori",
-                :tags => ["search", "mori"],
-                :title => "Why search engine find?")
-    end
-
-    def test_default
-      assert_equal(<<-EOS, dump)
-#{dumped_schema.chomp}
-
-load --table Posts
-[
-["_id","author","created_at","n_goods","published","rank","tag_text","tags","title"],
-[1,"mori",1268034720.0,4,true,10,"search mori",["search","mori"],"Why search engine find?"]
-]
-
-load --table Tags
-[
-["_key","name"],
-["search",""],
-["mori",""]
-]
-
-load --table Users
-[
-["_key","name"],
-["mori",""]
-]
-EOS
-    end
-
-    def test_limit_tables
-      assert_equal(<<-EOS, dump(:tables => ["Posts"]))
-#{dumped_schema.chomp}
-
-load --table Posts
-[
-["_id","author","created_at","n_goods","published","rank","tag_text","tags","title"],
-[1,"mori",1268034720.0,4,true,10,"search mori",["search","mori"],"Why search engine find?"]
-]
-EOS
-    end
-
-    def test_limit_tables_with_regexp
-      assert_equal(<<-EOS, dump(:tables => [/Posts?/]))
-#{dumped_schema.chomp}
-
-load --table Posts
-[
-["_id","author","created_at","n_goods","published","rank","tag_text","tags","title"],
-[1,"mori",1268034720.0,4,true,10,"search mori",["search","mori"],"Why search engine find?"]
-]
-EOS
-    end
-
-    def test_exclude_tables
-      dump_options = {
-        :exclude_tables => ["Posts"],
-      }
-      assert_equal(<<-EOS, dump(dump_options))
-#{dumped_schema.chomp}
-
-load --table Tags
-[
-["_key","name"],
-["search",""],
-["mori",""]
-]
-
-load --table Users
-[
-["_key","name"],
-["mori",""]
-]
-EOS
-    end
-
-    def test_exclude_tables_with_regexp
-      dump_options = {
-        :exclude_tables => [/Posts?/],
-      }
-      assert_equal(<<-EOS, dump(dump_options))
-#{dumped_schema.chomp}
-
-load --table Tags
-[
-["_key","name"],
-["search",""],
-["mori",""]
-]
-
-load --table Users
-[
-["_key","name"],
-["mori",""]
-]
-EOS
-    end
-
-    def test_tables_combination
-      dump_options = {
-        :exclude_tables => ["Posts"],
-        :tables => ["Posts", "Users"],
-      }
-      assert_equal(<<-EOS, dump(dump_options))
-#{dumped_schema.chomp}
-
-load --table Users
-[
-["_key","name"],
-["mori",""]
-]
-EOS
-    end
-
-    def test_no_schema
-      assert_equal(<<-EOS, dump(:dump_schema => false))
-load --table Posts
-[
-["_id","author","created_at","n_goods","published","rank","tag_text","tags","title"],
-[1,"mori",1268034720.0,4,true,10,"search mori",["search","mori"],"Why search engine find?"]
-]
-
-load --table Tags
-[
-["_key","name"],
-["search",""],
-["mori",""]
-]
-
-load --table Users
-[
-["_key","name"],
-["mori",""]
-]
-EOS
-    end
-
-    def test_no_tables
-      assert_equal(<<-EOS, dump(:dump_tables => false))
-#{dumped_schema.chomp}
-EOS
-    end
-  end
-
-  class PluginTest < DatabaseDumperTest
-    def test_standard_plugin
-      Groonga::Plugin.register("suggest/suggest")
-      assert_equal("register suggest/suggest\n" +
-                   "\n" +
-                   dumped_schema,
-                   dump)
-    end
-  end
-end

data/test/test-database.rb

@@ -1,148 +0,0 @@
-# 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 DatabaseTest < Test::Unit::TestCase
-  include GroongaTestUtils
-
-  def test_create
-    assert_nil(Groonga::Context.default.database)
-
-    db_path = @tmp_dir + "db"
-    assert_not_predicate(db_path, :exist?)
-    database = Groonga::Database.create(:path => db_path.to_s)
-    assert_predicate(db_path, :exist?)
-    assert_not_predicate(database, :closed?)
-
-    assert_equal(database, Groonga::Context.default.database)
-  end
-
-  def test_temporary
-    before_files = @tmp_dir.children
-    database = Groonga::Database.create
-    assert_nil(database.name)
-    assert_equal(before_files, @tmp_dir.children)
-  end
-
-  def test_open
-    db_path = @tmp_dir + "db"
-    database = Groonga::Database.create(:path => db_path.to_s)
-    database.close
-
-    assert_predicate(database, :closed?)
-    called = false
-    Groonga::Database.open(db_path.to_s) do |_database|
-      database = _database
-      assert_not_predicate(database, :closed?)
-      called = true
-    end
-    assert_true(called)
-    assert_predicate(database, :closed?)
-  end
-
-  def test_close
-    db_path = @tmp_dir + "db"
-    database = Groonga::Database.create(:path => db_path.to_s)
-    database.close
-
-    database = Groonga::Database.open(db_path.to_s)
-    assert_not_predicate(database, :closed?)
-    database.close
-    assert_predicate(database, :closed?)
-  end
-
-  def test_new
-    db_path = @tmp_dir + "db"
-    assert_raise(Groonga::NoSuchFileOrDirectory) do
-      Groonga::Database.new(db_path.to_s)
-    end
-
-    Groonga::Database.create(:path => db_path.to_s)
-    assert_not_predicate(Groonga::Database.new(db_path.to_s), :closed?)
-  end
-
-  def test_each
-    db_path = @tmp_dir + "db"
-    database = Groonga::Database.create(:path => db_path.to_s)
-    default_object_names = database.collect {|object| object.name}.sort
-    assert_send([default_object_names, :include?, "Bool"])
-  end
-
-  def test_encoding
-    assert_equal(Groonga::Encoding.default,
-                 Groonga::Database.create.encoding)
-  end
-
-  def test_lock
-    database = Groonga::Database.create
-
-    assert_not_predicate(database, :locked?)
-    database.lock
-    assert_predicate(database, :locked?)
-    database.unlock
-    assert_not_predicate(database, :locked?)
-  end
-
-  def test_lock_failed
-    database = Groonga::Database.create
-
-    database.lock
-    assert_raise(Groonga::ResourceDeadlockAvoided) do
-      database.lock
-    end
-  end
-
-  def test_lock_block
-    database = Groonga::Database.create
-
-    assert_not_predicate(database, :locked?)
-    database.lock do
-      assert_predicate(database, :locked?)
-    end
-    assert_not_predicate(database, :locked?)
-  end
-
-  def test_clear_lock
-    database = Groonga::Database.create
-
-    assert_not_predicate(database, :locked?)
-    database.lock
-    assert_predicate(database, :locked?)
-    database.clear_lock
-    assert_not_predicate(database, :locked?)
-  end
-
-  def test_touch
-    database = Groonga::Database.create
-    assert_nothing_raised do
-      database.touch
-    end
-  end
-
-  def test_defrag
-    setup_database
-    Groonga::Schema.define do |schema|
-      schema.create_table("Users") do |table|
-        table.short_text("name")
-        table.short_text("address")
-      end
-    end
-    users = context["Users"]
-    1000.times do |i|
-      users.add(:name => "user #{i}" * 1000,
-                :address => "address #{i}" * 1000)
-    end
-    assert_equal(7, @database.defrag)
-  end
-end

data/test/test-double-array-trie.rb

@@ -1,164 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# 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 DoubleArrayTrieTest < Test::Unit::TestCase
-  include GroongaTestUtils
-  include ERB::Util
-
-  setup :setup_database
-
-  def test_support_key?
-    assert_predicate(Groonga::DoubleArrayTrie.create(:name => "Users",
-                                                     :key_type => "ShortText"),
-                     :support_key?)
-  end
-
-  def test_encoding
-    assert_equal(Groonga::Encoding.default,
-                 Groonga::DoubleArrayTrie.create.encoding)
-  end
-
-  def test_tokenizer
-    trie = Groonga::DoubleArrayTrie.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::DoubleArrayTrie.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::DoubleArrayTrie.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::DoubleArrayTrie.create(:name => "Terms",
-                                            :default_tokenizer => "TokenUnigram")
-    assert_equal(context[Groonga::Type::UNIGRAM],
-                 terms.default_tokenizer)
-  end
-
-  def test_duplicated_name
-    Groonga::DoubleArrayTrie.create(:name => "Users")
-    assert_raise(Groonga::InvalidArgument) do
-      Groonga::DoubleArrayTrie.create(:name => "Users")
-    end
-  end
-
-  def test_has_key?
-    users = Groonga::DoubleArrayTrie.create(:name => "Users")
-    assert_false(users.has_key?("morita"))
-    users.add("morita")
-    assert_true(users.has_key?("morita"))
-  end
-
-  def test_prefix_cursor
-    paths = Groonga::DoubleArrayTrie.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_add_uint_key
-    numbers = Groonga::DoubleArrayTrie.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::DoubleArrayTrie.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::DoubleArrayTrie.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::DoubleArrayTrie.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-encoding.rb

@@ -1,33 +0,0 @@
-# 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 EncodingTest < Test::Unit::TestCase
-  include GroongaTestUtils
-
-  def test_constants
-    assert_equal(:default, Groonga::Encoding::DEFAULT)
-    assert_equal(:none, Groonga::Encoding::NONE)
-    assert_equal(:euc_jp, Groonga::Encoding::EUC_JP)
-    assert_equal(:sjis, Groonga::Encoding::SJIS)
-    assert_equal(:utf8, Groonga::Encoding::UTF8)
-    assert_equal(:latin1, Groonga::Encoding::LATIN1)
-    assert_equal(:koi8r, Groonga::Encoding::KOI8R)
-  end
-
-  def test_default
-    Groonga::Encoding.default = :utf8
-    assert_equal(:utf8, Groonga::Encoding.default)
-  end
-end

data/test/test-exception.rb

@@ -1,96 +0,0 @@
-# Copyright (C) 2009-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 ExceptionTest < Test::Unit::TestCase
-  include GroongaTestUtils
-
-  def test_defined
-    assert_not_const_defined(Groonga, :Success)
-
-    assert_const_defined(Groonga, :Error)
-    assert_const_defined(Groonga, :ObjectClosed)
-
-    assert_const_defined(Groonga, :EndOfData)
-    assert_const_defined(Groonga, :UnknownError)
-    assert_const_defined(Groonga, :OperationNotPermitted)
-    assert_const_defined(Groonga, :NoSuchFileOrDirectory)
-    assert_const_defined(Groonga, :NoSuchProcess)
-    assert_const_defined(Groonga, :InterruptedFunctionCall)
-    assert_const_defined(Groonga, :InputOutputError)
-    assert_const_defined(Groonga, :NoSuchDeviceOrAddress)
-    assert_const_defined(Groonga, :ArgumentListTooLong)
-    assert_const_defined(Groonga, :ExecFormatError)
-    assert_const_defined(Groonga, :BadFileDescriptor)
-    assert_const_defined(Groonga, :NoChildProcesses)
-    assert_const_defined(Groonga, :ResourceTemporarilyUnavailable)
-    assert_const_defined(Groonga, :NotEnoughSpace)
-    assert_const_defined(Groonga, :PermissionDenied)
-    assert_const_defined(Groonga, :BadAddress)
-    assert_const_defined(Groonga, :ResourceBusy)
-    assert_const_defined(Groonga, :FileExists)
-    assert_const_defined(Groonga, :ImproperLink)
-    assert_const_defined(Groonga, :NoSuchDevice)
-    assert_const_defined(Groonga, :NotADirectory)
-    assert_const_defined(Groonga, :IsADirectory)
-    assert_const_defined(Groonga, :InvalidArgument)
-    assert_const_defined(Groonga, :TooManyOpenFilesInSystem)
-    assert_const_defined(Groonga, :TooManyOpenFiles)
-    assert_const_defined(Groonga, :InappropriateIOControlOperation)
-    assert_const_defined(Groonga, :FileTooLarge)
-    assert_const_defined(Groonga, :NoSpaceLeftOnDevice)
-    assert_const_defined(Groonga, :InvalidSeek)
-    assert_const_defined(Groonga, :ReadOnlyFileSystem)
-    assert_const_defined(Groonga, :TooManyLinks)
-    assert_const_defined(Groonga, :BrokenPipe)
-    assert_const_defined(Groonga, :DomainError)
-    assert_const_defined(Groonga, :ResultTooLarge)
-    assert_const_defined(Groonga, :ResourceDeadlockAvoided)
-    assert_const_defined(Groonga, :NoMemoryAvailable)
-    assert_const_defined(Groonga, :FilenameTooLong)
-    assert_const_defined(Groonga, :NoLocksAvailable)
-    assert_const_defined(Groonga, :FunctionNotImplemented)
-    assert_const_defined(Groonga, :DirectoryNotEmpty)
-    assert_const_defined(Groonga, :IllegalByteSequence)
-    assert_const_defined(Groonga, :SocketNotInitialized)
-    assert_const_defined(Groonga, :OperationWouldBlock)
-    assert_const_defined(Groonga, :AddressIsNotAvailable)
-    assert_const_defined(Groonga, :NetworkIsDown)
-    assert_const_defined(Groonga, :NoBuffer)
-    assert_const_defined(Groonga, :SocketIsAlreadyConnected)
-    assert_const_defined(Groonga, :SocketIsNotConnected)
-    assert_const_defined(Groonga, :SocketIsAlreadyShutdowned)
-    assert_const_defined(Groonga, :OperationTimeout)
-    assert_const_defined(Groonga, :ConnectionRefused)
-    assert_const_defined(Groonga, :RangeError)
-    assert_const_defined(Groonga, :TokenizerError)
-    assert_const_defined(Groonga, :FileCorrupt)
-    assert_const_defined(Groonga, :InvalidFormat)
-    assert_const_defined(Groonga, :ObjectCorrupt)
-    assert_const_defined(Groonga, :TooManySymbolicLinks)
-    assert_const_defined(Groonga, :NotSocket)
-    assert_const_defined(Groonga, :OperationNotSupported)
-    assert_const_defined(Groonga, :AddressIsInUse)
-    assert_const_defined(Groonga, :ZLibError)
-    assert_const_defined(Groonga, :LZOError)
-    assert_const_defined(Groonga, :StackOverFlow)
-    assert_const_defined(Groonga, :SyntaxError)
-    assert_const_defined(Groonga, :RetryMax)
-    assert_const_defined(Groonga, :IncompatibleFileFormat)
-    assert_const_defined(Groonga, :UpdateNotAllowed)
-    assert_const_defined(Groonga, :TooSmallOffset)
-    assert_const_defined(Groonga, :TooLargeOffset)
-    assert_const_defined(Groonga, :TooSmallLimit)
-  end
-end