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 */
     }