diff --git a/tests/suites/test_suite_ssl.function b/tests/suites/test_suite_ssl.function
index 4a6c6fb..a5fdd84 100644
--- a/tests/suites/test_suite_ssl.function
+++ b/tests/suites/test_suite_ssl.function
@@ -28,9 +28,9 @@
  * this case, it will count the instances of a mbedtls_test_ssl_log_pattern in the received
  * logged messages.
  */
-void log_analyzer(void *ctx, int level,
-                  const char *file, int line,
-                  const char *str)
+void mbedtls_test_ssl_log_analyzer(void *ctx, int level,
+                                   const char *file, int line,
+                                   const char *str)
 {
     mbedtls_test_ssl_log_pattern *p = (mbedtls_test_ssl_log_pattern *) ctx;
 
@@ -45,7 +45,7 @@
     }
 }
 
-void init_handshake_options(mbedtls_test_handshake_test_options *opts)
+void mbedtls_test_init_handshake_options(mbedtls_test_handshake_test_options *opts)
 {
     opts->cipher = "";
     opts->client_min_version = TEST_SSL_MINOR_VERSION_NONE;
@@ -74,18 +74,18 @@
 
 /*
  * Initialises \p buf. After calling this function it is safe to call
- * `mbedtls_test_buffer_free()` on \p buf.
+ * `mbedtls_test_ssl_buffer_free()` on \p buf.
  */
-void mbedtls_test_buffer_init(mbedtls_test_ssl_buffer *buf)
+void mbedtls_test_ssl_buffer_init(mbedtls_test_ssl_buffer *buf)
 {
     memset(buf, 0, sizeof(*buf));
 }
 
 /*
  * Sets up \p buf. After calling this function it is safe to call
- * `mbedtls_test_buffer_put()` and `mbedtls_test_buffer_get()` on \p buf.
+ * `mbedtls_test_ssl_buffer_put()` and `mbedtls_test_ssl_buffer_get()` on \p buf.
  */
-int mbedtls_test_buffer_setup(mbedtls_test_ssl_buffer *buf, size_t capacity)
+int mbedtls_test_ssl_buffer_setup(mbedtls_test_ssl_buffer *buf, size_t capacity)
 {
     buf->buffer = (unsigned char *) mbedtls_calloc(capacity,
                                                    sizeof(unsigned char));
@@ -97,7 +97,7 @@
     return 0;
 }
 
-void mbedtls_test_buffer_free(mbedtls_test_ssl_buffer *buf)
+void mbedtls_test_ssl_buffer_free(mbedtls_test_ssl_buffer *buf)
 {
     if (buf->buffer != NULL) {
         mbedtls_free(buf->buffer);
@@ -110,15 +110,15 @@
  * Puts \p input_len bytes from the \p input buffer into the ring buffer \p buf.
  *
  * \p buf must have been initialized and set up by calling
- * `mbedtls_test_buffer_init()` and `mbedtls_test_buffer_setup()`.
+ * `mbedtls_test_ssl_buffer_init()` and `mbedtls_test_ssl_buffer_setup()`.
  *
  * \retval  \p input_len, if the data fits.
  * \retval  0 <= value < \p input_len, if the data does not fit.
  * \retval  -1, if \p buf is NULL, it hasn't been set up or \p input_len is not
  *          zero and \p input is NULL.
  */
-int mbedtls_test_buffer_put(mbedtls_test_ssl_buffer *buf,
-                            const unsigned char *input, size_t input_len)
+int mbedtls_test_ssl_buffer_put(mbedtls_test_ssl_buffer *buf,
+                                const unsigned char *input, size_t input_len)
 {
     size_t overflow = 0;
 
@@ -167,14 +167,14 @@
  * ring buffer will be dropped, if the requested length is available.
  *
  * \p buf must have been initialized and set up by calling
- * `mbedtls_test_buffer_init()` and `mbedtls_test_buffer_setup()`.
+ * `mbedtls_test_ssl_buffer_init()` and `mbedtls_test_ssl_buffer_setup()`.
  *
  * \retval  \p output_len, if the data is available.
  * \retval  0 <= value < \p output_len, if the data is not available.
  * \retval  -1, if \buf is NULL or it hasn't been set up.
  */
-int mbedtls_test_buffer_get(mbedtls_test_ssl_buffer *buf,
-                            unsigned char *output, size_t output_len)
+int mbedtls_test_ssl_buffer_get(mbedtls_test_ssl_buffer *buf,
+                                unsigned char *output, size_t output_len)
 {
     size_t overflow = 0;
 
@@ -222,8 +222,8 @@
  * \retval  0, if a metadata queue of a given length can be allocated.
  * \retval  MBEDTLS_ERR_SSL_ALLOC_FAILED, if allocation failed.
  */
-int mbedtls_test_message_queue_setup(mbedtls_test_ssl_message_queue *queue,
-                                     size_t capacity)
+int mbedtls_test_ssl_message_queue_setup(mbedtls_test_ssl_message_queue *queue,
+                                         size_t capacity)
 {
     queue->messages = (size_t *) mbedtls_calloc(capacity, sizeof(size_t));
     if (NULL == queue->messages) {
@@ -237,7 +237,7 @@
     return 0;
 }
 
-void mbedtls_test_message_queue_free(mbedtls_test_ssl_message_queue *queue)
+void mbedtls_test_ssl_message_queue_free(mbedtls_test_ssl_message_queue *queue)
 {
     if (queue == NULL) {
         return;
@@ -258,8 +258,8 @@
  * \retval  MBEDTLS_ERR_SSL_WANT_WRITE, if the queue is full.
  * \retval  \p len, if the push was successful.
  */
-int mbedtls_test_message_queue_push_info(mbedtls_test_ssl_message_queue *queue,
-                                         size_t len)
+int mbedtls_test_ssl_message_queue_push_info(mbedtls_test_ssl_message_queue *queue,
+                                             size_t len)
 {
     int place;
     if (queue == NULL) {
@@ -286,8 +286,8 @@
  * \retval  message length, if the pop was successful, up to the given
             \p buf_len.
  */
-int mbedtls_test_message_queue_pop_info(mbedtls_test_ssl_message_queue *queue,
-                                        size_t buf_len)
+int mbedtls_test_ssl_message_queue_pop_info(mbedtls_test_ssl_message_queue *queue,
+                                            size_t buf_len)
 {
     size_t message_length;
     if (queue == NULL) {
@@ -356,19 +356,19 @@
  * phenomenon that when closing a UDP connection the peer is not aware of the
  * connection having been closed.
  */
-void mbedtls_mock_socket_close(mbedtls_test_mock_socket *socket)
+void mbedtls_test_mock_socket_close(mbedtls_test_mock_socket *socket)
 {
     if (socket == NULL) {
         return;
     }
 
     if (socket->input != NULL) {
-        mbedtls_test_buffer_free(socket->input);
+        mbedtls_test_ssl_buffer_free(socket->input);
         mbedtls_free(socket->input);
     }
 
     if (socket->output != NULL) {
-        mbedtls_test_buffer_free(socket->output);
+        mbedtls_test_ssl_buffer_free(socket->output);
         mbedtls_free(socket->output);
     }
 
@@ -389,9 +389,9 @@
  * the correct value allows for simulation of MTU, sanity testing the mock
  * implementation and mocking TCP connections with lower memory cost.
  */
-int mbedtls_mock_socket_connect(mbedtls_test_mock_socket *peer1,
-                                mbedtls_test_mock_socket *peer2,
-                                size_t bufsize)
+int mbedtls_test_mock_socket_connect(mbedtls_test_mock_socket *peer1,
+                                     mbedtls_test_mock_socket *peer2,
+                                     size_t bufsize)
 {
     int ret = -1;
 
@@ -401,8 +401,8 @@
         ret = MBEDTLS_ERR_SSL_ALLOC_FAILED;
         goto exit;
     }
-    mbedtls_test_buffer_init(peer1->output);
-    if (0 != (ret = mbedtls_test_buffer_setup(peer1->output, bufsize))) {
+    mbedtls_test_ssl_buffer_init(peer1->output);
+    if (0 != (ret = mbedtls_test_ssl_buffer_setup(peer1->output, bufsize))) {
         goto exit;
     }
 
@@ -412,8 +412,8 @@
         ret = MBEDTLS_ERR_SSL_ALLOC_FAILED;
         goto exit;
     }
-    mbedtls_test_buffer_init(peer2->output);
-    if (0 != (ret = mbedtls_test_buffer_setup(peer2->output, bufsize))) {
+    mbedtls_test_ssl_buffer_init(peer2->output);
+    if (0 != (ret = mbedtls_test_ssl_buffer_setup(peer2->output, bufsize))) {
         goto exit;
     }
 
@@ -428,8 +428,8 @@
 exit:
 
     if (ret != 0) {
-        mbedtls_mock_socket_close(peer1);
-        mbedtls_mock_socket_close(peer2);
+        mbedtls_test_mock_socket_close(peer1);
+        mbedtls_test_mock_socket_close(peer2);
     }
 
     return ret;
@@ -439,7 +439,7 @@
  * Callbacks for simulating blocking I/O over connection-oriented transport.
  */
 
-int mbedtls_mock_tcp_send_b(void *ctx, const unsigned char *buf, size_t len)
+int mbedtls_test_mock_tcp_send_b(void *ctx, const unsigned char *buf, size_t len)
 {
     mbedtls_test_mock_socket *socket = (mbedtls_test_mock_socket *) ctx;
 
@@ -447,10 +447,10 @@
         return -1;
     }
 
-    return mbedtls_test_buffer_put(socket->output, buf, len);
+    return mbedtls_test_ssl_buffer_put(socket->output, buf, len);
 }
 
-int mbedtls_mock_tcp_recv_b(void *ctx, unsigned char *buf, size_t len)
+int mbedtls_test_mock_tcp_recv_b(void *ctx, unsigned char *buf, size_t len)
 {
     mbedtls_test_mock_socket *socket = (mbedtls_test_mock_socket *) ctx;
 
@@ -458,14 +458,14 @@
         return -1;
     }
 
-    return mbedtls_test_buffer_get(socket->input, buf, len);
+    return mbedtls_test_ssl_buffer_get(socket->input, buf, len);
 }
 
 /*
  * Callbacks for simulating non-blocking I/O over connection-oriented transport.
  */
 
-int mbedtls_mock_tcp_send_nb(void *ctx, const unsigned char *buf, size_t len)
+int mbedtls_test_mock_tcp_send_nb(void *ctx, const unsigned char *buf, size_t len)
 {
     mbedtls_test_mock_socket *socket = (mbedtls_test_mock_socket *) ctx;
 
@@ -477,10 +477,10 @@
         return MBEDTLS_ERR_SSL_WANT_WRITE;
     }
 
-    return mbedtls_test_buffer_put(socket->output, buf, len);
+    return mbedtls_test_ssl_buffer_put(socket->output, buf, len);
 }
 
-int mbedtls_mock_tcp_recv_nb(void *ctx, unsigned char *buf, size_t len)
+int mbedtls_test_mock_tcp_recv_nb(void *ctx, unsigned char *buf, size_t len)
 {
     mbedtls_test_mock_socket *socket = (mbedtls_test_mock_socket *) ctx;
 
@@ -492,10 +492,10 @@
         return MBEDTLS_ERR_SSL_WANT_READ;
     }
 
-    return mbedtls_test_buffer_get(socket->input, buf, len);
+    return mbedtls_test_ssl_buffer_get(socket->input, buf, len);
 }
 
-void mbedtls_message_socket_init(mbedtls_test_message_socket_context *ctx)
+void mbedtls_test_message_socket_init(mbedtls_test_message_socket_context *ctx)
 {
     ctx->queue_input = NULL;
     ctx->queue_output = NULL;
@@ -511,13 +511,13 @@
  * \retval  MBEDTLS_ERR_SSL_ALLOC_FAILED, if allocation of a message
  *          queue failed.
  */
-int mbedtls_message_socket_setup(mbedtls_test_ssl_message_queue *queue_input,
-                                 mbedtls_test_ssl_message_queue *queue_output,
-                                 size_t queue_capacity,
-                                 mbedtls_test_mock_socket *socket,
-                                 mbedtls_test_message_socket_context *ctx)
+int mbedtls_test_message_socket_setup(mbedtls_test_ssl_message_queue *queue_input,
+                                      mbedtls_test_ssl_message_queue *queue_output,
+                                      size_t queue_capacity,
+                                      mbedtls_test_mock_socket *socket,
+                                      mbedtls_test_message_socket_context *ctx)
 {
-    int ret = mbedtls_test_message_queue_setup(queue_input, queue_capacity);
+    int ret = mbedtls_test_ssl_message_queue_setup(queue_input, queue_capacity);
     if (ret != 0) {
         return ret;
     }
@@ -533,14 +533,14 @@
  * Close a given message socket context, along with the socket itself. Free the
  * memory allocated by the input queue.
  */
-void mbedtls_message_socket_close(mbedtls_test_message_socket_context *ctx)
+void mbedtls_test_message_socket_close(mbedtls_test_message_socket_context *ctx)
 {
     if (ctx == NULL) {
         return;
     }
 
-    mbedtls_test_message_queue_free(ctx->queue_input);
-    mbedtls_mock_socket_close(ctx->socket);
+    mbedtls_test_ssl_message_queue_free(ctx->queue_input);
+    mbedtls_test_mock_socket_close(ctx->socket);
     memset(ctx, 0, sizeof(*ctx));
 }
 
@@ -550,13 +550,13 @@
  * \retval  \p len, if everything succeeds.
  * \retval  MBEDTLS_TEST_ERROR_CONTEXT_ERROR, if any of the needed context
  *          elements or the context itself is null.
- * \retval  MBEDTLS_TEST_ERROR_SEND_FAILED if mbedtls_mock_tcp_send_b failed.
+ * \retval  MBEDTLS_TEST_ERROR_SEND_FAILED if mbedtls_test_mock_tcp_send_b failed.
  * \retval  MBEDTLS_ERR_SSL_WANT_WRITE, if the output queue is full.
  *
  * This function will also return any error from
- * mbedtls_test_message_queue_push_info.
+ * mbedtls_test_ssl_message_queue_push_info.
  */
-int mbedtls_mock_tcp_send_msg(void *ctx, const unsigned char *buf, size_t len)
+int mbedtls_test_mock_tcp_send_msg(void *ctx, const unsigned char *buf, size_t len)
 {
     mbedtls_test_ssl_message_queue *queue;
     mbedtls_test_mock_socket *socket;
@@ -574,11 +574,11 @@
         return MBEDTLS_ERR_SSL_WANT_WRITE;
     }
 
-    if (mbedtls_mock_tcp_send_b(socket, buf, len) != (int) len) {
+    if (mbedtls_test_mock_tcp_send_b(socket, buf, len) != (int) len) {
         return MBEDTLS_TEST_ERROR_SEND_FAILED;
     }
 
-    return mbedtls_test_message_queue_push_info(queue, len);
+    return mbedtls_test_ssl_message_queue_push_info(queue, len);
 }
 
 /*
@@ -588,12 +588,12 @@
  * \retval  message length, if everything succeeds.
  * \retval  MBEDTLS_TEST_ERROR_CONTEXT_ERROR, if any of the needed context
  *          elements or the context itself is null.
- * \retval  MBEDTLS_TEST_ERROR_RECV_FAILED if mbedtls_mock_tcp_recv_b failed.
+ * \retval  MBEDTLS_TEST_ERROR_RECV_FAILED if mbedtls_test_mock_tcp_recv_b failed.
  *
  * This function will also return any error other than
  * MBEDTLS_TEST_ERROR_MESSAGE_TRUNCATED from mbedtls_test_message_queue_peek_info.
  */
-int mbedtls_mock_tcp_recv_msg(void *ctx, unsigned char *buf, size_t buf_len)
+int mbedtls_test_mock_tcp_recv_msg(void *ctx, unsigned char *buf, size_t buf_len)
 {
     mbedtls_test_ssl_message_queue *queue;
     mbedtls_test_mock_socket *socket;
@@ -623,19 +623,19 @@
         return ret;
     }
 
-    if (mbedtls_mock_tcp_recv_b(socket, buf, msg_len) != (int) msg_len) {
+    if (mbedtls_test_mock_tcp_recv_b(socket, buf, msg_len) != (int) msg_len) {
         return MBEDTLS_TEST_ERROR_RECV_FAILED;
     }
 
     if (ret == MBEDTLS_TEST_ERROR_MESSAGE_TRUNCATED) {
         /* Drop the remaining part of the message */
-        if (mbedtls_mock_tcp_recv_b(socket, NULL, drop_len) != (int) drop_len) {
+        if (mbedtls_test_mock_tcp_recv_b(socket, NULL, drop_len) != (int) drop_len) {
             /* Inconsistent state - part of the message was read,
              * and a part couldn't. Not much we can do here, but it should not
              * happen in test environment, unless forced manually. */
         }
     }
-    mbedtls_test_message_queue_pop_info(queue, buf_len);
+    mbedtls_test_ssl_message_queue_pop_info(queue, buf_len);
 
     return msg_len;
 }
@@ -682,7 +682,7 @@
  *
  * \retval  0 on success, otherwise error code.
  */
-int mbedtls_endpoint_certificate_init(mbedtls_test_ssl_endpoint *ep, int pk_alg)
+int mbedtls_test_ssl_endpoint_certificate_init(mbedtls_test_ssl_endpoint *ep, int pk_alg)
 {
     int i = 0;
     int ret = -1;
@@ -773,7 +773,7 @@
 }
 
 /*
- * Initializes \p ep structure. It is important to call `mbedtls_endpoint_free()`
+ * Initializes \p ep structure. It is important to call `mbedtls_test_ssl_endpoint_free()`
  * after calling this function even if it fails.
  *
  * \p endpoint_type must be set as MBEDTLS_SSL_IS_SERVER or
@@ -786,11 +786,11 @@
  *
  * \retval  0 on success, otherwise error code.
  */
-int mbedtls_endpoint_init(mbedtls_test_ssl_endpoint *ep, int endpoint_type, int pk_alg,
-                          mbedtls_test_message_socket_context *dtls_context,
-                          mbedtls_test_ssl_message_queue *input_queue,
-                          mbedtls_test_ssl_message_queue *output_queue,
-                          const mbedtls_ecp_group_id *curves)
+int mbedtls_test_ssl_endpoint_init(mbedtls_test_ssl_endpoint *ep, int endpoint_type, int pk_alg,
+                                   mbedtls_test_message_socket_context *dtls_context,
+                                   mbedtls_test_ssl_message_queue *input_queue,
+                                   mbedtls_test_ssl_message_queue *output_queue,
+                                   const mbedtls_ecp_group_id *curves)
 {
     int ret = -1;
 
@@ -814,9 +814,9 @@
                          &(ep->ctr_drbg));
     mbedtls_entropy_init(&(ep->entropy));
     if (dtls_context != NULL) {
-        TEST_ASSERT(mbedtls_message_socket_setup(input_queue, output_queue,
-                                                 100, &(ep->socket),
-                                                 dtls_context) == 0);
+        TEST_ASSERT(mbedtls_test_message_socket_setup(input_queue, output_queue,
+                                                      100, &(ep->socket),
+                                                      dtls_context) == 0);
     } else {
         mbedtls_mock_socket_init(&(ep->socket));
     }
@@ -829,13 +829,13 @@
     /* Non-blocking callbacks without timeout */
     if (dtls_context != NULL) {
         mbedtls_ssl_set_bio(&(ep->ssl), dtls_context,
-                            mbedtls_mock_tcp_send_msg,
-                            mbedtls_mock_tcp_recv_msg,
+                            mbedtls_test_mock_tcp_send_msg,
+                            mbedtls_test_mock_tcp_recv_msg,
                             NULL);
     } else {
         mbedtls_ssl_set_bio(&(ep->ssl), &(ep->socket),
-                            mbedtls_mock_tcp_send_nb,
-                            mbedtls_mock_tcp_recv_nb,
+                            mbedtls_test_mock_tcp_send_nb,
+                            mbedtls_test_mock_tcp_recv_nb,
                             NULL);
     }
 
@@ -863,7 +863,7 @@
     }
 #endif
 
-    ret = mbedtls_endpoint_certificate_init(ep, pk_alg);
+    ret = mbedtls_test_ssl_endpoint_certificate_init(ep, pk_alg);
     TEST_ASSERT(ret == 0);
 
 exit:
@@ -873,8 +873,8 @@
 /*
  * Deinitializes endpoint represented by \p ep.
  */
-void mbedtls_endpoint_free(mbedtls_test_ssl_endpoint *ep,
-                           mbedtls_test_message_socket_context *context)
+void mbedtls_test_ssl_endpoint_free(mbedtls_test_ssl_endpoint *ep,
+                                    mbedtls_test_message_socket_context *context)
 {
     mbedtls_endpoint_certificate_free(ep);
 
@@ -884,9 +884,9 @@
     mbedtls_entropy_free(&(ep->entropy));
 
     if (context != NULL) {
-        mbedtls_message_socket_close(context);
+        mbedtls_test_message_socket_close(context);
     } else {
-        mbedtls_mock_socket_close(&(ep->socket));
+        mbedtls_test_mock_socket_close(&(ep->socket));
     }
 }
 
@@ -897,9 +897,9 @@
  *
  * \retval  0 on success, otherwise error code.
  */
-int mbedtls_move_handshake_to_state(mbedtls_ssl_context *ssl,
-                                    mbedtls_ssl_context *second_ssl,
-                                    int state)
+int mbedtls_test_move_handshake_to_state(mbedtls_ssl_context *ssl,
+                                         mbedtls_ssl_context *second_ssl,
+                                         int state)
 {
     enum { BUFFSIZE = 1024 };
     int max_steps = 1000;
@@ -1079,12 +1079,12 @@
 #define SSL_CID_LEN_MIN MBEDTLS_SSL_CID_OUT_LEN_MAX
 #endif
 
-static int build_transforms(mbedtls_ssl_transform *t_in,
-                            mbedtls_ssl_transform *t_out,
-                            int cipher_type, int hash_id,
-                            int etm, int tag_mode, int ver,
-                            size_t cid0_len,
-                            size_t cid1_len)
+static int mbedtls_test_ssl_build_transforms(mbedtls_ssl_transform *t_in,
+                                             mbedtls_ssl_transform *t_out,
+                                             int cipher_type, int hash_id,
+                                             int etm, int tag_mode, int ver,
+                                             size_t cid0_len,
+                                             size_t cid1_len)
 {
     mbedtls_cipher_info_t const *cipher_info;
     int ret = 0;
@@ -1330,9 +1330,9 @@
  * Populate a session structure for serialization tests.
  * Choose dummy values, mostly non-0 to distinguish from the init default.
  */
-static int ssl_populate_session(mbedtls_ssl_session *session,
-                                int ticket_len,
-                                const char *crt_file)
+static int mbedtls_test_ssl_populate_session(mbedtls_ssl_session *session,
+                                             int ticket_len,
+                                             const char *crt_file)
 {
 #if defined(MBEDTLS_HAVE_TIME)
     session->start = mbedtls_time(NULL) - 42;
@@ -1558,7 +1558,7 @@
     defined(MBEDTLS_CERTS_C) && \
     defined(MBEDTLS_ENTROPY_C) && \
     defined(MBEDTLS_CTR_DRBG_C)
-void perform_handshake(mbedtls_test_handshake_test_options *options)
+void mbedtls_test_ssl_perform_handshake(mbedtls_test_handshake_test_options *options)
 {
     /* forced_ciphersuite needs to last until the end of the handshake */
     int forced_ciphersuite[2];
@@ -1585,24 +1585,24 @@
 
     mbedtls_test_ssl_message_queue server_queue, client_queue;
     mbedtls_test_message_socket_context server_context, client_context;
-    mbedtls_message_socket_init(&server_context);
-    mbedtls_message_socket_init(&client_context);
+    mbedtls_test_message_socket_init(&server_context);
+    mbedtls_test_message_socket_init(&client_context);
 
     /* Client side */
     if (options->dtls != 0) {
-        TEST_ASSERT(mbedtls_endpoint_init(&client, MBEDTLS_SSL_IS_CLIENT,
-                                          options->pk_alg, &client_context,
-                                          &client_queue,
-                                          &server_queue, NULL) == 0);
+        TEST_ASSERT(mbedtls_test_ssl_endpoint_init(&client, MBEDTLS_SSL_IS_CLIENT,
+                                                   options->pk_alg, &client_context,
+                                                   &client_queue,
+                                                   &server_queue, NULL) == 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_endpoint_init(&client, MBEDTLS_SSL_IS_CLIENT,
-                                          options->pk_alg, NULL, NULL,
-                                          NULL, NULL) == 0);
+        TEST_ASSERT(mbedtls_test_ssl_endpoint_init(&client, MBEDTLS_SSL_IS_CLIENT,
+                                                   options->pk_alg, NULL, NULL,
+                                                   NULL, NULL) == 0);
     }
 
     if (options->client_min_version != TEST_SSL_MINOR_VERSION_NONE) {
@@ -1629,19 +1629,19 @@
 
     /* Server side */
     if (options->dtls != 0) {
-        TEST_ASSERT(mbedtls_endpoint_init(&server, MBEDTLS_SSL_IS_SERVER,
-                                          options->pk_alg, &server_context,
-                                          &server_queue,
-                                          &client_queue, NULL) == 0);
+        TEST_ASSERT(mbedtls_test_ssl_endpoint_init(&server, MBEDTLS_SSL_IS_SERVER,
+                                                   options->pk_alg, &server_context,
+                                                   &server_queue,
+                                                   &client_queue, NULL) == 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_endpoint_init(&server, MBEDTLS_SSL_IS_SERVER,
-                                          options->pk_alg, NULL, NULL,
-                                          NULL, NULL) == 0);
+        TEST_ASSERT(mbedtls_test_ssl_endpoint_init(&server, MBEDTLS_SSL_IS_SERVER,
+                                                   options->pk_alg, NULL, NULL,
+                                                   NULL, NULL) == 0);
     }
 
     mbedtls_ssl_conf_authmode(&server.conf, options->srv_auth_mode);
@@ -1702,9 +1702,9 @@
     }
 #endif
 
-    TEST_ASSERT(mbedtls_mock_socket_connect(&(client.socket),
-                                            &(server.socket),
-                                            BUFFSIZE) == 0);
+    TEST_ASSERT(mbedtls_test_mock_socket_connect(&(client.socket),
+                                                 &(server.socket),
+                                                 BUFFSIZE) == 0);
 
 #if defined(MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH)
     if (options->resize_buffers != 0) {
@@ -1720,9 +1720,9 @@
         expected_handshake_result = MBEDTLS_ERR_SSL_BAD_HS_PROTOCOL_VERSION;
     }
 
-    TEST_ASSERT(mbedtls_move_handshake_to_state(&(client.ssl),
-                                                &(server.ssl),
-                                                MBEDTLS_SSL_HANDSHAKE_OVER)
+    TEST_ASSERT(mbedtls_test_move_handshake_to_state(&(client.ssl),
+                                                     &(server.ssl),
+                                                     MBEDTLS_SSL_HANDSHAKE_OVER)
                 ==  expected_handshake_result);
 
     if (expected_handshake_result != 0) {
@@ -1788,8 +1788,8 @@
         TEST_ASSERT(mbedtls_ssl_setup(&(server.ssl), &(server.conf)) == 0);
 
         mbedtls_ssl_set_bio(&(server.ssl), &server_context,
-                            mbedtls_mock_tcp_send_msg,
-                            mbedtls_mock_tcp_recv_msg,
+                            mbedtls_test_mock_tcp_send_msg,
+                            mbedtls_test_mock_tcp_recv_msg,
                             NULL);
 
 #if defined(MBEDTLS_TIMING_C)
@@ -1894,8 +1894,8 @@
 #endif /* MBEDTLS_SSL_RENEGOTIATION */
 
 exit:
-    mbedtls_endpoint_free(&client, options->dtls != 0 ? &client_context : NULL);
-    mbedtls_endpoint_free(&server, options->dtls != 0 ? &server_context : NULL);
+    mbedtls_test_ssl_endpoint_free(&client, options->dtls != 0 ? &client_context : NULL);
+    mbedtls_test_ssl_endpoint_free(&server, options->dtls != 0 ? &server_context : NULL);
 #if defined(MBEDTLS_DEBUG_C)
     if (options->cli_log_fun || options->srv_log_fun) {
         mbedtls_debug_set_threshold(0);
@@ -1928,53 +1928,53 @@
     memset(input, 0, sizeof(input));
 
     /* Make sure calling put and get on NULL buffer results in error. */
-    TEST_ASSERT(mbedtls_test_buffer_put(NULL, input, sizeof(input))
+    TEST_ASSERT(mbedtls_test_ssl_buffer_put(NULL, input, sizeof(input))
                 == -1);
-    TEST_ASSERT(mbedtls_test_buffer_get(NULL, output, sizeof(output))
+    TEST_ASSERT(mbedtls_test_ssl_buffer_get(NULL, output, sizeof(output))
                 == -1);
-    TEST_ASSERT(mbedtls_test_buffer_put(NULL, NULL, sizeof(input)) == -1);
+    TEST_ASSERT(mbedtls_test_ssl_buffer_put(NULL, NULL, sizeof(input)) == -1);
 
-    TEST_ASSERT(mbedtls_test_buffer_put(NULL, NULL, 0) == -1);
-    TEST_ASSERT(mbedtls_test_buffer_get(NULL, NULL, 0) == -1);
+    TEST_ASSERT(mbedtls_test_ssl_buffer_put(NULL, NULL, 0) == -1);
+    TEST_ASSERT(mbedtls_test_ssl_buffer_get(NULL, NULL, 0) == -1);
 
     /* Make sure calling put and get on a buffer that hasn't been set up results
      * in error. */
-    mbedtls_test_buffer_init(&buf);
+    mbedtls_test_ssl_buffer_init(&buf);
 
-    TEST_ASSERT(mbedtls_test_buffer_put(&buf, input, sizeof(input)) == -1);
-    TEST_ASSERT(mbedtls_test_buffer_get(&buf, output, sizeof(output))
+    TEST_ASSERT(mbedtls_test_ssl_buffer_put(&buf, input, sizeof(input)) == -1);
+    TEST_ASSERT(mbedtls_test_ssl_buffer_get(&buf, output, sizeof(output))
                 == -1);
-    TEST_ASSERT(mbedtls_test_buffer_put(&buf, NULL, sizeof(input)) == -1);
+    TEST_ASSERT(mbedtls_test_ssl_buffer_put(&buf, NULL, sizeof(input)) == -1);
 
-    TEST_ASSERT(mbedtls_test_buffer_put(&buf, NULL, 0) == -1);
-    TEST_ASSERT(mbedtls_test_buffer_get(&buf, NULL, 0) == -1);
+    TEST_ASSERT(mbedtls_test_ssl_buffer_put(&buf, NULL, 0) == -1);
+    TEST_ASSERT(mbedtls_test_ssl_buffer_get(&buf, NULL, 0) == -1);
 
     /* Make sure calling put and get on NULL input only results in
      * error if the length is not zero, and that a NULL output is valid for data
      * dropping.
      */
 
-    TEST_ASSERT(mbedtls_test_buffer_setup(&buf, sizeof(input)) == 0);
+    TEST_ASSERT(mbedtls_test_ssl_buffer_setup(&buf, sizeof(input)) == 0);
 
-    TEST_ASSERT(mbedtls_test_buffer_put(&buf, NULL, sizeof(input)) == -1);
-    TEST_ASSERT(mbedtls_test_buffer_get(&buf, NULL, sizeof(output))
+    TEST_ASSERT(mbedtls_test_ssl_buffer_put(&buf, NULL, sizeof(input)) == -1);
+    TEST_ASSERT(mbedtls_test_ssl_buffer_get(&buf, NULL, sizeof(output))
                 == 0);
-    TEST_ASSERT(mbedtls_test_buffer_put(&buf, NULL, 0) == 0);
-    TEST_ASSERT(mbedtls_test_buffer_get(&buf, NULL, 0) == 0);
+    TEST_ASSERT(mbedtls_test_ssl_buffer_put(&buf, NULL, 0) == 0);
+    TEST_ASSERT(mbedtls_test_ssl_buffer_get(&buf, NULL, 0) == 0);
 
     /* Make sure calling put several times in the row is safe */
 
-    TEST_ASSERT(mbedtls_test_buffer_put(&buf, input, sizeof(input))
+    TEST_ASSERT(mbedtls_test_ssl_buffer_put(&buf, input, sizeof(input))
                 == sizeof(input));
-    TEST_ASSERT(mbedtls_test_buffer_get(&buf, output, 2) == 2);
-    TEST_ASSERT(mbedtls_test_buffer_put(&buf, input, 1) == 1);
-    TEST_ASSERT(mbedtls_test_buffer_put(&buf, input, 2) == 1);
-    TEST_ASSERT(mbedtls_test_buffer_put(&buf, input, 2) == 0);
+    TEST_ASSERT(mbedtls_test_ssl_buffer_get(&buf, output, 2) == 2);
+    TEST_ASSERT(mbedtls_test_ssl_buffer_put(&buf, input, 1) == 1);
+    TEST_ASSERT(mbedtls_test_ssl_buffer_put(&buf, input, 2) == 1);
+    TEST_ASSERT(mbedtls_test_ssl_buffer_put(&buf, input, 2) == 0);
 
 
 exit:
 
-    mbedtls_test_buffer_free(&buf);
+    mbedtls_test_ssl_buffer_free(&buf);
 }
 /* END_CASE */
 
@@ -2008,8 +2008,8 @@
     size_t output_len;
     size_t i, j, written, read;
 
-    mbedtls_test_buffer_init(&buf);
-    TEST_ASSERT(mbedtls_test_buffer_setup(&buf, size) == 0);
+    mbedtls_test_ssl_buffer_init(&buf);
+    TEST_ASSERT(mbedtls_test_ssl_buffer_setup(&buf, size) == 0);
 
     /* Check the sanity of input parameters and initialise local variables. That
      * is, ensure that the amount of data is not negative and that we are not
@@ -2068,11 +2068,11 @@
 
     written = read = 0;
     for (j = 0; j < ROUNDS; j++) {
-        TEST_ASSERT(put_ret[j] == mbedtls_test_buffer_put(&buf,
-                                                          input + written, put[j]));
+        TEST_ASSERT(put_ret[j] == mbedtls_test_ssl_buffer_put(&buf,
+                                                              input + written, put[j]));
         written += put_ret[j];
-        TEST_ASSERT(get_ret[j] == mbedtls_test_buffer_get(&buf,
-                                                          output + read, get[j]));
+        TEST_ASSERT(get_ret[j] == mbedtls_test_ssl_buffer_get(&buf,
+                                                              output + read, get[j]));
         read += get_ret[j];
         TEST_ASSERT(read <= written);
         if (get_ret[j] > 0) {
@@ -2086,7 +2086,7 @@
 
     mbedtls_free(input);
     mbedtls_free(output);
-    mbedtls_test_buffer_free(&buf);
+    mbedtls_test_ssl_buffer_free(&buf);
 }
 /* END_CASE */
 
@@ -2104,22 +2104,22 @@
     mbedtls_test_mock_socket socket;
 
     mbedtls_mock_socket_init(&socket);
-    TEST_ASSERT(mbedtls_mock_tcp_send_b(&socket, message, MSGLEN) < 0);
-    mbedtls_mock_socket_close(&socket);
+    TEST_ASSERT(mbedtls_test_mock_tcp_send_b(&socket, message, MSGLEN) < 0);
+    mbedtls_test_mock_socket_close(&socket);
     mbedtls_mock_socket_init(&socket);
-    TEST_ASSERT(mbedtls_mock_tcp_recv_b(&socket, received, MSGLEN) < 0);
-    mbedtls_mock_socket_close(&socket);
+    TEST_ASSERT(mbedtls_test_mock_tcp_recv_b(&socket, received, MSGLEN) < 0);
+    mbedtls_test_mock_socket_close(&socket);
 
     mbedtls_mock_socket_init(&socket);
-    TEST_ASSERT(mbedtls_mock_tcp_send_nb(&socket, message, MSGLEN) < 0);
-    mbedtls_mock_socket_close(&socket);
+    TEST_ASSERT(mbedtls_test_mock_tcp_send_nb(&socket, message, MSGLEN) < 0);
+    mbedtls_test_mock_socket_close(&socket);
     mbedtls_mock_socket_init(&socket);
-    TEST_ASSERT(mbedtls_mock_tcp_recv_nb(&socket, received, MSGLEN) < 0);
-    mbedtls_mock_socket_close(&socket);
+    TEST_ASSERT(mbedtls_test_mock_tcp_recv_nb(&socket, received, MSGLEN) < 0);
+    mbedtls_test_mock_socket_close(&socket);
 
 exit:
 
-    mbedtls_mock_socket_close(&socket);
+    mbedtls_test_mock_socket_close(&socket);
 }
 /* END_CASE */
 
@@ -2144,11 +2144,11 @@
     unsigned i;
 
     if (blocking == 0) {
-        send = mbedtls_mock_tcp_send_nb;
-        recv = mbedtls_mock_tcp_recv_nb;
+        send = mbedtls_test_mock_tcp_send_nb;
+        recv = mbedtls_test_mock_tcp_recv_nb;
     } else {
-        send = mbedtls_mock_tcp_send_b;
-        recv = mbedtls_mock_tcp_recv_b;
+        send = mbedtls_test_mock_tcp_send_b;
+        recv = mbedtls_test_mock_tcp_recv_b;
     }
 
     mbedtls_mock_socket_init(&client);
@@ -2161,7 +2161,7 @@
     }
 
     /* Make sure that sending a message takes a few  iterations. */
-    TEST_ASSERT(0 == mbedtls_mock_socket_connect(&client, &server, BUFLEN));
+    TEST_ASSERT(0 == mbedtls_test_mock_socket_connect(&client, &server, BUFLEN));
 
     /* Send the message to the server */
     send_ret = recv_ret = 1;
@@ -2211,8 +2211,8 @@
 
 exit:
 
-    mbedtls_mock_socket_close(&client);
-    mbedtls_mock_socket_close(&server);
+    mbedtls_test_mock_socket_close(&client);
+    mbedtls_test_mock_socket_close(&server);
 }
 /* END_CASE */
 
@@ -2241,11 +2241,11 @@
     mbedtls_ssl_recv_t *recv;
 
     if (blocking == 0) {
-        send = mbedtls_mock_tcp_send_nb;
-        recv = mbedtls_mock_tcp_recv_nb;
+        send = mbedtls_test_mock_tcp_send_nb;
+        recv = mbedtls_test_mock_tcp_recv_nb;
     } else {
-        send = mbedtls_mock_tcp_send_b;
-        recv = mbedtls_mock_tcp_recv_b;
+        send = mbedtls_test_mock_tcp_send_b;
+        recv = mbedtls_test_mock_tcp_recv_b;
     }
 
     mbedtls_mock_socket_init(&client);
@@ -2260,7 +2260,7 @@
     }
 
     /* Make sure that sending a message takes a few  iterations. */
-    TEST_ASSERT(0 == mbedtls_mock_socket_connect(&client, &server, BUFLEN));
+    TEST_ASSERT(0 == mbedtls_test_mock_socket_connect(&client, &server, BUFLEN));
 
     /* Send the message from both sides, interleaving. */
     progress = 1;
@@ -2338,8 +2338,8 @@
 
 exit:
 
-    mbedtls_mock_socket_close(&client);
-    mbedtls_mock_socket_close(&server);
+    mbedtls_test_mock_socket_close(&client);
+    mbedtls_test_mock_socket_close(&server);
 }
 /* END_CASE */
 
@@ -2349,17 +2349,17 @@
     mbedtls_test_ssl_message_queue queue;
 
     /* Trying to push/pull to an empty queue */
-    TEST_ASSERT(mbedtls_test_message_queue_push_info(NULL, 1)
+    TEST_ASSERT(mbedtls_test_ssl_message_queue_push_info(NULL, 1)
                 == MBEDTLS_TEST_ERROR_ARG_NULL);
-    TEST_ASSERT(mbedtls_test_message_queue_pop_info(NULL, 1)
+    TEST_ASSERT(mbedtls_test_ssl_message_queue_pop_info(NULL, 1)
                 == MBEDTLS_TEST_ERROR_ARG_NULL);
 
-    TEST_ASSERT(mbedtls_test_message_queue_setup(&queue, 3) == 0);
+    TEST_ASSERT(mbedtls_test_ssl_message_queue_setup(&queue, 3) == 0);
     TEST_ASSERT(queue.capacity == 3);
     TEST_ASSERT(queue.num == 0);
 
 exit:
-    mbedtls_test_message_queue_free(&queue);
+    mbedtls_test_ssl_message_queue_free(&queue);
 }
 /* END_CASE */
 
@@ -2368,25 +2368,25 @@
 {
     mbedtls_test_ssl_message_queue queue;
 
-    TEST_ASSERT(mbedtls_test_message_queue_setup(&queue, 3) == 0);
+    TEST_ASSERT(mbedtls_test_ssl_message_queue_setup(&queue, 3) == 0);
 
     /* Sanity test - 3 pushes and 3 pops with sufficient space */
-    TEST_ASSERT(mbedtls_test_message_queue_push_info(&queue, 1) == 1);
+    TEST_ASSERT(mbedtls_test_ssl_message_queue_push_info(&queue, 1) == 1);
     TEST_ASSERT(queue.capacity == 3);
     TEST_ASSERT(queue.num == 1);
-    TEST_ASSERT(mbedtls_test_message_queue_push_info(&queue, 1) == 1);
+    TEST_ASSERT(mbedtls_test_ssl_message_queue_push_info(&queue, 1) == 1);
     TEST_ASSERT(queue.capacity == 3);
     TEST_ASSERT(queue.num == 2);
-    TEST_ASSERT(mbedtls_test_message_queue_push_info(&queue, 2) == 2);
+    TEST_ASSERT(mbedtls_test_ssl_message_queue_push_info(&queue, 2) == 2);
     TEST_ASSERT(queue.capacity == 3);
     TEST_ASSERT(queue.num == 3);
 
-    TEST_ASSERT(mbedtls_test_message_queue_pop_info(&queue, 1) == 1);
-    TEST_ASSERT(mbedtls_test_message_queue_pop_info(&queue, 1) == 1);
-    TEST_ASSERT(mbedtls_test_message_queue_pop_info(&queue, 2) == 2);
+    TEST_ASSERT(mbedtls_test_ssl_message_queue_pop_info(&queue, 1) == 1);
+    TEST_ASSERT(mbedtls_test_ssl_message_queue_pop_info(&queue, 1) == 1);
+    TEST_ASSERT(mbedtls_test_ssl_message_queue_pop_info(&queue, 2) == 2);
 
 exit:
-    mbedtls_test_message_queue_free(&queue);
+    mbedtls_test_ssl_message_queue_free(&queue);
 }
 /* END_CASE */
 
@@ -2395,24 +2395,24 @@
 {
     mbedtls_test_ssl_message_queue queue;
 
-    TEST_ASSERT(mbedtls_test_message_queue_setup(&queue, 3) == 0);
+    TEST_ASSERT(mbedtls_test_ssl_message_queue_setup(&queue, 3) == 0);
 
     /* 4 pushes (last one with an error), 4 pops (last one with an error) */
-    TEST_ASSERT(mbedtls_test_message_queue_push_info(&queue, 1) == 1);
-    TEST_ASSERT(mbedtls_test_message_queue_push_info(&queue, 1) == 1);
-    TEST_ASSERT(mbedtls_test_message_queue_push_info(&queue, 2) == 2);
-    TEST_ASSERT(mbedtls_test_message_queue_push_info(&queue, 3)
+    TEST_ASSERT(mbedtls_test_ssl_message_queue_push_info(&queue, 1) == 1);
+    TEST_ASSERT(mbedtls_test_ssl_message_queue_push_info(&queue, 1) == 1);
+    TEST_ASSERT(mbedtls_test_ssl_message_queue_push_info(&queue, 2) == 2);
+    TEST_ASSERT(mbedtls_test_ssl_message_queue_push_info(&queue, 3)
                 == MBEDTLS_ERR_SSL_WANT_WRITE);
 
-    TEST_ASSERT(mbedtls_test_message_queue_pop_info(&queue, 1) == 1);
-    TEST_ASSERT(mbedtls_test_message_queue_pop_info(&queue, 1) == 1);
-    TEST_ASSERT(mbedtls_test_message_queue_pop_info(&queue, 2) == 2);
+    TEST_ASSERT(mbedtls_test_ssl_message_queue_pop_info(&queue, 1) == 1);
+    TEST_ASSERT(mbedtls_test_ssl_message_queue_pop_info(&queue, 1) == 1);
+    TEST_ASSERT(mbedtls_test_ssl_message_queue_pop_info(&queue, 2) == 2);
 
-    TEST_ASSERT(mbedtls_test_message_queue_pop_info(&queue, 1)
+    TEST_ASSERT(mbedtls_test_ssl_message_queue_pop_info(&queue, 1)
                 == MBEDTLS_ERR_SSL_WANT_READ);
 
 exit:
-    mbedtls_test_message_queue_free(&queue);
+    mbedtls_test_ssl_message_queue_free(&queue);
 }
 /* END_CASE */
 
@@ -2421,32 +2421,32 @@
 {
     mbedtls_test_ssl_message_queue queue;
 
-    TEST_ASSERT(mbedtls_test_message_queue_setup(&queue, 3) == 0);
+    TEST_ASSERT(mbedtls_test_ssl_message_queue_setup(&queue, 3) == 0);
 
     /* Interleaved test - [2 pushes, 1 pop] twice, and then two pops
      * (to wrap around the buffer) */
-    TEST_ASSERT(mbedtls_test_message_queue_push_info(&queue, 1) == 1);
-    TEST_ASSERT(mbedtls_test_message_queue_push_info(&queue, 1) == 1);
+    TEST_ASSERT(mbedtls_test_ssl_message_queue_push_info(&queue, 1) == 1);
+    TEST_ASSERT(mbedtls_test_ssl_message_queue_push_info(&queue, 1) == 1);
 
-    TEST_ASSERT(mbedtls_test_message_queue_pop_info(&queue, 1) == 1);
+    TEST_ASSERT(mbedtls_test_ssl_message_queue_pop_info(&queue, 1) == 1);
 
-    TEST_ASSERT(mbedtls_test_message_queue_push_info(&queue, 2) == 2);
-    TEST_ASSERT(mbedtls_test_message_queue_push_info(&queue, 3) == 3);
+    TEST_ASSERT(mbedtls_test_ssl_message_queue_push_info(&queue, 2) == 2);
+    TEST_ASSERT(mbedtls_test_ssl_message_queue_push_info(&queue, 3) == 3);
 
-    TEST_ASSERT(mbedtls_test_message_queue_pop_info(&queue, 1) == 1);
-    TEST_ASSERT(mbedtls_test_message_queue_pop_info(&queue, 2) == 2);
+    TEST_ASSERT(mbedtls_test_ssl_message_queue_pop_info(&queue, 1) == 1);
+    TEST_ASSERT(mbedtls_test_ssl_message_queue_pop_info(&queue, 2) == 2);
 
-    TEST_ASSERT(mbedtls_test_message_queue_push_info(&queue, 5) == 5);
-    TEST_ASSERT(mbedtls_test_message_queue_push_info(&queue, 8) == 8);
+    TEST_ASSERT(mbedtls_test_ssl_message_queue_push_info(&queue, 5) == 5);
+    TEST_ASSERT(mbedtls_test_ssl_message_queue_push_info(&queue, 8) == 8);
 
-    TEST_ASSERT(mbedtls_test_message_queue_pop_info(&queue, 3) == 3);
+    TEST_ASSERT(mbedtls_test_ssl_message_queue_pop_info(&queue, 3) == 3);
 
-    TEST_ASSERT(mbedtls_test_message_queue_pop_info(&queue, 5) == 5);
+    TEST_ASSERT(mbedtls_test_ssl_message_queue_pop_info(&queue, 5) == 5);
 
-    TEST_ASSERT(mbedtls_test_message_queue_pop_info(&queue, 8) == 8);
+    TEST_ASSERT(mbedtls_test_ssl_message_queue_pop_info(&queue, 8) == 8);
 
 exit:
-    mbedtls_test_message_queue_free(&queue);
+    mbedtls_test_ssl_message_queue_free(&queue);
 }
 /* END_CASE */
 
@@ -2457,15 +2457,15 @@
     size_t message_len = 10;
     size_t buffer_len = 5;
 
-    TEST_ASSERT(mbedtls_test_message_queue_setup(&queue, 1) == 0);
+    TEST_ASSERT(mbedtls_test_ssl_message_queue_setup(&queue, 1) == 0);
 
     /* Popping without a sufficient buffer */
-    TEST_ASSERT(mbedtls_test_message_queue_push_info(&queue, message_len)
+    TEST_ASSERT(mbedtls_test_ssl_message_queue_push_info(&queue, message_len)
                 == (int) message_len);
-    TEST_ASSERT(mbedtls_test_message_queue_pop_info(&queue, buffer_len)
+    TEST_ASSERT(mbedtls_test_ssl_message_queue_pop_info(&queue, buffer_len)
                 == (int) buffer_len);
 exit:
-    mbedtls_test_message_queue_free(&queue);
+    mbedtls_test_ssl_message_queue_free(&queue);
 }
 /* END_CASE */
 
@@ -2477,41 +2477,41 @@
     mbedtls_test_mock_socket client, server;
     mbedtls_test_ssl_message_queue server_queue, client_queue;
     mbedtls_test_message_socket_context server_context, client_context;
-    mbedtls_message_socket_init(&server_context);
-    mbedtls_message_socket_init(&client_context);
+    mbedtls_test_message_socket_init(&server_context);
+    mbedtls_test_message_socket_init(&client_context);
 
     /* Send with a NULL context */
-    TEST_ASSERT(mbedtls_mock_tcp_send_msg(NULL, message, MSGLEN)
+    TEST_ASSERT(mbedtls_test_mock_tcp_send_msg(NULL, message, MSGLEN)
                 == MBEDTLS_TEST_ERROR_CONTEXT_ERROR);
 
-    TEST_ASSERT(mbedtls_mock_tcp_recv_msg(NULL, message, MSGLEN)
+    TEST_ASSERT(mbedtls_test_mock_tcp_recv_msg(NULL, message, MSGLEN)
                 == MBEDTLS_TEST_ERROR_CONTEXT_ERROR);
 
-    TEST_ASSERT(mbedtls_message_socket_setup(&server_queue, &client_queue, 1,
-                                             &server,
-                                             &server_context) == 0);
+    TEST_ASSERT(mbedtls_test_message_socket_setup(&server_queue, &client_queue, 1,
+                                                  &server,
+                                                  &server_context) == 0);
 
-    TEST_ASSERT(mbedtls_message_socket_setup(&client_queue, &server_queue, 1,
-                                             &client,
-                                             &client_context) == 0);
+    TEST_ASSERT(mbedtls_test_message_socket_setup(&client_queue, &server_queue, 1,
+                                                  &client,
+                                                  &client_context) == 0);
 
-    TEST_ASSERT(mbedtls_mock_tcp_send_msg(&client_context, message, MSGLEN)
+    TEST_ASSERT(mbedtls_test_mock_tcp_send_msg(&client_context, message, MSGLEN)
                 == MBEDTLS_TEST_ERROR_SEND_FAILED);
 
-    TEST_ASSERT(mbedtls_mock_tcp_recv_msg(&server_context, received, MSGLEN)
+    TEST_ASSERT(mbedtls_test_mock_tcp_recv_msg(&server_context, received, MSGLEN)
                 == MBEDTLS_ERR_SSL_WANT_READ);
 
     /* Push directly to a queue to later simulate a disconnected behavior */
-    TEST_ASSERT(mbedtls_test_message_queue_push_info(&server_queue, MSGLEN)
+    TEST_ASSERT(mbedtls_test_ssl_message_queue_push_info(&server_queue, MSGLEN)
                 == MSGLEN);
 
     /* Test if there's an error when trying to read from a disconnected
      * socket */
-    TEST_ASSERT(mbedtls_mock_tcp_recv_msg(&server_context, received, MSGLEN)
+    TEST_ASSERT(mbedtls_test_mock_tcp_recv_msg(&server_context, received, MSGLEN)
                 == MBEDTLS_TEST_ERROR_RECV_FAILED);
 exit:
-    mbedtls_message_socket_close(&server_context);
-    mbedtls_message_socket_close(&client_context);
+    mbedtls_test_message_socket_close(&server_context);
+    mbedtls_test_message_socket_close(&client_context);
 }
 /* END_CASE */
 
@@ -2524,48 +2524,48 @@
     unsigned i;
     mbedtls_test_ssl_message_queue server_queue, client_queue;
     mbedtls_test_message_socket_context server_context, client_context;
-    mbedtls_message_socket_init(&server_context);
-    mbedtls_message_socket_init(&client_context);
+    mbedtls_test_message_socket_init(&server_context);
+    mbedtls_test_message_socket_init(&client_context);
 
-    TEST_ASSERT(mbedtls_message_socket_setup(&server_queue, &client_queue, 1,
-                                             &server,
-                                             &server_context) == 0);
+    TEST_ASSERT(mbedtls_test_message_socket_setup(&server_queue, &client_queue, 1,
+                                                  &server,
+                                                  &server_context) == 0);
 
-    TEST_ASSERT(mbedtls_message_socket_setup(&client_queue, &server_queue, 1,
-                                             &client,
-                                             &client_context) == 0);
+    TEST_ASSERT(mbedtls_test_message_socket_setup(&client_queue, &server_queue, 1,
+                                                  &client,
+                                                  &client_context) == 0);
 
     /* Fill up the buffer with structured data so that unwanted changes
      * can be detected */
     for (i = 0; i < MSGLEN; i++) {
         message[i] = i & 0xFF;
     }
-    TEST_ASSERT(0 == mbedtls_mock_socket_connect(&client, &server,
-                                                 MSGLEN));
+    TEST_ASSERT(0 == mbedtls_test_mock_socket_connect(&client, &server,
+                                                      MSGLEN));
 
     /* Send the message to the server */
-    TEST_ASSERT(mbedtls_mock_tcp_send_msg(&client_context, message,
-                                          MSGLEN) == MSGLEN);
+    TEST_ASSERT(mbedtls_test_mock_tcp_send_msg(&client_context, message,
+                                               MSGLEN) == MSGLEN);
 
     /* Read from the server */
-    TEST_ASSERT(mbedtls_mock_tcp_recv_msg(&server_context, received, MSGLEN)
+    TEST_ASSERT(mbedtls_test_mock_tcp_recv_msg(&server_context, received, MSGLEN)
                 == MSGLEN);
 
     TEST_ASSERT(memcmp(message, received, MSGLEN) == 0);
     memset(received, 0, MSGLEN);
 
     /* Send the message to the client */
-    TEST_ASSERT(mbedtls_mock_tcp_send_msg(&server_context, message,
-                                          MSGLEN) == MSGLEN);
+    TEST_ASSERT(mbedtls_test_mock_tcp_send_msg(&server_context, message,
+                                               MSGLEN) == MSGLEN);
 
     /* Read from the client */
-    TEST_ASSERT(mbedtls_mock_tcp_recv_msg(&client_context, received, MSGLEN)
+    TEST_ASSERT(mbedtls_test_mock_tcp_recv_msg(&client_context, received, MSGLEN)
                 == MSGLEN);
     TEST_ASSERT(memcmp(message, received, MSGLEN) == 0);
 
 exit:
-    mbedtls_message_socket_close(&server_context);
-    mbedtls_message_socket_close(&client_context);
+    mbedtls_test_message_socket_close(&server_context);
+    mbedtls_test_message_socket_close(&client_context);
 }
 /* END_CASE */
 
@@ -2578,51 +2578,51 @@
     unsigned i;
     mbedtls_test_ssl_message_queue server_queue, client_queue;
     mbedtls_test_message_socket_context server_context, client_context;
-    mbedtls_message_socket_init(&server_context);
-    mbedtls_message_socket_init(&client_context);
+    mbedtls_test_message_socket_init(&server_context);
+    mbedtls_test_message_socket_init(&client_context);
 
-    TEST_ASSERT(mbedtls_message_socket_setup(&server_queue, &client_queue, 2,
-                                             &server,
-                                             &server_context) == 0);
+    TEST_ASSERT(mbedtls_test_message_socket_setup(&server_queue, &client_queue, 2,
+                                                  &server,
+                                                  &server_context) == 0);
 
-    TEST_ASSERT(mbedtls_message_socket_setup(&client_queue, &server_queue, 2,
-                                             &client,
-                                             &client_context) == 0);
+    TEST_ASSERT(mbedtls_test_message_socket_setup(&client_queue, &server_queue, 2,
+                                                  &client,
+                                                  &client_context) == 0);
 
     /* Fill up the buffer with structured data so that unwanted changes
      * can be detected */
     for (i = 0; i < MSGLEN; i++) {
         message[i] = i & 0xFF;
     }
-    TEST_ASSERT(0 == mbedtls_mock_socket_connect(&client, &server,
-                                                 MSGLEN*2));
+    TEST_ASSERT(0 == mbedtls_test_mock_socket_connect(&client, &server,
+                                                      MSGLEN*2));
 
     /* Send three message to the server, last one with an error */
-    TEST_ASSERT(mbedtls_mock_tcp_send_msg(&client_context, message,
-                                          MSGLEN - 1) == MSGLEN - 1);
+    TEST_ASSERT(mbedtls_test_mock_tcp_send_msg(&client_context, message,
+                                               MSGLEN - 1) == MSGLEN - 1);
 
-    TEST_ASSERT(mbedtls_mock_tcp_send_msg(&client_context, message,
-                                          MSGLEN) == MSGLEN);
+    TEST_ASSERT(mbedtls_test_mock_tcp_send_msg(&client_context, message,
+                                               MSGLEN) == MSGLEN);
 
-    TEST_ASSERT(mbedtls_mock_tcp_send_msg(&client_context, message,
-                                          MSGLEN)
+    TEST_ASSERT(mbedtls_test_mock_tcp_send_msg(&client_context, message,
+                                               MSGLEN)
                 == MBEDTLS_ERR_SSL_WANT_WRITE);
 
     /* Read three messages from the server, last one with an error */
-    TEST_ASSERT(mbedtls_mock_tcp_recv_msg(&server_context, received,
-                                          MSGLEN - 1) == MSGLEN - 1);
+    TEST_ASSERT(mbedtls_test_mock_tcp_recv_msg(&server_context, received,
+                                               MSGLEN - 1) == MSGLEN - 1);
 
-    TEST_ASSERT(mbedtls_mock_tcp_recv_msg(&server_context, received, MSGLEN)
+    TEST_ASSERT(mbedtls_test_mock_tcp_recv_msg(&server_context, received, MSGLEN)
                 == MSGLEN);
 
     TEST_ASSERT(memcmp(message, received, MSGLEN) == 0);
 
-    TEST_ASSERT(mbedtls_mock_tcp_recv_msg(&server_context, received, MSGLEN)
+    TEST_ASSERT(mbedtls_test_mock_tcp_recv_msg(&server_context, received, MSGLEN)
                 == MBEDTLS_ERR_SSL_WANT_READ);
 
 exit:
-    mbedtls_message_socket_close(&server_context);
-    mbedtls_message_socket_close(&client_context);
+    mbedtls_test_message_socket_close(&server_context);
+    mbedtls_test_message_socket_close(&client_context);
 }
 /* END_CASE */
 
@@ -2635,42 +2635,42 @@
     unsigned i;
     mbedtls_test_ssl_message_queue server_queue, client_queue;
     mbedtls_test_message_socket_context server_context, client_context;
-    mbedtls_message_socket_init(&server_context);
-    mbedtls_message_socket_init(&client_context);
+    mbedtls_test_message_socket_init(&server_context);
+    mbedtls_test_message_socket_init(&client_context);
 
-    TEST_ASSERT(mbedtls_message_socket_setup(&server_queue, &client_queue, 2,
-                                             &server,
-                                             &server_context) == 0);
+    TEST_ASSERT(mbedtls_test_message_socket_setup(&server_queue, &client_queue, 2,
+                                                  &server,
+                                                  &server_context) == 0);
 
-    TEST_ASSERT(mbedtls_message_socket_setup(&client_queue, &server_queue, 2,
-                                             &client,
-                                             &client_context) == 0);
+    TEST_ASSERT(mbedtls_test_message_socket_setup(&client_queue, &server_queue, 2,
+                                                  &client,
+                                                  &client_context) == 0);
 
     /* Fill up the buffer with structured data so that unwanted changes
      * can be detected */
     for (i = 0; i < MSGLEN; i++) {
         message[i] = i & 0xFF;
     }
-    TEST_ASSERT(0 == mbedtls_mock_socket_connect(&client, &server,
-                                                 MSGLEN));
+    TEST_ASSERT(0 == mbedtls_test_mock_socket_connect(&client, &server,
+                                                      MSGLEN));
 
     /* Send two message to the server, second one with an error */
-    TEST_ASSERT(mbedtls_mock_tcp_send_msg(&client_context, message,
-                                          MSGLEN) == MSGLEN);
+    TEST_ASSERT(mbedtls_test_mock_tcp_send_msg(&client_context, message,
+                                               MSGLEN) == MSGLEN);
 
-    TEST_ASSERT(mbedtls_mock_tcp_send_msg(&client_context, message,
-                                          MSGLEN)
+    TEST_ASSERT(mbedtls_test_mock_tcp_send_msg(&client_context, message,
+                                               MSGLEN)
                 == MBEDTLS_TEST_ERROR_SEND_FAILED);
 
     /* Read the only message from the server */
-    TEST_ASSERT(mbedtls_mock_tcp_recv_msg(&server_context, received, MSGLEN)
+    TEST_ASSERT(mbedtls_test_mock_tcp_recv_msg(&server_context, received, MSGLEN)
                 == MSGLEN);
 
     TEST_ASSERT(memcmp(message, received, MSGLEN) == 0);
 
 exit:
-    mbedtls_message_socket_close(&server_context);
-    mbedtls_message_socket_close(&client_context);
+    mbedtls_test_message_socket_close(&server_context);
+    mbedtls_test_message_socket_close(&client_context);
 }
 /* END_CASE */
 
@@ -2683,16 +2683,16 @@
     unsigned i;
     mbedtls_test_ssl_message_queue server_queue, client_queue;
     mbedtls_test_message_socket_context server_context, client_context;
-    mbedtls_message_socket_init(&server_context);
-    mbedtls_message_socket_init(&client_context);
+    mbedtls_test_message_socket_init(&server_context);
+    mbedtls_test_message_socket_init(&client_context);
 
-    TEST_ASSERT(mbedtls_message_socket_setup(&server_queue, &client_queue, 2,
-                                             &server,
-                                             &server_context) == 0);
+    TEST_ASSERT(mbedtls_test_message_socket_setup(&server_queue, &client_queue, 2,
+                                                  &server,
+                                                  &server_context) == 0);
 
-    TEST_ASSERT(mbedtls_message_socket_setup(&client_queue, &server_queue, 2,
-                                             &client,
-                                             &client_context) == 0);
+    TEST_ASSERT(mbedtls_test_message_socket_setup(&client_queue, &server_queue, 2,
+                                                  &client,
+                                                  &client_context) == 0);
 
     memset(received, 0, MSGLEN);
     /* Fill up the buffer with structured data so that unwanted changes
@@ -2700,17 +2700,17 @@
     for (i = 0; i < MSGLEN; i++) {
         message[i] = i & 0xFF;
     }
-    TEST_ASSERT(0 == mbedtls_mock_socket_connect(&client, &server,
-                                                 2 * MSGLEN));
+    TEST_ASSERT(0 == mbedtls_test_mock_socket_connect(&client, &server,
+                                                      2 * MSGLEN));
 
     /* Send two messages to the server, the second one small enough to fit in the
      * receiver's buffer. */
-    TEST_ASSERT(mbedtls_mock_tcp_send_msg(&client_context, message,
-                                          MSGLEN) == MSGLEN);
-    TEST_ASSERT(mbedtls_mock_tcp_send_msg(&client_context, message,
-                                          MSGLEN / 2) == MSGLEN / 2);
+    TEST_ASSERT(mbedtls_test_mock_tcp_send_msg(&client_context, message,
+                                               MSGLEN) == MSGLEN);
+    TEST_ASSERT(mbedtls_test_mock_tcp_send_msg(&client_context, message,
+                                               MSGLEN / 2) == MSGLEN / 2);
     /* Read a truncated message from the server */
-    TEST_ASSERT(mbedtls_mock_tcp_recv_msg(&server_context, received, MSGLEN/2)
+    TEST_ASSERT(mbedtls_test_mock_tcp_recv_msg(&server_context, received, MSGLEN/2)
                 == MSGLEN/2);
 
     /* Test that the first half of the message is valid, and second one isn't */
@@ -2720,15 +2720,15 @@
     memset(received, 0, MSGLEN);
 
     /* Read a full message from the server */
-    TEST_ASSERT(mbedtls_mock_tcp_recv_msg(&server_context, received, MSGLEN/2)
+    TEST_ASSERT(mbedtls_test_mock_tcp_recv_msg(&server_context, received, MSGLEN/2)
                 == MSGLEN / 2);
 
     /* Test that the first half of the message is valid */
     TEST_ASSERT(memcmp(message, received, MSGLEN/2) == 0);
 
 exit:
-    mbedtls_message_socket_close(&server_context);
-    mbedtls_message_socket_close(&client_context);
+    mbedtls_test_message_socket_close(&server_context);
+    mbedtls_test_message_socket_close(&client_context);
 }
 /* END_CASE */
 
@@ -2741,31 +2741,31 @@
     unsigned i;
     mbedtls_test_ssl_message_queue server_queue, client_queue;
     mbedtls_test_message_socket_context server_context, client_context;
-    mbedtls_message_socket_init(&server_context);
-    mbedtls_message_socket_init(&client_context);
+    mbedtls_test_message_socket_init(&server_context);
+    mbedtls_test_message_socket_init(&client_context);
 
-    TEST_ASSERT(mbedtls_message_socket_setup(&server_queue, &client_queue, 1,
-                                             &server,
-                                             &server_context) == 0);
+    TEST_ASSERT(mbedtls_test_message_socket_setup(&server_queue, &client_queue, 1,
+                                                  &server,
+                                                  &server_context) == 0);
 
-    TEST_ASSERT(mbedtls_message_socket_setup(&client_queue, &server_queue, 1,
-                                             &client,
-                                             &client_context) == 0);
+    TEST_ASSERT(mbedtls_test_message_socket_setup(&client_queue, &server_queue, 1,
+                                                  &client,
+                                                  &client_context) == 0);
 
     /* Fill up the buffer with structured data so that unwanted changes
      * can be detected */
     for (i = 0; i < MSGLEN; i++) {
         message[i] = i & 0xFF;
     }
-    TEST_ASSERT(0 == mbedtls_mock_socket_connect(&client, &server,
-                                                 MSGLEN));
+    TEST_ASSERT(0 == mbedtls_test_mock_socket_connect(&client, &server,
+                                                      MSGLEN));
 
-    TEST_ASSERT(mbedtls_mock_tcp_send_msg(&client_context, message,
-                                          MSGLEN) == MSGLEN);
+    TEST_ASSERT(mbedtls_test_mock_tcp_send_msg(&client_context, message,
+                                               MSGLEN) == MSGLEN);
 
     /* Force a read error by disconnecting the socket by hand */
     server.status = 0;
-    TEST_ASSERT(mbedtls_mock_tcp_recv_msg(&server_context, received, MSGLEN)
+    TEST_ASSERT(mbedtls_test_mock_tcp_recv_msg(&server_context, received, MSGLEN)
                 == MBEDTLS_TEST_ERROR_RECV_FAILED);
     /* Return to a valid state */
     server.status = MBEDTLS_MOCK_SOCKET_CONNECTED;
@@ -2774,14 +2774,14 @@
 
     /* Test that even though the server tried to read once disconnected, the
      * continuity is preserved */
-    TEST_ASSERT(mbedtls_mock_tcp_recv_msg(&server_context, received, MSGLEN)
+    TEST_ASSERT(mbedtls_test_mock_tcp_recv_msg(&server_context, received, MSGLEN)
                 == MSGLEN);
 
     TEST_ASSERT(memcmp(message, received, MSGLEN) == 0);
 
 exit:
-    mbedtls_message_socket_close(&server_context);
-    mbedtls_message_socket_close(&client_context);
+    mbedtls_test_message_socket_close(&server_context);
+    mbedtls_test_message_socket_close(&client_context);
 }
 /* END_CASE */
 
@@ -2794,51 +2794,51 @@
     unsigned i;
     mbedtls_test_ssl_message_queue server_queue, client_queue;
     mbedtls_test_message_socket_context server_context, client_context;
-    mbedtls_message_socket_init(&server_context);
-    mbedtls_message_socket_init(&client_context);
+    mbedtls_test_message_socket_init(&server_context);
+    mbedtls_test_message_socket_init(&client_context);
 
-    TEST_ASSERT(mbedtls_message_socket_setup(&server_queue, &client_queue, 3,
-                                             &server,
-                                             &server_context) == 0);
+    TEST_ASSERT(mbedtls_test_message_socket_setup(&server_queue, &client_queue, 3,
+                                                  &server,
+                                                  &server_context) == 0);
 
-    TEST_ASSERT(mbedtls_message_socket_setup(&client_queue, &server_queue, 3,
-                                             &client,
-                                             &client_context) == 0);
+    TEST_ASSERT(mbedtls_test_message_socket_setup(&client_queue, &server_queue, 3,
+                                                  &client,
+                                                  &client_context) == 0);
 
     /* Fill up the buffer with structured data so that unwanted changes
      * can be detected */
     for (i = 0; i < MSGLEN; i++) {
         message[i] = i & 0xFF;
     }
-    TEST_ASSERT(0 == mbedtls_mock_socket_connect(&client, &server,
-                                                 MSGLEN*3));
+    TEST_ASSERT(0 == mbedtls_test_mock_socket_connect(&client, &server,
+                                                      MSGLEN*3));
 
     /* Interleaved test - [2 sends, 1 read] twice, and then two reads
      * (to wrap around the buffer) */
     for (i = 0; i < 2; i++) {
-        TEST_ASSERT(mbedtls_mock_tcp_send_msg(&client_context, message,
-                                              MSGLEN) == MSGLEN);
+        TEST_ASSERT(mbedtls_test_mock_tcp_send_msg(&client_context, message,
+                                                   MSGLEN) == MSGLEN);
 
-        TEST_ASSERT(mbedtls_mock_tcp_send_msg(&client_context, message,
-                                              MSGLEN) == MSGLEN);
+        TEST_ASSERT(mbedtls_test_mock_tcp_send_msg(&client_context, message,
+                                                   MSGLEN) == MSGLEN);
 
-        TEST_ASSERT(mbedtls_mock_tcp_recv_msg(&server_context, received,
-                                              MSGLEN) == MSGLEN);
+        TEST_ASSERT(mbedtls_test_mock_tcp_recv_msg(&server_context, received,
+                                                   MSGLEN) == MSGLEN);
         TEST_ASSERT(memcmp(message, received, MSGLEN) == 0);
         memset(received, 0, sizeof(received));
     }
 
     for (i = 0; i < 2; i++) {
-        TEST_ASSERT(mbedtls_mock_tcp_recv_msg(&server_context, received,
-                                              MSGLEN) == MSGLEN);
+        TEST_ASSERT(mbedtls_test_mock_tcp_recv_msg(&server_context, received,
+                                                   MSGLEN) == MSGLEN);
 
         TEST_ASSERT(memcmp(message, received, MSGLEN) == 0);
     }
-    TEST_ASSERT(mbedtls_mock_tcp_recv_msg(&server_context, received, MSGLEN)
+    TEST_ASSERT(mbedtls_test_mock_tcp_recv_msg(&server_context, received, MSGLEN)
                 == MBEDTLS_ERR_SSL_WANT_READ);
 exit:
-    mbedtls_message_socket_close(&server_context);
-    mbedtls_message_socket_close(&client_context);
+    mbedtls_test_message_socket_close(&server_context);
+    mbedtls_test_message_socket_close(&client_context);
 }
 /* END_CASE */
 
@@ -2851,49 +2851,49 @@
     unsigned i;
     mbedtls_test_ssl_message_queue server_queue, client_queue;
     mbedtls_test_message_socket_context server_context, client_context;
-    mbedtls_message_socket_init(&server_context);
-    mbedtls_message_socket_init(&client_context);
+    mbedtls_test_message_socket_init(&server_context);
+    mbedtls_test_message_socket_init(&client_context);
 
-    TEST_ASSERT(mbedtls_message_socket_setup(&server_queue, &client_queue, 3,
-                                             &server,
-                                             &server_context) == 0);
+    TEST_ASSERT(mbedtls_test_message_socket_setup(&server_queue, &client_queue, 3,
+                                                  &server,
+                                                  &server_context) == 0);
 
-    TEST_ASSERT(mbedtls_message_socket_setup(&client_queue, &server_queue, 3,
-                                             &client,
-                                             &client_context) == 0);
+    TEST_ASSERT(mbedtls_test_message_socket_setup(&client_queue, &server_queue, 3,
+                                                  &client,
+                                                  &client_context) == 0);
 
     /* Fill up the buffer with structured data so that unwanted changes
      * can be detected */
     for (i = 0; i < MSGLEN; i++) {
         message[i] = i & 0xFF;
     }
-    TEST_ASSERT(0 == mbedtls_mock_socket_connect(&client, &server,
-                                                 MSGLEN*3));
+    TEST_ASSERT(0 == mbedtls_test_mock_socket_connect(&client, &server,
+                                                      MSGLEN*3));
 
     /* Interleaved test - [2 sends, 1 read] twice, both ways, and then two reads
      * (to wrap around the buffer) both ways. */
     for (i = 0; i < 2; i++) {
-        TEST_ASSERT(mbedtls_mock_tcp_send_msg(&client_context, message,
-                                              MSGLEN) == MSGLEN);
+        TEST_ASSERT(mbedtls_test_mock_tcp_send_msg(&client_context, message,
+                                                   MSGLEN) == MSGLEN);
 
-        TEST_ASSERT(mbedtls_mock_tcp_send_msg(&client_context, message,
-                                              MSGLEN) == MSGLEN);
+        TEST_ASSERT(mbedtls_test_mock_tcp_send_msg(&client_context, message,
+                                                   MSGLEN) == MSGLEN);
 
-        TEST_ASSERT(mbedtls_mock_tcp_send_msg(&server_context, message,
-                                              MSGLEN) == MSGLEN);
+        TEST_ASSERT(mbedtls_test_mock_tcp_send_msg(&server_context, message,
+                                                   MSGLEN) == MSGLEN);
 
-        TEST_ASSERT(mbedtls_mock_tcp_send_msg(&server_context, message,
-                                              MSGLEN) == MSGLEN);
+        TEST_ASSERT(mbedtls_test_mock_tcp_send_msg(&server_context, message,
+                                                   MSGLEN) == MSGLEN);
 
-        TEST_ASSERT(mbedtls_mock_tcp_recv_msg(&server_context, received,
-                                              MSGLEN) == MSGLEN);
+        TEST_ASSERT(mbedtls_test_mock_tcp_recv_msg(&server_context, received,
+                                                   MSGLEN) == MSGLEN);
 
         TEST_ASSERT(memcmp(message, received, MSGLEN) == 0);
 
         memset(received, 0, sizeof(received));
 
-        TEST_ASSERT(mbedtls_mock_tcp_recv_msg(&client_context, received,
-                                              MSGLEN) == MSGLEN);
+        TEST_ASSERT(mbedtls_test_mock_tcp_recv_msg(&client_context, received,
+                                                   MSGLEN) == MSGLEN);
 
         TEST_ASSERT(memcmp(message, received, MSGLEN) == 0);
 
@@ -2901,27 +2901,27 @@
     }
 
     for (i = 0; i < 2; i++) {
-        TEST_ASSERT(mbedtls_mock_tcp_recv_msg(&server_context, received,
-                                              MSGLEN) == MSGLEN);
+        TEST_ASSERT(mbedtls_test_mock_tcp_recv_msg(&server_context, received,
+                                                   MSGLEN) == MSGLEN);
 
         TEST_ASSERT(memcmp(message, received, MSGLEN) == 0);
         memset(received, 0, sizeof(received));
 
-        TEST_ASSERT(mbedtls_mock_tcp_recv_msg(&client_context, received,
-                                              MSGLEN) == MSGLEN);
+        TEST_ASSERT(mbedtls_test_mock_tcp_recv_msg(&client_context, received,
+                                                   MSGLEN) == MSGLEN);
 
         TEST_ASSERT(memcmp(message, received, MSGLEN) == 0);
         memset(received, 0, sizeof(received));
     }
 
-    TEST_ASSERT(mbedtls_mock_tcp_recv_msg(&server_context, received, MSGLEN)
+    TEST_ASSERT(mbedtls_test_mock_tcp_recv_msg(&server_context, received, MSGLEN)
                 == MBEDTLS_ERR_SSL_WANT_READ);
 
-    TEST_ASSERT(mbedtls_mock_tcp_recv_msg(&client_context, received, MSGLEN)
+    TEST_ASSERT(mbedtls_test_mock_tcp_recv_msg(&client_context, received, MSGLEN)
                 == MBEDTLS_ERR_SSL_WANT_READ);
 exit:
-    mbedtls_message_socket_close(&server_context);
-    mbedtls_message_socket_close(&client_context);
+    mbedtls_test_message_socket_close(&server_context);
+    mbedtls_test_message_socket_close(&client_context);
 }
 /* END_CASE */
 
@@ -2992,10 +2992,10 @@
     mbedtls_ssl_init(&ssl);
     mbedtls_ssl_transform_init(&t0);
     mbedtls_ssl_transform_init(&t1);
-    TEST_ASSERT(build_transforms(&t0, &t1, cipher_type, hash_id,
-                                 etm, tag_mode, ver,
-                                 (size_t) cid0_len,
-                                 (size_t) cid1_len) == 0);
+    TEST_ASSERT(mbedtls_test_ssl_build_transforms(&t0, &t1, cipher_type, hash_id,
+                                                  etm, tag_mode, ver,
+                                                  (size_t) cid0_len,
+                                                  (size_t) cid1_len) == 0);
 
     TEST_ASSERT((buf = mbedtls_calloc(1, buflen)) != NULL);
 
@@ -3141,10 +3141,10 @@
     mbedtls_ssl_init(&ssl);
     mbedtls_ssl_transform_init(&t0);
     mbedtls_ssl_transform_init(&t1);
-    TEST_ASSERT(build_transforms(&t0, &t1, cipher_type, hash_id,
-                                 etm, tag_mode, ver,
-                                 (size_t) cid0_len,
-                                 (size_t) cid1_len) == 0);
+    TEST_ASSERT(mbedtls_test_ssl_build_transforms(&t0, &t1, cipher_type, hash_id,
+                                                  etm, tag_mode, ver,
+                                                  (size_t) cid0_len,
+                                                  (size_t) cid1_len) == 0);
 
     TEST_ASSERT((buf = mbedtls_calloc(1, buflen)) != NULL);
 
@@ -3293,10 +3293,10 @@
     mbedtls_ssl_transform_init(&t1);
 
     /* Set up transforms with dummy keys */
-    TEST_ASSERT(build_transforms(&t0, &t1, cipher_type, hash_id,
-                                 0, trunc_hmac,
-                                 MBEDTLS_SSL_MINOR_VERSION_3,
-                                 0, 0) == 0);
+    TEST_ASSERT(mbedtls_test_ssl_build_transforms(&t0, &t1, cipher_type, hash_id,
+                                                  0, trunc_hmac,
+                                                  MBEDTLS_SSL_MINOR_VERSION_3,
+                                                  0, 0) == 0);
 
     /* Determine padding/plaintext length */
     TEST_ASSERT(length_selector >= -2 && length_selector <= 255);
@@ -3651,7 +3651,7 @@
     mbedtls_ssl_session_init(&restored);
 
     /* Prepare a dummy session to work on */
-    TEST_ASSERT(ssl_populate_session(&original, ticket_len, crt_file) == 0);
+    TEST_ASSERT(mbedtls_test_ssl_populate_session(&original, ticket_len, crt_file) == 0);
 
     /* Serialize it */
     TEST_ASSERT(mbedtls_ssl_session_save(&original, NULL, 0, &len)
@@ -3749,7 +3749,7 @@
     mbedtls_ssl_session_init(&session);
 
     /* Prepare a dummy session to work on */
-    TEST_ASSERT(ssl_populate_session(&session, ticket_len, crt_file) == 0);
+    TEST_ASSERT(mbedtls_test_ssl_populate_session(&session, ticket_len, crt_file) == 0);
 
     /* Get desired buffer size for serializing */
     TEST_ASSERT(mbedtls_ssl_session_save(&session, NULL, 0, &len0)
@@ -3799,7 +3799,7 @@
     mbedtls_ssl_session_init(&session);
 
     /* Prepare dummy session and get serialized size */
-    TEST_ASSERT(ssl_populate_session(&session, ticket_len, crt_file) == 0);
+    TEST_ASSERT(mbedtls_test_ssl_populate_session(&session, ticket_len, crt_file) == 0);
     TEST_ASSERT(mbedtls_ssl_session_save(&session, NULL, 0, &good_len)
                 == MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL);
 
@@ -3834,7 +3834,7 @@
     mbedtls_ssl_session_init(&session);
 
     /* Prepare serialized session data */
-    TEST_ASSERT(ssl_populate_session(&session, ticket_len, crt_file) == 0);
+    TEST_ASSERT(mbedtls_test_ssl_populate_session(&session, ticket_len, crt_file) == 0);
     TEST_ASSERT(mbedtls_ssl_session_save(&session, NULL, 0, &good_len)
                 == MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL);
     TEST_ASSERT((good_buf = mbedtls_calloc(1, good_len)) != NULL);
@@ -3930,19 +3930,19 @@
     mbedtls_test_ssl_endpoint ep;
     int ret = -1;
 
-    ret = mbedtls_endpoint_init(NULL, endpoint_type, MBEDTLS_PK_RSA,
-                                NULL, NULL, NULL, NULL);
+    ret = mbedtls_test_ssl_endpoint_init(NULL, endpoint_type, MBEDTLS_PK_RSA,
+                                         NULL, NULL, NULL, NULL);
     TEST_ASSERT(MBEDTLS_ERR_SSL_BAD_INPUT_DATA == ret);
 
-    ret = mbedtls_endpoint_certificate_init(NULL, MBEDTLS_PK_RSA);
+    ret = mbedtls_test_ssl_endpoint_certificate_init(NULL, MBEDTLS_PK_RSA);
     TEST_ASSERT(MBEDTLS_ERR_SSL_BAD_INPUT_DATA == ret);
 
-    ret = mbedtls_endpoint_init(&ep, endpoint_type, MBEDTLS_PK_RSA,
-                                NULL, NULL, NULL, NULL);
+    ret = mbedtls_test_ssl_endpoint_init(&ep, endpoint_type, MBEDTLS_PK_RSA,
+                                         NULL, NULL, NULL, NULL);
     TEST_ASSERT(ret == 0);
 
 exit:
-    mbedtls_endpoint_free(&ep, NULL);
+    mbedtls_test_ssl_endpoint_free(&ep, NULL);
 }
 /* END_CASE */
 
@@ -3956,24 +3956,24 @@
     mbedtls_platform_zeroize(&base_ep, sizeof(base_ep));
     mbedtls_platform_zeroize(&second_ep, sizeof(second_ep));
 
-    ret = mbedtls_endpoint_init(&base_ep, endpoint_type, MBEDTLS_PK_RSA,
-                                NULL, NULL, NULL, NULL);
+    ret = mbedtls_test_ssl_endpoint_init(&base_ep, endpoint_type, MBEDTLS_PK_RSA,
+                                         NULL, NULL, NULL, NULL);
     TEST_ASSERT(ret == 0);
 
-    ret = mbedtls_endpoint_init(&second_ep,
-                                (endpoint_type == MBEDTLS_SSL_IS_SERVER) ?
-                                MBEDTLS_SSL_IS_CLIENT : MBEDTLS_SSL_IS_SERVER,
-                                MBEDTLS_PK_RSA, NULL, NULL, NULL, NULL);
+    ret = mbedtls_test_ssl_endpoint_init(&second_ep,
+                                         (endpoint_type == MBEDTLS_SSL_IS_SERVER) ?
+                                         MBEDTLS_SSL_IS_CLIENT : MBEDTLS_SSL_IS_SERVER,
+                                         MBEDTLS_PK_RSA, NULL, NULL, NULL, NULL);
     TEST_ASSERT(ret == 0);
 
-    ret = mbedtls_mock_socket_connect(&(base_ep.socket),
-                                      &(second_ep.socket),
-                                      BUFFSIZE);
+    ret = mbedtls_test_mock_socket_connect(&(base_ep.socket),
+                                           &(second_ep.socket),
+                                           BUFFSIZE);
     TEST_ASSERT(ret == 0);
 
-    ret = mbedtls_move_handshake_to_state(&(base_ep.ssl),
-                                          &(second_ep.ssl),
-                                          state);
+    ret = mbedtls_test_move_handshake_to_state(&(base_ep.ssl),
+                                               &(second_ep.ssl),
+                                               state);
     if (need_pass) {
         TEST_ASSERT(ret == 0);
         TEST_ASSERT(base_ep.ssl.state == state);
@@ -3983,8 +3983,8 @@
     }
 
 exit:
-    mbedtls_endpoint_free(&base_ep, NULL);
-    mbedtls_endpoint_free(&second_ep, NULL);
+    mbedtls_test_ssl_endpoint_free(&base_ep, NULL);
+    mbedtls_test_ssl_endpoint_free(&second_ep, NULL);
 }
 /* END_CASE */
 
@@ -3994,7 +3994,7 @@
                        int expected_negotiated_version)
 {
     mbedtls_test_handshake_test_options options;
-    init_handshake_options(&options);
+    mbedtls_test_init_handshake_options(&options);
 
     options.client_min_version = client_min_version;
     options.client_max_version = client_max_version;
@@ -4011,7 +4011,7 @@
         options.expected_cli_fragments = 2;
         options.expected_srv_fragments = 2;
     }
-    perform_handshake(&options);
+    mbedtls_test_ssl_perform_handshake(&options);
 
     /* The goto below is used to avoid an "unused label" warning.*/
     goto exit;
@@ -4022,14 +4022,14 @@
 void handshake_psk_cipher(char *cipher, int pk_alg, data_t *psk_str, int dtls)
 {
     mbedtls_test_handshake_test_options options;
-    init_handshake_options(&options);
+    mbedtls_test_init_handshake_options(&options);
 
     options.cipher = cipher;
     options.dtls = dtls;
     options.psk_str = psk_str;
     options.pk_alg = pk_alg;
 
-    perform_handshake(&options);
+    mbedtls_test_ssl_perform_handshake(&options);
 
     /* The goto below is used to avoid an "unused label" warning.*/
     goto exit;
@@ -4052,7 +4052,7 @@
               int expected_srv_fragments, int dtls)
 {
     mbedtls_test_handshake_test_options options;
-    init_handshake_options(&options);
+    mbedtls_test_init_handshake_options(&options);
 
     options.mfl = mfl;
     options.cli_msg_len = cli_msg_len;
@@ -4061,7 +4061,7 @@
     options.expected_srv_fragments = expected_srv_fragments;
     options.dtls = dtls;
 
-    perform_handshake(&options);
+    mbedtls_test_ssl_perform_handshake(&options);
     /* The goto below is used to avoid an "unused label" warning.*/
     goto exit;
 }
@@ -4095,11 +4095,11 @@
 void handshake_serialization()
 {
     mbedtls_test_handshake_test_options options;
-    init_handshake_options(&options);
+    mbedtls_test_init_handshake_options(&options);
 
     options.serialize = 1;
     options.dtls = 1;
-    perform_handshake(&options);
+    mbedtls_test_ssl_perform_handshake(&options);
     /* The goto below is used to avoid an "unused label" warning.*/
     goto exit;
 }
@@ -4117,7 +4117,7 @@
     srv_pattern.counter = 0;
     cli_pattern.counter = 0;
 
-    init_handshake_options(&options);
+    mbedtls_test_init_handshake_options(&options);
     options.dtls = 1;
     options.mfl = mfl;
     /* Set cipher to one using CBC so that record splitting can be tested */
@@ -4125,10 +4125,10 @@
     options.srv_auth_mode = MBEDTLS_SSL_VERIFY_REQUIRED;
     options.srv_log_obj = &srv_pattern;
     options.cli_log_obj = &cli_pattern;
-    options.srv_log_fun = log_analyzer;
-    options.cli_log_fun = log_analyzer;
+    options.srv_log_fun = mbedtls_test_ssl_log_analyzer;
+    options.cli_log_fun = mbedtls_test_ssl_log_analyzer;
 
-    perform_handshake(&options);
+    mbedtls_test_ssl_perform_handshake(&options);
 
     /* Test if the server received a fragmented handshake */
     if (expected_srv_hs_fragmentation) {
@@ -4145,13 +4145,13 @@
 void renegotiation(int legacy_renegotiation)
 {
     mbedtls_test_handshake_test_options options;
-    init_handshake_options(&options);
+    mbedtls_test_init_handshake_options(&options);
 
     options.renegotiate = 1;
     options.legacy_renegotiation = legacy_renegotiation;
     options.dtls = 1;
 
-    perform_handshake(&options);
+    mbedtls_test_ssl_perform_handshake(&options);
     /* The goto below is used to avoid an "unused label" warning.*/
     goto exit;
 }
@@ -4162,7 +4162,7 @@
                     int serialize, int dtls, char *cipher)
 {
     mbedtls_test_handshake_test_options options;
-    init_handshake_options(&options);
+    mbedtls_test_init_handshake_options(&options);
 
     options.mfl = mfl;
     options.cipher = cipher;
@@ -4172,7 +4172,7 @@
     options.dtls = dtls;
     options.resize_buffers = 1;
 
-    perform_handshake(&options);
+    mbedtls_test_ssl_perform_handshake(&options);
     /* The goto below is used to avoid an "unused label" warning.*/
     goto exit;
 }
@@ -4217,22 +4217,22 @@
     /* Client side, force SECP256R1 to make one key bitflip fail
      * the raw key agreement. Flipping the first byte makes the
      * required 0x04 identifier invalid. */
-    TEST_EQUAL(mbedtls_endpoint_init(&client, MBEDTLS_SSL_IS_CLIENT,
-                                     MBEDTLS_PK_ECDSA, NULL, NULL,
-                                     NULL, curve_list), 0);
+    TEST_EQUAL(mbedtls_test_ssl_endpoint_init(&client, MBEDTLS_SSL_IS_CLIENT,
+                                              MBEDTLS_PK_ECDSA, NULL, NULL,
+                                              NULL, curve_list), 0);
 
     /* Server side */
-    TEST_EQUAL(mbedtls_endpoint_init(&server, MBEDTLS_SSL_IS_SERVER,
-                                     MBEDTLS_PK_ECDSA, NULL, NULL,
-                                     NULL, NULL), 0);
+    TEST_EQUAL(mbedtls_test_ssl_endpoint_init(&server, MBEDTLS_SSL_IS_SERVER,
+                                              MBEDTLS_PK_ECDSA, NULL, NULL,
+                                              NULL, NULL), 0);
 
-    TEST_EQUAL(mbedtls_mock_socket_connect(&(client.socket),
-                                           &(server.socket),
-                                           BUFFSIZE), 0);
+    TEST_EQUAL(mbedtls_test_mock_socket_connect(&(client.socket),
+                                                &(server.socket),
+                                                BUFFSIZE), 0);
 
-    TEST_EQUAL(mbedtls_move_handshake_to_state(&(client.ssl),
-                                               &(server.ssl),
-                                               MBEDTLS_SSL_CLIENT_KEY_EXCHANGE)
+    TEST_EQUAL(mbedtls_test_move_handshake_to_state(&(client.ssl),
+                                                    &(server.ssl),
+                                                    MBEDTLS_SSL_CLIENT_KEY_EXCHANGE)
                , 0);
 
     mbedtls_psa_get_stats(&stats);
@@ -4246,9 +4246,9 @@
         (client.ssl).handshake->ecdh_psa_peerkey[0] ^= 0x02;
     }
 
-    TEST_EQUAL(mbedtls_move_handshake_to_state(&(client.ssl),
-                                               &(server.ssl),
-                                               MBEDTLS_SSL_HANDSHAKE_OVER),
+    TEST_EQUAL(mbedtls_test_move_handshake_to_state(&(client.ssl),
+                                                    &(server.ssl),
+                                                    MBEDTLS_SSL_HANDSHAKE_OVER),
                bad_server_ecdhe_key ? MBEDTLS_ERR_SSL_HW_ACCEL_FAILED : 0);
 
     mbedtls_psa_get_stats(&stats);
@@ -4260,8 +4260,8 @@
     }
 
 exit:
-    mbedtls_endpoint_free(&client, NULL);
-    mbedtls_endpoint_free(&server, NULL);
+    mbedtls_test_ssl_endpoint_free(&client, NULL);
+    mbedtls_test_ssl_endpoint_free(&server, NULL);
 
     USE_PSA_DONE();
 }