RubyGems - rroonga - Versions diffs - 2.0.2-x86-mingw32 → 2.0.3-x86-mingw32 - Mend

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

Files changed (398) hide show

data/test/test-column.rb DELETED Viewed

@@ -1,350 +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 ColumnTest < Test::Unit::TestCase
-  include GroongaTestUtils
-  def setup
-    setup_database
-    setup_users_table
-    setup_bookmarks_table
-    setup_indexes
-  end
-  def setup_users_table
-    @users_path = @tables_dir + "users"
-    @users = Groonga::Array.create(:name => "Users",
-                                   :path => @users_path.to_s)
-    @users_name_column_path = @columns_dir + "name"
-    @users_name_column =
-      @users.define_column("name", "ShortText",
-                           :path => @users_name_column_path.to_s)
-  end
-  def setup_bookmarks_table
-    @bookmarks_path = @tables_dir + "bookmarks"
-    @bookmarks = Groonga::Array.create(:name => "Bookmarks",
-                                       :path => @bookmarks_path.to_s)
-    @uri_column_path = @columns_dir + "uri"
-    @bookmarks_uri = @bookmarks.define_column("uri", "ShortText",
-                                              :path => @uri_column_path.to_s)
-    @comment_column_path = @columns_dir + "comment"
-    @bookmarks_comment =
-      @bookmarks.define_column("comment", "Text",
-                               :path => @comment_column_path.to_s)
-    @content_column_path = @columns_dir + "content"
-    @bookmarks_content = @bookmarks.define_column("content", "LongText")
-    @user_column_path = @columns_dir + "user"
-    @bookmarks_user = @bookmarks.define_column("user", @users)
-  end
-  def setup_indexes
-    @bookmarks_index_path = @tables_dir + "bookmarks-index"
-    @bookmarks_index =
-      Groonga::PatriciaTrie.create(:name => "BookmarksIndex",
-                                   :path => @bookmarks_index_path.to_s,
-                                   :key_type => "ShortText")
-    @bookmarks_index.default_tokenizer = "TokenBigram"
-    @content_index_column_path = @columns_dir + "content-index"
-    @bookmarks_index_content =
-      @bookmarks_index.define_index_column("content", @bookmarks,
-                                           :with_section => true,
-                                           :with_weight => true,
-                                           :with_position => true,
-                                           :path => @content_index_column_path.to_s)
-    @uri_index_column_path = @columns_dir + "uri-index"
-    @bookmarks_index_uri =
-      @bookmarks_index.define_index_column("uri", @bookmarks,
-                                           :path => @uri_index_column_path.to_s)
-  end
-  def test_source_info
-    @bookmarks_index_content.sources = [@bookmarks_content]
-    groonga = @bookmarks.add
-    groonga["content"] = "<html><body>groonga</body></html>"
-    ruby = @bookmarks.add
-    ruby["content"] = "<html><body>ruby</body></html>"
-    assert_content_search([groonga], "groonga")
-    assert_content_search([groonga, ruby], "html")
-    assert_equal([@bookmarks_content], @bookmarks_index_content.sources)
-  end
-  def test_update_index_column
-    groonga = @bookmarks.add
-    groonga["content"] = "<html><body>groonga</body></html>"
-    ruby = @bookmarks.add
-    ruby["content"] = "<html><body>ruby</body></html>"
-    @bookmarks_index_content[groonga.id] = groonga["content"]
-    @bookmarks_index_content[ruby.id] = ruby["content"]
-    assert_content_search([groonga], "groonga")
-    assert_content_search([groonga, ruby], "html")
-  end
-  def test_range
-    assert_equal(context[Groonga::Type::SHORT_TEXT], @bookmarks_uri.range)
-    assert_equal(context[Groonga::Type::TEXT], @bookmarks_comment.range)
-    assert_equal(context[Groonga::Type::LONG_TEXT], @bookmarks_content.range)
-    assert_equal(@users, @bookmarks_user.range)
-    assert_equal(@bookmarks, @bookmarks_index_content.range)
-    assert_equal(@bookmarks, @bookmarks_index_uri.range)
-  end
-  def test_accessor
-    posts = Groonga::Hash.create(:name => "Posts", :key_type => "ShortText")
-    posts.define_column("body", "Text")
-    comments = Groonga::Hash.create(:name => "Comments",
-                                    :key_type => "ShortText")
-    content = comments.define_column("content", "ShortText")
-    comments.define_column("post", posts)
-    index = Groonga::PatriciaTrie.create(:name => "Terms",
-                                         :key_type => "ShortText")
-    index.default_tokenizer = "TokenBigram"
-    content_index = index.define_index_column("content_index", comments,
-                                              :with_position => true)
-    content_index.source = content
-    first_post = posts.add("Hello!")
-    first_post["body"] = "World"
-    hobby = posts.add("My Hobby")
-    hobby["body"] = "Drive and Eat"
-    friend = comments.add("Me too")
-    friend["content"] = "I'm also like drive"
-    friend["post"] = hobby
-    result = content_index.search("drive")
-    assert_equal([["I'm also like drive", "My Hobby"]],
-                 result.records.collect do |record|
-                   [record[".content"], record[".post._key"]]
-                 end)
-  end
-  def test_accessor_reference
-    bookmark = @bookmarks.add
-    assert_nil(@bookmarks_user[bookmark.id])
-    daijiro = @users.add
-    daijiro["name"] = "daijiro"
-    @bookmarks_user[bookmark.id] = daijiro
-    assert_equal(daijiro, @bookmarks_user[bookmark.id])
-  end
-  def test_array_set_with_key_of_table
-    languages = Groonga::Hash.create(:name => "Languages",
-                                     :key_type => "ShortText")
-    sites = Groonga::Hash.create(:name => "Sites")
-    sites.define_column("language", languages)
-    languages.add("Ruby")
-    taiyaki_ru = sites.add("http://taiyaki.ru/", :language => "Ruby")
-    assert_equal("Ruby", taiyaki_ru[:language].key)
-  end
-  def test_local_name
-    items = Groonga::Array.create(:name => "Items")
-    title = items.define_column("title", "ShortText")
-    assert_equal("Items.title", title.name)
-    assert_equal("title", title.local_name)
-  end
-  def test_select_query
-    populate_table_for_select
-    result = @body.select("drive")
-    assert_equal(["Drive and Eat"],
-                 result.records.collect do |record|
-                   record["body"]
-                 end)
-    assert_equal("#<Groonga::Expression noname($1:\"\")" +
-                 "{2body GET_VALUE,0\"drive\",0MATCH}>",
-                 result.expression.inspect)
-  end
-  def test_select_query_from_ctx
-    populate_table_for_select
-    body = Groonga::Context.default['Posts.body']
-    # select twice.
-    result = body.select("drive")
-    assert_equal(["Drive and Eat"],
-                 result.records.collect do |record|
-                   record["body"]
-                 end)
-    result = body.select("drive")
-    assert_equal(["Drive and Eat"],
-                 result.records.collect do |record|
-                   record["body"]
-                 end)
-  end
-  def test_select_query_with_parser
-    populate_table_for_select
-    result = @body.select("body @ \"drive\"", :syntax => :script)
-    assert_equal(["Drive and Eat"],
-                 result.records.collect do |record|
-                   record["body"]
-                 end)
-    assert_equal("#<Groonga::Expression noname($1:\"\")" +
-                 "{2body GET_VALUE,0\"drive\",0MATCH}>",
-                 result.expression.inspect)
-  end
-  def test_select_expression
-    populate_table_for_select
-    expression = Groonga::Expression.new
-    variable = expression.define_variable(:domain => @posts)
-    expression.append_object(variable)
-    expression.parse("body:@drive", :syntax => :query)
-    expression.compile
-    result = @body.select(expression)
-    assert_equal(["Drive and Eat"],
-                 result.records.collect do |record|
-                   record["body"]
-                 end)
-    assert_equal("#<Groonga::Expression noname($1:\"\")" +
-                 "{0\"\",2body GET_VALUE,0\"drive\",0MATCH}>",
-                 result.expression.inspect)
-  end
-  def test_select_with_block
-    populate_table_for_select
-    result = @body.select do |column|
-      column =~ "drive"
-    end
-    assert_equal(["Drive and Eat"],
-                 result.records.collect do |record|
-                   record["body"]
-                 end)
-    assert_equal("#<Groonga::Expression noname($1:\"\")" +
-                 "{1\"\",2body GET_VALUE,0\"drive\",0MATCH}>",
-                 result.expression.inspect)
-  end
-  def test_set_time
-    posts = Groonga::Hash.create(:name => "Posts", :key_type => "ShortText")
-    posts.define_column("issued", "Time")
-    post = posts.add("hello", :issued => 123456)
-    assert_equal(Time.at(123456), post[".issued"])
-    post = posts.add("groonga", :issued => 1251380635)
-    assert_equal(Time.parse("2009-08-27 22:43:55"), post[".issued"])
-    post = posts.add("mroonga", :issued => 1251380635.1234567)
-    assert_in_delta(Time.at(1251380635.1234567).usec, post[".issued"].usec, 10)
-  end
-  def test_set_nil_to_time
-    posts = Groonga::Hash.create(:name => "Posts", :key_type => "ShortText")
-    posts.define_column("issued", "Time")
-    post = posts.add("hello", :issued => nil)
-    assert_equal(Time.at(0), post["issued"])
-  end
-  def test_bool
-    posts = Groonga::Hash.create(:name => "Posts", :key_type => "ShortText")
-    posts.define_column("hidden", "Bool")
-    post = posts.add("hello")
-    assert_false(post["hidden"])
-    post["hidden"] = true
-    assert_true(post["hidden"])
-    post["hidden"] = false
-    assert_false(post["hidden"])
-  end
-  def test_indexes
-    Groonga::Schema.define do |schema|
-      schema.create_table("Comments") do |table|
-        table.short_text("title")
-      end
-    end
-    title = Groonga["Comments.title"]
-    assert_equal([], title.indexes)
-    Groonga::Schema.define do |schema|
-      schema.create_table("Terms",
-                          :type => :patricia_trie,
-                          :default_tokenizer => "TokenBigram") do |table|
-        table.index("Comments.title")
-      end
-    end
-    assert_equal([Groonga["Terms.Comments_title"]],
-                 title.indexes)
-    Groonga::Schema.define do |schema|
-      schema.create_table("Titles",
-                          :type => :hash) do |table|
-        table.index("Comments.title")
-      end
-    end
-    assert_equal([Groonga["Titles.Comments_title"],
-                  Groonga["Terms.Comments_title"]],
-                 title.indexes)
-  end
-  def test_builtin?
-    assert_not_predicate(@users_name_column, :builtin?)
-  end
-  private
-  def assert_content_search(expected_records, term)
-    records = @bookmarks_index_content.search(term).records
-    expected_contents = expected_records.collect do |record|
-      record["content"]
-    end
-    actual_contents = records.collect do |record|
-      record.key["content"]
-    end
-    assert_equal(expected_contents, actual_contents)
-  end
-  def populate_table_for_select
-    @posts = Groonga::Hash.create(:name => "Posts", :key_type => "ShortText")
-    @body = @posts.define_column("body", "Text")
-    index = Groonga::PatriciaTrie.create(:name => "Terms",
-                                         :key_type => "ShortText",
-                                         :key_normalize => true)
-    index.default_tokenizer = "TokenBigram"
-    index.define_index_column("body_index", @posts,
-                              :with_position => true,
-                              :source => @body)
-    @posts.add("Hello!", :body => "World")
-    @posts.add("My Hobby", :body => "Drive and Eat")
-  end
-end

data/test/test-command-select.rb DELETED Viewed

@@ -1,147 +0,0 @@
-# Copyright (C) 2010-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 CommandSelectTest < Test::Unit::TestCase
-  include GroongaTestUtils
-  setup :setup_database
-  setup
-  def setup_data
-    Groonga::Schema.define do |schema|
-      schema.create_table("Books",
-                          :type => :hash, :key_type => "ShortText") do |table|
-        table.time("published")
-      end
-      schema.create_table("Users",
-                          :type => :hash, :key_type => "ShortText") do |table|
-        table.reference("book", "Books")
-      end
-      schema.create_table("Bigram",
-                          :type => :patricia_trie,
-                          :key_type => "ShortText",
-                          :default_tokenizer => "TokenBigramSplitSymbolAlpha") do |table|
-        table.index("Books._key")
-      end
-    end
-    @books = Groonga["Books"]
-    @users = Groonga["Users"]
-    @books.add("the groonga book", :published => Time.parse("2010/04/01"))
-    @books.add("the groonga book (2)", :published => Time.parse("2011/04/01"))
-    @users.add("morita", :book => "the groonga book")
-    @users.add("gunyara-kun", :book => "the groonga book")
-    @users.add("yu")
-    @users.add("ryoqun", :book => "the groonga book (2)")
-  end
-  def test_no_option
-    result = context.select(@users)
-    assert_equal([4,
-                  [{"_id" => 1, "_key" => "morita",
-                     "book" => "the groonga book"},
-                   {"_id" => 2, "_key" => "gunyara-kun",
-                     "book" => "the groonga book"},
-                   {"_id" => 3, "_key" => "yu",
-                     "book" => ""},
-                   {"_id" => 4, "_key" => "ryoqun",
-                     "book" => "the groonga book (2)"}]],
-                 [result.n_hits, result.records])
-  end
-  def test_output_columns
-    result = context.select(@users, :output_columns => ["_key"])
-    assert_equal([4,
-                  [{"_key" => "morita"},
-                   {"_key" => "gunyara-kun"},
-                   {"_key" => "yu"},
-                   {"_key" => "ryoqun"}]],
-                 [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)
-    drill_down = normalize_drill_down(result.drill_down)
-    assert_equal([4,
-                  [{"_key" => "morita"},
-                   {"_key" => "gunyara-kun"},
-                   {"_key" => "yu"},
-                   {"_key" => "ryoqun"}],
-                  {
-                    "_key" => [4, [{"_key" => "morita"},
-                                   {"_key" => "gunyara-kun"},
-                                   {"_key" => "yu"},
-                                   {"_key" => "ryoqun"}]],
-                    "book" => [2, [{"_key" => "the groonga book"},
-                                   {"_key" => "the groonga book (2)"}]],
-                  },
-                 ],
-                 [result.n_hits, result.records, drill_down])
-  end
-  def test_drill_down_with_no_hit
-    result = context.select(@users,
-                            :filter => "_key == \"no\\ hit\"",
-                            :output_columns => ["_key"],
-                            :drill_down => ["_key", "book"],
-                            :drill_down_output_columns => "_key",
-                            :drill_down_limit => 10)
-    drill_down = normalize_drill_down(result.drill_down)
-    assert_equal([0, [],
-                  {
-                    "_key" => [0, []],
-                    "book" => [0, []],
-                  },
-                 ],
-                 [result.n_hits, result.records, drill_down])
-  end
-  def test_time
-    result = context.select(@books)
-    assert_equal([{
-                    "_id" => 1,
-                    "_key" => "the groonga book",
-                    "published" => Time.parse("2010/04/01"),
-                  },
-                  {
-                    "_id" => 2,
-                    "_key" => "the groonga book (2)",
-                    "published" => Time.parse("2011/04/01"),
-                  }],
-                 result.records)
-  end
-  def test_invalid
-    assert_raise(Groonga::SyntaxError) do
-      context.select(@books, :query => "<")
-    end
-  end
-  private
-  def normalize_drill_down(drill_down)
-    normalized_drill_down = {}
-    drill_down.each do |key, drill|
-      normalized_drill_down[key] = [drill.n_hits, drill.records]
-    end
-    normalized_drill_down
-  end
-end

data/test/test-context.rb DELETED Viewed

@@ -1,130 +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 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_create_database
-    db_path = @tmp_dir + "db"
-    assert_not_predicate(db_path, :exist?)
-    context = Groonga::Context.new
-    assert_equal(nil, context.database)
-    database = context.create_database(db_path.to_s)
-    assert_predicate(db_path, :exist?)
-    assert_not_predicate(database, :closed?)
-    assert_equal(database, context.database)
-  end
-  def test_create_temporary_database
-    before_files = @tmp_dir.children
-    context = Groonga::Context.new
-    database = context.create_database
-    assert_nil(database.name)
-    assert_equal(before_files, @tmp_dir.children)
-  end
-  def test_open_database
-    db_path = @tmp_dir + "db"
-    database = Groonga::Database.create(:path => db_path.to_s)
-    database.close
-    assert_predicate(database, :closed?)
-    called = false
-    context = Groonga::Context.new
-    context.open_database(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_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
-  def test_support_zlib?
-    assert_boolean(Groonga::Context.default.support_zlib?)
-  end
-  def test_support_lzo?
-    assert_boolean(Groonga::Context.default.support_lzo?)
-  end
-  def test_match_escalation_threshold
-    assert_equal(0, context.match_escalation_threshold)
-    context.match_escalation_threshold = -1
-    assert_equal(-1, context.match_escalation_threshold)
-  end
-  def test_close
-    context = Groonga::Context.new
-    assert_false(context.closed?)
-    context.close
-    assert_true(context.closed?)
-  end
-end