1/*
| 1/*
|
2 * Copyright 2016-2018 The OpenSSL Project Authors. All Rights Reserved.
| 2 * Copyright 2016 The OpenSSL Project Authors. All Rights Reserved.
|
3 *
4 * Licensed under the OpenSSL license (the "License"). You may not use
5 * this file except in compliance with the License. You can obtain a copy
6 * in the file LICENSE in the source distribution or at
7 * https://www.openssl.org/source/license.html
8 */
9
10/*
11 * Ideally, CONF should offer standard parsing methods and cover them
12 * in tests. But since we have no CONF tests, we use a custom test for now.
13 */
14
15#include <stdio.h>
16#include <string.h>
17
| 3 *
4 * Licensed under the OpenSSL license (the "License"). You may not use
5 * this file except in compliance with the License. You can obtain a copy
6 * in the file LICENSE in the source distribution or at
7 * https://www.openssl.org/source/license.html
8 */
9
10/*
11 * Ideally, CONF should offer standard parsing methods and cover them
12 * in tests. But since we have no CONF tests, we use a custom test for now.
13 */
14
15#include <stdio.h>
16#include <string.h>
17
|
18#include "internal/nelem.h"
| 18#include "e_os.h"
|
19#include "ssl_test_ctx.h"
20#include "testutil.h"
21#include <openssl/e_os2.h>
22#include <openssl/err.h>
23#include <openssl/conf.h>
24#include <openssl/ssl.h>
25
26static CONF *conf = NULL;
27
28typedef struct ssl_test_ctx_test_fixture {
29 const char *test_case_name;
30 const char *test_section;
31 /* Expected parsed configuration. */
32 SSL_TEST_CTX *expected_ctx;
33} SSL_TEST_CTX_TEST_FIXTURE;
34
35
| 19#include "ssl_test_ctx.h"
20#include "testutil.h"
21#include <openssl/e_os2.h>
22#include <openssl/err.h>
23#include <openssl/conf.h>
24#include <openssl/ssl.h>
25
26static CONF *conf = NULL;
27
28typedef struct ssl_test_ctx_test_fixture {
29 const char *test_case_name;
30 const char *test_section;
31 /* Expected parsed configuration. */
32 SSL_TEST_CTX *expected_ctx;
33} SSL_TEST_CTX_TEST_FIXTURE;
34
35
|
36static int clientconf_eq(SSL_TEST_CLIENT_CONF *conf1,
37 SSL_TEST_CLIENT_CONF *conf2)
| 36static int SSL_TEST_CLIENT_CONF_equal(SSL_TEST_CLIENT_CONF *client,
37 SSL_TEST_CLIENT_CONF *client2)
|
38{
| 38{
|
39 if (!TEST_int_eq(conf1->verify_callback, conf2->verify_callback)
40 || !TEST_int_eq(conf1->servername, conf2->servername)
41 || !TEST_str_eq(conf1->npn_protocols, conf2->npn_protocols)
42 || !TEST_str_eq(conf1->alpn_protocols, conf2->alpn_protocols)
43 || !TEST_int_eq(conf1->ct_validation, conf2->ct_validation)
44 || !TEST_int_eq(conf1->max_fragment_len_mode,
45 conf2->max_fragment_len_mode))
| 39 if (client->verify_callback != client2->verify_callback) {
40 fprintf(stderr, "ClientVerifyCallback mismatch: %s vs %s.\n",
41 ssl_verify_callback_name(client->verify_callback),
42 ssl_verify_callback_name(client2->verify_callback));
|
46 return 0;
| 43 return 0;
|
| 44 }
45 if (client->servername != client2->servername) {
46 fprintf(stderr, "ServerName mismatch: %s vs %s.\n",
47 ssl_servername_name(client->servername),
48 ssl_servername_name(client2->servername));
49 return 0;
50 }
51 if (!strings_equal("Client NPNProtocols", client->npn_protocols,
52 client2->npn_protocols))
53 return 0;
54 if (!strings_equal("Client ALPNProtocols", client->alpn_protocols,
55 client2->alpn_protocols))
56 return 0;
57 if (client->ct_validation != client2->ct_validation) {
58 fprintf(stderr, "CTValidation mismatch: %s vs %s.\n",
59 ssl_ct_validation_name(client->ct_validation),
60 ssl_ct_validation_name(client2->ct_validation));
61 return 0;
62 }
|
47 return 1;
48}
49
| 63 return 1;
64}
65
|
50static int serverconf_eq(SSL_TEST_SERVER_CONF *serv,
51 SSL_TEST_SERVER_CONF *serv2)
| 66static int SSL_TEST_SERVER_CONF_equal(SSL_TEST_SERVER_CONF *server,
67 SSL_TEST_SERVER_CONF *server2)
|
52{
| 68{
|
53 if (!TEST_int_eq(serv->servername_callback, serv2->servername_callback)
54 || !TEST_str_eq(serv->npn_protocols, serv2->npn_protocols)
55 || !TEST_str_eq(serv->alpn_protocols, serv2->alpn_protocols)
56 || !TEST_int_eq(serv->broken_session_ticket,
57 serv2->broken_session_ticket)
58 || !TEST_str_eq(serv->session_ticket_app_data,
59 serv2->session_ticket_app_data)
60 || !TEST_int_eq(serv->cert_status, serv2->cert_status))
| 69 if (server->servername_callback != server2->servername_callback) {
70 fprintf(stderr, "ServerNameCallback mismatch: %s vs %s.\n",
71 ssl_servername_callback_name(server->servername_callback),
72 ssl_servername_callback_name(server2->servername_callback));
|
61 return 0;
| 73 return 0;
|
| 74 }
75 if (!strings_equal("Server NPNProtocols", server->npn_protocols,
76 server2->npn_protocols))
77 return 0;
78 if (!strings_equal("Server ALPNProtocols", server->alpn_protocols,
79 server2->alpn_protocols))
80 return 0;
81 if (server->broken_session_ticket != server2->broken_session_ticket) {
82 fprintf(stderr, "Broken session ticket mismatch: %d vs %d.\n",
83 server->broken_session_ticket, server2->broken_session_ticket);
84 return 0;
85 }
86 if (server->cert_status != server2->cert_status) {
87 fprintf(stderr, "CertStatus mismatch: %s vs %s.\n",
88 ssl_certstatus_name(server->cert_status),
89 ssl_certstatus_name(server2->cert_status));
90 return 0;
91 }
|
62 return 1;
63}
64
| 92 return 1;
93}
94
|
65static int extraconf_eq(SSL_TEST_EXTRA_CONF *extra,
66 SSL_TEST_EXTRA_CONF *extra2)
| 95static int SSL_TEST_EXTRA_CONF_equal(SSL_TEST_EXTRA_CONF *extra,
96 SSL_TEST_EXTRA_CONF *extra2)
|
67{
| 97{
|
68 if (!TEST_true(clientconf_eq(&extra->client, &extra2->client))
69 || !TEST_true(serverconf_eq(&extra->server, &extra2->server))
70 || !TEST_true(serverconf_eq(&extra->server2, &extra2->server2)))
71 return 0;
72 return 1;
| 98 return SSL_TEST_CLIENT_CONF_equal(&extra->client, &extra2->client)
99 && SSL_TEST_SERVER_CONF_equal(&extra->server, &extra2->server)
100 && SSL_TEST_SERVER_CONF_equal(&extra->server2, &extra2->server2);
|
73}
74
| 101}
102
|
75static int testctx_eq(SSL_TEST_CTX *ctx, SSL_TEST_CTX *ctx2)
| 103/* Returns 1 if the contexts are equal, 0 otherwise. */
104static int SSL_TEST_CTX_equal(SSL_TEST_CTX *ctx, SSL_TEST_CTX *ctx2)
|
76{
| 105{
|
77 if (!TEST_int_eq(ctx->method, ctx2->method)
78 || !TEST_int_eq(ctx->handshake_mode, ctx2->handshake_mode)
79 || !TEST_int_eq(ctx->app_data_size, ctx2->app_data_size)
80 || !TEST_int_eq(ctx->max_fragment_size, ctx2->max_fragment_size)
81 || !extraconf_eq(&ctx->extra, &ctx2->extra)
82 || !extraconf_eq(&ctx->resume_extra, &ctx2->resume_extra)
83 || !TEST_int_eq(ctx->expected_result, ctx2->expected_result)
84 || !TEST_int_eq(ctx->expected_client_alert,
85 ctx2->expected_client_alert)
86 || !TEST_int_eq(ctx->expected_server_alert,
87 ctx2->expected_server_alert)
88 || !TEST_int_eq(ctx->expected_protocol, ctx2->expected_protocol)
89 || !TEST_int_eq(ctx->expected_servername, ctx2->expected_servername)
90 || !TEST_int_eq(ctx->session_ticket_expected,
91 ctx2->session_ticket_expected)
92 || !TEST_int_eq(ctx->compression_expected,
93 ctx2->compression_expected)
94 || !TEST_str_eq(ctx->expected_npn_protocol,
95 ctx2->expected_npn_protocol)
96 || !TEST_str_eq(ctx->expected_alpn_protocol,
97 ctx2->expected_alpn_protocol)
98 || !TEST_str_eq(ctx->expected_cipher,
99 ctx2->expected_cipher)
100 || !TEST_str_eq(ctx->expected_session_ticket_app_data,
101 ctx2->expected_session_ticket_app_data)
102 || !TEST_int_eq(ctx->resumption_expected,
103 ctx2->resumption_expected)
104 || !TEST_int_eq(ctx->session_id_expected,
105 ctx2->session_id_expected))
| 106 if (ctx->method != ctx2->method) {
107 fprintf(stderr, "Method mismatch: %s vs %s.\n",
108 ssl_test_method_name(ctx->method),
109 ssl_test_method_name(ctx2->method));
|
106 return 0;
| 110 return 0;
|
| 111 }
112 if (ctx->handshake_mode != ctx2->handshake_mode) {
113 fprintf(stderr, "HandshakeMode mismatch: %s vs %s.\n",
114 ssl_handshake_mode_name(ctx->handshake_mode),
115 ssl_handshake_mode_name(ctx2->handshake_mode));
116 return 0;
117 }
118 if (ctx->app_data_size != ctx2->app_data_size) {
119 fprintf(stderr, "ApplicationData mismatch: %d vs %d.\n",
120 ctx->app_data_size, ctx2->app_data_size);
121 return 0;
122 }
123
124 if (ctx->max_fragment_size != ctx2->max_fragment_size) {
125 fprintf(stderr, "MaxFragmentSize mismatch: %d vs %d.\n",
126 ctx->max_fragment_size, ctx2->max_fragment_size);
127 return 0;
128 }
129
130 if (!SSL_TEST_EXTRA_CONF_equal(&ctx->extra, &ctx2->extra)) {
131 fprintf(stderr, "Extra conf mismatch.\n");
132 return 0;
133 }
134 if (!SSL_TEST_EXTRA_CONF_equal(&ctx->resume_extra, &ctx2->resume_extra)) {
135 fprintf(stderr, "Resume extra conf mismatch.\n");
136 return 0;
137 }
138
139 if (ctx->expected_result != ctx2->expected_result) {
140 fprintf(stderr, "ExpectedResult mismatch: %s vs %s.\n",
141 ssl_test_result_name(ctx->expected_result),
142 ssl_test_result_name(ctx2->expected_result));
143 return 0;
144 }
145 if (ctx->expected_client_alert != ctx2->expected_client_alert) {
146 fprintf(stderr, "ClientAlert mismatch: %s vs %s.\n",
147 ssl_alert_name(ctx->expected_client_alert),
148 ssl_alert_name(ctx2->expected_client_alert));
149 return 0;
150 }
151 if (ctx->expected_server_alert != ctx2->expected_server_alert) {
152 fprintf(stderr, "ServerAlert mismatch: %s vs %s.\n",
153 ssl_alert_name(ctx->expected_server_alert),
154 ssl_alert_name(ctx2->expected_server_alert));
155 return 0;
156 }
157 if (ctx->expected_protocol != ctx2->expected_protocol) {
158 fprintf(stderr, "ClientAlert mismatch: %s vs %s.\n",
159 ssl_protocol_name(ctx->expected_protocol),
160 ssl_protocol_name(ctx2->expected_protocol));
161 return 0;
162 }
163 if (ctx->expected_servername != ctx2->expected_servername) {
164 fprintf(stderr, "ExpectedServerName mismatch: %s vs %s.\n",
165 ssl_servername_name(ctx->expected_servername),
166 ssl_servername_name(ctx2->expected_servername));
167 return 0;
168 }
169 if (ctx->session_ticket_expected != ctx2->session_ticket_expected) {
170 fprintf(stderr, "SessionTicketExpected mismatch: %s vs %s.\n",
171 ssl_session_ticket_name(ctx->session_ticket_expected),
172 ssl_session_ticket_name(ctx2->session_ticket_expected));
173 return 0;
174 }
175 if (!strings_equal("ExpectedNPNProtocol", ctx->expected_npn_protocol,
176 ctx2->expected_npn_protocol))
177 return 0;
178 if (!strings_equal("ExpectedALPNProtocol", ctx->expected_alpn_protocol,
179 ctx2->expected_alpn_protocol))
180 return 0;
181 if (ctx->resumption_expected != ctx2->resumption_expected) {
182 fprintf(stderr, "ResumptionExpected mismatch: %d vs %d.\n",
183 ctx->resumption_expected, ctx2->resumption_expected);
184 return 0;
185 }
|
107 return 1;
108}
109
| 186 return 1;
187}
188
|
110static SSL_TEST_CTX_TEST_FIXTURE *set_up(const char *const test_case_name)
| 189static SSL_TEST_CTX_TEST_FIXTURE set_up(const char *const test_case_name)
|
111{
| 190{
|
112 SSL_TEST_CTX_TEST_FIXTURE *fixture;
113
114 if (!TEST_ptr(fixture = OPENSSL_zalloc(sizeof(*fixture))))
115 return NULL;
116 fixture->test_case_name = test_case_name;
117 if (!TEST_ptr(fixture->expected_ctx = SSL_TEST_CTX_new())) {
118 OPENSSL_free(fixture);
119 return NULL;
120 }
| 191 SSL_TEST_CTX_TEST_FIXTURE fixture;
192 fixture.test_case_name = test_case_name;
193 fixture.expected_ctx = SSL_TEST_CTX_new();
194 TEST_check(fixture.expected_ctx != NULL);
|
121 return fixture;
122}
123
| 195 return fixture;
196}
197
|
124static int execute_test(SSL_TEST_CTX_TEST_FIXTURE *fixture)
| 198static int execute_test(SSL_TEST_CTX_TEST_FIXTURE fixture)
|
125{
126 int success = 0;
| 199{
200 int success = 0;
|
127 SSL_TEST_CTX *ctx;
| |
128
| 201
|
129 if (!TEST_ptr(ctx = SSL_TEST_CTX_create(conf, fixture->test_section))
130 || !testctx_eq(ctx, fixture->expected_ctx))
| 202 SSL_TEST_CTX *ctx = SSL_TEST_CTX_create(conf, fixture.test_section);
203
204 if (ctx == NULL) {
205 fprintf(stderr, "Failed to parse good configuration %s.\n",
206 fixture.test_section);
|
131 goto err;
| 207 goto err;
|
| 208 }
|
132
| 209
|
| 210 if (!SSL_TEST_CTX_equal(ctx, fixture.expected_ctx))
211 goto err;
212
|
133 success = 1;
134 err:
135 SSL_TEST_CTX_free(ctx);
136 return success;
137}
138
| 213 success = 1;
214 err:
215 SSL_TEST_CTX_free(ctx);
216 return success;
217}
218
|
139static void tear_down(SSL_TEST_CTX_TEST_FIXTURE *fixture)
| 219static int execute_failure_test(SSL_TEST_CTX_TEST_FIXTURE fixture)
|
140{
| 220{
|
141 SSL_TEST_CTX_free(fixture->expected_ctx);
142 OPENSSL_free(fixture);
| 221 SSL_TEST_CTX *ctx = SSL_TEST_CTX_create(conf, fixture.test_section);
222
223 if (ctx != NULL) {
224 fprintf(stderr, "Parsing bad configuration %s succeeded.\n",
225 fixture.test_section);
226 SSL_TEST_CTX_free(ctx);
227 return 0;
228 }
229
230 return 1;
|
143}
144
| 231}
232
|
145#define SETUP_SSL_TEST_CTX_TEST_FIXTURE() \
146 SETUP_TEST_FIXTURE(SSL_TEST_CTX_TEST_FIXTURE, set_up);
147#define EXECUTE_SSL_TEST_CTX_TEST() \
| 233static void tear_down(SSL_TEST_CTX_TEST_FIXTURE fixture)
234{
235 SSL_TEST_CTX_free(fixture.expected_ctx);
236 ERR_print_errors_fp(stderr);
237}
238
239#define SETUP_SSL_TEST_CTX_TEST_FIXTURE() \
240 SETUP_TEST_FIXTURE(SSL_TEST_CTX_TEST_FIXTURE, set_up)
241#define EXECUTE_SSL_TEST_CTX_TEST() \
|
148 EXECUTE_TEST(execute_test, tear_down)
| 242 EXECUTE_TEST(execute_test, tear_down)
|
| 243#define EXECUTE_SSL_TEST_CTX_FAILURE_TEST() \
244 EXECUTE_TEST(execute_failure_test, tear_down)
|
149
| 245
|
150static int test_empty_configuration(void)
| 246static int test_empty_configuration()
|
151{
152 SETUP_SSL_TEST_CTX_TEST_FIXTURE();
| 247{
248 SETUP_SSL_TEST_CTX_TEST_FIXTURE();
|
153 if (fixture == NULL)
154 return 0;
155 fixture->test_section = "ssltest_default";
156 fixture->expected_ctx->expected_result = SSL_TEST_SUCCESS;
| 249 fixture.test_section = "ssltest_default";
250 fixture.expected_ctx->expected_result = SSL_TEST_SUCCESS;
|
157 EXECUTE_SSL_TEST_CTX_TEST();
| 251 EXECUTE_SSL_TEST_CTX_TEST();
|
158 return result;
| |
159}
160
| 252}
253
|
161static int test_good_configuration(void)
| 254static int test_good_configuration()
|
162{
163 SETUP_SSL_TEST_CTX_TEST_FIXTURE();
| 255{
256 SETUP_SSL_TEST_CTX_TEST_FIXTURE();
|
164 if (fixture == NULL)
165 return 0;
166 fixture->test_section = "ssltest_good";
167 fixture->expected_ctx->method = SSL_TEST_METHOD_DTLS;
168 fixture->expected_ctx->handshake_mode = SSL_TEST_HANDSHAKE_RESUME;
169 fixture->expected_ctx->app_data_size = 1024;
170 fixture->expected_ctx->max_fragment_size = 2048;
| 257 fixture.test_section = "ssltest_good";
258 fixture.expected_ctx->method = SSL_TEST_METHOD_DTLS;
259 fixture.expected_ctx->handshake_mode = SSL_TEST_HANDSHAKE_RESUME;
260 fixture.expected_ctx->app_data_size = 1024;
261 fixture.expected_ctx->max_fragment_size = 2048;
|
171
| 262
|
172 fixture->expected_ctx->expected_result = SSL_TEST_SERVER_FAIL;
173 fixture->expected_ctx->expected_client_alert = SSL_AD_UNKNOWN_CA;
174 fixture->expected_ctx->expected_server_alert = 0; /* No alert. */
175 fixture->expected_ctx->expected_protocol = TLS1_1_VERSION;
176 fixture->expected_ctx->expected_servername = SSL_TEST_SERVERNAME_SERVER2;
177 fixture->expected_ctx->session_ticket_expected = SSL_TEST_SESSION_TICKET_YES;
178 fixture->expected_ctx->compression_expected = SSL_TEST_COMPRESSION_NO;
179 fixture->expected_ctx->session_id_expected = SSL_TEST_SESSION_ID_IGNORE;
180 fixture->expected_ctx->resumption_expected = 1;
| 263 fixture.expected_ctx->expected_result = SSL_TEST_SERVER_FAIL;
264 fixture.expected_ctx->expected_client_alert = SSL_AD_UNKNOWN_CA;
265 fixture.expected_ctx->expected_server_alert = 0; /* No alert. */
266 fixture.expected_ctx->expected_protocol = TLS1_1_VERSION;
267 fixture.expected_ctx->expected_servername = SSL_TEST_SERVERNAME_SERVER2;
268 fixture.expected_ctx->session_ticket_expected = SSL_TEST_SESSION_TICKET_YES;
269 fixture.expected_ctx->resumption_expected = 1;
|
181
| 270
|
182 fixture->expected_ctx->extra.client.verify_callback =
| 271 fixture.expected_ctx->extra.client.verify_callback =
|
183 SSL_TEST_VERIFY_REJECT_ALL;
| 272 SSL_TEST_VERIFY_REJECT_ALL;
|
184 fixture->expected_ctx->extra.client.servername = SSL_TEST_SERVERNAME_SERVER2;
185 fixture->expected_ctx->extra.client.npn_protocols =
| 273 fixture.expected_ctx->extra.client.servername = SSL_TEST_SERVERNAME_SERVER2;
274 fixture.expected_ctx->extra.client.npn_protocols =
|
186 OPENSSL_strdup("foo,bar");
| 275 OPENSSL_strdup("foo,bar");
|
187 if (!TEST_ptr(fixture->expected_ctx->extra.client.npn_protocols))
188 goto err;
189 fixture->expected_ctx->extra.client.max_fragment_len_mode = 0;
| 276 TEST_check(fixture.expected_ctx->extra.client.npn_protocols != NULL);
|
190
| 277
|
191 fixture->expected_ctx->extra.server.servername_callback =
| 278 fixture.expected_ctx->extra.server.servername_callback =
|
192 SSL_TEST_SERVERNAME_IGNORE_MISMATCH;
| 279 SSL_TEST_SERVERNAME_IGNORE_MISMATCH;
|
193 fixture->expected_ctx->extra.server.broken_session_ticket = 1;
| 280 fixture.expected_ctx->extra.server.broken_session_ticket = 1;
|
194
| 281
|
195 fixture->expected_ctx->resume_extra.server2.alpn_protocols =
| 282 fixture.expected_ctx->resume_extra.server2.alpn_protocols =
|
196 OPENSSL_strdup("baz");
| 283 OPENSSL_strdup("baz");
|
197 if (!TEST_ptr(fixture->expected_ctx->resume_extra.server2.alpn_protocols))
198 goto err;
| 284 TEST_check(
285 fixture.expected_ctx->resume_extra.server2.alpn_protocols != NULL);
|
199
| 286
|
200 fixture->expected_ctx->resume_extra.client.ct_validation =
| 287 fixture.expected_ctx->resume_extra.client.ct_validation =
|
201 SSL_TEST_CT_VALIDATION_STRICT;
202
203 EXECUTE_SSL_TEST_CTX_TEST();
| 288 SSL_TEST_CT_VALIDATION_STRICT;
289
290 EXECUTE_SSL_TEST_CTX_TEST();
|
204 return result;
205
206err:
207 tear_down(fixture);
208 return 0;
| |
209}
210
211static const char *bad_configurations[] = {
212 "ssltest_unknown_option",
213 "ssltest_wrong_section",
214 "ssltest_unknown_expected_result",
215 "ssltest_unknown_alert",
216 "ssltest_unknown_protocol",
217 "ssltest_unknown_verify_callback",
218 "ssltest_unknown_servername",
219 "ssltest_unknown_servername_callback",
220 "ssltest_unknown_session_ticket_expected",
| 291}
292
293static const char *bad_configurations[] = {
294 "ssltest_unknown_option",
295 "ssltest_wrong_section",
296 "ssltest_unknown_expected_result",
297 "ssltest_unknown_alert",
298 "ssltest_unknown_protocol",
299 "ssltest_unknown_verify_callback",
300 "ssltest_unknown_servername",
301 "ssltest_unknown_servername_callback",
302 "ssltest_unknown_session_ticket_expected",
|
221 "ssltest_unknown_compression_expected",
222 "ssltest_unknown_session_id_expected",
| |
223 "ssltest_unknown_method",
224 "ssltest_unknown_handshake_mode",
225 "ssltest_unknown_resumption_expected",
226 "ssltest_unknown_ct_validation",
| 303 "ssltest_unknown_method",
304 "ssltest_unknown_handshake_mode",
305 "ssltest_unknown_resumption_expected",
306 "ssltest_unknown_ct_validation",
|
227 "ssltest_invalid_max_fragment_len",
| |
228};
229
230static int test_bad_configuration(int idx)
231{
| 307};
308
309static int test_bad_configuration(int idx)
310{
|
232 SSL_TEST_CTX *ctx;
233
234 if (!TEST_ptr_null(ctx = SSL_TEST_CTX_create(conf,
235 bad_configurations[idx]))) {
236 SSL_TEST_CTX_free(ctx);
237 return 0;
238 }
239
240 return 1;
| 311 SETUP_SSL_TEST_CTX_TEST_FIXTURE();
312 fixture.test_section = bad_configurations[idx];
313 EXECUTE_SSL_TEST_CTX_FAILURE_TEST();
|
241}
242
| 314}
315
|
243int setup_tests(void)
| 316int main(int argc, char **argv)
|
244{
| 317{
|
245 if (!TEST_ptr(conf = NCONF_new(NULL)))
246 return 0;
247 /* argument should point to test/ssl_test_ctx_test.conf */
248 if (!TEST_int_gt(NCONF_load(conf, test_get_argument(0), NULL), 0)) {
249 TEST_note("Missing file argument");
250 return 0;
251 }
| 318 int result = 0;
|
252
| 319
|
| 320 if (argc != 2)
321 return 1;
322
323 conf = NCONF_new(NULL);
324 TEST_check(conf != NULL);
325
326 /* argv[1] should point to test/ssl_test_ctx_test.conf */
327 TEST_check(NCONF_load(conf, argv[1], NULL) > 0);
328
|
253 ADD_TEST(test_empty_configuration);
254 ADD_TEST(test_good_configuration);
255 ADD_ALL_TESTS(test_bad_configuration, OSSL_NELEM(bad_configurations));
| 329 ADD_TEST(test_empty_configuration);
330 ADD_TEST(test_good_configuration);
331 ADD_ALL_TESTS(test_bad_configuration, OSSL_NELEM(bad_configurations));
|
256 return 1;
257}
| |
258
| 332
|
259void cleanup_tests(void)
260{
| 333 result = run_tests(argv[0]);
334
|
261 NCONF_free(conf);
| 335 NCONF_free(conf);
|
| 336
337 return result;
|
262}
| 338}
|