Merge branch 'ingela/ssl/test-enhancment'

* ingela/ssl/test-enhancment:
  ssl: Increase timeout
  ssl: Remove use of test_server config macro
  ssl: Disable DTLS test for now
  ssl: move TLS/DTLS version logging into helper
  ssl: tests for DTLS

1 files changed, 74 insertions, 79 deletions

diff --git a/lib/ssl/test/ssl_to_openssl_SUITE.erl b/lib/ssl/test/ssl_to_openssl_SUITE.erl
index 686d24b044..9df31a3381 100644
--- a/lib/ssl/test/ssl_to_openssl_SUITE.erl
+++ b/lib/ssl/test/ssl_to_openssl_SUITE.erl
@@ -117,8 +117,8 @@ init_per_suite(Config0) ->
 	    try crypto:start() of
 		ok ->
 		    ssl:start(),
-		    {ok,  _} = make_certs:all(?config(data_dir, Config0),
-					      ?config(priv_dir, Config0)),
+		    {ok,  _} = make_certs:all(proplists:get_value(data_dir, Config0),
+					      proplists:get_value(priv_dir, Config0)),
 		    Config1 = ssl_test_lib:make_dsa_cert(Config0),
 		    Config = ssl_test_lib:cert_options(Config1),
 		    ssl_test_lib:cipher_restriction(Config)
@@ -136,8 +136,7 @@ init_per_group(GroupName, Config) ->
 	true ->
 	    case ssl_test_lib:check_sane_openssl_version(GroupName) of
 		true ->
-		    ssl_test_lib:init_tls_version(GroupName),
-		    Config;
+		    ssl_test_lib:init_tls_version(GroupName, Config);
 		false ->
 		    {skip, openssl_does_not_support_version}
 	    end;
@@ -257,8 +256,8 @@ basic_erlang_client_openssl_server() ->
     [{doc,"Test erlang client with openssl server"}].
 basic_erlang_client_openssl_server(Config) when is_list(Config) ->
     process_flag(trap_exit, true),
-    ServerOpts = ?config(server_opts, Config),  
-    ClientOpts = ?config(client_opts, Config),  
+    ServerOpts = ssl_test_lib:ssl_options(server_opts, Config),
+    ClientOpts = ssl_test_lib:ssl_options(client_opts, Config),
 
     {ClientNode, _, Hostname} = ssl_test_lib:run_where(Config),
     
@@ -296,7 +295,7 @@ basic_erlang_server_openssl_client() ->
     [{doc,"Test erlang server with openssl client"}].
 basic_erlang_server_openssl_client(Config) when is_list(Config) ->
     process_flag(trap_exit, true),
-    ServerOpts = ?config(server_opts, Config),  
+    ServerOpts = ssl_test_lib:ssl_options(server_opts, Config),
 
     {_, ServerNode, _} = ssl_test_lib:run_where(Config),
     
@@ -326,8 +325,8 @@ erlang_client_openssl_server() ->
     [{doc,"Test erlang client with openssl server"}].
 erlang_client_openssl_server(Config) when is_list(Config) ->
     process_flag(trap_exit, true),
-    ServerOpts = ?config(server_opts, Config),
-    ClientOpts = ?config(client_opts, Config),
+    ServerOpts = ssl_test_lib:ssl_options(server_opts, Config),
+    ClientOpts = ssl_test_lib:ssl_options(client_opts, Config),
 
     {ClientNode, _, Hostname} = ssl_test_lib:run_where(Config),
 
@@ -336,7 +335,7 @@ erlang_client_openssl_server(Config) when is_list(Config) ->
     Port = ssl_test_lib:inet_port(node()),
     CertFile = proplists:get_value(certfile, ServerOpts),
     KeyFile = proplists:get_value(keyfile, ServerOpts),
-    Version = tls_record:protocol_version(tls_record:highest_protocol_version([])),
+    Version = ssl_test_lib:protocol_version(Config),
     Exe = "openssl",
     Args = ["s_server", "-accept", integer_to_list(Port),
 	    ssl_test_lib:version_flag(Version), 
@@ -366,7 +365,7 @@ erlang_server_openssl_client() ->
     [{doc,"Test erlang server with openssl client"}].
 erlang_server_openssl_client(Config) when is_list(Config) ->
     process_flag(trap_exit, true),
-    ServerOpts = ?config(server_opts, Config),
+    ServerOpts = ssl_test_lib:ssl_options(server_opts, Config),
 
     {_, ServerNode, _} = ssl_test_lib:run_where(Config),
     
@@ -377,7 +376,7 @@ erlang_server_openssl_client(Config) when is_list(Config) ->
 			   {mfa, {?MODULE, erlang_ssl_receive, [Data]}},
 			   {options, ServerOpts}]),
     Port = ssl_test_lib:inet_port(Server),
-    Version = tls_record:protocol_version(tls_record:highest_protocol_version([])),
+    Version = ssl_test_lib:protocol_version(Config),
 
     Exe = "openssl",
     Args = ["s_client", "-connect", "localhost: " ++ integer_to_list(Port), 
@@ -398,8 +397,8 @@ erlang_client_openssl_server_dsa_cert() ->
     [{doc,"Test erlang server with openssl client"}].
 erlang_client_openssl_server_dsa_cert(Config) when is_list(Config) ->
     process_flag(trap_exit, true),
-    ClientOpts = ?config(client_dsa_opts, Config),  
-    ServerOpts = ?config(server_dsa_opts, Config),  
+    ClientOpts = ssl_test_lib:ssl_options(client_dsa_opts, Config),
+    ServerOpts = ssl_test_lib:ssl_options(server_dsa_opts, Config),
 
     {ClientNode, _, Hostname} = ssl_test_lib:run_where(Config),
   
@@ -409,7 +408,7 @@ erlang_client_openssl_server_dsa_cert(Config) when is_list(Config) ->
     CaCertFile =  proplists:get_value(cacertfile, ServerOpts),
     CertFile = proplists:get_value(certfile, ServerOpts),
     KeyFile = proplists:get_value(keyfile, ServerOpts),
-    Version = tls_record:protocol_version(tls_record:highest_protocol_version([])),
+    Version = ssl_test_lib:protocol_version(Config),
     Exe = "openssl",
     Args = ["s_server", "-accept", integer_to_list(Port),
 	    ssl_test_lib:version_flag(Version),
@@ -441,8 +440,8 @@ erlang_server_openssl_client_dsa_cert() ->
     [{doc,"Test erlang server with openssl client"}].
 erlang_server_openssl_client_dsa_cert(Config) when is_list(Config) ->
     process_flag(trap_exit, true),
-    ClientOpts = ?config(client_dsa_opts, Config),
-    ServerOpts = ?config(server_dsa_verify_opts, Config),
+    ClientOpts = ssl_test_lib:ssl_options(client_dsa_opts, Config),
+    ServerOpts = ssl_test_lib:ssl_options(server_dsa_verify_opts, Config),
 
     {_, ServerNode, _} = ssl_test_lib:run_where(Config),
 
@@ -456,7 +455,7 @@ erlang_server_openssl_client_dsa_cert(Config) when is_list(Config) ->
                           {mfa, {?MODULE, erlang_ssl_receive, [Data]}},
                           {options, ServerOpts}]),
     Port = ssl_test_lib:inet_port(Server),
-    Version = tls_record:protocol_version(tls_record:highest_protocol_version([])),
+    Version = ssl_test_lib:protocol_version(Config),
     Exe = "openssl",
     Args = ["s_client", "-connect", "localhost: " ++ integer_to_list(Port),
 	    ssl_test_lib:version_flag(Version),
@@ -481,7 +480,7 @@ erlang_server_openssl_client_reuse_session() ->
      "same session id, to test reusing of sessions."}].
 erlang_server_openssl_client_reuse_session(Config) when is_list(Config) ->
     process_flag(trap_exit, true),
-    ServerOpts = ?config(server_opts, Config),  
+    ServerOpts = ssl_test_lib:ssl_options(server_opts, Config),
 
     {_, ServerNode, _} = ssl_test_lib:run_where(Config),
     
@@ -493,7 +492,7 @@ erlang_server_openssl_client_reuse_session(Config) when is_list(Config) ->
 			   {reconnect_times, 5},		
 			   {options, ServerOpts}]),
     Port = ssl_test_lib:inet_port(Server),
-    Version = tls_record:protocol_version(tls_record:highest_protocol_version([])),
+    Version = ssl_test_lib:protocol_version(Config),
     
     Exe = "openssl",
     Args = ["s_client", "-connect",  "localhost:" ++ integer_to_list(Port),
@@ -518,8 +517,8 @@ erlang_client_openssl_server_renegotiate() ->
     [{doc,"Test erlang client when openssl server issuses a renegotiate"}].
 erlang_client_openssl_server_renegotiate(Config) when is_list(Config) ->
     process_flag(trap_exit, true),
-    ServerOpts = ?config(server_opts, Config),  
-    ClientOpts = ?config(client_opts, Config),  
+    ServerOpts = ssl_test_lib:ssl_options(server_opts, Config),
+    ClientOpts = ssl_test_lib:ssl_options(client_opts, Config),
 
     {ClientNode, _, Hostname} = ssl_test_lib:run_where(Config),
     
@@ -529,7 +528,7 @@ erlang_client_openssl_server_renegotiate(Config) when is_list(Config) ->
     Port = ssl_test_lib:inet_port(node()),
     CertFile = proplists:get_value(certfile, ServerOpts),
     KeyFile = proplists:get_value(keyfile, ServerOpts),
-    Version = tls_record:protocol_version(tls_record:highest_protocol_version([])),
+    Version = ssl_test_lib:protocol_version(Config),
 
     Exe = "openssl",
     Args = ["s_server", "-accept", integer_to_list(Port),  
@@ -568,8 +567,8 @@ erlang_client_openssl_server_nowrap_seqnum() ->
      " to lower treashold substantially."}].
 erlang_client_openssl_server_nowrap_seqnum(Config) when is_list(Config) ->
     process_flag(trap_exit, true),
-    ServerOpts = ?config(server_opts, Config),  
-    ClientOpts = ?config(client_opts, Config),  
+    ServerOpts = ssl_test_lib:ssl_options(server_opts, Config),
+    ClientOpts = ssl_test_lib:ssl_options(client_opts, Config),
 
     {ClientNode, _, Hostname} = ssl_test_lib:run_where(Config),
     
@@ -579,7 +578,7 @@ erlang_client_openssl_server_nowrap_seqnum(Config) when is_list(Config) ->
     Port = ssl_test_lib:inet_port(node()),
     CertFile = proplists:get_value(certfile, ServerOpts),
     KeyFile = proplists:get_value(keyfile, ServerOpts),
-    Version = tls_record:protocol_version(tls_record:highest_protocol_version([])),
+    Version = ssl_test_lib:protocol_version(Config),
     Exe = "openssl",
     Args = ["s_server", "-accept", integer_to_list(Port),
 	    ssl_test_lib:version_flag(Version),
@@ -611,7 +610,7 @@ erlang_server_openssl_client_nowrap_seqnum() ->
      " to lower treashold substantially."}].
 erlang_server_openssl_client_nowrap_seqnum(Config) when is_list(Config) ->
     process_flag(trap_exit, true),
-    ServerOpts = ?config(server_opts, Config),  
+    ServerOpts = ssl_test_lib:ssl_options(server_opts, Config),
 
     {_, ServerNode, _} = ssl_test_lib:run_where(Config),
     
@@ -625,7 +624,7 @@ erlang_server_openssl_client_nowrap_seqnum(Config) when is_list(Config) ->
 					       trigger_renegotiate, [[Data, N+2]]}},
 					{options, [{renegotiate_at, N}, {reuse_sessions, false} | ServerOpts]}]),
     Port = ssl_test_lib:inet_port(Server),
-    Version = tls_record:protocol_version(tls_record:highest_protocol_version([])),
+    Version = ssl_test_lib:protocol_version(Config),
     Exe = "openssl", 
     Args = ["s_client","-connect", "localhost: " ++ integer_to_list(Port),
 	    ssl_test_lib:version_flag(Version),
@@ -650,8 +649,8 @@ erlang_client_openssl_server_no_server_ca_cert() ->
      "implicitly tested eleswhere."}].
 erlang_client_openssl_server_no_server_ca_cert(Config) when is_list(Config) ->
     process_flag(trap_exit, true),
-    ServerOpts = ?config(server_opts, Config),  
-    ClientOpts = ?config(client_opts, Config),  
+    ServerOpts = ssl_test_lib:ssl_options(server_opts, Config),
+    ClientOpts = ssl_test_lib:ssl_options(client_opts, Config),
 
     {ClientNode, _, Hostname} = ssl_test_lib:run_where(Config),
     
@@ -660,7 +659,7 @@ erlang_client_openssl_server_no_server_ca_cert(Config) when is_list(Config) ->
     Port = ssl_test_lib:inet_port(node()),
     CertFile = proplists:get_value(certfile, ServerOpts),
     KeyFile = proplists:get_value(keyfile, ServerOpts),
-    Version = tls_record:protocol_version(tls_record:highest_protocol_version([])),
+    Version = ssl_test_lib:protocol_version(Config),
     Exe = "openssl",
     Args = ["s_server", "-accept", integer_to_list(Port), 
 	    ssl_test_lib:version_flag(Version),
@@ -691,8 +690,8 @@ erlang_client_openssl_server_client_cert() ->
     [{doc,"Test erlang client with openssl server when client sends cert"}].
 erlang_client_openssl_server_client_cert(Config) when is_list(Config) ->
     process_flag(trap_exit, true),
-    ServerOpts = ?config(server_verification_opts, Config),  
-    ClientOpts = ?config(client_verification_opts, Config),  
+    ServerOpts = ssl_test_lib:ssl_options(server_verification_opts, Config),
+    ClientOpts = ssl_test_lib:ssl_options(client_verification_opts, Config),
 
     {ClientNode, _, Hostname} = ssl_test_lib:run_where(Config),
     
@@ -702,7 +701,7 @@ erlang_client_openssl_server_client_cert(Config) when is_list(Config) ->
     CertFile = proplists:get_value(certfile, ServerOpts),
     CaCertFile = proplists:get_value(cacertfile, ServerOpts),
     KeyFile = proplists:get_value(keyfile, ServerOpts),
-    Version = tls_record:protocol_version(tls_record:highest_protocol_version([])),
+    Version = ssl_test_lib:protocol_version(Config),
     Exe = "openssl",
     Args = ["s_server", "-accept", integer_to_list(Port),
 	    ssl_test_lib:version_flag(Version),
@@ -734,8 +733,8 @@ erlang_server_openssl_client_client_cert() ->
     [{doc,"Test erlang server with openssl client when client sends cert"}].
 erlang_server_openssl_client_client_cert(Config) when is_list(Config) ->
     process_flag(trap_exit, true),
-    ServerOpts = ?config(server_verification_opts, Config),  
-    ClientOpts = ?config(client_verification_opts, Config),  
+    ServerOpts = ssl_test_lib:ssl_options(server_verification_opts, Config),
+    ClientOpts = ssl_test_lib:ssl_options(client_verification_opts, Config),
 
     {_, ServerNode, _} = ssl_test_lib:run_where(Config),
     
@@ -753,7 +752,7 @@ erlang_server_openssl_client_client_cert(Config) when is_list(Config) ->
     CaCertFile = proplists:get_value(cacertfile, ClientOpts),
     CertFile = proplists:get_value(certfile, ClientOpts),
     KeyFile = proplists:get_value(keyfile, ClientOpts),
-    Version = tls_record:protocol_version(tls_record:highest_protocol_version([])),
+    Version = ssl_test_lib:protocol_version(Config),
     Exe = "openssl",
     Args = ["s_client", "-cert", CertFile,
 	   "-CAfile", CaCertFile, 
@@ -775,9 +774,9 @@ erlang_server_erlang_client_client_cert() ->
     [{doc,"Test erlang server with erlang client when client sends cert"}].
 erlang_server_erlang_client_client_cert(Config) when is_list(Config) ->
     process_flag(trap_exit, true),
-    ServerOpts = ?config(server_verification_opts, Config),  
-    ClientOpts = ?config(client_verification_opts, Config),  
-    Version = tls_record:protocol_version(tls_record:highest_protocol_version([])),
+    ServerOpts = proplists:get_value(server_verification_opts, Config),  
+    ClientOpts = proplists:get_value(client_verification_opts, Config),  
+    Version = ssl_test_lib:protocol_version(Config),
     {ClientNode, ServerNode, Hostname} = ssl_test_lib:run_where(Config),
     
     Data = "From erlang to erlang",
@@ -812,9 +811,7 @@ erlang_server_erlang_client_client_cert(Config) when is_list(Config) ->
 ciphers_rsa_signed_certs() ->
     [{doc,"Test cipher suites that uses rsa certs"}].
 ciphers_rsa_signed_certs(Config) when is_list(Config) ->
-    Version = 
-	tls_record:protocol_version(tls_record:highest_protocol_version([])),
-
+    Version = ssl_test_lib:protocol_version(Config),
     Ciphers = ssl_test_lib:rsa_suites(openssl),
     run_suites(Ciphers, Version, Config, rsa).
 %%--------------------------------------------------------------------
@@ -822,9 +819,7 @@ ciphers_rsa_signed_certs(Config) when is_list(Config) ->
 ciphers_dsa_signed_certs() ->
     [{doc,"Test cipher suites that uses dsa certs"}].
 ciphers_dsa_signed_certs(Config) when is_list(Config) ->
-    Version = 
-	tls_record:protocol_version(tls_record:highest_protocol_version([])),
-
+    Version = ssl_test_lib:protocol_version(Config),
     Ciphers = ssl_test_lib:dsa_suites(),
     run_suites(Ciphers, Version, Config, dsa).
 
@@ -833,15 +828,15 @@ erlang_client_bad_openssl_server() ->
     [{doc,"Test what happens if openssl server sends garbage to erlang ssl client"}].
 erlang_client_bad_openssl_server(Config) when is_list(Config) ->
     process_flag(trap_exit, true),
-    ServerOpts = ?config(server_verification_opts, Config),  
-    ClientOpts = ?config(client_verification_opts, Config),  
+    ServerOpts = ssl_test_lib:ssl_options(server_verification_opts, Config),
+    ClientOpts = ssl_test_lib:ssl_options(client_verification_opts, Config),
 
     {ClientNode, _, Hostname} = ssl_test_lib:run_where(Config),
     
     Port = ssl_test_lib:inet_port(node()),
     CertFile = proplists:get_value(certfile, ServerOpts),
     KeyFile = proplists:get_value(keyfile, ServerOpts),
-    Version = tls_record:protocol_version(tls_record:highest_protocol_version([])),
+    Version = ssl_test_lib:protocol_version(Config),
     Exe = "openssl",
     Args = ["s_server", "-accept", integer_to_list(Port), ssl_test_lib:version_flag(Version),
  	"-cert", CertFile, "-key", KeyFile],
@@ -888,8 +883,8 @@ expired_session() ->
       "better code coverage of the ssl_manager module"}].
 expired_session(Config) when is_list(Config) -> 
     process_flag(trap_exit, true),
-    ClientOpts = ?config(client_opts, Config),
-    ServerOpts = ?config(server_opts, Config),
+    ClientOpts = ssl_test_lib:ssl_options(client_opts, Config),
+    ServerOpts = ssl_test_lib:ssl_options(server_opts, Config),
     {ClientNode, _, Hostname} = ssl_test_lib:run_where(Config),
 
     Port = ssl_test_lib:inet_port(node()),
@@ -942,7 +937,7 @@ ssl2_erlang_server_openssl_client() ->
 
 ssl2_erlang_server_openssl_client(Config) when is_list(Config) ->
     process_flag(trap_exit, true),
-    ServerOpts = ?config(server_opts, Config),  
+    ServerOpts = ssl_test_lib:ssl_options(server_opts, Config),
 
     {_, ServerNode, _} = ssl_test_lib:run_where(Config),
     
@@ -1220,11 +1215,11 @@ run_suites(Ciphers, Version, Config, Type) ->
     {ClientOpts, ServerOpts} =
 	case Type of
 	    rsa ->
-		{?config(client_opts, Config),
-		 ?config(server_opts, Config)};
+		{ssl_test_lib:ssl_options(client_opts, Config),
+		 ssl_test_lib:ssl_options(server_opts, Config)};
 	    dsa ->
-		{?config(client_opts, Config),
-		 ?config(server_dsa_opts, Config)}
+		{ssl_test_lib:ssl_options(client_opts, Config),
+		 ssl_test_lib:ssl_options(server_dsa_opts, Config)}
 	end,
 
     Result =  lists:map(fun(Cipher) ->
@@ -1277,7 +1272,7 @@ send_and_hostname(SSLSocket) ->
 
 erlang_server_openssl_client_sni_test(Config, SNIHostname, ExpectedSNIHostname, ExpectedCN) ->
     ct:log("Start running handshake, Config: ~p, SNIHostname: ~p, ExpectedSNIHostname: ~p, ExpectedCN: ~p", [Config, SNIHostname, ExpectedSNIHostname, ExpectedCN]),
-    ServerOptions = ?config(sni_server_opts, Config) ++ ?config(server_opts, Config),
+    ServerOptions = proplists:get_value(sni_server_opts, Config) ++ proplists:get_value(server_opts, Config),
     {_, ServerNode, Hostname} = ssl_test_lib:run_where(Config),
     Server = ssl_test_lib:start_server([{node, ServerNode}, {port, 0},
                                         {from, self()}, {mfa, {?MODULE, send_and_hostname, []}},
@@ -1304,9 +1299,9 @@ erlang_server_openssl_client_sni_test(Config, SNIHostname, ExpectedSNIHostname,
 
 erlang_server_openssl_client_sni_test_sni_fun(Config, SNIHostname, ExpectedSNIHostname, ExpectedCN) ->
     ct:log("Start running handshake for sni_fun, Config: ~p, SNIHostname: ~p, ExpectedSNIHostname: ~p, ExpectedCN: ~p", [Config, SNIHostname, ExpectedSNIHostname, ExpectedCN]),
-    [{sni_hosts, ServerSNIConf}] = ?config(sni_server_opts, Config),
+    [{sni_hosts, ServerSNIConf}] = proplists:get_value(sni_server_opts, Config),
     SNIFun = fun(Domain) -> proplists:get_value(Domain, ServerSNIConf, undefined) end,
-    ServerOptions = ?config(server_opts, Config) ++ [{sni_fun, SNIFun}],
+    ServerOptions = proplists:get_value(server_opts, Config) ++ [{sni_fun, SNIFun}],
     {_, ServerNode, Hostname} = ssl_test_lib:run_where(Config),
     Server = ssl_test_lib:start_server([{node, ServerNode}, {port, 0},
                                         {from, self()}, {mfa, {?MODULE, send_and_hostname, []}},
@@ -1388,8 +1383,8 @@ cipher(CipherSuite, Version, Config, ClientOpts, ServerOpts) ->
 
 start_erlang_client_and_openssl_server_with_opts(Config, ErlangClientOpts, OpensslServerOpts, Data, Callback) ->
     process_flag(trap_exit, true),
-    ServerOpts = ?config(server_opts, Config),
-    ClientOpts0 = ?config(client_opts, Config),
+    ServerOpts = ssl_test_lib:ssl_options(server_opts, Config),
+    ClientOpts0 = ssl_test_lib:ssl_options(client_opts, Config),
     ClientOpts = ErlangClientOpts ++ ClientOpts0,
 
     {ClientNode, _, Hostname} = ssl_test_lib:run_where(Config),
@@ -1399,7 +1394,7 @@ start_erlang_client_and_openssl_server_with_opts(Config, ErlangClientOpts, Opens
     Port = ssl_test_lib:inet_port(node()),
     CertFile = proplists:get_value(certfile, ServerOpts),
     KeyFile = proplists:get_value(keyfile, ServerOpts),
-    Version = tls_record:protocol_version(tls_record:highest_protocol_version([])),
+    Version = ssl_test_lib:protocol_version(Config),
 
     Exe = "openssl",
     Args = case OpensslServerOpts of
@@ -1434,8 +1429,8 @@ start_erlang_client_and_openssl_server_with_opts(Config, ErlangClientOpts, Opens
 
 start_erlang_client_and_openssl_server_for_alpn_negotiation(Config, Data, Callback) ->
     process_flag(trap_exit, true),
-    ServerOpts = ?config(server_opts, Config),
-    ClientOpts0 = ?config(client_opts, Config),
+    ServerOpts = proplists:get_value(server_opts, Config),
+    ClientOpts0 = proplists:get_value(client_opts, Config),
     ClientOpts = [{alpn_advertised_protocols, [<<"spdy/2">>]} | ClientOpts0],
 
     {ClientNode, _, Hostname} = ssl_test_lib:run_where(Config),
@@ -1445,7 +1440,7 @@ start_erlang_client_and_openssl_server_for_alpn_negotiation(Config, Data, Callba
     Port = ssl_test_lib:inet_port(node()),
     CertFile = proplists:get_value(certfile, ServerOpts),
     KeyFile = proplists:get_value(keyfile, ServerOpts),
-    Version = tls_record:protocol_version(tls_record:highest_protocol_version([])),
+    Version = ssl_test_lib:protocol_version(Config),
 
     Exe = "openssl",
     Args = ["s_server", "-msg", "-alpn", "http/1.1,spdy/2", "-accept", integer_to_list(Port), ssl_test_lib:version_flag(Version),
@@ -1470,7 +1465,7 @@ start_erlang_client_and_openssl_server_for_alpn_negotiation(Config, Data, Callba
 
 start_erlang_server_and_openssl_client_for_alpn_negotiation(Config, Data, Callback) ->
     process_flag(trap_exit, true),
-    ServerOpts0 = ?config(server_opts, Config),
+    ServerOpts0 = proplists:get_value(server_opts, Config),
     ServerOpts = [{alpn_preferred_protocols, [<<"spdy/2">>]} | ServerOpts0],
 
     {_, ServerNode, _} = ssl_test_lib:run_where(Config),
@@ -1481,7 +1476,7 @@ start_erlang_server_and_openssl_client_for_alpn_negotiation(Config, Data, Callba
                     {mfa, {?MODULE, erlang_ssl_receive_and_assert_negotiated_protocol, [<<"spdy/2">>, Data]}},
                     {options, ServerOpts}]),
     Port = ssl_test_lib:inet_port(Server),
-    Version = tls_record:protocol_version(tls_record:highest_protocol_version([])),
+    Version = ssl_test_lib:protocol_version(Config),
 
     Exe = "openssl",
     Args = ["s_client", "-alpn", "http/1.0,spdy/2", "-msg", "-port", 
@@ -1499,8 +1494,8 @@ start_erlang_server_and_openssl_client_for_alpn_negotiation(Config, Data, Callba
 
 start_erlang_client_and_openssl_server_for_alpn_npn_negotiation(Config, Data, Callback) ->
     process_flag(trap_exit, true),
-    ServerOpts = ?config(server_opts, Config),
-    ClientOpts0 = ?config(client_opts, Config),
+    ServerOpts = proplists:get_value(server_opts, Config),
+    ClientOpts0 = proplists:get_value(client_opts, Config),
     ClientOpts = [{alpn_advertised_protocols, [<<"spdy/2">>]},
         {client_preferred_next_protocols, {client, [<<"spdy/3">>, <<"http/1.1">>]}} | ClientOpts0],
 
@@ -1511,7 +1506,7 @@ start_erlang_client_and_openssl_server_for_alpn_npn_negotiation(Config, Data, Ca
     Port = ssl_test_lib:inet_port(node()),
     CertFile = proplists:get_value(certfile, ServerOpts),
     KeyFile = proplists:get_value(keyfile, ServerOpts),
-    Version = tls_record:protocol_version(tls_record:highest_protocol_version([])),
+    Version = ssl_test_lib:protocol_version(Config),
 
     Exe = "openssl",
     Args = ["s_server", "-msg", "-alpn", "http/1.1,spdy/2", "-nextprotoneg", 
@@ -1539,7 +1534,7 @@ start_erlang_client_and_openssl_server_for_alpn_npn_negotiation(Config, Data, Ca
 
 start_erlang_server_and_openssl_client_for_alpn_npn_negotiation(Config, Data, Callback) ->
     process_flag(trap_exit, true),
-    ServerOpts0 = ?config(server_opts, Config),
+    ServerOpts0 = proplists:get_value(server_opts, Config),
     ServerOpts = [{alpn_preferred_protocols, [<<"spdy/2">>]},
         {next_protocols_advertised, [<<"spdy/3">>, <<"http/1.1">>]} | ServerOpts0],
 
@@ -1551,7 +1546,7 @@ start_erlang_server_and_openssl_client_for_alpn_npn_negotiation(Config, Data, Ca
                     {mfa, {?MODULE, erlang_ssl_receive_and_assert_negotiated_protocol, [<<"spdy/2">>, Data]}},
                     {options, ServerOpts}]),
     Port = ssl_test_lib:inet_port(Server),
-    Version = tls_record:protocol_version(tls_record:highest_protocol_version([])),
+    Version = ssl_test_lib:protocol_version(Config),
     Exe = "openssl",
     Args = ["s_client", "-alpn", "http/1.1,spdy/2", "-nextprotoneg", "spdy/3", 
 	    "-msg", "-port", integer_to_list(Port), ssl_test_lib:version_flag(Version),
@@ -1566,8 +1561,8 @@ start_erlang_server_and_openssl_client_for_alpn_npn_negotiation(Config, Data, Ca
 
 start_erlang_client_and_openssl_server_for_npn_negotiation(Config, Data, Callback) ->
     process_flag(trap_exit, true),
-    ServerOpts = ?config(server_opts, Config),
-    ClientOpts0 = ?config(client_opts, Config),
+    ServerOpts = ssl_test_lib:ssl_options(server_opts, Config),
+    ClientOpts0 = ssl_test_lib:ssl_options(client_opts, Config),
     ClientOpts = [{client_preferred_next_protocols, {client, [<<"spdy/2">>], <<"http/1.1">>}} | ClientOpts0],
 
     {ClientNode, _, Hostname} = ssl_test_lib:run_where(Config),
@@ -1577,7 +1572,7 @@ start_erlang_client_and_openssl_server_for_npn_negotiation(Config, Data, Callbac
     Port = ssl_test_lib:inet_port(node()),
     CertFile = proplists:get_value(certfile, ServerOpts),
     KeyFile = proplists:get_value(keyfile, ServerOpts),
-    Version = tls_record:protocol_version(tls_record:highest_protocol_version([])),
+    Version = ssl_test_lib:protocol_version(Config),
     
     Exe = "openssl",
     Args = ["s_server", "-msg", "-nextprotoneg", "http/1.1,spdy/2", "-accept", integer_to_list(Port),
@@ -1604,7 +1599,7 @@ start_erlang_client_and_openssl_server_for_npn_negotiation(Config, Data, Callbac
 
 start_erlang_server_and_openssl_client_for_npn_negotiation(Config, Data, Callback) ->
     process_flag(trap_exit, true),
-    ServerOpts0 = ?config(server_opts, Config),
+    ServerOpts0 = ssl_test_lib:ssl_options(server_opts, Config),
     ServerOpts = [{next_protocols_advertised, [<<"spdy/2">>]}, ServerOpts0],
 
     {_, ServerNode, _} = ssl_test_lib:run_where(Config),
@@ -1615,7 +1610,7 @@ start_erlang_server_and_openssl_client_for_npn_negotiation(Config, Data, Callbac
                     {mfa, {?MODULE, erlang_ssl_receive_and_assert_negotiated_protocol, [<<"spdy/2">>, Data]}},
                     {options, ServerOpts}]),
     Port = ssl_test_lib:inet_port(Server),
-    Version = tls_record:protocol_version(tls_record:highest_protocol_version([])),
+    Version = ssl_test_lib:protocol_version(Config),
 
     Exe = "openssl",
     Args = ["s_client", "-nextprotoneg", "http/1.0,spdy/2", "-msg", "-connect", "localhost:" 
@@ -1633,7 +1628,7 @@ start_erlang_server_and_openssl_client_for_npn_negotiation(Config, Data, Callbac
 
 start_erlang_server_and_openssl_client_with_opts(Config, ErlangServerOpts, OpenSSLClientOpts, Data, Callback) ->
     process_flag(trap_exit, true),
-    ServerOpts0 = ?config(server_opts, Config),
+    ServerOpts0 = ssl_test_lib:ssl_options(server_opts, Config),
     ServerOpts = ErlangServerOpts ++  ServerOpts0,
 
     {_, ServerNode, _} = ssl_test_lib:run_where(Config),
@@ -1644,7 +1639,7 @@ start_erlang_server_and_openssl_client_with_opts(Config, ErlangServerOpts, OpenS
                     {mfa, {?MODULE, erlang_ssl_receive, [Data]}},
                     {options, ServerOpts}]),
     Port = ssl_test_lib:inet_port(Server),
-    Version = tls_record:protocol_version(tls_record:highest_protocol_version([])),
+    Version = ssl_test_lib:protocol_version(Config),
    
     Exe = "openssl",
     Args = ["s_client"] ++ OpenSSLClientOpts ++ ["-msg",  "-connect", "localhost:" ++ integer_to_list(Port),