jruby-openssl 0.8.0.pre3 → 0.8.0

data/test/1.8/test_asn1.rb

@@ -1,212 +0,0 @@
-begin
-  require "openssl"
-  require File.join(File.dirname(__FILE__), "utils.rb")
-rescue LoadError
-end
-require 'test/unit'
-
-class  OpenSSL::TestASN1 < Test::Unit::TestCase
-  def test_decode
-    subj = OpenSSL::X509::Name.parse("/DC=org/DC=ruby-lang/CN=TestCA")
-    key = OpenSSL::TestUtils::TEST_KEY_RSA1024
-    now = Time.at(Time.now.to_i) # suppress usec
-    s = 0xdeadbeafdeadbeafdeadbeafdeadbeaf
-    exts = [
-      ["basicConstraints","CA:TRUE,pathlen:1",true],
-      ["keyUsage","keyCertSign, cRLSign",true],
-      ["subjectKeyIdentifier","hash",false],
-    ]
-    dgst = OpenSSL::Digest::SHA1.new
-    cert = OpenSSL::TestUtils.issue_cert(
-      subj, key, s, now, now+3600, exts, nil, nil, dgst)
-
-
-    asn1 = OpenSSL::ASN1.decode(cert)
-    assert_equal(OpenSSL::ASN1::Sequence, asn1.class)
-    assert_equal(3, asn1.value.size)
-    tbs_cert, sig_alg, sig_val = *asn1.value
-
-    assert_equal(OpenSSL::ASN1::Sequence, tbs_cert.class)
-    assert_equal(8, tbs_cert.value.size)
-
-    version = tbs_cert.value[0]
-    assert_equal(:CONTEXT_SPECIFIC, version.tag_class)
-    assert_equal(0, version.tag)
-    assert_equal(1, version.value.size)
-    assert_equal(OpenSSL::ASN1::Integer, version.value[0].class)
-    assert_equal(2, version.value[0].value)
-    assert_equal(OpenSSL::BN, version.value[0].value.class)
-
-    serial = tbs_cert.value[1]
-    assert_equal(OpenSSL::ASN1::Integer, serial.class)
-    assert_equal(0xdeadbeafdeadbeafdeadbeafdeadbeaf, serial.value)
-
-    sig = tbs_cert.value[2]
-    assert_equal(OpenSSL::ASN1::Sequence, sig.class)
-    assert_equal(2, sig.value.size)
-    assert_equal(OpenSSL::ASN1::ObjectId, sig.value[0].class)
-    assert_equal("1.2.840.113549.1.1.5", sig.value[0].oid)
-    assert_equal(OpenSSL::ASN1::Null, sig.value[1].class)
-
-    dn = tbs_cert.value[3] # issuer
-    assert_equal(subj.hash, OpenSSL::X509::Name.new(dn).hash)
-    assert_equal(OpenSSL::ASN1::Sequence, dn.class)
-    assert_equal(3, dn.value.size)
-    assert_equal(OpenSSL::ASN1::Set, dn.value[0].class)
-    assert_equal(OpenSSL::ASN1::Set, dn.value[1].class)
-    assert_equal(OpenSSL::ASN1::Set, dn.value[2].class)
-    assert_equal(1, dn.value[0].value.size)
-    assert_equal(1, dn.value[1].value.size)
-    assert_equal(1, dn.value[2].value.size)
-    assert_equal(OpenSSL::ASN1::Sequence, dn.value[0].value[0].class)
-    assert_equal(OpenSSL::ASN1::Sequence, dn.value[1].value[0].class)
-    assert_equal(OpenSSL::ASN1::Sequence, dn.value[2].value[0].class)
-    assert_equal(2, dn.value[0].value[0].value.size)
-    assert_equal(2, dn.value[1].value[0].value.size)
-    assert_equal(2, dn.value[2].value[0].value.size)
-    oid, value = *dn.value[0].value[0].value
-    assert_equal(OpenSSL::ASN1::ObjectId, oid.class)
-    assert_equal("0.9.2342.19200300.100.1.25", oid.oid)
-    assert_equal(OpenSSL::ASN1::IA5String, value.class)
-    assert_equal("org", value.value)
-    oid, value = *dn.value[1].value[0].value
-    assert_equal(OpenSSL::ASN1::ObjectId, oid.class)
-    assert_equal("0.9.2342.19200300.100.1.25", oid.oid)
-    assert_equal(OpenSSL::ASN1::IA5String, value.class)
-    assert_equal("ruby-lang", value.value)
-    oid, value = *dn.value[2].value[0].value
-    assert_equal(OpenSSL::ASN1::ObjectId, oid.class)
-    assert_equal("2.5.4.3", oid.oid)
-    assert_equal(OpenSSL::ASN1::UTF8String, value.class)
-    assert_equal("TestCA", value.value)
-
-    validity = tbs_cert.value[4]
-    assert_equal(OpenSSL::ASN1::Sequence, validity.class)
-    assert_equal(2, validity.value.size)
-    assert_equal(OpenSSL::ASN1::UTCTime, validity.value[0].class)
-    assert_equal(now, validity.value[0].value)
-    assert_equal(OpenSSL::ASN1::UTCTime, validity.value[1].class)
-    assert_equal(now+3600, validity.value[1].value)
-
-    dn = tbs_cert.value[5] # subject
-    assert_equal(subj.hash, OpenSSL::X509::Name.new(dn).hash)
-    assert_equal(OpenSSL::ASN1::Sequence, dn.class)
-    assert_equal(3, dn.value.size)
-    assert_equal(OpenSSL::ASN1::Set, dn.value[0].class)
-    assert_equal(OpenSSL::ASN1::Set, dn.value[1].class)
-    assert_equal(OpenSSL::ASN1::Set, dn.value[2].class)
-    assert_equal(1, dn.value[0].value.size)
-    assert_equal(1, dn.value[1].value.size)
-    assert_equal(1, dn.value[2].value.size)
-    assert_equal(OpenSSL::ASN1::Sequence, dn.value[0].value[0].class)
-    assert_equal(OpenSSL::ASN1::Sequence, dn.value[1].value[0].class)
-    assert_equal(OpenSSL::ASN1::Sequence, dn.value[2].value[0].class)
-    assert_equal(2, dn.value[0].value[0].value.size)
-    assert_equal(2, dn.value[1].value[0].value.size)
-    assert_equal(2, dn.value[2].value[0].value.size)
-    oid, value = *dn.value[0].value[0].value
-    assert_equal(OpenSSL::ASN1::ObjectId, oid.class)
-    assert_equal("0.9.2342.19200300.100.1.25", oid.oid)
-    assert_equal(OpenSSL::ASN1::IA5String, value.class)
-    assert_equal("org", value.value)
-    oid, value = *dn.value[1].value[0].value
-    assert_equal(OpenSSL::ASN1::ObjectId, oid.class)
-    assert_equal("0.9.2342.19200300.100.1.25", oid.oid)
-    assert_equal(OpenSSL::ASN1::IA5String, value.class)
-    assert_equal("ruby-lang", value.value)
-    oid, value = *dn.value[2].value[0].value
-    assert_equal(OpenSSL::ASN1::ObjectId, oid.class)
-    assert_equal("2.5.4.3", oid.oid)
-    assert_equal(OpenSSL::ASN1::UTF8String, value.class)
-    assert_equal("TestCA", value.value)
-
-    pkey = tbs_cert.value[6]
-    assert_equal(OpenSSL::ASN1::Sequence, pkey.class)
-    assert_equal(2, pkey.value.size)
-    assert_equal(OpenSSL::ASN1::Sequence, pkey.value[0].class)
-    assert_equal(2, pkey.value[0].value.size)
-    assert_equal(OpenSSL::ASN1::ObjectId, pkey.value[0].value[0].class)
-    assert_equal("1.2.840.113549.1.1.1", pkey.value[0].value[0].oid)
-    assert_equal(OpenSSL::ASN1::BitString, pkey.value[1].class)
-    assert_equal(0, pkey.value[1].unused_bits)
-    spkey = OpenSSL::ASN1.decode(pkey.value[1].value)
-    assert_equal(OpenSSL::ASN1::Sequence, spkey.class)
-    assert_equal(2, spkey.value.size)
-    assert_equal(OpenSSL::ASN1::Integer, spkey.value[0].class)
-    assert_equal(143085709396403084580358323862163416700436550432664688288860593156058579474547937626086626045206357324274536445865308750491138538454154232826011964045825759324933943290377903384882276841880081931690695505836279972214003660451338124170055999155993192881685495391496854691199517389593073052473319331505702779271, spkey.value[0].value)
-    assert_equal(OpenSSL::ASN1::Integer, spkey.value[1].class)
-    assert_equal(65537, spkey.value[1].value)
-
-    extensions = tbs_cert.value[7]
-    assert_equal(:CONTEXT_SPECIFIC, extensions.tag_class)
-    assert_equal(3, extensions.tag)
-    assert_equal(1, extensions.value.size)
-    assert_equal(OpenSSL::ASN1::Sequence, extensions.value[0].class)
-    assert_equal(3, extensions.value[0].value.size)
-
-    ext = extensions.value[0].value[0]  # basicConstraints
-    assert_equal(OpenSSL::ASN1::Sequence, ext.class)
-    assert_equal(3, ext.value.size)
-    assert_equal(OpenSSL::ASN1::ObjectId, ext.value[0].class)
-    assert_equal("2.5.29.19",  ext.value[0].oid)
-    assert_equal(OpenSSL::ASN1::Boolean, ext.value[1].class)
-    assert_equal(true, ext.value[1].value)
-    assert_equal(OpenSSL::ASN1::OctetString, ext.value[2].class)
-    extv = OpenSSL::ASN1.decode(ext.value[2].value)
-    assert_equal(OpenSSL::ASN1::Sequence, extv.class)
-    assert_equal(2, extv.value.size)
-    assert_equal(OpenSSL::ASN1::Boolean, extv.value[0].class)
-    assert_equal(true, extv.value[0].value)
-    assert_equal(OpenSSL::ASN1::Integer, extv.value[1].class)
-    assert_equal(1, extv.value[1].value)
-
-    ext = extensions.value[0].value[1]  # keyUsage
-    assert_equal(OpenSSL::ASN1::Sequence, ext.class)
-    assert_equal(3, ext.value.size)
-    assert_equal(OpenSSL::ASN1::ObjectId, ext.value[0].class)
-    assert_equal("2.5.29.15",  ext.value[0].oid)
-    assert_equal(OpenSSL::ASN1::Boolean, ext.value[1].class)
-    assert_equal(true, ext.value[1].value)
-    assert_equal(OpenSSL::ASN1::OctetString, ext.value[2].class)
-    extv = OpenSSL::ASN1.decode(ext.value[2].value)
-    assert_equal(OpenSSL::ASN1::BitString, extv.class)
-    str = "\000"; str[0] = 0b00000110
-    assert_equal(str, extv.value)
-
-    ext = extensions.value[0].value[2]  # subjetKeyIdentifier
-    assert_equal(OpenSSL::ASN1::Sequence, ext.class)
-    assert_equal(2, ext.value.size)
-    assert_equal(OpenSSL::ASN1::ObjectId, ext.value[0].class)
-    assert_equal("2.5.29.14",  ext.value[0].oid)
-    assert_equal(OpenSSL::ASN1::OctetString, ext.value[1].class)
-    extv = OpenSSL::ASN1.decode(ext.value[1].value)
-    assert_equal(OpenSSL::ASN1::OctetString, extv.class)
-    sha1 = OpenSSL::Digest::SHA1.new
-    sha1.update(pkey.value[1].value)
-    assert_equal(sha1.digest, extv.value)
-
-    assert_equal(OpenSSL::ASN1::Sequence, sig_alg.class)
-    assert_equal(2, sig_alg.value.size)
-    assert_equal(OpenSSL::ASN1::ObjectId, pkey.value[0].value[0].class)
-    assert_equal("1.2.840.113549.1.1.1", pkey.value[0].value[0].oid)
-    assert_equal(OpenSSL::ASN1::Null, pkey.value[0].value[1].class)
-
-    assert_equal(OpenSSL::ASN1::BitString, sig_val.class)
-    cululated_sig = key.sign(OpenSSL::Digest::SHA1.new, tbs_cert.to_der)
-    assert_equal(cululated_sig, sig_val.value)
-  end
-
-  def test_encode_boolean
-    encode_decode_test(OpenSSL::ASN1::Boolean, [true, false])
-  end
-
-  def test_encode_integer
-    encode_decode_test(OpenSSL::ASN1::Integer, [72, -127, -128, 128, -1, 0, 1, -(2**12345), 2**12345])
-  end
-
-  def encode_decode_test(type, values)
-    values.each do |v|
-      assert_equal(v, OpenSSL::ASN1.decode(type.new(v).to_der).value)
-    end
-  end
-end if defined?(OpenSSL)

data/test/1.8/test_cipher.rb

@@ -1,193 +0,0 @@
-begin
-  require "openssl"
-rescue LoadError
-end
-require "test/unit"
-
-if defined?(OpenSSL)
-
-class OpenSSL::TestCipher < Test::Unit::TestCase
-  def setup
-    @c1 = OpenSSL::Cipher::Cipher.new("DES-EDE3-CBC")
-    @c2 = OpenSSL::Cipher::DES.new(:EDE3, "CBC")
-    @key = "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
-    @iv = "\0\0\0\0\0\0\0\0"
-    @iv1 = "\1\1\1\1\1\1\1\1"
-    @hexkey = "0000000000000000000000000000000000000000000000"
-    @hexiv = "0000000000000000"
-    @data = "DATA"
-  end
-
-  def teardown
-    @c1 = @c2 = nil
-  end
-
-  def test_crypt
-    @c1.encrypt.pkcs5_keyivgen(@key, @iv)
-    @c2.encrypt.pkcs5_keyivgen(@key, @iv)
-    s1 = @c1.update(@data) + @c1.final
-    s2 = @c2.update(@data) + @c2.final
-    assert_equal(s1, s2, "encrypt")
-
-    @c1.decrypt.pkcs5_keyivgen(@key, @iv)
-    @c2.decrypt.pkcs5_keyivgen(@key, @iv)
-    assert_equal(@data, @c1.update(s1)+@c1.final, "decrypt")
-    assert_equal(@data, @c2.update(s2)+@c2.final, "decrypt")
-  end
-
-  def test_info
-    assert_equal("DES-EDE3-CBC", @c1.name, "name")
-    assert_equal("DES-EDE3-CBC", @c2.name, "name")
-    assert_kind_of(Fixnum, @c1.key_len, "key_len")
-    assert_kind_of(Fixnum, @c1.iv_len, "iv_len")
-  end
-
-  def test_dup
-    assert_equal(@c1.name, @c1.dup.name, "dup")
-    assert_equal(@c1.name, @c1.clone.name, "clone")
-    @c1.encrypt
-    @c1.key = @key
-    @c1.iv = @iv
-    tmpc = @c1.dup
-    s1 = @c1.update(@data) + @c1.final
-    s2 = tmpc.update(@data) + tmpc.final
-    assert_equal(s1, s2, "encrypt dup")
-  end
-
-  def test_reset
-    @c1.encrypt
-    @c1.key = @key
-    @c1.iv = @iv
-    s1 = @c1.update(@data) + @c1.final
-    @c1.reset
-    s2 = @c1.update(@data) + @c1.final
-    assert_equal(s1, s2, "encrypt reset")
-  end
-
-  def test_set_iv
-    @c1.encrypt
-    @c1.key = @key
-    @c1.iv = @iv
-    s1 = @c1.update(@data) + @c1.final
-    @c1.iv = @iv1
-    s1 += @c1.update(@data) + @c1.final
-    @c1.reset
-    @c1.iv = @iv
-    s2 = @c1.update(@data) + @c1.final
-    @c1.iv = @iv1
-    s2 += @c1.update(@data) + @c1.final
-    assert_equal(s1, s2, "encrypt reset")
-  end
-
-  def test_empty_data
-    @c1.encrypt
-    assert_raise(ArgumentError){ @c1.update("") }
-  end
-
-  def test_disable_padding(padding=0)
-    # assume a padding size of 8
-    # encrypt the data with padding
-    @c1.encrypt
-    @c1.key = @key
-    @c1.iv = @iv
-    encrypted_data = @c1.update(@data) + @c1.final
-    assert_equal(8, encrypted_data.size)
-    # decrypt with padding disabled
-    @c1.decrypt
-    @c1.padding = padding
-    decrypted_data = @c1.update(encrypted_data) + @c1.final
-    # check that the result contains the padding
-    assert_equal(8, decrypted_data.size)
-    assert_equal(@data, decrypted_data[0...@data.size])
-  end
-
-  if RUBY_PLATFORM =~ /java/
-    # JRuby extension - using Java padding types
-
-    def test_disable_padding_javastyle
-      test_disable_padding('NoPadding')
-    end
-
-    def test_iso10126_padding
-      @c1.encrypt
-      @c1.key = @key
-      @c1.iv = @iv
-      @c1.padding = 'ISO10126Padding'
-      encrypted_data = @c1.update(@data) + @c1.final
-      # decrypt with padding disabled to see the padding
-      @c1.decrypt
-      @c1.padding = 0
-      decrypted_data = @c1.update(encrypted_data) + @c1.final
-      assert_equal(@data, decrypted_data[0...@data.size])
-      # last byte should be the amount of padding
-      assert_equal(4, decrypted_data[-1])
-    end
-
-    def test_iso10126_padding_boundry
-      @data = 'HELODATA' # 8 bytes, same as padding size
-      @c1.encrypt
-      @c1.key = @key
-      @c1.iv = @iv
-      @c1.padding = 'ISO10126Padding'
-      encrypted_data = @c1.update(@data) + @c1.final
-      # decrypt with padding disabled to see the padding
-      @c1.decrypt
-      @c1.padding = 0
-      decrypted_data = @c1.update(encrypted_data) + @c1.final
-      assert_equal(@data, decrypted_data[0...@data.size])
-      # padding should be one whole block
-      assert_equal(8, decrypted_data[-1])
-    end
-  end
-
-  if OpenSSL::OPENSSL_VERSION_NUMBER > 0x00907000
-    def test_ciphers
-      OpenSSL::Cipher.ciphers.each{|name|
-        assert(OpenSSL::Cipher::Cipher.new(name).is_a?(OpenSSL::Cipher::Cipher))
-      }
-    end
-
-    def test_AES
-      pt = File.read(__FILE__)
-      %w(ECB CBC CFB OFB).each{|mode|
-        c1 = OpenSSL::Cipher::AES256.new(mode)
-        c1.encrypt
-        assert_nothing_raised('This test fails w/o Java Cryptography Extension (JCE) Unlimited Strength Jurisdiction Policy Files') do
-          c1.pkcs5_keyivgen("passwd")
-        end
-        ct = c1.update(pt) + c1.final
-
-        c2 = OpenSSL::Cipher::AES256.new(mode)
-        c2.decrypt
-        c2.pkcs5_keyivgen("passwd")
-        assert_equal(pt, c2.update(ct) + c2.final)
-      }
-    end
-  end
-
-  # JRUBY-4028
-  def test_jruby_4028
-    key = "0599E113A7EE32A9"
-    data = "1234567890~5J96LC303C1D22DD~20090930005944~http%3A%2F%2Flocalhost%3A8080%2Flogin%3B0%3B1~http%3A%2F%2Fmix-stage.oracle.com%2F~00"
-    c1 = OpenSSL::Cipher::Cipher.new("DES-CBC")
-    c1.padding = 0
-    c1.iv = "0" * 8
-    c1.encrypt
-    c1.key = key
-    e = c1.update data
-    e << c1.final
-
-    c2 = OpenSSL::Cipher::Cipher.new("DES-CBC")
-    c2.padding = 0
-    c2.iv = "0" * 8
-    c2.decrypt
-    c2.key = key
-    d = c2.update e
-    d << c2.final
-
-    assert_equal "\342\320B.\300&X\310\344\253\025\215\017*\22015\344\024D\342\213\361\336\311\271\326\016\243\214\026\2545\002\237,\017s\202\316&Ew\323\221H\376\200\304\201\365\332Im\240\361\037\246\3536\001A2\341\324o0\350\364%=\325\330\240\324u\225\304h\277\272\361f\024\324\352\336\353N\002/]C\370!\003)\212oa\225\207\333\340\245\207\024\351\037\327[\212\001{\216\f\315\345\372\v\226\r\233?\002\vJK", e
-    assert_equal data, d
-  end
-end
-
-end

data/test/1.8/test_config.rb

@@ -1,290 +0,0 @@
-require 'openssl'
-require "test/unit"
-require 'tempfile'
-require File.join(File.dirname(__FILE__), "utils.rb")
-
-class OpenSSL::TestConfig < Test::Unit::TestCase
-  def setup
-    file = Tempfile.open("openssl.cnf")
-    file << <<__EOD__
-HOME = .
-[ ca ]
-default_ca = CA_default
-[ CA_default ]
-dir = ./demoCA
-certs                =                  ./certs
-__EOD__
-    file.close
-    @it = OpenSSL::Config.new(file.path)
-  end
-
-  def TODO_test_constants
-    assert(defined?(OpenSSL::Config::DEFAULT_CONFIG_FILE))
-    assert_nothing_raised do
-      OpenSSL::Config.load(OpenSSL::Config::DEFAULT_CONFIG_FILE)
-    end
-  end
-
-  def test_s_parse
-    c = OpenSSL::Config.parse('')
-    assert_equal("[ default ]\n\n", c.to_s)
-    c = OpenSSL::Config.parse(@it.to_s)
-    assert_equal(['CA_default', 'ca', 'default'], c.sections.sort)
-  end
-
-  def test_s_parse_format
-    c = OpenSSL::Config.parse(<<__EOC__)
- baz =qx\t                # "baz = qx"
-
-foo::bar = baz            # shortcut section::key format
-  default::bar = baz      # ditto
-a=\t \t                   # "a = ": trailing spaces are ignored
- =b                       # " = b": empty key
- =c                       # " = c": empty key (override the above line)
-    d=                    # "c = ": trailing comment is ignored
-
-sq = 'foo''b\\'ar'
-    dq ="foo""''\\""
-    dq2 = foo""bar
-esc=a\\r\\n\\b\\tb
-foo\\bar = foo\\b\\\\ar
-foo\\bar::foo\\bar = baz
-[default1  default2]\t\t  # space is allowed in section name
-          fo =b  ar       # space allowed in value
-[emptysection]
- [doller ]
-foo=bar
-bar = $(foo)
-baz = 123$(default::bar)456${foo}798
-qux = ${baz}
-quxx = $qux.$qux
-__EOC__
-    assert_equal(['default', 'default1  default2', 'doller', 'emptysection', 'foo', 'foo\\bar'], c.sections.sort)
-    assert_equal(['', 'a', 'bar', 'baz', 'd', 'dq', 'dq2', 'esc', 'foo\\bar', 'sq'], c['default'].keys.sort)
-    assert_equal('c', c['default'][''])
-    assert_equal('', c['default']['a'])
-    assert_equal('qx', c['default']['baz'])
-    assert_equal('', c['default']['d'])
-    assert_equal('baz', c['default']['bar'])
-    assert_equal("foob'ar", c['default']['sq'])
-    assert_equal("foo''\"", c['default']['dq'])
-    assert_equal("foobar", c['default']['dq2'])
-    assert_equal("a\r\n\b\tb", c['default']['esc'])
-    assert_equal("foo\b\\ar", c['default']['foo\\bar'])
-    assert_equal('baz', c['foo']['bar'])
-    assert_equal('baz', c['foo\\bar']['foo\\bar'])
-    assert_equal('b  ar', c['default1  default2']['fo'])
-
-    # dolloer
-    assert_equal('bar', c['doller']['foo'])
-    assert_equal('bar', c['doller']['bar'])
-    assert_equal('123baz456bar798', c['doller']['baz'])
-    assert_equal('123baz456bar798', c['doller']['qux'])
-    assert_equal('123baz456bar798.123baz456bar798', c['doller']['quxx'])
-
-    excn = assert_raise(OpenSSL::ConfigError) do
-      OpenSSL::Config.parse("foo = $bar")
-    end
-    assert_equal("error in line 1: variable has no value", excn.message)
-
-    excn = assert_raise(OpenSSL::ConfigError) do
-      OpenSSL::Config.parse("foo = $(bar")
-    end
-    assert_equal("error in line 1: no close brace", excn.message)
-
-    excn = assert_raise(OpenSSL::ConfigError) do
-      OpenSSL::Config.parse("f o =b  ar      # no space in key")
-    end
-    assert_equal("error in line 1: missing equal sign", excn.message)
-
-    excn = assert_raise(OpenSSL::ConfigError) do
-      OpenSSL::Config.parse(<<__EOC__)
-# comment 1               # comments
-
-#
- # comment 2
-\t#comment 3
-  [second    ]\t
-[third                    # section not terminated
-__EOC__
-    end
-    assert_equal("error in line 7: missing close square bracket", excn.message)
-  end
-
-  def test_s_load
-    # alias of new
-    c = OpenSSL::Config.load
-    assert_equal("", c.to_s)
-    assert_equal([], c.sections)
-    #
-    file = Tempfile.open("openssl.cnf")
-    file.close
-    c = OpenSSL::Config.load(file.path)
-    assert_equal("[ default ]\n\n", c.to_s)
-    assert_equal(['default'], c.sections)
-  end
-
-  def test_initialize
-    c = OpenSSL::Config.new
-    assert_equal("", c.to_s)
-    assert_equal([], c.sections)
-  end
-
-  def test_initialize_with_empty_file
-    file = Tempfile.open("openssl.cnf")
-    file.close
-    c = OpenSSL::Config.new(file.path)
-    assert_equal("[ default ]\n\n", c.to_s)
-    assert_equal(['default'], c.sections)
-  end
-
-  def test_initialize_with_example_file
-    assert_equal(['CA_default', 'ca', 'default'], @it.sections.sort)
-  end
-
-  def test_get_value
-    assert_equal('CA_default', @it.get_value('ca', 'default_ca'))
-    assert_equal(nil, @it.get_value('ca', 'no such key'))
-    assert_equal(nil, @it.get_value('no such section', 'no such key'))
-    assert_equal('.', @it.get_value('', 'HOME'))
-    assert_raise(TypeError) do
-      @it.get_value(nil, 'HOME') # not allowed unlike Config#value
-    end
-    # fallback to 'default' ugly...
-    assert_equal('.', @it.get_value('unknown', 'HOME'))
-  end
-
-  def test_get_value_ENV
-    key = ENV.keys.first
-    assert_not_nil(key) # make sure we have at least one ENV var.
-    assert_equal(ENV[key], @it.get_value('ENV', key))
-  end
-
-  def test_value
-    # supress deprecation warnings
-    OpenSSL::TestUtils.silent do
-      assert_equal('CA_default', @it.value('ca', 'default_ca'))
-      assert_equal(nil, @it.value('ca', 'no such key'))
-      assert_equal(nil, @it.value('no such section', 'no such key'))
-      assert_equal('.', @it.value('', 'HOME'))
-      assert_equal('.', @it.value(nil, 'HOME'))
-      assert_equal('.', @it.value('HOME'))
-      # fallback to 'default' ugly...
-      assert_equal('.', @it.value('unknown', 'HOME'))
-    end
-  end
-
-  def test_value_ENV
-    OpenSSL::TestUtils.silent do
-      key = ENV.keys.first
-      assert_not_nil(key) # make sure we have at least one ENV var.
-      assert_equal(ENV[key], @it.value('ENV', key))
-    end
-  end
-
-  def test_aref
-    assert_equal({'HOME' => '.'}, @it['default'])
-    assert_equal({'dir' => './demoCA', 'certs' => './certs'}, @it['CA_default'])
-    assert_equal({}, @it['no_such_section'])
-    assert_equal({}, @it[''])
-  end
-
-  def test_section
-    OpenSSL::TestUtils.silent do
-      assert_equal({'HOME' => '.'}, @it.section('default'))
-      assert_equal({'dir' => './demoCA', 'certs' => './certs'}, @it.section('CA_default'))
-      assert_equal({}, @it.section('no_such_section'))
-      assert_equal({}, @it.section(''))
-    end
-  end
-
-  def test_sections
-    assert_equal(['CA_default', 'ca', 'default'], @it.sections.sort)
-    @it['new_section'] = {'foo' => 'bar'}
-    assert_equal(['CA_default', 'ca', 'default', 'new_section'], @it.sections.sort)
-    @it['new_section'] = {}
-    assert_equal(['CA_default', 'ca', 'default', 'new_section'], @it.sections.sort)
-  end
-
-  def test_add_value
-    c = OpenSSL::Config.new
-    assert_equal("", c.to_s)
-    # add key
-    c.add_value('default', 'foo', 'bar')
-    assert_equal("[ default ]\nfoo=bar\n\n", c.to_s)
-    # add another key
-    c.add_value('default', 'baz', 'qux')
-    assert_equal('bar', c['default']['foo'])
-    assert_equal('qux', c['default']['baz'])
-    # update the value
-    c.add_value('default', 'baz', 'quxxx')
-    assert_equal('bar', c['default']['foo'])
-    assert_equal('quxxx', c['default']['baz'])
-    # add section and key
-    c.add_value('section', 'foo', 'bar')
-    assert_equal('bar', c['default']['foo'])
-    assert_equal('quxxx', c['default']['baz'])
-    assert_equal('bar', c['section']['foo'])
-  end
-
-  def test_aset
-    @it['foo'] = {'bar' => 'baz'}
-    assert_equal({'bar' => 'baz'}, @it['foo'])
-    @it['foo'] = {'bar' => 'qux', 'baz' => 'quxx'}
-    assert_equal({'bar' => 'qux', 'baz' => 'quxx'}, @it['foo'])
-
-    # OpenSSL::Config is add only for now.
-    @it['foo'] = {'foo' => 'foo'}
-    assert_equal({'foo' => 'foo', 'bar' => 'qux', 'baz' => 'quxx'}, @it['foo'])
-    # you cannot override or remove any section and key.
-    @it['foo'] = {}
-    assert_equal({'foo' => 'foo', 'bar' => 'qux', 'baz' => 'quxx'}, @it['foo'])
-  end
-
-  def test_each
-    # each returns [section, key, value] array.
-    ary = @it.map { |e| e }.sort { |a, b| a[0] <=> b[0] }
-    assert_equal(4, ary.size)
-    assert_equal('CA_default', ary[0][0])
-    assert_equal('CA_default', ary[1][0])
-    assert_equal(["ca", "default_ca", "CA_default"], ary[2])
-    assert_equal(["default", "HOME", "."], ary[3])
-  end
-
-  def test_to_s
-    c = OpenSSL::Config.parse("[empty]\n")
-    assert_equal("[ default ]\n\n[ empty ]\n\n", c.to_s)
-  end
-
-  def test_inspect
-    assert_match(/#<OpenSSL::Config sections=\[.*\]>/, @it.inspect)
-  end
-
-  def test_freeze
-    c = OpenSSL::Config.new
-    c['foo'] = [['key', 'value']]
-    c.freeze
-
-    # [ruby-core:18377]
-    # RuntimeError for 1.9, TypeError for 1.8
-    assert_raise(TypeError, /frozen/) do
-      c['foo'] = [['key', 'wrong']]
-    end
-  end
-
-  def test_dup
-    assert(!@it.sections.empty?)
-    c = @it.dup
-    assert_equal(@it.sections.sort, c.sections.sort)
-    @it['newsection'] = {'a' => 'b'}
-    assert_not_equal(@it.sections.sort, c.sections.sort)
-  end
-
-  def test_clone
-    assert(!@it.sections.empty?)
-    c = @it.clone
-    assert_equal(@it.sections.sort, c.sections.sort)
-    @it['newsection'] = {'a' => 'b'}
-    assert_not_equal(@it.sections.sort, c.sections.sort)
-  end
-end