natto 0.9.3 → 0.9.4

data/lib/natto/binding.rb

@@ -1,5 +1,4 @@
 # coding: utf-8
-
 module Natto
 
   # Module <tt>Binding</tt> encapsulates methods and behavior 
@@ -31,18 +30,25 @@ module Natto
     # @raise [LoadError] if MECAB_PATH environment variable is not set in Windows
     # <br/>
     # e.g., for bash on UNIX/Linux
+    #
     #     export MECAB_PATH=/usr/local/lib/libmecab.so
+    #
     # e.g., on Windows
+    #
     #     set MECAB_PATH=C:\Program Files\MeCab\bin\libmecab.dll
+    #
     # e.g., for Cygwin
+    #
     #     export MECAB_PATH=cygmecab-1
+    #
     # e.g., from within a Ruby program
+    #
     #     ENV['MECAB_PATH']=/usr/local/lib/libmecab.so
     def self.find_library
       host_os = RbConfig::CONFIG['host_os']
 
       if host_os =~ /mswin|mingw/i
-        raise LoadError, "Please set #{MECAB_PATH} to full path to libmecab.dll"
+        raise LoadError, "Please set #{MECAB_PATH} to the full path to libmecab.dll"
       elsif host_os =~ /cygwin/i
         'cygmecab-1'
       else
@@ -56,18 +62,15 @@ module Natto
     attach_function :mecab_version, [], :string
     attach_function :mecab_strerror, [:pointer],:string
     attach_function :mecab_destroy, [:pointer], :void
-  
     attach_function :mecab_set_theta, [:pointer, :float], :void
     attach_function :mecab_set_lattice_level, [:pointer, :int], :void 
     attach_function :mecab_set_all_morphs, [:pointer, :int], :void
-    
     attach_function :mecab_sparse_tostr, [:pointer, :string], :string
     attach_function :mecab_sparse_tonode, [:pointer, :string], :pointer
-    
     attach_function :mecab_nbest_init, [:pointer, :string], :int
     attach_function :mecab_nbest_sparse_tostr, [:pointer, :int, :string], :string
     attach_function :mecab_nbest_next_tonode, [:pointer], :pointer
-    
+    attach_function :mecab_format_node, [:pointer, :pointer], :string
     attach_function :mecab_dictionary_info, [:pointer], :pointer
 
     # @private
@@ -80,48 +83,56 @@ module Natto
         Natto::Binding.mecab_version
       end
 
-      def mecab_strerror(ptr)
-        Natto::Binding.mecab_strerror(ptr)
+      def mecab_strerror(m_ptr)
+        Natto::Binding.mecab_strerror(m_ptr)
       end
 
-      def mecab_destroy(ptr)
-        Natto::Binding.mecab_destroy(ptr)
+      def mecab_destroy(m_ptr)
+        Natto::Binding.mecab_destroy(m_ptr)
       end
 
-      def mecab_set_theta(ptr, t)
-        Natto::Binding.mecab_set_theta(ptr, t)
+      def mecab_set_theta(m_ptr, t)
+        Natto::Binding.mecab_set_theta(m_ptr, t)
       end
 
-      def mecab_set_lattice_level(ptr, ll)
-        Natto::Binding.mecab_set_lattice_level(ptr, ll)
+      def mecab_set_lattice_level(m_ptr, ll)
+        Natto::Binding.mecab_set_lattice_level(m_ptr, ll)
       end
-
-      def mecab_set_all_morphs(ptr, am)
-        Natto::Binding.mecab_set_all_morphs(ptr, am)
+      
+      def mecab_set_all_morphs(m_ptr, am)
+        Natto::Binding.mecab_set_all_morphs(m_ptr, am)
       end
 
-      def mecab_sparse_tostr(ptr, str)
-        Natto::Binding.mecab_sparse_tostr(ptr, str)
+      def mecab_sparse_tostr(m_ptr, str)
+        Natto::Binding.mecab_sparse_tostr(m_ptr, str)
       end
       
-      def mecab_sparse_tonode(ptr, str)
-        Natto::Binding.mecab_sparse_tonode(ptr, str)
+      def mecab_sparse_tonode(m_ptr, str)
+        Natto::Binding.mecab_sparse_tonode(m_ptr, str)
+      end
+
+      def mecab_nbest_next_tonode(m_ptr)
+        Natto::Binding.mecab_nbest_next_tonode(m_ptr)
       end
 
-      def mecab_nbest_next_tonode(ptr)
-        Natto::Binding.mecab_nbest_next_tonode(ptr)
+      def mecab_nbest_init(m_ptr, str)
+        Natto::Binding.mecab_nbest_init(m_ptr, str)
       end
 
-      def mecab_nbest_init(ptr, str)
-        Natto::Binding.mecab_nbest_init(ptr, str)
+      def mecab_nbest_sparse_tostr(m_ptr, n, str)
+        Natto::Binding.mecab_nbest_sparse_tostr(m_ptr, n, str)
       end
 
-      def mecab_nbest_sparse_tostr(ptr, n, str)
-        Natto::Binding.mecab_nbest_sparse_tostr(ptr, n, str)
+      def mecab_nbest_next_tonode(m_ptr)
+        Natto::Binding.mecab_nbest_next_tonode(m_ptr)
       end
 
-      def mecab_dictionary_info(ptr)
-        Natto::Binding.mecab_dictionary_info(ptr)
+      def mecab_format_node(m_ptr, n_ptr)
+        Natto::Binding.mecab_format_node(m_ptr, n_ptr)
+      end
+      
+      def mecab_dictionary_info(m_ptr)
+        Natto::Binding.mecab_dictionary_info(m_ptr)
       end
     end
   end

data/lib/natto/utils.rb

@@ -0,0 +1,16 @@
+# coding: utf-8
+module Natto
+  module Utils
+    # @private
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def force_enc(str)
+        str.force_encoding(Encoding.default_external) if str.respond_to?(:encoding) && str.encoding!=Encoding.default_external
+        str
+      end
+    end
+  end
+end

data/lib/natto/version.rb

@@ -1,10 +1,10 @@
 # coding: utf-8
 
 # <tt>Natto</tt> is the namespace for objects that provide
-# a binding to the <tt>mecab</tt> parser and related resources.
+# a binding to the <tt>mecab</tt> tagger and related resources.
 #
 # <tt>Natto::MeCab</tt> is a wrapper class for the <tt>mecab</tt> 
-# parser.
+# tagger.
 #
 # <tt>Natto::MeCabStruct</tt> is a base class for a <tt>mecab</tt>
 # struct.
@@ -23,5 +23,5 @@
 # which are made available via <tt>FFI</tt> bindings to <tt>mecab</tt>.
 module Natto
   # Version string for this Rubygem.
-  VERSION = "0.9.3"
+  VERSION = "0.9.4"
 end

metadata

@@ -1,95 +1,74 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: natto
-version: !ruby/object:Gem::Version 
-  hash: 61
+version: !ruby/object:Gem::Version
+  version: 0.9.4
   prerelease: 
-  segments: 
-  - 0
-  - 9
-  - 3
-  version: 0.9.3
 platform: ruby
-authors: 
+authors:
 - Brooke M. Fujita
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2012-02-13 00:00:00 Z
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2012-02-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: ffi
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  requirement: &341055920 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 1
-        segments: 
-        - 0
-        - 6
-        - 3
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
         version: 0.6.3
   type: :runtime
-  version_requirements: *id001
-description: "natto is a gem bridging Ruby and MeCab using FFI (foreign function interface). No compilation is necessary, and natto will run on CRuby (mri/yarv) and JRuby (jvm) equally well, on any OS.\n\
-  ruby \xE3\x81\xA7 mecab \xE3\x82\x92\xE8\x87\xAA\xE7\x94\xB1\xE3\x81\xAB\xE5\x88\xA9\xE7\x94\xA8\xE3\x81\xA7\xE3\x81\x8D\xE3\x82\x8B natto \xE3\x82\x92\xE3\x81\x9C\xE3\x81\xB2\xE8\xA9\xA6\xE3\x81\x97\xE3\x81\xA6\xE3\x81\x8F\xE3\x81\xA0\xE3\x81\x95\xE3\x81\x84\xE3\x80\x82\n"
+  prerelease: false
+  version_requirements: *341055920
+description: ! 'natto is a gem bridging Ruby and MeCab using FFI (foreign function
+  interface). No compilation is necessary, and natto will run on CRuby (mri/yarv)
+  and JRuby (jvm) equally well, on any OS.
+
+  ruby で mecab を自由に利用できる natto をぜひ試してください。
+
+'
 email: buruzaemon@gmail.com
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
 - lib/natto.rb
 - lib/natto/binding.rb
 - lib/natto/version.rb
-- test/test_natto.rb
-- test/natto/tc_binding.rb
-- test/natto/tc_dictionaryinfo.rb
-- test/natto/tc_mecab.rb
-- test/natto/tc_mecabnode.rb
+- lib/natto/utils.rb
 - README.md
 - LICENSE
 - CHANGELOG
 - .yardopts
 homepage: https://bitbucket.org/buruzaemon/natto/overview
-licenses: 
+licenses:
 - BSD
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 57
-      segments: 
-      - 1
-      - 8
-      - 7
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
       version: 1.8.7
-required_rubygems_version: !ruby/object:Gem::Requirement 
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
-requirements: 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements:
 - MeCab, 0.993 or greater
 - FFI, 0.6.3 or greater
 rubyforge_project: 
-rubygems_version: 1.8.10
+rubygems_version: 1.8.17
 signing_key: 
 specification_version: 3
-summary: natto combines the Ruby programming language with MeCab, the part-of-speech and morphological analyzer for the Japanese language.
-test_files: 
-- test/test_natto.rb
+summary: natto combines the Ruby programming language with MeCab, the part-of-speech
+  and morphological analyzer for the Japanese language.
+test_files: []
+has_rdoc: 

data/test/natto/tc_binding.rb

@@ -1,41 +0,0 @@
-# coding: utf-8
-
-# TestNatto encapsulates tests for the basic
-# behavior of the Natto::Binding module.
-class TestNattoBinding < Test::Unit::TestCase
-  def setup
-    @klass = Class.new do
-      include Natto::Binding
-    end
-  end
-
-  def teardown
-    @klass = nil
-  end
-
-  # Tests the mecab_version function.
-  def test_mecab_version
-    mv = `mecab -v`.split.last
-    assert_equal(mv, @klass.mecab_version)
-  end
-
-  # Tests for the inclusion of mecab methods made available
-  # to any classes including the Natto::Binding module.
-  def test_functions_included
-    [  :mecab_new2, 
-       :mecab_version, 
-       :mecab_strerror,
-       :mecab_destroy, 
-       :mecab_set_theta,
-       :mecab_set_lattice_level,
-       :mecab_set_all_morphs,
-       :mecab_sparse_tostr, 
-       :mecab_nbest_sparse_tostr, 
-       :mecab_nbest_init,
-       :mecab_nbest_sparse_tostr,
-       :mecab_nbest_next_tonode,
-       :mecab_dictionary_info ].each do |f|
-       assert(@klass.respond_to? f)
-    end
-  end
-end

data/test/natto/tc_dictionaryinfo.rb

@@ -1,65 +0,0 @@
-# coding: utf-8
-
-# TestDictionaryInfo encapsulates tests for the basic
-# behavior of Natto::DictionaryInfo
-class TestDictionaryInfo < Test::Unit::TestCase
-  def setup
-    m = Natto::MeCab.new
-    @dicts = m.dicts
-
-    out = `mecab -D`.lines.to_a
-    out.each do |l|
-      tokens = l.split("\t")
-      @sysdic_filename = tokens[1].strip if tokens[0] =~ /filename:/i
-      @sysdic_charset = tokens[1].strip if tokens[0] =~ /charset:/i
-    end
-  end
-
-  def teardown
-    @dicts = nil
-  end
-
-  # Tests the dictionaries accessor method of Natto::MeCab.
-  # Assumes that:
-  # a) system dictionary is /usr/local/lib/mecab/dic/ipadic/sys.dic
-  # b) system dictionary encoding is utf-8
-  # c) only dealing w/ case of 1 dictionary being used
-  def test_dictionaries_accessor
-    assert @dicts.empty? == false
-    sysdic = @dicts.first
-    assert_equal(@sysdic_filename, sysdic[:filename])
-    assert_equal(@sysdic_charset, sysdic[:charset])
-    assert_equal(0x0, sysdic[:next].address)
-  end
-
-  # Tests the to_s method.
-  def test_to_s
-    #<Natto::DictionaryInfo:0x288879bc @filename=\"/usr/local/lib/mecab/dic/ipadic/sys.dic\", @charset=\"utf8\">
-    assert(@dicts.first.to_s.include?("filename=\"#{@sysdic_filename}\", charset=\"#{@sysdic_charset}\""))
-  end
-
-  # Tests the accessors of Natto::DictionaryInfo.
-  # Note: Object#type is deprecated in 1.9.n, but comes with a warning
-  #       in 1.8.n
-  def test_dictionary_info_member_accessors
-    sysdic = @dicts.first
-    members = [
-      :filename,
-      :charset,
-      :type,
-      :size,
-      :lsize,
-      :rsize,
-      :version,
-      :next 
-    ]
-    members.each do |nomme|
-      assert_not_nil(sysdic.send nomme ) 
-    end
-    
-    # NoMethodError will be raised for anything else!
-    assert_raise NoMethodError do
-      sysdic.send :unknown_attr
-    end
-  end
-end

data/test/natto/tc_mecab.rb

@@ -1,295 +0,0 @@
-# coding: utf-8
-require 'rbconfig'
-require 'nkf'
-
-# TestMeCab encapsulates tests for the basic
-# behavior of Natto::MeCab.
-class TestMeCab < Test::Unit::TestCase
-
-  host_os = RbConfig::CONFIG['host_os']
-  # we need to transfrom from UTF-8 ot SJIS if we are on Windows!
-  if host_os =~ /mswin|mingw/i
-    TEST_STR = NKF.nkf("-Ws", '試験ですよ、これが。')
-  else
-    TEST_STR = '試験ですよ、これが。'
-  end
-
-  def setup
-    @m = Natto::MeCab.new
-    @ver = `mecab -v`.strip.split.last
-  end
-
-  def teardown
-    @m = nil
-  end
-
-  def test_parse_mecab_options
-    [ '-r /some/file',
-      '-r/some/file',
-      '--rcfile=/some/file',
-      '--rcfile /some/file',
-      {:rcfile=>"/some/file"} ].each do |opts|
-      assert_equal({:rcfile => '/some/file'}, Natto::MeCab.parse_mecab_options(opts))
-    end
-
-    [ '-d /some/other/file',
-      '-d/some/other/file',
-      '--dicdir=/some/other/file',
-      '--dicdir /some/other/file',
-      {:dicdir=>"/some/other/file"} ].each do |opts|
-      assert_equal({:dicdir => '/some/other/file'}, Natto::MeCab.parse_mecab_options(opts))
-    end
-   
-    [ '-u /yet/another/file',
-      '-u/yet/another/file',
-      '--userdic=/yet/another/file',
-      '--userdic /yet/another/file',
-      {:userdic=>"/yet/another/file"} ].each do |opts|
-      assert_equal({:userdic => '/yet/another/file'}, Natto::MeCab.parse_mecab_options(opts))
-    end
-   
-    [ '-l 42',
-      '-l42',
-      '--lattice-level=42',
-      '--lattice-level 42',
-      {:lattice_level=>42}
-    ].each do |opts|
-      assert_equal({:lattice_level => 42}, Natto::MeCab.parse_mecab_options(opts))
-    end
-   
-    [ '-a',
-      '--all-morphs',
-      {:all_morphs=>true} ].each do |opts|
-      assert_equal({:all_morphs => true}, Natto::MeCab.parse_mecab_options(opts))
-    end
-   
-    [ '-O natto',
-      '-Onatto',
-      '--output-format-type=natto',
-      '--output-format-type natto',
-      {:output_format_type=>"natto"} ].each do |opts|
-      assert_equal({:output_format_type => 'natto'}, Natto::MeCab.parse_mecab_options(opts))
-    end
-   
-    [ '-N 42',
-      '-N42',
-      '--nbest=42',
-      '--nbest 42',
-      {:nbest=>42}
-    ].each do |opts|
-      assert_equal({:nbest => 42}, Natto::MeCab.parse_mecab_options(opts))
-    end
-    [ '--nbest=-1', '--nbest=0', '--nbest=513' ].each do |bad|
-      assert_raise Natto::MeCabError do
-        Natto::MeCab.parse_mecab_options(bad)
-      end
-    end
-   
-    [ '-F %m\t%f[7]\n',
-      '-F%m\t%f[7]\n',
-      '--node-format=%m\t%f[7]\n',
-      '--node-format %m\t%f[7]\n',
-      {:node_format=>'%m\t%f[7]\n'} ].each do |opts|
-      assert_equal({:node_format => '%m\t%f[7]\n'}, Natto::MeCab.parse_mecab_options(opts))
-    end
-
-    [ '-U %m\t%f[7]\n',
-      '-U%m\t%f[7]\n',
-      '--unk-format=%m\t%f[7]\n',
-      '--unk-format %m\t%f[7]\n',
-      {:unk_format=>'%m\t%f[7]\n'} ].each do |opts|
-      assert_equal({:unk_format => '%m\t%f[7]\n'}, Natto::MeCab.parse_mecab_options(opts))
-    end
-    
-    [ '-B %m\t%f[7]\n',
-      '-B%m\t%f[7]\n',
-      '--bos-format=%m\t%f[7]\n',
-      '--bos-format %m\t%f[7]\n',
-      {:bos_format=>'%m\t%f[7]\n'} ].each do |opts|
-      assert_equal({:bos_format => '%m\t%f[7]\n'}, Natto::MeCab.parse_mecab_options(opts))
-    end
-    
-    [ '-E %m\t%f[7]\n',
-      '-E%m\t%f[7]\n',
-      '--eos-format=%m\t%f[7]\n',
-      '--eos-format %m\t%f[7]\n',
-      {:eos_format=>'%m\t%f[7]\n'} ].each do |opts|
-      assert_equal({:eos_format => '%m\t%f[7]\n'}, Natto::MeCab.parse_mecab_options(opts))
-    end
-    
-    [ '-S %m\t%f[7]\n',
-      '-S%m\t%f[7]\n',
-      '--eon-format=%m\t%f[7]\n',
-      '--eon-format %m\t%f[7]\n',
-      {:eon_format=>'%m\t%f[7]\n'} ].each do |opts|
-      assert_equal({:eon_format => '%m\t%f[7]\n'}, Natto::MeCab.parse_mecab_options(opts))
-    end
-    
-    [ '-x %m\t%f[7]\n',
-      '-x%m\t%f[7]\n',
-      '--unk-feature=%m\t%f[7]\n',
-      '--unk-feature %m\t%f[7]\n',
-      {:unk_feature=>'%m\t%f[7]\n'} ].each do |opts|
-      assert_equal({:unk_feature => '%m\t%f[7]\n'}, Natto::MeCab.parse_mecab_options(opts))
-    end
-    
-    [ '-b 102400',
-      '-b102400',
-      '--input-buffer-size=102400',
-      '--input-buffer-size 102400',
-      {:input_buffer_size=>102400} ].each do |opts|
-      assert_equal({:input_buffer_size => 102400}, Natto::MeCab.parse_mecab_options(opts))
-    end
-    
-    [ '-C',
-      '--allocate-sentence',
-      {:allocate_sentence=>true} ].each do |opts|
-      assert_equal({:allocate_sentence => true}, Natto::MeCab.parse_mecab_options(opts))
-    end
-    
-    [ '-t 0.42',
-      '-t0.42',
-      '--theta=0.42',
-      '--theta 0.42',
-      {:theta=>0.42} ].each do |opts|
-      assert_equal({:theta => 0.42}, Natto::MeCab.parse_mecab_options(opts))
-    end
-    
-    [ '-c 42',
-      '-c42',
-      '--cost-factor=42',
-      '--cost-factor 42',
-      {:cost_factor=>42} ].each do |opts|
-      assert_equal({:cost_factor => 42}, Natto::MeCab.parse_mecab_options(opts))
-    end
-
-    assert_equal({}, Natto::MeCab.parse_mecab_options)
-    assert_equal({}, Natto::MeCab.parse_mecab_options(:unknown=>"ignore"))
-  end
-
-  def test_build_options_str
-    assert_equal('--rcfile=/some/file', Natto::MeCab.build_options_str(:rcfile=>"/some/file"))
-    assert_equal('--dicdir=/some/other/file', Natto::MeCab.build_options_str(:dicdir=>"/some/other/file"))
-    assert_equal('--userdic=/yet/another/file', Natto::MeCab.build_options_str(:userdic=>"/yet/another/file"))
-    assert_equal('--lattice-level=42', Natto::MeCab.build_options_str(:lattice_level=>42))
-    assert_equal('--all-morphs', Natto::MeCab.build_options_str(:all_morphs=>true))
-    assert_equal('--output-format-type=natto', Natto::MeCab.build_options_str(:output_format_type=>"natto"))
-    assert_equal('--node-format=%m\t%f[7]\n', Natto::MeCab.build_options_str(:node_format=>'%m\t%f[7]\n'))
-    assert_equal('--unk-format=%m\t%f[7]\n', Natto::MeCab.build_options_str(:unk_format=>'%m\t%f[7]\n'))
-    assert_equal('--bos-format=%m\t%f[7]\n', Natto::MeCab.build_options_str(:bos_format=>'%m\t%f[7]\n'))
-    assert_equal('--eos-format=%m\t%f[7]\n', Natto::MeCab.build_options_str(:eos_format=>'%m\t%f[7]\n'))
-    assert_equal('--eon-format=%m\t%f[7]\n', Natto::MeCab.build_options_str(:eon_format=>'%m\t%f[7]\n'))
-    assert_equal('--unk-feature=%m\t%f[7]\n', Natto::MeCab.build_options_str(:unk_feature=>'%m\t%f[7]\n'))
-    assert_equal('--input-buffer-size=102400',Natto::MeCab.build_options_str(:input_buffer_size=>102400))
-    assert_equal('--allocate-sentence', Natto::MeCab.build_options_str(:allocate_sentence=>true))
-    assert_equal('--nbest=42', Natto::MeCab.build_options_str(:nbest=>42))
-    assert_equal('--theta=0.42', Natto::MeCab.build_options_str(:theta=>0.42))
-    assert_equal('--cost-factor=42', Natto::MeCab.build_options_str(:cost_factor=>42))
-  end
-
-  def test_construction
-    m = nil
-    assert_nothing_raised do
-      m = Natto::MeCab.new
-    end
-    assert_equal({}, m.options)
-
-    opts = {:output_format_type=>'chasen'}
-    assert_nothing_raised do
-      m = Natto::MeCab.new(opts)
-    end
-    assert_equal(opts, m.options)
-    assert_nothing_raised do
-      m = Natto::MeCab.new("-O chasen")
-    end
-    assert_equal(opts, m.options)
-    assert_nothing_raised do
-      m = Natto::MeCab.new("--output-format-type=chasen")
-    end
-    assert_equal(opts, m.options)
-    
-    opts = {:all_morphs=>true, :allocate_sentence=>true}
-    assert_nothing_raised do
-      m = Natto::MeCab.new(opts)
-    end
-    assert_equal(opts, m.options)
-    assert_nothing_raised do
-      m = Natto::MeCab.new('-a -C')
-    end
-    assert_equal(opts, m.options)
-    assert_nothing_raised do
-      m = Natto::MeCab.new('--all-morphs --allocate-sentence')
-    end
-    assert_equal(opts, m.options)
-    
-    opts = {:lattice_level=>999}
-    assert_nothing_raised do
-      m = Natto::MeCab.new(opts)
-    end
-    assert_equal(opts, m.options)
-    assert_nothing_raised do
-      m = Natto::MeCab.new('-l 999')
-    end
-    assert_equal(opts, m.options)
-    assert_nothing_raised do
-      m = Natto::MeCab.new('--lattice-level=999')
-    end
-    assert_equal(opts, m.options)
-  end
-
-  def test_initialize_with_errors
-    assert_raise Natto::MeCabError do
-      Natto::MeCab.new(:output_format_type=>'not_defined_anywhere')
-    end
-    
-    assert_raise Natto::MeCabError do
-      Natto::MeCab.new(:rcfile=>'/rcfile/does/not/exist')
-    end
-
-    assert_raise Natto::MeCabError do
-      Natto::MeCab.new(:dicdir=>'/dicdir/does/not/exist')
-    end
-
-    assert_raise Natto::MeCabError do
-      Natto::MeCab.new(:userdic=>'/userdic/does/not/exist')
-    end
-  end
-
-  def test_version_accessor
-    assert_equal(@ver, @m.version)
-  end
-
-  def test_all_morphs
-    m = Natto::MeCab.new(:all_morphs=>true)
-    expected = `echo #{TEST_STR} | mecab --all-morphs`.lines.to_a
-    expected.delete_if {|e| e =~ /^(EOS|BOS)/ }
-    
-    actual   = m.parse(TEST_STR).lines.to_a
-    actual.delete_if {|e| e =~ /^(EOS|BOS|\t)/ }
-    
-    assert_equal(expected, actual)
-  end
-
-  def test_parse_tostr_default
-    expected = `echo #{TEST_STR} | mecab`.lines.to_a
-    expected.delete_if {|e| e =~ /^(EOS|BOS|\t)/ }
-
-    actual = @m.parse(TEST_STR).lines.to_a
-    actual.delete_if {|e| e =~ /^(EOS|BOS|\t)/ }
-
-    assert_equal(expected, actual)
-  end
-
-  def test_parse_tonode_default
-    expected = `echo #{TEST_STR} | mecab`.lines.to_a
-    expected.delete_if {|e| e =~ /^(EOS|BOS|\t)/ }
-
-    actual = []
-    @m.parse(TEST_STR) do |node|
-      actual << "#{node.surface}\t#{node.feature}\n"
-    end
-    actual.delete_if {|e| e =~ /^(EOS|BOS|\t)/ }
-
-    assert_equal(expected, actual)
-  end
-end