Use TEST_EQUAL(a,b) instead of TEST_ASSERT(a==b)
Regexp replacement then `code_style.py --fix`.
Signed-off-by: Gilles Peskine <Gilles.Peskine@arm.com>
diff --git a/tests/src/test_helpers/ssl_helpers.c b/tests/src/test_helpers/ssl_helpers.c
index 1eed8ab..3d4901c 100644
--- a/tests/src/test_helpers/ssl_helpers.c
+++ b/tests/src/test_helpers/ssl_helpers.c
@@ -637,7 +637,7 @@
cert->ca_cert,
(const unsigned char *) mbedtls_test_cas_der[i],
mbedtls_test_cas_der_len[i]);
- TEST_ASSERT(ret == 0);
+ TEST_EQUAL(ret, 0);
}
/* Load own certificate and private key */
@@ -648,25 +648,25 @@
cert->cert,
(const unsigned char *) mbedtls_test_srv_crt_rsa_sha256_der,
mbedtls_test_srv_crt_rsa_sha256_der_len);
- TEST_ASSERT(ret == 0);
+ TEST_EQUAL(ret, 0);
ret = mbedtls_pk_parse_key(
cert->pkey,
(const unsigned char *) mbedtls_test_srv_key_rsa_der,
mbedtls_test_srv_key_rsa_der_len, NULL, 0);
- TEST_ASSERT(ret == 0);
+ TEST_EQUAL(ret, 0);
} else {
ret = mbedtls_x509_crt_parse(
cert->cert,
(const unsigned char *) mbedtls_test_srv_crt_ec_der,
mbedtls_test_srv_crt_ec_der_len);
- TEST_ASSERT(ret == 0);
+ TEST_EQUAL(ret, 0);
ret = mbedtls_pk_parse_key(
cert->pkey,
(const unsigned char *) mbedtls_test_srv_key_ec_der,
mbedtls_test_srv_key_ec_der_len, NULL, 0);
- TEST_ASSERT(ret == 0);
+ TEST_EQUAL(ret, 0);
}
} else {
if (pk_alg == MBEDTLS_PK_RSA) {
@@ -674,25 +674,25 @@
cert->cert,
(const unsigned char *) mbedtls_test_cli_crt_rsa_der,
mbedtls_test_cli_crt_rsa_der_len);
- TEST_ASSERT(ret == 0);
+ TEST_EQUAL(ret, 0);
ret = mbedtls_pk_parse_key(
cert->pkey,
(const unsigned char *) mbedtls_test_cli_key_rsa_der,
mbedtls_test_cli_key_rsa_der_len, NULL, 0);
- TEST_ASSERT(ret == 0);
+ TEST_EQUAL(ret, 0);
} else {
ret = mbedtls_x509_crt_parse(
cert->cert,
(const unsigned char *) mbedtls_test_cli_crt_ec_der,
mbedtls_test_cli_crt_ec_len);
- TEST_ASSERT(ret == 0);
+ TEST_EQUAL(ret, 0);
ret = mbedtls_pk_parse_key(
cert->pkey,
(const unsigned char *) mbedtls_test_cli_key_ec_der,
mbedtls_test_cli_key_ec_der_len, NULL, 0);
- TEST_ASSERT(ret == 0);
+ TEST_EQUAL(ret, 0);
}
}
@@ -723,16 +723,16 @@
ret = mbedtls_ssl_conf_own_cert(&(ep->conf), cert->cert,
cert->pkey);
- TEST_ASSERT(ret == 0);
+ TEST_EQUAL(ret, 0);
TEST_ASSERT(ep->conf.key_cert != NULL);
ret = mbedtls_ssl_conf_own_cert(&(ep->conf), NULL, NULL);
- TEST_ASSERT(ret == 0);
+ TEST_EQUAL(ret, 0);
TEST_ASSERT(ep->conf.key_cert == NULL);
ret = mbedtls_ssl_conf_own_cert(&(ep->conf), cert->cert,
cert->pkey);
- TEST_ASSERT(ret == 0);
+ TEST_EQUAL(ret, 0);
ok = 1;
@@ -787,9 +787,9 @@
mbedtls_ssl_set_user_data_n(&ep->ssl, user_data_n);
if (dtls_context != NULL) {
- TEST_ASSERT(mbedtls_test_message_socket_setup(input_queue, output_queue,
- 100, &(ep->socket),
- dtls_context) == 0);
+ TEST_EQUAL(mbedtls_test_message_socket_setup(input_queue, output_queue,
+ 100, &(ep->socket),
+ dtls_context), 0);
} else {
mbedtls_test_mock_socket_init(&(ep->socket));
}
@@ -812,7 +812,7 @@
MBEDTLS_SSL_TRANSPORT_DATAGRAM :
MBEDTLS_SSL_TRANSPORT_STREAM,
MBEDTLS_SSL_PRESET_DEFAULT);
- TEST_ASSERT(ret == 0);
+ TEST_EQUAL(ret, 0);
if (MBEDTLS_SSL_IS_CLIENT == endpoint_type) {
if (options->client_min_version != MBEDTLS_SSL_VERSION_UNKNOWN) {
@@ -868,7 +868,7 @@
#endif
ret = mbedtls_ssl_setup(&(ep->ssl), &(ep->conf));
- TEST_ASSERT(ret == 0);
+ TEST_EQUAL(ret, 0);
if (MBEDTLS_SSL_IS_CLIENT == endpoint_type) {
ret = mbedtls_ssl_set_hostname(&(ep->ssl), "localhost");
@@ -902,7 +902,7 @@
options->opaque_alg,
options->opaque_alg2,
options->opaque_usage);
- TEST_ASSERT(ret == 0);
+ TEST_EQUAL(ret, 0);
TEST_EQUAL(mbedtls_ssl_conf_get_user_data_n(&ep->conf), user_data_n);
mbedtls_ssl_conf_set_user_data_p(&ep->conf, ep);
@@ -985,7 +985,7 @@
/* Verify that calling mbedtls_ssl_write with a NULL buffer and zero length is
* a valid no-op for TLS connections. */
if (ssl->conf->transport != MBEDTLS_SSL_TRANSPORT_DATAGRAM) {
- TEST_ASSERT(mbedtls_ssl_write(ssl, NULL, 0) == 0);
+ TEST_EQUAL(mbedtls_ssl_write(ssl, NULL, 0), 0);
}
ret = mbedtls_ssl_write(ssl, buf + *written, buf_len - *written);
@@ -1032,7 +1032,7 @@
/* Verify that calling mbedtls_ssl_write with a NULL buffer and zero length is
* a valid no-op for TLS connections. */
if (ssl->conf->transport != MBEDTLS_SSL_TRANSPORT_DATAGRAM) {
- TEST_ASSERT(mbedtls_ssl_read(ssl, NULL, 0) == 0);
+ TEST_EQUAL(mbedtls_ssl_read(ssl, NULL, 0), 0);
}
ret = mbedtls_ssl_read(ssl, buf + *read, buf_len - *read);
@@ -1042,7 +1042,7 @@
}
if (expected_fragments == 0) {
- TEST_ASSERT(ret == 0);
+ TEST_EQUAL(ret, 0);
} else if (expected_fragments == 1) {
TEST_ASSERT(ret == buf_len ||
ret == MBEDTLS_ERR_SSL_WANT_READ ||
@@ -1929,10 +1929,10 @@
if (expected_fragments_1 == 0) {
/* This error is expected when the message is too large and
* cannot be fragmented */
- TEST_ASSERT(ret == MBEDTLS_ERR_SSL_BAD_INPUT_DATA);
+ TEST_EQUAL(ret, MBEDTLS_ERR_SSL_BAD_INPUT_DATA);
msg_len_1 = 0;
} else {
- TEST_ASSERT(ret == 0);
+ TEST_EQUAL(ret, 0);
}
}
@@ -1944,10 +1944,10 @@
if (expected_fragments_2 == 0) {
/* This error is expected when the message is too large and
* cannot be fragmented */
- TEST_ASSERT(ret == MBEDTLS_ERR_SSL_BAD_INPUT_DATA);
+ TEST_EQUAL(ret, MBEDTLS_ERR_SSL_BAD_INPUT_DATA);
msg_len_2 = 0;
} else {
- TEST_ASSERT(ret == 0);
+ TEST_EQUAL(ret, 0);
}
}
@@ -1957,7 +1957,7 @@
msg_len_2, &read_1,
&fragments_2,
expected_fragments_2);
- TEST_ASSERT(ret == 0);
+ TEST_EQUAL(ret, 0);
}
/* ssl_2 reading */
@@ -1966,15 +1966,15 @@
msg_len_1, &read_2,
&fragments_1,
expected_fragments_1);
- TEST_ASSERT(ret == 0);
+ TEST_EQUAL(ret, 0);
}
}
ret = -1;
- TEST_ASSERT(0 == memcmp(msg_buf_1, in_buf_2, msg_len_1));
- TEST_ASSERT(0 == memcmp(msg_buf_2, in_buf_1, msg_len_2));
- TEST_ASSERT(fragments_1 == expected_fragments_1);
- TEST_ASSERT(fragments_2 == expected_fragments_2);
+ TEST_EQUAL(0, memcmp(msg_buf_1, in_buf_2, msg_len_1));
+ TEST_EQUAL(0, memcmp(msg_buf_2, in_buf_1, msg_len_2));
+ TEST_EQUAL(fragments_1, expected_fragments_1);
+ TEST_EQUAL(fragments_2, expected_fragments_2);
}
ret = 0;
@@ -2026,12 +2026,12 @@
switch (expected_negotiated_version) {
case MBEDTLS_SSL_VERSION_TLS1_2:
TEST_EQUAL(version_number, MBEDTLS_SSL_VERSION_TLS1_2);
- TEST_ASSERT(strcmp(version_string, "TLSv1.2") == 0);
+ TEST_EQUAL(strcmp(version_string, "TLSv1.2"), 0);
break;
case MBEDTLS_SSL_VERSION_TLS1_3:
TEST_EQUAL(version_number, MBEDTLS_SSL_VERSION_TLS1_3);
- TEST_ASSERT(strcmp(version_string, "TLSv1.3") == 0);
+ TEST_EQUAL(strcmp(version_string, "TLSv1.3"), 0);
break;
default:
@@ -2142,21 +2142,21 @@
/* Client side */
if (options->dtls != 0) {
- TEST_ASSERT(mbedtls_test_ssl_endpoint_init(&client,
- MBEDTLS_SSL_IS_CLIENT,
- options, &client_context,
- &client_queue,
- &server_queue) == 0);
+ TEST_EQUAL(mbedtls_test_ssl_endpoint_init(&client,
+ MBEDTLS_SSL_IS_CLIENT,
+ options, &client_context,
+ &client_queue,
+ &server_queue), 0);
#if defined(MBEDTLS_TIMING_C)
mbedtls_ssl_set_timer_cb(&client.ssl, &timer_client,
mbedtls_timing_set_delay,
mbedtls_timing_get_delay);
#endif
} else {
- TEST_ASSERT(mbedtls_test_ssl_endpoint_init(&client,
- MBEDTLS_SSL_IS_CLIENT,
- options, NULL, NULL,
- NULL) == 0);
+ TEST_EQUAL(mbedtls_test_ssl_endpoint_init(&client,
+ MBEDTLS_SSL_IS_CLIENT,
+ options, NULL, NULL,
+ NULL), 0);
}
if (strlen(options->cipher) > 0) {
@@ -2165,49 +2165,49 @@
/* Server side */
if (options->dtls != 0) {
- TEST_ASSERT(mbedtls_test_ssl_endpoint_init(&server,
- MBEDTLS_SSL_IS_SERVER,
- options, &server_context,
- &server_queue,
- &client_queue) == 0);
+ TEST_EQUAL(mbedtls_test_ssl_endpoint_init(&server,
+ MBEDTLS_SSL_IS_SERVER,
+ options, &server_context,
+ &server_queue,
+ &client_queue), 0);
#if defined(MBEDTLS_TIMING_C)
mbedtls_ssl_set_timer_cb(&server.ssl, &timer_server,
mbedtls_timing_set_delay,
mbedtls_timing_get_delay);
#endif
} else {
- TEST_ASSERT(mbedtls_test_ssl_endpoint_init(&server,
- MBEDTLS_SSL_IS_SERVER,
- options, NULL, NULL,
- NULL) == 0);
+ TEST_EQUAL(mbedtls_test_ssl_endpoint_init(&server,
+ MBEDTLS_SSL_IS_SERVER,
+ options, NULL, NULL,
+ NULL), 0);
}
mbedtls_ssl_conf_authmode(&server.conf, options->srv_auth_mode);
#if defined(MBEDTLS_SSL_MAX_FRAGMENT_LENGTH)
- TEST_ASSERT(mbedtls_ssl_conf_max_frag_len(&(server.conf),
- (unsigned char) options->mfl)
- == 0);
- TEST_ASSERT(mbedtls_ssl_conf_max_frag_len(&(client.conf),
- (unsigned char) options->mfl)
- == 0);
+ TEST_EQUAL(mbedtls_ssl_conf_max_frag_len(&(server.conf),
+ (unsigned char) options->mfl),
+ 0);
+ TEST_EQUAL(mbedtls_ssl_conf_max_frag_len(&(client.conf),
+ (unsigned char) options->mfl),
+ 0);
#else
- TEST_ASSERT(MBEDTLS_SSL_MAX_FRAG_LEN_NONE == options->mfl);
+ TEST_EQUAL(MBEDTLS_SSL_MAX_FRAG_LEN_NONE, options->mfl);
#endif /* MBEDTLS_SSL_MAX_FRAGMENT_LENGTH */
#if defined(MBEDTLS_SSL_HANDSHAKE_WITH_PSK_ENABLED)
if (options->psk_str != NULL && options->psk_str->len > 0) {
- TEST_ASSERT(mbedtls_ssl_conf_psk(
- &client.conf, options->psk_str->x,
- options->psk_str->len,
- (const unsigned char *) psk_identity,
- strlen(psk_identity)) == 0);
+ TEST_EQUAL(mbedtls_ssl_conf_psk(
+ &client.conf, options->psk_str->x,
+ options->psk_str->len,
+ (const unsigned char *) psk_identity,
+ strlen(psk_identity)), 0);
- TEST_ASSERT(mbedtls_ssl_conf_psk(
- &server.conf, options->psk_str->x,
- options->psk_str->len,
- (const unsigned char *) psk_identity,
- strlen(psk_identity)) == 0);
+ TEST_EQUAL(mbedtls_ssl_conf_psk(
+ &server.conf, options->psk_str->x,
+ options->psk_str->len,
+ (const unsigned char *) psk_identity,
+ strlen(psk_identity)), 0);
#if defined(MBEDTLS_SSL_SRV_C)
mbedtls_ssl_conf_psk_cb(&server.conf, psk_dummy_callback, NULL);
#endif
@@ -2227,17 +2227,17 @@
}
#endif /* MBEDTLS_SSL_RENEGOTIATION */
- TEST_ASSERT(mbedtls_test_mock_socket_connect(&(client.socket),
- &(server.socket),
- BUFFSIZE) == 0);
+ TEST_EQUAL(mbedtls_test_mock_socket_connect(&(client.socket),
+ &(server.socket),
+ BUFFSIZE), 0);
#if defined(MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH)
if (options->resize_buffers != 0) {
/* Ensure that the buffer sizes are appropriate before resizes */
- TEST_ASSERT(client.ssl.out_buf_len == MBEDTLS_SSL_OUT_BUFFER_LEN);
- TEST_ASSERT(client.ssl.in_buf_len == MBEDTLS_SSL_IN_BUFFER_LEN);
- TEST_ASSERT(server.ssl.out_buf_len == MBEDTLS_SSL_OUT_BUFFER_LEN);
- TEST_ASSERT(server.ssl.in_buf_len == MBEDTLS_SSL_IN_BUFFER_LEN);
+ TEST_EQUAL(client.ssl.out_buf_len, MBEDTLS_SSL_OUT_BUFFER_LEN);
+ TEST_EQUAL(client.ssl.in_buf_len, MBEDTLS_SSL_IN_BUFFER_LEN);
+ TEST_EQUAL(server.ssl.out_buf_len, MBEDTLS_SSL_OUT_BUFFER_LEN);
+ TEST_EQUAL(server.ssl.in_buf_len, MBEDTLS_SSL_IN_BUFFER_LEN);
}
#endif
@@ -2245,17 +2245,17 @@
expected_handshake_result = MBEDTLS_ERR_SSL_BAD_PROTOCOL_VERSION;
}
- TEST_ASSERT(mbedtls_test_move_handshake_to_state(&(client.ssl),
- &(server.ssl),
- MBEDTLS_SSL_HANDSHAKE_OVER)
- == expected_handshake_result);
+ TEST_EQUAL(mbedtls_test_move_handshake_to_state(&(client.ssl),
+ &(server.ssl),
+ MBEDTLS_SSL_HANDSHAKE_OVER),
+ expected_handshake_result);
if (expected_handshake_result != 0) {
/* Connection will have failed by this point, skip to cleanup */
goto exit;
}
- TEST_ASSERT(mbedtls_ssl_is_handshake_over(&client.ssl) == 1);
+ TEST_EQUAL(mbedtls_ssl_is_handshake_over(&client.ssl), 1);
/* Make sure server state is moved to HANDSHAKE_OVER also. */
TEST_EQUAL(mbedtls_test_move_handshake_to_state(&(server.ssl),
@@ -2263,7 +2263,7 @@
MBEDTLS_SSL_HANDSHAKE_OVER),
0);
- TEST_ASSERT(mbedtls_ssl_is_handshake_over(&server.ssl) == 1);
+ TEST_EQUAL(mbedtls_ssl_is_handshake_over(&server.ssl), 1);
/* Check that both sides have negotiated the expected version. */
mbedtls_test_set_step(0);
if (!check_ssl_version(options->expected_negotiated_version,
@@ -2286,48 +2286,48 @@
if (options->resize_buffers != 0) {
/* A server, when using DTLS, might delay a buffer resize to happen
* after it receives a message, so we force it. */
- TEST_ASSERT(exchange_data(&(client.ssl), &(server.ssl)) == 0);
+ TEST_EQUAL(exchange_data(&(client.ssl), &(server.ssl)), 0);
- TEST_ASSERT(client.ssl.out_buf_len ==
- mbedtls_ssl_get_output_buflen(&client.ssl));
- TEST_ASSERT(client.ssl.in_buf_len ==
- mbedtls_ssl_get_input_buflen(&client.ssl));
- TEST_ASSERT(server.ssl.out_buf_len ==
- mbedtls_ssl_get_output_buflen(&server.ssl));
- TEST_ASSERT(server.ssl.in_buf_len ==
- mbedtls_ssl_get_input_buflen(&server.ssl));
+ TEST_EQUAL(client.ssl.out_buf_len,
+ mbedtls_ssl_get_output_buflen(&client.ssl));
+ TEST_EQUAL(client.ssl.in_buf_len,
+ mbedtls_ssl_get_input_buflen(&client.ssl));
+ TEST_EQUAL(server.ssl.out_buf_len,
+ mbedtls_ssl_get_output_buflen(&server.ssl));
+ TEST_EQUAL(server.ssl.in_buf_len,
+ mbedtls_ssl_get_input_buflen(&server.ssl));
}
#endif
if (options->cli_msg_len != 0 || options->srv_msg_len != 0) {
/* Start data exchanging test */
- TEST_ASSERT(mbedtls_test_ssl_exchange_data(
- &(client.ssl), options->cli_msg_len,
- options->expected_cli_fragments,
- &(server.ssl), options->srv_msg_len,
- options->expected_srv_fragments)
- == 0);
+ TEST_EQUAL(mbedtls_test_ssl_exchange_data(
+ &(client.ssl), options->cli_msg_len,
+ options->expected_cli_fragments,
+ &(server.ssl), options->srv_msg_len,
+ options->expected_srv_fragments),
+ 0);
}
#if defined(MBEDTLS_SSL_CONTEXT_SERIALIZATION)
if (options->serialize == 1) {
- TEST_ASSERT(options->dtls == 1);
+ TEST_EQUAL(options->dtls, 1);
- TEST_ASSERT(mbedtls_ssl_context_save(&(server.ssl), NULL,
- 0, &context_buf_len)
- == MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL);
+ TEST_EQUAL(mbedtls_ssl_context_save(&(server.ssl), NULL,
+ 0, &context_buf_len),
+ MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL);
context_buf = mbedtls_calloc(1, context_buf_len);
TEST_ASSERT(context_buf != NULL);
- TEST_ASSERT(mbedtls_ssl_context_save(&(server.ssl), context_buf,
- context_buf_len,
- &context_buf_len)
- == 0);
+ TEST_EQUAL(mbedtls_ssl_context_save(&(server.ssl), context_buf,
+ context_buf_len,
+ &context_buf_len),
+ 0);
mbedtls_ssl_free(&(server.ssl));
mbedtls_ssl_init(&(server.ssl));
- TEST_ASSERT(mbedtls_ssl_setup(&(server.ssl), &(server.conf)) == 0);
+ TEST_EQUAL(mbedtls_ssl_setup(&(server.ssl), &(server.conf)), 0);
mbedtls_ssl_set_bio(&(server.ssl), &server_context,
mbedtls_test_mock_tcp_send_msg,
@@ -2344,30 +2344,30 @@
#if defined(MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH)
if (options->resize_buffers != 0) {
/* Ensure that the buffer sizes are appropriate before resizes */
- TEST_ASSERT(server.ssl.out_buf_len == MBEDTLS_SSL_OUT_BUFFER_LEN);
- TEST_ASSERT(server.ssl.in_buf_len == MBEDTLS_SSL_IN_BUFFER_LEN);
+ TEST_EQUAL(server.ssl.out_buf_len, MBEDTLS_SSL_OUT_BUFFER_LEN);
+ TEST_EQUAL(server.ssl.in_buf_len, MBEDTLS_SSL_IN_BUFFER_LEN);
}
#endif
- TEST_ASSERT(mbedtls_ssl_context_load(&(server.ssl), context_buf,
- context_buf_len) == 0);
+ TEST_EQUAL(mbedtls_ssl_context_load(&(server.ssl), context_buf,
+ context_buf_len), 0);
#if defined(MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH)
/* Validate buffer sizes after context deserialization */
if (options->resize_buffers != 0) {
- TEST_ASSERT(server.ssl.out_buf_len ==
- mbedtls_ssl_get_output_buflen(&server.ssl));
- TEST_ASSERT(server.ssl.in_buf_len ==
- mbedtls_ssl_get_input_buflen(&server.ssl));
+ TEST_EQUAL(server.ssl.out_buf_len,
+ mbedtls_ssl_get_output_buflen(&server.ssl));
+ TEST_EQUAL(server.ssl.in_buf_len,
+ mbedtls_ssl_get_input_buflen(&server.ssl));
}
#endif
/* Retest writing/reading */
if (options->cli_msg_len != 0 || options->srv_msg_len != 0) {
- TEST_ASSERT(mbedtls_test_ssl_exchange_data(
- &(client.ssl), options->cli_msg_len,
- options->expected_cli_fragments,
- &(server.ssl), options->srv_msg_len,
- options->expected_srv_fragments)
- == 0);
+ TEST_EQUAL(mbedtls_test_ssl_exchange_data(
+ &(client.ssl), options->cli_msg_len,
+ options->expected_cli_fragments,
+ &(server.ssl), options->srv_msg_len,
+ options->expected_srv_fragments),
+ 0);
}
}
#endif /* MBEDTLS_SSL_CONTEXT_SERIALIZATION */
@@ -2375,24 +2375,24 @@
#if defined(MBEDTLS_SSL_RENEGOTIATION)
if (options->renegotiate) {
/* Start test with renegotiation */
- TEST_ASSERT(server.ssl.renego_status ==
- MBEDTLS_SSL_INITIAL_HANDSHAKE);
- TEST_ASSERT(client.ssl.renego_status ==
- MBEDTLS_SSL_INITIAL_HANDSHAKE);
+ TEST_EQUAL(server.ssl.renego_status,
+ MBEDTLS_SSL_INITIAL_HANDSHAKE);
+ TEST_EQUAL(client.ssl.renego_status,
+ MBEDTLS_SSL_INITIAL_HANDSHAKE);
/* After calling this function for the server, it only sends a handshake
* request. All renegotiation should happen during data exchanging */
- TEST_ASSERT(mbedtls_ssl_renegotiate(&(server.ssl)) == 0);
- TEST_ASSERT(server.ssl.renego_status ==
- MBEDTLS_SSL_RENEGOTIATION_PENDING);
- TEST_ASSERT(client.ssl.renego_status ==
- MBEDTLS_SSL_INITIAL_HANDSHAKE);
+ TEST_EQUAL(mbedtls_ssl_renegotiate(&(server.ssl)), 0);
+ TEST_EQUAL(server.ssl.renego_status,
+ MBEDTLS_SSL_RENEGOTIATION_PENDING);
+ TEST_EQUAL(client.ssl.renego_status,
+ MBEDTLS_SSL_INITIAL_HANDSHAKE);
- TEST_ASSERT(exchange_data(&(client.ssl), &(server.ssl)) == 0);
- TEST_ASSERT(server.ssl.renego_status ==
- MBEDTLS_SSL_RENEGOTIATION_DONE);
- TEST_ASSERT(client.ssl.renego_status ==
- MBEDTLS_SSL_RENEGOTIATION_DONE);
+ TEST_EQUAL(exchange_data(&(client.ssl), &(server.ssl)), 0);
+ TEST_EQUAL(server.ssl.renego_status,
+ MBEDTLS_SSL_RENEGOTIATION_DONE);
+ TEST_EQUAL(client.ssl.renego_status,
+ MBEDTLS_SSL_RENEGOTIATION_DONE);
/* After calling mbedtls_ssl_renegotiate for the client,
* all renegotiation should happen inside this function.
@@ -2404,34 +2404,34 @@
#if defined(MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH)
if (options->resize_buffers != 0) {
/* Ensure that the buffer sizes are appropriate before resizes */
- TEST_ASSERT(client.ssl.out_buf_len == MBEDTLS_SSL_OUT_BUFFER_LEN);
- TEST_ASSERT(client.ssl.in_buf_len == MBEDTLS_SSL_IN_BUFFER_LEN);
+ TEST_EQUAL(client.ssl.out_buf_len, MBEDTLS_SSL_OUT_BUFFER_LEN);
+ TEST_EQUAL(client.ssl.in_buf_len, MBEDTLS_SSL_IN_BUFFER_LEN);
}
#endif
TEST_ASSERT(ret == 0 ||
ret == MBEDTLS_ERR_SSL_WANT_READ ||
ret == MBEDTLS_ERR_SSL_WANT_WRITE);
- TEST_ASSERT(server.ssl.renego_status ==
- MBEDTLS_SSL_RENEGOTIATION_DONE);
- TEST_ASSERT(client.ssl.renego_status ==
- MBEDTLS_SSL_RENEGOTIATION_IN_PROGRESS);
+ TEST_EQUAL(server.ssl.renego_status,
+ MBEDTLS_SSL_RENEGOTIATION_DONE);
+ TEST_EQUAL(client.ssl.renego_status,
+ MBEDTLS_SSL_RENEGOTIATION_IN_PROGRESS);
- TEST_ASSERT(exchange_data(&(client.ssl), &(server.ssl)) == 0);
- TEST_ASSERT(server.ssl.renego_status ==
- MBEDTLS_SSL_RENEGOTIATION_DONE);
- TEST_ASSERT(client.ssl.renego_status ==
- MBEDTLS_SSL_RENEGOTIATION_DONE);
+ TEST_EQUAL(exchange_data(&(client.ssl), &(server.ssl)), 0);
+ TEST_EQUAL(server.ssl.renego_status,
+ MBEDTLS_SSL_RENEGOTIATION_DONE);
+ TEST_EQUAL(client.ssl.renego_status,
+ MBEDTLS_SSL_RENEGOTIATION_DONE);
#if defined(MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH)
/* Validate buffer sizes after renegotiation */
if (options->resize_buffers != 0) {
- TEST_ASSERT(client.ssl.out_buf_len ==
- mbedtls_ssl_get_output_buflen(&client.ssl));
- TEST_ASSERT(client.ssl.in_buf_len ==
- mbedtls_ssl_get_input_buflen(&client.ssl));
- TEST_ASSERT(server.ssl.out_buf_len ==
- mbedtls_ssl_get_output_buflen(&server.ssl));
- TEST_ASSERT(server.ssl.in_buf_len ==
- mbedtls_ssl_get_input_buflen(&server.ssl));
+ TEST_EQUAL(client.ssl.out_buf_len,
+ mbedtls_ssl_get_output_buflen(&client.ssl));
+ TEST_EQUAL(client.ssl.in_buf_len,
+ mbedtls_ssl_get_input_buflen(&client.ssl));
+ TEST_EQUAL(server.ssl.out_buf_len,
+ mbedtls_ssl_get_output_buflen(&server.ssl));
+ TEST_EQUAL(server.ssl.in_buf_len,
+ mbedtls_ssl_get_input_buflen(&server.ssl));
}
#endif /* MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH */
}