ssl: Remove use of test_server config macro

15 files changed, 137 insertions, 137 deletions

diff --git a/lib/ssl/test/ssl_ECC_SUITE.erl b/lib/ssl/test/ssl_ECC_SUITE.erl
index 75586a7211..3a1fd00c06 100644
--- a/lib/ssl/test/ssl_ECC_SUITE.erl
+++ b/lib/ssl/test/ssl_ECC_SUITE.erl
@@ -74,8 +74,8 @@ init_per_suite(Config0) ->
     try crypto:start() of
 	ok ->
 	    %% make rsa certs using oppenssl
-	    {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_ecdsa_cert(Config0),
 	    Config2 = ssl_test_lib:make_ecdh_rsa_cert(Config1),
 	    ssl_test_lib:cert_options(Config2)
@@ -158,43 +158,43 @@ end_per_testcase(_TestCase, Config) ->
 %%--------------------------------------------------------------------
 
 client_ecdh_server_ecdh(Config) when is_list(Config) ->
-    COpts =  ?config(client_ecdh_rsa_opts, Config),
-    SOpts = ?config(server_ecdh_rsa_verify_opts, Config),
+    COpts =  proplists:get_value(client_ecdh_rsa_opts, Config),
+    SOpts = proplists:get_value(server_ecdh_rsa_verify_opts, Config),
     basic_test(COpts, SOpts, Config).
     
 client_ecdh_server_rsa(Config)  when is_list(Config) ->
-    COpts =  ?config(client_ecdh_rsa_opts, Config),
-    SOpts = ?config(server_ecdh_rsa_verify_opts, Config),
+    COpts =  proplists:get_value(client_ecdh_rsa_opts, Config),
+    SOpts = proplists:get_value(server_ecdh_rsa_verify_opts, Config),
     basic_test(COpts, SOpts, Config).
   
 client_rsa_server_ecdh(Config)  when is_list(Config) ->
-    COpts =  ?config(client_ecdh_rsa_opts, Config),
-    SOpts = ?config(server_ecdh_rsa_verify_opts, Config),
+    COpts =  proplists:get_value(client_ecdh_rsa_opts, Config),
+    SOpts = proplists:get_value(server_ecdh_rsa_verify_opts, Config),
     basic_test(COpts, SOpts, Config).
    
 client_rsa_server_rsa(Config)  when is_list(Config) ->
-    COpts =  ?config(client_verification_opts, Config),
-    SOpts = ?config(server_verification_opts, Config),
+    COpts =  proplists:get_value(client_verification_opts, Config),
+    SOpts = proplists:get_value(server_verification_opts, Config),
     basic_test(COpts, SOpts, Config).
    
 client_ecdsa_server_ecdsa(Config)  when is_list(Config) ->
-    COpts =  ?config(client_ecdsa_opts, Config),
-    SOpts = ?config(server_ecdsa_verify_opts, Config),
+    COpts =  proplists:get_value(client_ecdsa_opts, Config),
+    SOpts = proplists:get_value(server_ecdsa_verify_opts, Config),
     basic_test(COpts, SOpts, Config).
 
 client_ecdsa_server_rsa(Config)  when is_list(Config) ->
-    COpts =  ?config(client_ecdsa_opts, Config),
-    SOpts = ?config(server_ecdsa_verify_opts, Config),
+    COpts =  proplists:get_value(client_ecdsa_opts, Config),
+    SOpts = proplists:get_value(server_ecdsa_verify_opts, Config),
     basic_test(COpts, SOpts, Config).
 
 client_rsa_server_ecdsa(Config)  when is_list(Config) ->
-    COpts =  ?config(client_ecdsa_opts, Config),
-    SOpts = ?config(server_ecdsa_verify_opts, Config),
+    COpts =  proplists:get_value(client_ecdsa_opts, Config),
+    SOpts = proplists:get_value(server_ecdsa_verify_opts, Config),
     basic_test(COpts, SOpts, Config).
 
 client_ecdsa_server_ecdsa_with_raw_key(Config)  when is_list(Config) ->
-    COpts =  ?config(client_ecdsa_opts, Config),
-    SOpts = ?config(server_ecdsa_verify_opts, Config),
+    COpts =  proplists:get_value(client_ecdsa_opts, Config),
+    SOpts = proplists:get_value(server_ecdsa_verify_opts, Config),
     ServerCert = proplists:get_value(certfile, SOpts),
     ServerKeyFile = proplists:get_value(keyfile, SOpts),
     {ok, PemBin} = file:read_file(ServerKeyFile),
@@ -205,8 +205,8 @@ client_ecdsa_server_ecdsa_with_raw_key(Config)  when is_list(Config) ->
     ClientCert = proplists:get_value(certfile, COpts),
     ClientKey = proplists:get_value(keyfile, COpts),
     ClientCA = proplists:get_value(cacertfile, COpts),
-    SType = ?config(server_type, Config),
-    CType = ?config(client_type, Config),
+    SType = proplists:get_value(server_type, Config),
+    CType = proplists:get_value(client_type, Config),
     {Server, Port} = start_server_with_raw_key(SType,
 				  ClientCA, ServerCA,
 				  ServerCert,
@@ -231,8 +231,8 @@ basic_test(COpts, SOpts, Config) ->
 	       Config).
     
 basic_test(ClientCert, ClientKey, ClientCA, ServerCert, ServerKey, ServerCA, Config) ->
-    SType = ?config(server_type, Config),
-    CType = ?config(client_type, Config),
+    SType = proplists:get_value(server_type, Config),
+    CType = proplists:get_value(client_type, Config),
     {Server, Port} = start_server(SType,
 				  ClientCA, ServerCA,
 				  ServerCert,
@@ -245,7 +245,7 @@ basic_test(ClientCert, ClientKey, ClientCA, ServerCert, ServerKey, ServerCA, Con
     close(Server, Client).    
 
 start_client(openssl, Port, CA, OwnCa, Cert, Key, Config) ->
-    PrivDir = ?config(priv_dir, Config),
+    PrivDir = proplists:get_value(priv_dir, Config),
     NewCA = new_ca(filename:join(PrivDir, "new_ca.pem"), CA, OwnCa),
     Version = tls_record:protocol_version(tls_record:highest_protocol_version([])),
     Exe = "openssl",
@@ -268,7 +268,7 @@ start_client(erlang, Port, CA, _, Cert, Key, Config) ->
 					  {certfile, Cert}, {keyfile, Key}]}]).
 
 start_server(openssl, CA, OwnCa, Cert, Key, Config) ->
-    PrivDir = ?config(priv_dir, Config),
+    PrivDir = proplists:get_value(priv_dir, Config),
     NewCA = new_ca(filename:join(PrivDir, "new_ca.pem"), CA, OwnCa),
 
     Port = ssl_test_lib:inet_port(node()),
@@ -315,7 +315,7 @@ check_result(_,openssl, _, openssl) ->
 openssl_check(erlang, Config) ->
     Config;
 openssl_check(_, Config) ->
-    TLSVersion = ?config(tls_version, Config),
+    TLSVersion = proplists:get_value(tls_version, Config),
     case ssl_test_lib:check_sane_openssl_version(TLSVersion) of
 	true ->
 	    Config;
diff --git a/lib/ssl/test/ssl_alpn_handshake_SUITE.erl b/lib/ssl/test/ssl_alpn_handshake_SUITE.erl
index d240e19cd8..da181faf64 100644
--- a/lib/ssl/test/ssl_alpn_handshake_SUITE.erl
+++ b/lib/ssl/test/ssl_alpn_handshake_SUITE.erl
@@ -72,8 +72,8 @@ init_per_suite(Config) ->
     try crypto:start() of
 	ok ->
 	    ssl:start(),
-	    {ok, _} = make_certs:all(?config(data_dir, Config),
-				     ?config(priv_dir, Config)),
+	    {ok, _} = make_certs:all(proplists:get_value(data_dir, Config),
+				     proplists:get_value(priv_dir, Config)),
 	    ssl_test_lib:cert_options(Config)
     catch _:_ ->
 	    {skip, "Crypto did not start"}
@@ -226,9 +226,9 @@ client_alpn_and_server_alpn_npn(Config) when is_list(Config) ->
 client_renegotiate(Config) when is_list(Config) ->
     Data = "hello world",
     
-    ClientOpts0 = ?config(client_opts, Config),
+    ClientOpts0 = proplists:get_value(client_opts, Config),
     ClientOpts = [{alpn_advertised_protocols, [<<"http/1.0">>]}] ++ ClientOpts0,
-    ServerOpts0 = ?config(server_opts, Config),
+    ServerOpts0 = proplists:get_value(server_opts, Config),
     ServerOpts = [{alpn_preferred_protocols, [<<"spdy/2">>, <<"http/1.1">>, <<"http/1.0">>]}] ++  ServerOpts0,
     ExpectedProtocol = {ok, <<"http/1.0">>},
 
@@ -250,9 +250,9 @@ client_renegotiate(Config) when is_list(Config) ->
 %--------------------------------------------------------------------------------
 
 session_reused(Config) when  is_list(Config)->
-    ClientOpts0 = ?config(client_opts, Config),
+    ClientOpts0 = proplists:get_value(client_opts, Config),
     ClientOpts = [{alpn_advertised_protocols, [<<"http/1.0">>]}] ++ ClientOpts0,
-    ServerOpts0 = ?config(server_opts, Config),
+    ServerOpts0 = proplists:get_value(server_opts, Config),
     ServerOpts = [{alpn_preferred_protocols, [<<"spdy/2">>, <<"http/1.1">>, <<"http/1.0">>]}] ++  ServerOpts0,
 
     {ClientNode, ServerNode, Hostname} = ssl_test_lib:run_where(Config),
@@ -299,7 +299,7 @@ session_reused(Config) when  is_list(Config)->
 %--------------------------------------------------------------------------------
 
 alpn_not_supported_client(Config) when is_list(Config) ->
-    ClientOpts0 = ?config(client_opts, Config),
+    ClientOpts0 = proplists:get_value(client_opts, Config),
     PrefProtocols = {client_preferred_next_protocols,
 		     {client, [<<"http/1.0">>], <<"http/1.1">>}},
     ClientOpts = [PrefProtocols] ++ ClientOpts0,
@@ -315,7 +315,7 @@ alpn_not_supported_client(Config) when is_list(Config) ->
 %--------------------------------------------------------------------------------
 
 alpn_not_supported_server(Config) when is_list(Config)->
-    ServerOpts0 = ?config(server_opts, Config),
+    ServerOpts0 = proplists:get_value(server_opts, Config),
     AdvProtocols = {next_protocols_advertised, [<<"spdy/2">>, <<"http/1.1">>, <<"http/1.0">>]},
     ServerOpts = [AdvProtocols] ++  ServerOpts0,
   
@@ -326,8 +326,8 @@ alpn_not_supported_server(Config) when is_list(Config)->
 %%--------------------------------------------------------------------
 
 run_failing_handshake(Config, ClientExtraOpts, ServerExtraOpts, ExpectedResult) ->
-    ClientOpts = ClientExtraOpts ++ ?config(client_opts, Config),
-    ServerOpts = ServerExtraOpts ++ ?config(server_opts, Config),
+    ClientOpts = ClientExtraOpts ++ proplists:get_value(client_opts, Config),
+    ServerOpts = ServerExtraOpts ++ proplists:get_value(server_opts, Config),
 
     {ClientNode, ServerNode, Hostname} = ssl_test_lib:run_where(Config),
     Server = ssl_test_lib:start_server([{node, ServerNode}, {port, 0},
@@ -346,9 +346,9 @@ run_failing_handshake(Config, ClientExtraOpts, ServerExtraOpts, ExpectedResult)
 run_handshake(Config, ClientExtraOpts, ServerExtraOpts, ExpectedProtocol) ->
     Data = "hello world",
 
-    ClientOpts0 = ?config(client_opts, Config),
+    ClientOpts0 = proplists:get_value(client_opts, Config),
     ClientOpts = ClientExtraOpts ++ ClientOpts0,
-    ServerOpts0 = ?config(server_opts, Config),
+    ServerOpts0 = proplists:get_value(server_opts, Config),
     ServerOpts = ServerExtraOpts ++  ServerOpts0,
 
     {ClientNode, ServerNode, Hostname} = ssl_test_lib:run_where(Config),
diff --git a/lib/ssl/test/ssl_basic_SUITE.erl b/lib/ssl/test/ssl_basic_SUITE.erl
index d5568b6fa7..d1162ab4a5 100644
--- a/lib/ssl/test/ssl_basic_SUITE.erl
+++ b/lib/ssl/test/ssl_basic_SUITE.erl
@@ -353,11 +353,11 @@ init_per_testcase(rizzo, Config) ->
 init_per_testcase(prf, Config) ->
     ct:log("TLS/SSL version ~p~n ", [tls_record:supported_protocol_versions()]),
     ct:timetrap({seconds, 40}),
-    case ?config(tc_group_path, Config) of
+    case proplists:get_value(tc_group_path, Config) of
         [] -> Prop = [];
         [Prop] -> Prop
     end,
-    case ?config(name, Prop) of
+    case proplists:get_value(name, Prop) of
         undefined -> TlsVersions = [sslv3, tlsv1, 'tlsv1.1', 'tlsv1.2'];
         TlsVersion when is_atom(TlsVersion) ->
             TlsVersions = [TlsVersion]
@@ -494,16 +494,16 @@ new_options_in_accept(Config) when is_list(Config) ->
 prf() ->
     [{doc,"Test that ssl:prf/5 uses the negotiated PRF."}].
 prf(Config) when is_list(Config) ->
-    TestPlan = ?config(prf_test_plan, Config),
+    TestPlan = proplists:get_value(prf_test_plan, Config),
     case TestPlan of
         [] -> ct:fail({error, empty_prf_test_plan});
         _ -> lists:foreach(fun(Suite) ->
                                    lists:foreach(
                                      fun(Test) ->
-                                             V = ?config(tls_ver, Test),
-                                             C = ?config(ciphers, Test),
-                                             E = ?config(expected, Test),
-                                             P = ?config(prf, Test),
+                                             V = proplists:get_value(tls_ver, Test),
+                                             C = proplists:get_value(ciphers, Test),
+                                             E = proplists:get_value(expected, Test),
+                                             P = proplists:get_value(prf, Test),
                                              prf_run_test(Config, V, C, E, P)
                                      end, Suite)
                            end, TestPlan)
@@ -3825,8 +3825,8 @@ prf_run_test(_, TlsVer, [], _, Prf) ->
 prf_run_test(Config, TlsVer, Ciphers, Expected, Prf) ->
     {ClientNode, ServerNode, Hostname} = ssl_test_lib:run_where(Config),
     BaseOpts = [{active, true}, {versions, [TlsVer]}, {ciphers, Ciphers}],
-    ServerOpts = BaseOpts ++ ?config(server_opts, Config),
-    ClientOpts = BaseOpts ++ ?config(client_opts, Config),
+    ServerOpts = BaseOpts ++ proplists:get_value(server_opts, Config),
+    ClientOpts = BaseOpts ++ proplists:get_value(client_opts, Config),
     Server = ssl_test_lib:start_server(
                [{node, ServerNode}, {port, 0}, {from, self()},
                 {mfa, {?MODULE, prf_verify_value, [TlsVer, Expected, Prf]}},
diff --git a/lib/ssl/test/ssl_crl_SUITE.erl b/lib/ssl/test/ssl_crl_SUITE.erl
index 291a5f3fde..aa321407b7 100644
--- a/lib/ssl/test/ssl_crl_SUITE.erl
+++ b/lib/ssl/test/ssl_crl_SUITE.erl
@@ -97,8 +97,8 @@ init_per_group(Group, Config0) ->
 	true ->
 	    [{idp_crl, true} | Config0];
 	false ->
-	    DataDir = ?config(data_dir, Config0), 
-	    CertDir = filename:join(?config(priv_dir, Config0), Group),
+	    DataDir = proplists:get_value(data_dir, Config0), 
+	    CertDir = filename:join(proplists:get_value(priv_dir, Config0), Group),
 	    {CertOpts, Config} = init_certs(CertDir, Group, Config0),
 	    {ok, _} =  make_certs:all(DataDir, CertDir, CertOpts),
 	    [{cert_dir, CertDir}, {idp_crl, false} | Config]
@@ -109,23 +109,23 @@ end_per_group(_GroupName, Config) ->
     Config.
 
 init_per_testcase(Case, Config0) ->
-    case ?config(idp_crl, Config0) of
+    case proplists:get_value(idp_crl, Config0) of
 	true ->
 	    end_per_testcase(Case, Config0),
 	    inets:start(),
 	    ssl:start(),
-	    ServerRoot = make_dir_path([?config(priv_dir, Config0), idp_crl, tmp]),
+	    ServerRoot = make_dir_path([proplists:get_value(priv_dir, Config0), idp_crl, tmp]),
 	    %% start a HTTP server to serve the CRLs
-	    {ok, Httpd} = inets:start(httpd, [{ipfamily, ?config(ipfamily, Config0)},
+	    {ok, Httpd} = inets:start(httpd, [{ipfamily, proplists:get_value(ipfamily, Config0)},
 					      {server_name, "localhost"}, {port, 0},
 					      {server_root, ServerRoot},
 					      {document_root, 
-					       filename:join(?config(priv_dir, Config0), idp_crl)}
+					       filename:join(proplists:get_value(priv_dir, Config0), idp_crl)}
 					     ]),
 	    [{port,Port}] = httpd:info(Httpd, [port]),
 	    Config = [{httpd_port, Port} | Config0],
-	    DataDir = ?config(data_dir, Config), 
-	    CertDir = filename:join(?config(priv_dir, Config0), idp_crl),
+	    DataDir = proplists:get_value(data_dir, Config), 
+	    CertDir = filename:join(proplists:get_value(priv_dir, Config0), idp_crl),
 	    {CertOpts, Config} = init_certs(CertDir, idp_crl, Config),
 	    {ok, _} =  make_certs:all(DataDir, CertDir, CertOpts),
 	    ct:timetrap({seconds, 6}),
@@ -137,7 +137,7 @@ init_per_testcase(Case, Config0) ->
     end.
 
 end_per_testcase(_, Config) ->
-    case ?config(idp_crl, Config) of
+    case proplists:get_value(idp_crl, Config) of
 	true ->
 	    ssl:stop(),
 	    inets:stop();
@@ -152,12 +152,12 @@ end_per_testcase(_, Config) ->
 crl_verify_valid() ->
     [{doc,"Verify a simple valid CRL chain"}].
 crl_verify_valid(Config) when is_list(Config) ->
-    PrivDir = ?config(cert_dir, Config),
-    Check = ?config(crl_check, Config),
+    PrivDir = proplists:get_value(cert_dir, Config),
+    Check = proplists:get_value(crl_check, Config),
     ServerOpts =  [{keyfile, filename:join([PrivDir, "server", "key.pem"])},
       		  {certfile, filename:join([PrivDir, "server", "cert.pem"])},
 		   {cacertfile, filename:join([PrivDir, "server", "cacerts.pem"])}],
-    ClientOpts =  case ?config(idp_crl, Config) of 
+    ClientOpts =  case proplists:get_value(idp_crl, Config) of 
 		      true ->	       
 			  [{cacertfile, filename:join([PrivDir, "server", "cacerts.pem"])},
 			   {crl_check, Check},
@@ -178,8 +178,8 @@ crl_verify_valid(Config) when is_list(Config) ->
 crl_verify_revoked() ->
     [{doc,"Verify a simple CRL chain when peer cert is reveoked"}].
 crl_verify_revoked(Config)  when is_list(Config) ->
-    PrivDir = ?config(cert_dir, Config),
-    Check = ?config(crl_check, Config),
+    PrivDir = proplists:get_value(cert_dir, Config),
+    Check = proplists:get_value(crl_check, Config),
     ServerOpts = [{keyfile, filename:join([PrivDir, "revoked", "key.pem"])},
       		  {certfile, filename:join([PrivDir, "revoked", "cert.pem"])},
       		  {cacertfile, filename:join([PrivDir, "revoked", "cacerts.pem"])}],
@@ -189,7 +189,7 @@ crl_verify_revoked(Config)  when is_list(Config) ->
     ssl_crl_cache:insert({file, filename:join([PrivDir, "erlangCA", "crl.pem"])}),
     ssl_crl_cache:insert({file, filename:join([PrivDir, "otpCA", "crl.pem"])}),
     
-    ClientOpts =  case ?config(idp_crl, Config) of 
+    ClientOpts =  case proplists:get_value(idp_crl, Config) of 
 		      true ->	       
 			  [{cacertfile, filename:join([PrivDir, "revoked", "cacerts.pem"])},
 			   {crl_cache, {ssl_crl_cache, {internal, [{http, 5000}]}}},
@@ -207,12 +207,12 @@ crl_verify_revoked(Config)  when is_list(Config) ->
 crl_verify_no_crl() ->
     [{doc,"Verify a simple CRL chain when the CRL is missing"}].
 crl_verify_no_crl(Config) when is_list(Config) ->
-    PrivDir = ?config(cert_dir, Config),
-    Check = ?config(crl_check, Config),
+    PrivDir = proplists:get_value(cert_dir, Config),
+    Check = proplists:get_value(crl_check, Config),
     ServerOpts =  [{keyfile, filename:join([PrivDir, "server", "key.pem"])},
       		  {certfile, filename:join([PrivDir, "server", "cert.pem"])},
 		   {cacertfile, filename:join([PrivDir, "server", "cacerts.pem"])}],
-    ClientOpts =  case ?config(idp_crl, Config) of 
+    ClientOpts =  case proplists:get_value(idp_crl, Config) of 
 		      true ->	       
 			  [{cacertfile, filename:join([PrivDir, "server", "cacerts.pem"])},
 			   {crl_check, Check},
@@ -297,7 +297,7 @@ is_idp(_) ->
 init_certs(_,v1_crl, Config)  -> 
     {[{v2_crls, false}], Config};
 init_certs(_, idp_crl, Config) -> 
-    Port = ?config(httpd_port, Config),
+    Port = proplists:get_value(httpd_port, Config),
     {[{crl_port,Port},
       {issuing_distribution_point, true}], Config
     };
diff --git a/lib/ssl/test/ssl_dist_SUITE.erl b/lib/ssl/test/ssl_dist_SUITE.erl
index e7cbfa63f4..d90ec428ee 100644
--- a/lib/ssl/test/ssl_dist_SUITE.erl
+++ b/lib/ssl/test/ssl_dist_SUITE.erl
@@ -502,7 +502,7 @@ start_ssl_node(Config) ->
 
 start_ssl_node(Config, XArgs) ->
     Name = mk_node_name(Config),
-    SSL = ?config(ssl_opts, Config),
+    SSL = proplists:get_value(ssl_opts, Config),
     SSLDistOpts = setup_dist_opts(Config),
     start_ssl_node_raw(Name, SSL ++ " " ++ SSLDistOpts ++ XArgs).
 
@@ -539,7 +539,7 @@ host_name() ->
 
 mk_node_name(Config) ->
     N = erlang:unique_integer([positive]),
-    Case = ?config(testcase, Config),
+    Case = proplists:get_value(testcase, Config),
     atom_to_list(?MODULE)
 	++ "_"
 	++ atom_to_list(Case)
@@ -792,7 +792,7 @@ do_append_files([F|Fs], RF) ->
     do_append_files(Fs, RF).
 
 setup_certs(Config) ->
-    PrivDir = ?config(priv_dir, Config),
+    PrivDir = proplists:get_value(priv_dir, Config),
     NodeDir = filename:join([PrivDir, "Certs"]),
     RGenDir = filename:join([NodeDir, "rand_gen"]),
     ok = file:make_dir(NodeDir),
@@ -811,8 +811,8 @@ setup_certs(Config) ->
     append_files([CK, CC], CKC).
 
 setup_dist_opts(Config) ->
-    PrivDir = ?config(priv_dir, Config),
-    DataDir = ?config(data_dir, Config),
+    PrivDir = proplists:get_value(priv_dir, Config),
+    DataDir = proplists:get_value(data_dir, Config),
     Dhfile = filename:join([DataDir, "dHParam.pem"]),
     NodeDir = filename:join([PrivDir, "Certs"]),
     SDir = filename:join([NodeDir, "server"]),
@@ -874,7 +874,7 @@ add_ssl_opts_config(Config) ->
     %% just point out ssl ebin with -pa.
     %%
     try
-	Dir = ?config(priv_dir, Config),
+	Dir = proplists:get_value(priv_dir, Config),
 	LibDir = code:lib_dir(),
 	Apps = application:which_applications(),
 	{value, {stdlib, _, STDL_VSN}} = lists:keysearch(stdlib, 1, Apps),
diff --git a/lib/ssl/test/ssl_handshake_SUITE.erl b/lib/ssl/test/ssl_handshake_SUITE.erl
index d050812208..26e83413c1 100644
--- a/lib/ssl/test/ssl_handshake_SUITE.erl
+++ b/lib/ssl/test/ssl_handshake_SUITE.erl
@@ -62,8 +62,8 @@ init_per_testcase(ignore_hassign_extension_pre_tls_1_2, Config0) ->
 		true ->
 		    ssl:start(),
 		    %% make rsa certs using oppenssl
-		    {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)),
 		    Config = ssl_test_lib:cert_options(Config0),
 		    ct:timetrap({seconds, 5}),
 		    Config;
@@ -162,7 +162,7 @@ select_proper_tls_1_2_rsa_default_hashsign(_Config) ->
 
 
 ignore_hassign_extension_pre_tls_1_2(Config) ->
-    Opts = ?config(server_opts, Config),
+    Opts = proplists:get_value(server_opts, Config),
     CertFile = proplists:get_value(certfile, Opts),
     [{_, Cert, _}] = ssl_test_lib:pem_to_der(CertFile),
     HashSigns = #hash_sign_algos{hash_sign_algos = [{sha512, rsa}, {sha, dsa}]},
diff --git a/lib/ssl/test/ssl_npn_handshake_SUITE.erl b/lib/ssl/test/ssl_npn_handshake_SUITE.erl
index 8363c80cf4..c55fa73cfb 100644
--- a/lib/ssl/test/ssl_npn_handshake_SUITE.erl
+++ b/lib/ssl/test/ssl_npn_handshake_SUITE.erl
@@ -69,8 +69,8 @@ init_per_suite(Config) ->
     try crypto:start() of
 	ok ->
 	    ssl:start(),
-	    {ok, _} = make_certs:all(?config(data_dir, Config),
-				      ?config(priv_dir, Config)),
+	    {ok, _} = make_certs:all(proplists:get_value(data_dir, Config),
+				      proplists:get_value(priv_dir, Config)),
 	    ssl_test_lib:cert_options(Config)
     catch _:_ ->
 	    {skip, "Crypto did not start"}
diff --git a/lib/ssl/test/ssl_packet_SUITE.erl b/lib/ssl/test/ssl_packet_SUITE.erl
index cc5fec929a..92c0c1eb01 100644
--- a/lib/ssl/test/ssl_packet_SUITE.erl
+++ b/lib/ssl/test/ssl_packet_SUITE.erl
@@ -137,8 +137,8 @@ init_per_suite(Config) ->
     try crypto:start() of
 	ok ->
 	    ssl:start(),
-	    {ok, _} = make_certs:all(?config(data_dir, Config),
-				     ?config(priv_dir, Config)),
+	    {ok, _} = make_certs:all(proplists:get_value(data_dir, Config),
+				     proplists:get_value(priv_dir, Config)),
 	    ssl_test_lib:cert_options(Config)
     catch _:_ ->
 	    {skip, "Crypto did not start"}
diff --git a/lib/ssl/test/ssl_payload_SUITE.erl b/lib/ssl/test/ssl_payload_SUITE.erl
index 1c81dcd8b6..cb0571d0a7 100644
--- a/lib/ssl/test/ssl_payload_SUITE.erl
+++ b/lib/ssl/test/ssl_payload_SUITE.erl
@@ -71,7 +71,7 @@ init_per_suite(Config) ->
     try crypto:start() of
 	ok ->
 	    ssl:start(),
-	    {ok, _} = make_certs:all(?config(data_dir, Config), ?config(priv_dir, Config)),
+	    {ok, _} = make_certs:all(proplists:get_value(data_dir, Config), proplists:get_value(priv_dir, Config)),
 	    ssl_test_lib:cert_options(Config)
     catch _:_  ->
 	    {skip, "Crypto did not start"}
diff --git a/lib/ssl/test/ssl_pem_cache_SUITE.erl b/lib/ssl/test/ssl_pem_cache_SUITE.erl
index 3e96276258..13b0ce8ed9 100644
--- a/lib/ssl/test/ssl_pem_cache_SUITE.erl
+++ b/lib/ssl/test/ssl_pem_cache_SUITE.erl
@@ -45,8 +45,8 @@ init_per_suite(Config0) ->
 	ok ->
 	    ssl:start(),
 	    %% make rsa certs using oppenssl
-	    {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),
 	    ssl_test_lib:cert_options(Config1)
     catch _:_ ->
@@ -81,8 +81,8 @@ pem_cleanup() ->
     [{doc, "Test pem cache invalidate mechanism"}].
 pem_cleanup(Config)when is_list(Config) ->
     process_flag(trap_exit, true),
-    ClientOpts = ?config(client_opts, Config),
-    ServerOpts = ?config(server_opts, Config),
+    ClientOpts = proplists:get_value(client_opts, Config),
+    ServerOpts = proplists:get_value(server_opts, Config),
     {ClientNode, ServerNode, Hostname} = ssl_test_lib:run_where(Config),
 
     Server =
diff --git a/lib/ssl/test/ssl_session_cache_SUITE.erl b/lib/ssl/test/ssl_session_cache_SUITE.erl
index fa74e111ec..5e6137d2a6 100644
--- a/lib/ssl/test/ssl_session_cache_SUITE.erl
+++ b/lib/ssl/test/ssl_session_cache_SUITE.erl
@@ -60,8 +60,8 @@ init_per_suite(Config0) ->
 	ok ->
 	    ssl:start(),
 	    %% make rsa certs using 
-	    {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)),
 	    Config = ssl_test_lib:make_dsa_cert(Config0),
 	    ssl_test_lib:cert_options(Config)
     catch _:_ ->
@@ -154,8 +154,8 @@ client_unique_session() ->
       "sets up many connections"}].
 client_unique_session(Config) when is_list(Config) ->
     process_flag(trap_exit, true),
-    ClientOpts = ?config(client_opts, Config),
-    ServerOpts = ?config(server_opts, Config),
+    ClientOpts = proplists:get_value(client_opts, Config),
+    ServerOpts = proplists:get_value(server_opts, Config),
     {ClientNode, ServerNode, Hostname} = ssl_test_lib:run_where(Config),
     Server =
 	ssl_test_lib:start_server([{node, ServerNode}, {port, 0},
@@ -259,8 +259,8 @@ max_table_size() ->
     [{doc,"Test max limit on session table"}].
 max_table_size(Config) when is_list(Config) ->
     process_flag(trap_exit, true),
-    ClientOpts = ?config(client_verification_opts, Config),
-    ServerOpts = ?config(server_verification_opts, Config),
+    ClientOpts = proplists:get_value(client_verification_opts, Config),
+    ServerOpts = proplists:get_value(server_verification_opts, Config),
     {ClientNode, ServerNode, Hostname} = ssl_test_lib:run_where(Config),
     Server =
 	ssl_test_lib:start_server([{node, ServerNode}, {port, 0},
diff --git a/lib/ssl/test/ssl_sni_SUITE.erl b/lib/ssl/test/ssl_sni_SUITE.erl
index 9c8a915b94..34ef2e6af9 100644
--- a/lib/ssl/test/ssl_sni_SUITE.erl
+++ b/lib/ssl/test/ssl_sni_SUITE.erl
@@ -42,8 +42,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)),
             ssl_test_lib:cert_options(Config0)
     catch _:_  ->
             {skip, "Crypto did not start"}
@@ -139,15 +139,15 @@ run_sni_fun_handshake(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}],
     ClientOptions = 
     case SNIHostname of
         undefined ->
-            ?config(client_opts, Config);
+            proplists:get_value(client_opts, Config);
         _ ->
-            [{server_name_indication, SNIHostname}] ++ ?config(client_opts, Config)
+            [{server_name_indication, SNIHostname}] ++ proplists:get_value(client_opts, Config)
     end,
     ct:log("Options: ~p", [[ServerOptions, ClientOptions]]),
     {ClientNode, ServerNode, Hostname} = ssl_test_lib:run_where(Config),
@@ -167,13 +167,13 @@ run_handshake(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),
     ClientOptions = 
     case SNIHostname of
         undefined ->
-            ?config(client_opts, Config);
+            proplists:get_value(client_opts, Config);
         _ ->
-            [{server_name_indication, SNIHostname}] ++ ?config(client_opts, Config)
+            [{server_name_indication, SNIHostname}] ++ proplists:get_value(client_opts, Config)
     end,
     ct:log("Options: ~p", [[ServerOptions, ClientOptions]]),
     {ClientNode, ServerNode, Hostname} = ssl_test_lib:run_where(Config),
diff --git a/lib/ssl/test/ssl_test_lib.erl b/lib/ssl/test/ssl_test_lib.erl
index 6949cbb6ed..543728627e 100644
--- a/lib/ssl/test/ssl_test_lib.erl
+++ b/lib/ssl/test/ssl_test_lib.erl
@@ -354,37 +354,37 @@ user_lookup(srp, Username, _UserState) ->
     {ok, {srp_1024, Salt, UserPassHash}}.
 
 cert_options(Config) ->
-    ClientCaCertFile = filename:join([?config(priv_dir, Config), 
+    ClientCaCertFile = filename:join([proplists:get_value(priv_dir, Config), 
 				      "client", "cacerts.pem"]),
-    ClientCertFile = filename:join([?config(priv_dir, Config), 
+    ClientCertFile = filename:join([proplists:get_value(priv_dir, Config), 
 				    "client", "cert.pem"]),
-    ClientCertFileDigitalSignatureOnly = filename:join([?config(priv_dir, Config),
+    ClientCertFileDigitalSignatureOnly = filename:join([proplists:get_value(priv_dir, Config),
 				    "client", "digital_signature_only_cert.pem"]),
-    ServerCaCertFile = filename:join([?config(priv_dir, Config), 
+    ServerCaCertFile = filename:join([proplists:get_value(priv_dir, Config), 
 				      "server", "cacerts.pem"]),
-    ServerCertFile = filename:join([?config(priv_dir, Config), 
+    ServerCertFile = filename:join([proplists:get_value(priv_dir, Config), 
 				    "server", "cert.pem"]),
-    ServerKeyFile = filename:join([?config(priv_dir, Config), 
+    ServerKeyFile = filename:join([proplists:get_value(priv_dir, Config), 
 			     "server", "key.pem"]),
-    ClientKeyFile = filename:join([?config(priv_dir, Config), 
+    ClientKeyFile = filename:join([proplists:get_value(priv_dir, Config), 
 			     "client", "key.pem"]),
-    ServerKeyCertFile = filename:join([?config(priv_dir, Config), 
+    ServerKeyCertFile = filename:join([proplists:get_value(priv_dir, Config), 
 				       "server", "keycert.pem"]),
-    ClientKeyCertFile = filename:join([?config(priv_dir, Config), 
+    ClientKeyCertFile = filename:join([proplists:get_value(priv_dir, Config), 
 				       "client", "keycert.pem"]),
 
-    BadCaCertFile = filename:join([?config(priv_dir, Config), 
+    BadCaCertFile = filename:join([proplists:get_value(priv_dir, Config), 
 				   "badcacert.pem"]),
-    BadCertFile = filename:join([?config(priv_dir, Config), 
+    BadCertFile = filename:join([proplists:get_value(priv_dir, Config), 
 				   "badcert.pem"]),
-    BadKeyFile = filename:join([?config(priv_dir, Config), 
+    BadKeyFile = filename:join([proplists:get_value(priv_dir, Config), 
 			      "badkey.pem"]),
     PskSharedSecret = <<1,2,3,4,5,6,7,8,9,10,11,12,13,14,15>>,
 
-    SNIServerACertFile = filename:join([?config(priv_dir, Config), "a.server", "cert.pem"]),
-    SNIServerAKeyFile = filename:join([?config(priv_dir, Config), "a.server", "key.pem"]),
-    SNIServerBCertFile = filename:join([?config(priv_dir, Config), "b.server", "cert.pem"]),
-    SNIServerBKeyFile = filename:join([?config(priv_dir, Config), "b.server", "key.pem"]),
+    SNIServerACertFile = filename:join([proplists:get_value(priv_dir, Config), "a.server", "cert.pem"]),
+    SNIServerAKeyFile = filename:join([proplists:get_value(priv_dir, Config), "a.server", "key.pem"]),
+    SNIServerBCertFile = filename:join([proplists:get_value(priv_dir, Config), "b.server", "cert.pem"]),
+    SNIServerBKeyFile = filename:join([proplists:get_value(priv_dir, Config), "b.server", "key.pem"]),
     [{client_opts, []}, 
      {client_verification_opts, [{cacertfile, ServerCaCertFile}, 
 				{certfile, ClientCertFile},  
@@ -552,11 +552,11 @@ make_cert_files(RoleStr, Config, Alg1, Alg2, Prefix) ->
     Alg2Str = atom_to_list(Alg2),
     CaInfo = {CaCert, _} = erl_make_certs:make_cert([{key, Alg1}]),
     {Cert, CertKey} = erl_make_certs:make_cert([{key, Alg2}, {issuer, CaInfo}]),
-    CaCertFile = filename:join([?config(priv_dir, Config), 
+    CaCertFile = filename:join([proplists:get_value(priv_dir, Config), 
 				RoleStr, Prefix ++ Alg1Str ++ "_cacerts.pem"]),
-    CertFile = filename:join([?config(priv_dir, Config), 
+    CertFile = filename:join([proplists:get_value(priv_dir, Config), 
 			      RoleStr, Prefix ++ Alg2Str ++ "_cert.pem"]),
-    KeyFile = filename:join([?config(priv_dir, Config), 
+    KeyFile = filename:join([proplists:get_value(priv_dir, Config), 
 				   RoleStr, Prefix ++ Alg2Str ++ "_key.pem"]),
     
     der_to_pem(CaCertFile, [{'Certificate', CaCert, not_encrypted}]),
@@ -1311,7 +1311,7 @@ do_supports_ssl_tls_version(Port) ->
 
 ssl_options(Option, Config) ->
     ProtocolOpts = proplists:get_value(protocol_opts, Config, []),
-    Opts = ?config(Option, Config),
+    Opts = proplists:get_value(Option, Config, []),
     Opts ++ ProtocolOpts.
 
 protocol_version(Config) ->
diff --git a/lib/ssl/test/ssl_to_openssl_SUITE.erl b/lib/ssl/test/ssl_to_openssl_SUITE.erl
index 01c1cf5d33..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)
@@ -774,8 +774,8 @@ 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),  
+    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),
     
@@ -1272,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, []}},
@@ -1299,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, []}},
@@ -1429,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),
@@ -1465,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),
@@ -1494,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],
 
@@ -1534,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],
 
diff --git a/lib/ssl/test/ssl_upgrade_SUITE.erl b/lib/ssl/test/ssl_upgrade_SUITE.erl
index 3975fbb5de..113b3b4158 100644
--- a/lib/ssl/test/ssl_upgrade_SUITE.erl
+++ b/lib/ssl/test/ssl_upgrade_SUITE.erl
@@ -47,8 +47,8 @@ init_per_suite(Config0) ->
                     {skip, Reason};
                 Config ->
                     Result =
-                    {ok, _} = make_certs:all(?config(data_dir, Config),
-                                             ?config(priv_dir, Config)),
+                    {ok, _} = make_certs:all(proplists:get_value(data_dir, Config),
+                                             proplists:get_value(priv_dir, Config)),
                     ssl_test_lib:cert_options(Config)
             end
     catch _:_ ->
@@ -139,8 +139,8 @@ use_connection(Socket) ->
     end.
 
 soft_start_connection(Config, ResulProxy) ->
-    ClientOpts = ?config(client_verification_opts, Config),
-    ServerOpts = ?config(server_verification_opts, Config),
+    ClientOpts = proplists:get_value(client_verification_opts, Config),
+    ServerOpts = proplists:get_value(server_verification_opts, Config),
     {ClientNode, ServerNode, Hostname} = ssl_test_lib:run_where(Config),
     Server = start_server([{node, ServerNode}, {port, 0},
 			   {from, ResulProxy},
@@ -156,8 +156,8 @@ soft_start_connection(Config, ResulProxy) ->
     {Server, Client}.
 
 restart_start_connection(Config, ResulProxy) ->
-    ClientOpts = ?config(client_verification_opts, Config),
-    ServerOpts = ?config(server_verification_opts, Config),
+    ClientOpts = proplists:get_value(client_verification_opts, Config),
+    ServerOpts = proplists:get_value(server_verification_opts, Config),
     {ClientNode, ServerNode, Hostname} = ssl_test_lib:run_where(Config),
     Server = start_server([{node, ServerNode}, {port, 0},
 					{from, ResulProxy},