diff --git a/tests/suites/test_suite_mps.function b/tests/suites/test_suite_mps.function
index 3c84163..2bf787a 100644
--- a/tests/suites/test_suite_mps.function
+++ b/tests/suites/test_suite_mps.function
@@ -40,24 +40,24 @@
     unsigned char bufA[100];
     unsigned char acc[10];
     unsigned char *tmp;
-    mbedtls_reader rd;
+    mbedtls_mps_reader rd;
     for( int i=0; (unsigned) i < sizeof( bufA ); i++ )
         bufA[i] = (unsigned char) i;
 
     /* Preparation (lower layer) */
     if( with_acc == 0 )
-        mbedtls_reader_init( &rd, NULL, 0 );
+        mbedtls_mps_reader_init( &rd, NULL, 0 );
     else
-        mbedtls_reader_init( &rd, acc, sizeof( acc ) );
-    TEST_ASSERT( mbedtls_reader_feed( &rd, bufA, sizeof( bufA ) ) == 0 );
+        mbedtls_mps_reader_init( &rd, acc, sizeof( acc ) );
+    TEST_ASSERT( mbedtls_mps_reader_feed( &rd, bufA, sizeof( bufA ) ) == 0 );
     /* Consumption (upper layer) */
     /* Consume exactly what's available */
-    TEST_ASSERT( mbedtls_reader_get( &rd, 100, &tmp, NULL ) == 0 );
+    TEST_ASSERT( mbedtls_mps_reader_get( &rd, 100, &tmp, NULL ) == 0 );
     ASSERT_COMPARE( tmp, 100, bufA, 100 );
-    TEST_ASSERT( mbedtls_reader_commit( &rd ) == 0 );
+    TEST_ASSERT( mbedtls_mps_reader_commit( &rd ) == 0 );
     /* Wrapup (lower layer) */
-    TEST_ASSERT( mbedtls_reader_reclaim( &rd, NULL ) == 0 );
-    mbedtls_reader_free( &rd );
+    TEST_ASSERT( mbedtls_mps_reader_reclaim( &rd, NULL ) == 0 );
+    mbedtls_mps_reader_free( &rd );
 }
 /* END_CASE */
 
@@ -82,7 +82,7 @@
     unsigned char bufA[100], bufB[100];
     unsigned char acc[10];
     unsigned char *tmp;
-    mbedtls_reader rd;
+    mbedtls_mps_reader rd;
     for( int i=0; (unsigned) i < sizeof( bufA ); i++ )
         bufA[i] = (unsigned char) i;
     for( int i=0; (unsigned) i < sizeof( bufB ); i++ )
@@ -90,25 +90,25 @@
 
     /* Preparation (lower layer) */
     if( with_acc == 0 )
-        mbedtls_reader_init( &rd, NULL, 0 );
+        mbedtls_mps_reader_init( &rd, NULL, 0 );
     else
-        mbedtls_reader_init( &rd, acc, sizeof( acc ) );
-    TEST_ASSERT( mbedtls_reader_feed( &rd, bufA, sizeof( bufA ) ) == 0 );
+        mbedtls_mps_reader_init( &rd, acc, sizeof( acc ) );
+    TEST_ASSERT( mbedtls_mps_reader_feed( &rd, bufA, sizeof( bufA ) ) == 0 );
     /* Consumption (upper layer) */
     /* Consume exactly what's available */
-    TEST_ASSERT( mbedtls_reader_get( &rd, 100, &tmp, NULL ) == 0 );
+    TEST_ASSERT( mbedtls_mps_reader_get( &rd, 100, &tmp, NULL ) == 0 );
     ASSERT_COMPARE( tmp, 100, bufA, 100 );
-    TEST_ASSERT( mbedtls_reader_commit( &rd ) == 0 );
+    TEST_ASSERT( mbedtls_mps_reader_commit( &rd ) == 0 );
     /* Preparation */
-    TEST_ASSERT( mbedtls_reader_reclaim( &rd, NULL ) == 0 );
-    TEST_ASSERT( mbedtls_reader_feed( &rd, bufB, sizeof( bufB ) ) == 0 );
+    TEST_ASSERT( mbedtls_mps_reader_reclaim( &rd, NULL ) == 0 );
+    TEST_ASSERT( mbedtls_mps_reader_feed( &rd, bufB, sizeof( bufB ) ) == 0 );
     /* Consumption */
-    TEST_ASSERT( mbedtls_reader_get( &rd, 100, &tmp, NULL ) == 0 );
+    TEST_ASSERT( mbedtls_mps_reader_get( &rd, 100, &tmp, NULL ) == 0 );
     ASSERT_COMPARE( tmp, 100, bufB, 100 );
-    TEST_ASSERT( mbedtls_reader_commit( &rd ) == 0 );
+    TEST_ASSERT( mbedtls_mps_reader_commit( &rd ) == 0 );
     /* Wrapup (lower layer) */
-    TEST_ASSERT( mbedtls_reader_reclaim( &rd, NULL ) == 0 );
-    mbedtls_reader_free( &rd );
+    TEST_ASSERT( mbedtls_mps_reader_reclaim( &rd, NULL ) == 0 );
+    mbedtls_mps_reader_free( &rd );
 }
 /* END_CASE */
 
@@ -118,7 +118,7 @@
     /* This test exercises one round of the following:
      * - The 'producing' layer provides a buffer
      * - The 'consuming' layer fetches it in multiple calls
-     *   to `mbedtls_reader_get()`, without comitting in between.
+     *   to `mbedtls_mps_reader_get()`, without comitting in between.
      * - After processing, the consuming layer commit the data
      *   and returns back to the producing layer.
      *
@@ -137,27 +137,27 @@
     unsigned char acc[10];
     unsigned char *tmp;
     mbedtls_mps_size_t tmp_len;
-    mbedtls_reader rd;
+    mbedtls_mps_reader rd;
     for( int i=0; (unsigned) i < sizeof( buf ); i++ )
         buf[i] = (unsigned char) i;
 
     /* Preparation (lower layer) */
     if( with_acc == 0 )
-        mbedtls_reader_init( &rd, NULL, 0 );
+        mbedtls_mps_reader_init( &rd, NULL, 0 );
     else
-        mbedtls_reader_init( &rd, acc, sizeof( acc ) );
-    TEST_ASSERT( mbedtls_reader_feed( &rd, buf, sizeof( buf ) ) == 0 );
+        mbedtls_mps_reader_init( &rd, acc, sizeof( acc ) );
+    TEST_ASSERT( mbedtls_mps_reader_feed( &rd, buf, sizeof( buf ) ) == 0 );
     /* Consumption (upper layer) */
-    TEST_ASSERT( mbedtls_reader_get( &rd, 10, &tmp, NULL ) == 0 );
+    TEST_ASSERT( mbedtls_mps_reader_get( &rd, 10, &tmp, NULL ) == 0 );
     ASSERT_COMPARE( tmp, 10, buf, 10 );
-    TEST_ASSERT( mbedtls_reader_get( &rd, 70, &tmp, NULL ) == 0 );
+    TEST_ASSERT( mbedtls_mps_reader_get( &rd, 70, &tmp, NULL ) == 0 );
     ASSERT_COMPARE( tmp, 70, buf + 10, 70 );
-    TEST_ASSERT( mbedtls_reader_get( &rd, 30, &tmp, &tmp_len ) == 0 );
+    TEST_ASSERT( mbedtls_mps_reader_get( &rd, 30, &tmp, &tmp_len ) == 0 );
     ASSERT_COMPARE( tmp, tmp_len, buf + 80, 20 );
-    TEST_ASSERT( mbedtls_reader_commit( &rd ) == 0 );
+    TEST_ASSERT( mbedtls_mps_reader_commit( &rd ) == 0 );
     /* Wrapup (lower layer) */
-    TEST_ASSERT( mbedtls_reader_reclaim( &rd, NULL ) == 0 );
-    mbedtls_reader_free( &rd );
+    TEST_ASSERT( mbedtls_mps_reader_reclaim( &rd, NULL ) == 0 );
+    mbedtls_mps_reader_free( &rd );
 }
 /* END_CASE */
 
@@ -172,7 +172,7 @@
     unsigned char acc[10];
     unsigned char *tmp;
     mbedtls_mps_size_t tmp_len;
-    mbedtls_reader rd;
+    mbedtls_mps_reader rd;
     for( int i=0; (unsigned) i < sizeof( bufA ); i++ )
         bufA[i] = (unsigned char) i;
     for( int i=0; (unsigned) i < sizeof( bufB ); i++ )
@@ -180,28 +180,28 @@
 
     /* Preparation (lower layer) */
     if( with_acc == 0 )
-        mbedtls_reader_init( &rd, NULL, 0 );
+        mbedtls_mps_reader_init( &rd, NULL, 0 );
     else
-        mbedtls_reader_init( &rd, acc, sizeof( acc ) );
-    TEST_ASSERT( mbedtls_reader_feed( &rd, bufA, sizeof( bufA ) ) == 0 );
+        mbedtls_mps_reader_init( &rd, acc, sizeof( acc ) );
+    TEST_ASSERT( mbedtls_mps_reader_feed( &rd, bufA, sizeof( bufA ) ) == 0 );
     /* Consumption (upper layer) */
-    TEST_ASSERT( mbedtls_reader_get( &rd, 10, &tmp, NULL ) == 0 );
+    TEST_ASSERT( mbedtls_mps_reader_get( &rd, 10, &tmp, NULL ) == 0 );
     ASSERT_COMPARE( tmp, 10, bufA, 10 );
-    TEST_ASSERT( mbedtls_reader_get( &rd, 70, &tmp, NULL ) == 0 );
+    TEST_ASSERT( mbedtls_mps_reader_get( &rd, 70, &tmp, NULL ) == 0 );
     ASSERT_COMPARE( tmp, 70, bufA + 10, 70 );
-    TEST_ASSERT( mbedtls_reader_get( &rd, 30, &tmp, &tmp_len ) == 0 );
+    TEST_ASSERT( mbedtls_mps_reader_get( &rd, 30, &tmp, &tmp_len ) == 0 );
     ASSERT_COMPARE( tmp, tmp_len, bufA + 80, 20 );
-    TEST_ASSERT( mbedtls_reader_commit( &rd ) == 0 );
+    TEST_ASSERT( mbedtls_mps_reader_commit( &rd ) == 0 );
     /* Preparation */
-    TEST_ASSERT( mbedtls_reader_reclaim( &rd, NULL ) == 0 );
-    TEST_ASSERT( mbedtls_reader_feed( &rd, bufB, sizeof( bufB ) ) == 0 );
+    TEST_ASSERT( mbedtls_mps_reader_reclaim( &rd, NULL ) == 0 );
+    TEST_ASSERT( mbedtls_mps_reader_feed( &rd, bufB, sizeof( bufB ) ) == 0 );
     /* Consumption */
-    TEST_ASSERT( mbedtls_reader_get( &rd, 100, &tmp, NULL ) == 0 );
+    TEST_ASSERT( mbedtls_mps_reader_get( &rd, 100, &tmp, NULL ) == 0 );
     ASSERT_COMPARE( tmp, 100, bufB, 100 );
-    TEST_ASSERT( mbedtls_reader_commit( &rd ) == 0 );
+    TEST_ASSERT( mbedtls_mps_reader_commit( &rd ) == 0 );
     /* Wrapup */
-    TEST_ASSERT( mbedtls_reader_reclaim( &rd, NULL ) == 0 );
-    mbedtls_reader_free( &rd );
+    TEST_ASSERT( mbedtls_mps_reader_reclaim( &rd, NULL ) == 0 );
+    mbedtls_mps_reader_free( &rd );
 }
 /* END_CASE */
 
@@ -217,23 +217,23 @@
 
     unsigned char buf[100];
     unsigned char *tmp;
-    mbedtls_reader rd;
+    mbedtls_mps_reader rd;
     for( int i=0; (unsigned) i < sizeof( buf ); i++ )
         buf[i] = (unsigned char) i;
 
     /* Preparation (lower layer) */
-    mbedtls_reader_init( &rd, NULL, 0 );
-    TEST_ASSERT( mbedtls_reader_feed( &rd, buf, sizeof( buf ) ) == 0 );
+    mbedtls_mps_reader_init( &rd, NULL, 0 );
+    TEST_ASSERT( mbedtls_mps_reader_feed( &rd, buf, sizeof( buf ) ) == 0 );
     /* Consumption (upper layer) */
-    TEST_ASSERT( mbedtls_reader_get( &rd, 50, &tmp, NULL ) == 0 );
+    TEST_ASSERT( mbedtls_mps_reader_get( &rd, 50, &tmp, NULL ) == 0 );
     ASSERT_COMPARE( tmp, 50, buf, 50 );
-    TEST_ASSERT( mbedtls_reader_commit( &rd ) == 0 );
-    TEST_ASSERT( mbedtls_reader_get( &rd, 100, &tmp, NULL ) ==
+    TEST_ASSERT( mbedtls_mps_reader_commit( &rd ) == 0 );
+    TEST_ASSERT( mbedtls_mps_reader_get( &rd, 100, &tmp, NULL ) ==
                  MBEDTLS_ERR_MPS_READER_OUT_OF_DATA );
     /* Wrapup (lower layer) */
-    TEST_ASSERT( mbedtls_reader_reclaim( &rd, NULL ) ==
+    TEST_ASSERT( mbedtls_mps_reader_reclaim( &rd, NULL ) ==
                  MBEDTLS_ERR_MPS_READER_NEED_ACCUMULATOR );
-    mbedtls_reader_free( &rd );
+    mbedtls_mps_reader_free( &rd );
 }
 /* END_CASE */
 
@@ -250,23 +250,23 @@
     unsigned char buf[100];
     unsigned char acc[10];
     unsigned char *tmp;
-    mbedtls_reader rd;
+    mbedtls_mps_reader rd;
     for( int i=0; (unsigned) i < sizeof( buf ); i++ )
         buf[i] = (unsigned char) i;
 
     /* Preparation (lower layer) */
-    mbedtls_reader_init( &rd, acc, sizeof( acc ) );
-    TEST_ASSERT( mbedtls_reader_feed( &rd, buf, sizeof( buf ) ) == 0 );
+    mbedtls_mps_reader_init( &rd, acc, sizeof( acc ) );
+    TEST_ASSERT( mbedtls_mps_reader_feed( &rd, buf, sizeof( buf ) ) == 0 );
     /* Consumption (upper layer) */
-    TEST_ASSERT( mbedtls_reader_get( &rd, 50, &tmp, NULL ) == 0 );
+    TEST_ASSERT( mbedtls_mps_reader_get( &rd, 50, &tmp, NULL ) == 0 );
     ASSERT_COMPARE( tmp, 50, buf, 50 );
-    TEST_ASSERT( mbedtls_reader_commit( &rd ) == 0 );
-    TEST_ASSERT( mbedtls_reader_get( &rd, 100, &tmp, NULL ) ==
+    TEST_ASSERT( mbedtls_mps_reader_commit( &rd ) == 0 );
+    TEST_ASSERT( mbedtls_mps_reader_get( &rd, 100, &tmp, NULL ) ==
                  MBEDTLS_ERR_MPS_READER_OUT_OF_DATA );
     /* Wrapup (lower layer) */
-    TEST_ASSERT( mbedtls_reader_reclaim( &rd, NULL ) ==
+    TEST_ASSERT( mbedtls_mps_reader_reclaim( &rd, NULL ) ==
                  MBEDTLS_ERR_MPS_READER_ACCUMULATOR_TOO_SMALL );
-    mbedtls_reader_free( &rd );
+    mbedtls_mps_reader_free( &rd );
 }
 /* END_CASE */
 
@@ -293,89 +293,89 @@
     unsigned char bufA[100], bufB[100];
     unsigned char *tmp;
     unsigned char acc[40];
-    mbedtls_reader rd;
+    mbedtls_mps_reader rd;
     for( int i=0; (unsigned) i < sizeof( bufA ); i++ )
         bufA[i] = (unsigned char) i;
     for( int i=0; (unsigned) i < sizeof( bufB ); i++ )
         bufB[i] = ~ ((unsigned char) i);
 
     /* Preparation (lower layer) */
-    mbedtls_reader_init( &rd, acc, sizeof( acc ) );
-    TEST_ASSERT( mbedtls_reader_feed( &rd, bufA, sizeof( bufA ) ) == 0 );
+    mbedtls_mps_reader_init( &rd, acc, sizeof( acc ) );
+    TEST_ASSERT( mbedtls_mps_reader_feed( &rd, bufA, sizeof( bufA ) ) == 0 );
 
     /* Consumption (upper layer) */
     /* Ask for more than what's available. */
-    TEST_ASSERT( mbedtls_reader_get( &rd, 80, &tmp, NULL ) == 0 );
+    TEST_ASSERT( mbedtls_mps_reader_get( &rd, 80, &tmp, NULL ) == 0 );
     ASSERT_COMPARE( tmp, 80, bufA, 80 );
-    TEST_ASSERT( mbedtls_reader_commit( &rd ) == 0 );
-    TEST_ASSERT( mbedtls_reader_get( &rd, 10, &tmp, NULL ) == 0 );
+    TEST_ASSERT( mbedtls_mps_reader_commit( &rd ) == 0 );
+    TEST_ASSERT( mbedtls_mps_reader_get( &rd, 10, &tmp, NULL ) == 0 );
     ASSERT_COMPARE( tmp, 10, bufA + 80, 10 );
     switch( option )
     {
         case 0:  /* Single uncommitted fetch at pausing */
         case 1:
-            TEST_ASSERT( mbedtls_reader_commit( &rd ) == 0 );
+            TEST_ASSERT( mbedtls_mps_reader_commit( &rd ) == 0 );
             break;
         default: /* Multiple uncommitted fetches at pausing */
             break;
     }
-    TEST_ASSERT( mbedtls_reader_get( &rd, 20, &tmp, NULL ) ==
+    TEST_ASSERT( mbedtls_mps_reader_get( &rd, 20, &tmp, NULL ) ==
                  MBEDTLS_ERR_MPS_READER_OUT_OF_DATA );
 
     /* Preparation */
-    TEST_ASSERT( mbedtls_reader_reclaim( &rd, NULL ) == 0 );
-    TEST_ASSERT( mbedtls_reader_feed( &rd, bufB, sizeof( bufB ) ) == 0 );
+    TEST_ASSERT( mbedtls_mps_reader_reclaim( &rd, NULL ) == 0 );
+    TEST_ASSERT( mbedtls_mps_reader_feed( &rd, bufB, sizeof( bufB ) ) == 0 );
 
     /* Consumption */
     switch( option )
     {
         case 0: /* Single fetch at pausing, re-fetch with commit. */
-            TEST_ASSERT( mbedtls_reader_get( &rd, 20, &tmp, NULL ) == 0 );
+            TEST_ASSERT( mbedtls_mps_reader_get( &rd, 20, &tmp, NULL ) == 0 );
             ASSERT_COMPARE( tmp, 10, bufA + 90, 10 );
             ASSERT_COMPARE( tmp + 10, 10, bufB, 10 );
-            TEST_ASSERT( mbedtls_reader_commit( &rd ) == 0 );
+            TEST_ASSERT( mbedtls_mps_reader_commit( &rd ) == 0 );
             break;
 
         case 1: /* Single fetch at pausing, re-fetch without commit. */
-            TEST_ASSERT( mbedtls_reader_get( &rd, 20, &tmp, NULL ) == 0 );
+            TEST_ASSERT( mbedtls_mps_reader_get( &rd, 20, &tmp, NULL ) == 0 );
             ASSERT_COMPARE( tmp, 10, bufA + 90, 10 );
             ASSERT_COMPARE( tmp + 10, 10, bufB, 10 );
             break;
 
         case 2: /* Multiple fetches at pausing, repeat without commit. */
-            TEST_ASSERT( mbedtls_reader_get( &rd, 10, &tmp, NULL ) == 0 );
+            TEST_ASSERT( mbedtls_mps_reader_get( &rd, 10, &tmp, NULL ) == 0 );
             ASSERT_COMPARE( tmp, 10, bufA + 80, 10 );
-            TEST_ASSERT( mbedtls_reader_get( &rd, 20, &tmp, NULL ) == 0 );
+            TEST_ASSERT( mbedtls_mps_reader_get( &rd, 20, &tmp, NULL ) == 0 );
             ASSERT_COMPARE( tmp, 10, bufA + 90, 10 );
             ASSERT_COMPARE( tmp + 10, 10, bufB, 10 );
             break;
 
         case 3: /* Multiple fetches at pausing, repeat with commit 1. */
-            TEST_ASSERT( mbedtls_reader_get( &rd, 10, &tmp, NULL ) == 0 );
+            TEST_ASSERT( mbedtls_mps_reader_get( &rd, 10, &tmp, NULL ) == 0 );
             ASSERT_COMPARE( tmp, 10, bufA + 80, 10 );
-            TEST_ASSERT( mbedtls_reader_commit( &rd ) == 0 );
-            TEST_ASSERT( mbedtls_reader_get( &rd, 20, &tmp, NULL ) == 0 );
+            TEST_ASSERT( mbedtls_mps_reader_commit( &rd ) == 0 );
+            TEST_ASSERT( mbedtls_mps_reader_get( &rd, 20, &tmp, NULL ) == 0 );
             ASSERT_COMPARE( tmp, 10, bufA + 90, 10 );
             ASSERT_COMPARE( tmp + 10, 10, bufB, 10 );
             break;
 
         case 4: /* Multiple fetches at pausing, repeat with commit 2. */
-            TEST_ASSERT( mbedtls_reader_get( &rd, 10, &tmp, NULL ) == 0 );
+            TEST_ASSERT( mbedtls_mps_reader_get( &rd, 10, &tmp, NULL ) == 0 );
             ASSERT_COMPARE( tmp, 10, bufA + 80, 10 );
-            TEST_ASSERT( mbedtls_reader_get( &rd, 20, &tmp, NULL ) == 0 );
+            TEST_ASSERT( mbedtls_mps_reader_get( &rd, 20, &tmp, NULL ) == 0 );
             ASSERT_COMPARE( tmp, 10, bufA + 90, 10 );
             ASSERT_COMPARE( tmp + 10, 10, bufB, 10 );
-            TEST_ASSERT( mbedtls_reader_commit( &rd ) == 0 );
+            TEST_ASSERT( mbedtls_mps_reader_commit( &rd ) == 0 );
             break;
 
         case 5: /* Multiple fetches at pausing, repeat with commit 3. */
-            TEST_ASSERT( mbedtls_reader_get( &rd, 10, &tmp, NULL ) == 0 );
+            TEST_ASSERT( mbedtls_mps_reader_get( &rd, 10, &tmp, NULL ) == 0 );
             ASSERT_COMPARE( tmp, 10, bufA + 80, 10 );
-            TEST_ASSERT( mbedtls_reader_commit( &rd ) == 0 );
-            TEST_ASSERT( mbedtls_reader_get( &rd, 20, &tmp, NULL ) == 0 );
+            TEST_ASSERT( mbedtls_mps_reader_commit( &rd ) == 0 );
+            TEST_ASSERT( mbedtls_mps_reader_get( &rd, 20, &tmp, NULL ) == 0 );
             ASSERT_COMPARE( tmp, 10, bufA + 90, 10 );
             ASSERT_COMPARE( tmp + 10, 10, bufB, 10 );
-            TEST_ASSERT( mbedtls_reader_commit( &rd ) == 0 );
+            TEST_ASSERT( mbedtls_mps_reader_commit( &rd ) == 0 );
             break;
 
         default:
@@ -383,13 +383,13 @@
     }
 
     /* In all cases, fetch the rest of the second buffer. */
-    TEST_ASSERT( mbedtls_reader_get( &rd, 90, &tmp, NULL ) == 0 );
+    TEST_ASSERT( mbedtls_mps_reader_get( &rd, 90, &tmp, NULL ) == 0 );
     ASSERT_COMPARE( tmp, 90, bufB + 10, 90 );
-    TEST_ASSERT( mbedtls_reader_commit( &rd ) == 0 );
+    TEST_ASSERT( mbedtls_mps_reader_commit( &rd ) == 0 );
 
     /* Wrapup */
-    TEST_ASSERT( mbedtls_reader_reclaim( &rd, NULL ) == 0 );
-    mbedtls_reader_free( &rd );
+    TEST_ASSERT( mbedtls_mps_reader_reclaim( &rd, NULL ) == 0 );
+    mbedtls_mps_reader_free( &rd );
 }
 /* END_CASE */
 
@@ -400,8 +400,8 @@
      * in the following situation:
      * - The consumer has asked for mre than what's available, so the
      *   reader pauses and waits for further input data via
-     *   `mbedtls_reader_feed()`
-     * - Multiple such calls to `mbedtls_reader_feed()` are necessary
+     *   `mbedtls_mps_reader_feed()`
+     * - Multiple such calls to `mbedtls_mps_reader_feed()` are necessary
      *   to fulfill the original request, and the reader needs to do
      *   the necessary bookkeeping under the hood.
      *
@@ -413,7 +413,7 @@
     unsigned char bufA[100], bufB[100];
     unsigned char *tmp;
     unsigned char acc[70];
-    mbedtls_reader rd;
+    mbedtls_mps_reader rd;
     mbedtls_mps_size_t fetch_len;
     for( int i=0; (unsigned) i < sizeof( bufA ); i++ )
         bufA[i] = (unsigned char) i;
@@ -421,46 +421,46 @@
         bufB[i] = ~ ((unsigned char) i);
 
     /* Preparation (lower layer) */
-    mbedtls_reader_init( &rd, acc, sizeof( acc ) );
-    TEST_ASSERT( mbedtls_reader_feed( &rd, bufA, sizeof( bufA ) ) == 0 );
+    mbedtls_mps_reader_init( &rd, acc, sizeof( acc ) );
+    TEST_ASSERT( mbedtls_mps_reader_feed( &rd, bufA, sizeof( bufA ) ) == 0 );
 
     /* Consumption (upper layer) */
     /* Ask for more than what's available. */
-    TEST_ASSERT( mbedtls_reader_get( &rd, 80, &tmp, NULL ) == 0 );
+    TEST_ASSERT( mbedtls_mps_reader_get( &rd, 80, &tmp, NULL ) == 0 );
     ASSERT_COMPARE( tmp, 80, bufA, 80 );
-    TEST_ASSERT( mbedtls_reader_commit( &rd ) == 0 );
+    TEST_ASSERT( mbedtls_mps_reader_commit( &rd ) == 0 );
     /* 20 left, ask for 70 -> 50 overhead */
-    TEST_ASSERT( mbedtls_reader_get( &rd, 70, &tmp, NULL ) ==
+    TEST_ASSERT( mbedtls_mps_reader_get( &rd, 70, &tmp, NULL ) ==
                  MBEDTLS_ERR_MPS_READER_OUT_OF_DATA );
 
     /* Preparation */
-    TEST_ASSERT( mbedtls_reader_reclaim( &rd, NULL ) == 0 );
+    TEST_ASSERT( mbedtls_mps_reader_reclaim( &rd, NULL ) == 0 );
     switch( option )
     {
         case 0: /* 10 + 10 + 80 byte feed */
-            TEST_ASSERT( mbedtls_reader_feed( &rd, bufB, 10 ) ==
+            TEST_ASSERT( mbedtls_mps_reader_feed( &rd, bufB, 10 ) ==
                          MBEDTLS_ERR_MPS_READER_NEED_MORE );
-            TEST_ASSERT( mbedtls_reader_feed( &rd, bufB + 10, 10 ) ==
+            TEST_ASSERT( mbedtls_mps_reader_feed( &rd, bufB + 10, 10 ) ==
                          MBEDTLS_ERR_MPS_READER_NEED_MORE );
-            TEST_ASSERT( mbedtls_reader_feed( &rd, bufB + 20, 80 ) == 0 );
+            TEST_ASSERT( mbedtls_mps_reader_feed( &rd, bufB + 20, 80 ) == 0 );
             break;
 
         case 1: /* 50 x 1byte */
             for( int num_feed=0; num_feed<49; num_feed++ )
             {
-                TEST_ASSERT( mbedtls_reader_feed( &rd, bufB + num_feed, 1 ) ==
+                TEST_ASSERT( mbedtls_mps_reader_feed( &rd, bufB + num_feed, 1 ) ==
                              MBEDTLS_ERR_MPS_READER_NEED_MORE );
             }
-            TEST_ASSERT( mbedtls_reader_feed( &rd, bufB + 49, 1 ) == 0 );
+            TEST_ASSERT( mbedtls_mps_reader_feed( &rd, bufB + 49, 1 ) == 0 );
             break;
 
         case 2: /* 49 x 1byte + 51bytes */
             for( int num_feed=0; num_feed<49; num_feed++ )
             {
-                TEST_ASSERT( mbedtls_reader_feed( &rd, bufB + num_feed, 1 ) ==
+                TEST_ASSERT( mbedtls_mps_reader_feed( &rd, bufB + num_feed, 1 ) ==
                              MBEDTLS_ERR_MPS_READER_NEED_MORE );
             }
-            TEST_ASSERT( mbedtls_reader_feed( &rd, bufB + 49, 51 ) == 0 );
+            TEST_ASSERT( mbedtls_mps_reader_feed( &rd, bufB + 49, 51 ) == 0 );
             break;
 
         default:
@@ -469,10 +469,10 @@
     }
 
     /* Consumption */
-    TEST_ASSERT( mbedtls_reader_get( &rd, 70, &tmp, NULL ) == 0 );
+    TEST_ASSERT( mbedtls_mps_reader_get( &rd, 70, &tmp, NULL ) == 0 );
     ASSERT_COMPARE( tmp, 20, bufA + 80, 20 );
     ASSERT_COMPARE( tmp + 20, 50, bufB, 50 );
-    TEST_ASSERT( mbedtls_reader_get( &rd, 1000, &tmp, &fetch_len ) == 0 );
+    TEST_ASSERT( mbedtls_mps_reader_get( &rd, 1000, &tmp, &fetch_len ) == 0 );
     switch( option )
     {
         case 0:
@@ -491,11 +491,11 @@
             TEST_ASSERT( 0 );
             break;
     }
-    TEST_ASSERT( mbedtls_reader_commit( &rd ) == 0 );
+    TEST_ASSERT( mbedtls_mps_reader_commit( &rd ) == 0 );
 
     /* Wrapup */
-    TEST_ASSERT( mbedtls_reader_reclaim( &rd, NULL ) == 0 );
-    mbedtls_reader_free( &rd );
+    TEST_ASSERT( mbedtls_mps_reader_reclaim( &rd, NULL ) == 0 );
+    mbedtls_mps_reader_free( &rd );
 }
 /* END_CASE */
 
@@ -504,32 +504,32 @@
 void mbedtls_mps_reader_reclaim_data_left( int option )
 {
     /* This test exercises the behaviour of the MPS reader when a
-     * call to mbedtls_reader_reclaim() is made before all data
+     * call to mbedtls_mps_reader_reclaim() is made before all data
      * provided by the producer has been fetched and committed. */
 
     unsigned char buf[100];
     unsigned char *tmp;
-    mbedtls_reader rd;
+    mbedtls_mps_reader rd;
     for( int i=0; (unsigned) i < sizeof( buf ); i++ )
         buf[i] = (unsigned char) i;
 
     /* Preparation (lower layer) */
-    mbedtls_reader_init( &rd, NULL, 0 );
-    TEST_ASSERT( mbedtls_reader_feed( &rd, buf, sizeof( buf ) ) == 0 );
+    mbedtls_mps_reader_init( &rd, NULL, 0 );
+    TEST_ASSERT( mbedtls_mps_reader_feed( &rd, buf, sizeof( buf ) ) == 0 );
 
     /* Consumption (upper layer) */
     switch( option )
     {
         case 0:
             /* Fetch (but not commit) the entire buffer. */
-            TEST_ASSERT( mbedtls_reader_get( &rd, sizeof( buf ), &tmp, NULL )
+            TEST_ASSERT( mbedtls_mps_reader_get( &rd, sizeof( buf ), &tmp, NULL )
                          == 0 );
             ASSERT_COMPARE( tmp, 100, buf, 100 );
             break;
 
         case 1:
             /* Fetch (but not commit) parts of the buffer. */
-            TEST_ASSERT( mbedtls_reader_get( &rd, sizeof( buf ) / 2,
+            TEST_ASSERT( mbedtls_mps_reader_get( &rd, sizeof( buf ) / 2,
                                              &tmp, NULL ) == 0 );
             ASSERT_COMPARE( tmp, sizeof( buf ) / 2, buf, sizeof( buf ) / 2 );
             break;
@@ -537,11 +537,11 @@
         case 2:
             /* Fetch and commit parts of the buffer, then
              * fetch but not commit the rest of the buffer. */
-            TEST_ASSERT( mbedtls_reader_get( &rd, sizeof( buf ) / 2,
+            TEST_ASSERT( mbedtls_mps_reader_get( &rd, sizeof( buf ) / 2,
                                              &tmp, NULL ) == 0 );
             ASSERT_COMPARE( tmp, sizeof( buf ) / 2, buf, sizeof( buf ) / 2 );
-            TEST_ASSERT( mbedtls_reader_commit( &rd ) == 0 );
-            TEST_ASSERT( mbedtls_reader_get( &rd, sizeof( buf ) / 2,
+            TEST_ASSERT( mbedtls_mps_reader_commit( &rd ) == 0 );
+            TEST_ASSERT( mbedtls_mps_reader_get( &rd, sizeof( buf ) / 2,
                                              &tmp, NULL ) == 0 );
             ASSERT_COMPARE( tmp, sizeof( buf ) / 2,
                             buf + sizeof( buf ) / 2,
@@ -554,9 +554,9 @@
     }
 
     /* Wrapup */
-    TEST_ASSERT( mbedtls_reader_reclaim( &rd, NULL ) ==
+    TEST_ASSERT( mbedtls_mps_reader_reclaim( &rd, NULL ) ==
                  MBEDTLS_ERR_MPS_READER_DATA_LEFT );
-    mbedtls_reader_free( &rd );
+    mbedtls_mps_reader_free( &rd );
 }
 /* END_CASE */
 
@@ -568,30 +568,30 @@
      * to be processed, and the consumer subsequently fetches more data. */
     unsigned char buf[100];
     unsigned char *tmp;
-    mbedtls_reader rd;
+    mbedtls_mps_reader rd;
 
     for( int i=0; (unsigned) i < sizeof( buf ); i++ )
         buf[i] = (unsigned char) i;
 
     /* Preparation (lower layer) */
-    mbedtls_reader_init( &rd, NULL, 0 );
-    TEST_ASSERT( mbedtls_reader_feed( &rd, buf, sizeof( buf ) ) == 0 );
+    mbedtls_mps_reader_init( &rd, NULL, 0 );
+    TEST_ASSERT( mbedtls_mps_reader_feed( &rd, buf, sizeof( buf ) ) == 0 );
     /* Consumption (upper layer) */
-    TEST_ASSERT( mbedtls_reader_get( &rd, 50, &tmp, NULL ) == 0 );
+    TEST_ASSERT( mbedtls_mps_reader_get( &rd, 50, &tmp, NULL ) == 0 );
     ASSERT_COMPARE( tmp, 50, buf, 50 );
-    TEST_ASSERT( mbedtls_reader_commit( &rd ) == 0 );
-    TEST_ASSERT( mbedtls_reader_get( &rd, 50, &tmp, NULL ) == 0 );
+    TEST_ASSERT( mbedtls_mps_reader_commit( &rd ) == 0 );
+    TEST_ASSERT( mbedtls_mps_reader_get( &rd, 50, &tmp, NULL ) == 0 );
     ASSERT_COMPARE( tmp, 50, buf + 50, 50 );
     /* Preparation */
-    TEST_ASSERT( mbedtls_reader_reclaim( &rd, NULL ) ==
+    TEST_ASSERT( mbedtls_mps_reader_reclaim( &rd, NULL ) ==
                  MBEDTLS_ERR_MPS_READER_DATA_LEFT );
     /* Consumption */
-    TEST_ASSERT( mbedtls_reader_get( &rd, 50, &tmp, NULL ) == 0 );
+    TEST_ASSERT( mbedtls_mps_reader_get( &rd, 50, &tmp, NULL ) == 0 );
     ASSERT_COMPARE( tmp, 50, buf + 50, 50 );
-    TEST_ASSERT( mbedtls_reader_commit( &rd ) == 0 );
+    TEST_ASSERT( mbedtls_mps_reader_commit( &rd ) == 0 );
     /* Wrapup */
-    TEST_ASSERT( mbedtls_reader_reclaim( &rd, NULL ) == 0 );
-    mbedtls_reader_free( &rd );
+    TEST_ASSERT( mbedtls_mps_reader_reclaim( &rd, NULL ) == 0 );
+    mbedtls_mps_reader_free( &rd );
 }
 /* END_CASE */
 
@@ -600,7 +600,7 @@
 {
     /* This test exercises the behaviour of the MPS reader
      * in the following situation:
-     * - A read request via `mbedtls_reader_get()` can't
+     * - A read request via `mbedtls_mps_reader_get()` can't
      *   be served and the reader is paused to accumulate
      *   the desired amount of data from the producer.
      * - Once enough data is availble, the consumer successfully
@@ -613,7 +613,7 @@
     unsigned char *tmp;
     unsigned char acc[50];
     mbedtls_mps_size_t tmp_len;
-    mbedtls_reader rd;
+    mbedtls_mps_reader rd;
     for( int i=0; (unsigned) i < sizeof( bufA ); i++ )
         bufA[i] = (unsigned char) i;
     for( int i=0; (unsigned) i < sizeof( bufB ); i++ )
@@ -622,22 +622,22 @@
         bufC[i] = ~ ((unsigned char) i);
 
     /* Preparation (lower layer) */
-    mbedtls_reader_init( &rd, acc, sizeof( acc ) );
-    TEST_ASSERT( mbedtls_reader_feed( &rd, bufA, sizeof( bufA ) ) == 0 );
+    mbedtls_mps_reader_init( &rd, acc, sizeof( acc ) );
+    TEST_ASSERT( mbedtls_mps_reader_feed( &rd, bufA, sizeof( bufA ) ) == 0 );
 
     /* Consumption (upper layer) */
     /* Ask for more than what's available. */
-    TEST_ASSERT( mbedtls_reader_get( &rd, 80, &tmp, NULL ) == 0 );
+    TEST_ASSERT( mbedtls_mps_reader_get( &rd, 80, &tmp, NULL ) == 0 );
     ASSERT_COMPARE( tmp, 80, bufA, 80 );
-    TEST_ASSERT( mbedtls_reader_commit( &rd ) == 0 );
-    TEST_ASSERT( mbedtls_reader_get( &rd, 10, &tmp, NULL ) == 0 );
+    TEST_ASSERT( mbedtls_mps_reader_commit( &rd ) == 0 );
+    TEST_ASSERT( mbedtls_mps_reader_get( &rd, 10, &tmp, NULL ) == 0 );
     ASSERT_COMPARE( tmp, 10, bufA + 80, 10 );
-    TEST_ASSERT( mbedtls_reader_get( &rd, 20, &tmp, NULL ) ==
+    TEST_ASSERT( mbedtls_mps_reader_get( &rd, 20, &tmp, NULL ) ==
                  MBEDTLS_ERR_MPS_READER_OUT_OF_DATA );
 
     /* Preparation */
-    TEST_ASSERT( mbedtls_reader_reclaim( &rd, NULL ) == 0 );
-    TEST_ASSERT( mbedtls_reader_feed( &rd, bufB, sizeof( bufB ) ) == 0 );
+    TEST_ASSERT( mbedtls_mps_reader_reclaim( &rd, NULL ) == 0 );
+    TEST_ASSERT( mbedtls_mps_reader_feed( &rd, bufB, sizeof( bufB ) ) == 0 );
 
     switch( option )
     {
@@ -646,21 +646,21 @@
                  * large enough. */
 
             /* Consume */
-            TEST_ASSERT( mbedtls_reader_get( &rd, 10, &tmp, &tmp_len ) == 0 );
+            TEST_ASSERT( mbedtls_mps_reader_get( &rd, 10, &tmp, &tmp_len ) == 0 );
             ASSERT_COMPARE( tmp, tmp_len, bufA + 80, 10 );
-            TEST_ASSERT( mbedtls_reader_get( &rd, 20, &tmp, NULL ) == 0 );
+            TEST_ASSERT( mbedtls_mps_reader_get( &rd, 20, &tmp, NULL ) == 0 );
             ASSERT_COMPARE( tmp, 10, bufA + 90, 10 );
             ASSERT_COMPARE( tmp + 10, 10, bufB, 10 );
-            TEST_ASSERT( mbedtls_reader_commit( &rd ) == 0 );
-            TEST_ASSERT( mbedtls_reader_get( &rd, 20, &tmp, NULL ) ==
+            TEST_ASSERT( mbedtls_mps_reader_commit( &rd ) == 0 );
+            TEST_ASSERT( mbedtls_mps_reader_get( &rd, 20, &tmp, NULL ) ==
                          MBEDTLS_ERR_MPS_READER_OUT_OF_DATA );
 
             /* Prepare */
-            TEST_ASSERT( mbedtls_reader_reclaim( &rd, NULL ) == 0 );
-            TEST_ASSERT( mbedtls_reader_feed( &rd, bufC, sizeof( bufC ) ) == 0 );;
+            TEST_ASSERT( mbedtls_mps_reader_reclaim( &rd, NULL ) == 0 );
+            TEST_ASSERT( mbedtls_mps_reader_feed( &rd, bufC, sizeof( bufC ) ) == 0 );;
 
             /* Consume */
-            TEST_ASSERT( mbedtls_reader_get( &rd, 20, &tmp, NULL ) == 0 );
+            TEST_ASSERT( mbedtls_mps_reader_get( &rd, 20, &tmp, NULL ) == 0 );
             ASSERT_COMPARE( tmp, 10, bufB + 10, 10 );
             ASSERT_COMPARE( tmp + 10, 10, bufC, 10 );
             break;
@@ -668,37 +668,37 @@
         case 1: /* Fetch same chunks, commit afterwards, and
                  * then exceed bounds of new buffer; accumulator
                  * not large enough. */
-            TEST_ASSERT( mbedtls_reader_get( &rd, 10, &tmp, NULL ) == 0 );
+            TEST_ASSERT( mbedtls_mps_reader_get( &rd, 10, &tmp, NULL ) == 0 );
             ASSERT_COMPARE( tmp, 10, bufA + 80, 10 );
-            TEST_ASSERT( mbedtls_reader_get( &rd, 20, &tmp, NULL ) == 0 );
+            TEST_ASSERT( mbedtls_mps_reader_get( &rd, 20, &tmp, NULL ) == 0 );
             ASSERT_COMPARE( tmp, 10, bufA + 90, 10 );
             ASSERT_COMPARE( tmp + 10, 10, bufB, 10 );
-            TEST_ASSERT( mbedtls_reader_commit( &rd ) == 0 );
-            TEST_ASSERT( mbedtls_reader_get( &rd, 51, &tmp, NULL ) ==
+            TEST_ASSERT( mbedtls_mps_reader_commit( &rd ) == 0 );
+            TEST_ASSERT( mbedtls_mps_reader_get( &rd, 51, &tmp, NULL ) ==
                          MBEDTLS_ERR_MPS_READER_OUT_OF_DATA );
 
             /* Prepare */
-            TEST_ASSERT( mbedtls_reader_reclaim( &rd, NULL ) ==
+            TEST_ASSERT( mbedtls_mps_reader_reclaim( &rd, NULL ) ==
                          MBEDTLS_ERR_MPS_READER_ACCUMULATOR_TOO_SMALL );
             break;
 
         case 2: /* Fetch same chunks, don't commit afterwards, and
                  * then exceed bounds of new buffer; accumulator
                  * large enough. */
-            TEST_ASSERT( mbedtls_reader_get( &rd, 10, &tmp, NULL ) == 0 );
+            TEST_ASSERT( mbedtls_mps_reader_get( &rd, 10, &tmp, NULL ) == 0 );
             ASSERT_COMPARE( tmp, 10, bufA + 80, 10 );
-            TEST_ASSERT( mbedtls_reader_get( &rd, 20, &tmp, NULL ) == 0 );
+            TEST_ASSERT( mbedtls_mps_reader_get( &rd, 20, &tmp, NULL ) == 0 );
             ASSERT_COMPARE( tmp, 10, bufA + 90, 10 );
             ASSERT_COMPARE( tmp + 10, 10, bufB, 10 );
-            TEST_ASSERT( mbedtls_reader_get( &rd, 20, &tmp, NULL ) ==
+            TEST_ASSERT( mbedtls_mps_reader_get( &rd, 20, &tmp, NULL ) ==
                          MBEDTLS_ERR_MPS_READER_OUT_OF_DATA );
 
             /* Prepare */
-            TEST_ASSERT( mbedtls_reader_reclaim( &rd, NULL ) == 0 );
-            TEST_ASSERT( mbedtls_reader_feed( &rd, bufC, sizeof( bufC ) ) == 0 );;
+            TEST_ASSERT( mbedtls_mps_reader_reclaim( &rd, NULL ) == 0 );
+            TEST_ASSERT( mbedtls_mps_reader_feed( &rd, bufC, sizeof( bufC ) ) == 0 );;
 
             /* Consume */
-            TEST_ASSERT( mbedtls_reader_get( &rd, 50, &tmp, NULL ) == 0 );
+            TEST_ASSERT( mbedtls_mps_reader_get( &rd, 50, &tmp, NULL ) == 0 );
             ASSERT_COMPARE( tmp, 20, bufA + 80, 20 );
             ASSERT_COMPARE( tmp + 20, 20, bufB, 20 );
             ASSERT_COMPARE( tmp + 40, 10, bufC, 10 );
@@ -707,16 +707,16 @@
         case 3: /* Fetch same chunks, don't commit afterwards, and
                  * then exceed bounds of new buffer; accumulator
                  * not large enough. */
-            TEST_ASSERT( mbedtls_reader_get( &rd, 10, &tmp, NULL ) == 0 );
+            TEST_ASSERT( mbedtls_mps_reader_get( &rd, 10, &tmp, NULL ) == 0 );
             ASSERT_COMPARE( tmp, 10, bufA + 80, 10 );
-            TEST_ASSERT( mbedtls_reader_get( &rd, 20, &tmp, NULL ) == 0 );
+            TEST_ASSERT( mbedtls_mps_reader_get( &rd, 20, &tmp, NULL ) == 0 );
             ASSERT_COMPARE( tmp, 10, bufA + 90, 10 );
             ASSERT_COMPARE( tmp + 10, 10, bufB, 10 );
-            TEST_ASSERT( mbedtls_reader_get( &rd, 21, &tmp, NULL ) ==
+            TEST_ASSERT( mbedtls_mps_reader_get( &rd, 21, &tmp, NULL ) ==
                          MBEDTLS_ERR_MPS_READER_OUT_OF_DATA );
 
             /* Prepare */
-            TEST_ASSERT( mbedtls_reader_reclaim( &rd, NULL ) ==
+            TEST_ASSERT( mbedtls_mps_reader_reclaim( &rd, NULL ) ==
                          MBEDTLS_ERR_MPS_READER_ACCUMULATOR_TOO_SMALL );
             break;
 
@@ -725,7 +725,7 @@
             break;
     }
 
-    mbedtls_reader_free( &rd );
+    mbedtls_mps_reader_free( &rd );
 }
 /* END_CASE */
 
@@ -771,7 +771,7 @@
     int mode = 0; /* Lower layer (0) or Upper layer (1) */
     int reclaimed = 1; /* Have to call reclaim at least once before
                         * returning the reader to the upper layer. */
-    mbedtls_reader rd;
+    mbedtls_mps_reader rd;
 
     if( acc_size > 0 )
     {
@@ -785,7 +785,7 @@
     ASSERT_ALLOC( outgoing, num_out_chunks * max_chunk_size );
     ASSERT_ALLOC( incoming, num_out_chunks * max_chunk_size );
 
-    mbedtls_reader_init( &rd, acc, acc_size );
+    mbedtls_mps_reader_init( &rd, acc, acc_size );
 
     cur_out_chunk = 0;
     in_commit = 0;
@@ -801,7 +801,7 @@
             if( rand_op == 0 )
             {
                 /* Reclaim */
-                ret = mbedtls_reader_reclaim( &rd, NULL );
+                ret = mbedtls_mps_reader_reclaim( &rd, NULL );
 
                 if( ret == 0 )
                 {
@@ -823,7 +823,7 @@
                 ASSERT_ALLOC( tmp, tmp_size );
 
                 TEST_ASSERT( mbedtls_test_rnd_std_rand( NULL, tmp, tmp_size ) == 0 );
-                ret = mbedtls_reader_feed( &rd, tmp, tmp_size );
+                ret = mbedtls_mps_reader_feed( &rd, tmp, tmp_size );
 
                 if( ret == 0 || ret == MBEDTLS_ERR_MPS_READER_NEED_MORE )
                 {
@@ -864,13 +864,13 @@
                 get_size = ( rand() % max_request ) + 1;
                 if( rand_op == 0 )
                 {
-                    ret = mbedtls_reader_get( &rd, get_size, &chunk_get,
+                    ret = mbedtls_mps_reader_get( &rd, get_size, &chunk_get,
                                               &real_size );
                 }
                 else
                 {
                     real_size = get_size;
-                    ret = mbedtls_reader_get( &rd, get_size, &chunk_get, NULL );
+                    ret = mbedtls_mps_reader_get( &rd, get_size, &chunk_get, NULL );
                 }
 
                 /* Check if output is in accordance with what was written */
@@ -886,7 +886,7 @@
             }
             else if( rand_op == 2 ) /* Commit */
             {
-                ret = mbedtls_reader_commit( &rd );
+                ret = mbedtls_mps_reader_commit( &rd );
                 if( ret == 0 )
                 {
                     in_commit += in_fetch;
@@ -904,7 +904,7 @@
     }
 
     /* Cleanup */
-    mbedtls_reader_free( &rd );
+    mbedtls_mps_reader_free( &rd );
     mbedtls_free( incoming );
     mbedtls_free( outgoing );
     mbedtls_free( acc );
@@ -931,7 +931,7 @@
     unsigned char bufA[100], bufB[100];
     unsigned char *tmp;
     unsigned char acc[40];
-    mbedtls_reader rd;
+    mbedtls_mps_reader rd;
     int success = 0;
     for( int i=0; (unsigned) i < sizeof( bufA ); i++ )
         bufA[i] = (unsigned char) i;
@@ -939,23 +939,23 @@
         bufB[i] = ~ ((unsigned char) i);
 
     /* Preparation (lower layer) */
-    mbedtls_reader_init( &rd, acc, sizeof( acc ) );
-    TEST_ASSERT( mbedtls_reader_feed( &rd, bufA, sizeof( bufA ) ) == 0 );
+    mbedtls_mps_reader_init( &rd, acc, sizeof( acc ) );
+    TEST_ASSERT( mbedtls_mps_reader_feed( &rd, bufA, sizeof( bufA ) ) == 0 );
     /* Consumption (upper layer) */
-    TEST_ASSERT( mbedtls_reader_get( &rd, 80, &tmp, NULL ) == 0 );
-    TEST_ASSERT( mbedtls_reader_commit( &rd ) == 0 );
-    TEST_ASSERT( mbedtls_reader_get( &rd, 10, &tmp, NULL ) == 0 );
-    TEST_ASSERT( mbedtls_reader_get( &rd, 20, &tmp, NULL ) ==
+    TEST_ASSERT( mbedtls_mps_reader_get( &rd, 80, &tmp, NULL ) == 0 );
+    TEST_ASSERT( mbedtls_mps_reader_commit( &rd ) == 0 );
+    TEST_ASSERT( mbedtls_mps_reader_get( &rd, 10, &tmp, NULL ) == 0 );
+    TEST_ASSERT( mbedtls_mps_reader_get( &rd, 20, &tmp, NULL ) ==
                  MBEDTLS_ERR_MPS_READER_OUT_OF_DATA );
     /* Preparation */
-    TEST_ASSERT( mbedtls_reader_reclaim( &rd, NULL ) == 0 );
-    TEST_ASSERT( mbedtls_reader_feed( &rd, bufB, sizeof( bufB ) ) == 0 );
+    TEST_ASSERT( mbedtls_mps_reader_reclaim( &rd, NULL ) == 0 );
+    TEST_ASSERT( mbedtls_mps_reader_feed( &rd, bufB, sizeof( bufB ) ) == 0 );
     /* Consumption */
     switch( option )
     {
         case 0:
             /* Ask for buffered data in a single chunk, no commit */
-            TEST_ASSERT( mbedtls_reader_get( &rd, 30, &tmp, NULL ) == 0 );
+            TEST_ASSERT( mbedtls_mps_reader_get( &rd, 30, &tmp, NULL ) == 0 );
             ASSERT_COMPARE( tmp, 20, bufA + 80, 20 );
             ASSERT_COMPARE( tmp + 20, 10, bufB, 10 );
             success = 1;
@@ -963,40 +963,40 @@
 
         case 1:
             /* Ask for buffered data in a single chunk, with commit */
-            TEST_ASSERT( mbedtls_reader_get( &rd, 30, &tmp, NULL ) == 0 );
+            TEST_ASSERT( mbedtls_mps_reader_get( &rd, 30, &tmp, NULL ) == 0 );
             ASSERT_COMPARE( tmp, 20, bufA + 80, 20 );
             ASSERT_COMPARE( tmp + 20, 10, bufB, 10 );
-            TEST_ASSERT( mbedtls_reader_commit( &rd ) == 0 );
+            TEST_ASSERT( mbedtls_mps_reader_commit( &rd ) == 0 );
             success = 1;
             break;
 
         case 2:
             /* Ask for more than was requested when pausing, #1 */
-            TEST_ASSERT( mbedtls_reader_get( &rd, 31, &tmp, NULL ) ==
+            TEST_ASSERT( mbedtls_mps_reader_get( &rd, 31, &tmp, NULL ) ==
                          MBEDTLS_ERR_MPS_READER_INCONSISTENT_REQUESTS );
             break;
 
         case 3:
             /* Ask for more than was requested when pausing #2 */
-            TEST_ASSERT( mbedtls_reader_get( &rd, (mbedtls_mps_size_t) -1, &tmp, NULL ) ==
+            TEST_ASSERT( mbedtls_mps_reader_get( &rd, (mbedtls_mps_size_t) -1, &tmp, NULL ) ==
                          MBEDTLS_ERR_MPS_READER_INCONSISTENT_REQUESTS );
             break;
 
         case 4:
             /* Asking for buffered data in different
              * chunks than before CAN fail. */
-            TEST_ASSERT( mbedtls_reader_get( &rd, 15, &tmp, NULL ) == 0 );
+            TEST_ASSERT( mbedtls_mps_reader_get( &rd, 15, &tmp, NULL ) == 0 );
             ASSERT_COMPARE( tmp, 15, bufA + 80, 15 );
-            TEST_ASSERT( mbedtls_reader_get( &rd, 10, &tmp, NULL ) ==
+            TEST_ASSERT( mbedtls_mps_reader_get( &rd, 10, &tmp, NULL ) ==
                          MBEDTLS_ERR_MPS_READER_INCONSISTENT_REQUESTS );
             break;
 
         case 5:
             /* Asking for buffered data different chunks
              * than before NEED NOT fail - no commits */
-            TEST_ASSERT( mbedtls_reader_get( &rd, 15, &tmp, NULL ) == 0 );
+            TEST_ASSERT( mbedtls_mps_reader_get( &rd, 15, &tmp, NULL ) == 0 );
             ASSERT_COMPARE( tmp, 15, bufA + 80, 15 );
-            TEST_ASSERT( mbedtls_reader_get( &rd, 15, &tmp, NULL ) == 0 );
+            TEST_ASSERT( mbedtls_mps_reader_get( &rd, 15, &tmp, NULL ) == 0 );
             ASSERT_COMPARE( tmp, 5, bufA + 95, 5 );
             ASSERT_COMPARE( tmp + 5, 10, bufB, 10 );
             success = 1;
@@ -1005,10 +1005,10 @@
         case 6:
             /* Asking for buffered data different chunks
              * than before NEED NOT fail - intermediate commit */
-            TEST_ASSERT( mbedtls_reader_get( &rd, 15, &tmp, NULL ) == 0 );
+            TEST_ASSERT( mbedtls_mps_reader_get( &rd, 15, &tmp, NULL ) == 0 );
             ASSERT_COMPARE( tmp, 15, bufA + 80, 15 );
-            TEST_ASSERT( mbedtls_reader_commit( &rd ) == 0 );
-            TEST_ASSERT( mbedtls_reader_get( &rd, 15, &tmp, NULL ) == 0 );
+            TEST_ASSERT( mbedtls_mps_reader_commit( &rd ) == 0 );
+            TEST_ASSERT( mbedtls_mps_reader_get( &rd, 15, &tmp, NULL ) == 0 );
             ASSERT_COMPARE( tmp, 5, bufA + 95, 5 );
             ASSERT_COMPARE( tmp + 5, 10, bufB, 10 );
             success = 1;
@@ -1017,25 +1017,25 @@
         case 7:
             /* Asking for buffered data different chunks
              * than before NEED NOT fail - end commit */
-            TEST_ASSERT( mbedtls_reader_get( &rd, 15, &tmp, NULL ) == 0 );
+            TEST_ASSERT( mbedtls_mps_reader_get( &rd, 15, &tmp, NULL ) == 0 );
             ASSERT_COMPARE( tmp, 15, bufA + 80, 15 );
-            TEST_ASSERT( mbedtls_reader_get( &rd, 15, &tmp, NULL ) == 0 );
+            TEST_ASSERT( mbedtls_mps_reader_get( &rd, 15, &tmp, NULL ) == 0 );
             ASSERT_COMPARE( tmp, 5, bufA + 95, 5 );
             ASSERT_COMPARE( tmp + 5, 10, bufB, 10 );
-            TEST_ASSERT( mbedtls_reader_commit( &rd ) == 0 );
+            TEST_ASSERT( mbedtls_mps_reader_commit( &rd ) == 0 );
             success = 1;
             break;
 
         case 8:
             /* Asking for buffered data different chunks
              * than before NEED NOT fail - intermediate & end commit */
-            TEST_ASSERT( mbedtls_reader_get( &rd, 15, &tmp, NULL ) == 0 );
+            TEST_ASSERT( mbedtls_mps_reader_get( &rd, 15, &tmp, NULL ) == 0 );
             ASSERT_COMPARE( tmp, 15, bufA + 80, 15 );
-            TEST_ASSERT( mbedtls_reader_get( &rd, 15, &tmp, NULL ) == 0 );
-            TEST_ASSERT( mbedtls_reader_commit( &rd ) == 0 );
+            TEST_ASSERT( mbedtls_mps_reader_get( &rd, 15, &tmp, NULL ) == 0 );
+            TEST_ASSERT( mbedtls_mps_reader_commit( &rd ) == 0 );
             ASSERT_COMPARE( tmp, 5, bufA + 95, 5 );
             ASSERT_COMPARE( tmp + 5, 10, bufB, 10 );
-            TEST_ASSERT( mbedtls_reader_commit( &rd ) == 0 );
+            TEST_ASSERT( mbedtls_mps_reader_commit( &rd ) == 0 );
             success = 1;
             break;
 
@@ -1047,16 +1047,16 @@
     if( success == 1 )
     {
         /* In all succeeding cases, fetch the rest of the second buffer. */
-        TEST_ASSERT( mbedtls_reader_get( &rd, 90, &tmp, NULL ) == 0 );
+        TEST_ASSERT( mbedtls_mps_reader_get( &rd, 90, &tmp, NULL ) == 0 );
         ASSERT_COMPARE( tmp, 90, bufB + 10, 90 );
-        TEST_ASSERT( mbedtls_reader_commit( &rd ) == 0 );
+        TEST_ASSERT( mbedtls_mps_reader_commit( &rd ) == 0 );
 
         /* Wrapup */
-        TEST_ASSERT( mbedtls_reader_reclaim( &rd, NULL ) == 0 );
+        TEST_ASSERT( mbedtls_mps_reader_reclaim( &rd, NULL ) == 0 );
     }
 
     /* Wrapup */
-    mbedtls_reader_free( &rd );
+    mbedtls_mps_reader_free( &rd );
 }
 /* END_CASE */
 
@@ -1067,16 +1067,16 @@
      * fed a NULL buffer. */
     unsigned char buf[100];
     unsigned char *tmp;
-    mbedtls_reader rd;
+    mbedtls_mps_reader rd;
     for( int i=0; (unsigned) i < sizeof( buf ); i++ )
         buf[i] = (unsigned char) i;
 
     /* Preparation (lower layer) */
-    mbedtls_reader_init( &rd, NULL, 0 );
+    mbedtls_mps_reader_init( &rd, NULL, 0 );
     switch( option )
     {
         case 0: /* NULL buffer */
-            TEST_ASSERT( mbedtls_reader_feed( &rd, NULL, sizeof( buf ) ) ==
+            TEST_ASSERT( mbedtls_mps_reader_feed( &rd, NULL, sizeof( buf ) ) ==
                          MBEDTLS_ERR_MPS_READER_INVALID_ARG );
             break;
 
@@ -1085,15 +1085,15 @@
             break;
     }
     /* Subsequent feed-calls should still succeed. */
-    TEST_ASSERT( mbedtls_reader_feed( &rd, buf, sizeof( buf ) ) == 0 );
+    TEST_ASSERT( mbedtls_mps_reader_feed( &rd, buf, sizeof( buf ) ) == 0 );
 
     /* Consumption (upper layer) */
-    TEST_ASSERT( mbedtls_reader_get( &rd, 100, &tmp, NULL ) == 0 );
+    TEST_ASSERT( mbedtls_mps_reader_get( &rd, 100, &tmp, NULL ) == 0 );
     ASSERT_COMPARE( tmp, 100, buf, 100 );
-    TEST_ASSERT( mbedtls_reader_commit( &rd ) == 0 );
+    TEST_ASSERT( mbedtls_mps_reader_commit( &rd ) == 0 );
 
     /* Wrapup */
-    TEST_ASSERT( mbedtls_reader_reclaim( &rd, NULL ) == 0 );
-    mbedtls_reader_free( &rd );
+    TEST_ASSERT( mbedtls_mps_reader_reclaim( &rd, NULL ) == 0 );
+    mbedtls_mps_reader_free( &rd );
 }
 /* END_CASE */