rroonga 2.0.4 → 2.0.5

data/test/test-plugin.rb

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

data/test/test-procedure.rb

@@ -0,0 +1,37 @@
+# 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 ProcedureTest < Test::Unit::TestCase
+  include GroongaTestUtils
+
+  setup :setup_database
+
+  def test_builtins
+    assert_equal_procedure("TokenDelimit", Groonga::Procedure::DELIMIT)
+    assert_equal_procedure("TokenUnigram", Groonga::Procedure::UNIGRAM)
+    assert_equal_procedure("TokenBigram", Groonga::Procedure::BIGRAM)
+    assert_equal_procedure("TokenTrigram", Groonga::Procedure::TRIGRAM)
+    assert_equal_procedure("TokenMecab", Groonga::Procedure::MECAB,
+                           :accept_nil => true)
+  end
+
+  private
+  def assert_equal_procedure(expected_name, id, options={})
+    procedure = Groonga::Context.default[id]
+    expected_name = nil if procedure.nil? and options[:accept_nil]
+    assert_equal(expected_name,
+                 procedure ? procedure.name : procedure)
+  end
+end

data/test/test-query-log.rb

@@ -0,0 +1,258 @@
+# -*- 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
+
+require "cgi"
+
+module QueryLogTest
+  module CommandParseTestUtils
+    private
+    def command(name, parameters)
+      Groonga::QueryLog::Command.new(name, parameters)
+    end
+
+    def parse_http_path(command, parameters)
+      path = "/d/#{command}.json"
+      unless parameters.empty?
+        uri_parameters = parameters.collect do |key, value|
+          [CGI.escape(key.to_s), CGI.escape(value.to_s)].join("=")
+        end
+        path << "?"
+        path << uri_parameters.join("&")
+      end
+      Groonga::QueryLog::Command.parse(path)
+    end
+
+    def parse_command_line(command, parameters)
+      command_line = "#{command} --output_type json"
+      parameters.each do |key, value|
+        if /"| / =~ value
+          escaped_value = '"' + value.gsub(/"/, '\"') + '"'
+        else
+          escaped_value = value
+        end
+        command_line << " --#{key} #{escaped_value}"
+      end
+      Groonga::QueryLog::Command.parse(command_line)
+    end
+  end
+
+  module HTTPCommandParseTestUtils
+    private
+    def parse(command, parameters={})
+      parse_http_path(command, parameters)
+    end
+  end
+
+  module CommandLineCommandParseTestUtils
+    private
+    def parse(command, parameters={})
+      parse_command_line(command, parameters)
+    end
+  end
+
+  module SelectCommandParseTests
+    include CommandParseTestUtils
+
+    def test_parameters
+      select = parse("select",
+                     :table => "Users",
+                     :filter => "age<=30")
+      assert_equal(command("select",
+                           "table" => "Users",
+                           "filter" => "age<=30",
+                           "output_type" => "json"),
+                   select)
+    end
+
+    def test_scorer
+      select = parse("select",
+                     :table => "Users",
+                     :filter => "age<=30",
+                     :scorer => "_score = random()")
+      assert_equal("_score = random()", select.scorer)
+    end
+
+    def test_to_uri_format
+      select = parse("select",
+                     :table => "Users",
+                     :filter => "age<=30")
+      assert_equal("/d/select.json?filter=age%3C%3D30&table=Users",
+                   select.to_uri_format)
+    end
+
+    def test_to_command_format
+      select = parse("select",
+                     :table => "Users",
+                     :filter => "age<=30")
+      assert_equal("select --filter \"age<=30\" " +
+                   "--output_type \"json\" --table \"Users\"",
+                   select.to_command_format)
+    end
+  end
+
+  module SelectCommandParseFilterTests
+    include CommandParseTestUtils
+
+    def test_parenthesis
+      filter = 'geo_in_rectangle(location,' +
+                                '"35.73360x139.7394","62614x139.7714") && ' +
+               '((type == "たいやき" || type == "和菓子")) && ' +
+               'keyword @ "たいやき" &! keyword @ "白" &! keyword @ "養殖"'
+      select = parse("select",
+                     :table => "Users",
+                     :filter => filter)
+      assert_equal(['geo_in_rectangle(location,' +
+                                     '"35.73360x139.7394","62614x139.7714")',
+                     'type == "たいやき"',
+                     'type == "和菓子"',
+                     'keyword @ "たいやき"',
+                     'keyword @ "白"',
+                     'keyword @ "養殖"'],
+                   select.conditions)
+    end
+
+    def test_to_uri_format
+      filter = 'geo_in_rectangle(location,' +
+                                '"35.73360x139.7394","62614x139.7714") && ' +
+               '((type == "たいやき" || type == "和菓子")) && ' +
+               'keyword @ "たいやき" &! keyword @ "白" &! keyword @ "養殖"'
+      select = parse("select",
+                     :table => "Users",
+                     :filter => filter)
+      assert_equal("/d/select.json?filter=geo_in_rectangle%28location%2C" +
+                   "%2235.73360x139.7394%22%2C%2262614x139.7714%22%29+" +
+                   "%26%26+%28%28type+" +
+                   "%3D%3D+%22%E3%81%9F%E3%81%84%E3%82%84%E3%81%8D%22+" +
+                   "%7C%7C+type+%3D%3D+" +
+                   "%22%E5%92%8C%E8%8F%93%E5%AD%90%22%29%29+" +
+                   "%26%26+keyword+%40+" +
+                   "%22%E3%81%9F%E3%81%84%E3%82%84%E3%81%8D%22+%26%21+" +
+                   "keyword+%40+%22%E7%99%BD%22+%26%21+" +
+                   "keyword+%40+%22%E9%A4%8A%E6%AE%96%22&table=Users",
+                   select.to_uri_format)
+    end
+
+    def test_to_command_format
+      filter = 'geo_in_rectangle(location,' +
+                                '"35.73360x139.7394","62614x139.7714") && ' +
+               '((type == "たいやき" || type == "和菓子")) && ' +
+               'keyword @ "たいやき" &! keyword @ "白" &! keyword @ "養殖"'
+      select = parse("select",
+                     :table => "Users",
+                     :filter => filter)
+      assert_equal("select " +
+                   "--filter " +
+                     "\"geo_in_rectangle(location," +
+                     "\\\"35.73360x139.7394\\\",\\\"62614x139.7714\\\") && " +
+                     "((type == \\\"たいやき\\\" || " +
+                       "type == \\\"和菓子\\\")) && " +
+                     "keyword @ \\\"たいやき\\\" &! keyword @ \\\"白\\\" &! " +
+                     "keyword @ \\\"養殖\\\"\" " +
+                   "--output_type \"json\" --table \"Users\"",
+                   select.to_command_format)
+    end
+  end
+
+  class HTTPSelectCommandParseTest < Test::Unit::TestCase
+    include SelectCommandParseTests
+    include SelectCommandParseFilterTests
+    include HTTPCommandParseTestUtils
+
+    def test_uri_format?
+      command = parse("status")
+      assert_predicate(command, :uri_format?)
+    end
+
+    def test_command_format?
+      command = parse("status")
+      assert_not_predicate(command, :command_format?)
+    end
+  end
+
+  class CommandLineSelecCommandParseTest < Test::Unit::TestCase
+    include SelectCommandParseTests
+    include SelectCommandParseFilterTests
+    include CommandLineCommandParseTestUtils
+
+    def test_uri_format?
+      command = parse("status")
+      assert_not_predicate(command, :uri_format?)
+    end
+
+    def test_command_format?
+      command = parse("status")
+      assert_predicate(command, :command_format?)
+    end
+  end
+
+  class StatisticOperationParseTest < Test::Unit::TestCase
+    def test_context
+      operations = statistics.first.operations.collect do |operation|
+        [operation[:name], operation[:context]]
+      end
+      expected = [
+        ["filter", "local_name @ \"gsub\""],
+        ["filter", "description @ \"string\""],
+        ["select", nil],
+        ["sort", "_score"],
+        ["output", "_key"],
+        ["drilldown", "name"],
+        ["drilldown", "class"],
+      ]
+      assert_equal(expected, operations)
+    end
+
+    def test_n_records
+      operations = statistics.first.operations.collect do |operation|
+        [operation[:name], operation[:n_records]]
+      end
+      expected = [
+        ["filter", 15],
+        ["filter", 13],
+        ["select", 13],
+        ["sort", 10],
+        ["output", 10],
+        ["drilldown", 3],
+        ["drilldown", 2],
+      ]
+      assert_equal(expected, operations)
+    end
+
+    private
+    def log
+      <<-EOL
+2011-06-02 16:27:04.731685|5091e5c0|>/d/select.join?table=Entries&filter=local_name+%40+%22gsub%22+%26%26+description+%40+%22string%22&sortby=_score&output_columns=_key&drilldown=name,class
+2011-06-02 16:27:04.733539|5091e5c0|:000000001849451 filter(15)
+2011-06-02 16:27:04.734978|5091e5c0|:000000003293459 filter(13)
+2011-06-02 16:27:04.735012|5091e5c0|:000000003327415 select(13)
+2011-06-02 16:27:04.735096|5091e5c0|:000000003411824 sort(10)
+2011-06-02 16:27:04.735232|5091e5c0|:000000003547265 output(10)
+2011-06-02 16:27:04.735606|5091e5c0|:000000003921419 drilldown(3)
+2011-06-02 16:27:04.735762|5091e5c0|:000000004077552 drilldown(2)
+2011-06-02 16:27:04.735808|5091e5c0|<000000004123726 rc=0
+EOL
+    end
+
+    def statistics
+      statistics = []
+      parser = Groonga::QueryLog::Parser.new
+      parser.parse(StringIO.new(log)) do |statistic|
+        statistics << statistic
+      end
+      statistics
+    end
+  end
+end

data/test/test-record.rb

@@ -0,0 +1,577 @@
+# Copyright (C) 2009-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 RecordTest < Test::Unit::TestCase
+  include GroongaTestUtils
+
+  def setup
+    setup_database
+
+    setup_addresses_table
+    setup_users_table
+    setup_bookmarks_table
+    setup_indexes
+  end
+
+  def setup_addresses_table
+    @addresses = Groonga::Array.create(:name => "Addresses")
+    @addresses.define_column("mail", "ShortText")
+  end
+
+  def setup_users_table
+    @users = Groonga::Hash.create(:name => "Users",
+                                  :key_type => "ShortText")
+    @users.define_column("addresses", @addresses, :type => "vector")
+  end
+
+  def setup_bookmarks_table
+    @bookmarks = Groonga::Array.create(:name => "Bookmarks",
+                                       :value_type => "Int32")
+    @bookmarks.define_column("uri", "ShortText")
+    @bookmarks.define_column("rate", "Int32")
+    @bookmarks.define_column("comment", "Text")
+    @bookmarks.define_column("content", "LongText")
+    @bookmarks.define_column("user", @users)
+  end
+
+  def setup_indexes
+    @bookmarks_index =  Groonga::PatriciaTrie.create(:name => "BookmarksIndex")
+    @bookmarks_index.default_tokenizer = "TokenBigram"
+
+    @bookmarks_content_index =
+      @bookmarks_index.define_index_column("content", @bookmarks,
+                                           :with_section => true,
+                                           :with_weight => true,
+                                           :with_position => true,
+                                           :source => "Bookmarks.content")
+    @bookmarks_index.define_index_column("uri", @bookmarks,
+                                         :with_position => true,
+                                         :source => "Bookmarks.uri")
+  end
+
+  def test_column_accessor
+    groonga = @bookmarks.add
+
+    groonga["uri"] = "http://groonga.org/"
+    assert_equal("http://groonga.org/", groonga["uri"])
+
+    groonga["comment"] = "fulltext search engine"
+    assert_equal("fulltext search engine", groonga["comment"])
+  end
+
+  def test_have_column?
+    groonga = @bookmarks.add
+    assert_true(groonga.have_column?(:uri))
+    assert_false(groonga.have_column?(:nonexistent))
+  end
+
+  def test_have_column_id
+    groonga = @bookmarks.add
+    assert_true(groonga.have_column?(:_id))
+  end
+
+  def test_have_column_key_hash
+    mori = @users.add("mori")
+    assert_true(mori.have_column?(:_key))
+  end
+
+  def test_have_column_key_array_with_value_type
+    groonga = @bookmarks.add
+    assert_true(groonga.have_column?(:_key))
+  end
+
+  def test_have_column_key_array_without_value_type
+    groonga_ml = @addresses.add
+    assert_false(groonga_ml.have_column?(:_key))
+  end
+
+  def test_have_column_nsubrecs_existent
+    @users.add("mori")
+    bookmarks = @users.select do |record|
+      record.key == "mori"
+    end
+    assert_true(bookmarks.to_a.first.have_column?(:_nsubrecs))
+  end
+
+  def test_have_column_nsubrecs_nonexistent
+    groonga = @bookmarks.add
+    assert_false(groonga.have_column?(:_nsubrecs))
+  end
+
+  def test_get_nonexistent_column
+    groonga = @bookmarks.add
+    assert_raise(Groonga::NoSuchColumn) do
+      groonga["nonexistent"]
+    end
+  end
+
+  def test_set_nonexistent_column
+    groonga = @bookmarks.add
+    assert_raise(Groonga::NoSuchColumn) do
+      groonga["nonexistent"] = "value"
+    end
+  end
+
+  def test_set_object_id
+    groonga = @bookmarks.add
+    daijiro = @users.add("daijiro")
+    assert_nil(groonga["user"])
+    groonga["user"] = daijiro
+    assert_equal(daijiro, groonga["user"])
+  end
+
+  def test_set_nil
+    groonga = @bookmarks.add(:content => "groonga")
+    assert_equal("groonga", groonga["content"])
+    groonga["content"] = nil
+    assert_nil(groonga["content"])
+  end
+
+  def test_set_empty_string
+    groonga = @bookmarks.add(:content => "groonga")
+    assert_equal("groonga", groonga["content"])
+    groonga["content"] = ""
+    assert_nil(groonga["content"])
+  end
+
+  def test_set_nil_reference
+    groonga = @bookmarks.add(:user => "daijiro",
+                             :uri => "http://groonga.org/")
+    groonga.user = nil
+    assert_nil(groonga.user)
+  end
+
+  def test_set_empty_key_reference
+    groonga = @bookmarks.add(:user => "daijiro",
+                             :uri => "http://groonga.org/")
+    assert_equal(@users["daijiro"], groonga.user)
+    groonga["user"] = ""
+    assert_nil(groonga.user)
+  end
+
+  def test_set_string_to_integer_column
+    groonga = @bookmarks.add(:content => "groonga")
+    groonga.rate = "100"
+    assert_equal(100, groonga.rate)
+  end
+
+  def test_delete
+    bookmark_records = []
+    bookmark_records << @bookmarks.add
+    bookmark_records << @bookmarks.add
+    bookmark_records << @bookmarks.add
+
+    assert_equal(3, @bookmarks.size)
+    bookmark_records[1].delete
+    assert_equal(2, @bookmarks.size)
+  end
+
+  def test_key
+    documents = Groonga::PatriciaTrie.create(:name => "Documents",
+                                             :key_type => "ShortText")
+    reference = documents.add("reference")
+    assert_equal("reference", reference.key)
+  end
+
+  def test_value
+    bookmark = @bookmarks.add
+    assert_equal(0, bookmark.value)
+    bookmark.value = 100
+    assert_equal(100, bookmark.value)
+  end
+
+  def test_reference_column?
+    bookmark = @bookmarks.add
+    assert_false(bookmark.reference_column?("uri"))
+    assert_true(bookmark.reference_column?("user"))
+  end
+
+  def test_index_column?
+    bookmark = @bookmarks.add
+    assert_false(bookmark.index_column?("uri"))
+    index = @bookmarks_index.add("token")
+    assert_true(index.index_column?("content"))
+  end
+
+  def test_vector_column?
+    bookmark = @bookmarks.add
+    assert_false(bookmark.vector_column?("uri"))
+    morita = @users.add("morita")
+    assert_true(morita.vector_column?("addresses"))
+  end
+
+  def test_scalar_column?
+    bookmark = @bookmarks.add
+    assert_true(bookmark.scalar_column?("uri"))
+    morita = @users.add("morita")
+    assert_false(morita.scalar_column?("addresses"))
+  end
+
+  def test_score
+    groonga = @bookmarks.add
+    groonga["content"] = "full text search search search engine."
+
+    google = @bookmarks.add
+    google["content"] = "Web search engine."
+
+    results = @bookmarks_content_index.search("search")
+    assert_equal([[groonga.id, 3], [google.id, 1]],
+                 results.collect do |record|
+                   [record.id, record.score]
+                 end)
+  end
+
+  def test_score=
+    groonga = @bookmarks.add
+    groonga["content"] = "full text search search search engine."
+
+    google = @bookmarks.add
+    google["content"] = "Web search engine."
+
+    results = @bookmarks_content_index.search("search")
+    results.each do |record|
+      record.score *= 10
+    end
+    assert_equal([[groonga.id, 30], [google.id, 10]],
+                 results.collect do |record|
+                   [record.id, record.score]
+                 end)
+  end
+
+  def test_increment!
+    groonga = @bookmarks.add
+    assert_equal(0, groonga["rate"])
+    groonga.increment!("rate")
+    assert_equal(1, groonga["rate"])
+    groonga.increment!("rate", 2)
+    assert_equal(3, groonga["rate"])
+    groonga.increment!("rate", -2)
+    assert_equal(1, groonga["rate"])
+  end
+
+  def test_decrement!
+    groonga = @bookmarks.add
+    assert_equal(0, groonga["rate"])
+    groonga.decrement!("rate")
+    assert_equal(-1, groonga["rate"])
+    groonga.decrement!("rate", 2)
+    assert_equal(-3, groonga["rate"])
+    groonga.decrement!("rate", -2)
+    assert_equal(-1, groonga["rate"])
+  end
+
+  def test_lock
+    groonga = @bookmarks.add
+
+    assert_not_predicate(groonga, :locked?)
+    groonga.lock
+    assert_predicate(groonga, :locked?)
+    groonga.unlock
+    assert_not_predicate(groonga, :locked?)
+  end
+
+  def test_lock_failed
+    groonga = @bookmarks.add
+
+    groonga.lock
+    assert_raise(Groonga::ResourceDeadlockAvoided) do
+      groonga.lock
+    end
+  end
+
+  def test_lock_block
+    groonga = @bookmarks.add
+
+    assert_not_predicate(groonga, :locked?)
+    groonga.lock do
+      assert_predicate(groonga, :locked?)
+    end
+    assert_not_predicate(groonga, :locked?)
+  end
+
+  def test_clear_lock
+    groonga = @bookmarks.add
+
+    assert_not_predicate(groonga, :locked?)
+    groonga.lock
+    assert_predicate(groonga, :locked?)
+    groonga.clear_lock
+    assert_not_predicate(groonga, :locked?)
+  end
+
+  def test_attributes
+    values = {
+      "uri" => "http://groonga.org/",
+      "rate" => 5,
+      "comment" => "Great!"
+    }
+    groonga = @bookmarks.add(values)
+    assert_equal(values.merge("_id" => groonga.id,
+                              "content" => nil,
+                              "user" => nil),
+                 groonga.attributes)
+  end
+
+  def test_recursive_attributes
+    need_self_recursive_equal
+
+    @bookmarks.define_column("next", @bookmarks)
+
+    top_page_record = @bookmarks.add(top_page)
+    doc_page_record = @bookmarks.add(doc_page)
+
+    top_page_record["next"] = doc_page_record
+    doc_page_record["next"] = top_page_record
+
+    expected = {
+      "_id" => 1,
+      "user" => nil,
+      "uri" => "http://groonga.org/",
+      "rate" => 5,
+      "next" => {
+        "_id" => 2,
+        "user" => nil,
+        "uri" => "http://groonga.org/document.html",
+        "rate" => 8,
+        "content" => nil,
+        "comment" => "Informative"
+      },
+      "content" => nil,
+      "comment" => "Great!"
+    }
+    expected["next"]["next"] = expected
+
+    assert_equal(expected, top_page_record.attributes)
+  end
+
+  def test_duplicate_records_attributes
+    need_self_recursive_equal
+
+    @bookmarks.define_column("next1", @bookmarks)
+    @bookmarks.define_column("next2", @bookmarks)
+
+    top_page_record = @bookmarks.add(top_page)
+    doc_page_record = @bookmarks.add(doc_page)
+
+    top_page_record["next1"] = doc_page_record
+    top_page_record["next2"] = doc_page_record
+    doc_page_record["next1"] = top_page_record
+
+    doc_page_attributes = {
+      "_id" => 2,
+      "user" => nil,
+      "uri" => "http://groonga.org/document.html",
+      "rate" => 8,
+      "content" => nil,
+      "comment" => "Informative",
+      "next2" => nil
+    }
+    top_page_attributes = {
+      "_id" => 1,
+      "user" => nil,
+      "uri" => "http://groonga.org/",
+      "rate" => 5,
+      "next1" => doc_page_attributes,
+      "next2" => doc_page_attributes,
+      "content" => nil,
+      "comment" => "Great!"
+    }
+    doc_page_attributes["next1"] = top_page_attributes
+
+    actual_records = top_page_record.attributes
+    assert_equal(top_page_attributes, actual_records)
+    assert_equal(actual_records["next1"].object_id,
+                 actual_records["next2"].object_id)
+  end
+
+  def test_select_result_attributes
+    @bookmarks.add(top_page)
+    select_result = @bookmarks.select
+    select_result_result = select_result.first
+
+    expected_attributes = {
+      "_id" => 1,
+      "_key" => {
+        "comment" => "Great!",
+        "content" => nil,
+        "_id" => 1,
+        "rate" => 5,
+        "uri" => "http://groonga.org/",
+        "user" => nil
+      },
+      "_nsubrecs" => 1,
+      "_score" => 1,
+    }
+
+    assert_equal(expected_attributes, select_result_result.attributes)
+  end
+
+  def test_self_referencing_attributes
+    need_self_recursive_equal
+
+    @bookmarks.define_column("next", @bookmarks)
+
+    top_page_record = @bookmarks.add(top_page)
+    top_page_record["next"] = top_page_record
+
+    expected = {
+      "_id" => 1,
+      "user" => nil,
+      "uri" => "http://groonga.org/",
+      "rate" => 5,
+      "content" => nil,
+      "comment" => "Great!"
+    }
+    expected["next"] = expected
+
+    assert_equal(expected, top_page_record.attributes)
+  end
+
+  def test_vector_attributes
+    @bookmarks.define_column("related_bookmarks", @bookmarks, :type => :vector)
+
+    top_page_record = @bookmarks.add(top_page)
+    doc_page_record = @bookmarks.add(doc_page)
+    top_page_record["related_bookmarks"] = [doc_page_record]
+
+    expected = {
+      "_id" => 1,
+      "user" => nil,
+      "uri" => "http://groonga.org/",
+      "rate" => 5,
+      "related_bookmarks" => [
+        {
+          "_id" => 2,
+          "comment" => "Informative",
+          "content" => nil,
+          "rate" => 8,
+          "related_bookmarks" => [],
+          "uri" => "http://groonga.org/document.html",
+          "user" => nil,
+        }
+      ],
+      "content" => nil,
+      "comment" => "Great!"
+    }
+
+    assert_equal(expected, top_page_record.attributes)
+  end
+
+  def test_self_referencing_vector_attributes
+    need_self_recursive_equal
+
+    @bookmarks.define_column("related_bookmarks", @bookmarks, :type => :vector)
+
+    top_page_record = @bookmarks.add(top_page)
+    doc_page_record = @bookmarks.add(doc_page)
+    top_page_record["related_bookmarks"] = [
+      top_page_record,
+      doc_page_record
+    ]
+
+    top_page_attributes = {
+      "_id" => 1,
+      "user" => nil,
+      "uri" => "http://groonga.org/",
+      "rate" => 5,
+      "content" => nil,
+      "comment" => "Great!"
+    }
+    doc_page_attributes = {
+      "_id" => 2,
+      "comment" => "Informative",
+      "content" => nil,
+      "rate" => 8,
+      "related_bookmarks" => [],
+      "uri" => "http://groonga.org/document.html",
+      "user" => nil,
+    }
+    top_page_attributes["related_bookmarks"] = [
+      top_page_attributes,
+      doc_page_attributes
+    ]
+    assert_equal(top_page_attributes, top_page_record.attributes)
+  end
+
+  def test_dynamic_accessor
+    groonga = @bookmarks.add
+    assert_equal([],
+                 ["uri", "uri="] - groonga.methods.collect {|name| name.to_s})
+    assert_equal([true, true],
+                 [groonga.respond_to?(:uri),
+                  groonga.respond_to?(:uri=)])
+    groonga.uri = "http://groonga.org/"
+    assert_equal("http://groonga.org/", groonga.uri)
+  end
+
+  def test_method_chain
+    morita = @users.add("morita")
+    groonga = @bookmarks.add(:user => morita, :uri => "http://groonga.org")
+    assert_equal("morita", groonga.user.key)
+  end
+
+  def test_support_sub_records
+    morita = @users.add("morita")
+    assert_not_predicate(morita, :support_sub_records?)
+    users = @users.select {|record| record.key == "morita"}
+    assert_predicate(users.to_a[0], :support_sub_records?)
+  end
+
+  def test_set_record_like_object
+    kou_at_clear_code = @addresses.add(:mail => "kou@clear-code.com")
+    record_like_class = Class.new do
+      attr_reader :record_raw_id
+      def initialize(record_raw_id)
+        @record_raw_id = record_raw_id
+      end
+    end
+    record_like_object = record_like_class.new(kou_at_clear_code.record_raw_id)
+    kou = @users.add("kou")
+    kou.addresses = [record_like_object]
+  end
+
+  def test_set_array_like_records
+    kou_at_clear_code = @addresses.add(:mail => "kou@clear-code.com")
+    array_like_class = Class.new do
+      def initialize(records)
+        @records = records
+      end
+
+      def to_ary
+        @records
+      end
+    end
+    array_like_object = array_like_class.new([kou_at_clear_code])
+    kou = @users.add("kou")
+    kou.addresses = array_like_object
+  end
+
+  private
+  def top_page
+    {
+      "uri" => "http://groonga.org/",
+      "rate" => 5,
+      "comment" => "Great!",
+    }
+  end
+
+  def doc_page
+    {
+      "uri" => "http://groonga.org/document.html",
+      "rate" => 8,
+      "comment" => "Informative"
+    }
+  end
+end