rroonga 2.0.4 → 2.0.5

data/test/test-database.rb

@@ -0,0 +1,173 @@
+# 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_each_without_block
+    setup_database
+    default_object_names = @database.each.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
+
+  def test_tables
+    setup_database
+    Groonga::Schema.define do |schema|
+      schema.create_table("HashTable") do |table|
+      end
+
+      schema.create_table("PatriciaTrie",
+                          :type => :patricia_trie) do |table|
+      end
+
+      schema.create_table("DoubleArrayTrie",
+                          :type => :double_array_trie) do |table|
+      end
+    end
+
+    assert_equal(["HashTable", "PatriciaTrie", "DoubleArrayTrie"].sort,
+                 @database.tables.collect(&:name).sort)
+  end
+end

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

@@ -0,0 +1,189 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2011-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 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
+
+  def test_each
+    users = Groonga::DoubleArrayTrie.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::DoubleArrayTrie.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-encoding.rb

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

@@ -0,0 +1,230 @@
+# 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
+
+class TooManyOpenFilesTest < Test::Unit::TestCase
+  include GroongaTestUtils
+
+  def setup
+    setup_database
+    @context = create_sub_context
+  end
+
+  def test_database_each
+    setup_users
+
+    assert_error do
+      over_limit do
+        @context.database.each do
+        end
+      end
+    end
+  end
+
+  def test_context_array_reference
+    setup_users
+
+    assert_error do
+      over_limit do
+        @context["Users"]
+      end
+    end
+  end
+
+  def test_table_columns
+    setup_schema do |schema|
+      schema.create_table("Users") do |table|
+        table.short_text("name")
+      end
+    end
+
+    table = @context["Users"]
+    assert_error do
+      over_limit do
+        table.columns
+      end
+    end
+  end
+
+  def test_column_sources
+    setup_schema do |schema|
+      schema.create_table("Users") do |table|
+        table.short_text("name")
+      end
+      schema.create_table("Bookmarks") do |table|
+        table.reference("user", "Users")
+      end
+      schema.create_table("Users") do |table|
+        table.index("Bookmarks.user")
+      end
+    end
+
+    column = @context["Users"].column("Bookmarks_user")
+    assert_error do
+      over_limit do
+        column.sources
+      end
+    end
+  end
+
+  def test_string_key_type
+    setup_users
+
+    assert_error do
+      over_limit do
+        create_reference_table("Users")
+      end
+    end
+  end
+
+  def test_id_key_type
+    setup_users
+    users_id = Groonga["Users"].id
+
+    assert_error do
+      over_limit do
+        create_reference_table(users_id)
+      end
+    end
+  end
+
+  private
+  def setup_schema
+    Groonga::Schema.define do |schema|
+      yield(schema)
+    end
+  end
+
+  def setup_users
+    setup_schema do |schema|
+      schema.create_table("Users")
+    end
+  end
+
+  def create_sub_context
+    context = Groonga::Context.new
+    context.open_database(Groonga::Context.default.database.path)
+    context
+  end
+
+  def over_limit
+    unavailable = 0
+    original, max = Process.getrlimit(open_files)
+
+    Process.setrlimit(open_files, unavailable, max)
+    begin
+      yield
+    ensure
+      Process.setrlimit(open_files, original, max)
+    end
+  end
+
+  def open_files
+    Process::RLIMIT_NOFILE
+  end
+
+  def assert_error
+    assert_raise(Groonga::TooManyOpenFiles) do
+      yield
+    end
+  end
+
+  def create_reference_table(key)
+    Groonga::Hash.create(:context => @context,
+                         :name => "Bookmarks",
+                         :key_type => key)
+  end
+end