diff --git a/CMakeLists.txt b/CMakeLists.txt
new file mode 100644
index 0000000..3c58803
--- /dev/null
+++ b/CMakeLists.txt
@@ -0,0 +1,15 @@
+cmake_minimum_required(VERSION 2.6)
+project(POLARSSL C)
+
+enable_testing()
+
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -g -O0 -Wall -W -fprofile-arcs -ftest-coverage -lgcov")
+set(CMAKE_SHARED_LINKER_FLAGS "-fprofile-arcs -ftest-coverage")
+#set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -g -O0 -Wall -W")
+#set(CMAKE_SHARED_LINKER_FLAGS "")
+
+include_directories(include/)
+
+add_subdirectory(library)
+add_subdirectory(programs)
+add_subdirectory(tests)
diff --git a/ChangeLog b/ChangeLog
index b72b055..67f6926 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,6 +1,11 @@
 PolarSSL ChangeLog
 
 = Version X released on X
+Features
+   * Added CMake makefiles as alternative to regular Makefiles.
+   * Added preliminary Code Coverage tests for AES, ARC4,
+     Base64, MPI, SHA-family, MD-family and  HMAC-SHA-family.
+
 Bug fixes
    * Fixed incorrect handling of negative strings in
      mpi_read_string() (found by code coverage tests).
diff --git a/library/CMakeLists.txt b/library/CMakeLists.txt
new file mode 100644
index 0000000..51c45fc
--- /dev/null
+++ b/library/CMakeLists.txt
@@ -0,0 +1,15 @@
+add_library(polarssl STATIC
+     base64.c rsa.c timing.c havege.c
+     md5.c
+     ssl_cli.c 
+     bignum.c    debug.c              sha1.c  x509parse.c
+     aes.c        net.c      ssl_srv.c 
+     camellia.c  des.c                md2.c             sha2.c   xtea.c
+     arc4.c
+     padlock.c
+     ssl_tls.c
+     certs.c
+     dhm.c
+     md4.c
+     sha4.c
+)
diff --git a/programs/CMakeLists.txt b/programs/CMakeLists.txt
new file mode 100644
index 0000000..a11929a
--- /dev/null
+++ b/programs/CMakeLists.txt
@@ -0,0 +1,5 @@
+add_subdirectory(aes)
+add_subdirectory(hash)
+add_subdirectory(pkey)
+add_subdirectory(ssl)
+add_subdirectory(test)
diff --git a/programs/aes/CMakeLists.txt b/programs/aes/CMakeLists.txt
new file mode 100644
index 0000000..1daad58
--- /dev/null
+++ b/programs/aes/CMakeLists.txt
@@ -0,0 +1,2 @@
+add_executable(aescrypt2 aescrypt2.c)
+target_link_libraries(aescrypt2 polarssl)
diff --git a/programs/hash/CMakeLists.txt b/programs/hash/CMakeLists.txt
new file mode 100644
index 0000000..e9af522
--- /dev/null
+++ b/programs/hash/CMakeLists.txt
@@ -0,0 +1,11 @@
+add_executable(hello hello.c)
+target_link_libraries(hello polarssl)
+
+add_executable(md5sum md5sum.c)
+target_link_libraries(md5sum polarssl)
+
+add_executable(sha1sum sha1sum.c)
+target_link_libraries(sha1sum polarssl)
+
+add_executable(sha2sum sha2sum.c)
+target_link_libraries(sha2sum polarssl)
diff --git a/programs/pkey/CMakeLists.txt b/programs/pkey/CMakeLists.txt
new file mode 100644
index 0000000..7190ee4
--- /dev/null
+++ b/programs/pkey/CMakeLists.txt
@@ -0,0 +1,20 @@
+add_executable(dh_client dh_client.c)
+target_link_libraries(dh_client polarssl)
+
+add_executable(dh_genprime dh_genprime.c)
+target_link_libraries(dh_genprime polarssl)
+
+add_executable(dh_server dh_server.c)
+target_link_libraries(dh_server polarssl)
+
+add_executable(mpi_demo mpi_demo.c)
+target_link_libraries(mpi_demo polarssl)
+
+add_executable(rsa_genkey rsa_genkey.c)
+target_link_libraries(rsa_genkey polarssl)
+
+add_executable(rsa_sign rsa_sign.c)
+target_link_libraries(rsa_sign polarssl)
+
+add_executable(rsa_verify rsa_verify.c)
+target_link_libraries(rsa_verify polarssl)
diff --git a/programs/ssl/CMakeLists.txt b/programs/ssl/CMakeLists.txt
new file mode 100644
index 0000000..8eb6d3c
--- /dev/null
+++ b/programs/ssl/CMakeLists.txt
@@ -0,0 +1,8 @@
+add_executable(ssl_client1 ssl_client1.c)
+target_link_libraries(ssl_client1 polarssl)
+
+add_executable(ssl_client2 ssl_client2.c)
+target_link_libraries(ssl_client2 polarssl)
+
+add_executable(ssl_server ssl_server.c)
+target_link_libraries(ssl_server polarssl)
diff --git a/programs/test/CMakeLists.txt b/programs/test/CMakeLists.txt
new file mode 100644
index 0000000..95c01b4
--- /dev/null
+++ b/programs/test/CMakeLists.txt
@@ -0,0 +1,12 @@
+add_executable(selftest selftest.c)
+target_link_libraries(selftest polarssl)
+
+add_executable(benchmark benchmark.c)
+target_link_libraries(benchmark polarssl)
+
+add_executable(ssl_test ssl_test.c)
+target_link_libraries(ssl_test polarssl)
+
+add_executable(ssl_cert_test ssl_cert_test.c)
+target_link_libraries(ssl_cert_test polarssl)
+
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
new file mode 100644
index 0000000..8c83288
--- /dev/null
+++ b/tests/CMakeLists.txt
@@ -0,0 +1,21 @@
+function(add_test_suite suite_name)
+    add_custom_command(
+        OUTPUT test_suite_${suite_name}.c
+        COMMAND scripts/generate_code.pl suites test_suite_${suite_name}
+        DEPENDS scripts/generate_code.pl polarssl fct.h suites/helpers.function suites/test_suite_${suite_name}.function suites/test_suite_${suite_name}.data
+)
+
+    add_executable(test_suite_${suite_name} test_suite_${suite_name}.c)
+    target_link_libraries(test_suite_${suite_name} polarssl)
+    add_test(${suite_name}-suite test_suite_${suite_name})
+endfunction(add_test_suite)
+
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-unused-function -Wno-unused-value")
+
+add_test_suite(mpi)
+add_test_suite(base64)
+add_test_suite(arc4)
+add_test_suite(mdx)
+add_test_suite(shax)
+add_test_suite(hmac_shax)
+add_test_suite(aes)
diff --git a/tests/fct.h b/tests/fct.h
new file mode 100644
index 0000000..f6c1251
--- /dev/null
+++ b/tests/fct.h
@@ -0,0 +1,1688 @@
+/*
+====================================================================
+Copyright (c) 2008 Ian Blumel.  All rights reserved.
+
+FCT (Fast C Test) Unit Testing Framework
+
+Copyright (c) 2008, Ian Blumel (ian.blumel@gmail.com)
+All rights reserved.
+
+This license is based on the BSD License.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+    * Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+    
+    * Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in
+    the documentation and/or other materials provided with the
+    distribution.
+
+    * Neither the name of, Ian Blumel, nor the names of its
+    contributors may be used to endorse or promote products derived
+    from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
+OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+====================================================================
+
+File: fct.h
+*/
+
+#if !defined(FCT_INCLUDED__IMB)
+#define FCT_INCLUDED__IMB
+
+#define FCT_VERSION_STR   "1.0.2"
+#define FCT_VERSION_MAJOR 1
+#define FCT_VERSION_MINOR 0
+#define FCT_VERSION_MICRO 2
+
+/* Define this to remove unneeded WIN32 warnings. We will undefine this at
+the end of the file so as not to interfere with your build. */
+#if defined(WIN32) && !defined(_CRT_SECURE_NO_WARNINGS)
+#  define _CRT_SECURE_NO_WARNINGS
+#endif
+
+#include <string.h>
+#include <assert.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <time.h>
+#include <float.h>
+#include <math.h>
+
+#define FCT_MAX_NAME           256
+#define FCT_MAX_LOG_LINE       256
+
+#define nbool_t int
+#define FCT_TRUE   1
+#define FCT_FALSE  0
+
+/* Forward declarations. The following forward declarations are required
+because there is a inter-relationship between certain objects that 
+just can not be untwined. */
+typedef struct _fct_logger_i fct_logger_i;
+typedef struct _fct_standard_logger_t fct_standard_logger_t;
+typedef struct _fct_minimal_logger_t fct_minimal_logger_t;
+typedef struct _fctchk_t fctchk_t;
+typedef struct _fct_test_t fct_test_t;
+typedef struct _fct_ts_t fct_ts_t;
+typedef struct _fctkern_t fctkern_t;
+
+/* Forward declare some functions used throughout. */
+static fct_standard_logger_t *
+fct_standard_logger__new(void);
+
+static void
+fct_logger__del(fct_logger_i *logger);
+
+static void
+fct_logger__on_cndtn(fct_logger_i *self, fctchk_t const *chk);
+
+static void
+fct_logger__on_test_start(fct_logger_i *logger, fct_test_t const *test);
+
+static void
+fct_logger__on_test_end(fct_logger_i *logger, fct_test_t const *test);
+
+static void
+fct_logger__on_test_suite_start(fct_logger_i *logger, fct_ts_t const *ts);
+
+static void
+fct_logger__on_test_suite_end(fct_logger_i *logger, fct_ts_t const *ts);
+
+static void
+fct_logger__on_fct_start(fct_logger_i *logger, fctkern_t const *kern);
+
+static void
+fct_logger__on_fct_end(fct_logger_i *logger, fctkern_t const *kern);
+
+
+
+/* Explicitly indicate a no-op */
+#define fct_pass()    
+
+#define fct_unused(x)   ((void) (x));
+
+/* This is just a little trick to let me put comments inside of macros. I
+really only want to bother with this when we are "unwinding" the macros
+for debugging purposes. */
+#if defined(FCT_CONF_UNWIND)
+#	define _fct_cmt(string)		{char*_=string;} 
+#else
+#	define _fct_cmt(string)
+#endif
+
+/* 
+-------------------------------------------------------- 
+UTILITIES
+-------------------------------------------------------- 
+*/
+
+/* Utility for truncated, safe string copies. */
+static void
+fct_safe_str_cpy(char *dst, char const *src, size_t num)
+{
+   assert( dst != NULL );
+   assert( src != NULL );
+   assert( num > 0 );
+   strncpy(dst, src, num);
+   dst[num-1] = '\0';
+}
+
+/* Isolate the snprintf implemenation. */
+int 
+fct_snprintf(char *buffer, size_t buffer_len, char *format, ...)
+{
+   int count =0;
+   va_list args;
+   va_start(args, format);
+   count =vsnprintf(buffer, buffer_len, format, args);
+   va_end(args);
+   return count;
+}
+
+/* A very, very simple "filter". This just compares the supplied prefix 
+against the test_str, to see if they both have the same starting 
+characters. If they do we return true, otherwise we return false. If the
+prefix is a blank string or NULL, then it will return FCT_TRUE.*/
+static nbool_t
+fct_filter_pass(char const *prefix, char const *test_str)
+{
+   nbool_t is_match = FCT_FALSE;
+   char const *prefix_p;
+   char const *test_str_p;
+
+   /* If you got nothing to test against, why test? */
+   assert( test_str != NULL );
+
+   /* When the prefix is NULL or blank, we always return FCT_TRUE. */
+   if ( prefix == NULL  || prefix[0] == '\0' ) 
+   { 
+      return FCT_TRUE;
+   }
+     
+   /* Iterate through both character arrays at the same time. We are
+   going to play a game and see if we can beat the house. */
+   for ( prefix_p = prefix, test_str_p = test_str; 
+         *prefix_p != '\0' && *test_str_p != '\0'; 
+         ++prefix_p, ++test_str_p )
+   {
+      is_match = *prefix_p == *test_str_p;
+      if ( !is_match ) 
+      {
+         break;   /* Quit the first time we don't match. */
+      }
+   }
+   
+   /* If the iterator for the test_str is pointing at the null char, and
+   the iterator for the prefix string is not, then the prefix string is 
+   larger than the actual test string, and therefore we failed to pass the
+   filter. */
+   if ( *test_str_p == '\0' && *prefix_p != '\0' )
+   {
+      return FCT_FALSE;
+   }
+
+   /* is_match will be set to the either FCT_TRUE if we kicked of the loop
+   early because our filter ran out of characters or FCT_FALSE if we 
+   encountered a mismatch before our filter ran out of characters. */
+   return is_match;
+}
+
+/* Returns true if two reals are equal. */
+nbool_t 
+fct_real_eq(double v1, double v2)
+{
+   return (nbool_t)(fabs(v1 - v2) < DBL_EPSILON);
+}
+
+/* 
+-------------------------------------------------------- 
+TIMER
+-------------------------------------------------------- 
+*/
+
+typedef struct _fct_timer_t fct_timer_t;
+struct _fct_timer_t {
+    clock_t start;
+    clock_t stop;
+    double duration;
+};
+
+
+static void
+fct_timer__init(fct_timer_t *timer) {
+    assert(timer != NULL);
+    memset(timer, 0, sizeof(fct_timer_t));
+}
+
+
+static void
+fct_timer__start(fct_timer_t *timer) {
+    assert(timer != NULL);
+    timer->start = clock();
+}
+
+
+static void
+fct_timer__stop(fct_timer_t *timer) {
+    assert(timer != NULL);
+    timer->stop = clock();
+    timer->duration = (double) (timer->stop - timer->start) / CLOCKS_PER_SEC;
+}
+
+
+/* Returns the time in seconds. */
+static double
+fct_timer__duration(fct_timer_t *timer) {
+    assert( timer != NULL );
+    return timer->duration;   
+}
+
+
+/* 
+-------------------------------------------------------- 
+GENERIC LIST
+-------------------------------------------------------- 
+*/
+
+/* For now we will just keep it at a linear growth rate. */
+#define FCT_LIST_GROWTH_FACTOR   2
+
+/* Starting size for the list, to keep it simple we will start
+at a reasonable size. */
+#define FCT_LIST_START_SIZE      2
+
+/* Helper macros for quickly iterating through a list. You should be able
+to do something like,
+
+  NLIST_FOREACH_BGN(fct_logger_i*, logger, my_list)
+  {
+     fct_logger__on_blah(logger);
+  }
+  NLIST_FOREACH_END();
+
+*/
+#define NLIST_FOREACH_BGN(Type, Var, List)\
+{\
+   if ( List != NULL ) {\
+      size_t item_i##Var;\
+      size_t num_items##Var = nlist__size(List);\
+      for( item_i##Var =0; item_i##Var != num_items##Var; ++item_i##Var )\
+      {\
+         Type Var = (Type) nlist__at((List), item_i##Var);
+
+#define NLIST_FOREACH_END() }}}
+
+/* Used to manage a list of loggers. This works mostly like
+the STL vector, where the array grows as more items are 
+appended. */
+typedef struct _nlist_t nlist_t;
+struct _nlist_t
+{ 
+   /* Item's are stored as pointers to void. */
+   void **itm_list;
+   
+   /* Indicates the number of element's in the array. */
+   size_t avail_itm_num;
+
+   /* Indicates the number of actually elements in the array. */
+   size_t used_itm_num;
+};
+
+static nlist_t *
+nlist_new(void)
+{
+   nlist_t *list = (nlist_t*)calloc(1, sizeof(nlist_t));
+   assert( list != NULL && "memory check");
+
+   list->itm_list = (void**)malloc(sizeof(void*)*FCT_LIST_START_SIZE);
+   assert( list->itm_list != NULL && "memory check");
+
+   list->avail_itm_num =FCT_LIST_START_SIZE;
+   list->used_itm_num =0;
+   return list;
+}
+
+typedef void (*on_del_t)(void*);
+
+/* Cleans up list, and applies `on_del` to each item in the list. 
+If on_del is NULL, it will not be applied. If `list` is NULL this
+function does nothing. */
+static void
+nlist__del(nlist_t *list, on_del_t on_del)
+{
+   size_t itm_i =0;
+
+   if ( list == NULL ) { return; }
+
+   /* Walk through the list applying the destroy function, if it was 
+   defined. */
+   if ( on_del != NULL )
+   {
+      for ( itm_i =0; itm_i != list->used_itm_num; ++itm_i )
+      {
+         on_del(list->itm_list[itm_i]);
+      }
+   }
+
+   free(list->itm_list);
+   free(list);
+}
+
+
+/* Returns the number of elements within the list. */
+static size_t
+nlist__size(nlist_t const *list)
+{
+   assert( list != NULL );
+   return list->used_itm_num;
+}
+
+
+/* Returns the item at idx, asserts otherwise. */
+static void*
+nlist__at(nlist_t const *list, size_t idx)
+{
+   assert( list != NULL );
+   assert( idx < list->used_itm_num );
+   return list->itm_list[idx];
+}
+
+
+static void
+nlist__append(nlist_t *list, void *itm)
+{
+   assert( list != NULL );
+   assert( list->itm_list != NULL );
+   assert( list->avail_itm_num != 0 );
+
+   /* If we ran out of room, then the last increment should be equal to the
+   available space, in this case we need to grow a little more. */
+   if ( list->used_itm_num == list->avail_itm_num )
+   {
+      list->avail_itm_num = list->avail_itm_num*FCT_LIST_GROWTH_FACTOR;
+      list->itm_list = (void**)realloc(
+         list->itm_list, sizeof(void*)*list->avail_itm_num
+         );
+      assert( list->itm_list != NULL && "memory check");
+   }
+
+   list->itm_list[list->used_itm_num] = itm;
+   ++(list->used_itm_num);
+}
+
+
+
+/*
+-----------------------------------------------------------
+A SINGLE CHECK
+-----------------------------------------------------------
+This defines a single check. It indicates what the check was,
+and where it occurred. A "Test" object will have-a bunch
+of "checks".
+*/
+
+struct _fctchk_t {
+   /* This string that represents the condition. */
+   char cndtn[FCT_MAX_LOG_LINE];
+
+   /* These indicate where the condition occurred. */
+   char file[FCT_MAX_LOG_LINE];
+
+   int lineno;
+
+   nbool_t is_pass;
+};
+
+#define fctchk__is_pass(_CHK_) ((_CHK_)->is_pass)
+#define fctchk__file(_CHK_)    ((_CHK_)->file)
+#define fctchk__lineno(_CHK_)  ((_CHK_)->lineno)
+#define fctchk__cndtn(_CHK_)   ((_CHK_)->cndtn)
+
+
+static fctchk_t*
+fctchk_new(char const *cndtn, char const *file, int lineno, nbool_t is_pass)
+{
+   fctchk_t *chk = NULL;
+
+   assert( cndtn != NULL );
+   assert( file != NULL );
+   assert( lineno > 0 );
+   
+   chk = (fctchk_t*)calloc(1, sizeof(fctchk_t));
+   assert( chk != NULL && "out of memory");
+   if ( chk == NULL ) { return NULL; }
+
+   fct_safe_str_cpy(chk->cndtn, cndtn, FCT_MAX_LOG_LINE);
+   fct_safe_str_cpy(chk->file, file, FCT_MAX_LOG_LINE);
+   chk->lineno = lineno;
+
+   chk->is_pass =is_pass;
+
+   return chk;
+}
+
+
+/* Cleans up a "check" object. If the `chk` is NULL, this function does 
+nothing. */
+static void
+fctchk__del(fctchk_t *chk)
+{
+   if ( chk == NULL ) { return; }
+   free( chk );
+}
+
+
+/*
+-----------------------------------------------------------
+A TEST
+-----------------------------------------------------------
+A suite will have-a list of tests. Where each test will have-a
+list of failed and passed checks.
+*/
+
+struct _fct_test_t {
+   /* List of failed and passed "checks" (fctchk_t). Two seperate
+   lists make it faster to determine how many checks passed and how
+   many checks failed. */
+   nlist_t *failed_chks;
+   nlist_t *passed_chks;
+
+   /* The name of the test case. */
+   char name[FCT_MAX_NAME];
+};
+
+#define fct_test__name(_TEST_) ((_TEST_)->name)
+
+static fct_test_t*
+fct_test_new(char const *name) {
+   fct_test_t *test =NULL;
+
+   test = (fct_test_t*)malloc(sizeof(fct_test_t));
+   assert( test != NULL && "out of memory");
+   
+   fct_safe_str_cpy(test->name, name, FCT_MAX_NAME);
+     
+   test->failed_chks = nlist_new();
+   test->passed_chks = nlist_new();
+   assert( test->failed_chks != NULL && "out of memory");
+   assert( test->passed_chks != NULL && "out of memory");
+
+   return test;
+}
+
+
+static nbool_t
+fct_test__is_pass(fct_test_t const *test)
+{
+   assert( test != NULL );
+   return nlist__size(test->failed_chks) == 0;   
+}
+
+
+static void
+fct_test__add(fct_test_t *test, fctchk_t *chk)
+{
+
+   assert( test != NULL );
+   assert( chk != NULL );
+
+   if ( fctchk__is_pass(chk) )
+   {
+      nlist__append(test->passed_chks, (void*)chk);
+   }
+   else
+   {
+      nlist__append(test->failed_chks, (void*)chk);
+   }
+}
+
+/* Returns the number of checks made throughout the test. */
+static int
+fct_test__chk_cnt(fct_test_t const *test)
+{
+   assert( test != NULL );
+   return nlist__size(test->failed_chks) + nlist__size(test->passed_chks);
+}
+
+
+static void
+fct_test__del(fct_test_t *test)
+{
+   if (test == NULL ) { return; }
+   nlist__del(test->passed_chks, (on_del_t)fctchk__del);
+   nlist__del(test->failed_chks, (on_del_t)fctchk__del);
+   free(test);
+}
+
+
+/* 
+-----------------------------------------------------------
+TEST SUITE (TS)
+-----------------------------------------------------------
+*/
+
+
+/* The different types of 'modes' that a test suite can be in.
+
+While the test suite is iterating through all the tests, its "State"
+can change from "setup mode", to "test mode" to "tear down" mode. 
+These help to indicate what mode are currently in. Think of it as a 
+basic FSM.
+
+            if the count was 0                               end
+           +--------->---------------------> ending_mode-----+
+           |                                       ^
+           ^                                       |
+start      |                              [if no more tests]
+  |        |                                       |      
+  +-count_mode -> setup_mode -> test_mode -> teardown_mode
+                      ^                           |                         
+                      +-----------<---------------+ 
+*/    
+enum ts_mode {
+   ts_mode_cnt,         /* To setup when done counting. */
+   ts_mode_setup,       /* To test when done setup. */
+   ts_mode_teardown,    /* To ending mode, when no more tests. */
+   ts_mode_test,        /* To tear down mode. */
+   ts_mode_ending,      /* To ... */
+   ts_mode_end          /* .. The End. */
+};
+
+/* Types of modes the test could be in. */
+typedef enum {
+   fct_test_status_SUCCESS,
+   fct_test_status_FAILURE
+} fct_test_status;
+
+
+struct _fct_ts_t {
+   /* For counting our 'current' test number, and the total number of 
+   tests. */
+   int  curr_test_num;
+   int  total_test_num;
+
+   /* Keeps track of the current state of the object while it is walking
+   through its "FSM" */
+   enum ts_mode mode;
+
+   /* The name of the test suite. */
+   char name[FCT_MAX_NAME];
+
+   /* List of tests that where executed within the test suite. */
+   nlist_t *test_list;
+};
+
+
+#define fct_ts__is_setup_mode(ts)     ((ts)->mode == ts_mode_setup)
+#define fct_ts__is_teardown_mode(ts)  ((ts)->mode == ts_mode_teardown)
+#define fct_ts__is_test_mode(ts)      ((ts)->mode == ts_mode_test)
+#define fct_ts__is_ending_mode(ts)    ((ts)->mode == ts_mode_ending)
+#define fct_ts__is_end(ts)            ((ts)->mode == ts_mode_end)
+#define fct_ts__is_cnt_mode(ts)       ((ts)->mode == ts_mode_cnt)
+#define fct_ts__name(ts)              ((ts)->name)
+
+
+static fct_ts_t *
+fct_ts_new(char const *name) {
+   fct_ts_t *ts =NULL;
+   ts = (fct_ts_t*)calloc(1, sizeof(fct_ts_t));
+   assert( ts != NULL );
+
+   fct_safe_str_cpy(ts->name, name, FCT_MAX_NAME);
+   ts->mode = ts_mode_cnt;
+
+   ts->test_list = nlist_new();
+   assert( ts->test_list != NULL && "no memory");
+
+   return ts;
+}
+
+static void
+fct_ts__del(fct_ts_t *ts) {
+   if ( ts == NULL ) { return; }
+   free(ts);
+}
+
+/* Flag a test suite as complete. It will no longer accept any more tests. */
+#define fct_ts__end(_TS_)  ((_TS_)->mode == ts_mode_end)
+
+
+static nbool_t
+fct_ts__is_more_tests(fct_ts_t const *ts) {
+   assert( ts != NULL );
+   assert( !fct_ts__is_end(ts) );
+   return ts->curr_test_num < ts->total_test_num;
+}
+
+
+/* Indicates that we have started a test case. */
+static void
+fct_ts__test_begin(fct_ts_t *ts) {
+   assert( !fct_ts__is_end(ts) );
+   ++(ts->curr_test_num);
+}
+
+
+/* Takes OWNERSHIP of a test object, and warehouses it for later stat
+generation. */
+static void
+fct_ts__add_test(fct_ts_t *ts, fct_test_t *test) {
+   assert( ts != NULL && "invalid arg");
+   assert( test != NULL && "invalid arg");
+   assert( !fct_ts__is_end(ts) );
+   nlist__append(ts->test_list, test);
+}
+
+
+static void
+fct_ts__test_end(fct_ts_t *ts) {
+   assert( ts != NULL );
+   assert( fct_ts__is_test_mode(ts) && "not in test mode, can't end!" );
+
+   /* After a test has completed, move to teardown mode. */
+   ts->mode = ts_mode_teardown;
+}
+
+
+/* Increments the internal count by 1. */
+static void
+fct_ts__inc_total_test_num(fct_ts_t *ts)
+{
+   assert( ts != NULL );
+   assert( fct_ts__is_cnt_mode(ts) );
+   assert( !fct_ts__is_end(ts) );
+   ++(ts->total_test_num);
+}
+
+
+/* Flags the end of the setup, which implies we are going to move into
+setup mode. You must be already in setup mode for this to work! */
+static void
+fct_ts__setup_end(fct_ts_t *ts)
+{
+   assert( fct_ts__is_setup_mode(ts) );
+   assert( !fct_ts__is_end(ts) );
+   ts->mode = ts_mode_test;
+}
+
+
+/* This cndtn is set when we have iterated through all the tests, and
+there was nothing more to do. */
+static void
+fct_ts__ending(fct_ts_t *ts)
+{
+   // We can only go from 'test-mode' to 'end-down' mode.
+   assert( fct_ts__is_test_mode(ts) );
+   assert( !fct_ts__is_end(ts) );
+   ts->mode = ts_mode_ending;
+}
+
+
+/* Flags the end of the teardown, which implies we are going to move
+into setup mode (for the next 'iteration'). */
+static void
+fct_ts__teardown_end(fct_ts_t *ts)
+{
+    assert( fct_ts__is_teardown_mode(ts) );
+    assert( !fct_ts__is_end(ts) );
+    /* We have to decide if we should keep on testing by moving into tear down 
+    mode or if we have reached the real end and should be moving into the 
+    ending mode. */
+    if ( fct_ts__is_more_tests(ts) ) {
+        ts->mode = ts_mode_setup;
+    }
+    else {
+        ts->mode = ts_mode_ending;
+    }
+}
+
+
+/* Flags the end of the counting, and proceeding to the first setup. 
+Consider the special case when a test suite has NO tests in it, in
+that case we will have a current count that is zero, in which case
+we can skip right to 'ending'. */
+static void
+fct_ts__cnt_end(fct_ts_t *ts)
+{
+   assert( ts != NULL );
+   assert( fct_ts__is_cnt_mode(ts) );
+   assert( !fct_ts__is_end(ts) );
+   if (ts->total_test_num == 0  ) {
+      ts->mode = ts_mode_ending;
+   }
+   else {
+      ts->mode = ts_mode_setup;
+   }
+}
+
+
+static nbool_t
+fct_ts__is_test_cnt(fct_ts_t const *ts, int test_num)
+{
+   assert( ts != NULL );
+   assert( 0 <= test_num );
+   assert( test_num < ts->total_test_num );
+   assert( !fct_ts__is_end(ts) );
+
+   /* As we roll through the tests we increment the count. With this
+   count we can decide if we need to execute a test or not. */
+   return test_num == ts->curr_test_num;
+}
+
+
+/* Returns the # of tests on the FCT TS object. This is the actual
+# of tests executed. */
+static int
+fct_ts__tst_cnt(fct_ts_t const *ts)
+{
+   assert( ts != NULL );
+   assert( !fct_ts__is_end(ts) );
+   return nlist__size(ts->test_list);
+}
+
+
+/* Returns the # of tests in the TS object that passed. */
+static int
+fct_ts__tst_cnt_passed(fct_ts_t const *ts)
+{
+   int tally =0;
+
+   assert( ts != NULL );
+   assert( !fct_ts__is_end(ts) );
+
+   NLIST_FOREACH_BGN(fct_test_t*, test, ts->test_list)
+   {
+      if ( fct_test__is_pass(test) )
+      {
+         tally += 1;
+      }
+   }
+   NLIST_FOREACH_END();
+   return tally;
+}
+
+
+/* Returns the # of checks made throughout a test suite. */
+static int
+fct_ts__chk_cnt(fct_ts_t const *ts)
+{
+   int tally =0;
+
+   assert( ts != NULL );
+   
+   NLIST_FOREACH_BGN(fct_test_t *, test, ts->test_list)
+   {
+      tally += fct_test__chk_cnt(test);
+   }
+   NLIST_FOREACH_END();
+   return tally;
+}
+
+
+/* 
+-------------------------------------------------------- 
+FCT KERNAL
+-------------------------------------------------------- 
+
+The "fctkern" is a singleton that is defined throughout the 
+system. 
+*/
+
+struct _fctkern_t {
+   /* This is an list of loggers that can be used in the fct system. 
+   You/ can attach _MAX_LOGGERS to any framework. */
+   nlist_t *logger_list;
+
+   /* This is a list of prefix's that can be used to determine if a 
+   test is should be run or not. */
+   nlist_t *prefix_list;
+
+   /* This is a list of test suites that where generated throughout the
+   testing process. */
+   nlist_t *ts_list;
+};
+
+
+/* Returns the number of filters defined for the fct kernal. */
+#define fctkern__filter_cnt(_NK_) (nlist__size((_NK_)->prefix_list))
+
+
+static void
+fctkern__add_logger(fctkern_t *fct, fct_logger_i *logger_owns)
+{
+   assert(fct != NULL && "invalid arg");
+   assert(logger_owns != NULL && "invalid arg");
+   nlist__append(fct->logger_list, logger_owns);
+   assert( fct->logger_list != NULL && "memory check");
+}
+
+/* Appends a prefix filter that is used to determine if a test can
+be executed or not. If the test starts with the same characters as
+the prefix, then it should be "runnable". The prefix filter must be
+a non-NULL, non-Blank string. */
+static void
+fctkern__add_prefix_filter(fctkern_t const *fct, char const *prefix_filter)
+{
+   char *filter =NULL;
+   int filter_len =0;
+
+   assert( fct != NULL && "invalid arg" );
+   assert( prefix_filter != NULL && "invalid arg" );
+   assert( strlen(prefix_filter) > 0 && "invalid arg" );
+
+   /* First we make a copy of the prefix, then we store it away
+   in our little list. */
+   filter_len = strlen(prefix_filter);
+   filter = (char*)malloc(sizeof(char)*(filter_len+1));
+   strncpy(filter, prefix_filter, filter_len);
+   filter[filter_len] = '\0';
+
+   nlist__append(fct->prefix_list, (void*)filter);
+}
+
+
+/* Parses the command line and sets up the framework. The argc and argv 
+should be directly from the program's  main. */
+static void
+fctkern_init(fctkern_t *nk, int argc, char *argv[])
+{
+   fct_logger_i *standard_logger = NULL;
+   int arg_i =0;
+
+   assert( nk != NULL );
+
+   memset(nk, 0, sizeof(fctkern_t));
+
+   nk->logger_list = nlist_new();
+   nk->prefix_list = nlist_new();
+   nk->ts_list = nlist_new();
+
+   /* Low-budget memory check for now. */
+   assert( nk->logger_list != NULL );
+   assert( nk->prefix_list != NULL );
+   assert( nk->ts_list != NULL );
+
+   standard_logger = (fct_logger_i*) fct_standard_logger__new();
+   assert( standard_logger != NULL && "no memory!");
+
+   fctkern__add_logger(nk, standard_logger);   
+   standard_logger = NULL;   /* Owned by the nk list. */
+
+   /* Our basic parser. For now we just take each 'argv' and assume
+   that it is a prefix filter. Notice we start at argument 1, since
+   we don't care about the *name* of the program. */
+   for ( arg_i =1; arg_i < argc; ++arg_i )
+   {
+      fctkern__add_prefix_filter(nk, argv[arg_i]);
+   }
+}
+
+
+/* Takes OWNERSHIP of the test suite after we have finished executing
+its contents. This way we can build up all kinds of summaries at the end
+of a run. */
+static void
+fctkern__add_ts(fctkern_t *nk, fct_ts_t *ts) {
+   assert( nk != NULL );
+   assert( ts != NULL );
+   nlist__append(nk->ts_list, ts);
+}
+
+
+
+/* Returns FCT_TRUE if the supplied test_name passes the filters set on
+this test suite. If there are no filters, we return FCT_TRUE always. */
+static nbool_t
+fctkern__pass_filter(fctkern_t *nk, char const *test_name) {
+   int prefix_i =0;
+   int prefix_list_size =0;
+
+   assert( nk != NULL && "invalid arg");
+   assert( test_name != NULL );
+   assert( strlen(test_name) > 0 );
+
+   prefix_list_size = fctkern__filter_cnt(nk);
+   
+   /* If there is no filter list, then we return FCT_TRUE always. */
+   if ( prefix_list_size == 0 ) {
+      return FCT_TRUE;
+   }   
+
+   /* Iterate through the prefix filter list, and see if we have
+   anything that does not pass. All we require is ONE item that
+   passes the test in order for us to succeed here. */
+   for ( prefix_i = 0; prefix_i != prefix_list_size; ++prefix_i ) {
+      char const *prefix = (char const*)nlist__at(nk->prefix_list, prefix_i);
+      nbool_t pass = fct_filter_pass(prefix, test_name);
+      if ( pass ) {
+         return FCT_TRUE;
+      }
+   }
+
+   /* Otherwise, we never managed to find a prefix that satisfied the 
+   supplied test name. Therefore we have failed to pass to the filter 
+   list test. */
+   return FCT_FALSE;
+}
+
+
+/* Returns the number of tests that were performed. */
+static int
+fctkern__tst_cnt(fctkern_t const *nk)
+{
+   int tally =0;
+   assert( nk != NULL );
+
+   NLIST_FOREACH_BGN(fct_ts_t *, ts, nk->ts_list)
+   {
+      tally += fct_ts__tst_cnt(ts);
+   }
+   NLIST_FOREACH_END();
+   return tally;
+}
+
+/* Returns the number of tests that passed. */
+static int
+fctkern__tst_cnt_passed(fctkern_t const *nk)
+{
+   int tally =0;
+   assert( nk != NULL );
+
+   NLIST_FOREACH_BGN(fct_ts_t*, ts, nk->ts_list)
+   {
+      tally += fct_ts__tst_cnt_passed(ts);
+   }
+   NLIST_FOREACH_END();
+
+   return tally;
+}
+
+
+/* Returns the number of tests that failed. */
+static int
+fctkern__tst_cnt_failed(fctkern_t const *nk)
+{
+   /* Keep it simple for now and just do a little math. */
+   int total =0;
+   int passed =0;
+   int failed =0;
+
+   assert( nk != NULL );
+
+   total = fctkern__tst_cnt(nk);
+   passed = fctkern__tst_cnt_passed(nk);
+
+   failed = total - passed;
+
+   return failed;
+}
+
+
+/* Returns the number of checks made throughout the entire test. */
+static int
+fctkern__chk_cnt(fctkern_t const *nk)
+{
+   int tally =0;
+   assert( nk != NULL );
+
+   NLIST_FOREACH_BGN(fct_ts_t *, ts, nk->ts_list)
+   {
+      tally += fct_ts__chk_cnt(ts);
+   }
+   NLIST_FOREACH_END();
+   return tally;
+}
+
+
+/* Indicates the very end of all the tests. */
+static void
+fctkern__end(fctkern_t *fct)
+{
+   fct_unused(fct);
+}
+
+
+/* Cleans up the contents of a fctkern. NULL does nothing. */
+static void
+fctkern__final(fctkern_t *fct) 
+{
+   if ( fct == NULL ) { return; }
+
+   nlist__del(fct->logger_list, (on_del_t)fct_logger__del);
+
+   /* The prefix list is a list of malloc'd strings. */
+   nlist__del(fct->prefix_list, (on_del_t)free);
+
+   nlist__del(fct->ts_list, (on_del_t)fct_ts__del);
+}
+
+
+static void
+fctkern__log_suite_start(fctkern_t *kern, fct_ts_t const *ts)
+{
+   assert( kern != NULL );
+   assert( ts != NULL );
+   NLIST_FOREACH_BGN(fct_logger_i*, logger, kern->logger_list)
+   {
+      fct_logger__on_test_suite_start(logger, ts);
+   }
+   NLIST_FOREACH_END();
+}
+
+
+static void
+fctkern__log_suite_end(fctkern_t *kern, fct_ts_t const *ts)
+{
+   assert( kern != NULL );
+   assert( ts != NULL );
+   NLIST_FOREACH_BGN(fct_logger_i*, logger, kern->logger_list)
+   {
+      fct_logger__on_test_suite_end(logger, ts);
+   }
+   NLIST_FOREACH_END();
+}
+
+
+static void
+fctkern__log_chk(fctkern_t *kern, fctchk_t const *chk)
+{
+   assert( kern != NULL );
+   assert( chk != NULL );
+  
+   NLIST_FOREACH_BGN(fct_logger_i*, logger, kern->logger_list)
+   {
+      fct_logger__on_cndtn(logger, chk);
+   }
+   NLIST_FOREACH_END();
+}
+
+
+/* Called whenever a test is started. */
+static void
+fctkern__log_test_start(fctkern_t *kern, fct_test_t const *test)
+{
+   assert( kern != NULL );
+   assert( test != NULL );
+   NLIST_FOREACH_BGN(fct_logger_i*, logger, kern->logger_list)
+   {
+      fct_logger__on_test_start(logger, test);
+   }
+   NLIST_FOREACH_END();
+}
+
+
+static void
+fctkern__log_test_end(fctkern_t *kern, fct_test_t const *test)
+{
+   assert( kern != NULL );
+   assert( test != NULL );
+   NLIST_FOREACH_BGN(fct_logger_i*, logger, kern->logger_list)
+   {
+      fct_logger__on_test_end(logger, test);
+   }
+   NLIST_FOREACH_END();
+}
+
+
+static void
+fctkern__log_start(fctkern_t *kern)
+{
+   assert( kern != NULL );
+   NLIST_FOREACH_BGN(fct_logger_i*, logger, kern->logger_list)
+   {
+      fct_logger__on_fct_start(logger, kern);
+   }
+   NLIST_FOREACH_END();
+}
+
+
+static void
+fctkern__log_end(fctkern_t *kern)
+{
+   assert( kern != NULL );
+   NLIST_FOREACH_BGN(fct_logger_i*, logger, kern->logger_list)
+   {
+      fct_logger__on_fct_end(logger, kern);
+   }
+   NLIST_FOREACH_END();
+}
+
+
+/*
+-----------------------------------------------------------
+LOGGER INTERFACE
+
+Defines an interface to a logging system. A logger 
+must define the following functions in order to hook 
+into the logging system.
+
+See the "Standard Logger" and "Minimal Logger" as examples
+of the implementation.
+-----------------------------------------------------------
+*/
+
+typedef void (*fct_logger_on_cndtn_fn)(fct_logger_i *self, 
+                                       fctchk_t const *chk);
+#define _fct_logger_head \
+   fct_logger_on_cndtn_fn on_cndtn;\
+   void (*on_test_start)(fct_logger_i *logger, fct_test_t const *test);\
+   void (*on_test_end)(fct_logger_i *logger, fct_test_t const *test);\
+   void (*on_test_suite_start)(fct_logger_i *logger, fct_ts_t const *ts);\
+   void (*on_test_suite_end)(fct_logger_i *logger, fct_ts_t const *ts);\
+   void (*on_fct_start)(fct_logger_i *logger, fctkern_t const *kern);\
+   void (*on_fct_end)(fct_logger_i *logger, fctkern_t const *kern);\
+   void (*on_delete)(fct_logger_i *logger)\
+
+struct _fct_logger_i {
+   _fct_logger_head;
+};
+
+
+/* Initializes the elements of a logger interface so they are at their 
+standard values. */
+static void
+fct_logger__init(fct_logger_i *logger)
+{
+   assert( logger != NULL );
+   logger->on_cndtn =NULL;
+   logger->on_test_start =NULL;
+   logger->on_test_end =NULL;
+   logger->on_test_suite_start =NULL;
+   logger->on_test_suite_end =NULL;
+   logger->on_fct_start =NULL;
+   logger->on_fct_end =NULL;
+   logger->on_delete =NULL;
+}
+
+
+static void
+fct_logger__del(fct_logger_i *logger)
+{
+   if ( logger == NULL ) { return; }
+   if ( logger->on_delete) { logger->on_delete(logger); }
+}
+
+
+static void
+fct_logger__on_test_start(fct_logger_i *logger, fct_test_t const *test)
+{
+   assert( logger != NULL && "invalid arg");
+   assert( test != NULL && "invalid arg");
+
+   if ( logger->on_test_start != NULL )
+   {
+      logger->on_test_start(logger, test);
+   }
+}
+
+
+static void
+fct_logger__on_test_end(fct_logger_i *logger, fct_test_t const *test)
+{
+   assert( logger != NULL && "invalid arg");
+   assert( test != NULL && "invalid arg");
+
+   if ( logger->on_test_end != NULL )
+   {
+      logger->on_test_end(logger, test);
+   }
+}
+
+
+static void
+fct_logger__on_test_suite_start(fct_logger_i *logger, fct_ts_t const *ts)
+{
+   assert( logger != NULL && "invalid arg");
+   assert( ts != NULL && "invalid arg");
+
+   if ( logger->on_test_suite_start != NULL )
+   {
+      logger->on_test_suite_start(logger, ts);
+   }
+}
+
+
+static void
+fct_logger__on_test_suite_end(fct_logger_i *logger, fct_ts_t const *ts)
+{
+   assert( logger != NULL && "invalid arg");
+   assert( ts != NULL && "invalid arg");
+
+   if ( logger->on_test_suite_end != NULL )
+   {
+      logger->on_test_suite_end(logger, ts);
+   }
+}
+
+
+static void
+fct_logger__on_cndtn(fct_logger_i *logger, fctchk_t const *chk)
+{
+   assert( logger != NULL && "invalid arg");
+   assert( chk != NULL && "invalid arg");
+
+   if ( logger->on_cndtn ) 
+   {
+      logger->on_cndtn(logger, chk);
+   }
+}                        
+
+
+/* When we start all our tests. */
+static void
+fct_logger__on_fct_start(fct_logger_i *logger, fctkern_t const *kern)
+{
+   assert( logger != NULL );
+   assert( kern != NULL );
+
+   if ( logger->on_fct_start != NULL ) 
+   {
+      logger->on_fct_start(logger, kern);
+   }
+}
+
+
+/* When we have reached the end of ALL of our testing. */
+static void
+fct_logger__on_fct_end(fct_logger_i *logger, fctkern_t const *kern)
+{
+   assert( logger != NULL );
+   assert( kern != NULL );
+
+   if ( logger->on_fct_end )
+   {
+      logger->on_fct_end(logger, kern);
+   }
+}
+
+
+
+/*
+-----------------------------------------------------------
+MINIMAL LOGGER
+-----------------------------------------------------------
+*/
+
+/* Minimal logger, reports the minimum amount of information needed
+to determine "something is happening". */
+struct _fct_minimal_logger_t {
+   _fct_logger_head;
+};
+
+
+static void 
+fct_minimal_logger__on_cndtn(fct_logger_i *self, fctchk_t const *chk)
+{
+   fct_unused(self);   
+   printf(fctchk__is_pass(chk) ? "." : "!");
+}
+
+
+static void
+fct_minimal_logger__del(fct_logger_i *self)
+{
+   free(self);
+}
+
+
+static fct_minimal_logger_t *
+fct_minimal_logger__new(void)
+{
+   fct_minimal_logger_t *self = (fct_minimal_logger_t*)\
+				calloc(1,sizeof(fct_minimal_logger_t));
+   if ( self == NULL ) { return NULL; }
+
+   fct_logger__init((fct_logger_i*)self);
+
+   self->on_cndtn = fct_minimal_logger__on_cndtn;
+   self->on_delete = fct_minimal_logger__del;
+   return self;
+}
+
+
+/*
+-----------------------------------------------------------
+STANDARD LOGGER
+-----------------------------------------------------------
+*/
+
+struct _fct_standard_logger_t {
+   _fct_logger_head;
+
+   /* Start time. For now we use the low-accuracy time_t version. */
+   fct_timer_t timer;
+
+   /* A list of char*'s that needs to be cleaned up. */
+   nlist_t *failed_cndtns_list;
+};
+
+
+/* When a failure occurrs, we will record the details so we can display
+them when the log "finishes" up. */
+static void
+fct_standard_logger__on_cndtn(fct_logger_i *logger_, fctchk_t const *chk)
+{
+   fct_standard_logger_t *logger = (fct_standard_logger_t*)logger_;
+   
+   assert( logger != NULL );
+   assert( chk != NULL );
+
+   /* Only record failures. */
+   if ( !fctchk__is_pass(chk) )
+   {
+      /* For now we will truncate the string to some set amount, later
+      we can work out a dynamic string object. */
+      char *str = (char*)malloc(sizeof(char)*FCT_MAX_LOG_LINE);
+      assert( str != NULL );
+      
+      fct_snprintf(
+         str, 
+         FCT_MAX_LOG_LINE, 
+         "%s(%d): %s", 
+         fctchk__file(chk),
+         fctchk__lineno(chk),
+         fctchk__cndtn(chk)
+         );
+
+      /* Append it to the listing ... */
+      nlist__append(logger->failed_cndtns_list, (void*)str);
+   }  
+}
+
+
+static void
+fct_standard_logger__on_test_start(fct_logger_i *logger_, 
+                                   fct_test_t const *test)
+{
+   fct_unused(logger_);
+   printf("%s ... ", fct_test__name(test));
+}
+
+
+static void
+fct_standard_logger__on_test_end(fct_logger_i *logger_, 
+                                   fct_test_t const *test)
+{
+   nbool_t is_pass;
+   fct_unused(logger_);
+
+   is_pass = fct_test__is_pass(test);
+   printf("%s\n", (is_pass) ? "PASS" : "FAIL" );
+}
+
+
+static void
+fct_standard_logger__on_test_suite_start(fct_logger_i *logger_, 
+                                         fct_ts_t const *ts)
+{
+   fct_unused(logger_);
+   fct_unused(ts);
+}
+
+
+static void
+fct_standard_logger__on_test_suite_end(fct_logger_i *logger_, 
+                                         fct_ts_t const *ts)
+{
+   fct_unused(logger_);
+   fct_unused(ts);
+}
+
+
+static void
+fct_standard_logger__on_fct_start(fct_logger_i *logger_, 
+                                  fctkern_t const *nk)
+{
+   fct_standard_logger_t *logger = (fct_standard_logger_t*)logger_;
+   fct_unused(nk);
+   fct_timer__start(&(logger->timer));
+}
+
+
+static void
+fct_standard_logger__on_fct_end(fct_logger_i *logger_, fctkern_t const *nk)
+{
+   fct_standard_logger_t *logger = (fct_standard_logger_t*)logger_;
+   nbool_t is_success =1;
+   double elasped_time =0;
+   int num_tests =0;
+   int num_passed =0;
+
+   fct_timer__stop(&(logger->timer));
+     
+   is_success = nlist__size(logger->failed_cndtns_list) ==0;
+
+   if (  !is_success )
+   {
+      printf("\n--------------------------------------------------------\n");
+      printf("FAILED TESTS\n\n");
+
+      NLIST_FOREACH_BGN(char *, cndtn_str, logger->failed_cndtns_list)
+      {
+         printf("%s\n", cndtn_str);
+      }
+      NLIST_FOREACH_END();
+
+      printf("\n");
+   }
+
+   printf("\n--------------------------------------------------------\n");
+
+   num_tests = fctkern__tst_cnt(nk);
+   num_passed = fctkern__tst_cnt_passed(nk);
+
+   printf(
+      "%s (%d/%d tests", 
+      (is_success) ? "PASSED" : "FAILED",
+      num_passed,
+      num_tests
+   );
+
+   elasped_time = fct_timer__duration(&(logger->timer));
+   if ( elasped_time > 0.0000001 )
+   {
+      printf(" in %.6fs)\n", elasped_time);
+   }
+   else
+   {
+      /* Don't bother displaying the time to execute. */
+      printf(")\n");
+   }
+}
+
+
+static void
+fct_standard_logger__del(fct_logger_i *logger_)
+{
+   fct_standard_logger_t *logger = (fct_standard_logger_t*)logger_;
+
+   NLIST_FOREACH_BGN(char *, cndtn_str, logger->failed_cndtns_list)
+   {
+      free(cndtn_str);
+   }
+   NLIST_FOREACH_END();
+
+   free(logger);
+   logger_ =NULL;
+}
+
+
+fct_standard_logger_t *
+fct_standard_logger__new(void)
+{
+   fct_standard_logger_t *logger = (fct_standard_logger_t *)calloc(
+		   1, sizeof(fct_standard_logger_t)
+		   );
+   if ( logger == NULL ) 
+   { 
+      return NULL; 
+   }
+   fct_logger__init((fct_logger_i*)logger);
+   logger->on_cndtn = fct_standard_logger__on_cndtn;
+   logger->on_test_start = fct_standard_logger__on_test_start;
+   logger->on_test_end = fct_standard_logger__on_test_end;
+   logger->on_test_suite_start = fct_standard_logger__on_test_suite_start;
+   logger->on_test_suite_end = fct_standard_logger__on_test_suite_end;
+   logger->on_fct_start = fct_standard_logger__on_fct_start;
+   logger->on_fct_end = fct_standard_logger__on_fct_end;
+   logger->on_delete = fct_standard_logger__del;
+
+   logger->failed_cndtns_list = nlist_new();
+   assert( logger->failed_cndtns_list != NULL );
+   
+   fct_timer__init(&(logger->timer));
+
+   return logger;
+}
+
+
+
+/*
+------------------------------------------------------------
+MAGIC MACROS
+------------------------------------------------------------
+*/
+
+#define FCT_BGN() \
+int \
+main(int argc, char *argv[])\
+{\
+   fctkern_t fctkern__;\
+   fctkern_init(&fctkern__, argc, argv);\
+   fctkern__log_start(&fctkern__);
+
+
+#define FCT_END()\
+   {\
+      int num_failed__ =0;\
+      num_failed__ = fctkern__tst_cnt_failed((&fctkern__));\
+      fctkern__log_end(&fctkern__);\
+      fctkern__end(&fctkern__);\
+      fctkern__final(&fctkern__);\
+      return num_failed__;\
+   }\
+}
+
+#define FCT_FIXTURE_SUITE_BGN(_NAME_) \
+   {\
+      fct_ts_t *ts__ = fct_ts_new( #_NAME_ );\
+      fctkern__log_suite_start((&fctkern__), ts__);\
+      for (;;)\
+      {\
+         int fct_test_num__ = -1;\
+         _fct_cmt("Strict compiler warnings will complain in 'blank' suites.")\
+         _fct_cmt("so we are going to do a 'noop' to trick them.")\
+         fct_test_num__ = fct_test_num__;\
+         if ( fct_ts__is_ending_mode(ts__) )\
+         {\
+            _fct_cmt("flag the test suite as complete.");\
+            fct_ts__end(ts__);\
+            break;\
+         }
+
+
+/*  Closes off a "Fixture" test suite. */
+#define FCT_FIXTURE_SUITE_END() \
+         if ( fct_ts__is_cnt_mode(ts__) )\
+         {\
+            fct_ts__cnt_end(ts__);\
+         }\
+      }\
+      fctkern__add_ts((&fctkern__), ts__);\
+      fctkern__log_suite_end((&fctkern__), ts__);\
+      ts__ = NULL;\
+   }
+
+
+
+#define FCT_SETUP_BGN()\
+   if ( fct_ts__is_setup_mode(ts__) ) {
+
+#define FCT_SETUP_END() \
+   fct_ts__setup_end(ts__); }
+
+#define FCT_TEARDOWN_BGN() \
+   if ( fct_ts__is_teardown_mode(ts__) ) {\
+
+#define FCT_TEARDOWN_END() \
+   fct_ts__teardown_end(ts__); \
+   continue; \
+   }
+
+/* Lets you create a test suite, where maybe you don't want a fixture. We
+do it by 'stubbing' out the setup/teardown logic. */
+#define FCT_SUITE_BGN(Name) \
+   FCT_FIXTURE_SUITE_BGN(Name) {\
+   FCT_SETUP_BGN() {_fct_cmt("stubbed"); } FCT_SETUP_END()\
+   FCT_TEARDOWN_BGN() {_fct_cmt("stubbed");} FCT_TEARDOWN_END()\
+
+#define FCT_SUITE_END() } FCT_FIXTURE_SUITE_END()
+
+/* Depending on whether or not we are counting the tests, we will have to 
+first determine if the test is the "current" count. Then we have to determine
+if we can pass the filter. Finally we will execute everything so that when a 
+check fails, we can "break" out to the end of the test. */
+#define FCT_TEST_BGN(_NAME_) \
+         {\
+            char const *test_name__ = #_NAME_;\
+            ++fct_test_num__;\
+            if ( fct_ts__is_cnt_mode(ts__) )\
+            {\
+               fct_ts__inc_total_test_num(ts__);\
+            }\
+            else if ( fct_ts__is_test_mode(ts__) \
+                      && fct_ts__is_test_cnt(ts__, fct_test_num__) )\
+            {\
+               int is_pass__;\
+               is_pass__ = FCT_FALSE;\
+               fct_ts__test_begin(ts__);\
+               if ( fctkern__pass_filter(&fctkern__,  test_name__ ) )\
+               {\
+                  fct_test_t *test__ = fct_test_new( test_name__ );\
+                  fctkern__log_test_start(&fctkern__, test__);\
+                  for (;;) \
+                  {
+
+#define FCT_TEST_END() \
+                     break;\
+                  }\
+               fct_ts__add_test(ts__, test__);\
+               fctkern__log_test_end(&fctkern__, test__);\
+               }\
+               fct_ts__test_end(ts__);\
+               continue;\
+            }\
+         }
+
+
+
+/*
+---------------------------------------------------------
+CHECKING MACROS
+---------------------------------------------------------- 
+
+For now we only have the one "positive" check macro. In the future I plan
+to add more macros that check for different types of common conditions.
+*/
+
+#define fct_chk(_CNDTN_) \
+   {\
+      fctchk_t *chk =NULL;\
+      is_pass__ = (_CNDTN_);\
+      chk = fctchk_new(#_CNDTN_, __FILE__, __LINE__, is_pass__);\
+      fct_test__add(test__, chk);\
+      fctkern__log_chk(&fctkern__, chk);\
+      if ( !is_pass__ ) { break; }\
+   }
+
+
+/*
+---------------------------------------------------------
+GUT CHECK MACROS
+---------------------------------------------------------- 
+
+The following macros are used to help check the "guts" of
+the FCT, and to confirm that it all works according to spec.
+*/
+
+/* Generates a message to STDERR and exits the application with a 
+non-zero number. */
+#define _FCT_GUTCHK(_CNDTN_) \
+   if ( !(_CNDTN_) ) {\
+      fprintf(stderr, "gutchk fail: '"  #_CNDTN_ "' was not true.\n");\
+      exit(1);\
+   }\
+   else {\
+      fprintf(stdout, "gutchk pass:  '" #_CNDTN_ "'\n");\
+   }
+      
+
+/*
+---------------------------------------------------------
+CLOSING STATEMENTS
+---------------------------------------------------------- 
+*/
+
+/* This is defined at the start of the file. We are undefining it
+here so it doesn't conflict with existing. */
+#if defined(WIN32)
+#   undef _CRT_SECURE_NO_WARNINGS
+#endif
+
+#endif /* !FCT_INCLUDED__IMB */
diff --git a/tests/scripts/generate_code.pl b/tests/scripts/generate_code.pl
new file mode 100755
index 0000000..6aa9c05
--- /dev/null
+++ b/tests/scripts/generate_code.pl
@@ -0,0 +1,91 @@
+#!/usr/bin/perl
+#
+
+use strict;
+
+my $suite_dir = shift or die "Missing suite directory";
+my $suite_name = shift or die "Missing suite name";
+my $test_file = $suite_name.".c";
+my $test_helper_file = $suite_dir."/helpers.function";
+my $test_case_file = $suite_dir."/".$suite_name.".function";
+my $test_data_file = $suite_dir."/".$suite_name.".data";
+
+open(TEST_DATA, "$test_data_file") or die "Opening test cases '$test_data_file': $!";
+
+my $line_separator = $/;
+undef $/;
+
+open(TEST_HELPERS, "$test_helper_file") or die "Opening test helpers '$test_helper_file': $!";
+my $test_helpers = <TEST_HELPERS>;
+close(TEST_HELPERS);
+
+open(TEST_CASES, "$test_case_file") or die "Opening test cases '$test_case_file': $!";
+my $test_cases = <TEST_CASES>;
+close(TEST_CASES);
+my ( $suite_header ) = $test_cases =~ /BEGIN_HEADER\n(.*?)\nEND_HEADER/s;
+
+$/ = $line_separator;
+
+open(TEST_FILE, ">$test_file") or die "Opening destination file '$test_file': $!";
+print TEST_FILE << "END";
+#include "fct.h"
+$suite_header
+
+$test_helpers
+
+FCT_BGN()
+{
+    FCT_SUITE_BGN($suite_name)
+    {
+END
+
+while (my $line = <TEST_DATA>)
+{
+    my $description = $line;
+    $line = <TEST_DATA>;
+    my $command_line = $line;
+    $line = <TEST_DATA>;
+
+    my $test_name = $description;
+    $test_name =~ tr/A-Z \-/a-z__/;
+    $test_name =~ tr/a-z0-9_//cd;
+
+    my ( $case, $var_value ) = $command_line =~ /^([\w_]+):(.*)$/;
+
+    my ( $var_def, $case_code ) = $test_cases =~ /BEGIN_CASE\n$case:([^\n]*)\n(.*?)\nEND_CASE/s;
+
+    my @var_def_arr = split(/:/, $var_def);
+    my @var_value_arr = split(/:/, $var_value);
+
+    while (@var_def_arr)
+    {
+        my $def = shift @var_def_arr;
+        my $val = shift @var_value_arr;
+
+        $case_code =~ s/\{$def\}/$val/g;
+    }
+    $case_code = "int ${test_name}_code_present = 0;\nTEST_ASSERT( ${test_name}_code_present == 1 );" if ($case_code =~ /^\s*$/);
+
+    $case_code =~ s/TEST_ASSERT/fct_chk/g;
+    $case_code =~ s/TEST_EQUALS/fct_chk/g;
+
+    $case_code =~ s/^/        /gm;
+
+
+    print TEST_FILE << "END";
+        FCT_TEST_BGN($test_name)
+$case_code
+        FCT_TEST_END();
+
+END
+}
+
+print TEST_FILE << "END";
+    }
+    FCT_SUITE_END();
+}
+FCT_END();
+END
+
+close(TEST_DATA);
+close(TEST_FILE);
diff --git a/tests/suites/helpers.function b/tests/suites/helpers.function
new file mode 100644
index 0000000..6717292
--- /dev/null
+++ b/tests/suites/helpers.function
@@ -0,0 +1,57 @@
+int unhexify(unsigned char *obuf, const char *ibuf)
+{
+    unsigned char c, c2;
+    int len = strlen(ibuf) / 2;
+    assert(!(strlen(ibuf) %1)); // must be even number of bytes
+
+    while (*ibuf != 0)
+    {
+        c = *ibuf++;
+        if( c >= '0' && c <= '9' )
+            c -= '0';
+        else if( c >= 'a' && c <= 'f' )
+            c -= 'a' - 10;
+        else if( c >= 'A' && c <= 'F' )
+            c -= 'A' - 10;
+        else
+            assert( 0 );
+
+        c2 = *ibuf++;
+        if( c2 >= '0' && c2 <= '9' )
+            c2 -= '0';
+        else if( c2 >= 'a' && c2 <= 'f' )
+            c2 -= 'a' - 10;
+        else if( c2 >= 'A' && c2 <= 'F' )
+            c2 -= 'A' - 10;
+        else
+            assert( 0 );
+
+        *obuf++ = ( c << 4 ) | c2;
+    }
+
+    return len;
+}
+
+void hexify(unsigned char *obuf, const unsigned char *ibuf, int len)
+{
+    unsigned char l, h;
+
+    while (len != 0)
+    {
+        h = (*ibuf) / 16;
+        l = (*ibuf) % 16;
+
+        if( h < 10 )
+            *obuf++ = '0' + h;
+        else
+            *obuf++ = 'a' + h - 10;
+
+        if( l < 10 )
+            *obuf++ = '0' + l;
+        else
+            *obuf++ = 'a' + l - 10;
+
+        ++ibuf;
+        len--;
+    }
+}
diff --git a/tests/suites/test_suite_aes.data b/tests/suites/test_suite_aes.data
new file mode 100644
index 0000000..ddfddcf
--- /dev/null
+++ b/tests/suites/test_suite_aes.data
@@ -0,0 +1,662 @@
+AES-128-ECB Encrypt NIST KAT #1
+aes_encrypt_ecb:"00000000000000000000000000000000":"f34481ec3cc627bacd5dc3fb08f273e6":"0336763e966d92595a567cc9ce537f5e"
+
+AES-128-ECB Encrypt NIST KAT #2
+aes_encrypt_ecb:"00000000000000000000000000000000":"9798c4640bad75c7c3227db910174e72":"a9a1631bf4996954ebc093957b234589"
+
+AES-128-ECB Encrypt NIST KAT #3
+aes_encrypt_ecb:"00000000000000000000000000000000":"96ab5c2ff612d9dfaae8c31f30c42168":"ff4f8391a6a40ca5b25d23bedd44a597"
+
+AES-128-ECB Encrypt NIST KAT #4
+aes_encrypt_ecb:"e0000000000000000000000000000000":"00000000000000000000000000000000":"72a1da770f5d7ac4c9ef94d822affd97"
+
+AES-128-ECB Encrypt NIST KAT #5
+aes_encrypt_ecb:"f0000000000000000000000000000000":"00000000000000000000000000000000":"970014d634e2b7650777e8e84d03ccd8"
+
+AES-128-ECB Encrypt NIST KAT #6
+aes_encrypt_ecb:"f8000000000000000000000000000000":"00000000000000000000000000000000":"f17e79aed0db7e279e955b5f493875a7"
+
+AES-128-ECB Encrypt NIST KAT #7
+aes_encrypt_ecb:"fffffffffffff0000000000000000000":"00000000000000000000000000000000":"7b90785125505fad59b13c186dd66ce3"
+
+AES-128-ECB Encrypt NIST KAT #8
+aes_encrypt_ecb:"fffffffffffff8000000000000000000":"00000000000000000000000000000000":"8b527a6aebdaec9eaef8eda2cb7783e5"
+
+AES-128-ECB Encrypt NIST KAT #9
+aes_encrypt_ecb:"fffffffffffffc000000000000000000":"00000000000000000000000000000000":"43fdaf53ebbc9880c228617d6a9b548b"
+
+AES-128-ECB Encrypt NIST KAT #10
+aes_encrypt_ecb:"ffffffffffffffffffffffffffffc000":"00000000000000000000000000000000":"70c46bb30692be657f7eaa93ebad9897"
+
+AES-128-ECB Encrypt NIST KAT #11
+aes_encrypt_ecb:"ffffffffffffffffffffffffffffe000":"00000000000000000000000000000000":"323994cfb9da285a5d9642e1759b224a"
+
+AES-128-ECB Encrypt NIST KAT #12
+aes_encrypt_ecb:"fffffffffffffffffffffffffffff000":"00000000000000000000000000000000":"1dbf57877b7b17385c85d0b54851e371"
+
+AES-128-ECB Encrypt NIST KAT #13
+aes_encrypt_ecb:"00000000000000000000000000000000":"ffffffffffffffc00000000000000000":"3a4d354f02bb5a5e47d39666867f246a"
+
+AES-128-ECB Encrypt NIST KAT #14
+aes_encrypt_ecb:"00000000000000000000000000000000":"ffffffffffffffe00000000000000000":"d451b8d6e1e1a0ebb155fbbf6e7b7dc3"
+
+AES-128-ECB Encrypt NIST KAT #15
+aes_encrypt_ecb:"00000000000000000000000000000000":"fffffffffffffff00000000000000000":"6898d4f42fa7ba6a10ac05e87b9f2080"
+
+AES-128-ECB Encrypt NIST KAT #16
+aes_encrypt_ecb:"00000000000000000000000000000000":"ffffffffffffffffffffffffe0000000":"082eb8be35f442fb52668e16a591d1d6"
+
+AES-128-ECB Encrypt NIST KAT #17
+aes_encrypt_ecb:"00000000000000000000000000000000":"fffffffffffffffffffffffff0000000":"e656f9ecf5fe27ec3e4a73d00c282fb3"
+
+AES-128-ECB Encrypt NIST KAT #18
+aes_encrypt_ecb:"00000000000000000000000000000000":"fffffffffffffffffffffffff8000000":"2ca8209d63274cd9a29bb74bcd77683a"
+
+AES-128-ECB Decrypt NIST KAT #1
+aes_decrypt_ecb:"00000000000000000000000000000000":"db4f1aa530967d6732ce4715eb0ee24b":"ff000000000000000000000000000000"
+
+AES-128-ECB Decrypt NIST KAT #2
+aes_decrypt_ecb:"00000000000000000000000000000000":"a81738252621dd180a34f3455b4baa2f":"ff800000000000000000000000000000"
+
+AES-128-ECB Decrypt NIST KAT #3
+aes_decrypt_ecb:"00000000000000000000000000000000":"77e2b508db7fd89234caf7939ee5621a":"ffc00000000000000000000000000000"
+
+AES-128-ECB Decrypt NIST KAT #4
+aes_decrypt_ecb:"00000000000000000000000000000000":"dc43be40be0e53712f7e2bf5ca707209":"6a118a874519e64e9963798a503f1d35"
+
+AES-128-ECB Decrypt NIST KAT #5
+aes_decrypt_ecb:"00000000000000000000000000000000":"92beedab1895a94faa69b632e5cc47ce":"cb9fceec81286ca3e989bd979b0cb284"
+
+AES-128-ECB Decrypt NIST KAT #6
+aes_decrypt_ecb:"00000000000000000000000000000000":"459264f4798f6a78bacb89c15ed3d601":"b26aeb1874e47ca8358ff22378f09144"
+
+AES-128-ECB Decrypt NIST KAT #7
+aes_decrypt_ecb:"b69418a85332240dc82492353956ae0c":"a303d940ded8f0baff6f75414cac5243":"00000000000000000000000000000000"
+
+AES-128-ECB Decrypt NIST KAT #8
+aes_decrypt_ecb:"71b5c08a1993e1362e4d0ce9b22b78d5":"c2dabd117f8a3ecabfbb11d12194d9d0":"00000000000000000000000000000000"
+
+AES-128-ECB Decrypt NIST KAT #9
+aes_decrypt_ecb:"e234cdca2606b81f29408d5f6da21206":"fff60a4740086b3b9c56195b98d91a7b":"00000000000000000000000000000000"
+
+AES-128-ECB Decrypt NIST KAT #10
+aes_decrypt_ecb:"ffffffffffffffff0000000000000000":"84be19e053635f09f2665e7bae85b42d":"00000000000000000000000000000000"
+
+AES-128-ECB Decrypt NIST KAT #11
+aes_decrypt_ecb:"ffffffffffffffff8000000000000000":"32cd652842926aea4aa6137bb2be2b5e":"00000000000000000000000000000000"
+
+AES-192-ECB Encrypt NIST KAT #1
+aes_encrypt_ecb:"000000000000000000000000000000000000000000000000":"fffffffffffffffffffff80000000000":"156f07767a85a4312321f63968338a01"
+
+AES-192-ECB Encrypt NIST KAT #2
+aes_encrypt_ecb:"000000000000000000000000000000000000000000000000":"fffffffffffffffffffffc0000000000":"15eec9ebf42b9ca76897d2cd6c5a12e2"
+
+AES-192-ECB Encrypt NIST KAT #3
+aes_encrypt_ecb:"000000000000000000000000000000000000000000000000":"fffffffffffffffffffffe0000000000":"db0d3a6fdcc13f915e2b302ceeb70fd8"
+
+AES-192-ECB Encrypt NIST KAT #4
+aes_encrypt_ecb:"000000000000000000000000000000000000000000000000":"51719783d3185a535bd75adc65071ce1":"4f354592ff7c8847d2d0870ca9481b7c"
+
+AES-192-ECB Encrypt NIST KAT #5
+aes_encrypt_ecb:"000000000000000000000000000000000000000000000000":"26aa49dcfe7629a8901a69a9914e6dfd":"d5e08bf9a182e857cf40b3a36ee248cc"
+
+AES-192-ECB Encrypt NIST KAT #6
+aes_encrypt_ecb:"000000000000000000000000000000000000000000000000":"941a4773058224e1ef66d10e0a6ee782":"067cd9d3749207791841562507fa9626"
+
+AES-192-ECB Encrypt NIST KAT #7
+aes_encrypt_ecb:"d2926527e0aa9f37b45e2ec2ade5853ef807576104c7ace3":"00000000000000000000000000000000":"dd619e1cf204446112e0af2b9afa8f8c"
+
+AES-192-ECB Encrypt NIST KAT #8
+aes_encrypt_ecb:"982215f4e173dfa0fcffe5d3da41c4812c7bcc8ed3540f93":"00000000000000000000000000000000":"d4f0aae13c8fe9339fbf9e69ed0ad74d"
+
+AES-192-ECB Encrypt NIST KAT #9
+aes_encrypt_ecb:"98c6b8e01e379fbd14e61af6af891596583565f2a27d59e9":"00000000000000000000000000000000":"19c80ec4a6deb7e5ed1033dda933498f"
+
+AES-192-ECB Encrypt NIST KAT #10
+aes_encrypt_ecb:"fffffffffffffffffffffffffff800000000000000000000":"00000000000000000000000000000000":"8dd274bd0f1b58ae345d9e7233f9b8f3"
+
+AES-192-ECB Encrypt NIST KAT #11
+aes_encrypt_ecb:"fffffffffffffffffffffffffffc00000000000000000000":"00000000000000000000000000000000":"9d6bdc8f4ce5feb0f3bed2e4b9a9bb0b"
+
+AES-192-ECB Encrypt NIST KAT #12
+aes_encrypt_ecb:"fffffffffffffffffffffffffffe00000000000000000000":"00000000000000000000000000000000":"fd5548bcf3f42565f7efa94562528d46"
+
+AES-192-ECB Decrypt NIST KAT #1
+aes_decrypt_ecb:"fffffffffffffffffffffffffffffffff000000000000000":"bb2852c891c5947d2ed44032c421b85f":"00000000000000000000000000000000"
+
+AES-192-ECB Decrypt NIST KAT #2
+aes_decrypt_ecb:"fffffffffffffffffffffffffffffffff800000000000000":"1b9f5fbd5e8a4264c0a85b80409afa5e":"00000000000000000000000000000000"
+
+AES-192-ECB Decrypt NIST KAT #3
+aes_decrypt_ecb:"fffffffffffffffffffffffffffffffffc00000000000000":"30dab809f85a917fe924733f424ac589":"00000000000000000000000000000000"
+
+AES-192-ECB Decrypt NIST KAT #4
+aes_decrypt_ecb:"61257134a518a0d57d9d244d45f6498cbc32f2bafc522d79":"cfe4d74002696ccf7d87b14a2f9cafc9":"00000000000000000000000000000000"
+
+AES-192-ECB Decrypt NIST KAT #5
+aes_decrypt_ecb:"b0ab0a6a818baef2d11fa33eac947284fb7d748cfb75e570":"d2eafd86f63b109b91f5dbb3a3fb7e13":"00000000000000000000000000000000"
+
+AES-192-ECB Decrypt NIST KAT #6
+aes_decrypt_ecb:"ee053aa011c8b428cdcc3636313c54d6a03cac01c71579d6":"9b9fdd1c5975655f539998b306a324af":"00000000000000000000000000000000"
+
+AES-192-ECB Decrypt NIST KAT #7
+aes_decrypt_ecb:"000000000000000000000000000000000000000000000000":"275cfc0413d8ccb70513c3859b1d0f72":"1b077a6af4b7f98229de786d7516b639"
+
+AES-192-ECB Decrypt NIST KAT #8
+aes_decrypt_ecb:"000000000000000000000000000000000000000000000000":"c9b8135ff1b5adc413dfd053b21bd96d":"9c2d8842e5f48f57648205d39a239af1"
+
+AES-192-ECB Decrypt NIST KAT #9
+aes_decrypt_ecb:"000000000000000000000000000000000000000000000000":"4a3650c3371ce2eb35e389a171427440":"bff52510095f518ecca60af4205444bb"
+
+AES-192-ECB Decrypt NIST KAT #10
+aes_decrypt_ecb:"000000000000000000000000000000000000000000000000":"b2099795e88cc158fd75ea133d7e7fbe":"ffffffffffffffffffffc00000000000"
+
+AES-192-ECB Decrypt NIST KAT #11
+aes_decrypt_ecb:"000000000000000000000000000000000000000000000000":"a6cae46fb6fadfe7a2c302a34242817b":"ffffffffffffffffffffe00000000000"
+
+AES-192-ECB Decrypt NIST KAT #12
+aes_decrypt_ecb:"000000000000000000000000000000000000000000000000":"026a7024d6a902e0b3ffccbaa910cc3f":"fffffffffffffffffffff00000000000"
+
+AES-256-ECB Encrypt NIST KAT #1
+aes_encrypt_ecb:"c1cc358b449909a19436cfbb3f852ef8bcb5ed12ac7058325f56e6099aab1a1c":"00000000000000000000000000000000":"352065272169abf9856843927d0674fd"
+
+AES-256-ECB Encrypt NIST KAT #2
+aes_encrypt_ecb:"984ca75f4ee8d706f46c2d98c0bf4a45f5b00d791c2dfeb191b5ed8e420fd627":"00000000000000000000000000000000":"4307456a9e67813b452e15fa8fffe398"
+
+AES-256-ECB Encrypt NIST KAT #3
+aes_encrypt_ecb:"b43d08a447ac8609baadae4ff12918b9f68fc1653f1269222f123981ded7a92f":"00000000000000000000000000000000":"4663446607354989477a5c6f0f007ef4"
+
+AES-256-ECB Encrypt NIST KAT #4
+aes_encrypt_ecb:"0000000000000000000000000000000000000000000000000000000000000000":"0b24af36193ce4665f2825d7b4749c98":"a9ff75bd7cf6613d3731c77c3b6d0c04"
+
+AES-256-ECB Encrypt NIST KAT #5
+aes_encrypt_ecb:"0000000000000000000000000000000000000000000000000000000000000000":"761c1fe41a18acf20d241650611d90f1":"623a52fcea5d443e48d9181ab32c7421"
+
+AES-256-ECB Encrypt NIST KAT #6
+aes_encrypt_ecb:"0000000000000000000000000000000000000000000000000000000000000000":"8a560769d605868ad80d819bdba03771":"38f2c7ae10612415d27ca190d27da8b4"
+
+AES-256-ECB Encrypt NIST KAT #7
+aes_encrypt_ecb:"0000000000000000000000000000000000000000000000000000000000000000":"ffffff80000000000000000000000000":"36aff0ef7bf3280772cf4cac80a0d2b2"
+
+AES-256-ECB Encrypt NIST KAT #8
+aes_encrypt_ecb:"0000000000000000000000000000000000000000000000000000000000000000":"ffffffc0000000000000000000000000":"1f8eedea0f62a1406d58cfc3ecea72cf"
+
+AES-256-ECB Encrypt NIST KAT #9
+aes_encrypt_ecb:"0000000000000000000000000000000000000000000000000000000000000000":"ffffffe0000000000000000000000000":"abf4154a3375a1d3e6b1d454438f95a6"
+
+AES-256-ECB Encrypt NIST KAT #10
+aes_encrypt_ecb:"ffffffffffffffffffffffffffffffffffff8000000000000000000000000000":"00000000000000000000000000000000":"45d089c36d5c5a4efc689e3b0de10dd5"
+
+AES-256-ECB Encrypt NIST KAT #11
+aes_encrypt_ecb:"ffffffffffffffffffffffffffffffffffffc000000000000000000000000000":"00000000000000000000000000000000":"b4da5df4becb5462e03a0ed00d295629"
+
+AES-256-ECB Encrypt NIST KAT #12
+aes_encrypt_ecb:"ffffffffffffffffffffffffffffffffffffe000000000000000000000000000":"00000000000000000000000000000000":"dcf4e129136c1a4b7a0f38935cc34b2b"
+
+AES-256-ECB Decrypt NIST KAT #1
+aes_decrypt_ecb:"fffffffffffffffffffffffffffffffffffffffffffffff00000000000000000":"edf61ae362e882ddc0167474a7a77f3a":"00000000000000000000000000000000"
+
+AES-256-ECB Decrypt NIST KAT #2
+aes_decrypt_ecb:"fffffffffffffffffffffffffffffffffffffffffffffff80000000000000000":"6168b00ba7859e0970ecfd757efecf7c":"00000000000000000000000000000000"
+
+AES-256-ECB Decrypt NIST KAT #3
+aes_decrypt_ecb:"fffffffffffffffffffffffffffffffffffffffffffffffc0000000000000000":"d1415447866230d28bb1ea18a4cdfd02":"00000000000000000000000000000000"
+
+AES-256-ECB Decrypt NIST KAT #4
+aes_decrypt_ecb:"f8be9ba615c5a952cabbca24f68f8593039624d524c816acda2c9183bd917cb9":"a3944b95ca0b52043584ef02151926a8":"00000000000000000000000000000000"
+
+AES-256-ECB Decrypt NIST KAT #5
+aes_decrypt_ecb:"797f8b3d176dac5b7e34a2d539c4ef367a16f8635f6264737591c5c07bf57a3e":"a74289fe73a4c123ca189ea1e1b49ad5":"00000000000000000000000000000000"
+
+AES-256-ECB Decrypt NIST KAT #6
+aes_decrypt_ecb:"6838d40caf927749c13f0329d331f448e202c73ef52c5f73a37ca635d4c47707":"b91d4ea4488644b56cf0812fa7fcf5fc":"00000000000000000000000000000000"
+
+AES-256-ECB Decrypt NIST KAT #7
+aes_decrypt_ecb:"0000000000000000000000000000000000000000000000000000000000000000":"623a52fcea5d443e48d9181ab32c7421":"761c1fe41a18acf20d241650611d90f1"
+
+AES-256-ECB Decrypt NIST KAT #8
+aes_decrypt_ecb:"0000000000000000000000000000000000000000000000000000000000000000":"38f2c7ae10612415d27ca190d27da8b4":"8a560769d605868ad80d819bdba03771"
+
+AES-256-ECB Decrypt NIST KAT #9
+aes_decrypt_ecb:"0000000000000000000000000000000000000000000000000000000000000000":"1bc704f1bce135ceb810341b216d7abe":"91fbef2d15a97816060bee1feaa49afe"
+
+AES-256-ECB Decrypt NIST KAT #10
+aes_decrypt_ecb:"0000000000000000000000000000000000000000000000000000000000000000":"ddc6bf790c15760d8d9aeb6f9a75fd4e":"80000000000000000000000000000000"
+
+AES-256-ECB Decrypt NIST KAT #11
+aes_decrypt_ecb:"0000000000000000000000000000000000000000000000000000000000000000":"0a6bdc6d4c1e6280301fd8e97ddbe601":"c0000000000000000000000000000000"
+
+AES-256-ECB Decrypt NIST KAT #12
+aes_decrypt_ecb:"0000000000000000000000000000000000000000000000000000000000000000":"9b80eefb7ebe2d2b16247aa0efc72f5d":"e0000000000000000000000000000000"
+
+AES-128-CBC Encrypt NIST KAT #1
+aes_encrypt_cbc:"fffffffffffff8000000000000000000":"00000000000000000000000000000000":"00000000000000000000000000000000":"8b527a6aebdaec9eaef8eda2cb7783e5"
+
+AES-128-CBC Encrypt NIST KAT #2
+aes_encrypt_cbc:"fffffffffffffc000000000000000000":"00000000000000000000000000000000":"00000000000000000000000000000000":"43fdaf53ebbc9880c228617d6a9b548b"
+
+AES-128-CBC Encrypt NIST KAT #3
+aes_encrypt_cbc:"fffffffffffffe000000000000000000":"00000000000000000000000000000000":"00000000000000000000000000000000":"53786104b9744b98f052c46f1c850d0b"
+
+AES-128-CBC Encrypt NIST KAT #4
+aes_encrypt_cbc:"e37b1c6aa2846f6fdb413f238b089f23":"00000000000000000000000000000000":"00000000000000000000000000000000":"43c9f7e62f5d288bb27aa40ef8fe1ea8"
+
+AES-128-CBC Encrypt NIST KAT #5
+aes_encrypt_cbc:"6c002b682483e0cabcc731c253be5674":"00000000000000000000000000000000":"00000000000000000000000000000000":"3580d19cff44f1014a7c966a69059de5"
+
+AES-128-CBC Encrypt NIST KAT #6
+aes_encrypt_cbc:"143ae8ed6555aba96110ab58893a8ae1":"00000000000000000000000000000000":"00000000000000000000000000000000":"806da864dd29d48deafbe764f8202aef"
+
+AES-128-CBC Encrypt NIST KAT #7
+aes_encrypt_cbc:"00000000000000000000000000000000":"00000000000000000000000000000000":"6a118a874519e64e9963798a503f1d35":"dc43be40be0e53712f7e2bf5ca707209"
+
+AES-128-CBC Encrypt NIST KAT #8
+aes_encrypt_cbc:"00000000000000000000000000000000":"00000000000000000000000000000000":"cb9fceec81286ca3e989bd979b0cb284":"92beedab1895a94faa69b632e5cc47ce"
+
+AES-128-CBC Encrypt NIST KAT #9
+aes_encrypt_cbc:"00000000000000000000000000000000":"00000000000000000000000000000000":"b26aeb1874e47ca8358ff22378f09144":"459264f4798f6a78bacb89c15ed3d601"
+
+AES-128-CBC Encrypt NIST KAT #10
+aes_encrypt_cbc:"00000000000000000000000000000000":"00000000000000000000000000000000":"ffffffffffffffffffffffc000000000":"90684a2ac55fe1ec2b8ebd5622520b73"
+
+AES-128-CBC Encrypt NIST KAT #11
+aes_encrypt_cbc:"00000000000000000000000000000000":"00000000000000000000000000000000":"ffffffffffffffffffffffe000000000":"7472f9a7988607ca79707795991035e6"
+
+AES-128-CBC Encrypt NIST KAT #12
+aes_encrypt_cbc:"00000000000000000000000000000000":"00000000000000000000000000000000":"fffffffffffffffffffffff000000000":"56aff089878bf3352f8df172a3ae47d8"
+
+AES-128-CBC Decrypt NIST KAT #1
+aes_decrypt_cbc:"ffffffffe00000000000000000000000":"00000000000000000000000000000000":"23f710842b9bb9c32f26648c786807ca":"00000000000000000000000000000000"
+
+AES-128-CBC Decrypt NIST KAT #2
+aes_decrypt_cbc:"fffffffff00000000000000000000000":"00000000000000000000000000000000":"44a98bf11e163f632c47ec6a49683a89":"00000000000000000000000000000000"
+
+AES-128-CBC Decrypt NIST KAT #3
+aes_decrypt_cbc:"fffffffff80000000000000000000000":"00000000000000000000000000000000":"0f18aff94274696d9b61848bd50ac5e5":"00000000000000000000000000000000"
+
+AES-128-CBC Decrypt NIST KAT #4
+aes_decrypt_cbc:"e234cdca2606b81f29408d5f6da21206":"00000000000000000000000000000000":"fff60a4740086b3b9c56195b98d91a7b":"00000000000000000000000000000000"
+
+AES-128-CBC Decrypt NIST KAT #5
+aes_decrypt_cbc:"13237c49074a3da078dc1d828bb78c6f":"00000000000000000000000000000000":"8146a08e2357f0caa30ca8c94d1a0544":"00000000000000000000000000000000"
+
+AES-128-CBC Decrypt NIST KAT #6
+aes_decrypt_cbc:"3071a2a48fe6cbd04f1a129098e308f8":"00000000000000000000000000000000":"4b98e06d356deb07ebb824e5713f7be3":"00000000000000000000000000000000"
+
+AES-128-CBC Decrypt NIST KAT #7
+aes_decrypt_cbc:"00000000000000000000000000000000":"00000000000000000000000000000000":"0336763e966d92595a567cc9ce537f5e":"f34481ec3cc627bacd5dc3fb08f273e6"
+
+AES-128-CBC Decrypt NIST KAT #8
+aes_decrypt_cbc:"00000000000000000000000000000000":"00000000000000000000000000000000":"a9a1631bf4996954ebc093957b234589":"9798c4640bad75c7c3227db910174e72"
+
+AES-128-CBC Decrypt NIST KAT #9
+aes_decrypt_cbc:"00000000000000000000000000000000":"00000000000000000000000000000000":"ff4f8391a6a40ca5b25d23bedd44a597":"96ab5c2ff612d9dfaae8c31f30c42168"
+
+AES-128-CBC Decrypt NIST KAT #10
+aes_decrypt_cbc:"00000000000000000000000000000000":"00000000000000000000000000000000":"f9b0fda0c4a898f5b9e6f661c4ce4d07":"fffffffffffffffffffffffffffffff0"
+
+AES-128-CBC Decrypt NIST KAT #11
+aes_decrypt_cbc:"00000000000000000000000000000000":"00000000000000000000000000000000":"8ade895913685c67c5269f8aae42983e":"fffffffffffffffffffffffffffffff8"
+
+AES-128-CBC Decrypt NIST KAT #12
+aes_decrypt_cbc:"00000000000000000000000000000000":"00000000000000000000000000000000":"39bde67d5c8ed8a8b1c37eb8fa9f5ac0":"fffffffffffffffffffffffffffffffc"
+
+AES-192-CBC Encrypt NIST KAT #1
+aes_encrypt_cbc:"fffffffffffffffffffffffffffffffffffffffffffffe00":"00000000000000000000000000000000":"00000000000000000000000000000000":"ddb505e6cc1384cbaec1df90b80beb20"
+
+AES-192-CBC Encrypt NIST KAT #2
+aes_encrypt_cbc:"ffffffffffffffffffffffffffffffffffffffffffffff00":"00000000000000000000000000000000":"00000000000000000000000000000000":"5674a3bed27bf4bd3622f9f5fe208306"
+
+AES-192-CBC Encrypt NIST KAT #3
+aes_encrypt_cbc:"ffffffffffffffffffffffffffffffffffffffffffffff80":"00000000000000000000000000000000":"00000000000000000000000000000000":"b687f26a89cfbfbb8e5eeac54055315e"
+
+AES-192-CBC Encrypt NIST KAT #4
+aes_encrypt_cbc:"25a39dbfd8034f71a81f9ceb55026e4037f8f6aa30ab44ce":"00000000000000000000000000000000":"00000000000000000000000000000000":"3608c344868e94555d23a120f8a5502d"
+
+AES-192-CBC Encrypt NIST KAT #5
+aes_encrypt_cbc:"e08c15411774ec4a908b64eadc6ac4199c7cd453f3aaef53":"00000000000000000000000000000000":"00000000000000000000000000000000":"77da2021935b840b7f5dcc39132da9e5"
+
+AES-192-CBC Encrypt NIST KAT #6
+aes_encrypt_cbc:"3b375a1ff7e8d44409696e6326ec9dec86138e2ae010b980":"00000000000000000000000000000000":"00000000000000000000000000000000":"3b7c24f825e3bf9873c9f14d39a0e6f4"
+
+AES-192-CBC Encrypt NIST KAT #7
+aes_encrypt_cbc:"000000000000000000000000000000000000000000000000":"00000000000000000000000000000000":"51719783d3185a535bd75adc65071ce1":"4f354592ff7c8847d2d0870ca9481b7c"
+
+AES-192-CBC Encrypt NIST KAT #8
+aes_encrypt_cbc:"000000000000000000000000000000000000000000000000":"00000000000000000000000000000000":"26aa49dcfe7629a8901a69a9914e6dfd":"d5e08bf9a182e857cf40b3a36ee248cc"
+
+AES-192-CBC Encrypt NIST KAT #9
+aes_encrypt_cbc:"000000000000000000000000000000000000000000000000":"00000000000000000000000000000000":"941a4773058224e1ef66d10e0a6ee782":"067cd9d3749207791841562507fa9626"
+
+AES-192-CBC Encrypt NIST KAT #10
+aes_encrypt_cbc:"000000000000000000000000000000000000000000000000":"00000000000000000000000000000000":"ffc00000000000000000000000000000":"030d7e5b64f380a7e4ea5387b5cd7f49"
+
+AES-192-CBC Encrypt NIST KAT #11
+aes_encrypt_cbc:"000000000000000000000000000000000000000000000000":"00000000000000000000000000000000":"ffe00000000000000000000000000000":"0dc9a2610037009b698f11bb7e86c83e"
+
+AES-192-CBC Encrypt NIST KAT #12
+aes_encrypt_cbc:"000000000000000000000000000000000000000000000000":"00000000000000000000000000000000":"fff00000000000000000000000000000":"0046612c766d1840c226364f1fa7ed72"
+
+AES-192-CBC Decrypt NIST KAT #1
+aes_decrypt_cbc:"000000000000000000000000000000000000000000000000":"00000000000000000000000000000000":"902d88d13eae52089abd6143cfe394e9":"ffffffffe00000000000000000000000"
+
+AES-192-CBC Decrypt NIST KAT #2
+aes_decrypt_cbc:"000000000000000000000000000000000000000000000000":"00000000000000000000000000000000":"d49bceb3b823fedd602c305345734bd2":"fffffffff00000000000000000000000"
+
+AES-192-CBC Decrypt NIST KAT #3
+aes_decrypt_cbc:"000000000000000000000000000000000000000000000000":"00000000000000000000000000000000":"707b1dbb0ffa40ef7d95def421233fae":"fffffffff80000000000000000000000"
+
+AES-192-CBC Decrypt NIST KAT #4
+aes_decrypt_cbc:"fffffffffffffffffffc0000000000000000000000000000":"00000000000000000000000000000000":"8dfd999be5d0cfa35732c0ddc88ff5a5":"00000000000000000000000000000000"
+
+AES-192-CBC Decrypt NIST KAT #5
+aes_decrypt_cbc:"fffffffffffffffffffe0000000000000000000000000000":"00000000000000000000000000000000":"02647c76a300c3173b841487eb2bae9f":"00000000000000000000000000000000"
+
+AES-192-CBC Decrypt NIST KAT #6
+aes_decrypt_cbc:"ffffffffffffffffffff0000000000000000000000000000":"00000000000000000000000000000000":"172df8b02f04b53adab028b4e01acd87":"00000000000000000000000000000000"
+
+AES-192-CBC Decrypt NIST KAT #7
+aes_decrypt_cbc:"b3ad5cea1dddc214ca969ac35f37dae1a9a9d1528f89bb35":"00000000000000000000000000000000":"3cf5e1d21a17956d1dffad6a7c41c659":"00000000000000000000000000000000"
+
+AES-192-CBC Decrypt NIST KAT #8
+aes_decrypt_cbc:"45899367c3132849763073c435a9288a766c8b9ec2308516":"00000000000000000000000000000000":"69fd12e8505f8ded2fdcb197a121b362":"00000000000000000000000000000000"
+
+AES-192-CBC Decrypt NIST KAT #9
+aes_decrypt_cbc:"ec250e04c3903f602647b85a401a1ae7ca2f02f67fa4253e":"00000000000000000000000000000000":"8aa584e2cc4d17417a97cb9a28ba29c8":"00000000000000000000000000000000"
+
+AES-192-CBC Decrypt NIST KAT #10
+aes_decrypt_cbc:"000000000000000000000000000000000000000000000000":"00000000000000000000000000000000":"c9b8135ff1b5adc413dfd053b21bd96d":"9c2d8842e5f48f57648205d39a239af1"
+
+AES-192-CBC Decrypt NIST KAT #11
+aes_decrypt_cbc:"000000000000000000000000000000000000000000000000":"00000000000000000000000000000000":"4a3650c3371ce2eb35e389a171427440":"bff52510095f518ecca60af4205444bb"
+
+AES-192-CBC Decrypt NIST KAT #12
+aes_decrypt_cbc:"000000000000000000000000000000000000000000000000":"00000000000000000000000000000000":"4f354592ff7c8847d2d0870ca9481b7c":"51719783d3185a535bd75adc65071ce1"
+
+AES-256-CBC Encrypt NIST KAT #1
+aes_encrypt_cbc:"8000000000000000000000000000000000000000000000000000000000000000":"00000000000000000000000000000000":"00000000000000000000000000000000":"e35a6dcb19b201a01ebcfa8aa22b5759"
+
+AES-256-CBC Encrypt NIST KAT #2
+aes_encrypt_cbc:"c000000000000000000000000000000000000000000000000000000000000000":"00000000000000000000000000000000":"00000000000000000000000000000000":"b29169cdcf2d83e838125a12ee6aa400"
+
+AES-256-CBC Encrypt NIST KAT #3
+aes_encrypt_cbc:"e000000000000000000000000000000000000000000000000000000000000000":"00000000000000000000000000000000":"00000000000000000000000000000000":"d8f3a72fc3cdf74dfaf6c3e6b97b2fa6"
+
+AES-256-CBC Encrypt NIST KAT #4
+aes_encrypt_cbc:"dc0eba1f2232a7879ded34ed8428eeb8769b056bbaf8ad77cb65c3541430b4cf":"00000000000000000000000000000000":"00000000000000000000000000000000":"fc6aec906323480005c58e7e1ab004ad"
+
+AES-256-CBC Encrypt NIST KAT #5
+aes_encrypt_cbc:"f8be9ba615c5a952cabbca24f68f8593039624d524c816acda2c9183bd917cb9":"00000000000000000000000000000000":"00000000000000000000000000000000":"a3944b95ca0b52043584ef02151926a8"
+
+AES-256-CBC Encrypt NIST KAT #6
+aes_encrypt_cbc:"797f8b3d176dac5b7e34a2d539c4ef367a16f8635f6264737591c5c07bf57a3e":"00000000000000000000000000000000":"00000000000000000000000000000000":"a74289fe73a4c123ca189ea1e1b49ad5"
+
+AES-256-CBC Encrypt NIST KAT #7
+aes_encrypt_cbc:"0000000000000000000000000000000000000000000000000000000000000000":"00000000000000000000000000000000":"761c1fe41a18acf20d241650611d90f1":"623a52fcea5d443e48d9181ab32c7421"
+
+AES-256-CBC Encrypt NIST KAT #8
+aes_encrypt_cbc:"0000000000000000000000000000000000000000000000000000000000000000":"00000000000000000000000000000000":"8a560769d605868ad80d819bdba03771":"38f2c7ae10612415d27ca190d27da8b4"
+
+AES-256-CBC Encrypt NIST KAT #9
+aes_encrypt_cbc:"0000000000000000000000000000000000000000000000000000000000000000":"00000000000000000000000000000000":"91fbef2d15a97816060bee1feaa49afe":"1bc704f1bce135ceb810341b216d7abe"
+
+AES-256-CBC Encrypt NIST KAT #10
+aes_encrypt_cbc:"0000000000000000000000000000000000000000000000000000000000000000":"00000000000000000000000000000000":"ffffffffffffff800000000000000000":"0d9ac756eb297695eed4d382eb126d26"
+
+AES-256-CBC Encrypt NIST KAT #11
+aes_encrypt_cbc:"0000000000000000000000000000000000000000000000000000000000000000":"00000000000000000000000000000000":"ffffffffffffffc00000000000000000":"56ede9dda3f6f141bff1757fa689c3e1"
+
+AES-256-CBC Encrypt NIST KAT #12
+aes_encrypt_cbc:"0000000000000000000000000000000000000000000000000000000000000000":"00000000000000000000000000000000":"ffffffffffffffe00000000000000000":"768f520efe0f23e61d3ec8ad9ce91774"
+
+AES-256-CBC Decrypt NIST KAT #1
+aes_decrypt_cbc:"0000000000000000000000000000000000000000000000000000000000000000":"00000000000000000000000000000000":"49af6b372135acef10132e548f217b17":"ff000000000000000000000000000000"
+
+AES-256-CBC Decrypt NIST KAT #2
+aes_decrypt_cbc:"0000000000000000000000000000000000000000000000000000000000000000":"00000000000000000000000000000000":"8bcd40f94ebb63b9f7909676e667f1e7":"ff800000000000000000000000000000"
+
+AES-256-CBC Decrypt NIST KAT #3
+aes_decrypt_cbc:"0000000000000000000000000000000000000000000000000000000000000000":"00000000000000000000000000000000":"fe1cffb83f45dcfb38b29be438dbd3ab":"ffc00000000000000000000000000000"
+
+AES-256-CBC Decrypt NIST KAT #4
+aes_decrypt_cbc:"fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc00":"00000000000000000000000000000000":"cca7c3086f5f9511b31233da7cab9160":"00000000000000000000000000000000"
+
+AES-256-CBC Decrypt NIST KAT #5
+aes_decrypt_cbc:"fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe00":"00000000000000000000000000000000":"5b40ff4ec9be536ba23035fa4f06064c":"00000000000000000000000000000000"
+
+AES-256-CBC Decrypt NIST KAT #6
+aes_decrypt_cbc:"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00":"00000000000000000000000000000000":"60eb5af8416b257149372194e8b88749":"00000000000000000000000000000000"
+
+AES-256-CBC Decrypt NIST KAT #7
+aes_decrypt_cbc:"90143ae20cd78c5d8ebdd6cb9dc1762427a96c78c639bccc41a61424564eafe1":"00000000000000000000000000000000":"798c7c005dee432b2c8ea5dfa381ecc3":"00000000000000000000000000000000"
+
+AES-256-CBC Decrypt NIST KAT #8
+aes_decrypt_cbc:"b7a5794d52737475d53d5a377200849be0260a67a2b22ced8bbef12882270d07":"00000000000000000000000000000000":"637c31dc2591a07636f646b72daabbe7":"00000000000000000000000000000000"
+
+AES-256-CBC Decrypt NIST KAT #9
+aes_decrypt_cbc:"fca02f3d5011cfc5c1e23165d413a049d4526a991827424d896fe3435e0bf68e":"00000000000000000000000000000000":"179a49c712154bbffbe6e7a84a18e220":"00000000000000000000000000000000"
+
+AES-256-CBC Decrypt NIST KAT #10
+aes_decrypt_cbc:"0000000000000000000000000000000000000000000000000000000000000000":"00000000000000000000000000000000":"5c9d844ed46f9885085e5d6a4f94c7d7":"014730f80ac625fe84f026c60bfd547d"
+
+AES-256-CBC Decrypt NIST KAT #11
+aes_decrypt_cbc:"0000000000000000000000000000000000000000000000000000000000000000":"00000000000000000000000000000000":"a9ff75bd7cf6613d3731c77c3b6d0c04":"0b24af36193ce4665f2825d7b4749c98"
+
+AES-256-CBC Decrypt NIST KAT #12
+aes_decrypt_cbc:"0000000000000000000000000000000000000000000000000000000000000000":"00000000000000000000000000000000":"623a52fcea5d443e48d9181ab32c7421":"761c1fe41a18acf20d241650611d90f1"
+
+AES-128-CFB128 Encrypt NIST KAT #1
+aes_encrypt_cfb128:"f0000000000000000000000000000000":"00000000000000000000000000000000":"00000000000000000000000000000000":"970014d634e2b7650777e8e84d03ccd8"
+
+AES-128-CFB128 Encrypt NIST KAT #2
+aes_encrypt_cfb128:"f8000000000000000000000000000000":"00000000000000000000000000000000":"00000000000000000000000000000000":"f17e79aed0db7e279e955b5f493875a7"
+
+AES-128-CFB128 Encrypt NIST KAT #3
+aes_encrypt_cfb128:"fc000000000000000000000000000000":"00000000000000000000000000000000":"00000000000000000000000000000000":"9ed5a75136a940d0963da379db4af26a"
+
+AES-128-CFB128 Encrypt NIST KAT #4
+aes_encrypt_cfb128:"64cf9c7abc50b888af65f49d521944b2":"00000000000000000000000000000000":"00000000000000000000000000000000":"f7efc89d5dba578104016ce5ad659c05"
+
+AES-128-CFB128 Encrypt NIST KAT #5
+aes_encrypt_cfb128:"47d6742eefcc0465dc96355e851b64d9":"00000000000000000000000000000000":"00000000000000000000000000000000":"0306194f666d183624aa230a8b264ae7"
+
+AES-128-CFB128 Encrypt NIST KAT #6
+aes_encrypt_cfb128:"3eb39790678c56bee34bbcdeccf6cdb5":"00000000000000000000000000000000":"00000000000000000000000000000000":"858075d536d79ccee571f7d7204b1f67"
+
+AES-128-CFB128 Encrypt NIST KAT #7
+aes_encrypt_cfb128:"00000000000000000000000000000000":"6a118a874519e64e9963798a503f1d35":"00000000000000000000000000000000":"dc43be40be0e53712f7e2bf5ca707209"
+
+AES-128-CFB128 Encrypt NIST KAT #8
+aes_encrypt_cfb128:"00000000000000000000000000000000":"cb9fceec81286ca3e989bd979b0cb284":"00000000000000000000000000000000":"92beedab1895a94faa69b632e5cc47ce"
+
+AES-128-CFB128 Encrypt NIST KAT #9
+aes_encrypt_cfb128:"00000000000000000000000000000000":"b26aeb1874e47ca8358ff22378f09144":"00000000000000000000000000000000":"459264f4798f6a78bacb89c15ed3d601"
+
+AES-128-CFB128 Encrypt NIST KAT #10
+aes_encrypt_cfb128:"00000000000000000000000000000000":"fffffffffffffffffffffffffffffff0":"00000000000000000000000000000000":"f9b0fda0c4a898f5b9e6f661c4ce4d07"
+
+AES-128-CFB128 Encrypt NIST KAT #11
+aes_encrypt_cfb128:"00000000000000000000000000000000":"fffffffffffffffffffffffffffffff8":"00000000000000000000000000000000":"8ade895913685c67c5269f8aae42983e"
+
+AES-128-CFB128 Encrypt NIST KAT #12
+aes_encrypt_cfb128:"00000000000000000000000000000000":"fffffffffffffffffffffffffffffffc":"00000000000000000000000000000000":"39bde67d5c8ed8a8b1c37eb8fa9f5ac0"
+
+AES-128-CFB128 Decrypt NIST KAT #1
+aes_decrypt_cfb128:"fffffffe000000000000000000000000":"00000000000000000000000000000000":"1114bc2028009b923f0b01915ce5e7c4":"00000000000000000000000000000000"
+
+AES-128-CFB128 Decrypt NIST KAT #2
+aes_decrypt_cfb128:"ffffffff000000000000000000000000":"00000000000000000000000000000000":"9c28524a16a1e1c1452971caa8d13476":"00000000000000000000000000000000"
+
+AES-128-CFB128 Decrypt NIST KAT #3
+aes_decrypt_cfb128:"ffffffff800000000000000000000000":"00000000000000000000000000000000":"ed62e16363638360fdd6ad62112794f0":"00000000000000000000000000000000"
+
+AES-128-CFB128 Decrypt NIST KAT #4
+aes_decrypt_cfb128:"3071a2a48fe6cbd04f1a129098e308f8":"00000000000000000000000000000000":"4b98e06d356deb07ebb824e5713f7be3":"00000000000000000000000000000000"
+
+AES-128-CFB128 Decrypt NIST KAT #5
+aes_decrypt_cfb128:"90f42ec0f68385f2ffc5dfc03a654dce":"00000000000000000000000000000000":"7a20a53d460fc9ce0423a7a0764c6cf2":"00000000000000000000000000000000"
+
+AES-128-CFB128 Decrypt NIST KAT #6
+aes_decrypt_cfb128:"febd9a24d8b65c1c787d50a4ed3619a9":"00000000000000000000000000000000":"f4a70d8af877f9b02b4c40df57d45b17":"00000000000000000000000000000000"
+
+AES-128-CFB128 Decrypt NIST KAT #7
+aes_decrypt_cfb128:"00000000000000000000000000000000":"f34481ec3cc627bacd5dc3fb08f273e6":"0336763e966d92595a567cc9ce537f5e":"00000000000000000000000000000000"
+
+AES-128-CFB128 Decrypt NIST KAT #8
+aes_decrypt_cfb128:"00000000000000000000000000000000":"9798c4640bad75c7c3227db910174e72":"a9a1631bf4996954ebc093957b234589":"00000000000000000000000000000000"
+
+AES-128-CFB128 Decrypt NIST KAT #9
+aes_decrypt_cfb128:"00000000000000000000000000000000":"96ab5c2ff612d9dfaae8c31f30c42168":"ff4f8391a6a40ca5b25d23bedd44a597":"00000000000000000000000000000000"
+
+AES-128-CFB128 Decrypt NIST KAT #10
+aes_decrypt_cfb128:"00000000000000000000000000000000":"ffffffffffffffff0000000000000000":"f807c3e7985fe0f5a50e2cdb25c5109e":"00000000000000000000000000000000"
+
+AES-128-CFB128 Decrypt NIST KAT #11
+aes_decrypt_cfb128:"00000000000000000000000000000000":"ffffffffffffffff8000000000000000":"41f992a856fb278b389a62f5d274d7e9":"00000000000000000000000000000000"
+
+AES-128-CFB128 Decrypt NIST KAT #12
+aes_decrypt_cfb128:"00000000000000000000000000000000":"ffffffffffffffffc000000000000000":"10d3ed7a6fe15ab4d91acbc7d0767ab1":"00000000000000000000000000000000"
+
+AES-192-CFB128 Encrypt NIST KAT #1
+aes_encrypt_cfb128:"fffffffffffffffffffc0000000000000000000000000000":"00000000000000000000000000000000":"00000000000000000000000000000000":"8dfd999be5d0cfa35732c0ddc88ff5a5"
+
+AES-192-CFB128 Encrypt NIST KAT #2
+aes_encrypt_cfb128:"fffffffffffffffffffe0000000000000000000000000000":"00000000000000000000000000000000":"00000000000000000000000000000000":"02647c76a300c3173b841487eb2bae9f"
+
+AES-192-CFB128 Encrypt NIST KAT #3
+aes_encrypt_cfb128:"ffffffffffffffffffff0000000000000000000000000000":"00000000000000000000000000000000":"00000000000000000000000000000000":"172df8b02f04b53adab028b4e01acd87"
+
+AES-192-CFB128 Encrypt NIST KAT #4
+aes_encrypt_cfb128:"d184c36cf0dddfec39e654195006022237871a47c33d3198":"00000000000000000000000000000000":"00000000000000000000000000000000":"2e19fb60a3e1de0166f483c97824a978"
+
+AES-192-CFB128 Encrypt NIST KAT #5
+aes_encrypt_cfb128:"4c6994ffa9dcdc805b60c2c0095334c42d95a8fc0ca5b080":"00000000000000000000000000000000":"00000000000000000000000000000000":"7656709538dd5fec41e0ce6a0f8e207d"
+
+AES-192-CFB128 Encrypt NIST KAT #6
+aes_encrypt_cfb128:"c88f5b00a4ef9a6840e2acaf33f00a3bdc4e25895303fa72":"00000000000000000000000000000000":"00000000000000000000000000000000":"a67cf333b314d411d3c0ae6e1cfcd8f5"
+
+AES-192-CFB128 Encrypt NIST KAT #7
+aes_encrypt_cfb128:"000000000000000000000000000000000000000000000000":"9c2d8842e5f48f57648205d39a239af1":"00000000000000000000000000000000":"c9b8135ff1b5adc413dfd053b21bd96d"
+
+AES-192-CFB128 Encrypt NIST KAT #8
+aes_encrypt_cfb128:"000000000000000000000000000000000000000000000000":"bff52510095f518ecca60af4205444bb":"00000000000000000000000000000000":"4a3650c3371ce2eb35e389a171427440"
+
+AES-192-CFB128 Encrypt NIST KAT #9
+aes_encrypt_cfb128:"000000000000000000000000000000000000000000000000":"51719783d3185a535bd75adc65071ce1":"00000000000000000000000000000000":"4f354592ff7c8847d2d0870ca9481b7c"
+
+AES-192-CFB128 Encrypt NIST KAT #10
+aes_encrypt_cfb128:"000000000000000000000000000000000000000000000000":"ffffffffffffffe00000000000000000":"00000000000000000000000000000000":"f34e4a6324ea4a5c39a661c8fe5ada8f"
+
+AES-192-CFB128 Encrypt NIST KAT #11
+aes_encrypt_cfb128:"000000000000000000000000000000000000000000000000":"fffffffffffffff00000000000000000":"00000000000000000000000000000000":"0882a16f44088d42447a29ac090ec17e"
+
+AES-192-CFB128 Encrypt NIST KAT #12
+aes_encrypt_cfb128:"000000000000000000000000000000000000000000000000":"fffffffffffffff80000000000000000":"00000000000000000000000000000000":"3a3c15bfc11a9537c130687004e136ee"
+
+AES-192-CFB128 Decrypt NIST KAT #1
+aes_decrypt_cfb128:"ffffffffffffffffffffffffffffffffffffffffffe00000":"00000000000000000000000000000000":"60136703374f64e860b48ce31f930716":"00000000000000000000000000000000"
+
+AES-192-CFB128 Decrypt NIST KAT #2
+aes_decrypt_cfb128:"fffffffffffffffffffffffffffffffffffffffffff00000":"00000000000000000000000000000000":"8d63a269b14d506ccc401ab8a9f1b591":"00000000000000000000000000000000"
+
+AES-192-CFB128 Decrypt NIST KAT #3
+aes_decrypt_cfb128:"fffffffffffffffffffffffffffffffffffffffffff80000":"00000000000000000000000000000000":"d317f81dc6aa454aee4bd4a5a5cff4bd":"00000000000000000000000000000000"
+
+AES-192-CFB128 Decrypt NIST KAT #4
+aes_decrypt_cfb128:"98c6b8e01e379fbd14e61af6af891596583565f2a27d59e9":"00000000000000000000000000000000":"19c80ec4a6deb7e5ed1033dda933498f":"00000000000000000000000000000000"
+
+AES-192-CFB128 Decrypt NIST KAT #5
+aes_decrypt_cfb128:"b3ad5cea1dddc214ca969ac35f37dae1a9a9d1528f89bb35":"00000000000000000000000000000000":"3cf5e1d21a17956d1dffad6a7c41c659":"00000000000000000000000000000000"
+
+AES-192-CFB128 Decrypt NIST KAT #6
+aes_decrypt_cfb128:"45899367c3132849763073c435a9288a766c8b9ec2308516":"00000000000000000000000000000000":"69fd12e8505f8ded2fdcb197a121b362":"00000000000000000000000000000000"
+
+AES-192-CFB128 Decrypt NIST KAT #7
+aes_decrypt_cfb128:"000000000000000000000000000000000000000000000000":"1b077a6af4b7f98229de786d7516b639":"275cfc0413d8ccb70513c3859b1d0f72":"00000000000000000000000000000000"
+
+AES-192-CFB128 Decrypt NIST KAT #8
+aes_decrypt_cfb128:"000000000000000000000000000000000000000000000000":"9c2d8842e5f48f57648205d39a239af1":"c9b8135ff1b5adc413dfd053b21bd96d":"00000000000000000000000000000000"
+
+AES-192-CFB128 Decrypt NIST KAT #9
+aes_decrypt_cfb128:"000000000000000000000000000000000000000000000000":"bff52510095f518ecca60af4205444bb":"4a3650c3371ce2eb35e389a171427440":"00000000000000000000000000000000"
+
+AES-192-CFB128 Decrypt NIST KAT #10
+aes_decrypt_cfb128:"000000000000000000000000000000000000000000000000":"ffffffffffffffffffff000000000000":"54d632d03aba0bd0f91877ebdd4d09cb":"00000000000000000000000000000000"
+
+AES-192-CFB128 Decrypt NIST KAT #11
+aes_decrypt_cfb128:"000000000000000000000000000000000000000000000000":"ffffffffffffffffffff800000000000":"d3427be7e4d27cd54f5fe37b03cf0897":"00000000000000000000000000000000"
+
+AES-192-CFB128 Decrypt NIST KAT #12
+aes_decrypt_cfb128:"000000000000000000000000000000000000000000000000":"ffffffffffffffffffffc00000000000":"b2099795e88cc158fd75ea133d7e7fbe":"00000000000000000000000000000000"
+
+AES-256-CFB128 Encrypt NIST KAT #1
+aes_encrypt_cfb128:"ffffffe000000000000000000000000000000000000000000000000000000000":"00000000000000000000000000000000":"00000000000000000000000000000000":"bbd1097a62433f79449fa97d4ee80dbf"
+
+AES-256-CFB128 Encrypt NIST KAT #2
+aes_encrypt_cfb128:"fffffff000000000000000000000000000000000000000000000000000000000":"00000000000000000000000000000000":"00000000000000000000000000000000":"07058e408f5b99b0e0f061a1761b5b3b"
+
+AES-256-CFB128 Encrypt NIST KAT #3
+aes_encrypt_cfb128:"fffffff800000000000000000000000000000000000000000000000000000000":"00000000000000000000000000000000":"00000000000000000000000000000000":"5fd1f13fa0f31e37fabde328f894eac2"
+
+AES-256-CFB128 Encrypt NIST KAT #4
+aes_encrypt_cfb128:"13428b5e4c005e0636dd338405d173ab135dec2a25c22c5df0722d69dcc43887":"00000000000000000000000000000000":"00000000000000000000000000000000":"649a71545378c783e368c9ade7114f6c"
+
+AES-256-CFB128 Encrypt NIST KAT #5
+aes_encrypt_cfb128:"07eb03a08d291d1b07408bf3512ab40c91097ac77461aad4bb859647f74f00ee":"00000000000000000000000000000000":"00000000000000000000000000000000":"47cb030da2ab051dfc6c4bf6910d12bb"
+
+AES-256-CFB128 Encrypt NIST KAT #6
+aes_encrypt_cfb128:"90143ae20cd78c5d8ebdd6cb9dc1762427a96c78c639bccc41a61424564eafe1":"00000000000000000000000000000000":"00000000000000000000000000000000":"798c7c005dee432b2c8ea5dfa381ecc3"
+
+AES-256-CFB128 Encrypt NIST KAT #7
+aes_encrypt_cfb128:"0000000000000000000000000000000000000000000000000000000000000000":"0b24af36193ce4665f2825d7b4749c98":"00000000000000000000000000000000":"a9ff75bd7cf6613d3731c77c3b6d0c04"
+
+AES-256-CFB128 Encrypt NIST KAT #8
+aes_encrypt_cfb128:"0000000000000000000000000000000000000000000000000000000000000000":"761c1fe41a18acf20d241650611d90f1":"00000000000000000000000000000000":"623a52fcea5d443e48d9181ab32c7421"
+
+AES-256-CFB128 Encrypt NIST KAT #9
+aes_encrypt_cfb128:"0000000000000000000000000000000000000000000000000000000000000000":"8a560769d605868ad80d819bdba03771":"00000000000000000000000000000000":"38f2c7ae10612415d27ca190d27da8b4"
+
+AES-256-CFB128 Encrypt NIST KAT #10
+aes_encrypt_cfb128:"0000000000000000000000000000000000000000000000000000000000000000":"ffffffffffffffffffffffffe0000000":"00000000000000000000000000000000":"2be1fae5048a25582a679ca10905eb80"
+
+AES-256-CFB128 Encrypt NIST KAT #11
+aes_encrypt_cfb128:"0000000000000000000000000000000000000000000000000000000000000000":"fffffffffffffffffffffffff0000000":"00000000000000000000000000000000":"da86f292c6f41ea34fb2068df75ecc29"
+
+AES-256-CFB128 Encrypt NIST KAT #12
+aes_encrypt_cfb128:"0000000000000000000000000000000000000000000000000000000000000000":"fffffffffffffffffffffffff8000000":"00000000000000000000000000000000":"220df19f85d69b1b562fa69a3c5beca5"
+
+AES-256-CFB128 Decrypt NIST KAT #1
+aes_decrypt_cfb128:"ffffffffff800000000000000000000000000000000000000000000000000000":"00000000000000000000000000000000":"be66cfea2fecd6bf0ec7b4352c99bcaa":"00000000000000000000000000000000"
+
+AES-256-CFB128 Decrypt NIST KAT #2
+aes_decrypt_cfb128:"ffffffffffc00000000000000000000000000000000000000000000000000000":"00000000000000000000000000000000":"df31144f87a2ef523facdcf21a427804":"00000000000000000000000000000000"
+
+AES-256-CFB128 Decrypt NIST KAT #3
+aes_decrypt_cfb128:"ffffffffffe00000000000000000000000000000000000000000000000000000":"00000000000000000000000000000000":"b5bb0f5629fb6aae5e1839a3c3625d63":"00000000000000000000000000000000"
+
+AES-256-CFB128 Decrypt NIST KAT #4
+aes_decrypt_cfb128:"1d85a181b54cde51f0e098095b2962fdc93b51fe9b88602b3f54130bf76a5bd9":"00000000000000000000000000000000":"531c2c38344578b84d50b3c917bbb6e1":"00000000000000000000000000000000"
+
+AES-256-CFB128 Decrypt NIST KAT #5
+aes_decrypt_cfb128:"dc0eba1f2232a7879ded34ed8428eeb8769b056bbaf8ad77cb65c3541430b4cf":"00000000000000000000000000000000":"fc6aec906323480005c58e7e1ab004ad":"00000000000000000000000000000000"
+
+AES-256-CFB128 Decrypt NIST KAT #6
+aes_decrypt_cfb128:"f8be9ba615c5a952cabbca24f68f8593039624d524c816acda2c9183bd917cb9":"00000000000000000000000000000000":"a3944b95ca0b52043584ef02151926a8":"00000000000000000000000000000000"
+
+AES-256-CFB128 Decrypt NIST KAT #7
+aes_decrypt_cfb128:"0000000000000000000000000000000000000000000000000000000000000000":"761c1fe41a18acf20d241650611d90f1":"623a52fcea5d443e48d9181ab32c7421":"00000000000000000000000000000000"
+
+AES-256-CFB128 Decrypt NIST KAT #8
+aes_decrypt_cfb128:"0000000000000000000000000000000000000000000000000000000000000000":"8a560769d605868ad80d819bdba03771":"38f2c7ae10612415d27ca190d27da8b4":"00000000000000000000000000000000"
+
+AES-256-CFB128 Decrypt NIST KAT #9
+aes_decrypt_cfb128:"0000000000000000000000000000000000000000000000000000000000000000":"91fbef2d15a97816060bee1feaa49afe":"1bc704f1bce135ceb810341b216d7abe":"00000000000000000000000000000000"
+
+AES-256-CFB128 Decrypt NIST KAT #10
+aes_decrypt_cfb128:"0000000000000000000000000000000000000000000000000000000000000000":"e0000000000000000000000000000000":"9b80eefb7ebe2d2b16247aa0efc72f5d":"00000000000000000000000000000000"
+
+AES-256-CFB128 Decrypt NIST KAT #11
+aes_decrypt_cfb128:"0000000000000000000000000000000000000000000000000000000000000000":"f0000000000000000000000000000000":"7f2c5ece07a98d8bee13c51177395ff7":"00000000000000000000000000000000"
+
+AES-256-CFB128 Decrypt NIST KAT #12
+aes_decrypt_cfb128:"0000000000000000000000000000000000000000000000000000000000000000":"f8000000000000000000000000000000":"7818d800dcf6f4be1e0e94f403d1e4c2":"00000000000000000000000000000000"
diff --git a/tests/suites/test_suite_aes.function b/tests/suites/test_suite_aes.function
new file mode 100644
index 0000000..861ad2a
--- /dev/null
+++ b/tests/suites/test_suite_aes.function
@@ -0,0 +1,168 @@
+BEGIN_HEADER
+#include <polarssl/aes.h>
+END_HEADER
+
+BEGIN_CASE
+aes_encrypt_ecb:hex_key_string:hex_src_string:hex_dst_string
+{
+    unsigned char key_str[100];
+    unsigned char src_str[100];
+    unsigned char dst_str[100];
+    unsigned char output[100];
+    aes_context ctx;
+
+    memset(key_str, 0x00, 100);
+    memset(src_str, 0x00, 100);
+    memset(dst_str, 0x00, 100);
+    memset(output, 0x00, 100);
+
+    int key_len = unhexify( key_str, {hex_key_string} );
+    unhexify( src_str, {hex_src_string} );
+
+    aes_setkey_enc( &ctx, key_str, key_len * 8 );
+    aes_crypt_ecb( &ctx, AES_ENCRYPT, src_str, output );
+    hexify( dst_str, output, 16 );
+
+    TEST_ASSERT( strcmp( (char *) dst_str, {hex_dst_string} ) == 0 );
+}
+END_CASE
+
+BEGIN_CASE
+aes_decrypt_ecb:hex_key_string:hex_src_string:hex_dst_string
+{
+    unsigned char key_str[100];
+    unsigned char src_str[100];
+    unsigned char dst_str[100];
+    unsigned char output[100];
+    aes_context ctx;
+
+    memset(key_str, 0x00, 100);
+    memset(src_str, 0x00, 100);
+    memset(dst_str, 0x00, 100);
+    memset(output, 0x00, 100);
+
+    int key_len = unhexify( key_str, {hex_key_string} );
+    unhexify( src_str, {hex_src_string} );
+
+    aes_setkey_dec( &ctx, key_str, key_len * 8 );
+    aes_crypt_ecb( &ctx, AES_DECRYPT, src_str, output );
+    hexify( dst_str, output, 16 );
+
+    TEST_ASSERT( strcmp( (char *) dst_str, {hex_dst_string} ) == 0 );
+}
+END_CASE
+
+BEGIN_CASE
+aes_encrypt_cbc:hex_key_string:hex_iv_string:hex_src_string:hex_dst_string
+{
+    unsigned char key_str[100];
+    unsigned char iv_str[100];
+    unsigned char src_str[100];
+    unsigned char dst_str[100];
+    unsigned char output[100];
+    aes_context ctx;
+
+    memset(key_str, 0x00, 100);
+    memset(iv_str, 0x00, 100);
+    memset(src_str, 0x00, 100);
+    memset(dst_str, 0x00, 100);
+    memset(output, 0x00, 100);
+
+    int key_len = unhexify( key_str, {hex_key_string} );
+    unhexify( iv_str, {hex_iv_string} );
+    unhexify( src_str, {hex_src_string} );
+
+    aes_setkey_enc( &ctx, key_str, key_len * 8 );
+    aes_crypt_cbc( &ctx, AES_ENCRYPT, 16, iv_str, src_str, output );
+    hexify( dst_str, output, 16 );
+
+    TEST_ASSERT( strcmp( (char *) dst_str, {hex_dst_string} ) == 0 );
+}
+END_CASE
+
+BEGIN_CASE
+aes_decrypt_cbc:hex_key_string:hex_iv_string:hex_src_string:hex_dst_string
+{
+    unsigned char key_str[100];
+    unsigned char iv_str[100];
+    unsigned char src_str[100];
+    unsigned char dst_str[100];
+    unsigned char output[100];
+    aes_context ctx;
+
+    memset(key_str, 0x00, 100);
+    memset(iv_str, 0x00, 100);
+    memset(src_str, 0x00, 100);
+    memset(dst_str, 0x00, 100);
+    memset(output, 0x00, 100);
+
+    int key_len = unhexify( key_str, {hex_key_string} );
+    unhexify( iv_str, {hex_iv_string} );
+    unhexify( src_str, {hex_src_string} );
+
+    aes_setkey_dec( &ctx, key_str, key_len * 8 );
+    aes_crypt_cbc( &ctx, AES_DECRYPT, 16, iv_str, src_str, output );
+    hexify( dst_str, output, 16 );
+
+    TEST_ASSERT( strcmp( (char *) dst_str, {hex_dst_string} ) == 0 );
+}
+END_CASE
+
+BEGIN_CASE
+aes_encrypt_cfb128:hex_key_string:hex_iv_string:hex_src_string:hex_dst_string
+{
+    unsigned char key_str[100];
+    unsigned char iv_str[100];
+    unsigned char src_str[100];
+    unsigned char dst_str[100];
+    unsigned char output[100];
+    aes_context ctx;
+    int iv_offset = 0;
+
+    memset(key_str, 0x00, 100);
+    memset(iv_str, 0x00, 100);
+    memset(src_str, 0x00, 100);
+    memset(dst_str, 0x00, 100);
+    memset(output, 0x00, 100);
+
+    int key_len = unhexify( key_str, {hex_key_string} );
+    unhexify( iv_str, {hex_iv_string} );
+    unhexify( src_str, {hex_src_string} );
+
+    aes_setkey_enc( &ctx, key_str, key_len * 8 );
+    aes_crypt_cfb128( &ctx, AES_ENCRYPT, 16, &iv_offset, iv_str, src_str, output );
+    hexify( dst_str, output, 16 );
+
+    TEST_ASSERT( strcmp( (char *) dst_str, {hex_dst_string} ) == 0 );
+}
+END_CASE
+
+BEGIN_CASE
+aes_decrypt_cfb128:hex_key_string:hex_iv_string:hex_src_string:hex_dst_string
+{
+    unsigned char key_str[100];
+    unsigned char iv_str[100];
+    unsigned char src_str[100];
+    unsigned char dst_str[100];
+    unsigned char output[100];
+    aes_context ctx;
+    int iv_offset = 0;
+
+    memset(key_str, 0x00, 100);
+    memset(iv_str, 0x00, 100);
+    memset(src_str, 0x00, 100);
+    memset(dst_str, 0x00, 100);
+    memset(output, 0x00, 100);
+
+    int key_len = unhexify( key_str, {hex_key_string} );
+    unhexify( iv_str, {hex_iv_string} );
+    unhexify( src_str, {hex_src_string} );
+
+    aes_setkey_enc( &ctx, key_str, key_len * 8 );
+    aes_crypt_cfb128( &ctx, AES_DECRYPT, 16, &iv_offset, iv_str, src_str, output );
+    hexify( dst_str, output, 16 );
+
+    TEST_ASSERT( strcmp( (char *) dst_str, {hex_dst_string} ) == 0 );
+}
+END_CASE
+
diff --git a/tests/suites/test_suite_arc4.data b/tests/suites/test_suite_arc4.data
new file mode 100644
index 0000000..535bdd9
--- /dev/null
+++ b/tests/suites/test_suite_arc4.data
@@ -0,0 +1,8 @@
+Test vector ARC4 [Cryptlib]
+arc4_crypt:"0000000000000000":"0123456789abcdef":"7494c2e7104b0879"
+
+Test vector ARC4 [COMMERCE]
+arc4_crypt:"dcee4cf92c":"618a63d2fb":"f13829c9de"
+
+Test vector ARC4 [SSH ARCFOUR]
+arc4_crypt:"527569736c696e6e756e206c61756c75206b6f727669737373616e692c2074e4686be470e46964656e2070e4e46c6ce42074e47973696b75752e204b6573e479f66e206f6e206f6e6e69206f6d616e616e692c206b61736b6973617675756e206c61616b736f7420766572686f75752e20456e206d6120696c6f697473652c20737572652068756f6b61612c206d75747461206d657473e46e2074756d6d757573206d756c6c652074756f6b61612e205075756e746f2070696c76656e2c206d692068756b6b75752c207369696e746f20766172616e207475756c6973656e2c206d69206e756b6b75752e2054756f6b7375742076616e616d6f6e206a61207661726a6f74207665656e2c206e69697374e420737964e46d656e69206c61756c756e207465656e2e202d2045696e6f204c65696e6f":"29041972fb42ba5fc7127712f13829c9":"358186999001e6b5daf05eceeb7eee21e0689c1f00eea81f7dd2caaee1d2763e68af0ead33d66c268bc946c484fbe94c5f5e0b86a59279e4f824e7a640bd223210b0a61160b7bce986ea65688003596b630a6b90f8e0caf6912a98eb872176e83c202caa64166d2cce57ff1bca57b213f0ed1aa72fb8ea52b0be01cd1e412867720b326eb389d011bd70d8af035fb0d8589dbce3c666f5ea8d4c7954c50c3f340b0467f81b425961c11843074df620f208404b394cf9d37ff54b5f1ad8f6ea7da3c561dfa7281f964463d2cc35a4d1b03490dec51b0711fbd6f55f79234d5b7c766622a66de92be996461d5e4dc878ef9bca030521e8351e4baed2fd04f9467368c4ad6ac186d08245b263a2666d1f6c5420f1599dfd9f438921c2f5a463938ce0982265eef70179bc553f339eb1a4c1af5f6a547f"
diff --git a/tests/suites/test_suite_arc4.function b/tests/suites/test_suite_arc4.function
new file mode 100644
index 0000000..343c0f6
--- /dev/null
+++ b/tests/suites/test_suite_arc4.function
@@ -0,0 +1,26 @@
+BEGIN_HEADER
+#include <polarssl/arc4.h>
+END_HEADER
+
+BEGIN_CASE
+arc4_crypt:hex_src_string:hex_key_string:hex_dst_string
+{
+    unsigned char src_str[1000];
+    unsigned char key_str[1000];
+    unsigned char dst_str[2000];
+
+    memset(src_str, 0x00, 1000);
+    memset(key_str, 0x00, 1000);
+    memset(dst_str, 0x00, 2000);
+
+    int src_len = unhexify( src_str, {hex_src_string} );
+    int key_len = unhexify( key_str, {hex_key_string} );
+
+    arc4_context ctx;
+    arc4_setup(&ctx, key_str, key_len);
+    arc4_crypt(&ctx, src_str, src_len);
+    hexify( dst_str, src_str, src_len );
+
+    TEST_ASSERT( strcmp( (char *) dst_str, {hex_dst_string} ) == 0 );
+}
+END_CASE
diff --git a/tests/suites/test_suite_base64.data b/tests/suites/test_suite_base64.data
new file mode 100644
index 0000000..4c31fa5
--- /dev/null
+++ b/tests/suites/test_suite_base64.data
@@ -0,0 +1,41 @@
+Test case base64_encode #1
+base64_encode:"":""
+
+Test case base64_encode #2
+base64_encode:"f":"Zg=="
+
+Test case base64_encode #3
+base64_encode:"fo":"Zm8="
+
+Test case base64_encode #4
+base64_encode:"foo":"Zm9v"
+
+Test case base64_encode #5
+base64_encode:"foob":"Zm9vYg=="
+
+Test case base64_encode #6
+base64_encode:"fooba":"Zm9vYmE="
+
+Test case base64_encode #7
+base64_encode:"foobar":"Zm9vYmFy"
+
+Test case base64_decode #1
+base64_decode:"":""
+
+Test case base64_decode #2
+base64_decode:"Zg==":"f"
+
+Test case base64_decode #3
+base64_decode:"Zm8=":"fo"
+
+Test case base64_decode #4
+base64_decode:"Zm9v":"foo"
+
+Test case base64_decode #5
+base64_decode:"Zm9vYg==":"foob"
+
+Test case base64_decode #6
+base64_decode:"Zm9vYmE=":"fooba"
+
+Test case base64_decode #7
+base64_decode:"Zm9vYmFy":"foobar"
diff --git a/tests/suites/test_suite_base64.function b/tests/suites/test_suite_base64.function
new file mode 100644
index 0000000..7482db4
--- /dev/null
+++ b/tests/suites/test_suite_base64.function
@@ -0,0 +1,36 @@
+BEGIN_HEADER
+#include <polarssl/base64.h>
+END_HEADER
+
+BEGIN_CASE
+base64_encode:src_string:dst_string
+{
+    unsigned char src_str[1000];
+    unsigned char dst_str[1000];
+    int len = 1000;
+
+    memset(src_str, 0x00, 1000);
+    memset(dst_str, 0x00, 1000);
+
+    strcpy( (char *) src_str, {src_string} );
+    TEST_ASSERT( base64_encode( dst_str, &len, src_str, strlen( (char *) src_str ) ) == 0 );
+    TEST_ASSERT( strcmp( (char *) dst_str, {dst_string} ) == 0 );
+}
+END_CASE
+
+BEGIN_CASE
+base64_decode:src_string:dst_string
+{
+    unsigned char src_str[1000];
+    unsigned char dst_str[1000];
+    int len = 1000;
+    int res; 
+
+    memset(src_str, 0x00, 1000);
+    memset(dst_str, 0x00, 1000);
+    
+    strcpy( (char *) src_str, {src_string} );
+    TEST_ASSERT( res = base64_decode( dst_str, &len, src_str, strlen( (char *) src_str ) ) == 0 );
+    TEST_ASSERT( strcmp( (char *) dst_str, {dst_string} ) == 0 );
+}
+END_CASE
diff --git a/tests/suites/test_suite_hmac_shax.data b/tests/suites/test_suite_hmac_shax.data
new file mode 100644
index 0000000..670c3d4
--- /dev/null
+++ b/tests/suites/test_suite_hmac_shax.data
@@ -0,0 +1,107 @@
+HMAC-SHA-1 Test Vector FIPS-198a #1
+sha1_hmac:20:"000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f":"53616d706c65202331":"4f4ca3d5d68ba7cc0a1208c9c61e9c5da0403c0a"
+
+HMAC-SHA-1 Test Vector FIPS-198a #2
+sha1_hmac:20:"303132333435363738393a3b3c3d3e3f40414243":"53616d706c65202332":"0922d3405faa3d194f82a45830737d5cc6c75d24"
+
+HMAC-SHA-1 Test Vector FIPS-198a #3
+sha1_hmac:20:"505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3":"53616d706c65202333":"bcf41eab8bb2d802f3d05caf7cb092ecf8d1a3aa"
+
+HMAC-SHA-1 Test Vector FIPS-198a #4
+sha1_hmac:12:"707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0":"53616d706c65202334":"9ea886efe268dbecce420c75"
+
+HMAC-SHA-1 Test Vector NIST CAVS #1
+sha1_hmac:10:"7b10f4124b15c82e":"27dcb5b1daf60cfd3e2f73d4d64ca9c684f8bf71fc682a46793b1790afa4feb100ca7aaff26f58f0e1d0ed42f1cdad1f474afa2e79d53a0c42892c4d7b327cbe46b295ed8da3b6ecab3d4851687a6f812b79df2f6b20f11f6706f5301790ca99625aad7391d84f78043d2a0a239b1477984c157bbc9276064e7a1a406b0612ca":"4ead12c2fe3d6ea43acb"
+
+HMAC-SHA-1 Test Vector NIST CAVS #2
+sha1_hmac:10:"4fe9fb902172a21b":"4ceb3a7c13659c22fe51134f03dce4c239d181b63c6b0b59d367157fd05cab98384f92dfa482d2d5e78e72eef1b1838af4696026c54233d484ecbbe87f904df5546419f8567eafd232e6c2fcd3ee2b7682c63000524b078dbb2096f585007deae752562df1fe3b01278089e16f3be46e2d0f7cabac2d8e6cc02a2d0ca953425f":"564428a67be1924b5793"
+
+HMAC-SHA-1 Test Vector NIST CAVS #3
+sha1_hmac:10:"d1f01455f78c4fb4":"00d40f67b57914bec456a3e3201ef1464be319a8d188c02e157af4b54f9b5a66d67f898a9bdbb19ff63a80aba6f246d013575721d52eb1b47a65def884011c49b257bcc2817fc853f106e8138ce386d7a5ac3103de0a3fa0ed6bb7af9ff66ebd1cc46fb86e4da0013d20a3c2dcd8fb828a4b70f7f104b41bf3f44682a66497ea":"56a665a7cdfe610f9fc5"
+
+HMAC-SHA-1 Test Vector NIST CAVS #4
+sha1_hmac:10:"4e5ef77fdf033a5b":"e59326464e3201d195e29f2a3446ec1b1c9ff31154e2a4d0e40ed466f1bc855d29f76835624fa0127d29c9b1915939a046f385af7e5d47a23ba91f28bd22f811ea258dbbf3332bcd3543b8285d5df41bd064ffd64a341c22c4edb44f9c8d9e6df0c59dbf4a052a6c83da7478e179a6f3839c6870ff8ca8b9497f9ac1d725fdda":"981c0a7a8423b63a8fa6"
+
+HMAC-SHA-1 Test Vector NIST CAVS #5
+sha1_hmac:10:"bcd9ff8aa60be2be":"51be4d0eb37bab714f92e19e9d70390655b363e8cd346a748245e731f437759cb8206412c8dab2ef1d4f36f880f41ff69d949da4594fdecb65e23cac1329b59e69e29bf875b38c31df6fa546c595f35cc2192aa750679a8a51a65e00e839d73a8d8c598a610d237fbe78955213589d80efcb73b95b8586f96d17b6f51a71c3b8":"84633f9f5040c8971478"
+
+HMAC-SHA-1 Test Vector NIST CAVS #6
+sha1_hmac:10:"4a661bce6ed86d21":"5ff6c744f1aab1bc29697d71f67541b8b3cec3c7079183b10a83fb98a9ee251d4bac3e1cb581ca972aaed8efd7c2875a6fb4c991132f67c9742d45e53bc7e8eaa94b35b37a907be61086b426cd11088ac118934e85d968c9667fd69fc6f6ea38c0fe34710b7ece91211b9b7ea00acd31f022aa6726368f9928a1352f122233f1":"739df59353ac6694e55e"
+
+HMAC-SHA-1 Test Vector NIST CAVS #7
+sha1_hmac:10:"1287e1565a57b547":"390ffdccc6171c11568d85b8f913e019bf4cd982ca9cd21ea730d41bdf3fcc0bc88ff48ba13a8f23deb2d96ec1033e7b2a58ca72b0c1e17bf03330db25d1e360fa6918009c4294bd1215b5ccd159a8f58bc3dc3d490eb7c3b9f887e8c98dbbb274a75373dcb695a59abd0219529d88518a96f92abc0bbcbda985c388f1fbbcc9":"d78ddf08077c7d9e2ba6"
+
+HMAC-SHA-224 Test Vector NIST CAVS #1
+sha224_hmac:14:"e055eb756697ee573fd3214811a9f7fa":"3875847012ee42fe54a0027bdf38cca7021b83a2ed0503af69ef6c37c637bc1114fba40096c5947d736e19b7af3c68d95a4e3b8b073adbbb80f47e9db8f2d4f0018ddd847fabfdf9dd9b52c93e40458977725f6b7ba15f0816bb895cdf50401268f5d702b7e6a5f9faef57b8768c8a3fc14f9a4b3182b41d940e337d219b29ff":"40a453133361cc48da11baf616ee"
+
+HMAC-SHA-224 Test Vector NIST CAVS #2
+sha224_hmac:14:"88e5258b55b1623385eb9632fa7c57d6":"ada76bb604be14326551701cf30e48a65eee80b44f0b9d4a07b1844543b7844a621097fdc99de57387458ae9354899b620d0617eabcaefa9eef3d413a33628054335ce656c26fa2986e0f111a6351096b283101ec7868871d770b370973c7405983f9756b3005a3eab492cfd0e7eb42e5c2e15fa6be8718c0a50acc4e5717230":"81c783af538015cef3c60095df53"
+
+HMAC-SHA-224 Test Vector NIST CAVS #3
+sha224_hmac:14:"85d402d822114d31abf75526e2538705":"8020d8d98cc2e2298b32879c51c751e1dd5558fe2eabb8f158604297d6d072ce2261a1d6830b7cfe2617b57c7126f99c9476211d6161acd75d266da217ec8174b80484c9dc6f0448a0a036a3fc82e8bf54bdb71549368258d5d41f57978a4c266b92e8783ef66350215573d99be4089144b383ad8f3222bae8f3bf80ffb1bb2b":"2aa0340ac9deafe3be38129daca0"
+
+HMAC-SHA-224 Test Vector NIST CAVS #4
+sha224_hmac:14:"545c6eecc5ee46fa17c59f91a94f81ae":"8fb7f3565593170152ddb2021874784e951977cfdd22f8b72a72a61320a8f2a35697b5e913f717805559b1af1861ee3ed42fb788481e4fd276b17bdbefcae7b4501dc5d20de5b7626dd5efdcd65294db4bdf682c33d9a9255c6435383fa5f1c886326a3acbc6bd50a33ab5b2dbb034ce0112d4e226bbcd57e3731a519aa1d784":"3eb566eac54c4a3a9ef092469f24"
+
+HMAC-SHA-224 Test Vector NIST CAVS #5
+sha224_hmac:14:"4466ab4dc438841a9750c7f173dff02e":"2534c11c78c99cffaec8f722f04adc7045c7324d58ce98e37cfa94b6ed21ed7f58ce55379ef24b72d6d640ee9154f96c614734be9c408e225d7ba4cecc1179cc9f6e1808e1067aa8f244a99bd0c3267594c1887a40d167f8b7cf78db0d19f97b01fc50b8c86def490dfa7a5135002c33e71d77a8cce8ea0f93e0580439a33733":"59f44a9bbed4875b892d22d6b5ab"
+
+HMAC-SHA-224 Test Vector NIST CAVS #6
+sha224_hmac:28:"0e3dd9bb5e4cf0f09a4c11600af56d8d":"f4589fa76c328ea25cf8bae582026ba40a59d45a546ff31cf80eb826088f69bb954c452c74586836416dee90a5255bc5d56d3b405b3705a5197045688b32fa984c3a3dfbdc9c2460a0b5e6312a624048bb6f170306535e9b371a3ab134a2642a230ad03d2c688cca80baeaee9a20e1d4c548b1cede29c6a45bf4df2c8c476f1a":"12175b93e3da4c58217145e4dc0a1cf142fab9319bb501e037b350ba"
+
+HMAC-SHA-224 Test Vector NIST CAVS #7
+sha224_hmac:28:"cda5187b0c5dcb0f8e5a8beed2306584":"9011ae29b44c49b347487ce972965f16ade3c15be0856ce9c853a9739dba07e4f20d594ddc1dfe21560a65a4e458cfa17745575b915a30c7a9412ff8d1d689db9680dd2428c27588bb0dc92d2cd9445fe8f44b840a197c52c3c4333fff45533945134398df6436513cfab06c924046b8c795a5bd92e8d5f2de85bf306f2eed67":"4aaba92b40e2a600feab176eb9b292d814864195c03342aad6f67f08"
+
+HMAC-SHA-256 Test Vector NIST CAVS #1
+sha256_hmac:16:"cdffd34e6b16fdc0":"d83e78b99ab61709608972b36e76a575603db742269cc5dd4e7d5ca7816e26b65151c92632550cb4c5253c885d5fce53bc47459a1dbd5652786c4aac0145a532f12c05138af04cbb558101a7af5df478834c2146594dd73690d01a4fe72545894335f427ac70204798068cb86c5a600b40b414ede23590b41e1192373df84fe3":"c6f0dde266cb4a26d41e8259d33499cc"
+
+HMAC-SHA-256 Test Vector NIST CAVS #2
+sha256_hmac:16:"6d97bb5892245be2":"13c2b391d59c0252ca5d2302beaaf88c4bcd779bb505ad9a122003dfae4cc123ad2bd036f225c4f040021a6b9fb8bd6f0281cf2e2631a732bdc71693cc42ef6d52b6c6912a9ef77b3274eb85ad7f965ae6ed44ac1721962a884ec7acfb4534b1488b1c0c45afa4dae8da1eb7b0a88a3240365d7e4e7d826abbde9f9203fd99d7":"31588e241b015319a5ab8c4527296498"
+
+HMAC-SHA-256 Test Vector NIST CAVS #3
+sha256_hmac:16:"3c7fc8a70b49007a":"60024e428a39c8b8bb2e9591bad9dc2115dfbfd716b6eb7af30a6eb34560caccbbfa47b710fa8d523aca71e9e5ba10fc1feb1a43556d71f07ea4f33496f093044e8caf1d02b79e46eb1288d5964a7a7494f6b92574c35784eece054c6151281d80822f7d47b8231c35d07f5cb5cf4310ddc844845a01c6bfab514c048eccaf9f":"1c98c94a32bec9f253c21070f82f8438"
+
+HMAC-SHA-256 Test Vector NIST CAVS #4
+sha256_hmac:24:"369f33f85b927a07":"ae8e2a94ca386d448cbacdb0e9040ae3cb297c296363052cc157455da29a0c95897315fc11e3f12b81e2418da1ec280bccbc00e847584ce9d14deeba7b3c9b8dba958b04bba37551f6c9ba9c060be1a4b8cf43aa62e5078b76c6512c5619b71a6a7cf5727180e1ff14f5a1a3c1691bf8b6ebad365c151e58d749d57adb3a4986":"60b90383286533d309de46593e6ce39fc51fb00a8d88278c"
+
+HMAC-SHA-256 Test Vector NIST CAVS #5
+sha256_hmac:24:"e5179687582b4dc4":"ce103bdacdf32f614f6727bcb31ca1c2824a850d00f5585b016fb234fe1ef2cd687f302d3c6b738ed89a24060d65c36675d0d96307c72ef3e8a83bfa8402e226de9d5d1724ba75c4879bf41a4a465ce61887d9f49a34757849b48bae81c27ebed76faae2ad669bca04747d409148d40812776e0ae2c395b3cb9c89981ce72d5c":"509581f6816df4b8cc9f2cf42b7cc6e6a5a1e375a16f2412"
+
+HMAC-SHA-256 Test Vector NIST CAVS #6
+sha256_hmac:24:"63cec6246aeb1b61":"c178db908a405fa88aa255b8cad22b4057016585f139ee930388b083d86062fa0b3ea1f23f8a43bd11bee8464bcbd19b5ab9f6a8038d5245516f8274d20c8ee3033a07b908da528fa00343bb595deed500cab9745c4cb6391c23300f0d3584b090b3326c4cfa342620b78f9f5b4f27f7307ed770643ec1764aeae3dcf1a3ec69":"64f3dd861b7c7d29fce9ae0ce9ed954b5d7141806ee9eec7"
+
+HMAC-SHA-384 Test Vector NIST CAVS #1
+sha384_hmac:32:"91a7401817386948ca952f9a20ee55dc":"2fea5b91035d6d501f3a834fa178bff4e64b99a8450432dafd32e4466b0e1e7781166f8a73f7e036b3b0870920f559f47bd1400a1a906e85e0dcf00a6c26862e9148b23806680f285f1fe4f93cdaf924c181a965465739c14f2268c8be8b471847c74b222577a1310bcdc1a85ef1468aa1a3fd4031213c97324b7509c9050a3d":"6d7be9490058cf413cc09fd043c224c2ec4fa7859b13783000a9a593c9f75838"
+
+HMAC-SHA-384 Test Vector NIST CAVS #2
+sha384_hmac:32:"d6cac19657061aa90a6da11cd2e9ea47":"9f482e4655173135dfaa22a11bbbe6af263db48716406c5aec162ba3c4b41cad4f5a91558377521191c7343118beee65982929802913d67b6de5c4bdc3d27299bd722219d5ad2efa5bdb9ff7b229fc4bbc3f60719320cf2e7a51cad1133d21bad2d80919b1836ef825308b7c51c6b7677ac782e2bc30007afba065681cbdd215":"f3d5f3c008175321aa7b2ea379eaa4f8b9dcc60f895ec8940b8162f80a7dfe9f"
+
+HMAC-SHA-384 Test Vector NIST CAVS #3
+sha384_hmac:32:"e06366ad149b8442cd4c1abdddd0afde":"2d140a194c02a5598f69174834679b8371234a0d505491f1bd03e128dd91a8bca2fb812e9d5da71613b5b00952ea78bf450d5b7547dea79135925085c7d3e6f52009c51ca3d88c6c09e9d074b0ee110736e0ec9b478b93efb34d7bf1c41b54decec43eab077a3aa4998ede53f67b4ea36c266745f9643d5360bdc8337c70dabf":"c19c67eda6fe29f3667bee1c897c333ce7683094ae77e84b4c16378d290895a1"
+
+HMAC-SHA-384 Test Vector NIST CAVS #4
+sha384_hmac:48:"01ac59f42f8bb91d1bd10fe6990d7a87":"3caf18c476edd5615f343ac7b7d3a9da9efade755672d5ba4b8ae8a7505539ea2c124ff755ec0457fbe49e43480b3c71e7f4742ec3693aad115d039f90222b030fdc9440313691716d5302005808c07627483b916fdf61983063c2eb1268f2deeef42fc790334456bc6bad256e31fc9066de7cc7e43d1321b1866db45e905622":"1985fa2163a5943fc5d92f1fe8831215e7e91f0bff5332bc713a072bdb3a8f9e5c5157463a3bfeb36231416e65973e64"
+
+HMAC-SHA-384 Test Vector NIST CAVS #5
+sha384_hmac:48:"fd74b9d9e102a3a80df1baf0cb35bace":"1a068917584813d1689ccbd0370c2114d537cdc8cc52bf6db16d5535f8f7d1ad0c850a9fa0cf62373ffbf7642b1f1e8164010d350721d798d9f99e9724830399c2fce26377e83d38845675457865c03d4a07d741a505ef028343eb29fd46d0f761f3792886998c1e5c32ac3bc7e6f08faed194b34f06eff4d5d4a5b42c481e0e":"a981eaf5de3d78b20ebd4414a4edd0657e3667cd808a0dbc430cf7252f73a5b24efa136039207bd59806897457d74e0c"
+
+HMAC-SHA-384 Test Vector NIST CAVS #5
+sha384_hmac:48:"9fe794f0e26b669fa5f6883149377c6c":"6010c9745e8f1d44cfdc99e7e0fd79bc4271944c2d1d84dba589073dfc4ca5eb98c59356f60cd87bef28aeb83a832bde339b2087daf942aa1f67876c5d5ed33924bed4143bc12a2be532ccaf64daa7e2bc3c8872b9823b0533b6f5159135effe8c61545536975d7c3a61ba7365ec35f165bc92b4d19eb9156ade17dfa1bb4161":"915ae61f8754698c2b6ef9629e93441f8541bd4258a5e05372d19136cfaefc0473b48d96119291b38eb1a3cb1982a986"
+
+HMAC-SHA-512 Test Vector NIST CAVS #1
+sha512_hmac:32:"c95a17c09940a691ed2d621571b0eb844ede55a9":"99cd28262e81f34878cdcebf4128e05e2098a7009278a66f4c785784d0e5678f3f2b22f86e982d273b6273a222ec61750b4556d766f1550a7aedfe83faedbc4bdae83fa560d62df17eb914d05fdaa48940551bac81d700f5fca7147295e386e8120d66742ec65c6ee8d89a92217a0f6266d0ddc60bb20ef679ae8299c8502c2f":"6bc1379d156559ddee2ed420ea5d5c5ff3e454a1059b7ba72c350e77b6e9333c"
+
+HMAC-SHA-512 Test Vector NIST CAVS #2
+sha512_hmac:32:"3b10b8fa718840d1dea8e9fc317476bcf55875fd":"f04f5b7073d7d0274e8354433b390306c5607632f5f589c12edb62d55673aff2366d2e6b24de731adf92e654baa30b1cfd4a069788f65ec1b99b015d904d8832110dbd74eae35a81562d14ce4136d820ad0a55ff5489ba678fbbc1c27663ec1349d70e740f0e0ec27cfbe8971819f4789e486b50a2d7271d77e2aaea50de62fd":"fc3c38c7a17e3ce06db033f1c172866f01a00045db55f2e234f71c82264f2ba2"
+
+HMAC-SHA-512 Test Vector NIST CAVS #3
+sha512_hmac:32:"4803d311394600dc1e0d8fc8cedeb8bde3fe7c42":"a10c125dd702a97153ad923ba5e9889cfac1ba169de370debe51f233735aa6effcc9785c4b5c7e48c477dc5c411ae6a959118584e26adc94b42c2b29b046f3cf01c65b24a24bd2e620bdf650a23bb4a72655b1100d7ce9a4dab697c6379754b4396c825de4b9eb73f2e6a6c0d0353bbdeaf706612800e137b858fdb30f3311c6":"7cd8236c55102e6385f52279506df6fcc388ab75092da21395ce14a82b202ffa"
+
+HMAC-SHA-512 Test Vector NIST CAVS #4
+sha512_hmac:48:"aeb2f3b977fa6c8e71e07c5a5c74ff58166de092":"22457355dc76095abd46846b41cfe49a06ce42ac8857b4702fc771508dfb3626e0bfe851df897a07b36811ec433766e4b4166c26301b3493e7440d4554b0ef6ac20f1a530e58fac8aeba4e9ff2d4898d8a28783b49cd269c2965fd7f8e4f2d60cf1e5284f2495145b72382aad90e153a90ecae125ad75336fb128825c23fb8b0":"fa39bd8fcc3bfa218f9dea5d3b2ce10a7619e31678a56d8a9d927b1fe703b125af445debe9a89a07db6194d27b44d85a"
+
+HMAC-SHA-512 Test Vector NIST CAVS #5
+sha512_hmac:48:"4285d3d7744da52775bb44ca436a3154f7980309":"208f0b6f2de2e5aa5df11927ddc6df485edc1193181c484d0f0a434a95418803101d4de9fdb798f93516a6916fa38a8207de1666fe50fe3441c03b112eaaae6954ed063f7ac4e3c1e3f73b20d153fe9e4857f5e91430f0a70ee820529adac2467469fd18adf10e2af0fea27c0abc83c5a9af77c364a466cffce8bab4e2b70bc1":"fe7603f205b2774fe0f14ecfa3e338e90608a806d11ca459dff5ce36b1b264ecd3af5f0492a7521d8da3102ba20927a5"
+
+HMAC-SHA-512 Test Vector NIST CAVS #6
+sha512_hmac:48:"8ab783d5acf32efa0d9c0a21abce955e96630d89":"17371e013dce839963d54418e97be4bd9fa3cb2a368a5220f5aa1b8aaddfa3bdefc91afe7c717244fd2fb640f5cb9d9bf3e25f7f0c8bc758883b89dcdce6d749d9672fed222277ece3e84b3ec01b96f70c125fcb3cbee6d19b8ef0873f915f173bdb05d81629ba187cc8ac1934b2f75952fb7616ae6bd812946df694bd2763af":"9ac7ca8d1aefc166b046e4cf7602ebe181a0e5055474bff5b342106731da0d7e48e4d87bc0a6f05871574289a1b099f8"
diff --git a/tests/suites/test_suite_hmac_shax.function b/tests/suites/test_suite_hmac_shax.function
new file mode 100644
index 0000000..7b4a0dc
--- /dev/null
+++ b/tests/suites/test_suite_hmac_shax.function
@@ -0,0 +1,120 @@
+BEGIN_HEADER
+#include <polarssl/sha1.h>
+#include <polarssl/sha2.h>
+#include <polarssl/sha4.h>
+END_HEADER
+
+BEGIN_CASE
+sha1_hmac:trunc_size:hex_key_string:hex_src_string:hex_hash_string
+{
+    unsigned char src_str[10000];
+    unsigned char key_str[10000];
+    unsigned char hash_str[10000];
+    unsigned char output[41];
+
+    memset(src_str, 0x00, 10000);
+    memset(key_str, 0x00, 10000);
+    memset(hash_str, 0x00, 10000);
+    memset(output, 0x00, 41);
+
+    int key_len = unhexify( key_str, {hex_key_string} );
+    int src_len = unhexify( src_str, {hex_src_string} );
+
+    sha1_hmac( key_str, key_len, src_str, src_len, output );
+    hexify( hash_str, output, 20 );
+
+    TEST_ASSERT( strncmp( (char *) hash_str, {hex_hash_string}, {trunc_size} * 2 ) == 0 );
+}
+END_CASE
+
+BEGIN_CASE
+sha224_hmac:trunc_size:hex_key_string:hex_src_string:hex_hash_string
+{
+    unsigned char src_str[10000];
+    unsigned char key_str[10000];
+    unsigned char hash_str[10000];
+    unsigned char output[57];
+
+    memset(src_str, 0x00, 10000);
+    memset(key_str, 0x00, 10000);
+    memset(hash_str, 0x00, 10000);
+    memset(output, 0x00, 57);
+
+    int key_len = unhexify( key_str, {hex_key_string} );
+    int src_len = unhexify( src_str, {hex_src_string} );
+
+    sha2_hmac( key_str, key_len, src_str, src_len, output, 1 );
+    hexify( hash_str, output, 28 );
+
+    TEST_ASSERT( strncmp( (char *) hash_str, {hex_hash_string}, {trunc_size} * 2 ) == 0 );
+}
+END_CASE
+
+BEGIN_CASE
+sha256_hmac:trunc_size:hex_key_string:hex_src_string:hex_hash_string
+{
+    unsigned char src_str[10000];
+    unsigned char key_str[10000];
+    unsigned char hash_str[10000];
+    unsigned char output[65];
+
+    memset(src_str, 0x00, 10000);
+    memset(key_str, 0x00, 10000);
+    memset(hash_str, 0x00, 10000);
+    memset(output, 0x00, 65);
+
+    int key_len = unhexify( key_str, {hex_key_string} );
+    int src_len = unhexify( src_str, {hex_src_string} );
+
+    sha2_hmac( key_str, key_len, src_str, src_len, output, 0 );
+    hexify( hash_str, output, 32 );
+
+    TEST_ASSERT( strncmp( (char *) hash_str, {hex_hash_string}, {trunc_size} * 2 ) == 0 );
+}
+END_CASE
+
+BEGIN_CASE
+sha384_hmac:trunc_size:hex_key_string:hex_src_string:hex_hash_string
+{
+    unsigned char src_str[10000];
+    unsigned char key_str[10000];
+    unsigned char hash_str[10000];
+    unsigned char output[97];
+
+    memset(src_str, 0x00, 10000);
+    memset(key_str, 0x00, 10000);
+    memset(hash_str, 0x00, 10000);
+    memset(output, 0x00, 97);
+
+    int key_len = unhexify( key_str, {hex_key_string} );
+    int src_len = unhexify( src_str, {hex_src_string} );
+
+    sha4_hmac( key_str, key_len, src_str, src_len, output, 1 );
+    hexify( hash_str, output, 48 );
+
+    TEST_ASSERT( strncmp( (char *) hash_str, {hex_hash_string}, {trunc_size} * 2 ) == 0 );
+}
+END_CASE
+
+BEGIN_CASE
+sha512_hmac:trunc_size:hex_key_string:hex_src_string:hex_hash_string
+{
+    unsigned char src_str[10000];
+    unsigned char key_str[10000];
+    unsigned char hash_str[10000];
+    unsigned char output[129];
+
+    memset(src_str, 0x00, 10000);
+    memset(key_str, 0x00, 10000);
+    memset(hash_str, 0x00, 10000);
+    memset(output, 0x00, 129);
+
+    int key_len = unhexify( key_str, {hex_key_string} );
+    int src_len = unhexify( src_str, {hex_src_string} );
+
+    sha4_hmac( key_str, key_len, src_str, src_len, output, 0 );
+    hexify( hash_str, output, 64 );
+
+    TEST_ASSERT( strncmp( (char *) hash_str, {hex_hash_string}, {trunc_size} * 2 ) == 0 );
+}
+END_CASE
diff --git a/tests/suites/test_suite_mdx.data b/tests/suites/test_suite_mdx.data
new file mode 100644
index 0000000..e930c04
--- /dev/null
+++ b/tests/suites/test_suite_mdx.data
@@ -0,0 +1,62 @@
+md2 Test vector RFC1319 #1
+md2_text:"":"8350e5a3e24c153df2275c9f80692773"
+
+md2 Test vector RFC1319 #2
+md2_text:"a":"32ec01ec4a6dac72c0ab96fb34c0b5d1"
+
+md2 Test vector RFC1319 #3
+md2_text:"abc":"da853b0d3f88d99b30283a69e6ded6bb"
+
+md2 Test vector RFC1319 #4
+md2_text:"message digest":"ab4f496bfb2a530b219ff33031fe06b0"
+
+md2 Test vector RFC1319 #5
+md2_text:"abcdefghijklmnopqrstuvwxyz":"4e8ddff3650292ab5a4108c3aa47940b"
+
+md2 Test vector RFC1319 #6
+md2_text:"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789":"da33def2a42df13975352846c30338cd"
+
+md2 Test vector RFC1319 #7
+md2_text:"12345678901234567890123456789012345678901234567890123456789012345678901234567890":"d5976f79d83d3a0dc9806c3c66f3efd8"
+
+md4 Test vector RFC1320 #1
+md4_text:"":"31d6cfe0d16ae931b73c59d7e0c089c0"
+
+md4 Test vector RFC1320 #2
+md4_text:"a":"bde52cb31de33e46245e05fbdbd6fb24"
+
+md4 Test vector RFC1320 #3
+md4_text:"abc":"a448017aaf21d8525fc10ae87aa6729d"
+
+md4 Test vector RFC1320 #4
+md4_text:"message digest":"d9130a8164549fe818874806e1c7014b"
+
+md4 Test vector RFC1320 #5
+md4_text:"abcdefghijklmnopqrstuvwxyz":"d79e1c308aa5bbcdeea8ed63df412da9"
+
+md4 Test vector RFC1320 #6
+md4_text:"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789":"043f8582f241db351ce627e153e7f0e4"
+
+md4 Test vector RFC1320 #7
+md4_text:"12345678901234567890123456789012345678901234567890123456789012345678901234567890":"e33b4ddc9c38f2199c3e7b164fcc0536"
+
+md5 Test vector RFC1321 #1
+md5_text:"":"d41d8cd98f00b204e9800998ecf8427e"
+
+md5 Test vector RFC1321 #2
+md5_text:"a":"0cc175b9c0f1b6a831c399e269772661"
+
+md5 Test vector RFC1321 #3
+md5_text:"abc":"900150983cd24fb0d6963f7d28e17f72"
+
+md5 Test vector RFC1321 #4
+md5_text:"message digest":"f96b697d7cb7938d525a2f31aaf161d0"
+
+md5 Test vector RFC1321 #5
+md5_text:"abcdefghijklmnopqrstuvwxyz":"c3fcd3d76192e4007dfb496cca67e13b"
+
+md5 Test vector RFC1321 #6
+md5_text:"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789":"d174ab98d277d9f5a5611c2c9f419d9f"
+
+md5 Test vector RFC1321 #7
+md5_text:"12345678901234567890123456789012345678901234567890123456789012345678901234567890":"57edf4a22be3c955ac49da2e2107b67a"
diff --git a/tests/suites/test_suite_mdx.function b/tests/suites/test_suite_mdx.function
new file mode 100644
index 0000000..62046d7
--- /dev/null
+++ b/tests/suites/test_suite_mdx.function
@@ -0,0 +1,65 @@
+BEGIN_HEADER
+#include <polarssl/md2.h>
+#include <polarssl/md4.h>
+#include <polarssl/md5.h>
+END_HEADER
+
+BEGIN_CASE
+md2_text:text_src_string:hex_hash_string
+{
+    unsigned char src_str[1000];
+    unsigned char hash_str[1000];
+    unsigned char output[33];
+
+    memset(src_str, 0x00, 1000);
+    memset(hash_str, 0x00, 1000);
+    memset(output, 0x00, 33);
+
+    strcpy( (char *) src_str, {text_src_string} );
+
+    md2( src_str, strlen( (char *) src_str ), output );
+    hexify( hash_str, output, 16 );
+
+    TEST_ASSERT( strcmp( (char *) hash_str, {hex_hash_string} ) == 0 );
+}
+END_CASE
+
+BEGIN_CASE
+md4_text:text_src_string:hex_hash_string
+{
+    unsigned char src_str[1000];
+    unsigned char hash_str[1000];
+    unsigned char output[33];
+
+    memset(src_str, 0x00, 1000);
+    memset(hash_str, 0x00, 1000);
+    memset(output, 0x00, 33);
+
+    strcpy( (char *) src_str, {text_src_string} );
+
+    md4( src_str, strlen( (char *) src_str ), output );
+    hexify( hash_str, output, 16 );
+
+    TEST_ASSERT( strcmp( (char *) hash_str, {hex_hash_string} ) == 0 );
+}
+END_CASE
+
+BEGIN_CASE
+md5_text:text_src_string:hex_hash_string
+{
+    unsigned char src_str[1000];
+    unsigned char hash_str[1000];
+    unsigned char output[33];
+
+    memset(src_str, 0x00, 1000);
+    memset(hash_str, 0x00, 1000);
+    memset(output, 0x00, 33);
+
+    strcpy( (char *) src_str, {text_src_string} );
+
+    md5( src_str, strlen( (char *) src_str ), output );
+    hexify( hash_str, output, 16 );
+
+    TEST_ASSERT( strcmp( (char *) hash_str, {hex_hash_string} ) == 0 );
+}
+END_CASE
diff --git a/tests/suites/test_suite_mpi.data b/tests/suites/test_suite_mpi.data
new file mode 100644
index 0000000..ac25ceb
--- /dev/null
+++ b/tests/suites/test_suite_mpi.data
@@ -0,0 +1,341 @@
+Base test mpi_read_write_string #1
+mpi_read_write_string:10:"128":10:"128"
+
+Base test mpi_read_write_string #2
+mpi_read_write_string:10:"128":16:"80"
+
+Base test mpi_read_write_string #3 (Read zero)
+mpi_read_write_string:10:"0":10:"0"
+
+Base test mpi_read_write_string #3 (Negative decimal)
+mpi_read_write_string:10:"-23":10:"-23"
+
+Base test mpi_read_write_string #3 (Negative hex)
+mpi_read_write_string:16:"-20":10:"-32"
+
+Base test mpi_read_write_string #3 (Negative decimal)
+mpi_read_write_string:16:"-23":16:"-23"
+
+Base test mpi_cmp_int #1
+mpi_cmp_int:693:693:0
+
+Base test mpi_cmp_int #2
+mpi_cmp_int:693:692:1
+
+Base test mpi_cmp_int #3
+mpi_cmp_int:693:694:-1
+
+Base test mpi_cmp_int (Negative values) #1
+mpi_cmp_int:-2:-2:0
+
+Base test mpi_cmp_int (Negative values) #2
+mpi_cmp_int:-2:-3:1
+
+Base test mpi_cmp_int (Negative values) #3
+mpi_cmp_int:-2:-1:-1
+
+Base test mpi_cmp_mpi #1
+mpi_cmp_mpi:10:"693":10:"693":0
+
+Base test mpi_cmp_mpi #2
+mpi_cmp_mpi:10:"693":10:"692":1
+
+Base test mpi_cmp_mpi #3
+mpi_cmp_mpi:10:"693":10:"694":-1
+
+Base test mpi_cmp_mpi (Negative values) #1
+mpi_cmp_mpi:10:"-2":10:"-2":0
+
+Base test mpi_cmp_mpi (Negative values) #2
+mpi_cmp_mpi:10:"-2":10:"-3":1
+
+Base test mpi_cmp_mpi (Negative values) #3
+mpi_cmp_mpi:10:"-2":10:"-1":-1
+
+Base test mpi_cmp_abs #1
+mpi_cmp_abs:10:"693":10:"693":0
+
+Base test mpi_cmp_abs #2
+mpi_cmp_abs:10:"693":10:"692":1
+
+Base test mpi_cmp_abs #3
+mpi_cmp_abs:10:"693":10:"694":-1
+
+Base test mpi_cmp_abs (Negative values) #1
+mpi_cmp_abs:10:"-2":10:"-2":0
+
+Base test mpi_cmp_abs (Negative values) #2
+mpi_cmp_abs:10:"-2":10:"-3":-1
+
+Base test mpi_cmp_abs (Negative values) #3
+mpi_cmp_abs:10:"-2":10:"-1":1
+
+Base test mpi_cmp_abs (Mix values) #1
+mpi_cmp_abs:10:"-2":10:"2":0
+
+Base test mpi_cmp_abs (Mix values) #2
+mpi_cmp_abs:10:"2":10:"-3":-1
+
+Base test mpi_cmp_abs (Mix values) #3
+mpi_cmp_abs:10:"-2":10:"1":1
+
+Base test mpi_copy #1
+mpi_copy:0:1500
+
+Base test mpi_swap #1
+mpi_swap:0:1500
+
+Base test mpi_add_abs #1
+mpi_add_abs:10:"12345678":10:"642531":10:"12988209"
+
+Base test mpi_add_abs #2
+mpi_add_abs:10:"-12345678":10:"642531":10:"12988209"
+
+Base test mpi_add_abs #3
+mpi_add_abs:10:"12345678":10:"-642531":10:"12988209"
+
+Base test mpi_add_abs #4
+mpi_add_abs:10:"-12345678":10:"-642531":10:"12988209"
+
+Test mpi_add_abs #1
+mpi_add_abs:10:"-643808006803554439230129854961492699151386107534013432918073439524138264842370630061369715394739134090922937332590384720397133335969549256322620979036686633213903952966175107096769180017646161851573147596390153":10:"56125680981752282333498088313568935051383833838594899821664631784577337171193624243181360054669678410455329112434552942717084003541384594864129940145043086760031292483340068923506115878221189886491132772739661669044958531131327771":10:"56125680981752282334141896320372489490613963693556392520816017892111350604111697682705498319512049040516698827829292076808006940873974979584527073481012636016353913462376755556720019831187364993587901952757307830896531678727717924"
+
+Base test mpi_add_mpi #1
+mpi_add_mpi:10:"12345678":10:"642531":10:"12988209"
+
+Base test mpi_add_mpi #2
+mpi_add_mpi:10:"-12345678":10:"642531":10:"-11703147"
+
+Base test mpi_add_mpi #3
+mpi_add_mpi:10:"12345678":10:"-642531":10:"11703147"
+
+Base test mpi_add_mpi #4
+mpi_add_mpi:10:"-12345678":10:"-642531":10:"-12988209"
+
+Test mpi_add_mpi #1
+mpi_add_mpi:10:"203956878356401977405765866929034577280193993314348263094772646453283062722701277632936616063144088173312372882677123879538709400158306567338328279154499698366071906766440037074217117805690872792848149112022286332144876183376326512083574821647933992961249917319836219304274280243803104015000563790123":10:"531872289054204184185084734375133399408303613982130856645299464930952178606045848877129147820387996428175564228204785846141207532462936339834139412401975338705794646595487324365194792822189473092273993580587964571659678084484152603881094176995594813302284232006001752128168901293560051833646881436219":10:"735829167410606161590850601304167976688497607296479119740072111384235241328747126510065763883532084601487937110881909725679916932621242907172467691556475037071866553361927361439411910627880345885122142692610250903804554267860479115964668998643528806263534149325837971432443181537363155848647445226342"
+
+Test mpi_add_mpi #2
+mpi_add_mpi:10:"643808006803554439230129854961492699151386107534013432918073439524138264842370630061369715394739134090922937332590384720397133335969549256322620979036686633213903952966175107096769180017646161851573147596390153":10:"56125680981752282333498088313568935051383833838594899821664631784577337171193624243181360054669678410455329112434552942717084003541384594864129940145043086760031292483340068923506115878221189886491132772739661669044958531131327771":10:"56125680981752282334141896320372489490613963693556392520816017892111350604111697682705498319512049040516698827829292076808006940873974979584527073481012636016353913462376755556720019831187364993587901952757307830896531678727717924"
+
+Test mpi_add_int #1
+mpi_add_int:10:"2039568783564019774057658669290345772801939933143482630947726464532830627227012776329":9871232:10:"2039568783564019774057658669290345772801939933143482630947726464532830627227022647561"
+
+Test mpi_add_int #2
+mpi_add_int:10:"2039568783564019774057658669290345772801939933143482630947726464532830627227012776329":-9871232:10:"2039568783564019774057658669290345772801939933143482630947726464532830627227002905097"
+
+Base test mpi_sub_abs #1 (Test with larger second input)
+mpi_sub_abs:10:"5":10:"7":10:"0":POLARSSL_ERR_MPI_NEGATIVE_VALUE
+
+Base test mpi_sub_abs #2 (Test with larger second input)
+mpi_sub_abs:10:"-5":10:"-7":10:"0":POLARSSL_ERR_MPI_NEGATIVE_VALUE
+
+Base test mpi_sub_abs #3 (Test with larger second input)
+mpi_sub_abs:10:"-5":10:"7":10:"0":POLARSSL_ERR_MPI_NEGATIVE_VALUE
+
+Base test mpi_sub_abs #4 (Test with larger second input)
+mpi_sub_abs:10:"5":10:"-7":10:"0":POLARSSL_ERR_MPI_NEGATIVE_VALUE
+
+Base test mpi_sub_abs #1
+mpi_sub_abs:10:"7":10:"5":10:"2":0
+
+Base test mpi_sub_abs #2
+mpi_sub_abs:10:"-7":10:"-5":10:"2":0
+
+Base test mpi_sub_abs #3
+mpi_sub_abs:10:"-7":10:"5":10:"2":0
+
+Base test mpi_sub_abs #4
+mpi_sub_abs:10:"7":10:"-5":10:"2":0
+
+Base test mpi_sub_mpi #1 (Test with negative result)
+mpi_sub_mpi:10:"5":10:"7":10:"-2"
+
+Base test mpi_sub_mpi #2 (Test with negative inputs)
+mpi_sub_mpi:10:"-5":10:"-7":10:"2"
+
+Base test mpi_sub_mpi #3 (Test with negative base)
+mpi_sub_mpi:10:"-5":10:"7":10:"-12"
+
+Base test mpi_sub_mpi #4 (Test with negative substraction)
+mpi_sub_mpi:10:"5":10:"-7":10:"12"
+
+Test mpi_sub_mpi #1
+mpi_sub_mpi:10:"531872289054204184185084734375133399408303613982130856645299464930952178606045848877129147820387996428175564228204785846141207532462936339834139412401975338705794646595487324365194792822189473092273993580587964571659678084484152603881094176995594813302284232006001752128168901293560051833646881436219":10:"203956878356401977405765866929034577280193993314348263094772646453283062722701277632936616063144088173312372882677123879538709400158306567338328279154499698366071906766440037074217117805690872792848149112022286332144876183376326512083574821647933992961249917319836219304274280243803104015000563790123":10:"327915410697802206779318867446098822128109620667782593550526818477669115883344571244192531757243908254863191345527661966602498132304629772495811133247475640339722739829047287290977675016498600299425844468565678239514801901107826091797519355347660820341034314686165532823894621049756947818646317646096"
+
+Test mpi_sub_mpi #2 (Test for negative result)
+mpi_sub_mpi:10:"643808006803554439230129854961492699151386107534013432918073439524138264842370630061369715394739134090922937332590384720397133335969549256322620979036686633213903952966175107096769180017646161851573147596390153":10:"56125680981752282333498088313568935051383833838594899821664631784577337171193624243181360054669678410455329112434552942717084003541384594864129940145043086760031292483340068923506115878221189886491132772739661669044958531131327771":10:"-56125680981752282332854280306765380612153703983633407122513245677043323738275550803657221789827307780393959397039813808626161066208794210143732806809073537503708671504303382290292211925255014779394363592722015507193385383534937618"
+
+Test mpi_sub_int #1
+mpi_sub_int:10:"2039568783564019774057658669290345772801939933143482630947726464532830627227012776329":-9871232:10:"2039568783564019774057658669290345772801939933143482630947726464532830627227022647561"
+
+Test mpi_sub_int #2
+mpi_sub_int:10:"2039568783564019774057658669290345772801939933143482630947726464532830627227012776329":9871232:10:"2039568783564019774057658669290345772801939933143482630947726464532830627227002905097"
+
+Test mpi_shift_l #1
+mpi_shift_l:10:"64":1:10:"128"
+
+Test mpi_shift_l #2
+mpi_shift_l:10:"658385546911733550164516088405238961461880256029834598831972039469421755117818013653494814438931957316403111689187691446941406788869098983929874080332195117465344344350008880118042764943201875870917468833709791733282363323948005998269792207":37:10:"90487820548639020691922304619723076305400961610119884872723190678642804168382367856686134531865643066983017249846286450251272364365605022750900439437595355052945035915579216557330505438734955340526145476988250171181404966718289259743378883640981192704"
+
+Test mpi_shift_r #1
+mpi_shift_r:10:"128":1:10:"64"
+
+Test mpi_shift_r #2
+mpi_shift_r:10:"120815570979701484704906977000760567182871429114712069861589084706550626575967516787438008593490722779337547394120718248995900363209947025063336882559539208430319216688889117222633155838468458047056355241515415159736436403445579777425189969":45:10:"3433785053053426415343295076376096153094051405637175942660777670498379921354157795219578264137985649407981651226029903483433269093721578004287291678324982297860947730012217028349628999378309630601971640587504883789518896817457"
+
+Base test mpi_mul_mpi #1
+mpi_mul_mpi:10:"5":10:"7":10:"35"
+
+Base test mpi_mul_mpi #2
+mpi_mul_mpi:10:"-5":10:"7":10:"-35"
+
+Base test mpi_mul_mpi #3
+mpi_mul_mpi:10:"5":10:"-7":10:"-35"
+
+Base test mpi_mul_mpi #4
+mpi_mul_mpi:10:"-5":10:"-7":10:"35"
+
+Test mpi_mul_mpi #1
+mpi_mul_mpi:10:"28911710017320205966167820725313234361535259163045867986277478145081076845846493521348693253530011243988160148063424837895971948244167867236923919506962312185829914482993478947657472351461336729641485069323635424692930278888923450060546465883490944265147851036817433970984747733020522259537":10:"16471581891701794764704009719057349996270239948993452268812975037240586099924712715366967486587417803753916334331355573776945238871512026832810626226164346328807407669366029926221415383560814338828449642265377822759768011406757061063524768140567867350208554439342320410551341675119078050953":10:"476221599179424887669515829231223263939342135681791605842540429321038144633323941248706405375723482912535192363845116154236465184147599697841273424891410002781967962186252583311115708128167171262206919514587899883547279647025952837516324649656913580411611297312678955801899536937577476819667861053063432906071315727948826276092545739432005962781562403795455162483159362585281248265005441715080197800335757871588045959754547836825977169125866324128449699877076762316768127816074587766799018626179199776188490087103869164122906791440101822594139648973454716256383294690817576188761"
+
+Test mpi_mul_int #1
+mpi_mul_int:10:"2039568783564019774057658669290345772801939933143482630947726464532830627227012776329":9871232:10:"20133056642518226042310730101376278483547239130123806338055387803943342738063359782107667328":==
+
+Test mpi_mul_int #2 (Unsigned, thus failure)
+mpi_mul_int:10:"2039568783564019774057658669290345772801939933143482630947726464532830627227012776329":-9871232:10:"-20133056642518226042310730101376278483547239130123806338055387803943342738063359782107667328":!=
+
+Test mpi_mul_int #3
+mpi_mul_int:10:"-2039568783564019774057658669290345772801939933143482630947726464532830627227012776329":9871232:10:"-20133056642518226042310730101376278483547239130123806338055387803943342738063359782107667328":==
+
+Test mpi_mul_int #4 (Unsigned, thus failure)
+mpi_mul_int:10:"-2039568783564019774057658669290345772801939933143482630947726464532830627227012776329":-9871232:10:"20133056642518226042310730101376278483547239130123806338055387803943342738063359782107667328":!=
+
+Base test mpi_div_mpi #1
+mpi_div_mpi:10:"1000":10:"13":10:"76":10:"12":0
+
+Base test mpi_div_mpi #2 (Divide by zero)
+mpi_div_mpi:10:"1000":10:"0":10:"1":10:"1":POLARSSL_ERR_MPI_DIVISION_BY_ZERO
+
+Base test mpi_div_mpi #3
+mpi_div_mpi:10:"1000":10:"-13":10:"-76":10:"12":0
+
+Test mpi_div_mpi #1
+mpi_div_mpi:10:"20133056642518226042310730101376278483547239130123806338055387803943342738063359782107667328":10:"34":10:"592148724779947824773845002981655249516095268533053127589864347174804198178334111238460803":10:"26":0
+
+Test mpi_div_mpi #2
+mpi_div_mpi:10:"476221599179424887669515829231223263939342135681791605842540429321038144633323941248706405375723482912535192363845116154236465184147599697841273424891410002781967962186252583311115708128167171262206919514587899883547279647025952837516324649656913580411611297312678955801899536937577476819667861053063432906071315727948826276092545739432005962781562403795455162483159362585281248265005441715080197800335757871588045959754547836825977169125866324128449699877076762316768127816074587766799018626179199776188490087103869164122906791440101822594139648973454716256383294690817576188762":10:"28911710017320205966167820725313234361535259163045867986277478145081076845846493521348693253530011243988160148063424837895971948244167867236923919506962312185829914482993478947657472351461336729641485069323635424692930278888923450060546465883490944265147851036817433970984747733020522259537":10:"16471581891701794764704009719057349996270239948993452268812975037240586099924712715366967486587417803753916334331355573776945238871512026832810626226164346328807407669366029926221415383560814338828449642265377822759768011406757061063524768140567867350208554439342320410551341675119078050953":10:"1":0
+
+Base test mpi_div_int #1
+mpi_div_int:10:"1000":13:10:"76":10:"12":0
+
+Base test mpi_div_mpi #2 (Divide by zero)
+mpi_div_int:10:"1000":0:10:"1":10:"1":POLARSSL_ERR_MPI_DIVISION_BY_ZERO
+
+Base test mpi_div_int #3
+mpi_div_int:10:"1000":-13:10:"-76":10:"12":0
+
+Test mpi_div_int #1
+mpi_div_int:10:"20133056642518226042310730101376278483547239130123806338055387803943342738063359782107667328":34:10:"592148724779947824773845002981655249516095268533053127589864347174804198178334111238460803":10:"26":0
+
+Test mpi_div_int #2
+mpi_div_int:10:"20133056642518226042310730101376278483547239130123806338055387803943342738063359782107667328":-34:10:"-592148724779947824773845002981655249516095268533053127589864347174804198178334111238460803":10:"26":0
+
+Base test mpi_mod_mpi #1
+mpi_mod_mpi:10:"1000":10:"13":10:"12":0
+
+Base test mpi_mod_mpi #2 (Divide by zero)
+mpi_mod_mpi:10:"1000":10:"0":10:"0":POLARSSL_ERR_MPI_DIVISION_BY_ZERO
+
+Base test mpi_mod_mpi #3
+mpi_mod_mpi:10:"-1000":10:"13":10:"1":0
+
+Base test mpi_mod_mpi #4 (Negative modulo)
+mpi_mod_mpi:10:"1000":10:"-13":10:"-1":POLARSSL_ERR_MPI_NEGATIVE_VALUE
+
+Base test mpi_mod_mpi #5 (Negative modulo)
+mpi_mod_mpi:10:"-1000":10:"-13":10:"-12":POLARSSL_ERR_MPI_NEGATIVE_VALUE
+
+Base test mpi_mod_int #1
+mpi_mod_int:10:"1000":13:12:0
+
+Base test mpi_mod_int #2 (Divide by zero)
+mpi_mod_int:10:"1000":0:0:POLARSSL_ERR_MPI_DIVISION_BY_ZERO
+
+Base test mpi_mod_int #3
+mpi_mod_int:10:"-1000":13:1:0
+
+Base test mpi_mod_int #4 (Negative modulo)
+mpi_mod_int:10:"1000":-13:0:POLARSSL_ERR_MPI_NEGATIVE_VALUE
+
+Base test mpi_mod_int #5 (Negative modulo)
+mpi_mod_int:10:"-1000":-13:0:POLARSSL_ERR_MPI_NEGATIVE_VALUE
+
+Base test mpi_exp_mod #1
+mpi_exp_mod:10:"23":10:"13":10:"29":10:"":10:"24":0
+
+Base test mpi_exp_mod #2
+mpi_exp_mod:10:"23":10:"13":10:"30":10:"":10:"0":POLARSSL_ERR_MPI_BAD_INPUT_DATA
+
+Base test mpi_exp_mod #3
+mpi_exp_mod:10:"23":10:"13":10:"-29":10:"":10:"24":POLARSSL_ERR_MPI_BAD_INPUT_DATA
+
+Test mpi_exp_mod #1
+mpi_exp_mod:10:"433019240910377478217373572959560109819648647016096560523769010881172869083338285573756574557395862965095016483867813043663981946477698466501451832407592327356331263124555137732393938242285782144928753919588632679050799198937132922145084847":10:"5781538327977828897150909166778407659250458379645823062042492461576758526757490910073628008613977550546382774775570888130029763571528699574717583228939535960234464230882573615930384979100379102915657483866755371559811718767760594919456971354184113721":10:"583137007797276923956891216216022144052044091311388601652961409557516421612874571554415606746479105795833145583959622117418531166391184939066520869800857530421873250114773204354963864729386957427276448683092491947566992077136553066273207777134303397724679138833126700957":10:"":10:"114597449276684355144920670007147953232659436380163461553186940113929777196018164149703566472936578890991049344459204199888254907113495794730452699842273939581048142004834330369483813876618772578869083248061616444392091693787039636316845512292127097865026290173004860736":0
+
+Base test GCD #1
+mpi_gcd:10:"693":10:"609":10:"21"
+
+Base test GCD #2
+mpi_gcd:10:"1764":10:"868":10:"28"
+
+Base test GCD #3
+mpi_gcd:10:"768454923":10:"542167814":10:"1"
+
+Test GCD #1
+mpi_gcd:10:"433019240910377478217373572959560109819648647016096560523769010881172869083338285573756574557395862965095016483867813043663981946477698466501451832407592327356331263124555137732393938242285782144928753919588632679050799198937132922145084847":10:"5781538327977828897150909166778407659250458379645823062042492461576758526757490910073628008613977550546382774775570888130029763571528699574717583228939535960234464230882573615930384979100379102915657483866755371559811718767760594919456971354184113721":10:"1"
+
+Base test mpi_inv_mod #1
+mpi_inv_mod:10:"3":10:"11":10:"4":0
+
+Base test mpi_inv_mod #2
+mpi_inv_mod:10:"3":10:"0":10:"0":POLARSSL_ERR_MPI_BAD_INPUT_DATA
+
+Base test mpi_inv_mod #3
+mpi_inv_mod:10:"3":10:"-11":10:"4":POLARSSL_ERR_MPI_BAD_INPUT_DATA
+
+Base test mpi_inv_mod #4
+mpi_inv_mod:10:"2":10:"4":10:"0":POLARSSL_ERR_MPI_NOT_ACCEPTABLE
+
+Test mpi_inv_mod #1
+mpi_inv_mod:16:"aa4df5cb14b4c31237f98bd1faf527c283c2d0f3eec89718664ba33f9762907c":16:"fffbbd660b94412ae61ead9c2906a344116e316a256fd387874c6c675b1d587d":16:"8d6a5c1d7adeae3e94b9bcd2c47e0d46e778bc8804a2cc25c02d775dc3d05b0c":0
+
+Base test mpi_is_prime #1
+mpi_is_prime:10:"0":POLARSSL_ERR_MPI_NOT_ACCEPTABLE
+
+Base test mpi_is_prime #2
+mpi_is_prime:10:"1":POLARSSL_ERR_MPI_NOT_ACCEPTABLE
+
+Base test mpi_is_prime #3
+mpi_is_prime:10:"2":0
+
+Base test mpi_is_prime #4
+mpi_is_prime:10:"3":0
+
+Base test mpi_is_prime #5
+mpi_is_prime:10:"4":POLARSSL_ERR_MPI_NOT_ACCEPTABLE
+
+Base test mpi_is_prime #6
+mpi_is_prime:10:"5":0
+
+Base test mpi_is_prime #7
+mpi_is_prime:10:"27":POLARSSL_ERR_MPI_NOT_ACCEPTABLE
+
+Base test mpi_is_prime #8
+mpi_is_prime:10:"47":0
+
+Test mpi_is_prime #1
+mpi_is_prime:10:"827131507221654563937832686696200995595835694437983658840870036586124168186967796809117749047430768825822857042432722828096779098498192459819306321073968735177531164565305635281198148032612029767584644305912099":0
+
+Test mpi_is_prime #2
+mpi_is_prime:10:"827131507221654563937832686696200995595835694437983658840870036586124168186967796809117749047430768825822857042432722828096779098498192459819306321073968735177531164565305635281198148032612029767584644305912001":POLARSSL_ERR_MPI_NOT_ACCEPTABLE
diff --git a/tests/suites/test_suite_mpi.function b/tests/suites/test_suite_mpi.function
new file mode 100644
index 0000000..cea5edd
--- /dev/null
+++ b/tests/suites/test_suite_mpi.function
@@ -0,0 +1,391 @@
+BEGIN_HEADER
+#include <polarssl/bignum.h>
+
+static int myrand( void *rng_state )
+{
+    if( rng_state != NULL )
+        rng_state  = NULL;
+
+    return( rand() );
+}
+
+END_HEADER
+
+BEGIN_CASE
+mpi_read_write_string:radix_X:input_X:radix_A:input_A
+{
+    mpi X;
+    char str[1000];
+    int len = 1000;
+
+    mpi_init(&X, NULL);
+
+    TEST_ASSERT( mpi_read_string( &X, {radix_X}, {input_X} ) == 0 );
+    TEST_ASSERT( mpi_write_string( &X, {radix_A}, str, &len ) == 0 );
+    TEST_ASSERT( strcmp( str, {input_A} ) == 0 );
+}
+END_CASE
+
+BEGIN_CASE
+mpi_gcd:radix_X:input_X:radix_Y:input_Y:radix_A:input_A
+{
+    mpi A, X, Y, Z;
+    mpi_init(&A, &X, &Y, &Z, NULL);
+
+    TEST_ASSERT( mpi_read_string( &X, {radix_X}, {input_X} ) == 0 );
+    TEST_ASSERT( mpi_read_string( &Y, {radix_Y}, {input_Y} ) == 0 );
+    TEST_ASSERT( mpi_read_string( &A, {radix_A}, {input_A} ) == 0 );
+    TEST_ASSERT( mpi_gcd( &Z, &X, &Y ) == 0 );
+    TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 );
+}
+END_CASE
+
+BEGIN_CASE
+mpi_cmp_int:input_X:input_A:result_CMP
+{
+    mpi X;
+    mpi_init(&X, NULL);
+
+    TEST_ASSERT( mpi_lset( &X, {input_X} ) == 0);
+    TEST_ASSERT( mpi_cmp_int( &X, {input_A} ) == {result_CMP});
+}
+END_CASE
+
+BEGIN_CASE
+mpi_cmp_mpi:radix_X:input_X:radix_Y:input_Y:input_A
+{
+    mpi X, Y;
+    mpi_init(&X, &Y, NULL);
+
+    TEST_ASSERT( mpi_read_string( &X, {radix_X}, {input_X} ) == 0 );
+    TEST_ASSERT( mpi_read_string( &Y, {radix_Y}, {input_Y} ) == 0 );
+    TEST_ASSERT( mpi_cmp_mpi( &X, &Y ) == {input_A} );
+}
+END_CASE
+
+BEGIN_CASE
+mpi_cmp_abs:radix_X:input_X:radix_Y:input_Y:input_A
+{
+    mpi X, Y;
+    mpi_init(&X, &Y, NULL);
+
+    TEST_ASSERT( mpi_read_string( &X, {radix_X}, {input_X} ) == 0 );
+    TEST_ASSERT( mpi_read_string( &Y, {radix_Y}, {input_Y} ) == 0 );
+    TEST_ASSERT( mpi_cmp_abs( &X, &Y ) == {input_A} );
+}
+END_CASE
+
+BEGIN_CASE
+mpi_copy:input_X:input_A
+{
+    mpi X, Y, A;
+    mpi_init(&X, &Y, &A, NULL);
+
+    TEST_ASSERT( mpi_lset( &X, {input_X} ) == 0 );
+    TEST_ASSERT( mpi_lset( &Y, {input_A} ) == 0 );
+    TEST_ASSERT( mpi_lset( &A, {input_A} ) == 0 );
+    TEST_ASSERT( mpi_cmp_mpi( &X, &Y ) != 0 );
+    TEST_ASSERT( mpi_cmp_mpi( &Y, &A ) == 0 );
+    TEST_ASSERT( mpi_copy( &Y, &X ) == 0 );
+    TEST_ASSERT( mpi_cmp_mpi( &X, &Y ) == 0 );
+    TEST_ASSERT( mpi_cmp_mpi( &Y, &A ) != 0 );
+}
+END_CASE
+
+BEGIN_CASE
+mpi_swap:input_X:input_Y
+{
+    mpi X, Y, A;
+    mpi_init(&X, &Y, &A, NULL);
+
+    TEST_ASSERT( mpi_lset( &X, {input_X} ) == 0 );
+    TEST_ASSERT( mpi_lset( &Y, {input_Y} ) == 0 );
+    TEST_ASSERT( mpi_lset( &A, {input_X} ) == 0 );
+    TEST_ASSERT( mpi_cmp_mpi( &X, &Y ) != 0 );
+    TEST_ASSERT( mpi_cmp_mpi( &X, &A ) == 0 );
+    mpi_swap( &X, &Y );
+    TEST_ASSERT( mpi_cmp_mpi( &X, &Y ) != 0 );
+    TEST_ASSERT( mpi_cmp_mpi( &Y, &A ) == 0 );
+}
+END_CASE
+
+BEGIN_CASE
+mpi_add_mpi:radix_X:input_X:radix_Y:input_Y:radix_A:input_A
+{
+    mpi X, Y, Z, A;
+    mpi_init(&X, &Y, &Z, &A, NULL);
+
+    TEST_ASSERT( mpi_read_string( &X, {radix_X}, {input_X} ) == 0 );
+    TEST_ASSERT( mpi_read_string( &Y, {radix_Y}, {input_Y} ) == 0 );
+    TEST_ASSERT( mpi_read_string( &A, {radix_A}, {input_A} ) == 0 );
+    TEST_ASSERT( mpi_add_mpi( &Z, &X, &Y ) == 0 );
+    TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 );
+}
+END_CASE
+
+BEGIN_CASE
+mpi_add_abs:radix_X:input_X:radix_Y:input_Y:radix_A:input_A
+{
+    mpi X, Y, Z, A;
+    mpi_init(&X, &Y, &Z, &A, NULL);
+
+    TEST_ASSERT( mpi_read_string( &X, {radix_X}, {input_X} ) == 0 );
+    TEST_ASSERT( mpi_read_string( &Y, {radix_Y}, {input_Y} ) == 0 );
+    TEST_ASSERT( mpi_read_string( &A, {radix_A}, {input_A} ) == 0 );
+    TEST_ASSERT( mpi_add_abs( &Z, &X, &Y ) == 0 );
+    TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 );
+}
+END_CASE
+
+BEGIN_CASE
+mpi_add_int:radix_X:input_X:input_Y:radix_A:input_A
+{
+    mpi X, Z, A;
+    mpi_init(&X, &Z, &A, NULL);
+
+    TEST_ASSERT( mpi_read_string( &X, {radix_X}, {input_X} ) == 0 );
+    TEST_ASSERT( mpi_read_string( &A, {radix_A}, {input_A} ) == 0 );
+    TEST_ASSERT( mpi_add_int( &Z, &X, {input_Y} ) == 0 );
+    TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 );
+}
+END_CASE
+
+BEGIN_CASE
+mpi_sub_mpi:radix_X:input_X:radix_Y:input_Y:radix_A:input_A
+{
+    mpi X, Y, Z, A;
+    mpi_init(&X, &Y, &Z, &A, NULL);
+
+    TEST_ASSERT( mpi_read_string( &X, {radix_X}, {input_X} ) == 0 );
+    TEST_ASSERT( mpi_read_string( &Y, {radix_Y}, {input_Y} ) == 0 );
+    TEST_ASSERT( mpi_read_string( &A, {radix_A}, {input_A} ) == 0 );
+    TEST_ASSERT( mpi_sub_mpi( &Z, &X, &Y ) == 0 );
+    TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 );
+}
+END_CASE
+
+BEGIN_CASE
+mpi_sub_abs:radix_X:input_X:radix_Y:input_Y:radix_A:input_A:sub_result
+{
+    mpi X, Y, Z, A;
+    int res;
+    mpi_init(&X, &Y, &Z, &A, NULL);
+
+    TEST_ASSERT( mpi_read_string( &X, {radix_X}, {input_X} ) == 0 );
+    TEST_ASSERT( mpi_read_string( &Y, {radix_Y}, {input_Y} ) == 0 );
+    TEST_ASSERT( mpi_read_string( &A, {radix_A}, {input_A} ) == 0 );
+    
+    res = mpi_sub_abs( &Z, &X, &Y );
+    TEST_ASSERT( res == {sub_result} );
+    if( res == 0 )
+        TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 );
+}
+END_CASE
+
+BEGIN_CASE
+mpi_sub_int:radix_X:input_X:input_Y:radix_A:input_A
+{
+    mpi X, Z, A;
+    mpi_init(&X, &Z, &A, NULL);
+
+    TEST_ASSERT( mpi_read_string( &X, {radix_X}, {input_X} ) == 0 );
+    TEST_ASSERT( mpi_read_string( &A, {radix_A}, {input_A} ) == 0 );
+    TEST_ASSERT( mpi_sub_int( &Z, &X, {input_Y} ) == 0 );
+    TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 );
+}
+END_CASE
+
+BEGIN_CASE
+mpi_mul_mpi:radix_X:input_X:radix_Y:input_Y:radix_A:input_A
+{
+    mpi X, Y, Z, A;
+    mpi_init(&X, &Y, &Z, &A, NULL);
+
+    TEST_ASSERT( mpi_read_string( &X, {radix_X}, {input_X} ) == 0 );
+    TEST_ASSERT( mpi_read_string( &Y, {radix_Y}, {input_Y} ) == 0 );
+    TEST_ASSERT( mpi_read_string( &A, {radix_A}, {input_A} ) == 0 );
+    TEST_ASSERT( mpi_mul_mpi( &Z, &X, &Y ) == 0 );
+    TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 );
+}
+END_CASE
+
+BEGIN_CASE
+mpi_mul_int:radix_X:input_X:input_Y:radix_A:input_A:result_comparison
+{
+    mpi X, Z, A;
+    mpi_init(&X, &Z, &A, NULL);
+
+    TEST_ASSERT( mpi_read_string( &X, {radix_X}, {input_X} ) == 0 );
+    TEST_ASSERT( mpi_read_string( &A, {radix_A}, {input_A} ) == 0 );
+    TEST_ASSERT( mpi_mul_int( &Z, &X, {input_Y} ) == 0 );
+    TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) {result_comparison} 0 );
+}
+END_CASE
+
+BEGIN_CASE
+mpi_div_mpi:radix_X:input_X:radix_Y:input_Y:radix_A:input_A:radix_B:input_B:div_result
+{
+    mpi X, Y, Q, R, A, B;
+    int res;
+    mpi_init(&X, &Y, &Q, &R, &A, &B, NULL);
+
+    TEST_ASSERT( mpi_read_string( &X, {radix_X}, {input_X} ) == 0 );
+    TEST_ASSERT( mpi_read_string( &Y, {radix_Y}, {input_Y} ) == 0 );
+    TEST_ASSERT( mpi_read_string( &A, {radix_A}, {input_A} ) == 0 );
+    TEST_ASSERT( mpi_read_string( &B, {radix_B}, {input_B} ) == 0 );
+    res = mpi_div_mpi( &Q, &R, &X, &Y );
+    TEST_ASSERT( res == {div_result} );
+    if( res == 0 )
+    {
+        TEST_ASSERT( mpi_cmp_mpi( &Q, &A ) == 0 );
+        TEST_ASSERT( mpi_cmp_mpi( &R, &B ) == 0 );
+    }
+}
+END_CASE
+
+BEGIN_CASE
+mpi_div_int:radix_X:input_X:input_Y:radix_A:input_A:radix_B:input_B:div_result
+{
+    mpi X, Q, R, A, B;
+    int res;
+    mpi_init(&X, &Q, &R, &A, &B, NULL);
+
+    TEST_ASSERT( mpi_read_string( &X, {radix_X}, {input_X} ) == 0 );
+    TEST_ASSERT( mpi_read_string( &A, {radix_A}, {input_A} ) == 0 );
+    TEST_ASSERT( mpi_read_string( &B, {radix_B}, {input_B} ) == 0 );
+    res = mpi_div_int( &Q, &R, &X, {input_Y} );
+    TEST_ASSERT( res == {div_result} );
+    if( res == 0 )
+    {
+        TEST_ASSERT( mpi_cmp_mpi( &Q, &A ) == 0 );
+        TEST_ASSERT( mpi_cmp_mpi( &R, &B ) == 0 );
+    }
+}
+END_CASE
+
+BEGIN_CASE
+mpi_mod_mpi:radix_X:input_X:radix_Y:input_Y:radix_A:input_A:div_result
+{
+    mpi X, Y, Z, A;
+    int res;
+    mpi_init(&X, &Y, &Z, &A, NULL);
+
+    TEST_ASSERT( mpi_read_string( &X, {radix_X}, {input_X} ) == 0 );
+    TEST_ASSERT( mpi_read_string( &Y, {radix_Y}, {input_Y} ) == 0 );
+    TEST_ASSERT( mpi_read_string( &A, {radix_A}, {input_A} ) == 0 );
+    res = mpi_mod_mpi( &Z, &X, &Y );
+    TEST_ASSERT( res == {div_result} );
+    if( res == 0 )
+    {
+        TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 );
+    }
+}
+END_CASE
+
+BEGIN_CASE
+mpi_mod_int:radix_X:input_X:input_Y:input_A:div_result
+{
+    mpi X;
+    int res;
+    t_int r;
+    mpi_init(&X, NULL);
+
+    TEST_ASSERT( mpi_read_string( &X, {radix_X}, {input_X} ) == 0 );
+    res = mpi_mod_int( &r, &X, {input_Y} );
+    TEST_ASSERT( res == {div_result} );
+    if( res == 0 )
+    {
+        TEST_ASSERT( r == {input_A} );
+    }
+}
+END_CASE
+
+BEGIN_CASE
+mpi_exp_mod:radix_A:input_A:radix_E:input_E:radix_N:input_N:radix_RR:input_RR:radix_X:input_X:div_result
+{
+    mpi A, E, N, RR, Z, X;
+    int res;
+    mpi_init(&A, &E, &N, &RR, &Z, &X, NULL);
+
+    TEST_ASSERT( mpi_read_string( &A, {radix_A}, {input_A} ) == 0 );
+    TEST_ASSERT( mpi_read_string( &E, {radix_E}, {input_E} ) == 0 );
+    TEST_ASSERT( mpi_read_string( &N, {radix_N}, {input_N} ) == 0 );
+    TEST_ASSERT( mpi_read_string( &X, {radix_X}, {input_X} ) == 0 );
+
+    if( strlen( {input_RR} ) )
+        TEST_ASSERT( mpi_read_string( &RR, {radix_RR}, {input_RR} ) == 0 );
+
+    res = mpi_exp_mod( &Z, &A, &E, &N, &RR );
+    TEST_ASSERT( res == {div_result} );
+    if( res == 0 )
+    {
+        TEST_ASSERT( mpi_cmp_mpi( &Z, &X ) == 0 );
+    }
+}
+END_CASE
+
+BEGIN_CASE
+mpi_inv_mod:radix_X:input_X:radix_Y:input_Y:radix_A:input_A:div_result
+{
+    mpi X, Y, Z, A;
+    int res;
+    mpi_init(&X, &Y, &Z, &A, NULL);
+
+    TEST_ASSERT( mpi_read_string( &X, {radix_X}, {input_X} ) == 0 );
+    TEST_ASSERT( mpi_read_string( &Y, {radix_Y}, {input_Y} ) == 0 );
+    TEST_ASSERT( mpi_read_string( &A, {radix_A}, {input_A} ) == 0 );
+    res = mpi_inv_mod( &Z, &X, &Y );
+    TEST_ASSERT( res == {div_result} );
+    if( res == 0 )
+    {
+        TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 );
+    }
+}
+END_CASE
+
+BEGIN_CASE
+mpi_is_prime:radix_X:input_X:div_result
+{
+    mpi X;
+    int res;
+    mpi_init(&X, NULL);
+
+    TEST_ASSERT( mpi_read_string( &X, {radix_X}, {input_X} ) == 0 );
+    res = mpi_is_prime( &X, myrand, NULL );
+    TEST_ASSERT( res == {div_result} );
+}
+END_CASE
+
+BEGIN_CASE
+mpi_shift_l:radix_X:input_X:shift_X:radix_A:input_A
+{
+    mpi X, A;
+    mpi_init(&X, &A, NULL);
+
+    TEST_ASSERT( mpi_read_string( &X, {radix_X}, {input_X} ) == 0 );
+    TEST_ASSERT( mpi_read_string( &A, {radix_A}, {input_A} ) == 0 );
+    TEST_ASSERT( mpi_shift_l( &X, {shift_X} ) == 0 );
+    TEST_ASSERT( mpi_cmp_mpi( &X, &A ) == 0 );
+}
+END_CASE
+
+BEGIN_CASE
+mpi_shift_r:radix_X:input_X:shift_X:radix_A:input_A
+{
+    mpi X, A;
+    mpi_init(&X, &A, NULL);
+
+    TEST_ASSERT( mpi_read_string( &X, {radix_X}, {input_X} ) == 0 );
+    TEST_ASSERT( mpi_read_string( &A, {radix_A}, {input_A} ) == 0 );
+    TEST_ASSERT( mpi_shift_r( &X, {shift_X} ) == 0 );
+    TEST_ASSERT( mpi_cmp_mpi( &X, &A ) == 0 );
+}
+END_CASE
+
+/* Helper Code
+    char str[1000];
+    int len = 1000;
+    mpi_write_string(&Z, 10, str, &len);
+    printf("Z: %d %s\n", Z.s, str);
+    TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 );
+*/
diff --git a/tests/suites/test_suite_shax.data b/tests/suites/test_suite_shax.data
new file mode 100644
index 0000000..15b402d
--- /dev/null
+++ b/tests/suites/test_suite_shax.data
@@ -0,0 +1,119 @@
+SHA-1 Test Vector NIST CAVS #1
+sha1:"":"da39a3ee5e6b4b0d3255bfef95601890afd80709"
+
+SHA-1 Test Vector NIST CAVS #2
+sha1:"a8":"99f2aa95e36f95c2acb0eaf23998f030638f3f15"
+
+SHA-1 Test Vector NIST CAVS #3
+sha1:"3000":"f944dcd635f9801f7ac90a407fbc479964dec024"
+
+SHA-1 Test Vector NIST CAVS #4
+sha1:"42749e":"a444319e9b6cc1e8464c511ec0969c37d6bb2619"
+
+SHA-1 Test Vector NIST CAVS #5
+sha1:"9fc3fe08":"16a0ff84fcc156fd5d3ca3a744f20a232d172253"
+
+SHA-1 Test Vector NIST CAVS #6
+sha1:"b5c1c6f1af":"fec9deebfcdedaf66dda525e1be43597a73a1f93"
+
+SHA-1 Test Vector NIST CAVS #7
+sha1:"ec29561244ede706b6eb30a1c371d74450a105c3f9735f7fa9fe38cf67f304a5736a106e92e17139a6813b1c81a4f3d3fb9546ab4296fa9f722826c066869edacd73b2548035185813e22634a9da44000d95a281ff9f264ecce0a931222162d021cca28db5f3c2aa24945ab1e31cb413ae29810fd794cad5dfaf29ec43cb38d198fe4ae1da2359780221405bd6712a5305da4b1b737fce7cd21c0eb7728d08235a9011":"970111c4e77bcc88cc20459c02b69b4aa8f58217"
+
+SHA-1 Test Vector NIST CAVS #8
+sha1:"5fc2c3f6a7e79dc94be526e5166a238899d54927ce470018fbfd668fd9dd97cbf64e2c91584d01da63be3cc9fdff8adfefc3ac728e1e335b9cdc87f069172e323d094b47fa1e652afe4d6aa147a9f46fda33cacb65f3aa12234746b9007a8c85fe982afed7815221e43dba553d8fe8a022cdac1b99eeeea359e5a9d2e72e382dffa6d19f359f4f27dc3434cd27daeeda8e38594873398678065fbb23665aba9309d946135da0e4a4afdadff14db18e85e71dd93c3bf9faf7f25c8194c4269b1ee3d9934097ab990025d9c3aaf63d5109f52335dd3959d38ae485050e4bbb6235574fc0102be8f7a306d6e8de6ba6becf80f37415b57f9898a5824e77414197422be3d36a6080":"0423dc76a8791107d14e13f5265b343f24cc0f19"
+
+SHA-1 Test Vector NIST CAVS #9
+sha1:"0f865f46a8f3aed2da18482aa09a8f390dc9da07d51d1bd10fe0bf5f3928d5927d08733d32075535a6d1c8ac1b2dc6ba0f2f633dc1af68e3f0fa3d85e6c60cb7b56c239dc1519a007ea536a07b518ecca02a6c31b46b76f021620ef3fc6976804018380e5ab9c558ebfc5cb1c9ed2d974722bf8ab6398f1f2b82fa5083f85c16a5767a3a07271d67743f00850ce8ec428c7f22f1cf01f99895c0c844845b06a06cecb0c6cf83eb55a1d4ebc44c2c13f6f7aa5e0e08abfd84e7864279057abc471ee4a45dbbb5774afa24e51791a0eada11093b88681fe30baa3b2e94113dc63342c51ca5d1a6096d0897b626e42cb91761058008f746f35465465540ad8c6b8b60f7e1461b3ce9e6529625984cb8c7d46f07f735be067588a0117f23e34ff57800e2bbe9a1605fde6087fb15d22c5d3ac47566b8c448b0cee40373e5ba6eaa21abee71366afbb27dbbd300477d70c371e7b8963812f5ed4fb784fb2f3bd1d3afe883cdd47ef32beaea":"6692a71d73e00f27df976bc56df4970650d90e45"
+
+SHA-1 Test Vector NIST CAVS #10
+sha1:"8236153781bd2f1b81ffe0def1beb46f5a70191142926651503f1b3bb1016acdb9e7f7acced8dd168226f118ff664a01a8800116fd023587bfba52a2558393476f5fc69ce9c65001f23e70476d2cc81c97ea19caeb194e224339bcb23f77a83feac5096f9b3090c51a6ee6d204b735aa71d7e996d380b80822e4dfd43683af9c7442498cacbea64842dfda238cb099927c6efae07fdf7b23a4e4456e0152b24853fe0d5de4179974b2b9d4a1cdbefcbc01d8d311b5dda059136176ea698ab82acf20dd490be47130b1235cb48f8a6710473cfc923e222d94b582f9ae36d4ca2a32d141b8e8cc36638845fbc499bce17698c3fecae2572dbbd470552430d7ef30c238c2124478f1f780483839b4fb73d63a9460206824a5b6b65315b21e3c2f24c97ee7c0e78faad3df549c7ca8ef241876d9aafe9a309f6da352bec2caaa92ee8dca392899ba67dfed90aef33d41fc2494b765cb3e2422c8e595dabbfaca217757453fb322a13203f425f6073a9903e2dc5818ee1da737afc345f0057744e3a56e1681c949eb12273a3bfc20699e423b96e44bd1ff62e50a848a890809bfe1611c6787d3d741103308f849a790f9c015098286dbacfc34c1718b2c2b77e32194a75dda37954a320fa68764027852855a7e5b5274eb1e2cbcd27161d98b59ad245822015f48af82a45c0ed59be94f9af03d9736048570d6e3ef63b1770bc98dfb77de84b1bb1708d872b625d9ab9b06c18e5dbbf34399391f0f8aa26ec0dac7ff4cb8ec97b52bcb942fa6db2385dcd1b3b9d567aaeb425d567b0ebe267235651a1ed9bf78fd93d3c1dd077fe340bb04b00529c58f45124b717c168d07e9826e33376988bc5cf62845c2009980a4dfa69fbc7e5a0b1bb20a5958ca967aec68eb31dd8fccca9afcd30a26bab26279f1bf6724ff":"11863b483809ef88413ca9b0084ac4a5390640af"
+
+SHA-224 Test Vector NIST CAVS #1
+sha224:"":"d14a028c2a3a2bc9476102bb288234c415a2b01f828ea62ac5b3e42f"
+
+SHA-224 Test Vector NIST CAVS #2
+sha224:"ff":"e33f9d75e6ae1369dbabf81b96b4591ae46bba30b591a6b6c62542b5"
+
+SHA-224 Test Vector NIST CAVS #3
+sha224:"984c":"2fa9df9157d9e027cfbc4c6a9df32e1adc0cbe2328ec2a63c5ae934e"
+
+SHA-224 Test Vector NIST CAVS #4
+sha224:"50efd0":"b5a9820413c2bf8211fbbf5df1337043b32fa4eafaf61a0c8e9ccede"
+
+SHA-224 Test Vector NIST CAVS #5
+sha224:"e5e09924":"fd19e74690d291467ce59f077df311638f1c3a46e510d0e49a67062d"
+
+SHA-224 Test Vector NIST CAVS #6
+sha224:"21ebecb914":"78f4a71c21c694499ce1c7866611b14ace70d905012c356323c7c713"
+
+SHA-224 Test Vector NIST CAVS #7
+sha224:"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":"1302149d1e197c41813b054c942329d420e366530f5517b470e964fe"
+
+SHA-256 Test Vector NIST CAVS #1
+sha256:"":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+
+SHA-256 Test Vector NIST CAVS #2
+sha256:"bd":"68325720aabd7c82f30f554b313d0570c95accbb7dc4b5aae11204c08ffe732b"
+
+SHA-256 Test Vector NIST CAVS #3
+sha256:"5fd4":"7c4fbf484498d21b487b9d61de8914b2eadaf2698712936d47c3ada2558f6788"
+
+SHA-256 Test Vector NIST CAVS #4
+sha256:"b0bd69":"4096804221093ddccfbf46831490ea63e9e99414858f8d75ff7f642c7ca61803"
+
+SHA-256 Test Vector NIST CAVS #5
+sha256:"c98c8e55":"7abc22c0ae5af26ce93dbb94433a0e0b2e119d014f8e7f65bd56c61ccccd9504"
+
+SHA-256 Test Vector NIST CAVS #6
+sha256:"81a723d966":"7516fb8bb11350df2bf386bc3c33bd0f52cb4c67c6e4745e0488e62c2aea2605"
+
+SHA-256 Test Vector NIST CAVS #7
+sha256:"8390cf0be07661cc7669aac54ce09a37733a629d45f5d983ef201f9b2d13800e555d9b1097fec3b783d7a50dcb5e2b644b96a1e9463f177cf34906bf388f366db5c2deee04a30e283f764a97c3b377a034fefc22c259214faa99babaff160ab0aaa7e2ccb0ce09c6b32fe08cbc474694375aba703fadbfa31cf685b30a11c57f3cf4edd321e57d3ae6ebb1133c8260e75b9224fa47a2bb205249add2e2e62f817491482ae152322be0900355cdcc8d42a98f82e961a0dc6f537b7b410eff105f59673bfb787bf042aa071f7af68d944d27371c64160fe9382772372516c230c1f45c0d6b6cca7f274b394da9402d3eafdf733994ec58ab22d71829a98399574d4b5908a447a5a681cb0dd50a31145311d92c22a16de1ead66a5499f2dceb4cae694772ce90762ef8336afec653aa9b1a1c4820b221136dfce80dce2ba920d88a530c9410d0a4e0358a3a11052e58dd73b0b179ef8f56fe3b5a2d117a73a0c38a1392b6938e9782e0d86456ee4884e3c39d4d75813f13633bc79baa07c0d2d555afbf207f52b7dca126d015aa2b9873b3eb065e90b9b065a5373fe1fb1b20d594327d19fba56cb81e7b6696605ffa56eba3c27a438697cc21b201fd7e09f18deea1b3ea2f0d1edc02df0e20396a145412cd6b13c32d2e605641c948b714aec30c0649dc44143511f35ab0fd5dd64c34d06fe86f3836dfe9edeb7f08cfc3bd40956826356242191f99f53473f32b0cc0cf9321d6c92a112e8db90b86ee9e87cc32d0343db01e32ce9eb782cb24efbbbeb440fe929e8f2bf8dfb1550a3a2e742e8b455a3e5730e9e6a7a9824d17acc0f72a7f67eae0f0970f8bde46dcdefaed3047cf807e7f00a42e5fd11d40f5e98533d7574425b7d2bc3b3845c443008b58980e768e464e17cc6f6b3939eee52f713963d07d8c4abf02448ef0b889c9671e2f8a436ddeeffcca7176e9bf9d1005ecd377f2fa67c23ed1f137e60bf46018a8bd613d038e883704fc26e798969df35ec7bbc6a4fe46d8910bd82fa3cded265d0a3b6d399e4251e4d8233daa21b5812fded6536198ff13aa5a1cd46a5b9a17a4ddc1d9f85544d1d1cc16f3df858038c8e071a11a7e157a85a6a8dc47e88d75e7009a8b26fdb73f33a2a70f1e0c259f8f9533b9b8f9af9288b7274f21baeec78d396f8bacdcc22471207d9b4efccd3fedc5c5a2214ff5e51c553f35e21ae696fe51e8df733a8e06f50f419e599e9f9e4b37ce643fc810faaa47989771509d69a110ac916261427026369a21263ac4460fb4f708f8ae28599856db7cb6a43ac8e03d64a9609807e76c5f312b9d1863bfa304e8953647648b4f4ab0ed995e":"4109cdbec3240ad74cc6c37f39300f70fede16e21efc77f7865998714aad0b5e"
+
+SHA-384 Test Vector NIST CAVS #1
+sha384:"":"38b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da274edebfe76f65fbd51ad2f14898b95b"
+
+SHA-384 Test Vector NIST CAVS #2
+sha384:"ab":"fb94d5be118865f6fcbc978b825da82cff188faec2f66cb84b2537d74b4938469854b0ca89e66fa2e182834736629f3d"
+
+SHA-384 Test Vector NIST CAVS #3
+sha384:"7c27":"3d80be467df86d63abb9ea1d3f9cb39cd19890e7f2c53a6200bedc5006842b35e820dc4e0ca90ca9b97ab23ef07080fc"
+
+SHA-384 Test Vector NIST CAVS #4
+sha384:"31f5ca":"78d54b943421fdf7ba90a7fb9637c2073aa480454bd841d39ff72f4511fc21fb67797b652c0c823229342873d3bef955"
+
+SHA-384 Test Vector NIST CAVS #5
+sha384:"7bdee3f8":"8bdafba0777ee446c3431c2d7b1fbb631089f71d2ca417abc1d230e1aba64ec2f1c187474a6f4077d372c14ad407f99a"
+
+SHA-384 Test Vector NIST CAVS #6
+sha384:"8f05604915":"504e414bf1db1060f14c8c799e25b1e0c4dcf1504ebbd129998f0ae283e6de86e0d3c7e879c73ec3b1836c3ee89c2649"
+
+SHA-384 Test Vector NIST CAVS #7
+sha384:"665da6eda214":"4c022f112010908848312f8b8f1072625fd5c105399d562ea1d56130619a7eac8dfc3748fd05ee37e4b690be9daa9980"
+
+SHA-384 Test Vector NIST CAVS #8
+sha384:"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":"cba9e3eb12a6f83db11e8a6ff40d1049854ee094416bc527fea931d8585428a8ed6242ce81f6769b36e2123a5c23483e"
+
+SHA-512 Test Vector NIST CAVS #1
+sha512:"":"cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e"
+
+SHA-512 Test Vector NIST CAVS #2
+sha512:"8f":"e4cd2d19931b5aad9c920f45f56f6ce34e3d38c6d319a6e11d0588ab8b838576d6ce6d68eea7c830de66e2bd96458bfa7aafbcbec981d4ed040498c3dd95f22a"
+
+SHA-512 Test Vector NIST CAVS #3
+sha512:"e724":"7dbb520221a70287b23dbcf62bfc1b73136d858e86266732a7fffa875ecaa2c1b8f673b5c065d360c563a7b9539349f5f59bef8c0c593f9587e3cd50bb26a231"
+
+SHA-512 Test Vector NIST CAVS #4
+sha512:"de4c90":"33ce98281045a5c4c9df0363d8196f1d7dfcd5ee46ac89776fd8a4344c12f123a66788af5bd41ceff1941aa5637654b4064c88c14e00465ab79a2fc6c97e1014"
+
+SHA-512 Test Vector NIST CAVS #5
+sha512:"a801e94b":"dadb1b5a27f9fece8d86adb2a51879beb1787ff28f4e8ce162cad7fee0f942efcabbf738bc6f797fc7cc79a3a75048cd4c82ca0757a324695bfb19a557e56e2f"
+
+SHA-512 Test Vector NIST CAVS #6
+sha512:"94390d3502":"b6175c4c4cccf69e0ce5f0312010886ea6b34d43673f942ae42483f9cbb7da817de4e11b5d58e25a3d9bd721a22cdffe1c40411cc45df1911fa5506129b69297"
+
+SHA-512 Test Vector NIST CAVS #7
+sha512:"49297dd63e5f":"1fcc1e6f6870859d11649f5e5336a9cd16329c029baf04d5a6edf257889a2e9522b497dd656bb402da461307c4ee382e2e89380c8e6e6e7697f1e439f650fa94"
+
+SHA-512 Test Vector NIST CAVS #8
+sha512:"990d1ae71a62d7bda9bfdaa1762a68d296eee72a4cd946f287a898fbabc002ea941fd8d4d991030b4d27a637cce501a834bb95eab1b7889a3e784c7968e67cbf552006b206b68f76d9191327524fcc251aeb56af483d10b4e0c6c5e599ee8c0fe4faeca8293844a8547c6a9a90d093f2526873a19ad4a5e776794c68c742fb834793d2dfcb7fea46c63af4b70fd11cb6e41834e72ee40edb067b292a794990c288d5007e73f349fb383af6a756b8301ad6e5e0aa8cd614399bb3a452376b1575afa6bdaeaafc286cb064bb91edef97c632b6c1113d107fa93a0905098a105043c2f05397f702514439a08a9e5ddc196100721d45c8fc17d2ed659376f8a00bd5cb9a0860e26d8a29d8d6aaf52de97e9346033d6db501a35dbbaf97c20b830cd2d18c2532f3a59cc497ee64c0e57d8d060e5069b28d86edf1adcf59144b221ce3ddaef134b3124fbc7dd000240eff0f5f5f41e83cd7f5bb37c9ae21953fe302b0f6e8b68fa91c6ab99265c64b2fd9cd4942be04321bb5d6d71932376c6f2f88e02422ba6a5e2cb765df93fd5dd0728c6abdaf03bce22e0678a544e2c3636f741b6f4447ee58a8fc656b43ef817932176adbfc2e04b2c812c273cd6cbfa4098f0be036a34221fa02643f5ee2e0b38135f2a18ecd2f16ebc45f8eb31b8ab967a1567ee016904188910861ca1fa205c7adaa194b286893ffe2f4fbe0384c2aef72a4522aeafd3ebc71f9db71eeeef86c48394a1c86d5b36c352cc33a0a2c800bc99e62fd65b3a2fd69e0b53996ec13d8ce483ce9319efd9a85acefabdb5342226febb83fd1daf4b24265f50c61c6de74077ef89b6fecf9f29a1f871af1e9f89b2d345cda7499bd45c42fa5d195a1e1a6ba84851889e730da3b2b916e96152ae0c92154b49719841db7e7cc707ba8a5d7b101eb4ac7b629bb327817910fff61580b59aab78182d1a2e33473d05b00b170b29e331870826cfe45af206aa7d0246bbd8566ca7cfb2d3c10bfa1db7dd48dd786036469ce7282093d78b5e1a5b0fc81a54c8ed4ceac1e5305305e78284ac276f5d7862727aff246e17addde50c670028d572cbfc0be2e4f8b2eb28fa68ad7b4c6c2a239c460441bfb5ea049f23b08563b4e47729a59e5986a61a6093dbd54f8c36ebe87edae01f251cb060ad1364ce677d7e8d5a4a4ca966a7241cc360bc2acb280e5f9e9c1b032ad6a180a35e0c5180b9d16d026c865b252098cc1d99ba7375ca31c7702c0d943d5e3dd2f6861fa55bd46d94b67ed3e52eccd8dd06d968e01897d6de97ed3058d91dd":"8e4bc6f8b8c60fe4d68c61d9b159c8693c3151c46749af58da228442d927f23359bd6ccd6c2ec8fa3f00a86cecbfa728e1ad60b821ed22fcd309ba91a4138bc9"
diff --git a/tests/suites/test_suite_shax.function b/tests/suites/test_suite_shax.function
new file mode 100644
index 0000000..f90d161
--- /dev/null
+++ b/tests/suites/test_suite_shax.function
@@ -0,0 +1,105 @@
+BEGIN_HEADER
+#include <polarssl/sha1.h>
+#include <polarssl/sha2.h>
+#include <polarssl/sha4.h>
+END_HEADER
+
+BEGIN_CASE
+sha1:hex_src_string:hex_hash_string
+{
+    unsigned char src_str[10000];
+    unsigned char hash_str[10000];
+    unsigned char output[41];
+
+    memset(src_str, 0x00, 10000);
+    memset(hash_str, 0x00, 10000);
+    memset(output, 0x00, 41);
+
+    int src_len = unhexify( src_str, {hex_src_string} );
+
+    sha1( src_str, src_len, output );
+    hexify( hash_str, output, 20 );
+
+    TEST_ASSERT( strcmp( (char *) hash_str, {hex_hash_string} ) == 0 );
+}
+END_CASE
+
+BEGIN_CASE
+sha224:hex_src_string:hex_hash_string
+{
+    unsigned char src_str[10000];
+    unsigned char hash_str[10000];
+    unsigned char output[57];
+
+    memset(src_str, 0x00, 10000);
+    memset(hash_str, 0x00, 10000);
+    memset(output, 0x00, 57);
+
+    int src_len = unhexify( src_str, {hex_src_string} );
+
+    sha2( src_str, src_len, output, 1 );
+    hexify( hash_str, output, 28 );
+
+    TEST_ASSERT( strcmp( (char *) hash_str, {hex_hash_string} ) == 0 );
+}
+END_CASE
+
+BEGIN_CASE
+sha256:hex_src_string:hex_hash_string
+{
+    unsigned char src_str[10000];
+    unsigned char hash_str[10000];
+    unsigned char output[65];
+
+    memset(src_str, 0x00, 10000);
+    memset(hash_str, 0x00, 10000);
+    memset(output, 0x00, 65);
+
+    int src_len = unhexify( src_str, {hex_src_string} );
+
+    sha2( src_str, src_len, output, 0 );
+    hexify( hash_str, output, 32 );
+
+    TEST_ASSERT( strcmp( (char *) hash_str, {hex_hash_string} ) == 0 );
+}
+END_CASE
+
+BEGIN_CASE
+sha384:hex_src_string:hex_hash_string
+{
+    unsigned char src_str[10000];
+    unsigned char hash_str[10000];
+    unsigned char output[97];
+
+    memset(src_str, 0x00, 10000);
+    memset(hash_str, 0x00, 10000);
+    memset(output, 0x00, 97);
+
+    int src_len = unhexify( src_str, {hex_src_string} );
+
+    sha4( src_str, src_len, output, 1 );
+    hexify( hash_str, output, 48 );
+
+    TEST_ASSERT( strcmp( (char *) hash_str, {hex_hash_string} ) == 0 );
+}
+END_CASE
+
+BEGIN_CASE
+sha512:hex_src_string:hex_hash_string
+{
+    unsigned char src_str[10000];
+    unsigned char hash_str[10000];
+    unsigned char output[129];
+
+    memset(src_str, 0x00, 10000);
+    memset(hash_str, 0x00, 10000);
+    memset(output, 0x00, 129);
+
+    int src_len = unhexify( src_str, {hex_src_string} );
+
+    sha4( src_str, src_len, output, 0);
+    hexify( hash_str, output, 64 );
+
+    TEST_ASSERT( strcmp( (char *) hash_str, {hex_hash_string} ) == 0 );
+}
+END_CASE