rroonga 2.0.2 → 2.0.3

data/test/test-expression.rb

@@ -1,134 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# 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 ExpressionTest < Test::Unit::TestCase
-  include GroongaTestUtils
-
-  setup :setup_database
-
-  def test_array_reference
-    expression = Groonga::Expression.new
-    ryoqun = expression.define_variable({:name => "user"})
-    ryoqun.value = "ryoqun"
-    mori = expression.define_variable
-    mori.value = "mori"
-
-    expression.append_object(ryoqun)
-    expression.append_object(mori)
-
-    assert_equal("ryoqun", expression["user"])
-    assert_equal("ryoqun", expression[0])
-    assert_equal("mori", expression[1])
-  end
-
-  def test_get_value
-    users = Groonga::Hash.create(:name => "Users")
-    name = users.define_column("name", "ShortText")
-
-    morita = users.add("morita", :name => "mori daijiro")
-
-    expression = Groonga::Expression.new
-    expression.append_constant(morita)
-    expression.append_constant("name")
-    expression.append_operation(Groonga::Operation::GET_VALUE, 2)
-    expression.compile
-    assert_equal("mori daijiro", expression.execute)
-  end
-
-  def test_get_value_with_variable
-    users = Groonga::Hash.create(:name => "Users")
-    name = users.define_column("name", "ShortText")
-
-    morita = users.add("morita", :name => "mori daijiro")
-    gunyara_kun = users.add("gunyara-kun", :name => "Tasuku SUENAGA")
-
-    expression = Groonga::Expression.new
-    variable = expression.define_variable
-    variable.value = morita
-    expression.append_object(variable)
-    expression.append_constant("name")
-    expression.append_operation(Groonga::Operation::GET_VALUE, 2)
-    expression.compile
-    assert_equal("mori daijiro", expression.execute)
-
-    variable.value = gunyara_kun.id
-    assert_equal("Tasuku SUENAGA", expression.execute)
-  end
-
-  def test_inspect
-    expression = Groonga::Expression.new
-    expression.append_constant(1)
-    expression.append_constant(1)
-    expression.append_operation(Groonga::Operation::PLUS, 2)
-    expression.compile
-
-    assert_equal("#<Groonga::Expression noname(){21,01,0PLUS}>",
-                 expression.inspect)
-  end
-
-  def test_snippet
-    users = Groonga::Array.create(:name => "Users")
-    users.define_column("name", "ShortText")
-    Groonga::Hash.create(:name => "Terms",
-                         :key_type => "ShortText",
-                         :default_tokenizer => "TokenBigram")
-    users.define_index_column("user_name", users,
-                              :source => "Users.name",
-                              :with_position => true)
-
-    expression = Groonga::Expression.new
-    variable = expression.define_variable(:domain => users)
-    expression.append_object(variable)
-    expression.parse("ラングバ OR Ruby OR groonga", :default_column => name)
-    expression.compile
-
-    snippet = expression.snippet([["[[", "]]"], ["<", ">"]],
-                                 :width => 30)
-    assert_equal(["[[ラングバ]]プロジェクト",
-                  "ン[[groonga]]の機能を<Ruby>か",
-                  "。[[groonga]]の機能を<Ruby>ら"],
-                 snippet.execute("ラングバプロジェクトはカラムストア機能も" +
-                                 "備える高速・高機能な全文検索エンジンgroonga" +
-                                 "の機能をRubyから利用するためのライブラリを" +
-                                 "提供するプロジェクトです。groongaの機能を" +
-                                 "Rubyらしい読み書きしやすい構文で利用できる" +
-                                 "ことが利点です。"))
-    snippet.close
-  end
-
-  def test_snippet_without_tags
-    users = Groonga::Array.create(:name => "Users")
-    users.define_column("name", "ShortText")
-    Groonga::Hash.create(:name => "Terms",
-                         :key_type => "ShortText",
-                         :default_tokenizer => "TokenBigram")
-    users.define_index_column("user_name", users,
-                              :source => "Users.name",
-                              :with_position => true)
-
-    expression = Groonga::Expression.new
-    variable = expression.define_variable(:domain => users)
-    expression.append_object(variable)
-    expression.parse("ラングバ", :default_column => name)
-    expression.compile
-
-    snippet = expression.snippet([], :width => 30)
-    assert_equal(["ラングバプロジェクト"],
-                 snippet.execute("ラングバプロジェクトはカラムストア機能も"))
-    snippet.close
-  end
-end

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

@@ -1,77 +0,0 @@
-# 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 FixSizeColumnTest < Test::Unit::TestCase
-  include GroongaTestUtils
-
-  def setup
-    setup_database
-
-    setup_bookmarks_table
-  end
-
-  def setup_bookmarks_table
-    @bookmarks_path = @tables_dir + "bookmarks"
-    @bookmarks = Groonga::Array.create(:name => "Bookmarks",
-                                       :path => @bookmarks_path.to_s)
-
-    @viewed_column_path = @columns_dir + "viewed"
-    @viewed = @bookmarks.define_column("viewed", "Int32",
-                                       :path => @viewed_column_path.to_s)
-  end
-
-  def test_index?
-    assert_not_predicate(@viewed, :index?)
-  end
-
-  def test_vector?
-    assert_not_predicate(@viewed, :vector?)
-  end
-
-  def test_scalar?
-    assert_predicate(@viewed, :scalar?)
-  end
-
-  def test_inspect
-    assert_equal("#<Groonga::FixSizeColumn " +
-                 "id: <#{@viewed.id}>, " +
-                 "name: <Bookmarks.viewed>, " +
-                 "path: <#{@viewed_column_path}>, " +
-                 "domain: <Bookmarks>, " +
-                 "range: <Int32>, " +
-                 "flags: <KEY_INT>" +
-                 ">",
-                 @viewed.inspect)
-  end
-
-  def test_domain
-    assert_equal(@bookmarks, @viewed.domain)
-  end
-
-  def test_table
-    assert_equal(@bookmarks, @viewed.table)
-  end
-
-  def test_assign_time
-    comments = Groonga::Array.create(:name => "Comments")
-    comments.define_column("title", "ShortText")
-    comments.define_column("issued", "Time")
-    title = "Good"
-    issued = 1187430026
-    record = comments.add(:title => title, :issued => issued)
-    assert_equal([title, Time.at(issued)],
-                 [record["title"], record["issued"]])
-  end
-end

data/test/test-gqtp.rb

@@ -1,70 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2010-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 GQTPTest < Test::Unit::TestCase
-  include GroongaTestUtils
-
-  setup :setup_database
-
-  setup
-  def setup_comments
-    @users = Groonga::Hash.create(:name => "Users", :key_type => "ShortText")
-
-    @comments = Groonga::Array.create(:name => "Comments")
-    @comments.define_column("content", "Text")
-    @comments.define_column("created_at", "Time")
-    @comments.define_column("user", "Users")
-
-    terms = Groonga::PatriciaTrie.create(:name => "Terms",
-                                         :default_tokenizer => "TokenBigram")
-    terms.define_index_column("comment_content", @comments,
-                              :with_section => true,
-                              :source => "content")
-    @comment1 = @comments.add(:content => "Hello Good-bye!",
-                              :created_at => Time.parse("2009-08-09"),
-                              :user => "morita")
-    @comment2 = @comments.add(:content => "Hello World",
-                              :created_at => Time.parse("2009-07-09"),
-                              :user => "")
-    @comment3 = @comments.add(:content => "test",
-                              :created_at => Time.parse("2009-06-09"),
-                              :user => "gunyara-kun")
-    @japanese_comment =
-      @comments.add(:content => "うちのボロTVはまだ現役です",
-                    :created_at => Time.parse("2009-06-09"),
-                    :user => "darashi")
-  end
-
-  def test_select_filter_by_existent_user
-    assert_equal([[[1], [["user", "Users"]], ["darashi"]]],
-                 process("select Comments --output_columns user " +
-                         "--filter 'user == \"darashi\"'"))
-  end
-
-  def test_select_filter_by_nonexistent_user
-    assert_equal([[[0], [["user", "Users"]]]],
-                 process("select Comments --output_columns user " +
-                         "--filter 'user == \"yu\"'"))
-  end
-
-  private
-  def process(gqtp)
-    context.send(gqtp)
-    _, result = context.receive
-    JSON.parse(result)
-  end
-end

data/test/test-hash.rb

@@ -1,344 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# 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 HashTest < Test::Unit::TestCase
-  include GroongaTestUtils
-
-  setup :setup_database
-
-  def test_support_key?
-    assert_predicate(Groonga::Hash.create(:name => "Users",
-                                          :key_type => "ShortText"),
-                     :support_key?)
-  end
-
-  def test_delete
-    bookmarks_path = @tables_dir + "bookmarks"
-    bookmarks = Groonga::Hash.create(:name => "Bookmarks",
-                                     :path => bookmarks_path.to_s)
-
-    bookmarks.add("groonga")
-    google = bookmarks.add("Google")
-    cutter = bookmarks.add("Cutter")
-
-    assert_equal(["groonga", "Google", "Cutter"],
-                 bookmarks.collect {|bookmark| bookmark.key})
-
-    bookmarks.delete(google.id)
-    assert_equal(["groonga", "Cutter"],
-                 bookmarks.collect {|bookmark| bookmark.key})
-
-    bookmarks.delete(cutter.key)
-    assert_equal(["groonga"],
-                 bookmarks.collect {|bookmark| bookmark.key})
-  end
-
-  def test_value
-    bookmarks_path = @tables_dir + "bookmarks"
-    bookmarks = Groonga::Hash.create(:name => "Bookmarks",
-                                     :path => bookmarks_path.to_s,
-                                     :key_type => "ShortText",
-                                     :value_type => "UInt32")
-    bookmarks.set_value("http://google.com/", 29)
-    assert_equal(29, bookmarks.value("http://google.com/"))
-  end
-
-  def test_column_value
-    bookmarks_path = @tables_dir + "bookmarks"
-    bookmarks = Groonga::Hash.create(:name => "Bookmarks",
-                                     :path => bookmarks_path.to_s,
-                                     :key_type => "ShortText")
-    bookmarks.define_column("uri", "ShortText")
-    bookmarks.set_column_value("google", "uri", "http://google.com/")
-    assert_equal("http://google.com/", bookmarks.column_value("google", "uri"))
-  end
-
-  def test_array_reference
-    bookmarks_path = @tables_dir + "bookmarks"
-    bookmarks = Groonga::Hash.create(:name => "bookmarks",
-                                     :path => bookmarks_path.to_s,
-                                     :key_type => "ShortText")
-    bookmark = bookmarks.add("http://google.com/")
-    assert_equal(bookmark, bookmarks["http://google.com/"])
-  end
-
-  def test_inspect_anonymous
-    path = @tables_dir + "anoymous.groonga"
-    anonymous_table = Groonga::Hash.create(:path => path.to_s)
-    assert_equal("#<Groonga::Hash " +
-                 "id: <#{anonymous_table.id}>, " +
-                 "name: (anonymous), " +
-                 "path: <#{path}>, " +
-                 "domain: <ShortText>, " +
-                 "range: (nil), " +
-                 "flags: <>, " +
-                 "encoding: <#{encoding.inspect}>, " +
-                 "size: <0>>",
-                 anonymous_table.inspect)
-  end
-
-  def test_inspect_anonymous_temporary
-    anonymous_table = Groonga::Hash.create
-    assert_equal("#<Groonga::Hash " +
-                 "id: <#{anonymous_table.id}>, " +
-                 "name: (anonymous), " +
-                 "path: (temporary), " +
-                 "domain: <ShortText>, " +
-                 "range: (nil), " +
-                 "flags: <>, " +
-                 "encoding: <#{encoding.inspect}>, " +
-                 "size: <0>>",
-                 anonymous_table.inspect)
-  end
-
-  def test_inspect_named
-    path = @tables_dir + "named.groonga"
-    named_table = Groonga::Hash.create(:name => "Users", :path => path.to_s)
-    assert_equal("#<Groonga::Hash " +
-                 "id: <#{named_table.id}>, " +
-                 "name: <Users>, " +
-                 "path: <#{path}>, " +
-                 "domain: <ShortText>, " +
-                 "range: (nil), " +
-                 "flags: <>, " +
-                 "encoding: <#{encoding.inspect}>, " +
-                 "size: <0>>",
-                 named_table.inspect)
-  end
-
-  def test_inspect_temporary
-    named_table = Groonga::Hash.create
-    assert_equal("#<Groonga::Hash " +
-                 "id: <#{named_table.id}>, " +
-                 "name: (anonymous), " +
-                 "path: (temporary), " +
-                 "domain: <ShortText>, " +
-                 "range: (nil), " +
-                 "flags: <>, " +
-                 "encoding: <#{encoding.inspect}>, " +
-                 "size: <0>>",
-                 named_table.inspect)
-  end
-
-  def test_encoding
-    assert_equal(Groonga::Encoding.default,
-                 Groonga::Hash.create.encoding)
-  end
-
-  def test_tokenizer
-    hash = Groonga::Hash.create
-    assert_nil(hash.default_tokenizer)
-    hash.default_tokenizer = "TokenBigram"
-    assert_equal(Groonga::Context.default["TokenBigram"],
-                 hash.default_tokenizer)
-  end
-
-  def test_search
-    users = Groonga::Array.create(:name => "Users")
-    users.define_column("name", "ShortText")
-
-    bookmarks = Groonga::Hash.create(:name => "Bookmarks",
-                                     :key_type => "ShortText")
-    bookmarks.define_column("user_id", users)
-
-    daijiro = users.add
-    daijiro["name"] = "daijiro"
-    gunyarakun = users.add
-    gunyarakun["name"] = "gunyarakun"
-
-    groonga = bookmarks.add("http://groonga.org/")
-    groonga["user_id"] = daijiro
-
-    records = bookmarks.search("http://groonga.org/")
-    assert_equal(["daijiro"],
-                 records.records.collect {|record| record["user_id.name"]})
-  end
-
-  def test_add
-    users = Groonga::Hash.create(:name => "Users")
-    users.define_column("address", "Text")
-    me = users.add("me", :address => "me@example.com")
-    assert_equal("me@example.com", me[:address])
-  end
-
-  def test_default_tokenizer_on_create
-    terms = Groonga::Hash.create(:name => "Terms",
-                                 :default_tokenizer => "TokenTrigram")
-    assert_equal(context[Groonga::Type::TRIGRAM],
-                 terms.default_tokenizer)
-  end
-
-  def test_duplicated_name
-    Groonga::Hash.create(:name => "Users")
-    assert_raise(Groonga::InvalidArgument) do
-      Groonga::Hash.create(:name => "Users")
-    end
-  end
-
-  def test_define_index_column_implicit_with_position
-    bookmarks = Groonga::Hash.create(:name => "Bookmarks")
-    bookmarks.define_column("comment", "Text")
-    terms = Groonga::Hash.create(:name => "Terms",
-                                 :default_tokenizer => "TokenBigram")
-    index = terms.define_index_column("comment", bookmarks,
-                                      :source => "Bookmarks.comment")
-    bookmarks.add("groonga", :comment => "search engine by Brazil")
-    bookmarks.add("google", :comment => "search engine by Google")
-    bookmarks.add("ruby", :comment => "programing language")
-
-    assert_equal(["groonga", "google"],
-                 index.search("engine").collect {|record| record.key.key})
-  end
-
-  def test_has_key?
-    users = Groonga::Hash.create(:name => "Users")
-    assert_false(users.has_key?("morita"))
-    users.add("morita")
-    assert_true(users.has_key?("morita"))
-  end
-
-  def test_big_key
-    hash = Groonga::Hash.create(:key_type => "UInt64")
-    assert_nothing_raised do
-      hash.add(1 << 63)
-    end
-  end
-
-  def test_value_by_key
-    users = Groonga::Hash.create(:key_type => "ShortText",
-                                 :value_type => "Int32")
-    key = "niku"
-    users.add(key)
-    users.set_value(key, 29)
-    assert_equal(29, users.value(key))
-  end
-
-  def test_value_by_id
-    users = Groonga::Hash.create(:key_type => "ShortText",
-                                 :value_type => "Int32")
-    user_id = users.add("niku").id
-    users.set_value(user_id, 29, :id => true)
-    assert_equal(29, users.value(user_id, :id => true))
-  end
-
-  def test_id
-    users = Groonga::Hash.create(:key_type => "ShortText")
-
-    key = "niku"
-    assert_nil(users.id(key))
-    user_id = users.add(key).id
-    assert_equal(user_id, users.id(key))
-  end
-
-  def test_set_multi_values
-    users = Groonga::Hash.create(:name => "Users",
-                                 :key_type => "ShortText")
-    users.define_column("self_introduction", "ShortText")
-    users.define_column("age", "UInt32")
-
-    key = "niku"
-    niku = users.add(key)
-    assert_equal({
-                   "_id" => niku.id,
-                   "_key" => key,
-                   "self_introduction" => nil,
-                   "age" => 0,
-                 },
-                 niku.attributes)
-    users[key] = {
-      "self_introduction" => "I'm a meet lover.",
-      "age" => 29
-    }
-    assert_equal({
-                   "_id" => niku.id,
-                   "_key" => key,
-                   "self_introduction" => "I'm a meet lover.",
-                   "age" => 29,
-                 },
-                 niku.attributes)
-  end
-
-  def test_set_multi_values_for_nonexistent_record
-    users = Groonga::Hash.create(:name => "Users",
-                                 :key_type => "ShortText")
-    users.define_column("self_introduction", "ShortText")
-    users.define_column("age", "UInt32")
-
-    key = "niku"
-    users[key] = {
-      "self_introduction" => "I'm a meet lover.",
-      "age" => 29
-    }
-
-    assert_equal({
-                   "_id" => users[key].id,
-                   "_key" => key,
-                   "self_introduction" => "I'm a meet lover.",
-                   "age" => 29,
-                 },
-                 users[key].attributes)
-  end
-
-  def test_set_multi_values_with_nonexistent_column
-    users = Groonga::Hash.create(:name => "Users",
-                                 :key_type => "ShortText")
-    users.define_column("self_introduction", "ShortText")
-    users.define_column("age", "UInt32")
-
-    key = "niku"
-    inspected_users = users.inspect.sub(/size: <0>/, "size: <1>")
-    message = "no such column: <\"nonexistent\">: <#{inspected_users}>"
-    assert_raise(Groonga::NoSuchColumn.new(message)) do
-      users[key] = {
-        "nonexistent" => "No!",
-      }
-    end
-  end
-
-  def test_added?
-    users = Groonga::Hash.create(:name => "Users",
-                                 :key_type => "ShortText")
-    bob = users.add("bob")
-    assert_predicate(bob, :added?)
-    bob_again = users.add("bob")
-    assert_not_predicate(bob_again, :added?)
-  end
-
-  def test_defrag
-    users = Groonga::Hash.create(:name => "Users",
-                                 :key_type => "ShortText")
-    users.define_column("name", "ShortText")
-    users.define_column("address", "ShortText")
-    1000.times do |i|
-      users.add("user #{i}",
-                :name => "user #{i}" * 1000,
-                :address => "address #{i}" * 1000)
-    end
-    assert_equal(7, users.defrag)
-  end
-
-  def test_rename
-    users = Groonga::Hash.create(:name => "Users",
-                                 :key_type => "ShortText")
-    name = users.define_column("name", "ShortText")
-    address = users.define_column("address", "ShortText")
-
-    users.rename("People")
-    assert_equal(["People", "People.name", "People.address"],
-                 [users.name, name.name, address.name])
-  end
-end