gonzui 1.2

data/test/test_gonzui.rb

@@ -0,0 +1,11 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class TestGonzui < Test::Unit::TestCase
+
+  def setup
+  end
+
+  def test_truth
+    assert true # TODO
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+begin
+  require 'redgreen'
+rescue LoadError
+end
+$LOAD_PATH << File.dirname(__FILE__) # require "test"
+require 'stringio'
+#require 'rbconfig.rb' # omajinai
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/gonzui'

data/test/test_importer.rb

@@ -0,0 +1,56 @@
+#! /usr/bin/env ruby
+require File.dirname(__FILE__) + '/test_helper.rb'
+require '_external_tools.rb'
+require '_test-util'
+
+class ImporterTest < Test::Unit::TestCase
+  include TestUtil
+
+  include FileUtils
+
+  def _test_import(url)
+    config   = Gonzui::Config.new
+    remove_db(config)
+    make_archives
+
+    importer = Gonzui::Importer.new(config)
+    importer.import(url)
+    begin
+      importer.import(url)
+      assert(false)
+    rescue Gonzui::ImporterError => e
+      assert(true)
+    end
+    summary = importer.summary
+    assert(summary.is_a?(String))
+    assert(/\d+/.match(summary))
+    importer.finish
+    remove_db(config)
+  end
+
+  def test_import_archive
+    _test_import(URI.from_path(FOO_TGZ))
+  end
+
+  def test_import_by_apt
+    _test_import(URI.for_apt("portmap"))
+  end
+
+  def test_import_unreadable_file
+    tmp_directory = "tmp.unreadable.#{Process.pid}"
+    mkdir_p(tmp_directory)
+
+    unreadable = File.join(tmp_directory, "unreadable.txt")
+    File.open(unreadable, "w") {|f| f.puts("unreadable") }
+    readable = File.join(tmp_directory, "readable.txt")
+    File.open(readable, "w") {|f| f.puts("readable") }
+
+    File.chmod(0000, unreadable)
+    begin
+      _test_import(URI.from_path(tmp_directory))
+    ensure
+      File.chmod(0600, unreadable)
+      rm_rf(tmp_directory)
+    end
+  end
+end if (APT_ && ARC_)

data/test/test_indexer.rb

@@ -0,0 +1,37 @@
+#! /usr/bin/env ruby
+require File.dirname(__FILE__) + '/test_helper.rb'
+require '_test-util'
+
+class IndexerTest < Test::Unit::TestCase
+  include TestUtil
+
+  def setup
+	  @dbm = nil
+    @config   = Gonzui::Config.new
+  end
+  def teardown
+    unless @dbm.nil?
+      @dbm.close rescue nil
+    end
+    @dbm = nil
+    remove_db(@config)
+  end
+
+  def test_index
+    remove_db(@config)
+    dbm = Gonzui::DBM.open(@config)
+    @dbm = dbm
+    path = File.join(File.dirname(__FILE__), "foo", "foo.c")
+    url = URI.from_path(File.expand_path(path))
+    content = Gonzui::Content.new(File.read(path), File.mtime(path))
+    source_url = URI.parse("file:///foo")
+    indexer = Gonzui::Indexer.new(@config, dbm, source_url, path, content)
+    indexer.index
+    dbm.flush_cache
+    assert_equal(1, dbm.get_ncontents)
+    assert(dbm.has_package?("foo"))
+#    assert(dbm.has_package?(File.basename(File.dirname(__FILE__))))
+    assert(dbm.has_word?("main"))
+    assert(dbm.consistent?)
+  end
+end

data/test/test_info.rb

@@ -0,0 +1,82 @@
+#! /usr/bin/env ruby
+require File.dirname(__FILE__) + '/test_helper.rb'
+require '_test-util'
+
+class InfoTest < Test::Unit::TestCase
+  TYPE_TABLE = [:fundef, :funcall, :fundecl]
+
+  def test_word_info
+    word_id = 0
+    word = "foo"
+    path_id = 100
+    seqno = 0
+    byteno = 300
+    lineno = 200
+    TYPE_TABLE.each_with_index {|type, type_id|
+      values = [word_id, path_id, seqno, byteno, type_id, type, lineno]
+      info = Gonzui::WordInfo.new(*values)
+      assert_equal(word_id, info.word_id)
+      assert_equal(path_id, info.path_id)
+      assert_equal(lineno, info.lineno)
+      assert_equal(byteno, info.byteno)
+      assert_equal(type_id, info.type_id)
+      assert_equal(type, info.type)
+
+      assert_equal(values, info.values)
+    }
+  end
+
+  def test_digest_info
+    byteno = 100
+    length = 5
+    TYPE_TABLE.each_with_index {|type, type_id|
+      values = [byteno, length, type_id, type]
+      info = Gonzui::DigestInfo.new(*values)
+      assert_equal(byteno, info.byteno)
+      assert_equal(length, length)
+      assert_equal(type_id, info.type_id)
+      assert_equal(values, info.values)
+    }
+  end
+
+  def test_occurrence
+    o = Gonzui::Occurrence.new(10, 1, 5)
+    assert_equal((10...15), o.range)
+    assert_equal(15, o.end_byteno)
+  end
+
+  def test_content_info
+    i = {
+      :size => 123,
+      :mtime => Time.at(0),
+      :itime => Time.now,
+      :format_id => 0,
+      :license_id => 1,
+      :nlines => 10,
+      :indexed_p => true,
+    }
+    Gonzui::ContentInfo.members.each {|name|
+      name = name.intern
+      i.include?(name)
+    }
+    info = Gonzui::ContentInfo.new(i[:size], i[:mtime], i[:itime], i[:format_id], 
+                           i[:license_id], i[:nlines], i[:indexed_p])
+    info.members.each {|name|
+      name = name.intern
+      assert_equal(i[name], info.send(name))
+    }
+    i.each_key {|name|
+      assert_equal(i[name], info.send(name))
+    }
+  end
+
+  def test_minus_mtime
+    size = 100
+    mtime = -1
+    itime = Time.now.to_i
+    format_id = license_id = nlines = indexed_p = 0
+    packed = Gonzui::ContentInfo.dump(size, mtime, itime, format_id, 
+                              license_id, nlines, indexed_p)
+    assert(packed.is_a?(String))
+  end
+end

data/test/test_license.rb

@@ -0,0 +1,49 @@
+#! /usr/bin/env ruby
+require File.dirname(__FILE__) + '/test_helper.rb'
+require '_test-util'
+
+class LicenseTest < Test::Unit::TestCase
+  TestCases = [
+    ["GPL1", false, "GNU General Public License version 1"],
+    ["GPL2", false, "GNU General Public License version 2"],
+    ["LGPL1", false, "GNU Library Public License version 1"],
+    ["LGPL2", false, "GNU Library Public License version 2"],
+    ["LGPL2.1", false, "GNU Lesser Public License version 2.1"],
+    ["Other", false, "My own license version 999"],
+
+    ["GPL2", false, "GNU GENERAL PUBLIC LICENSE VERSION 2"],
+    ["GPL2", false, "GNU  GENERAL    PUBLIC    LICENSE VERSION  2"],
+    ["GPL2", false, "GNU/GENERAL/PUBLIC/LICENSE/VERSION/2"],
+
+    ["GPL2", false, '
+# You can redistribute it and/or modify it under the terms of 
+# the GNU General Public License version 2.
+'
+    ],
+
+    ["GPL2", false, '
+# You can redistribute it and/or modify it under the terms of 
+# the GNU General Public License version 2.
+#
+# This is foobar version 1.  <= confusing!
+'
+    ],
+
+    ["GPL2", true, '
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.'
+    ],
+  ]
+
+  def test_license_detector
+    TestCases.each {|abbrev, allow_later_p, text|
+      detector = Gonzui::LicenseDetector.new(text)
+      license = detector.detect
+      assert_equal(abbrev, license.abbrev)
+      assert_equal(allow_later_p, license.allow_later?)
+    }
+  end
+end
+

data/test/test_logger.rb

@@ -0,0 +1,60 @@
+#! /usr/bin/env ruby
+require File.dirname(__FILE__) + '/test_helper.rb'
+require '_test-util'
+require 'time'
+
+class LoggerTest < Test::Unit::TestCase
+  def create_test_case
+    format = "foo %s"
+    arguments = ["bar"]
+    message = sprintf(format, arguments)
+    return format, arguments, message
+  end
+
+  def test_log
+    format, arguments, message = create_test_case
+
+    strio = StringIO.new
+    logger = Gonzui::Logger.new(strio)
+    a = Time.now
+    logger.log(format, *arguments)
+
+    log = strio.string
+    m = /^(.*?) (.*)/.match(log)
+    assert(m.is_a?(MatchData))
+    assert_equal(message, m[2])
+
+    time = Time.parse(m[1])
+    assert(time.is_a?(Time))
+    assert((time - a).abs < 1) # within 1 sec
+  end
+
+  def test_vlog
+    format, arguments, message = create_test_case
+
+    strio = StringIO.new
+    logger = Gonzui::Logger.new(strio, false)
+    logger.vlog(format, arguments)
+    assert(strio.string.empty?)
+
+    logger = Gonzui::Logger.new(strio, true)
+    logger.vlog(format, arguments)
+    assert(/^.*? #{message}/.match(strio.string))
+  end
+
+  def test_monitor
+    format, arguments, message = create_test_case
+    strio1 = StringIO.new
+    strio2 = StringIO.new
+    logger = Gonzui::Logger.new(strio1)
+    logger.log(format, arguments)
+    assert_equal(false, strio1.string.empty?)
+    assert(strio2.string.empty?)
+
+    logger.monitor = strio2
+    logger.log(format, arguments)
+    assert_equal(false, strio2.string.empty?)
+    assert(strio1.string.length > strio2.string.length)
+  end
+end
+

data/test/test_monitor.rb

@@ -0,0 +1,23 @@
+#! /usr/bin/env ruby
+require File.dirname(__FILE__) + '/test_helper.rb'
+require '_test-util'
+
+class MonitorTest < Test::Unit::TestCase
+  include TestUtil
+
+  def foo
+    1
+  end
+
+  def test_monitor
+    monitor = Gonzui::PerformanceMonitor.new
+    assert(monitor.empty?)
+    assert_equal("", monitor.format([MonitorTest, :foo]))
+    monitor.profile(self, :foo)
+    assert(!monitor.empty?)
+    summary = monitor.format([MonitorTest, :foo],
+                             [MonitorTest, :foo])
+    assert(summary.is_a?(String))
+    
+  end
+end

data/test/test_searcher.rb

@@ -0,0 +1,37 @@
+#! /usr/bin/env ruby
+require File.dirname(__FILE__) + '/test_helper.rb'
+require '_external_tools'
+require '_test-util'
+
+class SearcherTest < Test::Unit::TestCase
+  include TestUtil
+
+  def setup
+	@dbm = nil
+  end
+  def teardown
+    unless @dbm.nil?
+      @dbm.close rescue nil
+    end
+    @dbm = nil
+  end
+
+  def test_searcher
+    config = Gonzui::Config.new
+    make_db(config)
+    dbm = Gonzui::DBM.open(config)
+    @dbm = dbm
+    search_query = Gonzui::SearchQuery.new(config, "foo")
+    searcher = Gonzui::Searcher.new(dbm, search_query, 100)
+    result = searcher.search
+    assert(result.is_a?(Gonzui::SearchResult))
+    assert(result.length > 0)
+
+    search_query = Gonzui::SearchQuery.new(config, "205438967we9tn8we09asf")
+    searcher = Gonzui::Searcher.new(dbm, search_query, 100)
+    result = searcher.search
+    assert_equal(0, result.length)
+
+    dbm.close
+  end
+end if (ARC_)

data/test/test_searchquery.rb

@@ -0,0 +1,27 @@
+#! /usr/bin/env ruby
+require File.dirname(__FILE__) + '/test_helper.rb'
+require '_test-util'
+
+class QueryTest < Test::Unit::TestCase
+  def test_query
+    config = Gonzui::Config.new
+    [ 
+      ['foo bar',           [["foo", nil], ["bar", nil]]],
+      ['fundef:foo bar',    [["foo", :fundef], ["bar", nil]]],
+      ['"foo bar" baz',     [["foo bar", nil], ["baz", nil]]]
+    ].each {|query_string, parts|
+      query = Gonzui::SearchQuery.new(config, query_string)
+      query.each {|item| 
+        assert(item.is_a?(Gonzui::QueryItem))
+        part = parts.shift
+        if item.phrase?
+          assert_equal(part.first, item.value.join(" "))
+        else
+          assert_equal(part.first, item.value)
+        end
+        assert_equal(part.last, item.property)
+      }
+    }
+  end
+end
+

data/test/test_searchresult.rb

@@ -0,0 +1,43 @@
+#! /usr/bin/env ruby
+require File.dirname(__FILE__) + '/test_helper.rb'
+require '_external_tools'
+require '_test-util'
+
+class SearchResultTest < Test::Unit::TestCase
+  include TestUtil
+
+  def _test_basic(result)
+    i = 0
+    result.each {|item| i += 1}
+    assert_equal(result.length, i)
+    result.length.times {|i| assert(result[i].is_a?(Gonzui::WordInfo)) }
+
+    assert_equal(result[0], result.first)
+    assert_equal(result[result.length - 1], result.last)
+  end
+
+  def _test_clear(result)
+    result.clear
+    assert(result.empty?)
+    assert(result.length == 0)
+  end
+
+  def search(config, key)
+    result = Gonzui::SearchResult.new
+    Gonzui::DBM.open(config) {|dbm|
+      dbm.find_all(key).each {|info| result.push(info) }
+    }
+    return result
+  end
+
+  def test_search_result
+    config = Gonzui::Config.new
+    make_db(config)
+
+    result = search(config, "foo")
+    _test_basic(result)
+    _test_clear(result)
+
+    remove_db(config)
+  end
+end if (ARC_)