jruby-openssl 0.8.0.pre3 → 0.8.0

data/test/test_all.rb

@@ -1 +0,0 @@
-Dir.glob("test/test_*.rb").sort.reject{|t| t =~ /test_all/}.each {|t| require t }

data/test/test_certificate.rb

@@ -1,132 +0,0 @@
-require 'openssl'
-require "test/unit"
-
-class TestCertificate < Test::Unit::TestCase
-  def setup
-    cert_file = File.expand_path('fixture/selfcert.pem', File.dirname(__FILE__))
-    key_file = File.expand_path('fixture/keypair.pem', File.dirname(__FILE__))
-    @cert = OpenSSL::X509::Certificate.new(File.read(cert_file))
-    @key = OpenSSL::PKey::RSA.new(File.read(key_file))
-  end
-
-  def test_sign_for_pem_initialized_certificate
-    pem = @cert.to_pem
-    exts = @cert.extensions
-    assert_nothing_raised do
-      @cert.sign(@key, OpenSSL::Digest::SHA1.new)
-    end
-    # TODO: for now, jruby-openssl cannot keep order of extensions after sign.
-    # assert_equal(pem, @cert.to_pem)
-    assert_equal(exts.size, @cert.extensions.size)
-    exts.each do |ext|
-      found = @cert.extensions.find { |e| e.oid == ext.oid }
-      assert_not_nil(found)
-      assert_equal(ext.value, found.value)
-    end
-  end
-
-  def test_set_public_key
-    pkey = @cert.public_key
-    newkey = OpenSSL::PKey::RSA.new(1024)
-    @cert.public_key = newkey
-    assert_equal(newkey.public_key.to_pem, @cert.public_key.to_pem)
-  end
-
-  # JRUBY-3468
-  def test_jruby3468
-    pem_cert = <<END
------BEGIN CERTIFICATE-----
-MIIC/jCCAmegAwIBAgIBATANBgkqhkiG9w0BAQUFADBNMQswCQYDVQQGEwJKUDER
-MA8GA1UECgwIY3Rvci5vcmcxFDASBgNVBAsMC0RldmVsb3BtZW50MRUwEwYDVQQD
-DAxodHRwLWFjY2VzczIwHhcNMDcwOTExMTM1ODMxWhcNMDkwOTEwMTM1ODMxWjBN
-MQswCQYDVQQGEwJKUDERMA8GA1UECgwIY3Rvci5vcmcxFDASBgNVBAsMC0RldmVs
-b3BtZW50MRUwEwYDVQQDDAxodHRwLWFjY2VzczIwgZ8wDQYJKoZIhvcNAQEBBQAD
-gY0AMIGJAoGBALi66ujWtUCQm5HpMSyr/AAIFYVXC/dmn7C8TR/HMiUuW3waY4uX
-LFqCDAGOX4gf177pX+b99t3mpaiAjJuqc858D9xEECzhDWgXdLbhRqWhUOble4RY
-c1yWYC990IgXJDMKx7VAuZ3cBhdBxtlE9sb1ZCzmHQsvTy/OoRzcJCrTAgMBAAGj
-ge0wgeowDwYDVR0TAQH/BAUwAwEB/zAxBglghkgBhvhCAQ0EJBYiUnVieS9PcGVu
-U1NMIEdlbmVyYXRlZCBDZXJ0aWZpY2F0ZTAdBgNVHQ4EFgQUJNE0GGaRKmN2qhnO
-FyBWVl4Qj6owDgYDVR0PAQH/BAQDAgEGMHUGA1UdIwRuMGyAFCTRNBhmkSpjdqoZ
-zhcgVlZeEI+qoVGkTzBNMQswCQYDVQQGEwJKUDERMA8GA1UECgwIY3Rvci5vcmcx
-FDASBgNVBAsMC0RldmVsb3BtZW50MRUwEwYDVQQDDAxodHRwLWFjY2VzczKCAQEw
-DQYJKoZIhvcNAQEFBQADgYEAH11tstSUuqFpMqoh/vM5l3Nqb8ygblbqEYQs/iG/
-UeQkOZk/P1TxB6Ozn2htJ1srqDpUsncFVZ/ecP19GkeOZ6BmIhppcHhE5WyLBcPX
-It5q1BW0PiAzT9LlEGoaiW0nw39so0Pr1whJDfc1t4fjdk+kSiMIzRHbTDvHWfpV
-nTA=
------END CERTIFICATE-----
-END
-
-    cert   = OpenSSL::X509::Certificate.new(pem_cert)
-    cert.extensions.each do |ext|
-      value = ext.value
-      crit = ext.critical?
-      case ext.oid
-      when "keyUsage"
-        assert_equal true, crit
-        assert_equal "Key Cert Sign, cRLSign", value
-      when "basicConstraints"
-        assert_equal true, crit
-        assert_equal "CA:TRUE", value
-      when "authorityKeyIdentifier"
-        assert_equal false, crit
-        assert_equal "keyid:80:14:24:D1:34:18:66:91:2A:63:76:AA:19:CE:17:20:56:56:5E:10:8F:AA", value
-      when "subjectKeyIdentifier"
-        assert_equal false, crit
-        assert_equal "24:D1:34:18:66:91:2A:63:76:AA:19:CE:17:20:56:56:5E:10:8F:AA", value
-      when "nsComment"
-        assert_equal false, crit
-        assert_equal "Ruby/OpenSSL Generated Certificate", value
-      end
-    end
-  end
-
-  # JRUBY-5060
-  def test_to_pem_with_empty_object
-    empty_cert = "MCUwGwIAMAMGAQAwADAEHwAfADAAMAgwAwYBAAMBADADBgEAAwEA"
-    empty_req = "MBowEAIAMAAwCDADBgEAAwEAoAAwAwYBAAMBAA=="
-    empty_crl = "MBMwCTADBgEAMAAfADADBgEAAwEA"
-    empty_key = "MAA="
-    #assert_equal(empty_cert, OpenSSL::X509::Certificate.new.to_pem.split("\n")[1])
-    #assert_equal(empty_req, OpenSSL::X509::Request.new.to_pem.split("\n")[1])
-    #assert_equal(empty_crl, OpenSSL::X509::CRL.new.to_pem.split("\n")[1])
-    assert_nothing_raised do
-      OpenSSL::X509::Certificate.new.to_pem
-    end
-    assert_nothing_raised do
-      OpenSSL::X509::Request.new.to_pem
-    end
-    assert_nothing_raised do
-      OpenSSL::X509::CRL.new.to_pem
-    end
-    assert_equal(empty_key, OpenSSL::PKey::RSA.new.to_pem.split("\n")[1].chomp)
-    assert_equal(empty_key, OpenSSL::PKey::DSA.new.to_pem.split("\n")[1].chomp)
-    assert_equal(empty_key, OpenSSL::PKey::DH.new.to_pem.split("\n")[1].chomp)
-  end
-
-  # JRUBY-5096
-  def test_verify_failed_by_lazy_public_key_initialization
-    msg = 'hello,world'
-    digester = OpenSSL::Digest::SHA1.new
-    sig = @key.sign(digester, msg)
-    assert(@cert.public_key.verify(digester, sig, msg))
-    assert(@cert.verify(@cert.public_key))
-  end
-
-  # JRUBY-5253
-  def test_load_key_and_cert_in_one_file
-    file = File.read(File.expand_path('fixture/key_then_cert.pem', File.dirname(__FILE__)))
-    cert = OpenSSL::X509::Certificate.new(file)
-    key = OpenSSL::PKey::RSA.new(file)
-    assert_equal("Tue Dec  7 04:34:54 2010", cert.not_before.asctime)
-    assert_equal(155138628173305760586484923990788939560020632428367464748448028799529480209574373402763304069949574437177088605664104864141770364385183263453740781162330879666907894314877641447552442838727890327086630369910941911916802731723019019303432276515402934176273116832204529025371212188573318159421452591783377914839, key.n)
-  end
-
-  # JRUBY-5834
-  def test_ids_in_subject_rdn_set
-    cert_file = File.expand_path('fixture/ids_in_subject_rdn_set.pem', File.dirname(__FILE__))
-    cert = OpenSSL::X509::Certificate.new(File.read(cert_file))
-    keys = cert.subject.to_a.map { |k, v| k }.sort
-    assert_equal(10, keys.size)
-    assert_equal(true, keys.include?("CN"))
-  end
-end

data/test/test_cipher.rb

@@ -1,197 +0,0 @@
-begin
-  require "openssl"
-rescue LoadError
-end
-
-require "test/unit"
-
-class TestCipher < Test::Unit::TestCase
-  def test_keylen
-    cipher = OpenSSL::Cipher::Cipher.new('DES-EDE3-CBC')
-    # must be 24 but it returns 16 on JRE6 without unlimited jurisdiction
-    # policy. it returns 24 on JRE6 with the unlimited policy.
-    assert_equal(24, cipher.key_len)
-  end
-
-  def test_encrypt_takes_parameter
-    enc = OpenSSL::Cipher::Cipher.new('DES-EDE3-CBC')
-    enc.encrypt("123")
-    data = enc.update("password")
-    data << enc.final
-  end
-
-  IV_TEMPLATE  = "aaaabbbbccccddddeeeeffffgggghhhhiiiijjjjj"
-  KEY_TEMPLATE = "aaaabbbbccccddddeeeeffffgggghhhhiiiijjjjj"
-
-  # JRUBY-1692
-  def test_repeated_des
-    do_repeated_test(
-                     "des-ede3-cbc",
-                     "foobarbazboofarf",
-                     ":\022Q\211ex\370\332\374\274\214\356\301\260V\025",
-                     "B\242\3531\003\362\3759\363s\203\374\240\030|\230"
-                     )
-  end
-
-  # JRUBY-1692
-  def test_repeated_aes
-    do_repeated_test(
-                     "aes-128-cbc",
-                     "foobarbazboofarf",
-                     "\342\260Y\344\306\227\004^\272|/\323<\016,\226",
-                     "jqO\305/\211\216\b\373\300\274\bw\213]\310"
-                     )
-  end
-
-  def test_rc2
-    do_repeated_test(
-                     "RC2",
-                     "foobarbazboofarf",
-                     "\x18imZ\x9Ed\x15\xF3\xD6\xE6M\xCDf\xAA\xD3\xFE",
-		     "\xEF\xF7\x16\x06\x93)-##\xB2~\xAD,\xAD\x82\xF5"
-		    )
-  end
-
-  def test_rc4
-    do_repeated_test(
-                     "RC4",
-                     "foobarbazboofarf",
-                     "/i|\257\336U\354\331\212\304E\021\246\351\235\303",
-                     "\020\367\370\316\212\262\266e\242\333\263\305z\340\204\200"
-		    )
-  end
-
-  def test_cast
-    do_repeated_test(
-                     "cast-cbc",
-                     "foobarbazboofarf",
-                     "`m^\225\277\307\247m`{\f\020fl\ry",
-                     "(\354\265\251,D\016\037\251\250V\207\367\214\276B"
-		    )
-  end
-
-  # JRUBY-4326 (1)
-  def test_cipher_unsupported_algorithm
-    assert_raise(OpenSSL::Cipher::CipherError) do
-      cipher = OpenSSL::Cipher::Cipher.new('aes-xxxxxxx')
-    end
-  end
-
-  # JRUBY-4326 (2)
-  def test_cipher_unsupported_keylen
-    bits_128 = java.lang.String.new("0123456789ABCDEF").getBytes()
-    bits_256 = java.lang.String.new("0123456789ABCDEF0123456789ABCDEF").getBytes()
-
-    # AES128 is allowed
-    cipher = OpenSSL::Cipher::Cipher.new('aes-128-cbc')
-    cipher = OpenSSL::Cipher::Cipher.new('AES-128-CBC')
-    cipher = javax.crypto.Cipher.getInstance("AES/CBC/PKCS5Padding")
-    key_spec = javax.crypto.spec.SecretKeySpec.new(bits_128, "AES")
-    iv_spec = javax.crypto.spec.IvParameterSpec.new(bits_128)
-    assert_nothing_raised do
-      cipher.init(javax.crypto.Cipher::ENCRYPT_MODE, key_spec, iv_spec)
-    end
-
-    # check if AES256 is allowed or not in env policy
-    cipher = javax.crypto.Cipher.getInstance("AES/CBC/PKCS5Padding")
-    key_spec = javax.crypto.spec.SecretKeySpec.new(bits_256, "AES")
-    allowed = false
-    begin
-      cipher.init(javax.crypto.Cipher::ENCRYPT_MODE, key_spec, iv_spec)
-      allowed = true
-    rescue
-    end
-
-    # jruby-openssl should raise as well?
-    # CRuby's openssl raises exception at initialization time.
-    # At this time, jruby-openssl raises later. TODO
-    cipher = OpenSSL::Cipher::Cipher.new('aes-256-cbc')
-    cipher.encrypt
-    cipher.padding = 0
-    if allowed
-      assert_nothing_raised(OpenSSL::Cipher::CipherError) do
-        cipher.pkcs5_keyivgen("password")
-      end
-    else
-      assert_raise(OpenSSL::Cipher::CipherError) do
-        cipher.pkcs5_keyivgen("password")
-      end
-    end
-  end
-
-  def test_iv_length_auto_trim_JRUBY_4012
-    e1 = e2 = nil
-    plain = 'data'
-    des = OpenSSL::Cipher::Cipher.new("des-ede3-cbc")
-    des.encrypt
-    des.key = '0123456789abcdef01234567890'
-    des.iv = "0" * (128/8) # too long for DES which is a 64 bit block
-    assert_nothing_raised do
-      e1 = des.update(plain) + des.final  
-    end
-    des = OpenSSL::Cipher::Cipher.new("des-ede3-cbc")
-    des.encrypt
-    des.key = '0123456789abcdef01234567890'
-    des.iv = "0" * (64/8) # DES is a 64 bit block
-    e2 = des.update(plain) + des.final  
-    assert_equal(e2, e1, "JRUBY-4012")
-  end
-
-  # JRUBY-5125
-  def test_rc4_cipher_name
-    assert_equal("RC4", OpenSSL::Cipher::Cipher.new("rc4").name)
-  end
-
-  # JRUBY-5126
-  def test_stream_cipher_reset_should_be_ignored
-    c1 = "%E\x96\xDAZ\xEF\xB2$/\x9F\x02"
-    c2 = ">aV\xB0\xE1l\xF3oyL\x9B"
-    #
-    cipher = OpenSSL::Cipher::Cipher.new("RC4")
-    cipher.encrypt
-    cipher.key = "\0\1\2\3" * (128/8/4)
-    str = cipher.update('hello,world')
-    str += cipher.final
-    assert_equal(c1, str)
-    #
-    cipher.reset
-    cipher.iv = "\0" * 16
-    str = cipher.update('hello,world')
-    str += cipher.final
-    assert_equal(c2, str) # was equal to c1 before the fix
-  end
-
-  private
-  def do_repeated_test(algo, string, enc1, enc2)
-    do_repeated_encrypt_test(algo, string, enc1, enc2)
-    do_repeated_decrypt_test(algo, string, enc1, enc2)
-  end
-  
-  def do_repeated_encrypt_test(algo, string, result1, result2)
-    cipher = OpenSSL::Cipher::Cipher.new(algo)
-    cipher.encrypt
-
-    cipher.padding = 0
-    cipher.iv      = IV_TEMPLATE[0, cipher.iv_len]
-    cipher.key     = KEY_TEMPLATE[0, cipher.key_len]
-
-    assert_equal result1, cipher.update(string)
-    assert_equal "", cipher.final
-
-    assert_equal result2, cipher.update(string) + cipher.final
-  end
-
-  def do_repeated_decrypt_test(algo, result, string1, string2)
-    cipher = OpenSSL::Cipher::Cipher.new(algo)
-    cipher.decrypt
-
-    cipher.padding = 0
-    cipher.iv      = IV_TEMPLATE[0, cipher.iv_len]
-    cipher.key     = KEY_TEMPLATE[0, cipher.key_len]
-
-    assert_equal result, cipher.update(string1)
-    assert_equal "", cipher.final
-
-    assert_equal result, cipher.update(string2) + cipher.final
-  end
-end

data/test/test_imaps.rb

@@ -1,107 +0,0 @@
-require "net/imap"
-require "test/unit"
-
-# This testcase is made for 1.8 based on test_imap.rb in CRuby 1.9
-class IMAPTest < Test::Unit::TestCase
-  CA_FILE = File.expand_path("fixture/imaps/cacert.pem", File.dirname(__FILE__))
-  SERVER_KEY = File.expand_path("fixture/imaps/server.key", File.dirname(__FILE__))
-  SERVER_CERT = File.expand_path("fixture/imaps/server.crt", File.dirname(__FILE__))
-
-  SERVER_ADDR = "127.0.0.1"
-
-  def setup
-    @do_not_reverse_lookup = Socket.do_not_reverse_lookup
-    Socket.do_not_reverse_lookup = true
-  end
-
-  def teardown
-    Socket.do_not_reverse_lookup = @do_not_reverse_lookup
-  end
-
-  def test_imaps_unknown_ca
-    assert_raise(OpenSSL::SSL::SSLError) do
-      imaps_test do |port|
-        Net::IMAP.new("localhost", port, true, nil, true)
-      end
-    end
-  end
-
-  def test_imaps_with_ca_file
-    assert_nothing_raised do
-      imaps_test do |port|
-        Net::IMAP.new("localhost", port, true, CA_FILE, true)
-      end
-    end
-  end
-
-  def test_imaps_login
-    assert_raises(Net::IMAP::ByeResponseError) do
-      imaps_test do |port|
-        imaps = Net::IMAP.new("localhost", port, true, CA_FILE, true)
-        imaps.login('foo@bar.com', 'wrong password')
-        imaps
-      end
-    end
-  end
-
-  def test_imaps_verify_none
-    assert_nothing_raised do
-      imaps_test do |port|
-        Net::IMAP.new(SERVER_ADDR, port, true, nil, false)
-      end
-    end
-  end
-
-  def test_imaps_post_connection_check
-    assert_raise(OpenSSL::SSL::SSLError) do
-      imaps_test do |port|
-        # SERVER_ADDR is different from the hostname in the certificate,
-        # so the following code should raise a SSLError.
-        Net::IMAP.new(SERVER_ADDR, port, true, CA_FILE, true)
-      end
-    end
-  end
-
-private
-
-  def imaps_test
-    server = create_tcp_server
-    port = server.addr[1]
-    ctx = OpenSSL::SSL::SSLContext.new
-    ctx.ca_file = CA_FILE
-    ctx.key = OpenSSL::PKey::RSA.new(File.read(SERVER_KEY))
-    ctx.cert = OpenSSL::X509::Certificate.new(File.read(SERVER_CERT))
-    ssl_server = OpenSSL::SSL::SSLServer.new(server, ctx)
-    Thread.start do
-      begin
-        sock = ssl_server.accept
-        begin
-          sock.print("* OK test server\r\n")
-          sock.read(10) # emulates half-read for JRUBY-5200
-          sock.print("* BYE terminating connection\r\n")
-          sock.print("RUBY0001 OK LOGOUT completed\r\n")
-          sock.gets
-        ensure
-          sock.close
-        end
-      rescue
-      end
-    end
-    begin
-      begin
-        imap = yield(port)
-        imap.logout if !imap.disconnected?
-      ensure
-        imap.disconnect if imap && !imap.disconnected?
-      end
-    rescue IOError
-      # ignore
-    ensure
-      ssl_server.close
-    end
-  end
-
-  def create_tcp_server
-    return TCPServer.new(SERVER_ADDR, 0)
-  end
-end

data/test/test_integration.rb

@@ -1,144 +0,0 @@
-begin
-  require "openssl"
-rescue LoadError
-end
-require "test/unit"
-require 'net/https'
-
-class TestIntegration < Test::Unit::TestCase
-  def path(file)
-    File.expand_path(file, File.dirname(__FILE__))
-  end
-
-  # JRUBY-2471
-  def _test_drb
-    config = {
-      :SSLVerifyMode => OpenSSL::SSL::VERIFY_PEER,
-      :SSLCACertificateFile => File.join(File.dirname(__FILE__), "fixture", "cacert.pem"),
-      :SSLPrivateKey => OpenSSL::PKey::RSA.new(File.read(File.join(File.dirname(__FILE__), "fixture", "localhost_keypair.pem"))),
-      :SSLCertificate => OpenSSL::X509::Certificate.new(File.read(File.join(File.dirname(__FILE__), "fixture", "cert_localhost.pem"))),
-    }
-    p config
-    DRb.start_service(nil, nil, config)
-  end
-
-  # JRUBY-2913
-  # Warning - this test actually uses the internet connection.
-  # If there is no connection, it will fail.
-  def test_ca_path_name
-    uri = URI.parse('https://www.amazon.com')
-    http = Net::HTTP.new(uri.host, uri.port)
-    http.verify_mode = OpenSSL::SSL::VERIFY_PEER
-    http.ca_path = path("fixture/ca_path/")
-    http.use_ssl = true
-    response = http.start do |s|
-      assert s.get(uri.request_uri).length > 0
-    end
-  end
-
-  # Warning - this test actually uses the internet connection.
-  # If there is no connection, it will fail.
-  def test_ssl_verify
-    uri = URI.parse('https://www.amazon.com/')
-    http = Net::HTTP.new(uri.host, uri.port)
-    http.use_ssl = true
-    http.verify_mode = OpenSSL::SSL::VERIFY_PEER
-    # right trust anchor for www.amazon.com
-    http.ca_file = path('fixture/verisign.pem')
-    response = http.start do |s|
-      assert s.get(uri.request_uri).length > 0
-    end
-    # wrong trust anchor for www.amazon.com
-    http = Net::HTTP.new(uri.host, uri.port)
-    http.use_ssl = true
-    http.verify_mode = OpenSSL::SSL::VERIFY_PEER
-    http.ca_file = path('fixture/verisign_c3.pem')
-    assert_raise(OpenSSL::SSL::SSLError) do
-      # it must cause SSLError for verification failure.
-      response = http.start do |s|
-        s.get(uri.request_uri)
-      end
-    end
-    # round trip
-    http = Net::HTTP.new(uri.host, uri.port)
-    http.use_ssl = true
-    http.verify_mode = OpenSSL::SSL::VERIFY_PEER
-    http.ca_file = path('fixture/verisign.pem')
-    response = http.start do |s|
-      assert s.get(uri.request_uri).length > 0
-    end
-  end
-
-  # Warning - this test actually uses the internet connection.
-  # If there is no connection, it will fail.
-  def test_pathlen_does_not_appear
-    uri = URI.parse('https://www.paypal.com/')
-    http = Net::HTTP.new(uri.host, uri.port)
-    http.use_ssl = true
-    http.verify_mode = OpenSSL::SSL::VERIFY_PEER
-    # right trust anchor for www.amazon.com
-    http.ca_file = path('fixture/verisign_c3.pem')
-    response = http.start do |s|
-      assert s.get(uri.request_uri).length > 0
-    end
-  end
-
-  # JRUBY-2178 and JRUBY-1307
-  # Warning - this test actually uses the internet connection.
-  # If there is no connection, it will fail.
-  # This test generally throws an exception
-  # about illegal_parameter when
-  # it can't use the cipher string correctly
-  def test_cipher_strings
-    socket = TCPSocket.new('rubyforge.org', 443)
-    ctx = OpenSSL::SSL::SSLContext.new
-    ctx.cert_store = OpenSSL::X509::Store.new
-    ctx.verify_mode = 0
-    ctx.cert = nil
-    ctx.key = nil
-    ctx.client_ca = nil
-    ctx.ciphers = "ALL:!ADH:!LOW:!EXP:!MD5:@STRENGTH"
-
-    ssl_socket = OpenSSL::SSL::SSLSocket.new(socket, ctx)
-    ssl_socket.connect
-    ssl_socket.close
-  end
-
-  # JRUBY-1194
-  def test_des_encryption
-    iv  = "IVIVIVIV"
-    key = "KEYKEYKE"
-    alg = "des"
-    str = "string abc foo bar baxz"
-        
-    cipher = OpenSSL::Cipher::Cipher.new(alg)
-    cipher.encrypt
-    cipher.key = key
-    cipher.iv = iv
-    cipher.padding = 32
-    cipher.key = key
-    cipher.iv = iv
-    
-    encrypted = cipher.update(str)
-    encrypted << cipher.final
- 
-    assert_equal "\253\305\306\372;\374\235\302\357/\006\360\355XO\232\312S\356* #\227\217", encrypted
-  end
-  
-  def _test_perf_of_nil
-# require 'net/https'
-# require 'benchmark'
-
-# def request(data)
-#   connection = Net::HTTP.new("www.google.com", 443)
-#   connection.use_ssl = true
-#   connection.verify_mode = OpenSSL::SSL::VERIFY_NONE
-#   connection.start do |connection|
-#     connection.request_post("/tbproxy/spell?lang=en", data, { 'User-Agent' => "Test", 'Accept' => 'text/xml' })
-#   end
-# end
-
-# puts "is not: #{Benchmark.measure { request("") }.to_s.chomp}"
-# puts "is nil: #{Benchmark.measure { request(nil) }.to_s.chomp}"
-  end
-end