test: fix formatting

Fix wrong nesting in test/utils.rb. Remove unnecessary requires. Wrap
the code with 'if defined?(OpenSSL::TestUtils) ~ end' and avoid class
definition with modifier if.

1 files changed, 148 insertions, 147 deletions

diff --git a/test/utils.rb b/test/utils.rb
index 4a7d4faa..6da02f69 100644
--- a/test/utils.rb
+++ b/test/utils.rb
@@ -30,11 +30,12 @@ if ENV["OSSL_MDEBUG"] == "1"
 end
 
 require "test/unit"
-require 'tempfile'
-require "rbconfig"
+require "tempfile"
 require "socket"
 require "envutil"
 
+if defined?(OpenSSL) && OpenSSL::OPENSSL_VERSION_NUMBER >= 0x10000000
+
 module OpenSSL::TestUtils
   module Fixtures
     module_function
@@ -130,177 +131,177 @@ module OpenSSL::TestUtils
       $VERBOSE = back
     end
   end
+end
 
-  class OpenSSL::TestCase < Test::Unit::TestCase
-    include OpenSSL::TestUtils
-    extend OpenSSL::TestUtils
+class OpenSSL::TestCase < Test::Unit::TestCase
+  include OpenSSL::TestUtils
+  extend OpenSSL::TestUtils
 
-    def setup
-      if ENV["OSSL_GC_STRESS"] == "1"
-        GC.stress = true
-      end
+  def setup
+    if ENV["OSSL_GC_STRESS"] == "1"
+      GC.stress = true
     end
+  end
 
-    def teardown
-      if ENV["OSSL_GC_STRESS"] == "1"
-        GC.stress = false
-      end
-      # OpenSSL error stack must be empty
-      assert_equal([], OpenSSL.errors)
+  def teardown
+    if ENV["OSSL_GC_STRESS"] == "1"
+      GC.stress = false
     end
+    # OpenSSL error stack must be empty
+    assert_equal([], OpenSSL.errors)
   end
+end
 
-  class OpenSSL::SSLTestCase < OpenSSL::TestCase
-    RUBY = EnvUtil.rubybin
-    ITERATIONS = ($0 == __FILE__) ? 100 : 10
-
-    def setup
-      super
-      @ca_key  = Fixtures.pkey("rsa2048")
-      @svr_key = Fixtures.pkey("rsa1024")
-      @cli_key = Fixtures.pkey("dsa1024")
-      @ca  = OpenSSL::X509::Name.parse("/DC=org/DC=ruby-lang/CN=CA")
-      @svr = OpenSSL::X509::Name.parse("/DC=org/DC=ruby-lang/CN=localhost")
-      @cli = OpenSSL::X509::Name.parse("/DC=org/DC=ruby-lang/CN=localhost")
-      ca_exts = [
-        ["basicConstraints","CA:TRUE",true],
-        ["keyUsage","cRLSign,keyCertSign",true],
-      ]
-      ee_exts = [
-        ["keyUsage","keyEncipherment,digitalSignature",true],
-      ]
-      @ca_cert  = issue_cert(@ca, @ca_key, 1, ca_exts, nil, nil)
-      @svr_cert = issue_cert(@svr, @svr_key, 2, ee_exts, @ca_cert, @ca_key)
-      @cli_cert = issue_cert(@cli, @cli_key, 3, ee_exts, @ca_cert, @ca_key)
-      @server = nil
-    end
+class OpenSSL::SSLTestCase < OpenSSL::TestCase
+  RUBY = EnvUtil.rubybin
+  ITERATIONS = ($0 == __FILE__) ? 100 : 10
 
-    def readwrite_loop(ctx, ssl)
-      while line = ssl.gets
-        ssl.write(line)
-      end
-    rescue OpenSSL::SSL::SSLError
-    rescue IOError
-    ensure
-      ssl.close rescue nil
+  def setup
+    super
+    @ca_key  = Fixtures.pkey("rsa2048")
+    @svr_key = Fixtures.pkey("rsa1024")
+    @cli_key = Fixtures.pkey("dsa1024")
+    @ca  = OpenSSL::X509::Name.parse("/DC=org/DC=ruby-lang/CN=CA")
+    @svr = OpenSSL::X509::Name.parse("/DC=org/DC=ruby-lang/CN=localhost")
+    @cli = OpenSSL::X509::Name.parse("/DC=org/DC=ruby-lang/CN=localhost")
+    ca_exts = [
+      ["basicConstraints","CA:TRUE",true],
+      ["keyUsage","cRLSign,keyCertSign",true],
+    ]
+    ee_exts = [
+      ["keyUsage","keyEncipherment,digitalSignature",true],
+    ]
+    @ca_cert  = issue_cert(@ca, @ca_key, 1, ca_exts, nil, nil)
+    @svr_cert = issue_cert(@svr, @svr_key, 2, ee_exts, @ca_cert, @ca_key)
+    @cli_cert = issue_cert(@cli, @cli_key, 3, ee_exts, @ca_cert, @ca_key)
+    @server = nil
+  end
+
+  def readwrite_loop(ctx, ssl)
+    while line = ssl.gets
+      ssl.write(line)
     end
+  rescue OpenSSL::SSL::SSLError
+  rescue IOError
+  ensure
+    ssl.close rescue nil
+  end
 
-    def server_loop(ctx, ssls, stop_pipe_r, ignore_listener_error, server_proc, threads)
-      loop do
-        ssl = nil
-        begin
-          readable, = IO.select([ssls, stop_pipe_r])
-          if readable.include? stop_pipe_r
-            return
-          end
-          ssl = ssls.accept
-        rescue OpenSSL::SSL::SSLError, Errno::ECONNRESET
-          if ignore_listener_error
-            retry
-          else
-            raise
-          end
+  def server_loop(ctx, ssls, stop_pipe_r, ignore_listener_error, server_proc, threads)
+    loop do
+      ssl = nil
+      begin
+        readable, = IO.select([ssls, stop_pipe_r])
+        if readable.include? stop_pipe_r
+          return
         end
-
-        th = Thread.start do
-          server_proc.call(ctx, ssl)
+        ssl = ssls.accept
+      rescue OpenSSL::SSL::SSLError, Errno::ECONNRESET
+        if ignore_listener_error
+          retry
+        else
+          raise
         end
-        threads << th
       end
-    rescue Errno::EBADF, IOError, Errno::EINVAL, Errno::ECONNABORTED, Errno::ENOTSOCK, Errno::ECONNRESET
-      if !ignore_listener_error
-        raise
+
+      th = Thread.start do
+        server_proc.call(ctx, ssl)
       end
+      threads << th
+    end
+  rescue Errno::EBADF, IOError, Errno::EINVAL, Errno::ECONNABORTED, Errno::ENOTSOCK, Errno::ECONNRESET
+    if !ignore_listener_error
+      raise
     end
+  end
 
-    def start_server(verify_mode: OpenSSL::SSL::VERIFY_NONE, start_immediately: true,
-                     ctx_proc: nil, server_proc: method(:readwrite_loop),
-                     ignore_listener_error: false, &block)
-      IO.pipe {|stop_pipe_r, stop_pipe_w|
-        store = OpenSSL::X509::Store.new
-        store.add_cert(@ca_cert)
-        store.purpose = OpenSSL::X509::PURPOSE_SSL_CLIENT
-        ctx = OpenSSL::SSL::SSLContext.new
-        ctx.cert_store = store
-        ctx.cert = @svr_cert
-        ctx.key = @svr_key
-        ctx.tmp_dh_callback = proc { Fixtures.pkey_dh("dh1024") }
-        begin
-          ctx.ecdh_curves = "P-256"
-        rescue NotImplementedError
-        end
-        ctx.verify_mode = verify_mode
-        ctx_proc.call(ctx) if ctx_proc
-
-        Socket.do_not_reverse_lookup = true
-        tcps = nil
-        tcps = TCPServer.new("127.0.0.1", 0)
-        port = tcps.connect_address.ip_port
-
-        ssls = OpenSSL::SSL::SSLServer.new(tcps, ctx)
-        ssls.start_immediately = start_immediately
-
-        threads = []
-        begin
-          server = Thread.new do
-            begin
-              server_loop(ctx, ssls, stop_pipe_r, ignore_listener_error, server_proc, threads)
-            ensure
-              tcps.close
-            end
+  def start_server(verify_mode: OpenSSL::SSL::VERIFY_NONE, start_immediately: true,
+                   ctx_proc: nil, server_proc: method(:readwrite_loop),
+                   ignore_listener_error: false, &block)
+    IO.pipe {|stop_pipe_r, stop_pipe_w|
+      store = OpenSSL::X509::Store.new
+      store.add_cert(@ca_cert)
+      store.purpose = OpenSSL::X509::PURPOSE_SSL_CLIENT
+      ctx = OpenSSL::SSL::SSLContext.new
+      ctx.cert_store = store
+      ctx.cert = @svr_cert
+      ctx.key = @svr_key
+      ctx.tmp_dh_callback = proc { Fixtures.pkey_dh("dh1024") }
+      begin
+        ctx.ecdh_curves = "P-256"
+      rescue NotImplementedError
+      end
+      ctx.verify_mode = verify_mode
+      ctx_proc.call(ctx) if ctx_proc
+
+      Socket.do_not_reverse_lookup = true
+      tcps = nil
+      tcps = TCPServer.new("127.0.0.1", 0)
+      port = tcps.connect_address.ip_port
+
+      ssls = OpenSSL::SSL::SSLServer.new(tcps, ctx)
+      ssls.start_immediately = start_immediately
+
+      threads = []
+      begin
+        server = Thread.new do
+          begin
+            server_loop(ctx, ssls, stop_pipe_r, ignore_listener_error, server_proc, threads)
+          ensure
+            tcps.close
           end
-          threads.unshift server
+        end
+        threads.unshift server
 
-          $stderr.printf("SSL server started: pid=%d port=%d\n", $$, port) if $DEBUG
+        $stderr.printf("SSL server started: pid=%d port=%d\n", $$, port) if $DEBUG
 
-          client = Thread.new do
-            begin
-              block.call(server, port.to_i)
-            ensure
-              stop_pipe_w.close
-            end
+        client = Thread.new do
+          begin
+            block.call(server, port.to_i)
+          ensure
+            stop_pipe_w.close
           end
-          threads.unshift client
-        ensure
-          assert_join_threads(threads)
         end
-      }
-    end
+        threads.unshift client
+      ensure
+        assert_join_threads(threads)
+      end
+    }
   end
+end
 
-  class OpenSSL::PKeyTestCase < OpenSSL::TestCase
-    def check_component(base, test, keys)
-      keys.each { |comp|
-        assert_equal base.send(comp), test.send(comp)
-      }
-    end
+class OpenSSL::PKeyTestCase < OpenSSL::TestCase
+  def check_component(base, test, keys)
+    keys.each { |comp|
+      assert_equal base.send(comp), test.send(comp)
+    }
+  end
 
-    def dup_public(key)
-      case key
-      when OpenSSL::PKey::RSA
-        rsa = OpenSSL::PKey::RSA.new
-        rsa.set_key(key.n, key.e, nil)
-        rsa
-      when OpenSSL::PKey::DSA
-        dsa = OpenSSL::PKey::DSA.new
-        dsa.set_pqg(key.p, key.q, key.g)
-        dsa.set_key(key.pub_key, nil)
-        dsa
-      when OpenSSL::PKey::DH
-        dh = OpenSSL::PKey::DH.new
-        dh.set_pqg(key.p, nil, key.g)
-        dh
+  def dup_public(key)
+    case key
+    when OpenSSL::PKey::RSA
+      rsa = OpenSSL::PKey::RSA.new
+      rsa.set_key(key.n, key.e, nil)
+      rsa
+    when OpenSSL::PKey::DSA
+      dsa = OpenSSL::PKey::DSA.new
+      dsa.set_pqg(key.p, key.q, key.g)
+      dsa.set_key(key.pub_key, nil)
+      dsa
+    when OpenSSL::PKey::DH
+      dh = OpenSSL::PKey::DH.new
+      dh.set_pqg(key.p, nil, key.g)
+      dh
+    else
+      if defined?(OpenSSL::PKey::EC) && OpenSSL::PKey::EC === key
+        ec = OpenSSL::PKey::EC.new(key.group)
+        ec.public_key = key.public_key
+        ec
       else
-        if defined?(OpenSSL::PKey::EC) && OpenSSL::PKey::EC === key
-          ec = OpenSSL::PKey::EC.new(key.group)
-          ec.public_key = key.public_key
-          ec
-        else
-          raise "unknown key type"
-        end
+        raise "unknown key type"
       end
     end
   end
+end
 
-end if defined?(OpenSSL::OPENSSL_LIBRARY_VERSION) and
-  /\AOpenSSL +0\./ !~ OpenSSL::OPENSSL_LIBRARY_VERSION
+end