writeexcel 0.3.5 → 0.4.0

data/test/test_biff.rb

@@ -1,4 +1,6 @@
+# -*- coding: utf-8 -*-
 require 'helper'
+require 'stringio'
 
 class TC_BIFFWriter < Test::Unit::TestCase
 
@@ -6,11 +8,12 @@ class TC_BIFFWriter < Test::Unit::TestCase
   PERL_OUTDIR = File.join(TEST_DIR, 'perl_output')
 
   def setup
-    t = Time.now.strftime("%Y%m%d")
-    path = "temp#{t}-#{$$}-#{rand(0x100000000).to_s(36)}"
-    @test_file  = File.join(Dir.tmpdir, path)
     @biff = BIFFWriter.new
-    @ruby_file = @test_file
+    @ruby_file = StringIO.new
+  end
+
+  def teardown
+    @biff = nil
   end
 
   def test_append_no_error
@@ -25,7 +28,7 @@ def test_data_added
     assert_nothing_raised{ @biff.append("Hello", "World") }
     data = ''
     while d = @biff.get_data
-      data = data + d
+      data += d
     end
     assert_equal("HelloWorld", data, "Bad data contents")
     assert_equal(10, @biff.datasize, "Bad data size")
@@ -37,7 +40,7 @@ def test_data_prepended
     assert_nothing_raised{ @biff.prepend("World") }
     data = ''
     while d = @biff.get_data
-      data = data + d
+      data += d
     end
     assert_equal("WorldHello", data, "Bad data contents")
     assert_equal(10, @biff.datasize, "Bad data size")
@@ -64,38 +67,9 @@ def test_datasize_mixed
   def test_add_continue
     perl_file = "#{PERL_OUTDIR}/biff_add_continue_testdata"
     size = File.size(perl_file)
-    @fh = File.new(@ruby_file,"w+")
-    @fh.print(@biff.add_continue('testdata'))
-    @fh.close
-    rsize = File.size(@ruby_file)
-    assert_equal(size,rsize,"File sizes not the same")
+    @ruby_file.print(@biff.add_continue('testdata'))
+    rsize = @ruby_file.size
+    assert_equal(size, rsize, "File sizes not the same")
     compare_file(perl_file, @ruby_file)
   end
-
-  def teardown
-    @biff = nil
-    File.delete(@ruby_file) if File.exist?(@ruby_file)
-  end
-
-  def compare_file(expected, target)
-    fh_e = File.open(expected, "r")
-    fh_t = File.open(target, "r")
-    while true do
-      e1 = fh_e.read(1)
-      t1 = fh_t.read(1)
-      if e1.nil?
-        assert( t1.nil?, "#{expexted} is EOF but #{target} is NOT EOF.")
-        break
-      elsif t1.nil?
-        assert( e1.nil?, '#{target} is EOF but #{expected} is NOT EOF.')
-        break
-      end
-      assert_equal(e1, t1, sprintf(" #{expected} = '%s' but #{target} = '%s'", e1, t1))
-      break
-    end
-    fh_e.close
-    fh_t.close
-  end
-
-
 end

data/test/test_compatibility.rb

@@ -0,0 +1,627 @@
+# -*- coding: utf-8 -*-
+require 'helper'
+require 'nkf'
+
+class TC_Compatibility < Test::Unit::TestCase
+  def setup
+    ruby_18 do
+      @kcode = $KCODE
+      $KCODE = 'u'
+    end
+  end
+
+  def teardown
+    ruby_18 { $KCODE = @kcode }
+  end
+
+  def test_encoding
+    # String#encoding -> Encoding::***
+    str     = 'あいう'
+    utf8    = str
+#    utf16le = NKF.nkf('-w16L0 -m0 -W', str)
+#    utf16be = NKF.nkf('-w16B0 -m0 -W', str)
+    assert_equal(Encoding::UTF_8, utf8.encoding)
+
+    if RUBY_VERSION < "1.9"
+      # String#encoding returns depending $KCODE
+      # if string has not changed its encoding.
+      str   = 'abc'
+      utf8  = str
+      assert_equal(Encoding::UTF_8, utf8.encoding)
+    end
+  end
+
+  def ascii_str_enc_ascii
+    str = ["abc"].pack('a*').encode('ASCII')
+    str.encode('ASCII') if RUBY_VERSION < "1.9"
+    str
+  end
+
+  def test_ascii_str_enc_ascii_is_ascii_encoding
+    assert_equal(Encoding::ASCII, ascii_str_enc_ascii.encoding)
+  end
+
+  def ascii_str_enc_binary
+    str = ["abc"].pack('a*').encode('BINARY')
+    str.encode('BINARY') if RUBY_VERSION < "1.9"
+    str
+  end
+
+  def test_ascii_str_enc_binary_is_binary_encoding
+    assert_equal(Encoding::BINARY, ascii_str_enc_binary.encoding)
+  end
+
+  def non_ascii_str_enc_binary
+    str = [0x80].pack('v*')
+    str.force_encoding('BINARY')
+    str
+  end
+
+  def test_non_ascii_str_enc_binary
+    assert_equal(Encoding::BINARY, non_ascii_str_enc_binary.encoding)
+  end
+
+  def ascii_str_enc_utf8
+    "abc"
+  end
+
+  def test_ascii_str_enc_utf8_is_utf8_encoding
+    assert_equal(Encoding::UTF_8, ascii_str_enc_utf8.encoding)
+  end
+
+  def non_ascii_str_enc_utf8
+    'あいう'
+  end
+
+  def test_non_ascii_str_enc_utf8
+    assert_equal(Encoding::UTF_8, non_ascii_str_enc_utf8.encoding)
+  end
+
+  def ascii_str_enc_eucjp
+    str = "abc".encode('EUCJP')
+    str
+  end
+
+  def test_ascii_str_enc_eucjp_is_eucjp_encoding
+    assert_equal(Encoding::EUCJP, ascii_str_enc_eucjp.encoding)
+  end
+
+  def non_ascii_str_enc_eucjp
+    str = 'あいう'.encode('EUCJP')
+    str
+  end
+
+  def test_non_ascii_str_enc_eucjp
+    assert_equal(Encoding::EUCJP, non_ascii_str_enc_eucjp.encoding)
+  end
+
+  def ascii_str_enc_sjis
+    str = "abc".encode('SJIS')
+    str
+  end
+
+  def test_ascii_str_enc_sjis_is_sjis_encoding
+    assert_equal(Encoding::SJIS, ascii_str_enc_sjis.encoding)
+  end
+
+  def non_ascii_str_enc_sjis
+    str = 'あいう'.encode('SJIS')
+    str
+  end
+
+  def test_non_ascii_str_enc_sjis
+    assert_equal(Encoding::SJIS, non_ascii_str_enc_sjis.encoding)
+  end
+
+  def ascii_str_enc_utf16le
+    str = NKF.nkf('-w16L0 -m0 -W', "abc")
+    str.force_encoding('UTF_16LE') if RUBY_VERSION < "1.9"
+    str
+  end
+
+  def test_ascii_str_enc_utf16le_is_utf16le_encoding
+    assert_equal(Encoding::UTF_16LE, ascii_str_enc_utf16le.encoding)
+  end
+
+  def non_ascii_str_enc_utf16le
+    str = NKF.nkf('-w16L0 -m0 -W', 'あいう')
+    str.force_encoding('UTF_16LE') if RUBY_VERSION < "1.9"
+    str
+  end
+
+  def test_non_ascii_str_enc_utf16le
+    assert_equal(Encoding::UTF_16LE, non_ascii_str_enc_utf16le.encoding)
+  end
+
+  def ascii_str_enc_utf16be
+    str = NKF.nkf('-w16B0 -m0 -W', "abc")
+    str.force_encoding('UTF_16BE') if RUBY_VERSION < "1.9"
+    str
+  end
+
+  def test_ascii_str_enc_utf16be_is_utf16be_encoding
+    assert_equal(Encoding::UTF_16BE, ascii_str_enc_utf16be.encoding)
+  end
+
+  def non_ascii_str_enc_utf16be
+    str = NKF.nkf('-w16B0 -m0 -W', 'あいう')
+    str.force_encoding('UTF_16BE') if RUBY_VERSION < "1.9"
+    str
+  end
+
+  def test_non_ascii_str_enc_utf16be
+    assert_equal(Encoding::UTF_16BE, non_ascii_str_enc_utf16be.encoding)
+  end
+
+  def test_ascii_str_ascii_to_ascii
+    str = ascii_str_enc_ascii
+    assert_equal(Encoding::ASCII, str.encode('ASCII').encoding)
+  end
+
+  def test_ascii_str_ascii_to_binary
+    str = ascii_str_enc_ascii
+    assert_equal(Encoding::BINARY, str.encode('BINARY').encoding)
+  end
+
+  def test_ascii_str_ascii_to_utf8
+    str = ascii_str_enc_ascii
+    assert_raise(Encoding::ConverterNotFoundError){ str.encode('UTF_8') }
+  end
+
+  def test_ascii_str_ascii_to_eucjp
+    str = ascii_str_enc_ascii
+    assert_equal(Encoding::EUCJP, str.encode('EUCJP').encoding)
+  end
+
+  def test_ascii_str_ascii_to_sjis
+    str = ascii_str_enc_ascii
+    assert_equal(Encoding::SJIS, str.encode('SJIS').encoding)
+  end
+
+  def test_ascii_str_ascii_to_utf16le
+    str = ascii_str_enc_ascii
+    assert_raise(Encoding::ConverterNotFoundError){ str.encode('UTF_16LE') }
+  end
+
+  def test_ascii_str_ascii_to_utf16be
+    str = ascii_str_enc_ascii
+    assert_raise(Encoding::ConverterNotFoundError){ str.encode('UTF_16BE') }
+  end
+
+  def test_ascii_str_binary_to_ascii
+    str = ascii_str_enc_binary
+    assert_equal(Encoding::ASCII, str.encode('ASCII').encoding)
+  end
+
+  def test_non_ascii_str_binary_to_ascii
+    str = non_ascii_str_enc_binary
+    assert_raise(Encoding::UndefinedConversionError){ str.encode('ASCII') }
+  end
+
+  def test_ascii_str_binary_to_binary
+    str = ascii_str_enc_binary
+    assert_equal(Encoding::BINARY, str.encode('BINARY').encoding)
+  end
+
+  def test_non_ascii_str_binary_to_binary
+    str = non_ascii_str_enc_binary
+    assert_equal(Encoding::BINARY, str.encode('BINARY').encoding)
+  end
+
+  def test_ascii_str_binary_to_utf8
+    str = ascii_str_enc_binary
+    assert_raise(Encoding::ConverterNotFoundError){ str.encode('UTF_8') }
+  end
+
+  def test_non_ascii_str_binary_to_utf8
+    str = non_ascii_str_enc_binary
+    assert_raise(Encoding::ConverterNotFoundError,
+                 Encoding::UndefinedConversionError) { str.encode('UTF_8') }
+  end
+
+  def test_ascii_str_binary_to_eucjp
+    str = ascii_str_enc_binary
+    assert_equal(Encoding::EUCJP, str.encode('EUCJP').encoding)
+  end
+
+  def test_non_ascii_str_binary_to_eucjp
+    str = non_ascii_str_enc_binary
+    assert_raise(Encoding::ConverterNotFoundError,
+                 Encoding::UndefinedConversionError) { str.encode('EUCJP') }
+  end
+
+  def test_ascii_str_binary_to_sjis
+    str = ascii_str_enc_binary
+    assert_equal(Encoding::SJIS, str.encode('SJIS').encoding)
+  end
+
+  def test_non_ascii_str_binary_to_sjis
+    str = non_ascii_str_enc_binary
+    assert_raise(Encoding::ConverterNotFoundError,
+                 Encoding::UndefinedConversionError) { str.encode('SJIS') }
+  end
+
+  def test_ascii_str_binary_to_utf16le
+    str = ascii_str_enc_binary
+    assert_raise(Encoding::ConverterNotFoundError){ str.encode('UTF_16LE') }
+  end
+
+  def test_non_ascii_str_binary_to_utf16le
+    str = non_ascii_str_enc_binary
+    assert_raise(Encoding::ConverterNotFoundError) { str.encode('UTF_16LE') }
+  end
+
+  def test_ascii_str_binary_to_utf16be
+    str = ascii_str_enc_binary
+    assert_raise(Encoding::ConverterNotFoundError){ str.encode('UTF_16BE') }
+  end
+
+  def test_non_ascii_str_binary_to_utf16be
+    str = non_ascii_str_enc_binary
+    assert_raise(Encoding::ConverterNotFoundError) { str.encode('UTF_16BE') }
+  end
+
+  def test_ascii_str_utf8_to_ascii
+    str = ascii_str_enc_utf8
+    assert_equal(Encoding::ASCII, str.encode('ASCII').encoding)
+  end
+
+  def test_non_ascii_str_utf8_to_ascii
+    str = non_ascii_str_enc_utf8
+    assert_raise(Encoding::UndefinedConversionError) { str.encode('ASCII') }
+  end
+
+  def test_ascii_str_utf8_to_binary
+    str = ascii_str_enc_utf8
+    assert_equal(Encoding::BINARY, str.encode('BINARY').encoding)
+  end
+
+  def test_non_ascii_str_utf8_to_binary
+    str = non_ascii_str_enc_utf8
+    assert_raise(Encoding::UndefinedConversionError) { str.encode('BINARY') }
+  end
+
+  def test_ascii_str_utf8_to_utf8
+    str = ascii_str_enc_utf8
+    assert_raise(Encoding::ConverterNotFoundError){ str.encode('UTF_8') }
+  end
+
+  def test_non_ascii_str_utf8_to_utf8
+    str = non_ascii_str_enc_utf8
+    assert_raise(Encoding::ConverterNotFoundError) { str.encode('UTF_8') }
+  end
+
+  def test_ascii_str_utf8_to_eucjp
+    str = ascii_str_enc_utf8
+    assert_equal(Encoding::EUCJP, str.encode('EUCJP').encoding)
+  end
+
+  def test_non_ascii_str_utf8_to_eucjp
+    str = non_ascii_str_enc_utf8
+    assert_equal(Encoding::EUCJP, str.encode('EUCJP').encoding)
+  end
+
+  def test_ascii_str_utf8_to_sjis
+    str = ascii_str_enc_utf8
+    assert_equal(Encoding::SJIS, str.encode('SJIS').encoding)
+  end
+
+  def test_non_ascii_str_utf8_to_sjis
+    str = non_ascii_str_enc_utf8
+    assert_equal(Encoding::SJIS, str.encode('SJIS').encoding)
+  end
+
+  def test_ascii_str_utf8_to_utf16le
+    str = ascii_str_enc_utf8
+    assert_raise(Encoding::ConverterNotFoundError){ str.encode('UTF_16LE') }
+  end
+
+  def test_non_ascii_str_utf8_to_utf16le
+    str = non_ascii_str_enc_utf8
+    assert_raise(Encoding::ConverterNotFoundError) { str.encode('UTF_16LE') }
+  end
+
+  def test_ascii_str_utf8_to_utf16be
+    str = ascii_str_enc_utf8
+    assert_raise(Encoding::ConverterNotFoundError){ str.encode('UTF_16BE') }
+  end
+
+  def test_non_ascii_str_utf8_to_utf16be
+    str = non_ascii_str_enc_utf8
+    assert_raise(Encoding::ConverterNotFoundError) { str.encode('UTF_16BE') }
+  end
+
+  def test_ascii_str_eucjp_to_ascii
+    str = ascii_str_enc_eucjp
+    assert_equal(Encoding::ASCII, str.encode('ASCII').encoding)
+  end
+
+  def test_non_ascii_str_eucjp_to_ascii
+    str = non_ascii_str_enc_eucjp
+    assert_raise(Encoding::UndefinedConversionError) { str.encode('ASCII') }
+  end
+
+  def test_ascii_str_eucjp_to_binary
+    str = ascii_str_enc_eucjp
+    assert_equal(Encoding::BINARY, str.encode('BINARY').encoding)
+  end
+
+  def test_non_ascii_str_eucjp_to_binary
+    str = non_ascii_str_enc_eucjp
+    assert_raise(Encoding::UndefinedConversionError) { str.encode('BINARY') }
+  end
+
+  def test_ascii_str_eucjp_to_utf8
+    str = ascii_str_enc_eucjp
+    assert_raise(Encoding::ConverterNotFoundError){ str.encode('UTF_8') }
+  end
+
+  def test_non_ascii_str_eucjp_to_utf8
+    str = non_ascii_str_enc_eucjp
+    assert_raise(Encoding::ConverterNotFoundError) { str.encode('UTF_8') }
+  end
+
+  def test_ascii_str_eucjp_to_eucjp
+    str = ascii_str_enc_eucjp
+    assert_equal(Encoding::EUCJP, str.encode('EUCJP').encoding)
+  end
+
+  def test_non_ascii_str_eucjp_to_eucjp
+    str = non_ascii_str_enc_eucjp
+    assert_equal(Encoding::EUCJP, str.encode('EUCJP').encoding)
+  end
+
+  def test_ascii_str_eucjp_to_sjis
+    str = ascii_str_enc_eucjp
+    assert_equal(Encoding::SJIS, str.encode('SJIS').encoding)
+  end
+
+  def test_non_ascii_str_eucjp_to_sjis
+    str = non_ascii_str_enc_eucjp
+    assert_equal(Encoding::SJIS, str.encode('SJIS').encoding)
+  end
+
+  def test_ascii_str_eucjp_to_utf16le
+    str = ascii_str_enc_eucjp
+    assert_raise(Encoding::ConverterNotFoundError){ str.encode('UTF_16LE') }
+  end
+
+  def test_non_ascii_str_eucjp_to_utf16le
+    str = non_ascii_str_enc_eucjp
+    assert_raise(Encoding::ConverterNotFoundError) { str.encode('UTF_16LE') }
+  end
+
+  def test_ascii_str_eucjp_to_utf16be
+    str = ascii_str_enc_eucjp
+    assert_raise(Encoding::ConverterNotFoundError){ str.encode('UTF_16BE') }
+  end
+
+  def test_non_ascii_str_eucjp_to_utf16be
+    str = non_ascii_str_enc_eucjp
+    assert_raise(Encoding::ConverterNotFoundError) { str.encode('UTF_16BE') }
+  end
+
+  def test_ascii_str_sjis_to_ascii
+    str = ascii_str_enc_sjis
+    assert_equal(Encoding::ASCII, str.encode('ASCII').encoding)
+  end
+
+  def test_non_ascii_str_sjis_to_ascii
+    str = non_ascii_str_enc_sjis
+    assert_raise(Encoding::UndefinedConversionError) { str.encode('ASCII') }
+  end
+
+  def test_ascii_str_sjis_to_binary
+    str = ascii_str_enc_sjis
+    assert_equal(Encoding::BINARY, str.encode('BINARY').encoding)
+  end
+
+  def test_non_ascii_str_sjis_to_binary
+    str = non_ascii_str_enc_sjis
+    assert_raise(Encoding::UndefinedConversionError) { str.encode('BINARY') }
+  end
+
+  def test_ascii_str_sjis_to_utf8
+    str = ascii_str_enc_sjis
+    assert_raise(Encoding::ConverterNotFoundError){ str.encode('UTF_8') }
+  end
+
+  def test_non_ascii_str_sjis_to_utf8
+    str = non_ascii_str_enc_sjis
+    assert_raise(Encoding::ConverterNotFoundError) { str.encode('UTF_8') }
+  end
+
+  def test_ascii_str_sjis_to_eucjp
+    str = ascii_str_enc_sjis
+    assert_equal(Encoding::EUCJP, str.encode('EUCJP').encoding)
+  end
+
+  def test_non_ascii_str_sjis_to_eucjp
+    str = non_ascii_str_enc_sjis
+    assert_equal(Encoding::EUCJP, str.encode('EUCJP').encoding)
+  end
+
+  def test_ascii_str_sjis_to_sjis
+    str = ascii_str_enc_sjis
+    assert_equal(Encoding::SJIS, str.encode('SJIS').encoding)
+  end
+
+  def test_non_ascii_str_sjis_to_sjis
+    str = non_ascii_str_enc_sjis
+    assert_equal(Encoding::SJIS, str.encode('SJIS').encoding)
+  end
+
+  def test_ascii_str_sjis_to_utf16le
+    str = ascii_str_enc_sjis
+    assert_raise(Encoding::ConverterNotFoundError){ str.encode('UTF_16LE') }
+  end
+
+  def test_non_ascii_str_sjis_to_utf16le
+    str = non_ascii_str_enc_sjis
+    assert_raise(Encoding::ConverterNotFoundError) { str.encode('UTF_16LE') }
+  end
+
+  def test_ascii_str_sjis_to_utf16be
+    str = ascii_str_enc_sjis
+    assert_raise(Encoding::ConverterNotFoundError){ str.encode('UTF_16BE') }
+  end
+
+  def test_non_ascii_str_sjis_to_utf16be
+    str = non_ascii_str_enc_sjis
+    assert_raise(Encoding::ConverterNotFoundError) { str.encode('UTF_16BE') }
+  end
+
+  def test_ascii_str_utf16le_to_ascii
+    str = ascii_str_enc_utf16le
+    assert_equal(Encoding::ASCII, str.encode('ASCII').encoding)
+  end
+
+  def test_non_ascii_str_utf16le_to_ascii
+    str = non_ascii_str_enc_utf16le
+    assert_raise(Encoding::UndefinedConversionError) { str.encode('ASCII') }
+  end
+
+  def test_ascii_str_utf16le_to_binary
+    str = ascii_str_enc_utf16le
+    assert_equal(Encoding::BINARY, str.encode('BINARY').encoding)
+  end
+
+  def test_non_ascii_str_utf16le_to_binary
+    str = non_ascii_str_enc_utf16le
+    assert_raise(Encoding::UndefinedConversionError) { str.encode('BINARY') }
+  end
+
+  def test_ascii_str_utf16le_to_utf8
+    str = ascii_str_enc_utf16le
+    assert_raise(Encoding::ConverterNotFoundError){ str.encode('UTF_8') }
+  end
+
+  def test_non_ascii_str_utf16le_to_utf8
+    str = non_ascii_str_enc_utf16le
+    assert_raise(Encoding::ConverterNotFoundError) { str.encode('UTF_8') }
+  end
+
+  def test_ascii_str_utf16le_to_eucjp
+    str = ascii_str_enc_utf16le
+    assert_equal(Encoding::EUCJP, str.encode('EUCJP').encoding)
+  end
+
+  def test_non_ascii_str_utf16le_to_eucjp
+    str = non_ascii_str_enc_utf16le
+    assert_equal(Encoding::EUCJP, str.encode('EUCJP').encoding)
+  end
+
+  def test_ascii_str_utf16le_to_sjis
+    str = ascii_str_enc_utf16le
+    assert_equal(Encoding::SJIS, str.encode('SJIS').encoding)
+  end
+
+  def test_non_ascii_str_utf16le_to_sjis
+    str = non_ascii_str_enc_utf16le
+    assert_equal(Encoding::SJIS, str.encode('SJIS').encoding)
+  end
+
+  def test_ascii_str_utf16le_to_utf16le
+    str = ascii_str_enc_utf16le
+    assert_raise(Encoding::ConverterNotFoundError){ str.encode('UTF_16LE') }
+  end
+
+  def test_non_ascii_str_utf16le_to_utf16le
+    str = non_ascii_str_enc_utf16le
+    assert_raise(Encoding::ConverterNotFoundError) { str.encode('UTF_16LE') }
+  end
+
+  def test_ascii_str_utf16le_to_utf16be
+    str = ascii_str_enc_utf16le
+    assert_raise(Encoding::ConverterNotFoundError){ str.encode('UTF_16BE') }
+  end
+
+  def test_non_ascii_str_utf16le_to_utf16be
+    str = non_ascii_str_enc_utf16le
+    assert_raise(Encoding::ConverterNotFoundError) { str.encode('UTF_16BE') }
+  end
+
+  def test_ascii_str_utf16be_to_ascii
+    str = ascii_str_enc_utf16be
+    assert_equal(Encoding::ASCII, str.encode('ASCII').encoding)
+  end
+
+  def test_non_ascii_str_utf16be_to_ascii
+    str = non_ascii_str_enc_utf16be
+    assert_raise(Encoding::UndefinedConversionError) { str.encode('ASCII') }
+  end
+
+  def test_ascii_str_utf16be_to_binary
+    str = ascii_str_enc_utf16be
+    assert_equal(Encoding::BINARY, str.encode('BINARY').encoding)
+  end
+
+  def test_non_ascii_str_utf16be_to_binary
+    str = non_ascii_str_enc_utf16be
+    assert_raise(Encoding::UndefinedConversionError) { str.encode('BINARY') }
+  end
+
+  def test_ascii_str_utf16be_to_utf8
+    str = ascii_str_enc_utf16be
+    assert_raise(Encoding::ConverterNotFoundError){ str.encode('UTF_8') }
+  end
+
+  def test_non_ascii_str_utf16be_to_utf8
+    str = non_ascii_str_enc_utf16be
+    assert_raise(Encoding::ConverterNotFoundError) { str.encode('UTF_8') }
+  end
+
+  def test_ascii_str_utf16be_to_eucjp
+    str = ascii_str_enc_utf16be
+    assert_equal(Encoding::EUCJP, str.encode('EUCJP').encoding)
+  end
+
+  def test_non_ascii_str_utf16be_to_eucjp
+    str = non_ascii_str_enc_utf16be
+    assert_equal(Encoding::EUCJP, str.encode('EUCJP').encoding)
+  end
+
+  def test_ascii_str_utf16be_to_sjis
+    str = ascii_str_enc_utf16be
+    assert_equal(Encoding::SJIS, str.encode('SJIS').encoding)
+  end
+
+  def test_non_ascii_str_utf16be_to_sjis
+    str = non_ascii_str_enc_utf16be
+    assert_equal(Encoding::SJIS, str.encode('SJIS').encoding)
+  end
+
+  def test_ascii_str_utf16be_to_utf16le
+    str = ascii_str_enc_utf16be
+    assert_raise(Encoding::ConverterNotFoundError){ str.encode('UTF_16LE') }
+  end
+
+  def test_non_ascii_str_utf16be_to_utf16le
+    str = non_ascii_str_enc_utf16be
+    assert_raise(Encoding::ConverterNotFoundError) { str.encode('UTF_16LE') }
+  end
+
+  def test_ascii_str_utf16be_to_utf16be
+    str = ascii_str_enc_utf16be
+    assert_raise(Encoding::ConverterNotFoundError){ str.encode('UTF_16BE') }
+  end
+
+  def test_non_ascii_str_utf16be_to_utf16be
+    str = non_ascii_str_enc_utf16be
+    assert_raise(Encoding::ConverterNotFoundError) { str.encode('UTF_16BE') }
+  end
+
+  def test_ord
+    a = 'a'
+    abc = 'abc'
+    assert_equal(97, a.ord, "#{a}.ord faild\n")
+    assert_equal(97, abc.ord, "#{abc}.ord faild\n")
+  end
+
+  def test_force_encodig
+    str = 'あいう'
+    org_dump = unpack_record(str)
+    asc8_dump = unpack_record(str.force_encoding('ASCII-8BIT'))
+    assert_equal(org_dump, asc8_dump)
+  end
+end