rroonga 0.9.2-mswin32

data/test-unit/test/util/test_procwrapper.rb

@@ -0,0 +1,36 @@
+# Author:: Nathaniel Talbott.
+# Copyright:: Copyright (c) 2000-2002 Nathaniel Talbott. All rights reserved.
+# License:: Ruby license.
+
+require 'test/unit'
+require 'test/unit/util/procwrapper'
+
+module Test
+  module Unit
+    module Util
+      class TC_ProcWrapper < TestCase
+        def munge_proc(&a_proc)
+          return a_proc
+        end
+        def setup
+          @original = proc {}
+          @munged = munge_proc(&@original)
+          @wrapped_original = ProcWrapper.new(@original)
+          @wrapped_munged = ProcWrapper.new(@munged)
+        end
+        def test_wrapping
+          assert_same(@original, @wrapped_original.to_proc, "The wrapper should return what was wrapped")
+        end
+        def test_hashing
+      
+          assert_equal(@wrapped_original.hash, @wrapped_munged.hash, "The original and munged should have the same hash when wrapped")
+          assert_equal(@wrapped_original, @wrapped_munged, "The wrappers should be equivalent")
+          
+          a_hash = {@wrapped_original => @original}
+          assert(a_hash[@wrapped_original], "Should be able to access the wrapper in the hash")
+          assert_equal(a_hash[@wrapped_original], @original, "Should be able to access the wrapper in the hash")
+        end
+      end
+    end
+  end
+end

data/test/.gitignore

@@ -0,0 +1 @@
+/.test-result

data/test/groonga-test-utils.rb

@@ -0,0 +1,133 @@
+# 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
+
+require 'fileutils'
+require 'pathname'
+require 'time'
+begin
+  require 'json'
+rescue LoadError
+  require 'rubygems'
+  require 'json'
+end
+require 'pkg-config'
+
+require 'groonga'
+
+module GroongaTestUtils
+  class << self
+    def included(base)
+      base.setup :setup_sandbox, :before => :prepend
+      base.teardown :teardown_sandbox, :after => :append
+    end
+  end
+
+  def setup_sandbox
+    setup_tmp_directory
+    setup_log_path
+
+    setup_tables_directory
+    setup_columns_directory
+
+    setup_encoding
+    setup_context
+  end
+
+  def setup_tmp_directory
+    @tmp_dir = Pathname(File.dirname(__FILE__)) + "tmp"
+    FileUtils.rm_rf(@tmp_dir.to_s)
+    FileUtils.mkdir_p(@tmp_dir.to_s)
+  end
+
+  def setup_log_path
+    @dump_log = false
+    Groonga::Logger.log_path = (@tmp_dir + "groonga.log").to_s
+    Groonga::Logger.query_log_path = (@tmp_dir + "groonga-query.log").to_s
+  end
+
+  def setup_tables_directory
+    @tables_dir = @tmp_dir + "tables"
+    FileUtils.mkdir_p(@tables_dir.to_s)
+  end
+
+  def setup_columns_directory
+    @columns_dir = @tmp_dir + "columns"
+    FileUtils.mkdir_p(@columns_dir.to_s)
+  end
+
+  def setup_encoding
+    Groonga::Encoding.default = nil
+  end
+
+  def setup_context
+    Groonga::Context.default = nil
+    Groonga::Context.default_options = nil
+  end
+
+  def context
+    Groonga::Context.default
+  end
+
+  def encoding
+    Groonga::Encoding.default
+  end
+
+  def setup_logger
+    Groonga::Logger.register(:level => :dump) do |level, time, title, message, location|
+      p [level, time, title, message, location]
+    end
+  end
+
+  def setup_database
+    @database_path = @tmp_dir + "database"
+    @database = Groonga::Database.create(:path => @database_path.to_s)
+  end
+
+  def teardown_sandbox
+    @database = nil
+    GC.start
+    teardown_log_path
+    teardown_tmp_directory
+  end
+
+  def teardown_log_path
+    return unless @dump_log
+    log_path = Groonga::Logger.log_path
+    query_log_path = Groonga::Logger.query_log_path
+    if File.exist?(log_path)
+      header = "--- log: #{log_path} ---"
+      puts(header)
+      puts(File.read(log_path))
+      puts("-" * header.length)
+    end
+    if File.exist?(query_log_path)
+      header = "--- query log: #{query_log_path} ---"
+      puts(header)
+      puts(File.read(query_log_path))
+      puts("-" * header.length)
+    end
+  end
+
+  def teardown_tmp_directory
+    FileUtils.rm_rf(@tmp_dir.to_s)
+  end
+
+  private
+  def assert_equal_select_result(expected, actual)
+    assert_equal(expected,
+                 actual.collect {|record| record.key},
+                 actual.expression.inspect)
+  end
+end

data/test/run-test.rb

@@ -0,0 +1,58 @@
+#!/usr/bin/env ruby
+#
+# 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
+
+$VERBOSE = true
+
+$KCODE = "u" if RUBY_VERSION < "1.9"
+
+base_dir = File.expand_path(File.join(File.dirname(__FILE__), ".."))
+test_unit_dir = File.join(base_dir, "test-unit", "lib")
+ext_dir = File.join(base_dir, "ext")
+lib_dir = File.join(base_dir, "lib")
+test_dir = File.join(base_dir, "test")
+
+make = nil
+if system("which gmake > /dev/null")
+  make = "gmake"
+elsif system("which make > /dev/null")
+  make = "make"
+end
+if make
+  system("cd #{base_dir.dump} && #{make} > /dev/null") or exit(1)
+end
+
+$LOAD_PATH.unshift(test_unit_dir)
+
+require 'test/unit'
+
+ARGV.unshift("--priority-mode")
+
+$LOAD_PATH.unshift(ext_dir)
+$LOAD_PATH.unshift(lib_dir)
+$LOAD_PATH.unshift(base_dir)
+
+$LOAD_PATH.unshift(test_dir)
+require 'groonga-test-utils'
+
+pkg_config = File.join(base_dir, "vendor", "local", "lib", "pkgconfig")
+PackageConfig.prepend_default_path(pkg_config)
+
+Dir.glob("#{base_dir}/test/**/test{_,-}*.rb") do |file|
+  require file.sub(/\.rb$/, '')
+end
+
+exit Test::Unit::AutoRunner.run(false)

data/test/test-array.rb

@@ -0,0 +1,97 @@
+# Copyright (C) 2009-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 ArrayTest < Test::Unit::TestCase
+  include GroongaTestUtils
+
+  setup :setup_database
+
+  def test_inspect_size
+    path = @tables_dir + "named.groonga"
+    contain_table = Groonga::Array.create(:name => "name", :path => path.to_s)
+    3.times do
+      contain_table.add
+    end
+    assert_equal("#<Groonga::Array " +
+                 "id: <#{contain_table.id}>, " +
+                 "name: <name>, " +
+                 "path: <#{path}>, " +
+                 "domain: (nil), " +
+                 "range: (nil), " +
+                 "flags: <>, " +
+                 "size: <3>>",
+                 contain_table.inspect)
+  end
+
+  def test_encoding
+    array = Groonga::Array.create
+    assert_false(array.respond_to?(:encoding))
+  end
+
+  def test_add
+    users = Groonga::Array.create(:name => "Users")
+    users.define_column("name", "Text")
+    me = users.add(:name => "me")
+    assert_equal("me", me[:name])
+  end
+
+  def test_define_index_column
+    users = Groonga::Array.create(:name => "Users")
+    users.define_column("name", "Text")
+    bookmarks = Groonga::Array.create(:name => "Bookmarks")
+    bookmarks.define_column("title", "Text")
+    bookmarks.define_column("user", users)
+
+    index = users.define_index_column("bookmarks", bookmarks,
+                                      :source => "Bookmarks.user")
+    morita = users.add(:name => "morita")
+    gunyara_kun = users.add(:name => "gunyara-kun")
+    groonga = bookmarks.add(:title => "groonga", :user => morita)
+    google = bookmarks.add(:title => "google", :user => morita)
+    python = bookmarks.add(:title => "Python", :user => gunyara_kun)
+
+    assert_equal(["groonga", "google"],
+                 index.search(morita.id).collect {|record| record.key["title"]})
+  end
+
+  def test_create_duplicated_name
+    Groonga::Array.create(:name => "Users")
+    assert_raise(Groonga::InvalidArgument) do
+      Groonga::Array.create(:name => "Users")
+    end
+  end
+
+  def test_open_same_name
+    users_created = Groonga::Array.create(:name => "Users")
+    users_opened = Groonga::Array.open(:name => "Users")
+    users_opened.add
+    assert_equal(1, users_created.size)
+  end
+
+  def test_value
+    users = Groonga::Array.create(:value_type => "Int32")
+    user_id = users.add.id
+    users.set_value(user_id, 29)
+    assert_equal(29, users.value(user_id))
+  end
+
+  def test_column_value
+    users = Groonga::Array.create(:name => "Users")
+    name = users.define_column("name", "ShortText")
+    morita_id = users.add.id
+    users.set_column_value(morita_id, "name", "morita")
+    assert_equal("morita", users.column_value(morita_id, "name"))
+  end
+end

data/test/test-column.rb

@@ -0,0 +1,316 @@
+# 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 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(?0:\"\")" +
+                 "{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(?0:\"\")" +
+                 "{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(?0:\"\")" +
+                 "{0?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(?0:\"\")" +
+                 "{1?0,2body GET_VALUE,0\"drive\",0MATCH}>",
+                 result.expression.inspect)
+  end
+
+  def test_set_time
+    posts = Groonga::Hash.create(:name => "Posts", :key_type => "ShortText")
+    body = 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")
+    body = 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")
+    hidden = 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
+
+  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"
+    body_index = index.define_index_column("body_index", @posts,
+                                           :with_position => true,
+                                           :source => @body)
+
+    first_post = @posts.add("Hello!", :body => "World")
+    hobby = @posts.add("My Hobby", :body => "Drive and Eat")
+  end
+end