groonga 0.9.1 → 1.0.0

data/test/test-context.rb

@@ -1,73 +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 ContextTest < Test::Unit::TestCase
-  include GroongaTestUtils
-
-  def test_default
-    context = Groonga::Context.default
-    assert_equal(Groonga::Encoding.default, context.encoding)
-  end
-
-  def test_default_options
-    Groonga::Context.default_options = {
-      :encoding => :utf8,
-    }
-    context = Groonga::Context.default
-    assert_equal(Groonga::Encoding::UTF8, context.encoding)
-  end
-
-  def test_encoding
-    context = Groonga::Context.new
-    assert_equal(Groonga::Encoding.default, context.encoding)
-
-    context = Groonga::Context.new(:encoding => :utf8)
-    assert_equal(Groonga::Encoding::UTF8, context.encoding)
-  end
-
-  def test_inspect
-    context = Groonga::Context.new(:encoding => Groonga::Encoding::UTF8)
-    assert_equal("#<Groonga::Context " +
-                 "encoding: <:utf8>, " +
-                 "database: <nil>>",
-                 context.inspect)
-  end
-
-  def test_inspect_with_database
-    db = Groonga::Database.create
-    context = Groonga::Context.default
-    assert_equal("#<Groonga::Context " +
-                 "encoding: <#{Groonga::Encoding.default.inspect}>, " +
-                 "database: <#{db.inspect}>>",
-                 context.inspect)
-  end
-
-  def test_array_reference_by_string
-    Groonga::Database.create
-    context = Groonga::Context.default
-    assert_equal("Int32", context["<int>"].name)
-  end
-
-  def test_array_reference_by_symbol
-    Groonga::Database.create
-    context = Groonga::Context.default
-    assert_equal("Bool", context[:Bool].name)
-  end
-
-  def test_shortcut_access
-    Groonga::Database.create
-    assert_equal("ShortText", Groonga["ShortText"].name)
-  end
-end

data/test/test-database.rb

@@ -1,113 +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 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)
-
-    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_new
-    db_path = @tmp_dir + "db"
-    assert_raise(Groonga::NoMemoryAvailable) do
-      Groonga::Database.new(db_path.to_s)
-    end
-
-    database = 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
-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,93 +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)
-  end
-end

data/test/test-expression-builder.rb

@@ -1,156 +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 ExpressionBuilderTest < Test::Unit::TestCase
-  include GroongaTestUtils
-
-  setup :setup_database
-  setup :setup_tables
-  setup :setup_data
-
-  def setup_tables
-    @users = Groonga::Hash.create(:name => "Users")
-    @name = @users.define_column("name", "ShortText")
-    @hp = @users.define_column("hp", "UInt32")
-
-    @terms = Groonga::PatriciaTrie.create(:name => "Terms",
-                                          :default_tokenizer => "TokenBigram")
-    @terms.define_index_column("user-name", @users, :source => @name)
-
-    @bookmarks = Groonga::Array.create(:name => "Bookmarks")
-    @bookmarks.define_column("user", @users)
-    @bookmarks.define_column("uri", "ShortText")
-  end
-
-  def setup_data
-    @morita = @users.add("morita",
-                         :name => "mori daijiro",
-                         :hp => 100)
-    @gunyara_kun = @users.add("gunyara-kun",
-                              :name => "Tasuku SUENAGA",
-                              :hp => 150)
-    @yu = @users.add("yu",
-                     :name => "Yutaro Shimamura",
-                     :hp => 200)
-
-    @groonga = @bookmarks.add(:user => @morita, :uri => "http://groonga.org/")
-    @ruby = @bookmarks.add(:user => @morita, :uri => "http://ruby-lang.org/")
-    @nico_dict = @bookmarks.add(:user => @gunyara_kun,
-                                :uri => "http://dic.nicovideo.jp/")
-  end
-
-  def test_equal
-    result = @users.select do |record|
-      record["name"] == "mori daijiro"
-    end
-    assert_equal(["morita"],
-                 result.collect {|record| record.key.key})
-  end
-
-  def test_not_equal
-    omit("not supported yet!!!")
-    result = @users.select do |record|
-      record["name"] != "mori daijiro"
-    end
-    assert_equal(["gunyara-kun", "yu"],
-                 result.collect {|record| record.key.key})
-  end
-
-  def test_less
-    result = @users.select do |record|
-      record["hp"] < 150
-    end
-    assert_equal(["morita"], result.collect {|record| record.key.key})
-  end
-
-  def test_less_equal
-    result = @users.select do |record|
-      record["hp"] <= 150
-    end
-    assert_equal(["morita", "gunyara-kun"],
-                 result.collect {|record| record.key.key})
-  end
-
-  def test_greater
-    result = @users.select do |record|
-      record["hp"] > 150
-    end
-    assert_equal(["yu"], result.collect {|record| record.key.key})
-  end
-
-  def test_greater_equal
-    result = @users.select do |record|
-      record["hp"] >= 150
-    end
-    assert_equal(["gunyara-kun", "yu"],
-                 result.collect {|record| record.key.key})
-  end
-
-  def test_and
-    result = @users.select do |record|
-      (record["hp"] > 100) & (record["hp"] <= 200)
-    end
-    assert_equal(["gunyara-kun", "yu"],
-                 result.collect {|record| record.key.key})
-  end
-
-  def test_match
-    result = @users.select do |record|
-      record["name"] =~ "ro"
-    end
-    assert_equal(["morita", "yu"],
-                 result.collect {|record| record.key.key})
-  end
-
-  def test_query_string
-    result = @users.select("name:%ro")
-    assert_equal(["morita", "yu"],
-                 result.collect {|record| record.key.key})
-  end
-
-  def test_record
-    result = @bookmarks.select do |record|
-      record["user"] == @morita
-    end
-    assert_equal(["http://groonga.org/", "http://ruby-lang.org/"],
-                 result.collect {|record| record.key["uri"]})
-  end
-
-  def test_record_id
-    result = @bookmarks.select do |record|
-      record["user"] == @morita.id
-    end
-    assert_equal(["http://groonga.org/", "http://ruby-lang.org/"],
-                 result.collect {|record| record.key["uri"]})
-  end
-
-  def test_nested_column
-    result = @bookmarks.select do |record|
-      record[".user.name"] == @morita["name"]
-    end
-    assert_equal(["http://groonga.org/", "http://ruby-lang.org/"],
-                 result.collect {|record| record.key["uri"]})
-  end
-
-  def test_nil_match
-    @users.select do |record|
-      exception = ArgumentError.new("match word should not be nil: Users.name")
-      assert_raise(exception) do
-        record["name"] =~ nil
-      end
-      record["name"] == "dummy"
-    end
-  end
-end