rroonga 0.9.2-x86-mingw32

data/test/test-context-select.rb

@@ -0,0 +1,93 @@
+# 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 ContextSelectTest < Test::Unit::TestCase
+  include GroongaTestUtils
+
+  setup :setup_database
+  setup
+  def setup_data
+    @books = Groonga::Hash.create(:name => "Books", :key_type => "ShortText")
+    @books.define_column("published", "Time")
+    @users = Groonga::Hash.create(:name => "Users", :key_type => "ShortText")
+    @users.define_column("book", "Books")
+
+    @books.add("the groonga book", :published => Time.parse("2010/04/01"))
+    @users.add("morita", :book => "the groonga book")
+    @users.add("gunyara-kun", :book => "the groonga book")
+    @users.add("yu")
+  end
+
+  def test_no_option
+    result = context.select(@users)
+    assert_equal([3,
+                  [{"_id" => 1, "_key" => "morita",
+                     "book" => "the groonga book"},
+                   {"_id" => 2, "_key" => "gunyara-kun",
+                     "book" => "the groonga book"},
+                   {"_id" => 3, "_key" => "yu",
+                     "book" => ""}]],
+                 [result.n_hits, result.records])
+  end
+
+  def test_success
+    result = context.select(@users)
+    assert_equal([true, 0, nil],
+                 [result.success?, result.return_code, result.error_message])
+  end
+
+  def test_output_columns
+    result = context.select(@users, :output_columns => ["_key"])
+    assert_equal([3,
+                  [{"_key" => "morita"},
+                   {"_key" => "gunyara-kun"},
+                   {"_key" => "yu"}]],
+                 [result.n_hits, result.records])
+  end
+
+  def test_drill_down
+    result = context.select(@users,
+                            :output_columns => ["_key"],
+                            :drill_down => ["_key", "book"],
+                            :drill_down_output_columns => "_key",
+                            :drill_down_limit => 10)
+    normalized_drill_down = {}
+    result.drill_down.each do |key, drill_down|
+      normalized_drill_down[key] = [drill_down.n_hits, drill_down.records]
+    end
+    assert_equal([3,
+                  [{"_key" => "morita"},
+                   {"_key" => "gunyara-kun"},
+                   {"_key" => "yu"}],
+                  {
+                    "_key" => [3, [{"_key" => "morita"},
+                                   {"_key" => "gunyara-kun"},
+                                   {"_key" => "yu"}]],
+                    "book" => [1, [{"_key" => "the groonga book"}]],
+                  },
+                 ],
+                 [result.n_hits, result.records, normalized_drill_down])
+  end
+
+  def test_time
+    result = context.select(@books)
+    assert_equal([{
+                    "_id" => 1,
+                    "_key" => "the groonga book",
+                    "published" => Time.parse("2010/04/01"),
+                  }],
+                 result.records)
+  end
+end

data/test/test-context.rb

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

@@ -0,0 +1,113 @@
+# 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::NoSuchFileOrDirectory) 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

@@ -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,93 @@
+# 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

@@ -0,0 +1,217 @@
+# 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 ExpressionBuilderTest < Test::Unit::TestCase
+  include GroongaTestUtils
+
+  setup :setup_database
+  setup :setup_tables
+  setup :setup_data
+
+  def setup_tables
+    @pets = Groonga::Hash.create(:name => "Pets", :key_type => "ShortText")
+    @pets.define_column("name", "ShortText")
+
+    @users = Groonga::Hash.create(:name => "Users", :key_type => "ShortText")
+    @name = @users.define_column("name", "ShortText")
+    @hp = @users.define_column("hp", "UInt32")
+    @users.define_column("pet", @pets)
+
+    @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["uri"]})
+  end
+
+  def test_method_chain
+    result = @bookmarks.select do |record|
+      record.user.name == @morita["name"]
+    end
+    assert_equal(["http://groonga.org/", "http://ruby-lang.org/"],
+                 result.collect {|record| record["uri"]})
+  end
+
+  def test_deep_method_chain
+    @pets.add("bob", :name => "morita Bob")
+    @morita["pet"] = "bob"
+
+    result = @bookmarks.select do |record|
+      record.user.pet.name == "morita Bob"
+    end
+    assert_equal(["http://groonga.org/", "http://ruby-lang.org/"],
+                 result.collect {|record| record["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
+
+  def test_id
+    result = @users.select do |record|
+      record.id == 1
+    end
+    assert_equal(["morita"],
+                 result.collect {|record| record.key.key})
+  end
+
+  def test_key
+    result = @users.select do |record|
+      record.key == "morita"
+    end
+    assert_equal(["morita"],
+                 result.collect {|record| record.key.key})
+  end
+
+  def test_score
+    result = @users.select do |record|
+      (record.name =~ "o") | (record.hp >= 150)
+    end
+    result = result.select do |record|
+      record.score > 1
+    end
+    assert_equal(["yu"],
+                 result.collect {|record| record["_key"]})
+  end
+
+  def test_n_sub_records
+    result = @users.select do |record|
+      (record.name =~ "o") | (record.hp >= 150)
+    end
+    result = result.select do |record|
+      record.n_sub_records > 1
+    end
+    assert_equal(["yu"],
+                 result.collect {|record| record["_key"]})
+  end
+end