rroonga 3.1.1-x86-mingw32 → 3.1.2-x86-mingw32

data/test/test-database.rb

@@ -150,7 +150,7 @@ class DatabaseTest < Test::Unit::TestCase
       users.add(:name => "user #{i}" * 1000,
                 :address => "address #{i}" * 1000)
     end
-    assert_equal(7, @database.defrag)
+    assert_equal(3, @database.defrag)
   end
 
   def test_tables

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

@@ -27,6 +27,21 @@ class DoubleArrayTrieTest < Test::Unit::TestCase
                      :support_key?)
   end
 
+  class SupportValueTest < self
+    def test_have_value_type
+      assert_predicate(Groonga::DoubleArrayTrie.create(:name => "Users",
+                                                       :key_type => "ShortText",
+                                                       :value_type => "Int32"),
+                       :support_value?)
+    end
+
+    def test_no_value_type
+      assert_not_predicate(Groonga::DoubleArrayTrie.create(:name => "Users",
+                                                           :key_type => "ShortText"),
+                           :support_value?)
+    end
+  end
+
   def test_encoding
     assert_equal(Groonga::Encoding.default,
                  Groonga::DoubleArrayTrie.create.encoding)
@@ -148,7 +163,7 @@ class DoubleArrayTrieTest < Test::Unit::TestCase
                 :name => "user #{i}" * 1000,
                 :address => "address #{i}" * 1000)
     end
-    assert_equal(7, users.defrag)
+    assert_equal(3, users.defrag)
   end
 
   def test_rename

data/test/test-hash.rb

@@ -26,6 +26,21 @@ class HashTest < Test::Unit::TestCase
                      :support_key?)
   end
 
+  class SupportValueTest < self
+    def test_have_value_type
+      assert_predicate(Groonga::Hash.create(:name => "Users",
+                                            :key_type => "ShortText",
+                                            :value_type => "Int32"),
+                       :support_value?)
+    end
+
+    def test_no_value_type
+      assert_not_predicate(Groonga::Hash.create(:name => "Users",
+                                                :key_type => "ShortText"),
+                           :support_value?)
+    end
+  end
+
   class DeleteTest < self
     setup
     def setup_data
@@ -357,7 +372,7 @@ class HashTest < Test::Unit::TestCase
                 :name => "user #{i}" * 1000,
                 :address => "address #{i}" * 1000)
     end
-    assert_equal(7, users.defrag)
+    assert_equal(3, users.defrag)
   end
 
   def test_rename

data/test/test-lock-timeout.rb

@@ -0,0 +1,29 @@
+# Copyright (C) 2014  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 LockTimeoutTest < Test::Unit::TestCase
+  def setup
+    @original_lock_timeout = Groonga.lock_timeout
+  end
+
+  def teardown
+    Groonga.lock_timeout = @original_lock_timeout
+  end
+
+  def test_accessor
+    Groonga.lock_timeout = 10
+    assert_equal(10, Groonga.lock_timeout)
+  end
+end

data/test/test-patricia-trie.rb

@@ -27,6 +27,21 @@ class PatriciaTrieTest < Test::Unit::TestCase
                      :support_key?)
   end
 
+  class SupportValueTest < self
+    def test_have_value_type
+      assert_predicate(Groonga::PatriciaTrie.create(:name => "Users",
+                                                    :key_type => "ShortText",
+                                                    :value_type => "Int32"),
+                       :support_value?)
+    end
+
+    def test_no_value_type
+      assert_not_predicate(Groonga::PatriciaTrie.create(:name => "Users",
+                                                        :key_type => "ShortText"),
+                           :support_value?)
+    end
+  end
+
   def test_encoding
     assert_equal(Groonga::Encoding.default,
                  Groonga::PatriciaTrie.create.encoding)
@@ -407,7 +422,7 @@ class PatriciaTrieTest < Test::Unit::TestCase
                 :name => "user #{i}" * 1000,
                 :address => "address #{i}" * 1000)
     end
-    assert_equal(7, users.defrag)
+    assert_equal(3, users.defrag)
   end
 
   def test_rename

data/test/test-record.rb

@@ -309,197 +309,231 @@ class RecordTest < Test::Unit::TestCase
     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
+  class AttributesTest < self
+    def test_basic
+      values = {
+        "uri" => "http://groonga.org/",
+        "rate" => 5,
+        "comment" => "Great!"
+      }
+      groonga = @bookmarks.add(values)
+      assert_equal(values.merge("_id" => groonga.id,
+                                "_value" => 0,
+                                "content" => nil,
+                                "user" => nil),
+                   groonga.attributes)
+    end
 
-  def test_recursive_attributes
-    need_self_recursive_equal
+    def test_recursive
+      need_self_recursive_equal
 
-    @bookmarks.define_column("next", @bookmarks)
+      @bookmarks.define_column("next", @bookmarks)
 
-    top_page_record = @bookmarks.add(top_page)
-    doc_page_record = @bookmarks.add(doc_page)
+      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
+      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,
+      expected = {
+        "_id" => 1,
+        "_value" => 0,
         "user" => nil,
-        "uri" => "http://groonga.org/document.html",
-        "rate" => 8,
+        "uri" => "http://groonga.org/",
+        "rate" => 5,
+        "next" => {
+          "_id" => 2,
+          "_value" => 0,
+          "user" => nil,
+          "uri" => "http://groonga.org/document.html",
+          "rate" => 8,
+          "content" => nil,
+          "comment" => "Informative"
+        },
         "content" => nil,
-        "comment" => "Informative"
-      },
-      "content" => nil,
-      "comment" => "Great!"
-    }
-    expected["next"]["next"] = expected
+        "comment" => "Great!"
+      }
+      expected["next"]["next"] = expected
 
-    assert_equal(expected, top_page_record.attributes)
-  end
+      assert_equal(expected, top_page_record.attributes)
+    end
 
-  def test_duplicate_records_attributes
-    need_self_recursive_equal
+    def test_duplicate_records
+      need_self_recursive_equal
 
-    @bookmarks.define_column("next1", @bookmarks)
-    @bookmarks.define_column("next2", @bookmarks)
+      @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 = @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
+      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
+      doc_page_attributes = {
+        "_id" => 2,
+        "_value" => 0,
+        "user" => nil,
+        "uri" => "http://groonga.org/document.html",
+        "rate" => 8,
+        "content" => nil,
+        "comment" => "Informative",
+        "next2" => nil
+      }
+      top_page_attributes = {
+        "_id" => 1,
+        "_value" => 0,
+        "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
+      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
+    def test_select_result
+      @bookmarks.add(top_page)
+      select_result = @bookmarks.select
+      select_result_result = select_result.first
 
-    expected_attributes = {
-      "_id" => 1,
-      "_key" => {
-        "comment" => "Great!",
-        "content" => nil,
+      expected_attributes = {
         "_id" => 1,
-        "rate" => 5,
-        "uri" => "http://groonga.org/",
-        "user" => nil
-      },
-      "_score" => 1,
-    }
+        "_key" => {
+          "comment" => "Great!",
+          "content" => nil,
+          "_id" => 1,
+          "_value" => 0,
+          "rate" => 5,
+          "uri" => "http://groonga.org/",
+          "user" => nil
+        },
+        "_score" => 1,
+      }
 
-    assert_equal(expected_attributes, select_result_result.attributes)
-  end
+      assert_equal(expected_attributes, select_result_result.attributes)
+    end
 
-  def test_self_referencing_attributes
-    need_self_recursive_equal
+    def test_sort_result
+      @bookmarks.add(top_page)
+      sort_result = @bookmarks.sort(["_id"])
+      sort_result_result = sort_result.first
 
-    @bookmarks.define_column("next", @bookmarks)
+      expected_attributes = {
+        "_id" => 1,
+        "_value" => {
+          "comment" => "Great!",
+          "content" => nil,
+          "_id" => 1,
+          "_value" => 0,
+          "rate" => 5,
+          "uri" => "http://groonga.org/",
+          "user" => nil
+        },
+      }
 
-    top_page_record = @bookmarks.add(top_page)
-    top_page_record["next"] = top_page_record
+      assert_equal(expected_attributes, sort_result_result.attributes)
+    end
 
-    expected = {
-      "_id" => 1,
-      "user" => nil,
-      "uri" => "http://groonga.org/",
-      "rate" => 5,
-      "content" => nil,
-      "comment" => "Great!"
-    }
-    expected["next"] = expected
+    def test_self_referencing
+      need_self_recursive_equal
 
-    assert_equal(expected, top_page_record.attributes)
-  end
+      @bookmarks.define_column("next", @bookmarks)
 
-  def test_vector_attributes
-    @bookmarks.define_column("related_bookmarks", @bookmarks, :type => :vector)
+      top_page_record = @bookmarks.add(top_page)
+      top_page_record["next"] = top_page_record
 
-    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,
+        "_value" => 0,
+        "user" => nil,
+        "uri" => "http://groonga.org/",
+        "rate" => 5,
+        "content" => nil,
+        "comment" => "Great!"
+      }
+      expected["next"] = expected
 
-    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
 
-    assert_equal(expected, top_page_record.attributes)
-  end
+    def test_vector
+      @bookmarks.define_column("related_bookmarks", @bookmarks, :type => :vector)
 
-  def test_self_referencing_vector_attributes
-    need_self_recursive_equal
+      top_page_record = @bookmarks.add(top_page)
+      doc_page_record = @bookmarks.add(doc_page)
+      top_page_record["related_bookmarks"] = [doc_page_record]
 
-    @bookmarks.define_column("related_bookmarks", @bookmarks, :type => :vector)
+      expected = {
+        "_id" => 1,
+        "_value" => 0,
+        "user" => nil,
+        "uri" => "http://groonga.org/",
+        "rate" => 5,
+        "related_bookmarks" => [
+          {
+            "_id" => 2,
+            "_value" => 0,
+            "comment" => "Informative",
+            "content" => nil,
+            "rate" => 8,
+            "related_bookmarks" => [],
+            "uri" => "http://groonga.org/document.html",
+            "user" => nil,
+          }
+        ],
+        "content" => nil,
+        "comment" => "Great!"
+      }
 
-    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
-    ]
+      assert_equal(expected, top_page_record.attributes)
+    end
 
-    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)
+    def test_self_referencing_vector
+      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,
+        "_value" => 0,
+        "user" => nil,
+        "uri" => "http://groonga.org/",
+        "rate" => 5,
+        "content" => nil,
+        "comment" => "Great!"
+      }
+      doc_page_attributes = {
+        "_id" => 2,
+        "_value" => 0,
+        "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
   end
 
   def test_dynamic_accessor