rroonga 2.0.2-x86-mingw32 → 2.0.3-x86-mingw32

data/test/test-schema-create-table.rb

@@ -1,267 +0,0 @@
-# Copyright (C) 2009-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
-
-module SchemaCreateTableTests
-  def test_normal
-    assert_nil(context["Posts"])
-    Groonga::Schema.create_table("Posts", options) do |table|
-    end
-    assert_not_nil(context["Posts"])
-  end
-
-  def test_force
-    Groonga::Schema.create_table("Posts", options) do |table|
-      table.string("name")
-    end
-    assert_not_nil(context["Posts.name"])
-
-    Groonga::Schema.create_table("Posts",
-                                 options(:type => differnt_type,
-                                         :force => true)) do |table|
-    end
-    assert_nil(context["Posts.name"])
-  end
-
-  def test_different_type
-    Groonga::Schema.create_table("Posts", options) do |table|
-    end
-
-    assert_raise(Groonga::Schema::TableCreationWithDifferentOptions) do
-      Groonga::Schema.create_table("Posts",
-                                   options(:type => differnt_type)) do |table|
-      end
-    end
-  end
-
-  def test_same_options
-    Groonga::Schema.create_table("Posts", options) do |table|
-    end
-
-    Groonga::Schema.create_table("Posts", options) do |table|
-    end
-    assert_not_nil(context["Posts"])
-  end
-
-  def test_same_value_type
-    Groonga::Schema.create_table("Posts",
-                                 options(:value_type => "UInt32")) do |table|
-    end
-
-    Groonga::Schema.create_table("Posts",
-                                 options(:value_type => "UInt32")) do |table|
-    end
-    assert_equal(context["UInt32"], context["Posts"].range)
-  end
-
-  def test_differnt_value_type
-    Groonga::Schema.create_table("Posts", options) do |table|
-    end
-
-    assert_raise(Groonga::Schema::TableCreationWithDifferentOptions) do
-      Groonga::Schema.create_table("Posts",
-                                   options(:value_type => "Int32")) do |table|
-      end
-    end
-  end
-
-  def test_same_sub_records
-    Groonga::Schema.create_table("Posts",
-                                 options(:sub_records => true)) do |table|
-    end
-
-    Groonga::Schema.create_table("Posts",
-                                 options(:sub_records => true)) do |table|
-    end
-    assert_true(context["Posts"].support_sub_records?)
-  end
-
-  def test_different_sub_records
-    Groonga::Schema.create_table("Posts",
-                                 options(:sub_records => true)) do |table|
-    end
-
-    assert_raise(Groonga::Schema::TableCreationWithDifferentOptions) do
-      Groonga::Schema.create_table("Posts",
-                                   options(:sub_records => false)) do |table|
-      end
-    end
-  end
-
-  def test_default_path
-    Groonga::Schema.create_table("Posts", options) do |table|
-    end
-    assert_equal("#{@database_path}.0000100",
-                 context["Posts"].path)
-  end
-
-  def test_default_named_path
-    options_with_named_path = options.merge(:named_path => true)
-    Groonga::Schema.create_table("Posts", options_with_named_path) do |table|
-    end
-    assert_equal("#{@database_path}.tables/Posts",
-                 context["Posts"].path)
-  end
-
-  private
-  def options(addional_options={})
-    default_options.merge(addional_options)
-  end
-end
-
-module SchemaCreateTableWithKeyTests
-  def test_same_key_type
-    Groonga::Schema.create_table("Posts",
-                                 options(:key_type => "ShortText")) do |table|
-    end
-
-    Groonga::Schema.create_table("Posts",
-                                 options(:key_type => "ShortText")) do |table|
-    end
-    assert_equal(context["ShortText"], context["Posts"].domain)
-  end
-
-  def test_differnt_key_type
-    Groonga::Schema.create_table("Posts",
-                                 options(:key_type => "Int32")) do |table|
-    end
-
-    assert_raise(Groonga::Schema::TableCreationWithDifferentOptions) do
-      Groonga::Schema.create_table("Posts",
-                                   options(:key_type => "ShortText")) do |table|
-      end
-    end
-  end
-
-  def test_same_default_tokenizer
-    _options = options(:key_type => "ShortText",
-                       :default_tokenizer => "TokenBigram")
-    Groonga::Schema.create_table("Posts", _options) do |table|
-    end
-
-    Groonga::Schema.create_table("Posts", _options) do |table|
-    end
-    assert_equal(context["TokenBigram"], context["Posts"].default_tokenizer)
-  end
-
-  def test_differnt_default_tokenizer
-    _options = options(:key_type => "ShortText")
-    Groonga::Schema.create_table("Posts", _options) do |table|
-    end
-
-    _options = _options.merge(:default_tokenizer => "TokenBigram")
-    assert_raise(Groonga::Schema::TableCreationWithDifferentOptions) do
-      Groonga::Schema.create_table("Posts", _options) do |table|
-      end
-    end
-  end
-
-  def test_same_key_normalize
-    _options = options(:key_type => "ShortText",
-                       :key_normalize => true)
-    Groonga::Schema.create_table("Posts", _options) do |table|
-    end
-
-    Groonga::Schema.create_table("Posts", _options) do |table|
-    end
-    assert_true(context["Posts"].normalize_key?)
-  end
-
-  def test_differnt_key_normalize
-    _options = options(:key_type => "ShortText",
-                       :key_normalize => true)
-    Groonga::Schema.create_table("Posts", _options) do |table|
-    end
-
-    _options = _options.merge(:key_normalize => false)
-    assert_raise(Groonga::Schema::TableCreationWithDifferentOptions) do
-      Groonga::Schema.create_table("Posts", _options) do |table|
-      end
-    end
-  end
-end
-
-class SchemaCreateTableArrayTest < Test::Unit::TestCase
-  include GroongaTestUtils
-  include SchemaCreateTableTests
-
-  setup :setup_database
-
-  private
-  def default_options
-    {}
-  end
-
-  def differnt_type
-    :hash
-  end
-end
-
-class SchemaCreateTableHashTest < Test::Unit::TestCase
-  include GroongaTestUtils
-  include SchemaCreateTableTests
-  include SchemaCreateTableWithKeyTests
-
-  setup :setup_database
-
-  private
-  def default_options
-    {:type => :hash}
-  end
-
-  def differnt_type
-    :patricia_trie
-  end
-end
-
-class SchemaCreateTablePatriciaTrieTest < Test::Unit::TestCase
-  include GroongaTestUtils
-  include SchemaCreateTableTests
-  include SchemaCreateTableWithKeyTests
-
-  setup :setup_database
-
-  def test_same_key_with_sis
-    _options = options(:key_type => "ShortText",
-                       :key_with_sis => true)
-    Groonga::Schema.create_table("Posts", _options) do |table|
-    end
-
-    Groonga::Schema.create_table("Posts", _options) do |table|
-    end
-    assert_true(context["Posts"].register_key_with_sis?)
-  end
-
-  def test_differnt_key_with_sis
-    _options = options(:key_type => "ShortText",
-                       :key_with_sis => true)
-    Groonga::Schema.create_table("Posts", _options) do |table|
-    end
-
-    _options = _options.merge(:key_with_sis => false)
-    assert_raise(Groonga::Schema::TableCreationWithDifferentOptions) do
-      Groonga::Schema.create_table("Posts", _options) do |table|
-      end
-    end
-  end
-
-  private
-  def default_options
-    {:type => :patricia_trie}
-  end
-
-  def differnt_type
-    :array
-  end
-end

data/test/test-schema-dumper.rb

@@ -1,235 +0,0 @@
-# Copyright (C) 2009-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 SchemaDumperTest < Test::Unit::TestCase
-  include GroongaTestUtils
-
-  setup :setup_database
-
-  private
-  def define_simple_schema
-    Groonga::Schema.define do |schema|
-      schema.create_table("Posts") do |table|
-        table.short_text :title
-        table.short_text :comments, :type => :vector
-      end
-    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|
-        table.short_text("title")
-      end
-
-      schema.create_table("Users") do |table|
-        table.short_text("name")
-      end
-
-      schema.create_table("Comments") do |table|
-        table.reference("item", "Items")
-        table.reference("author", "Users")
-        table.reference("children", "Items", :type => :vector)
-        table.text("content")
-        table.time("issued")
-      end
-    end
-  end
-
-  def define_index_schema
-    Groonga::Schema.define do |schema|
-      schema.create_table("Items",
-                          :type => :hash,
-                          :key_type => "ShortText") do |table|
-        table.short_text("title")
-      end
-
-      schema.create_table("Terms",
-                          :type => :patricia_trie,
-                          :key_type => "ShortText",
-                          :key_normalize => true,
-                          :default_tokenizer => "TokenBigram") do |table|
-        table.index("Items", "_key")
-        table.index("Items", "title")
-      end
-    end
-  end
-
-  class RubySyntaxSchemaDumperTest < SchemaDumperTest
-    def test_simple
-      define_simple_schema
-      assert_equal(<<-EOS, dump)
-create_table("Posts",
-             :force => true) do |table|
-  table.short_text("comments", :type => :vector)
-  table.short_text("title")
-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)
-create_table("Comments",
-             :force => true) do |table|
-  table.text("content")
-  table.time("issued")
-end
-
-create_table("Items",
-             :force => true) do |table|
-  table.short_text("title")
-end
-
-create_table("Users",
-             :force => true) do |table|
-  table.short_text("name")
-end
-
-change_table("Comments") do |table|
-  table.reference("author", "Users")
-  table.reference("children", "Items", :type => :vector)
-  table.reference("item", "Items")
-end
-EOS
-    end
-
-    def test_index
-      define_index_schema
-      assert_equal(<<-EOS, dump)
-create_table("Items",
-             :type => :hash,
-             :key_type => "ShortText",
-             :force => true) do |table|
-  table.short_text("title")
-end
-
-create_table("Terms",
-             :type => :patricia_trie,
-             :key_type => "ShortText",
-             :key_normalize => true,
-             :default_tokenizer => "TokenBigram",
-             :force => true) do |table|
-end
-
-change_table("Terms") do |table|
-  table.index("Items", "_key", :name => "Items__key")
-  table.index("Items", "title", :name => "Items_title")
-end
-EOS
-    end
-
-    private
-    def dump
-      Groonga::Schema.dump
-    end
-  end
-
-  class CommandSyntaxSchemaDumperTest < SchemaDumperTest
-    def test_simple
-      define_simple_schema
-      assert_equal(<<-EOS, dump)
-table_create Posts TABLE_NO_KEY
-column_create Posts comments COLUMN_VECTOR ShortText
-column_create Posts title COLUMN_SCALAR ShortText
-EOS
-    end
-
-    def test_reference
-      define_reference_schema
-      assert_equal(<<-EOS, dump)
-table_create Comments TABLE_NO_KEY
-column_create Comments content COLUMN_SCALAR Text
-column_create Comments issued COLUMN_SCALAR Time
-
-table_create Items TABLE_NO_KEY
-column_create Items title COLUMN_SCALAR ShortText
-
-table_create Users TABLE_NO_KEY
-column_create Users name COLUMN_SCALAR ShortText
-
-column_create Comments author COLUMN_SCALAR Users
-column_create Comments children COLUMN_VECTOR Items
-column_create Comments item COLUMN_SCALAR Items
-EOS
-    end
-
-    def test_index
-      define_index_schema
-      assert_equal(<<-EOS, dump)
-table_create Items TABLE_HASH_KEY --key_type ShortText
-column_create Items title COLUMN_SCALAR ShortText
-
-table_create Terms TABLE_PAT_KEY|KEY_NORMALIZE --key_type ShortText --default_tokenizer TokenBigram
-
-column_create Terms Items__key COLUMN_INDEX|WITH_POSITION Items _key
-column_create Terms Items_title COLUMN_INDEX|WITH_POSITION Items title
-EOS
-    end
-
-    private
-    def dump
-      Groonga::Schema.dump(:syntax => :command)
-    end
-  end
-end

data/test/test-schema-type.rb

@@ -1,208 +0,0 @@
-# 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 SchemaTypeTest < Test::Unit::TestCase
-  include GroongaTestUtils
-
-  def test_normalize_short_text
-    assert_normalize_type("ShortText", "short_text")
-    assert_normalize_type("ShortText", "string")
-    assert_normalize_type("ShortText", "ShortText")
-  end
-
-  def test_normalize_text
-    assert_normalize_type("Text", "text")
-    assert_normalize_type("Text", "Text")
-  end
-
-  def test_normalize_long_text
-    assert_normalize_type("LongText", "binary")
-    assert_normalize_type("LongText", "long_text")
-    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")
-    assert_normalize_type("Int32", "int32")
-    assert_normalize_type("Int32", "integer32")
-    assert_normalize_type("Int32", "Int32")
-  end
-
-  def test_normalize_integer64
-    assert_normalize_type("Int64", "int64")
-    assert_normalize_type("Int64", "integer64")
-    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")
-    assert_normalize_type("UInt32", "uint32")
-    assert_normalize_type("UInt32", "unsigned_integer32")
-    assert_normalize_type("UInt32", "UInt32")
-  end
-
-  def test_normalize_unsigned_integer64
-    assert_normalize_type("UInt64", "uint64")
-    assert_normalize_type("UInt64", "unsigned_integer64")
-    assert_normalize_type("UInt64", "UInt64")
-  end
-
-  def test_normalize_float
-    assert_normalize_type("Float", "float")
-    assert_normalize_type("Float", "Float")
-  end
-
-  def test_normalize_time
-    assert_normalize_type("Time", "datetime")
-    assert_normalize_type("Time", "timestamp")
-    assert_normalize_type("Time", "time")
-    assert_normalize_type("Time", "date")
-    assert_normalize_type("Time", "Time")
-  end
-
-  def test_normalize_boolean
-    assert_normalize_type("Bool", "boolean")
-    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")
-    assert_normalize_type("TokenDelimit", "TokenDelimit")
-  end
-
-  def test_normalize_unigram
-    assert_normalize_type("TokenUnigram", "unigram")
-    assert_normalize_type("TokenUnigram", "token_unigram")
-    assert_normalize_type("TokenUnigram", "TokenUnigram")
-  end
-
-  def test_normalize_bigram
-    assert_normalize_type("TokenBigram", "bigram")
-    assert_normalize_type("TokenBigram", "token_bigram")
-    assert_normalize_type("TokenBigram", "TokenBigram")
-  end
-
-  def test_normalize_bigram_split_symbol
-    assert_normalize_type("TokenBigramSplitSymbol", "bigram_split_symbol")
-    assert_normalize_type("TokenBigramSplitSymbol", "token_bigram_split_symbol")
-    assert_normalize_type("TokenBigramSplitSymbol", "TokenBigramSplitSymbol")
-  end
-
-  def test_normalize_bigram_split_symbol_alpha
-    assert_normalize_type("TokenBigramSplitSymbolAlpha",
-                          "bigram_split_symbol_alpha")
-    assert_normalize_type("TokenBigramSplitSymbolAlpha",
-                          "token_bigram_split_symbol_alpha")
-    assert_normalize_type("TokenBigramSplitSymbolAlpha",
-                          "TokenBigramSplitSymbolAlpha")
-  end
-
-  def test_normalize_bigram_split_symbol_alpha_digit
-    assert_normalize_type("TokenBigramSplitSymbolAlphaDigit",
-                          "bigram_split_symbol_alpha_digit")
-    assert_normalize_type("TokenBigramSplitSymbolAlphaDigit",
-                          "token_bigram_split_symbol_alpha_digit")
-    assert_normalize_type("TokenBigramSplitSymbolAlphaDigit",
-                          "TokenBigramSplitSymbolAlphaDigit")
-  end
-
-  def test_normalize_bigram_ignore_blank
-    assert_normalize_type("TokenBigramIgnoreBlank", "bigram_ignore_blank")
-    assert_normalize_type("TokenBigramIgnoreBlank", "token_bigram_ignore_blank")
-    assert_normalize_type("TokenBigramIgnoreBlank", "TokenBigramIgnoreBlank")
-  end
-
-  def test_normalize_bigram_ignore_blank_split_symbol
-    assert_normalize_type("TokenBigramIgnoreBlankSplitSymbol",
-                          "bigram_ignore_blank_split_symbol")
-    assert_normalize_type("TokenBigramIgnoreBlankSplitSymbol",
-                          "token_bigram_ignore_blank_split_symbol")
-    assert_normalize_type("TokenBigramIgnoreBlankSplitSymbol",
-                          "TokenBigramIgnoreBlankSplitSymbol")
-  end
-
-  def test_normalize_bigram_ignore_blank_split_symbol_alpha
-    assert_normalize_type("TokenBigramIgnoreBlankSplitSymbolAlpha",
-                          "bigram_ignore_blank_split_symbol_alpha")
-    assert_normalize_type("TokenBigramIgnoreBlankSplitSymbolAlpha",
-                          "token_bigram_ignore_blank_split_symbol_alpha")
-    assert_normalize_type("TokenBigramIgnoreBlankSplitSymbolAlpha",
-                          "TokenBigramIgnoreBlankSplitSymbolAlpha")
-  end
-
-  def test_normalize_bigram_ignore_blank_split_symbol_alpha_digit
-    assert_normalize_type("TokenBigramIgnoreBlankSplitSymbolAlphaDigit",
-                          "bigram_ignore_blank_split_symbol_alpha_digit")
-    assert_normalize_type("TokenBigramIgnoreBlankSplitSymbolAlphaDigit",
-                          "token_bigram_ignore_blank_split_symbol_alpha_digit")
-    assert_normalize_type("TokenBigramIgnoreBlankSplitSymbolAlphaDigit",
-                          "TokenBigramIgnoreBlankSplitSymbolAlphaDigit")
-  end
-
-  def test_normalize_trigram
-    assert_normalize_type("TokenTrigram", "trigram")
-    assert_normalize_type("TokenTrigram", "token_trigram")
-    assert_normalize_type("TokenTrigram", "TokenTrigram")
-  end
-
-  def test_normalize_mecab
-    assert_normalize_type("TokenMecab", "mecab")
-    assert_normalize_type("TokenMecab", "token_mecab")
-    assert_normalize_type("TokenMecab", "TokenMecab")
-  end
-
-  private
-  def assert_normalize_type(expected, type)
-    assert_equal(expected, Groonga::Schema.normalize_type(type))
-  end
-end