rroonga 1.3.0-x86-mingw32 → 1.3.1-x86-mingw32

data/test/test-schema-dumper.rb

@@ -28,6 +28,29 @@ class SchemaDumperTest < Test::Unit::TestCase
     end
   end
 
+  def define_built_in_types_schema
+    Groonga::Schema.define do |schema|
+      schema.create_table("Posts") do |table|
+        table.boolean :public
+        table.int8 :int8
+        table.uint8 :uint8
+        table.int16 :int16
+        table.uint16 :uint16
+        table.int32 :int32
+        table.uint32 :uint32
+        table.int64 :int64
+        table.uint64 :uint64
+        table.float :vote_average
+        table.time :published_at
+        table.short_text :title
+        table.text :content
+        table.long_text :attachment
+        table.tokyo_geo_point :location_tokyo
+        table.wgs84_geo_point :location_wgs84
+      end
+    end
+  end
+
   def define_reference_schema
     Groonga::Schema.define do |schema|
       schema.create_table("Items") do |table|
@@ -79,6 +102,31 @@ end
 EOS
     end
 
+    def test_built_in_types
+      define_built_in_types_schema
+      assert_equal(<<-EOS, dump)
+create_table("Posts",
+             :force => true) do |table|
+  table.long_text("attachment")
+  table.text("content")
+  table.integer16("int16")
+  table.integer32("int32")
+  table.integer64("int64")
+  table.integer8("int8")
+  table.tokyo_geo_point("location_tokyo")
+  table.wgs84_geo_point("location_wgs84")
+  table.boolean("public")
+  table.time("published_at")
+  table.short_text("title")
+  table.unsigned_integer16("uint16")
+  table.unsigned_integer32("uint32")
+  table.unsigned_integer64("uint64")
+  table.unsigned_integer8("uint8")
+  table.float("vote_average")
+end
+EOS
+    end
+
     def test_reference
       define_reference_schema
       assert_equal(<<-EOS, dump)

data/test/test-schema-type.rb

@@ -33,6 +33,18 @@ class SchemaTypeTest < Test::Unit::TestCase
     assert_normalize_type("LongText", "LongText")
   end
 
+  def test_normalize_integer8
+    assert_normalize_type("Int8", "int8")
+    assert_normalize_type("Int8", "integer8")
+    assert_normalize_type("Int8", "Int8")
+  end
+
+  def test_normalize_integer16
+    assert_normalize_type("Int16", "int16")
+    assert_normalize_type("Int16", "integer16")
+    assert_normalize_type("Int16", "Int16")
+  end
+
   def test_normalize_integer32
     assert_normalize_type("Int32", "int")
     assert_normalize_type("Int32", "integer")
@@ -47,6 +59,18 @@ class SchemaTypeTest < Test::Unit::TestCase
     assert_normalize_type("Int64", "Int64")
   end
 
+  def test_normalize_unsigned_integer8
+    assert_normalize_type("UInt8", "uint8")
+    assert_normalize_type("UInt8", "unsigned_integer8")
+    assert_normalize_type("UInt8", "UInt8")
+  end
+
+  def test_normalize_unsigned_integer16
+    assert_normalize_type("UInt16", "uint16")
+    assert_normalize_type("UInt16", "unsigned_integer16")
+    assert_normalize_type("UInt16", "UInt16")
+  end
+
   def test_normalize_unsigned_integer32
     assert_normalize_type("UInt32", "uint")
     assert_normalize_type("UInt32", "unsigned_integer")
@@ -79,6 +103,17 @@ class SchemaTypeTest < Test::Unit::TestCase
     assert_normalize_type("Bool", "Bool")
   end
 
+  def test_normalize_tokyo_geo_point
+    assert_normalize_type("TokyoGeoPoint", "tokyo_geo_point")
+    assert_normalize_type("TokyoGeoPoint", "TokyoGeoPoint")
+  end
+
+  def test_normalize_wgs84_geo_point
+    assert_normalize_type("WGS84GeoPoint", "geo_point")
+    assert_normalize_type("WGS84GeoPoint", "wgs84_geo_point")
+    assert_normalize_type("WGS84GeoPoint", "WGS84GeoPoint")
+  end
+
   def test_normalize_delimit
     assert_normalize_type("TokenDelimit", "delimit")
     assert_normalize_type("TokenDelimit", "token_delimit")

data/test/test-schema.rb

@@ -343,6 +343,22 @@ class SchemaTest < Test::Unit::TestCase
     end
   end
 
+  def test_integer8_column
+    assert_nil(context["Posts.rate"])
+    Groonga::Schema.create_table("Posts") do |table|
+      table.integer8 :rate
+    end
+    assert_equal(context["Int8"], context["Posts.rate"].range)
+  end
+
+  def test_integer16_column
+    assert_nil(context["Posts.rate"])
+    Groonga::Schema.create_table("Posts") do |table|
+      table.integer16 :rate
+    end
+    assert_equal(context["Int16"], context["Posts.rate"].range)
+  end
+
   def test_integer32_column
     assert_nil(context["Posts.rate"])
     Groonga::Schema.create_table("Posts") do |table|
@@ -359,6 +375,22 @@ class SchemaTest < Test::Unit::TestCase
     assert_equal(context["Int64"], context["Posts.rate"].range)
   end
 
+  def test_unsigned_integer8_column
+    assert_nil(context["Posts.n_viewed"])
+    Groonga::Schema.create_table("Posts") do |table|
+      table.unsigned_integer8 :n_viewed
+    end
+    assert_equal(context["UInt8"], context["Posts.n_viewed"].range)
+  end
+
+  def test_unsigned_integer16_column
+    assert_nil(context["Posts.n_viewed"])
+    Groonga::Schema.create_table("Posts") do |table|
+      table.unsigned_integer16 :n_viewed
+    end
+    assert_equal(context["UInt16"], context["Posts.n_viewed"].range)
+  end
+
   def test_unsigned_integer32_column
     assert_nil(context["Posts.n_viewed"])
     Groonga::Schema.create_table("Posts") do |table|
@@ -433,6 +465,30 @@ class SchemaTest < Test::Unit::TestCase
     assert_equal(context["Bool"], context["Posts.public"].range)
   end
 
+  def test_tokyo_geo_point_column
+    assert_nil(context["Posts.location"])
+    Groonga::Schema.create_table("Posts") do |table|
+      table.tokyo_geo_point :location
+    end
+    assert_equal(context["TokyoGeoPoint"], context["Posts.location"].range)
+  end
+
+  def test_wgs84_geo_point_column
+    assert_nil(context["Posts.location"])
+    Groonga::Schema.create_table("Posts") do |table|
+      table.wgs84_geo_point :location
+    end
+    assert_equal(context["WGS84GeoPoint"], context["Posts.location"].range)
+  end
+
+  def test_geo_point_column
+    assert_nil(context["Posts.location"])
+    Groonga::Schema.create_table("Posts") do |table|
+      table.geo_point :location
+    end
+    assert_equal(context["WGS84GeoPoint"], context["Posts.location"].range)
+  end
+
   def test_remove_column
     Groonga::Schema.create_table("Posts") do |table|
       table.long_text :content
@@ -456,26 +512,40 @@ class SchemaTest < Test::Unit::TestCase
     assert_equal("Posts.body", content.name)
   end
 
-  def test_column_again
-    Groonga::Schema.create_table("Posts") do |table|
-      table.text :content
+  class DefineColumnAgainTest < self
+    def test_same_option
+      Groonga::Schema.create_table("Posts") do |table|
+        table.text :content
+      end
+
+      assert_nothing_raised do
+        Groonga::Schema.create_table("Posts") do |table|
+          table.text :content
+        end
+      end
     end
 
-    assert_nothing_raised do
+    def test_difference_type
       Groonga::Schema.create_table("Posts") do |table|
         table.text :content
       end
-    end
-  end
 
-  def test_column_again_with_difference_type
-    Groonga::Schema.create_table("Posts") do |table|
-      table.text :content
+      assert_raise(Groonga::Schema::ColumnCreationWithDifferentOptions) do
+        Groonga::Schema.create_table("Posts") do |table|
+          table.integer :content
+        end
+      end
     end
 
-    assert_raise(Groonga::Schema::ColumnCreationWithDifferentOptions) do
+    def test_same_option_by_groonga_object
       Groonga::Schema.create_table("Posts") do |table|
-        table.integer :content
+        table.text :content
+      end
+
+      assert_nothing_raised do
+        Groonga::Schema.create_table("Posts") do |table|
+          table.column(:content, Groonga["Text"])
+        end
       end
     end
   end

data/test/test-table-select.rb

@@ -53,27 +53,37 @@ class TableSelectTest < Test::Unit::TestCase
                     :user => "darashi")
   end
 
+  setup
+  def setup_variables
+    @result = nil
+  end
+
+  teardown
+  def teardown_expression_close
+    @result.expression.close if @result # TODO: We want to remove it.
+  end
+
   def test_sub_expression
-    result = @comments.select do |record|
+    @result = @comments.select do |record|
       record.match("Hello", "content") &
         (record["created_at"] < Time.parse("2009-08-01"))
     end
-    assert_equal_select_result([@comment2], result)
+    assert_equal_select_result([@comment2], @result)
   end
 
   def test_query
-    result = @comments.select("content:@Hello")
-    assert_equal_select_result([@comment1, @comment2], result)
+    @result = @comments.select("content:@Hello")
+    assert_equal_select_result([@comment1, @comment2], @result)
   end
 
   def test_query_with_parser
-    result = @comments.select("content @ \"Hello\"", :syntax => :script)
-    assert_equal_select_result([@comment1, @comment2], result)
+    @result = @comments.select("content @ \"Hello\"", :syntax => :script)
+    assert_equal_select_result([@comment1, @comment2], @result)
   end
 
   def test_query_with_default_column
-    result = @comments.select("Hello", {:default_column => 'content'})
-    assert_equal_select_result([@comment1, @comment2], result)
+    @result = @comments.select("Hello", {:default_column => 'content'})
+    assert_equal_select_result([@comment1, @comment2], @result)
   end
 
   def test_expression
@@ -82,104 +92,105 @@ class TableSelectTest < Test::Unit::TestCase
     expression.append_object(variable)
     expression.parse("content:@Hello", :syntax => :query)
     expression.compile
-    result = @comments.select(expression)
-    assert_equal(expression, result.expression)
-    assert_equal_select_result([@comment1, @comment2], result)
+    @result = @comments.select(expression)
+    assert_equal(expression, @result.expression)
+    assert_equal_select_result([@comment1, @comment2], @result)
   end
 
   def test_query_with_block
-    result = @comments.select("content:@Hello") do |record|
+    @result = @comments.select("content:@Hello") do |record|
       record["created_at"] < Time.parse("2009-08-01")
     end
-    assert_equal_select_result([@comment2], result)
+    assert_equal_select_result([@comment2], @result)
   end
 
   def test_query_with_block_match
-    result = @comments.select("content:@Hello") do |record|
+    @result = @comments.select("content:@Hello") do |record|
       record.match("World", "content")
     end
-    assert_equal_select_result([@comment2], result)
+    assert_equal_select_result([@comment2], @result)
   end
 
   def test_without_block
+    @result = @comments.select
     assert_equal_select_result([@comment1, @comment2,
                                 @comment3, @japanese_comment],
-                               @comments.select)
+                               @result)
   end
 
   def test_query_japanese
-    result = @comments.select("content:@ボロTV")
-    assert_equal_select_result([@japanese_comment], result)
+    @result = @comments.select("content:@ボロTV")
+    assert_equal_select_result([@japanese_comment], @result)
   end
 
   def test_but_query
-    result = @comments.select do |record|
+    @result = @comments.select do |record|
       record["content"].match "Hello -World"
     end
-    assert_equal_select_result([@comment1], result)
+    assert_equal_select_result([@comment1], @result)
   end
 
   def test_query_with_three_terms
-    result = @comments.select do |record|
+    @result = @comments.select do |record|
       record["content"].match "Say Hello World"
     end
-    assert_equal_select_result([], result)
+    assert_equal_select_result([], @result)
   end
 
   def test_query_with_brackets
-    result = @comments.select do |record|
+    @result = @comments.select do |record|
       record["content"].match "Say (Hello World)"
     end
-    assert_equal_select_result([], result)
+    assert_equal_select_result([], @result)
   end
 
   def test_equal_reference_column_by_key
-    result = @comments.select do |record|
+    @result = @comments.select do |record|
       record["user"] == "darashi"
     end
-    assert_equal_select_result([@japanese_comment], result)
+    assert_equal_select_result([@japanese_comment], @result)
   end
 
   def test_not_equal_reference_column_by_key
-    result = @comments.select('user != "darashi"', :syntax => :script)
+    @result = @comments.select('user != "darashi"', :syntax => :script)
     assert_equal_select_result([@comment1, @comment2, @comment3],
-                               result)
+                               @result)
   end
 
   def test_not_equal_block
     only_ruby19
-    result = @comments.select do |record|
+    @result = @comments.select do |record|
       record.user != "darashi"
     end
     assert_equal_select_result([@comment1, @comment2, @comment3],
-                               result)
+                               @result)
   end
 
   def test_equal_reference_column_by_nonexistent_key
-    result = @comments.select do |record|
+    @result = @comments.select do |record|
       record["user"] == "nonexistent"
     end
-    assert_equal_select_result([], result)
+    assert_equal_select_result([], @result)
   end
 
   def test_query_key
-    result = @users.select do |record|
+    @result = @users.select do |record|
       record["_key"] =~ "mori"
     end
-    assert_equal_select_result([@users["morita"]], result)
+    assert_equal_select_result([@users["morita"]], @result)
   end
 
   def test_symbol
-    result = @comments.select do |record|
+    @result = @comments.select do |record|
       record[:content].match("Say Hello World")
     end
-    assert_equal_select_result([], result)
+    assert_equal_select_result([], @result)
   end
 
   def test_method
-    result = @comments.select do |record|
+    @result = @comments.select do |record|
       record.content.match("Say Hello World")
     end
-    assert_equal_select_result([], result)
+    assert_equal_select_result([], @result)
   end
 end

data/test/test-variable-size-column.rb

@@ -62,6 +62,36 @@ class VariableSizeColumnTest < Test::Unit::TestCase
     assert_not_predicate(@nick_names, :scalar?)
   end
 
+  def test_compressed?
+    description = @users.define_column("description", "ShortText",
+                                       :compress => :zlib)
+    if context.support_zlib?
+      assert_predicate(description, :compressed?)
+    else
+      assert_not_predicate(description, :compressed?)
+    end
+  end
+
+  def test_compressed_zlib?
+    description = @users.define_column("description", "ShortText",
+                                       :compress => :zlib)
+    if context.support_zlib?
+      assert_send([description, :compressed?, :zlib])
+    else
+      assert_not_send([description, :compressed?, :zlib])
+    end
+  end
+
+  def test_compressed_lzo?
+    description = @users.define_column("description", "ShortText",
+                                       :compress => :lzo)
+    if context.support_lzo?
+      assert_send([description, :compressed?, :lzo])
+    else
+      assert_not_send([description, :compressed?, :lzo])
+    end
+  end
+
   def test_inspect
     assert_equal("#<Groonga::VariableSizeColumn " +
                  "id: <#{@name.id}>, " +

data/vendor/local/include/groonga/groonga/plugin.h

@@ -1,5 +1,6 @@
 /* -*- c-basic-offset: 2 -*- */
-/* Copyright(C) 2010 Brazil
+/*
+  Copyright(C) 2010-2012 Brazil
 
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
@@ -17,7 +18,7 @@
 #ifndef GRN_PLUGIN_H
 #define GRN_PLUGIN_H
 
-#include "groonga.h"
+#include <groonga.h>
 
 #ifdef __cplusplus
 extern "C" {