bitclust-core 0.5.1 → 0.5.2

data/vendor/bundle/ruby/1.9.1/gems/bitclust-core-0.5.1/test/run_test.rb

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+require 'pathname'
+
+gem 'test-unit'
+require 'test/unit'
+require 'test/unit/notify'
+require 'test/unit/rr'
+
+base_dir = Pathname.new(__FILE__).dirname.expand_path
+top_dir = (base_dir + '..').expand_path
+lib_dir = top_dir + 'lib'
+
+$LOAD_PATH.unshift(lib_dir.to_s)
+
+exit Test::Unit::AutoRunner.run(true, base_dir)

data/vendor/bundle/ruby/1.9.1/gems/bitclust-core-0.5.1/test/test_bitclust.rb

@@ -0,0 +1,81 @@
+require 'bitclust'
+require 'bitclust/subcommand'
+require 'stringio'
+require 'tmpdir'
+require 'fileutils'
+
+class TestBitClust < Test::Unit::TestCase
+  def setup
+    @tmpdir = Dir.mktmpdir
+    src = "#{@tmpdir}/function/public_func"
+    @srcdir = Dir.mkdir File.dirname(src)
+    File.open(src, 'w') do |file|
+      file.puts <<'HERE'
+filename=test.c
+macro=false
+private=false
+type=VALUE
+name=public_func
+params=()
+
+
+This is public function.
+HERE
+    end
+
+    @out = StringIO.new
+  end
+
+  def teardown
+    FileUtils.rm_r(@tmpdir, :force => true)
+  end
+
+  def search_capi(command, *argv)
+    db = BitClust::FunctionDatabase.new(@tmpdir)
+    cmd = case command
+          when "lookup"
+            BitClust::LookupCommand.new
+          when "list"
+            BitClust::ListCommand.new
+          else
+            raise "must not happen! command=#{command}"
+          end
+    @out.string = ""
+    $stdout = @out
+    begin
+      cmd.parse(argv)
+      cmd.exec(db, argv)
+    ensure
+      $stdout = STDOUT
+    end
+    @out.string
+  end
+
+  def test_list
+    assert_equal("public_func\n", search_capi("list", "--function"))
+  end
+
+  def test_lookup
+    assert_equal(<<-EOS, search_capi("lookup", "--function=public_func").chomp)
+kind: function
+header: VALUE public_func()
+filename: test.c
+
+
+This is public function.
+    EOS
+  end
+
+  def test_lookup_html
+    assert_equal(<<-EOS, search_capi("lookup", "--function=public_func", "--html").chomp)
+<dl>
+<dt>kind</dt><dd>function</dd>
+<dt>header</dt><dd>VALUE public_func()</dd>
+<dt>filename</dt><dd>test.c</dd>
+</dl>
+<p>
+This is public function.
+</p>
+    EOS
+  end
+end

data/vendor/bundle/ruby/1.9.1/gems/bitclust-core-0.5.1/test/test_entry.rb

@@ -0,0 +1,53 @@
+require 'bitclust'
+require 'test/unit'
+
+class TestClassEntry < Test::Unit::TestCase
+  def setup
+    s = <<HERE
+= class Hoge
+alias HogeHoge
+alias HogeHogeHoge
+== Class Methods
+--- hoge
+= class Bar < Hoge
+== Class Methods
+--- bar
+= class Err < Exception
+alias ErrErr
+HERE
+    @lib, = BitClust::RRDParser.parse(s, 'hoge')
+  end
+
+  def test_entries
+    assert_equal(['bar', 'hoge'],
+                 @lib.fetch_class("Bar").entries(1).map{|e| e.name}.sort)
+  end
+
+  def test_aliases
+    assert_equal(['HogeHoge', 'HogeHogeHoge'],
+                 @lib.fetch_class("Hoge").aliases.map{|e| e.name}.sort)
+  end
+
+  def test_aliasof
+    assert_equal(nil, @lib.fetch_class("Hoge").aliasof)
+    assert_equal("Hoge", @lib.fetch_class("HogeHoge").aliasof.name)
+  end
+
+  def test_realname
+    assert_equal('Hoge', @lib.fetch_class("Hoge").realname)
+    assert_equal('Hoge', @lib.fetch_class("HogeHoge").realname)
+  end
+
+  def test_error_class_p
+    assert(!@lib.fetch_class("Hoge").error_class?)
+    assert(@lib.fetch_class("Err").error_class?)
+    assert(!@lib.fetch_class("HogeHoge").error_class?)
+    assert(@lib.fetch_class("ErrErr").error_class?)
+  end
+
+  def test_superclass
+    assert('Exception', @lib.fetch_class("Err").superclass.name)
+    assert('Exception', @lib.fetch_class("ErrErr").superclass.name)
+  end
+end
+

data/vendor/bundle/ruby/1.9.1/gems/bitclust-core-0.5.1/test/test_functiondatabase.rb

@@ -0,0 +1,55 @@
+require 'test/unit'
+require 'bitclust'
+require 'bitclust/functiondatabase'
+require 'tmpdir'
+require 'fileutils'
+
+class TesFunctionDatabase < Test::Unit::TestCase
+  def setup
+    prefix = 'db'
+    src = "test.rd"
+
+    @pwd = Dir.pwd
+    Dir.chdir(@tmpdir = Dir.mktmpdir)
+    File.open(src, 'w') do |file|
+      file.puts <<'HERE'
+--- VALUE func1()
+
+some text
+
+--- VALUE func2()
+
+some text
+HERE
+    end
+    @db = BitClust::FunctionDatabase.new(prefix)
+    @db.transaction {
+      @db.update_by_file(src, src)
+    }
+  end
+
+  def teardown
+    Dir.chdir @pwd
+    FileUtils.rm_r(@tmpdir, :force => true)
+  end
+
+  def test_search_functions__function
+    result = @db.search_functions('func1')
+    assert_not_nil result.first
+    assert_equal 1, result.size
+    assert_equal 'func1', result.first.name
+  end
+
+  def test_search_functions__functions
+    result = @db.search_functions('func')
+    assert_not_nil result.first
+    assert_equal 2, result.size
+    assert_equal %w[func1 func2], result.map(&:name)
+  end
+
+  def test_search_functions__nonexistent
+    assert_raise(BitClust::FunctionNotFound) do
+      @db.search_functions('nonexistent')
+    end
+  end
+end

data/vendor/bundle/ruby/1.9.1/gems/bitclust-core-0.5.1/test/test_libraryentry.rb

@@ -0,0 +1,39 @@
+require 'bitclust'
+require 'test/unit'
+require 'bitclust/libraryentry'
+
+class TestLibraryEntry < Test::Unit::TestCase
+  include BitClust
+
+  def setup
+    s = <<DOC
+require hoge/bar
+require hoge/baz
+require hoge/bar
+
+= class Hoge
+== Class Methods
+--- hoge
+= class Bar < Hoge
+== Class Methods
+--- bar
+= class Err < Exception
+= class Err2 < Err
+alias Err2Alias
+DOC
+    @lib_entry, @db = BitClust::RRDParser.parse(s, 'hoge')
+    @sublibrary = LibraryEntry.new(@db, 'testsub')
+  end
+
+  def test_sublibrary
+    @lib_entry.sublibrary(@sublibrary)
+    assert_equal(['testsub'], @lib_entry.sublibraries.map(&:name))
+    @lib_entry.sublibrary(@sublibrary)
+    assert_equal(['testsub'], @lib_entry.sublibraries.map(&:name))
+  end
+
+  def test_error_classes
+    assert_equal(["Err", "Err2", "Err2Alias"],
+                 @lib_entry.error_classes.map(&:name).sort)
+  end
+end

data/vendor/bundle/ruby/1.9.1/gems/bitclust-core-0.5.1/test/test_methoddatabase.rb

@@ -0,0 +1,81 @@
+require 'test/unit'
+require 'bitclust'
+require 'bitclust/methoddatabase'
+
+class TestMethodDatabase < Test::Unit::TestCase
+  def setup
+    @prefix = 'db'
+    @root = 'src'
+    setup_files
+    @db = BitClust::MethodDatabase.new(@prefix)
+    # init database
+    @db.init
+    @db.transaction {
+      [
+       %w[version 1.9.1],
+       %w[encoding utf-8]
+      ].each do |k,v|
+        @db.propset(k, v)
+      end
+    }
+    # update database
+    @db.transaction {
+      @db.update_by_stdlibtree(@root)
+    }
+  end
+
+  def teardown
+    FileUtils.rm_r([@prefix, @root], :force => true)
+  end
+
+  def test_search_methods__method
+    result = @db.search_methods(BitClust::MethodNamePattern.new(nil, nil, 'at_exit'))
+    assert_not_nil result.records.first.entry
+    assert_equal 1, result.records.size
+    assert_equal 'at_exit', result.records.first.entry.name
+  end
+
+  def test_search_methods__methods
+    result = @db.search_methods(BitClust::MethodNamePattern.new(nil, nil, 'foo'))
+    assert_not_nil result.records.first.entry
+    assert_equal 2, result.records.size
+    assert_equal %w[Foo Bar], result.records.map(&:entry).map(&:klass).map(&:name)
+    assert_equal 'foo', result.records.first.entry.name
+  end
+
+  def test_search_methods__constant
+    result = @db.search_methods(BitClust::MethodNamePattern.new(nil, nil, 'AAA'))
+    assert_not_nil result.records.first.entry
+    assert_equal 1, result.records.size
+    assert_equal 'AAA', result.records.first.entry.name
+  end
+
+  private
+  def setup_files
+    FileUtils.mkdir_p("#{@root}/_builtin")
+    File.open("#{@root}/LIBRARIES", 'w+') do |file|
+      file.puts '_builtin'
+    end
+    File.open("#{@root}/_builtin.rd", 'w+') do |file|
+      file.puts <<'HERE'
+description
+
+= class Foo < Object
+desctiption
+== Instance Methods
+--- foo
+== Constants
+--- AAA
+= class Bar < Object
+== Instance Methods
+--- foo
+= module Kernel
+description
+== Module Functions
+--- at_exit{ ... } -> Proc
+aaa
+
+HERE
+    end
+  end
+end

data/vendor/bundle/ruby/1.9.1/gems/bitclust-core-0.5.1/test/test_methodsignature.rb

@@ -0,0 +1,14 @@
+require 'test/unit'
+require 'bitclust/methodsignature'
+
+class TestMethodSignature < Test::Unit::TestCase
+
+  def test_friendlyname
+    [
+      ["$_ -> String | nil", "--- $_ -> String | nil"],
+      ["`command` -> String", "--- `(command) -> String"],
+    ].each do |friendly_string, method_signature|
+      assert_equal friendly_string, BitClust::MethodSignature.parse(method_signature).friendly_string
+    end
+  end
+end

data/vendor/bundle/ruby/1.9.1/gems/bitclust-core-0.5.1/test/test_nameutils.rb

@@ -0,0 +1,324 @@
+require 'test/unit'
+require 'bitclust/nameutils'
+
+class TestNameUtils < Test::Unit::TestCase
+
+  include BitClust::NameUtils
+
+  def test_libname?
+    assert_equal true, libname?("_builtin")
+    assert_equal true, libname?("fileutils")
+    assert_equal true, libname?("socket")
+    assert_equal true, libname?("open-uri")
+    assert_equal true, libname?("net/http")
+    assert_equal true, libname?("racc/cparse")
+    assert_equal true, libname?("test/unit/testcase")
+    assert_equal false, libname?("")
+    assert_equal false, libname?("fileutils ")
+    assert_equal false, libname?(" fileutils")
+    assert_equal false, libname?("file utils")
+    assert_equal false, libname?("fileutils\n")
+    assert_equal false, libname?("fileutils\t")
+    assert_equal false, libname?("fileutils.rb")
+    assert_equal false, libname?("English.rb")
+    assert_equal false, libname?("socket.so")
+    assert_equal false, libname?("net/http.rb")
+    assert_equal false, libname?("racc/cparse.so")
+  end
+
+  def test_libname2id
+    assert_equal "_builtin", libname2id("_builtin")
+    assert_equal "fileutils", libname2id("fileutils")
+    assert_equal "socket", libname2id("socket")
+    assert_equal "English", libname2id("English")
+    assert_equal "open=2duri", libname2id("open-uri")
+    assert_equal "net.http", libname2id("net/http")
+    assert_equal "racc.cparse", libname2id("racc/cparse")
+    assert_equal "test.unit.testcase", libname2id("test/unit/testcase")
+  end
+
+  def test_libid2name
+    assert_equal "_builtin", libid2name("_builtin")
+    assert_equal "fileutils", libid2name("fileutils")
+    assert_equal "socket", libid2name("socket")
+    assert_equal "English", libid2name("English")
+    assert_equal "open-uri", libid2name("open=2duri")
+    assert_equal "net/http", libid2name("net.http")
+    assert_equal "racc/cparse", libid2name("racc.cparse")
+    assert_equal "test/unit/testcase", libid2name("test.unit.testcase")
+  end
+
+  def test_classname?
+    assert_equal true, classname?("fatal")
+    assert_equal true, classname?("Array")
+    assert_equal true, classname?("String")
+    assert_equal true, classname?("Net::HTTP")
+    assert_equal true, classname?("Test::Unit::TestCase")
+    assert_equal false, classname?("")
+    assert_equal false, classname?("Array ")
+    assert_equal false, classname?(" Array")
+    assert_equal false, classname?("Test Case")
+    assert_equal false, classname?("TestCase\n")
+    assert_equal false, classname?("\tTestCase")
+    assert_equal false, classname?("string")
+    assert_equal false, classname?("stringScanner")
+    assert_equal false, classname?("net/http")
+    assert_equal false, classname?("net.http")
+    assert_equal false, classname?("open-uri")
+  end
+
+  def test_classname2id
+    assert_equal "Array", classname2id("Array")
+    assert_equal "String", classname2id("String")
+    assert_equal "Net=HTTP", classname2id("Net::HTTP")
+    assert_equal "Test=Unit=TestCase", classname2id("Test::Unit::TestCase")
+  end
+
+  def test_classid2name
+    assert_equal "Array", classid2name("Array")
+    assert_equal "String", classid2name("String")
+    assert_equal "Net::HTTP", classid2name("Net=HTTP")
+    assert_equal "Test::Unit::TestCase", classid2name("Test=Unit=TestCase")
+  end
+
+  def test_method_spec?
+    assert_equal true, method_spec?("String#index")
+    assert_equal true, method_spec?("CGI#accept")
+    assert_equal true, method_spec?("Net::HTTP#ca_path")
+    assert_equal true, method_spec?("FileUtils.#cp")
+  end
+
+  def test_methodid2spec
+    assert_equal "String#index", methodid2specstring("String/i.index._builtin")
+    assert_equal "CGI#accept", methodid2specstring("CGI/i.accept.cgi")
+    assert_equal "Net::HTTP#ca_path", methodid2specstring("Net=HTTP/i.ca_path.net.http")
+    assert_equal "FileUtils.#cp", methodid2specstring("FileUtils/m.cp.fileutils")
+  end
+
+  def test_methodid2libid
+    assert_equal "_builtin",   methodid2libid("String/i.index._builtin")
+    assert_equal "cgi",        methodid2libid("CGI/i.accept.cgi")
+    assert_equal "net.http",   methodid2libid("Net=HTTP/i.ca_path.net.http")
+    assert_equal "open=2duri", methodid2libid("OpenURI/m.open.open=2duri")
+  end
+
+  def test_methodid2classid
+    assert_equal "String", methodid2classid("String/i.index._builtin")
+    assert_equal "CGI", methodid2classid("CGI/i.accept.cgi")
+    assert_equal "Net=HTTP", methodid2classid("Net=HTTP/i.ca_path.net.http")
+  end
+
+  def test_methodid2typename
+    assert_equal :instance_method, methodid2typename("String/i.index._builtin")
+    assert_equal :instance_method, methodid2typename("CGI/i.accept.cgi")
+    assert_equal :instance_method, methodid2typename("Net=HTTP/i.ca_path.net.http")
+    assert_equal :singleton_method, methodid2typename("String/s.new._builtin")
+  end
+
+  def test_methodid2mname
+    assert_equal "index", methodid2mname("String/i.index._builtin")
+    assert_equal "accept", methodid2mname("CGI/i.accept.cgi")
+    assert_equal "ca_path", methodid2mname("Net=HTTP/i.ca_path.net.http")
+  end
+
+  def test_methodname?
+    assert_equal true, methodname?("index")
+    assert_equal true, methodname?("accept")
+    assert_equal true, methodname?("get")
+    assert_equal true, methodname?("Array")
+    assert_equal true, methodname?("getIndex")
+    assert_equal true, methodname?("PROXY")
+    assert_equal true, methodname?("HTTP_PROXY")
+    assert_equal true, methodname?("gsub!")
+    assert_equal true, methodname?("empty?")
+    assert_equal true, methodname?("instance_eval")
+    assert_equal true, methodname?("__send")
+    assert_equal true, methodname?("__send__")
+    assert_equal true, methodname?("__send!")
+    assert_equal true, methodname?("+")
+    assert_equal true, methodname?("-")
+    assert_equal true, methodname?("*")
+    assert_equal true, methodname?("/")
+    assert_equal true, methodname?("&")
+    assert_equal true, methodname?("|")
+    assert_equal true, methodname?("^")
+    assert_equal true, methodname?("`")
+    assert_equal true, methodname?(">>")
+    assert_equal true, methodname?("<<")
+    assert_equal true, methodname?("+@")
+    assert_equal true, methodname?("-@")
+    assert_equal true, methodname?("!")
+    assert_equal true, methodname?("!@")
+    assert_equal true, methodname?("~")
+    assert_equal true, methodname?("**")
+    assert_equal true, methodname?("<")
+    assert_equal true, methodname?(">")
+    assert_equal true, methodname?("<=")
+    assert_equal true, methodname?(">=")
+    assert_equal true, methodname?("==")
+    assert_equal true, methodname?("===")
+    assert_equal true, methodname?("=~")
+    assert_equal true, methodname?("[]")
+    assert_equal true, methodname?("[]=")
+
+    assert_equal false, methodname?("")
+    assert_equal true,  methodname?("!=")
+    assert_equal false, methodname?("!~")
+    assert_equal false, methodname?("&&")
+    assert_equal false, methodname?("||")
+    assert_equal false, methodname?("++")
+    assert_equal false, methodname?(">>>")
+    assert_equal false, methodname?("***")
+    assert_equal false, methodname?("====")
+    assert_equal false, methodname?("#accept")
+    assert_equal false, methodname?(".new")
+    assert_equal false, methodname?(".#cp")
+    assert_equal false, methodname?("$gvar")
+    assert_equal false, methodname?("CGI#accept")
+    assert_equal false, methodname?("String.new")
+    assert_equal false, methodname?("Net::HTTP.get")
+    assert_equal false, methodname?("Net::HTTP.new")
+  end
+
+  def test_build_method_id
+    assert_equal "String/i.index._builtin",
+        build_method_id("_builtin", "String", :instance_method, "index")
+  end
+
+  # library private
+  #def test_split_method_id
+  #  assert_equal ["String", "i", "index", "_builtin"],
+  #               split_method_id("String/i.index._builtin")
+  #end
+
+  def test_typename?
+    assert_equal true, typename?(:instance_method)
+    assert_equal true, typename?(:singleton_method)
+    assert_equal true, typename?(:module_function)
+    assert_equal true, typename?(:constant)
+    assert_equal true, typename?(:special_variable)
+    assert_equal false, typename?(:instance_eval)
+    assert_equal false, typename?(:instance)
+    assert_equal false, typename?(:singleton)
+    assert_equal false, typename?("i")
+    assert_equal false, typename?("s")
+    assert_equal false, typename?(:i)
+    assert_equal false, typename?(:s)
+  end
+
+  def test_typemark?
+    assert_equal true, typemark?('.')
+    assert_equal true, typemark?('#')
+    assert_equal true, typemark?('.#')
+    assert_equal true, typemark?('$')
+    assert_equal true, typemark?('::')
+    #marks = (0..255).map {|a| (0..255).map {|b| a.chr + b.chr } }.flatten
+    marks = (0..127).map {|a| (0..127).map {|b| a.chr + b.chr } }.flatten
+    (marks - %w( . # .# $ :: )).each do |m|
+      assert_equal false, typemark?(m)
+    end
+  end
+
+  def test_typechar?
+    typechars = %w( i s m c v )
+    typechars.each do |c|
+      assert_equal true, typechar?(c)
+    end
+    ((0..255).map {|b| b.chr } - typechars).each do |c|
+      assert_equal false, typechar?(c)
+    end
+  end
+
+  def test_typename2char
+    assert_equal 's', typename2char(:singleton_method)
+    assert_equal 'i', typename2char(:instance_method)
+    assert_equal 'm', typename2char(:module_function)
+    assert_equal 'c', typename2char(:constant)
+    assert_equal 'v', typename2char(:special_variable)
+  end
+
+  def test_typechar2name
+    assert_equal :singleton_method, typechar2name('s')
+    assert_equal :instance_method,  typechar2name('i')
+    assert_equal :module_function,  typechar2name('m')
+    assert_equal :constant,         typechar2name('c')
+    assert_equal :special_variable, typechar2name('v')
+  end
+
+  def test_typemark2char
+    assert_equal 's',  typemark2char('.')
+    assert_equal 'i',  typemark2char('#')
+    assert_equal 'm',  typemark2char('.#')
+    assert_equal 'c',  typemark2char('::')
+    assert_equal 'v',  typemark2char('$')
+  end
+
+  def test_typechar2mark
+    assert_equal '.',   typechar2mark('s')
+    assert_equal '#',   typechar2mark('i')
+    assert_equal '.#',  typechar2mark('m')
+    assert_equal '::',  typechar2mark('c')
+    assert_equal '$',   typechar2mark('v')
+  end
+
+  def test_encodename_url
+    assert_equal "Array",      encodename_url("Array")
+    assert_equal "String",     encodename_url("String")
+    assert_equal "index",      encodename_url("index")
+    assert_equal "=2a",        encodename_url("*")
+    assert_equal "=2a=2a",     encodename_url("**")
+    assert_equal "open=2duri", encodename_url("open-uri")
+    assert_equal "net=2ehttp", encodename_url("net.http")
+  end
+
+  def test_decodename_url
+    assert_equal "Array",      decodename_url("Array")
+    assert_equal "String",     decodename_url("String")
+    assert_equal "index",      decodename_url("index")
+    assert_equal "*",          decodename_url("=2a")
+    assert_equal "**",         decodename_url("=2a=2a")
+    assert_equal "open-uri",   decodename_url("open=2duri")
+    assert_equal "net.http",   decodename_url("net=2ehttp")
+  end
+
+  def test_encodeid
+    assert_equal "-array",        encodeid("Array")
+    assert_equal "-string",       encodeid("String")
+    assert_equal "-c-g-i",        encodeid("CGI")
+    assert_equal "=2a",           encodeid("=2a")
+    assert_equal "=2a=2a",        encodeid("=2a=2a")
+    assert_equal "open=2duri",    encodeid("open=2duri")
+    assert_equal "-net=-h-t-t-p", encodeid("Net=HTTP")
+  end
+
+  def test_decodeid
+    assert_equal "Array",      decodeid("-array")
+    assert_equal "String",     decodeid("-string")
+    assert_equal "CGI",        decodeid("-c-g-i")
+    assert_equal "=2a",        decodeid("=2a")
+    assert_equal "=2a=2a",     decodeid("=2a=2a")
+    assert_equal "open=2duri", decodeid("open=2duri")
+    assert_equal "Net=HTTP",   decodeid("-net=-h-t-t-p")
+  end
+
+  def test_encodename_fs
+    assert_equal "-array",     encodename_fs("Array")
+    assert_equal "-string",    encodename_fs("String")
+    assert_equal "index",      encodename_fs("index")
+    assert_equal "=2a",        encodename_fs("*")
+    assert_equal "=2a=2a",     encodename_fs("**")
+    assert_equal "open=2duri", encodename_fs("open-uri")
+    assert_equal "net=2ehttp", encodename_fs("net.http")
+  end
+
+  def test_decodename_fs
+    assert_equal "Array",      decodename_fs("-array")
+    assert_equal "String",     decodename_fs("-string")
+    assert_equal "index",      decodename_fs("index")
+    assert_equal "*",          decodename_fs("=2a")
+    assert_equal "**",         decodename_fs("=2a=2a")
+    assert_equal "open-uri",   decodename_fs("open=2duri")
+    assert_equal "net.http",   decodename_fs("net=2ehttp")
+  end
+
+end