diff --git a/testing/chameleon_ztesting.c b/testing/chameleon_ztesting.c
index 40b358d56e2444726df06c1313f1c77ff2576a75..29568d0cc130ff561a2fcad73f55926787046aaf 100644
--- a/testing/chameleon_ztesting.c
+++ b/testing/chameleon_ztesting.c
@@ -44,9 +44,10 @@ static parameter_t parameters[] = {
     { "mtxfmt",   "Change the way the matrix is stored (0: global, 1: tiles, 2: OOC)", -32, PARAM_OPTION | PARAM_INPUT | PARAM_OUTPUT, 1, 6, TestValInt, {0}, NULL, pread_int, sprint_int },
     { "profile",  "Display the kernel profiling",             -33, PARAM_OPTION, 0, 0, TestValInt, {0}, NULL, pread_int, sprint_int },
     { "forcegpu", "Force kernels on GPU",                     -34, PARAM_OPTION, 0, 0, TestValInt, {0}, NULL, pread_int, sprint_int },
-    { "async",    "Switch to the Async interface",            's', PARAM_OPTION, 0, 0, TestValInt, {0}, NULL, pread_int, sprint_int },
-    { "generic",  "Switch to the generic interface",          -35, PARAM_OPTION, 0, 0, TestValInt, {0}, NULL, pread_int, sprint_int },
-    { "splitsub", "Split the task submission and execution stages", 'S', PARAM_OPTION, 0, 0, TestValInt, {0}, NULL, pread_int, sprint_int },
+    { "async",    "Switch to the Async interface",                        's', PARAM_OPTION, 0, 0, TestValInt, {0}, NULL, pread_int, sprint_int },
+    { "splitsub", "Split the task submission and execution stages",       'S', PARAM_OPTION, 0, 0, TestValInt, {0}, NULL, pread_int, sprint_int },
+    { "generic",  "Switch to the non optimized generic algorithms",       -35, PARAM_OPTION, 0, 0, TestValInt, {0}, NULL, pread_int, sprint_int },
+    { "api",      "Select the API to test (0: Descriptors, 1: Standard)", -36, PARAM_OPTION, 1, 3, TestValInt, {0}, NULL, pread_int, sprint_int },
 
     { NULL, "Machine parameters", 0, PARAM_OPTION, 0, 0, 0, {0}, NULL, NULL, NULL },
     { "threads", "Number of CPU workers per node",      't', PARAM_OPTION | PARAM_OUTPUT, 1, 7, TestValInt, {-1}, NULL, pread_int, sprint_int },
@@ -599,7 +600,7 @@ testing_stop( testdata_t *tdata, cham_fixdbl_t flops )
 int main (int argc, char **argv) {
 
     int ncores, ngpus, human, generic, check, i, niter;
-    int trace, nowarmup, profile, forcegpu;
+    int trace, nowarmup, profile, forcegpu, api;
     int rc, info = 0;
     int run_id = 0;
     char *func_name;
@@ -626,11 +627,13 @@ int main (int argc, char **argv) {
     nowarmup  = parameters_getvalue_int( "nowarmup" );
     profile   = parameters_getvalue_int( "profile"  );
     forcegpu  = parameters_getvalue_int( "forcegpu" );
+    api       = parameters_getvalue_int( "api" );
 
     rc = CHAMELEON_Init( ncores, ngpus );
 
     if ( rc != CHAMELEON_SUCCESS ) {
         fprintf( stderr, "CHAMELEON_Init failed and returned %d.\n", rc );
+        info = 1;
         goto end;
     }
 
@@ -644,6 +647,13 @@ int main (int argc, char **argv) {
     /* Binds the right function to be called and builds the parameters combinations */
     test = testing_gettest( argv[0], func_name );
     free(func_name);
+    test_fct_t fptr = (api == 0) ? test->fptr_desc : test->fptr_std;
+    if ( fptr == NULL ) {
+        fprintf( stderr, "The %s API is not available for function %s\n",
+                 (api == 0) ? "descriptor" : "standard", func_name );
+        info = 1;
+        goto end;
+    }
 
     /* Generate the cartesian product of the parameters */
     runlist = run_list_generate( test->params );
@@ -658,6 +668,7 @@ int main (int argc, char **argv) {
             fprintf( stderr,
                      "--forcegpu can't be enable without GPU (-g 0).\n"
                      "  Please specify a larger number of GPU or disable this option\n" );
+            info = 1;
             goto end;
         }
         RUNTIME_zlocality_allrestrict( RUNTIME_CUDA );
@@ -666,7 +677,7 @@ int main (int argc, char **argv) {
     /* Warmup */
     if ( !nowarmup ) {
         run_arg_list_t copy = run_arg_list_copy( &(run->args) );
-        test->fptr( &copy, check );
+        fptr( &copy, check );
         run_arg_list_destroy( &copy );
     }
 
@@ -680,7 +691,7 @@ int main (int argc, char **argv) {
         CHAMELEON_Enable( CHAMELEON_PROFILING_MODE );
     }
 
-    if ( generic ) { 
+    if ( generic ) {
         CHAMELEON_Enable( CHAMELEON_GENERIC );
     }
 
@@ -688,7 +699,7 @@ int main (int argc, char **argv) {
     while ( run != NULL ) {
         for(i=0; i<niter; i++) {
             run_arg_list_t copy = run_arg_list_copy( &(run->args) );
-            rc = test->fptr( &copy, check );
+            rc = fptr( &copy, check );
 
             /* If rc < 0, we skipped the test */
             if ( rc >= 0 ) {
diff --git a/testing/testing_zcesca.c b/testing/testing_zcesca.c
index 4bc57a46f5231ccb989b138b4a0764d2ac866884..7378211a79a43995e8a2c65b785cbc56dad8df07 100644
--- a/testing/testing_zcesca.c
+++ b/testing/testing_zcesca.c
@@ -35,7 +35,7 @@ flops_zcesca( int M, int N )
 }
 
 int
-testing_zcesca( run_arg_list_t *args, int check )
+testing_zcesca_desc( run_arg_list_t *args, int check )
 {
     testdata_t test_data = { .args = args };
     int        hres      = 0;
@@ -108,7 +108,8 @@ testing_zcesca_init( void )
     test_zcesca.params = zcesca_params;
     test_zcesca.output = zcesca_output;
     test_zcesca.outchk = zcesca_outchk;
-    test_zcesca.fptr   = testing_zcesca;
+    test_zcesca.fptr_desc = testing_zcesca_desc;
+    test_zcesca.fptr_std  = NULL;
     test_zcesca.next   = NULL;
 
     testing_register( &test_zcesca );
diff --git a/testing/testing_zgeadd.c b/testing/testing_zgeadd.c
index 9198e1414d6924af319260c186b25bcb7cd74759..d354c8127f62538ea3e7caaa419a48652a35cc84 100644
--- a/testing/testing_zgeadd.c
+++ b/testing/testing_zgeadd.c
@@ -36,7 +36,7 @@ flops_zgeadd( int M, int N )
 }
 
 int
-testing_zgeadd( run_arg_list_t *args, int check )
+testing_zgeadd_desc( run_arg_list_t *args, int check )
 {
     testdata_t test_data = { .args = args };
     int        hres      = 0;
@@ -133,7 +133,8 @@ testing_zgeadd_init( void )
     test_zgeadd.params = zgeadd_params;
     test_zgeadd.output = zgeadd_output;
     test_zgeadd.outchk = zgeadd_outchk;
-    test_zgeadd.fptr   = testing_zgeadd;
+    test_zgeadd.fptr_desc = testing_zgeadd_desc;
+    test_zgeadd.fptr_std  = NULL;
     test_zgeadd.next   = NULL;
 
     testing_register( &test_zgeadd );
diff --git a/testing/testing_zgelqf.c b/testing/testing_zgelqf.c
index a53283dc1d2d5b15b35939799ac783a3c2e181b6..59b365657e36a76aa62aedf4531a934a086e8270 100644
--- a/testing/testing_zgelqf.c
+++ b/testing/testing_zgelqf.c
@@ -22,7 +22,7 @@
 #include <chameleon/flops.h>
 
 int
-testing_zgelqf( run_arg_list_t *args, int check )
+testing_zgelqf_desc( run_arg_list_t *args, int check )
 {
     testdata_t test_data = { .args = args };
     int        hres      = 0;
@@ -116,7 +116,8 @@ testing_zgelqf_init( void )
     test_zgelqf.params = zgelqf_params;
     test_zgelqf.output = zgelqf_output;
     test_zgelqf.outchk = zgelqf_outchk;
-    test_zgelqf.fptr   = testing_zgelqf;
+    test_zgelqf.fptr_desc = testing_zgelqf_desc;
+    test_zgelqf.fptr_std  = NULL;
     test_zgelqf.next   = NULL;
 
     testing_register( &test_zgelqf );
diff --git a/testing/testing_zgelqf_hqr.c b/testing/testing_zgelqf_hqr.c
index 32f880db00df57f57971b1e01214d0c39e427c6e..98c3116b8c9db11087a7fe6c0091d4db56541ea3 100644
--- a/testing/testing_zgelqf_hqr.c
+++ b/testing/testing_zgelqf_hqr.c
@@ -22,7 +22,7 @@
 #include <chameleon/flops.h>
 
 int
-testing_zgelqf_hqr( run_arg_list_t *args, int check )
+testing_zgelqf_hqr_desc( run_arg_list_t *args, int check )
 {
     testdata_t test_data = { .args = args };
     int        hres      = 0;
@@ -128,7 +128,8 @@ testing_zgelqf_hqr_init( void )
     test_zgelqf_hqr.params = zgelqf_hqr_params;
     test_zgelqf_hqr.output = zgelqf_hqr_output;
     test_zgelqf_hqr.outchk = zgelqf_hqr_outchk;
-    test_zgelqf_hqr.fptr   = testing_zgelqf_hqr;
+    test_zgelqf_hqr.fptr_desc = testing_zgelqf_hqr_desc;
+    test_zgelqf_hqr.fptr_std  = NULL;
     test_zgelqf_hqr.next   = NULL;
 
     testing_register( &test_zgelqf_hqr );
diff --git a/testing/testing_zgelqs.c b/testing/testing_zgelqs.c
index 75c2825c9f26e89dcc01549587c0a0713aa406bc..a9fac5b7899781a40df68d04fc71a19a8e78d646 100644
--- a/testing/testing_zgelqs.c
+++ b/testing/testing_zgelqs.c
@@ -30,7 +30,7 @@ flops_zgelqs()
 }
 
 int
-testing_zgelqs( run_arg_list_t *args, int check )
+testing_zgelqs_desc( run_arg_list_t *args, int check )
 {
     testdata_t test_data = { .args = args };
     int        hres      = 0;
@@ -129,7 +129,8 @@ testing_zgelqs_init( void )
     test_zgelqs.params = zgelqs_params;
     test_zgelqs.output = zgelqs_output;
     test_zgelqs.outchk = zgelqs_outchk;
-    test_zgelqs.fptr   = testing_zgelqs;
+    test_zgelqs.fptr_desc = testing_zgelqs_desc;
+    test_zgelqs.fptr_std  = NULL;
     test_zgelqs.next   = NULL;
 
     testing_register( &test_zgelqs );
diff --git a/testing/testing_zgels.c b/testing/testing_zgels.c
index 9e63a8020d557b854e1ae77037f46643ff591121..6f8e28f2c538de98d023283b3364ac8670917743 100644
--- a/testing/testing_zgels.c
+++ b/testing/testing_zgels.c
@@ -35,7 +35,7 @@ flops_zgels( cham_trans_t trans, int M, int N, int NRHS )
 }
 
 int
-testing_zgels( run_arg_list_t *args, int check )
+testing_zgels_desc( run_arg_list_t *args, int check )
 {
     testdata_t test_data = { .args = args };
     int        hres      = 0;
@@ -157,7 +157,8 @@ testing_zgels_init( void )
     test_zgels.params = zgels_params;
     test_zgels.output = zgels_output;
     test_zgels.outchk = zgels_outchk;
-    test_zgels.fptr   = testing_zgels;
+    test_zgels.fptr_desc = testing_zgels_desc;
+    test_zgels.fptr_std  = NULL;
     test_zgels.next   = NULL;
 
     testing_register( &test_zgels );
diff --git a/testing/testing_zgels_hqr.c b/testing/testing_zgels_hqr.c
index f0227671a35a880f44ca6bcf56afc7a423270e89..ca230b1de1a3a2f6ab94bd0451d5dd2160c20b57 100644
--- a/testing/testing_zgels_hqr.c
+++ b/testing/testing_zgels_hqr.c
@@ -35,7 +35,7 @@ flops_zgels_hqr( cham_trans_t trans, int M, int N, int NRHS )
 }
 
 int
-testing_zgels_hqr( run_arg_list_t *args, int check )
+testing_zgels_hqr_desc( run_arg_list_t *args, int check )
 {
     testdata_t test_data = { .args = args };
     int        hres      = 0;
@@ -167,7 +167,8 @@ testing_zgels_hqr_init( void )
     test_zgels_hqr.params = zgels_hqr_params;
     test_zgels_hqr.output = zgels_hqr_output;
     test_zgels_hqr.outchk = zgels_hqr_outchk;
-    test_zgels_hqr.fptr   = testing_zgels_hqr;
+    test_zgels_hqr.fptr_desc = testing_zgels_hqr_desc;
+    test_zgels_hqr.fptr_std  = NULL;
     test_zgels_hqr.next   = NULL;
 
     testing_register( &test_zgels_hqr );
diff --git a/testing/testing_zgemm.c b/testing/testing_zgemm.c
index d1700a38971d5db624e6b571f2d6513779151230..14d42ea824bc4cb185432cc33f011c6169a1a600 100644
--- a/testing/testing_zgemm.c
+++ b/testing/testing_zgemm.c
@@ -23,7 +23,7 @@
 #include <chameleon/flops.h>
 
 int
-testing_zgemm( run_arg_list_t *args, int check )
+testing_zgemm_desc( run_arg_list_t *args, int check )
 {
     testdata_t test_data = { .args = args };
     int        hres      = 0;
@@ -149,7 +149,8 @@ testing_zgemm_init( void )
     test_zgemm.params = zgemm_params;
     test_zgemm.output = zgemm_output;
     test_zgemm.outchk = zgemm_outchk;
-    test_zgemm.fptr   = testing_zgemm;
+    test_zgemm.fptr_desc = testing_zgemm_desc;
+    test_zgemm.fptr_std  = NULL;
     test_zgemm.next   = NULL;
 
     testing_register( &test_zgemm );
diff --git a/testing/testing_zgenm2.c b/testing/testing_zgenm2.c
index ea1a33154d969636d10743901adf3bf8f611b64e..44bf4730f44e6f788b960732c020946521b3a6fd 100644
--- a/testing/testing_zgenm2.c
+++ b/testing/testing_zgenm2.c
@@ -38,7 +38,7 @@ flops_zgenm2( int M, int N )
 }
 
 int
-testing_zgenm2( run_arg_list_t *args, int check )
+testing_zgenm2_desc( run_arg_list_t *args, int check )
 {
     testdata_t test_data = { .args = args };
     int        hres      = 0;
@@ -141,7 +141,8 @@ testing_zgenm2_init( void )
     test_zgenm2.params = zgenm2_params;
     test_zgenm2.output = zgenm2_output;
     test_zgenm2.outchk = zgenm2_outchk;
-    test_zgenm2.fptr   = testing_zgenm2;
+    test_zgenm2.fptr_desc = testing_zgenm2_desc;
+    test_zgenm2.fptr_std  = NULL;
     test_zgenm2.next   = NULL;
 
     testing_register( &test_zgenm2 );
diff --git a/testing/testing_zgepdf_qdwh.c b/testing/testing_zgepdf_qdwh.c
index 56042f19f2223a2707d1f6c1f1255e1919ab81fa..051bff8f69ee0d3feaaab6c6591cb3dbc6864b7b 100644
--- a/testing/testing_zgepdf_qdwh.c
+++ b/testing/testing_zgepdf_qdwh.c
@@ -28,7 +28,7 @@
 #include <chameleon/flops.h>
 
 int
-testing_zgepdf_qdwh( run_arg_list_t *args, int check )
+testing_zgepdf_qdwh_desc( run_arg_list_t *args, int check )
 {
     testdata_t test_data = { .args = args };
     int        hres      = 0;
@@ -137,7 +137,8 @@ testing_zgepdf_qdwh_init( void )
     test_zgepdf_qdwh.params = zgepdf_qdwh_params;
     test_zgepdf_qdwh.output = zgepdf_qdwh_output;
     test_zgepdf_qdwh.outchk = zgepdf_qdwh_outchk;
-    test_zgepdf_qdwh.fptr   = testing_zgepdf_qdwh;
+    test_zgepdf_qdwh.fptr_desc = testing_zgepdf_qdwh_desc;
+    test_zgepdf_qdwh.fptr_std  = NULL;
     test_zgepdf_qdwh.next   = NULL;
 
     testing_register( &test_zgepdf_qdwh );
diff --git a/testing/testing_zgepdf_qr.c b/testing/testing_zgepdf_qr.c
index 401d9b6d0816b61a72ba072e08b7251247dc6d00..25b85f3c52acd2c08238f4aa107f01bb95e8dafe 100644
--- a/testing/testing_zgepdf_qr.c
+++ b/testing/testing_zgepdf_qr.c
@@ -36,7 +36,7 @@ flops_zgepdf_qr( int M, int N )
 }
 
 int
-testing_zgepdf_qr( run_arg_list_t *args, int check )
+testing_zgepdf_qr_desc( run_arg_list_t *args, int check )
 {
     testdata_t test_data = { .args = args };
     int        hres      = 0;
@@ -192,7 +192,8 @@ testing_zgepdf_qr_init( void )
     test_zgepdf_qr.params = zgepdf_qr_params;
     test_zgepdf_qr.output = zgepdf_qr_output;
     test_zgepdf_qr.outchk = zgepdf_qr_outchk;
-    test_zgepdf_qr.fptr   = testing_zgepdf_qr;
+    test_zgepdf_qr.fptr_desc = testing_zgepdf_qr_desc;
+    test_zgepdf_qr.fptr_std  = NULL;
     test_zgepdf_qr.next   = NULL;
 
     testing_register( &test_zgepdf_qr );
diff --git a/testing/testing_zgeqrf.c b/testing/testing_zgeqrf.c
index 331eb06a9e1e41ce7b86c5efaa999266c5d87151..384ff7dc91370d7aca107cc7fbde4e638e3bb8a6 100644
--- a/testing/testing_zgeqrf.c
+++ b/testing/testing_zgeqrf.c
@@ -22,7 +22,7 @@
 #include <chameleon/flops.h>
 
 int
-testing_zgeqrf( run_arg_list_t *args, int check )
+testing_zgeqrf_desc( run_arg_list_t *args, int check )
 {
     testdata_t test_data = { .args = args };
     int        hres      = 0;
@@ -116,7 +116,8 @@ testing_zgeqrf_init( void )
     test_zgeqrf.params = zgeqrf_params;
     test_zgeqrf.output = zgeqrf_output;
     test_zgeqrf.outchk = zgeqrf_outchk;
-    test_zgeqrf.fptr   = testing_zgeqrf;
+    test_zgeqrf.fptr_desc = testing_zgeqrf_desc;
+    test_zgeqrf.fptr_std  = NULL;
     test_zgeqrf.next   = NULL;
 
     testing_register( &test_zgeqrf );
diff --git a/testing/testing_zgeqrf_hqr.c b/testing/testing_zgeqrf_hqr.c
index 8d4250ced4ba833115e4824b82010b4b2ff1ea48..6bf39e35a6be5a2def5d99133cd56e9a845f46b8 100644
--- a/testing/testing_zgeqrf_hqr.c
+++ b/testing/testing_zgeqrf_hqr.c
@@ -22,7 +22,7 @@
 #include <chameleon/flops.h>
 
 int
-testing_zgeqrf_hqr( run_arg_list_t *args, int check )
+testing_zgeqrf_hqr_desc( run_arg_list_t *args, int check )
 {
     testdata_t test_data = { .args = args };
     int        hres      = 0;
@@ -128,7 +128,8 @@ testing_zgeqrf_hqr_init( void )
     test_zgeqrf_hqr.params = zgeqrf_hqr_params;
     test_zgeqrf_hqr.output = zgeqrf_hqr_output;
     test_zgeqrf_hqr.outchk = zgeqrf_hqr_outchk;
-    test_zgeqrf_hqr.fptr   = testing_zgeqrf_hqr;
+    test_zgeqrf_hqr.fptr_desc = testing_zgeqrf_hqr_desc;
+    test_zgeqrf_hqr.fptr_std  = NULL;
     test_zgeqrf_hqr.next   = NULL;
 
     testing_register( &test_zgeqrf_hqr );
diff --git a/testing/testing_zgeqrs.c b/testing/testing_zgeqrs.c
index 4fd5f29ca6934caf639544bf50d5a743a1bf1c2f..732c9d639e0010089d7c1b90714fbfcbdeab8d99 100644
--- a/testing/testing_zgeqrs.c
+++ b/testing/testing_zgeqrs.c
@@ -23,7 +23,7 @@
 #include "control/common.h"
 
 int
-testing_zgeqrs( run_arg_list_t *args, int check )
+testing_zgeqrs_desc( run_arg_list_t *args, int check )
 {
     testdata_t test_data = { .args = args };
     int        hres      = 0;
@@ -136,7 +136,8 @@ testing_zgeqrs_init( void )
     test_zgeqrs.params = zgeqrs_params;
     test_zgeqrs.output = zgeqrs_output;
     test_zgeqrs.outchk = zgeqrs_outchk;
-    test_zgeqrs.fptr   = testing_zgeqrs;
+    test_zgeqrs.fptr_desc = testing_zgeqrs_desc;
+    test_zgeqrs.fptr_std  = NULL;
     test_zgeqrs.next   = NULL;
 
     testing_register( &test_zgeqrs );
diff --git a/testing/testing_zgesv.c b/testing/testing_zgesv.c
index ab8b9daa8800b162ba9313fb52d6017d1de1e894..ed64e0893b73df16b44656409e56ad8a9df50b58 100644
--- a/testing/testing_zgesv.c
+++ b/testing/testing_zgesv.c
@@ -29,7 +29,7 @@ flops_zgesv( int N, int NRHS )
 }
 
 int
-testing_zgesv( run_arg_list_t *args, int check )
+testing_zgesv_desc( run_arg_list_t *args, int check )
 {
     testdata_t test_data = { .args = args };
     int        hres      = 0;
@@ -121,7 +121,8 @@ testing_zgesv_init( void )
     test_zgesv.params = zgesv_params;
     test_zgesv.output = zgesv_output;
     test_zgesv.outchk = zgesv_outchk;
-    test_zgesv.fptr   = testing_zgesv;
+    test_zgesv.fptr_desc = testing_zgesv_desc;
+    test_zgesv.fptr_std  = NULL;
     test_zgesv.next   = NULL;
 
     testing_register( &test_zgesv );
diff --git a/testing/testing_zgetrf.c b/testing/testing_zgetrf.c
index bcc2b4ef42a367a124ee0a0bcf204ab01c43af3d..042c695bb57d8890d3de923855c193ab34ef5356 100644
--- a/testing/testing_zgetrf.c
+++ b/testing/testing_zgetrf.c
@@ -22,7 +22,7 @@
 #include <chameleon/flops.h>
 
 int
-testing_zgetrf( run_arg_list_t *args, int check )
+testing_zgetrf_desc( run_arg_list_t *args, int check )
 {
     testdata_t test_data = { .args = args };
     int        hres      = 0;
@@ -94,7 +94,8 @@ testing_zgetrf_init( void )
     test_zgetrf.params = zgetrf_params;
     test_zgetrf.output = zgetrf_output;
     test_zgetrf.outchk = zgetrf_outchk;
-    test_zgetrf.fptr   = testing_zgetrf;
+    test_zgetrf.fptr_desc = testing_zgetrf_desc;
+    test_zgetrf.fptr_std  = NULL;
     test_zgetrf.next   = NULL;
 
     testing_register( &test_zgetrf );
diff --git a/testing/testing_zgetrs.c b/testing/testing_zgetrs.c
index 7515edd2dc55efbac0c81cb746e72c37eebb2725..facc3e4759e74f09046597b736cffd9d4c8e2864 100644
--- a/testing/testing_zgetrs.c
+++ b/testing/testing_zgetrs.c
@@ -23,7 +23,7 @@
 #include <chameleon/flops.h>
 
 int
-testing_zgetrs( run_arg_list_t *args, int check )
+testing_zgetrs_desc( run_arg_list_t *args, int check )
 {
     testdata_t test_data = { .args = args };
     int        hres      = 0;
@@ -111,7 +111,8 @@ testing_zgetrs_init( void )
     test_zgetrs.params = zgetrs_params;
     test_zgetrs.output = zgetrs_output;
     test_zgetrs.outchk = zgetrs_outchk;
-    test_zgetrs.fptr   = testing_zgetrs;
+    test_zgetrs.fptr_desc = testing_zgetrs_desc;
+    test_zgetrs.fptr_std  = NULL;
     test_zgetrs.next   = NULL;
 
     testing_register( &test_zgetrs );
diff --git a/testing/testing_zgram.c b/testing/testing_zgram.c
index eca6b24f07505671d9a86e33228900b615fa28ec..78612bf69c744cea5b158b1e73b0958ecfa0eafd 100644
--- a/testing/testing_zgram.c
+++ b/testing/testing_zgram.c
@@ -35,7 +35,7 @@ flops_zgram( int N )
 }
 
 int
-testing_zgram( run_arg_list_t *args, int check )
+testing_zgram_desc( run_arg_list_t *args, int check )
 {
     testdata_t test_data = { .args = args };
     int        hres      = 0;
@@ -108,7 +108,8 @@ testing_zgram_init( void )
     test_zgram.params = zgram_params;
     test_zgram.output = zgram_output;
     test_zgram.outchk = zgram_outchk;
-    test_zgram.fptr   = testing_zgram;
+    test_zgram.fptr_desc = testing_zgram_desc;
+    test_zgram.fptr_std  = NULL;
     test_zgram.next   = NULL;
 
     testing_register( &test_zgram );
diff --git a/testing/testing_zhemm.c b/testing/testing_zhemm.c
index c592e8ceeeca316b50c31ffeeed33ead1804a059..0d01232b2644f541617502982593d8f0deb93219 100644
--- a/testing/testing_zhemm.c
+++ b/testing/testing_zhemm.c
@@ -23,7 +23,7 @@
 #include <chameleon/flops.h>
 
 int
-testing_zhemm( run_arg_list_t *args, int check )
+testing_zhemm_desc( run_arg_list_t *args, int check )
 {
     testdata_t test_data = { .args = args };
     int        hres      = 0;
@@ -131,7 +131,8 @@ testing_zhemm_init( void )
     test_zhemm.params = zhemm_params;
     test_zhemm.output = zhemm_output;
     test_zhemm.outchk = zhemm_outchk;
-    test_zhemm.fptr   = testing_zhemm;
+    test_zhemm.fptr_desc = testing_zhemm_desc;
+    test_zhemm.fptr_std  = NULL;
     test_zhemm.next   = NULL;
 
     testing_register( &test_zhemm );
diff --git a/testing/testing_zher2k.c b/testing/testing_zher2k.c
index c242fc2bfa57fddc6877cb66a1e505bd5987f7ad..c6f37eeea53f0751a47c4ce7b61e33d5f42b9281 100644
--- a/testing/testing_zher2k.c
+++ b/testing/testing_zher2k.c
@@ -23,7 +23,7 @@
 #include <chameleon/flops.h>
 
 int
-testing_zher2k( run_arg_list_t *args, int check )
+testing_zher2k_desc( run_arg_list_t *args, int check )
 {
     testdata_t test_data = { .args = args };
     int        hres      = 0;
@@ -134,7 +134,8 @@ testing_zher2k_init( void )
     test_zher2k.params = zher2k_params;
     test_zher2k.output = zher2k_output;
     test_zher2k.outchk = zher2k_outchk;
-    test_zher2k.fptr   = testing_zher2k;
+    test_zher2k.fptr_desc = testing_zher2k_desc;
+    test_zher2k.fptr_std  = NULL;
     test_zher2k.next   = NULL;
 
     testing_register( &test_zher2k );
diff --git a/testing/testing_zherk.c b/testing/testing_zherk.c
index 5162a37ce06b411348d22f414b6b46d457198ed8..05e3f349b00e065415c31ac350489222e6f4f80b 100644
--- a/testing/testing_zherk.c
+++ b/testing/testing_zherk.c
@@ -24,7 +24,7 @@
 #include <chameleon/flops.h>
 
 int
-testing_zherk( run_arg_list_t *args, int check )
+testing_zherk_desc( run_arg_list_t *args, int check )
 {
     testdata_t test_data = { .args = args };
     int        hres      = 0;
@@ -127,7 +127,8 @@ testing_zherk_init( void )
     test_zherk.params = zherk_params;
     test_zherk.output = zherk_output;
     test_zherk.outchk = zherk_outchk;
-    test_zherk.fptr   = testing_zherk;
+    test_zherk.fptr_desc = testing_zherk_desc;
+    test_zherk.fptr_std  = NULL;
     test_zherk.next   = NULL;
 
     testing_register( &test_zherk );
diff --git a/testing/testing_zlacpy.c b/testing/testing_zlacpy.c
index 708dc3f0800e6d4afa587642734d7970313812d5..b6178ef2801dfabab30610ca499bc6cfec0a566e 100644
--- a/testing/testing_zlacpy.c
+++ b/testing/testing_zlacpy.c
@@ -53,7 +53,7 @@ flops_zlacpy( cham_uplo_t uplo, int M, int N )
 }
 
 int
-testing_zlacpy( run_arg_list_t *args, int check )
+testing_zlacpy_desc( run_arg_list_t *args, int check )
 {
     testdata_t test_data = { .args = args };
     int        hres      = 0;
@@ -129,7 +129,8 @@ testing_zlacpy_init( void )
     test_zlacpy.params = zlacpy_params;
     test_zlacpy.output = zlacpy_output;
     test_zlacpy.outchk = zlacpy_outchk;
-    test_zlacpy.fptr   = testing_zlacpy;
+    test_zlacpy.fptr_desc = testing_zlacpy_desc;
+    test_zlacpy.fptr_std  = NULL;
     test_zlacpy.next   = NULL;
 
     testing_register( &test_zlacpy );
diff --git a/testing/testing_zlange.c b/testing/testing_zlange.c
index 1421cacc0b63b0721b921fecfd8982102d414842..7b5f2810d94697c6be6fe908e508eefe940576b8 100644
--- a/testing/testing_zlange.c
+++ b/testing/testing_zlange.c
@@ -26,31 +26,34 @@ static cham_fixdbl_t
 flops_zlange( cham_normtype_t ntype, int M, int N )
 {
     cham_fixdbl_t flops   = 0.;
-    double        coefabs = 1.;
+    cham_fixdbl_t coefabs = 1.;
+    cham_fixdbl_t size;
 #if defined( PRECISION_z ) || defined( PRECISION_c )
     coefabs = 3.;
 #endif
 
+    size = (cham_fixdbl_t)M * (cham_fixdbl_t)N;
     switch ( ntype ) {
         case ChamMaxNorm:
-            flops = coefabs * M * N;
+            flops = coefabs * size;
             break;
         case ChamOneNorm:
-            flops = coefabs * M * N + M * ( N - 1 );
+            flops = coefabs * size + M * ( N - 1 );
             break;
         case ChamInfNorm:
-            flops = coefabs * M * N + N * ( M - 1 );
+            flops = coefabs * size + N * ( M - 1 );
             break;
         case ChamFrobeniusNorm:
-            flops = ( coefabs + 1. ) * M * N;
+            flops = ( coefabs + 1. ) * size;
             break;
         default:;
     }
-    return flops;
+    (void)flops;
+    return sizeof( CHAMELEON_Complex64_t ) * size;
 }
 
 int
-testing_zlange( run_arg_list_t *args, int check )
+testing_zlange_desc( run_arg_list_t *args, int check )
 {
     testdata_t test_data = { .args = args };
     int        hres      = 0;
@@ -121,7 +124,8 @@ testing_zlange_init( void )
     test_zlange.params = zlange_params;
     test_zlange.output = zlange_output;
     test_zlange.outchk = zlange_outchk;
-    test_zlange.fptr   = testing_zlange;
+    test_zlange.fptr_desc = testing_zlange_desc;
+    test_zlange.fptr_std  = NULL;
     test_zlange.next   = NULL;
 
     testing_register( &test_zlange );
diff --git a/testing/testing_zlanhe.c b/testing/testing_zlanhe.c
index 7a3cb2bbcac798896d5298dd4f36b611cdc0bf4c..371afc260837a8594a62cb9c00f86dc29d41519b 100644
--- a/testing/testing_zlanhe.c
+++ b/testing/testing_zlanhe.c
@@ -25,29 +25,32 @@ static cham_fixdbl_t
 flops_zlanhe( cham_normtype_t ntype, int N )
 {
     cham_fixdbl_t flops   = 0.;
-    double        coefabs = 1.;
+    cham_fixdbl_t coefabs = 1.;
+    cham_fixdbl_t size;
 #if defined( PRECISION_z ) || defined( PRECISION_c )
     coefabs = 3.;
 #endif
 
+    size = ( (cham_fixdbl_t)N * ( (cham_fixdbl_t)N + 1. ) ) / 2.;
     switch ( ntype ) {
         case ChamMaxNorm:
-            flops = coefabs * ( N * ( N + 1 ) ) / 2.;
+            flops = coefabs * size;
             break;
         case ChamOneNorm:
         case ChamInfNorm:
-            flops = coefabs * ( N * ( N + 1 ) ) / 2. + N * ( N - 1 );
+            flops = coefabs * size + N * ( N - 1 );
             break;
         case ChamFrobeniusNorm:
-            flops = ( coefabs + 1. ) * ( N * ( N + 1 ) ) / 2.;
+            flops = ( coefabs + 1. ) * size;
             break;
         default:;
     }
-    return flops;
+    (void)flops;
+    return sizeof( CHAMELEON_Complex64_t ) * size;
 }
 
 int
-testing_zlanhe( run_arg_list_t *args, int check )
+testing_zlanhe_desc( run_arg_list_t *args, int check )
 {
     testdata_t test_data = { .args = args };
     int        hres      = 0;
@@ -120,7 +123,8 @@ testing_zlanhe_init( void )
     test_zlanhe.params = zlanhe_params;
     test_zlanhe.output = zlanhe_output;
     test_zlanhe.outchk = zlanhe_outchk;
-    test_zlanhe.fptr   = testing_zlanhe;
+    test_zlanhe.fptr_desc = testing_zlanhe_desc;
+    test_zlanhe.fptr_std  = NULL;
     test_zlanhe.next   = NULL;
 
     testing_register( &test_zlanhe );
diff --git a/testing/testing_zlansy.c b/testing/testing_zlansy.c
index 651092e54bdb3e6aa7806a17693460db207ad7f9..3d9aa0593f138c40a6802024d51fdffc20270520 100644
--- a/testing/testing_zlansy.c
+++ b/testing/testing_zlansy.c
@@ -25,29 +25,32 @@ static cham_fixdbl_t
 flops_zlansy( cham_normtype_t ntype, int N )
 {
     cham_fixdbl_t flops   = 0.;
-    double        coefabs = 1.;
+    cham_fixdbl_t coefabs = 1.;
+    cham_fixdbl_t size;
 #if defined( PRECISION_z ) || defined( PRECISION_c )
     coefabs = 3.;
 #endif
 
+    size = ( (cham_fixdbl_t)N * ( (cham_fixdbl_t)N + 1. ) ) / 2.;
     switch ( ntype ) {
         case ChamMaxNorm:
-            flops = coefabs * ( N * ( N + 1 ) ) / 2.;
+            flops = coefabs * size;
             break;
         case ChamOneNorm:
         case ChamInfNorm:
-            flops = coefabs * ( N * ( N + 1 ) ) / 2. + N * ( N - 1 );
+            flops = coefabs * size + N * ( N - 1 );
             break;
         case ChamFrobeniusNorm:
-            flops = ( coefabs + 1. ) * ( N * ( N + 1 ) ) / 2.;
+            flops = ( coefabs + 1. ) * size;
             break;
         default:;
     }
-    return flops;
+    (void)flops;
+    return sizeof( CHAMELEON_Complex64_t ) * size;
 }
 
 int
-testing_zlansy( run_arg_list_t *args, int check )
+testing_zlansy_desc( run_arg_list_t *args, int check )
 {
     testdata_t test_data = { .args = args };
     int        hres      = 0;
@@ -120,7 +123,8 @@ testing_zlansy_init( void )
     test_zlansy.params = zlansy_params;
     test_zlansy.output = zlansy_output;
     test_zlansy.outchk = zlansy_outchk;
-    test_zlansy.fptr   = testing_zlansy;
+    test_zlansy.fptr_desc = testing_zlansy_desc;
+    test_zlansy.fptr_std  = NULL;
     test_zlansy.next   = NULL;
 
     testing_register( &test_zlansy );
diff --git a/testing/testing_zlantr.c b/testing/testing_zlantr.c
index a7690f9e0df550c86b79469bdb91bb2e7fe43d53..251a73cb308113862f3a00cf84136663ceb8aaa7 100644
--- a/testing/testing_zlantr.c
+++ b/testing/testing_zlantr.c
@@ -25,7 +25,8 @@ static cham_fixdbl_t
 flops_zlantr( cham_normtype_t ntype, cham_uplo_t uplo, int M, int N )
 {
     cham_fixdbl_t flops   = 0.;
-    double        coefabs = 1.;
+    cham_fixdbl_t coefabs = 1.;
+    cham_fixdbl_t size;
 #if defined( PRECISION_z ) || defined( PRECISION_c )
     coefabs = 3.;
 #endif
@@ -33,25 +34,25 @@ flops_zlantr( cham_normtype_t ntype, cham_uplo_t uplo, int M, int N )
     switch ( uplo ) {
         case ChamUpper:
             if ( N > M ) {
-                flops = ( M * ( M + 1 ) / 2 ) + M * ( N - M );
+                size = ( M * ( M + 1 ) / 2 ) + M * ( N - M );
             }
             else {
-                flops = N * ( N + 1 ) / 2;
+                size = N * ( N + 1 ) / 2;
             }
             break;
         case ChamLower:
             if ( M > N ) {
-                flops = ( N * ( N + 1 ) / 2 ) + N * ( M - N );
+                size = ( N * ( N + 1 ) / 2 ) + N * ( M - N );
             }
             else {
-                flops = M * ( M + 1 ) / 2;
+                size = M * ( M + 1 ) / 2;
             }
             break;
         case ChamUpperLower:
         default:
-            flops = M * N;
+            size = M * N;
     }
-    flops *= coefabs;
+    flops = size * coefabs;
 
     switch ( ntype ) {
         case ChamOneNorm:
@@ -61,14 +62,18 @@ flops_zlantr( cham_normtype_t ntype, cham_uplo_t uplo, int M, int N )
             flops += M;
             break;
         case ChamMaxNorm:
+            break;
         case ChamFrobeniusNorm:
+            flops += size;
+            break;
         default:;
     }
-    return flops;
+    (void)flops;
+    return size;
 }
 
 int
-testing_zlantr( run_arg_list_t *args, int check )
+testing_zlantr_desc( run_arg_list_t *args, int check )
 {
     testdata_t test_data = { .args = args };
     int        hres      = 0;
@@ -141,7 +146,8 @@ testing_zlantr_init( void )
     test_zlantr.params = zlantr_params;
     test_zlantr.output = zlantr_output;
     test_zlantr.outchk = zlantr_outchk;
-    test_zlantr.fptr   = testing_zlantr;
+    test_zlantr.fptr_desc = testing_zlantr_desc;
+    test_zlantr.fptr_std  = NULL;
     test_zlantr.next   = NULL;
 
     testing_register( &test_zlantr );
diff --git a/testing/testing_zlascal.c b/testing/testing_zlascal.c
index 0c1f6248990fe39ad065dcf4cbdfc77ea4ee492a..34e3ad13450719da2f842c4bc53fbae5cf7b1fd9 100644
--- a/testing/testing_zlascal.c
+++ b/testing/testing_zlascal.c
@@ -47,7 +47,7 @@ flops_zlascal( cham_uplo_t uplo, int M, int N )
 }
 
 int
-testing_zlascal( run_arg_list_t *args, int check )
+testing_zlascal_desc( run_arg_list_t *args, int check )
 {
     testdata_t test_data = { .args = args };
     int        hres      = 0;
@@ -123,7 +123,8 @@ testing_zlascal_init( void )
     test_zlascal.params = zlascal_params;
     test_zlascal.output = zlascal_output;
     test_zlascal.outchk = zlascal_outchk;
-    test_zlascal.fptr   = testing_zlascal;
+    test_zlascal.fptr_desc = testing_zlascal_desc;
+    test_zlascal.fptr_std  = NULL;
     test_zlascal.next   = NULL;
 
     testing_register( &test_zlascal );
diff --git a/testing/testing_zlauum.c b/testing/testing_zlauum.c
index 10eb91965510fa299bdfcc0ae4a72492b309a3c9..a7e34a9610c282ea1da114d4541b99afd28dda29 100644
--- a/testing/testing_zlauum.c
+++ b/testing/testing_zlauum.c
@@ -29,7 +29,7 @@ flops_zlauum( int N )
 }
 
 int
-testing_zlauum( run_arg_list_t *args, int check )
+testing_zlauum_desc( run_arg_list_t *args, int check )
 {
     testdata_t test_data = { .args = args };
     int        hres      = 0;
@@ -100,7 +100,8 @@ testing_zlauum_init( void )
     test_zlauum.params = zlauum_params;
     test_zlauum.output = zlauum_output;
     test_zlauum.outchk = zlauum_outchk;
-    test_zlauum.fptr   = testing_zlauum;
+    test_zlauum.fptr_desc = testing_zlauum_desc;
+    test_zlauum.fptr_std  = NULL;
     test_zlauum.next   = NULL;
 
     testing_register( &test_zlauum );
diff --git a/testing/testing_zplrnk.c b/testing/testing_zplrnk.c
index 6563fc90a9a033a689d073c91cdba22f528f8caf..3e80a7a7642cde12fbd31f5a6c7dd7d711b2d727 100644
--- a/testing/testing_zplrnk.c
+++ b/testing/testing_zplrnk.c
@@ -23,7 +23,7 @@
 #include <chameleon/flops.h>
 
 int
-testing_zplrnk( run_arg_list_t *args, int check )
+testing_zplrnk_desc( run_arg_list_t *args, int check )
 {
     testdata_t test_data = { .args = args };
     int        hres      = 0;
@@ -89,7 +89,8 @@ testing_zplrnk_init( void )
     test_zplrnk.params = zplrnk_params;
     test_zplrnk.output = zplrnk_output;
     test_zplrnk.outchk = zplrnk_outchk;
-    test_zplrnk.fptr   = testing_zplrnk;
+    test_zplrnk.fptr_desc = testing_zplrnk_desc;
+    test_zplrnk.fptr_std  = NULL;
     test_zplrnk.next   = NULL;
 
     testing_register( &test_zplrnk );
diff --git a/testing/testing_zpoinv.c b/testing/testing_zpoinv.c
index 8abc4e85bd70d725565ff3c783a37f9555cbc4f9..2b5ff90b76186cc4443bb3f34bddc54929e1d74c 100644
--- a/testing/testing_zpoinv.c
+++ b/testing/testing_zpoinv.c
@@ -32,7 +32,7 @@ flops_zpoinv( int N )
 }
 
 int
-testing_zpoinv( run_arg_list_t *args, int check )
+testing_zpoinv_desc( run_arg_list_t *args, int check )
 {
     testdata_t test_data = { .args = args };
     int        hres      = 0;
@@ -104,7 +104,8 @@ testing_zpoinv_init( void )
     test_zpoinv.params = zpoinv_params;
     test_zpoinv.output = zpoinv_output;
     test_zpoinv.outchk = zpoinv_outchk;
-    test_zpoinv.fptr   = testing_zpoinv;
+    test_zpoinv.fptr_desc = testing_zpoinv_desc;
+    test_zpoinv.fptr_std  = NULL;
     test_zpoinv.next   = NULL;
 
     testing_register( &test_zpoinv );
diff --git a/testing/testing_zposv.c b/testing/testing_zposv.c
index 581eecc5380ac3f6bcf6d07d71031b8b3079c6a1..56b10eced0ca4731460d065649bb59b296c3e932 100644
--- a/testing/testing_zposv.c
+++ b/testing/testing_zposv.c
@@ -30,7 +30,7 @@ flops_zposv( int N, int NRHS )
 }
 
 int
-testing_zposv( run_arg_list_t *args, int check )
+testing_zposv_desc( run_arg_list_t *args, int check )
 {
     testdata_t test_data = { .args = args };
     int        hres      = 0;
@@ -123,7 +123,8 @@ testing_zposv_init( void )
     test_zposv.params = zposv_params;
     test_zposv.output = zposv_output;
     test_zposv.outchk = zposv_outchk;
-    test_zposv.fptr   = testing_zposv;
+    test_zposv.fptr_desc = testing_zposv_desc;
+    test_zposv.fptr_std  = NULL;
     test_zposv.next   = NULL;
 
     testing_register( &test_zposv );
diff --git a/testing/testing_zpotrf.c b/testing/testing_zpotrf.c
index 92caa245db6cf82f21dbca12a54ec99989ccbcc8..a584be5a26a48fe357fbe0efcbb2ffc4d8436d55 100644
--- a/testing/testing_zpotrf.c
+++ b/testing/testing_zpotrf.c
@@ -22,7 +22,7 @@
 #include <chameleon/flops.h>
 
 int
-testing_zpotrf( run_arg_list_t *args, int check )
+testing_zpotrf_desc( run_arg_list_t *args, int check )
 {
     testdata_t test_data = { .args = args };
     int        hres      = 0;
@@ -78,6 +78,51 @@ testing_zpotrf( run_arg_list_t *args, int check )
     return hres;
 }
 
+int
+testing_zpotrf_std( run_arg_list_t *args, int check )
+{
+    testdata_t test_data = { .args = args };
+    int        hres      = 0;
+
+    /* Read arguments */
+    int         nb    = run_arg_get_int( args, "nb", 320 );
+    cham_uplo_t uplo  = run_arg_get_uplo( args, "uplo", ChamUpper );
+    int         N     = run_arg_get_int( args, "N", 1000 );
+    int         LDA   = run_arg_get_int( args, "LDA", N );
+    int         seedA = run_arg_get_int( args, "seedA", random() );
+
+    /* Descriptors */
+    CHAMELEON_Complex64_t *A;
+
+    CHAMELEON_Set( CHAMELEON_TILE_SIZE, nb );
+
+    /* Creates the matrices */
+    A = malloc( LDA*N*sizeof(CHAMELEON_Complex64_t) );
+
+    /* Fills the matrix with random values */
+    CHAMELEON_zplghe( (double)N, uplo, N, A, LDA, seedA );
+
+    /* Calculates the solution */
+    testing_start( &test_data );
+    hres = CHAMELEON_zpotrf( uplo, N, A, LDA );
+    test_data.hres = hres;
+    testing_stop( &test_data, flops_zpotrf( N ) );
+
+    /* Checks the factorisation and residue */
+    if ( check ) {
+        CHAMELEON_Complex64_t *A0 = malloc( LDA * N * sizeof(CHAMELEON_Complex64_t) );
+        CHAMELEON_zplghe( (double)N, uplo, N, A0, LDA, seedA );
+
+        // hres += check_zxxtrf( args, ChamHermitian, uplo, A0, A );
+
+        free( A0 );
+    }
+
+    free( A );
+
+    return hres;
+}
+
 testing_t   test_zpotrf;
 const char *zpotrf_params[] = { "mtxfmt", "nb", "uplo", "n", "lda", "seedA", NULL };
 const char *zpotrf_output[] = { NULL };
@@ -95,7 +140,8 @@ testing_zpotrf_init( void )
     test_zpotrf.params = zpotrf_params;
     test_zpotrf.output = zpotrf_output;
     test_zpotrf.outchk = zpotrf_outchk;
-    test_zpotrf.fptr   = testing_zpotrf;
+    test_zpotrf.fptr_desc = testing_zpotrf_desc;
+    test_zpotrf.fptr_std  = testing_zpotrf_std;
     test_zpotrf.next   = NULL;
 
     testing_register( &test_zpotrf );
diff --git a/testing/testing_zpotri.c b/testing/testing_zpotri.c
index d2d735bb2a6945e8d4f11c46933c7967f979d09f..5544d3b4efba249db0beebc4b4644d2911b0a79c 100644
--- a/testing/testing_zpotri.c
+++ b/testing/testing_zpotri.c
@@ -24,7 +24,7 @@
 #include <chameleon/flops.h>
 
 int
-testing_zpotri( run_arg_list_t *args, int check )
+testing_zpotri_desc( run_arg_list_t *args, int check )
 {
     testdata_t test_data = { .args = args };
     int        hres      = 0;
@@ -99,7 +99,8 @@ testing_zpotri_init( void )
     test_zpotri.params = zpotri_params;
     test_zpotri.output = zpotri_output;
     test_zpotri.outchk = zpotri_outchk;
-    test_zpotri.fptr   = testing_zpotri;
+    test_zpotri.fptr_desc = testing_zpotri_desc;
+    test_zpotri.fptr_std  = NULL;
     test_zpotri.next   = NULL;
 
     testing_register( &test_zpotri );
diff --git a/testing/testing_zpotrs.c b/testing/testing_zpotrs.c
index de80992a7137fcb8e4037148b95d43d8066f9899..eff8694631327db69ebff726d2847b4beb0a3c08 100644
--- a/testing/testing_zpotrs.c
+++ b/testing/testing_zpotrs.c
@@ -23,7 +23,7 @@
 #include <chameleon/flops.h>
 
 int
-testing_zpotrs( run_arg_list_t *args, int check )
+testing_zpotrs_desc( run_arg_list_t *args, int check )
 {
     testdata_t test_data = { .args = args };
     int        hres      = 0;
@@ -112,7 +112,8 @@ testing_zpotrs_init( void )
     test_zpotrs.params = zpotrs_params;
     test_zpotrs.output = zpotrs_output;
     test_zpotrs.outchk = zpotrs_outchk;
-    test_zpotrs.fptr   = testing_zpotrs;
+    test_zpotrs.fptr_desc = testing_zpotrs_desc;
+    test_zpotrs.fptr_std  = NULL;
     test_zpotrs.next   = NULL;
 
     testing_register( &test_zpotrs );
diff --git a/testing/testing_zprint.c b/testing/testing_zprint.c
index a73d7b7a6485127e6f829f842aca11c02e5321e2..24c6041adf8275fc1950373d791e7db06421e9a8 100644
--- a/testing/testing_zprint.c
+++ b/testing/testing_zprint.c
@@ -50,7 +50,7 @@ chameleon_getblkldd_cm( const CHAM_desc_t *A, int m )
 }
 
 int
-testing_zprint( run_arg_list_t *args, int check )
+testing_zprint_desc( run_arg_list_t *args, int check )
 {
     int rc, hres = 0;
 
@@ -149,7 +149,8 @@ testing_zprint_init( void )
     test_zprint.params = zprint_params;
     test_zprint.output = zprint_output;
     test_zprint.outchk = zprint_outchk;
-    test_zprint.fptr   = testing_zprint;
+    test_zprint.fptr_desc = testing_zprint_desc;
+    test_zprint.fptr_std  = NULL;
     test_zprint.next   = NULL;
 
     testing_register( &test_zprint );
diff --git a/testing/testing_zsymm.c b/testing/testing_zsymm.c
index e4437d418b9b9d45235b8b42fa1bbef57555bf80..aa24d2d680eb1a7a0966dee44b83c7447b24add7 100644
--- a/testing/testing_zsymm.c
+++ b/testing/testing_zsymm.c
@@ -23,7 +23,7 @@
 #include <chameleon/flops.h>
 
 int
-testing_zsymm( run_arg_list_t *args, int check )
+testing_zsymm_desc( run_arg_list_t *args, int check )
 {
     testdata_t test_data = { .args = args };
     int        hres      = 0;
@@ -131,7 +131,8 @@ testing_zsymm_init( void )
     test_zsymm.params = zsymm_params;
     test_zsymm.output = zsymm_output;
     test_zsymm.outchk = zsymm_outchk;
-    test_zsymm.fptr   = testing_zsymm;
+    test_zsymm.fptr_desc = testing_zsymm_desc;
+    test_zsymm.fptr_std  = NULL;
     test_zsymm.next   = NULL;
 
     testing_register( &test_zsymm );
diff --git a/testing/testing_zsyr2k.c b/testing/testing_zsyr2k.c
index 5ad295e9d1e22740c4df40f6fd3fc2b5499914d3..e2c57b26f65242725b17946e02ab36ebf4f8eca7 100644
--- a/testing/testing_zsyr2k.c
+++ b/testing/testing_zsyr2k.c
@@ -23,7 +23,7 @@
 #include <chameleon/flops.h>
 
 int
-testing_zsyr2k( run_arg_list_t *args, int check )
+testing_zsyr2k_desc( run_arg_list_t *args, int check )
 {
     testdata_t test_data = { .args = args };
     int        hres      = 0;
@@ -134,7 +134,8 @@ testing_zsyr2k_init( void )
     test_zsyr2k.params = zsyr2k_params;
     test_zsyr2k.output = zsyr2k_output;
     test_zsyr2k.outchk = zsyr2k_outchk;
-    test_zsyr2k.fptr   = testing_zsyr2k;
+    test_zsyr2k.fptr_desc = testing_zsyr2k_desc;
+    test_zsyr2k.fptr_std  = NULL;
     test_zsyr2k.next   = NULL;
 
     testing_register( &test_zsyr2k );
diff --git a/testing/testing_zsyrk.c b/testing/testing_zsyrk.c
index 2c8bcf400da78aad665682eeabb82efd38732a7b..dd70eed1425ee1e1b7dc18769de3065e64674c69 100644
--- a/testing/testing_zsyrk.c
+++ b/testing/testing_zsyrk.c
@@ -23,7 +23,7 @@
 #include <chameleon/flops.h>
 
 int
-testing_zsyrk( run_arg_list_t *args, int check )
+testing_zsyrk_desc( run_arg_list_t *args, int check )
 {
     testdata_t test_data = { .args = args };
     int        hres      = 0;
@@ -126,7 +126,8 @@ testing_zsyrk_init( void )
     test_zsyrk.params = zsyrk_params;
     test_zsyrk.output = zsyrk_output;
     test_zsyrk.outchk = zsyrk_outchk;
-    test_zsyrk.fptr   = testing_zsyrk;
+    test_zsyrk.fptr_desc = testing_zsyrk_desc;
+    test_zsyrk.fptr_std  = NULL;
     test_zsyrk.next   = NULL;
 
     testing_register( &test_zsyrk );
diff --git a/testing/testing_zsysv.c b/testing/testing_zsysv.c
index 302eb4726ce2ddda4c9c4f6e6b75c19033375e55..8cb8807b869b9fc22c9b7332791dbc3020eba2d2 100644
--- a/testing/testing_zsysv.c
+++ b/testing/testing_zsysv.c
@@ -29,7 +29,7 @@ flops_zsysv( int N, int NRHS )
 }
 
 int
-testing_zsysv( run_arg_list_t *args, int check )
+testing_zsysv_desc( run_arg_list_t *args, int check )
 {
     testdata_t test_data = { .args = args };
     int        hres      = 0;
@@ -122,7 +122,8 @@ testing_zsysv_init( void )
     test_zsysv.params = zsysv_params;
     test_zsysv.output = zsysv_output;
     test_zsysv.outchk = zsysv_outchk;
-    test_zsysv.fptr   = testing_zsysv;
+    test_zsysv.fptr_desc = testing_zsysv_desc;
+    test_zsysv.fptr_std  = NULL;
     test_zsysv.next   = NULL;
 
     testing_register( &test_zsysv );
diff --git a/testing/testing_zsytrf.c b/testing/testing_zsytrf.c
index 72667bc976db03e6767e144adb93cabd2bf5da7f..0fa93374a88950999f28e5b9adf1cfeb827addfa 100644
--- a/testing/testing_zsytrf.c
+++ b/testing/testing_zsytrf.c
@@ -22,7 +22,7 @@
 #include <chameleon/flops.h>
 
 int
-testing_zsytrf( run_arg_list_t *args, int check )
+testing_zsytrf_desc( run_arg_list_t *args, int check )
 {
     testdata_t test_data = { .args = args };
     int        hres      = 0;
@@ -94,7 +94,8 @@ testing_zsytrf_init( void )
     test_zsytrf.params = zsytrf_params;
     test_zsytrf.output = zsytrf_output;
     test_zsytrf.outchk = zsytrf_outchk;
-    test_zsytrf.fptr   = testing_zsytrf;
+    test_zsytrf.fptr_desc = testing_zsytrf_desc;
+    test_zsytrf.fptr_std  = NULL;
     test_zsytrf.next   = NULL;
 
     testing_register( &test_zsytrf );
diff --git a/testing/testing_zsytrs.c b/testing/testing_zsytrs.c
index 80e44e41c8b17c8eddd5b71a43fdc44517b2db11..ffde16d2b14501c23f69df2d0c3c3daef31b9735 100644
--- a/testing/testing_zsytrs.c
+++ b/testing/testing_zsytrs.c
@@ -23,7 +23,7 @@
 #include <chameleon/flops.h>
 
 int
-testing_zsytrs( run_arg_list_t *args, int check )
+testing_zsytrs_desc( run_arg_list_t *args, int check )
 {
     testdata_t test_data = { .args = args };
     int        hres      = 0;
@@ -112,7 +112,8 @@ testing_zsytrs_init( void )
     test_zsytrs.params = zsytrs_params;
     test_zsytrs.output = zsytrs_output;
     test_zsytrs.outchk = zsytrs_outchk;
-    test_zsytrs.fptr   = testing_zsytrs;
+    test_zsytrs.fptr_desc = testing_zsytrs_desc;
+    test_zsytrs.fptr_std  = NULL;
     test_zsytrs.next   = NULL;
 
     testing_register( &test_zsytrs );
diff --git a/testing/testing_ztradd.c b/testing/testing_ztradd.c
index a754ce6c9bde8811abef65649d738d4d34a01b7b..c5fa76cf70a0f90920f65d038ac19ffe338a62e5 100644
--- a/testing/testing_ztradd.c
+++ b/testing/testing_ztradd.c
@@ -49,7 +49,7 @@ flops_ztradd( cham_uplo_t uplo, int M, int N )
 }
 
 int
-testing_ztradd( run_arg_list_t *args, int check )
+testing_ztradd_desc( run_arg_list_t *args, int check )
 {
     testdata_t test_data = { .args = args };
     int        hres      = 0;
@@ -168,7 +168,8 @@ testing_ztradd_init( void )
     test_ztradd.params = ztradd_params;
     test_ztradd.output = ztradd_output;
     test_ztradd.outchk = ztradd_outchk;
-    test_ztradd.fptr   = testing_ztradd;
+    test_ztradd.fptr_desc = testing_ztradd_desc;
+    test_ztradd.fptr_std  = NULL;
     test_ztradd.next   = NULL;
 
     testing_register( &test_ztradd );
diff --git a/testing/testing_ztrmm.c b/testing/testing_ztrmm.c
index bd226288f55c1dd64081027a319af67cafea38eb..16cd4e1e8d0aa345075789c7d62364fbb95b5f8b 100644
--- a/testing/testing_ztrmm.c
+++ b/testing/testing_ztrmm.c
@@ -23,7 +23,7 @@
 #include <chameleon/flops.h>
 
 int
-testing_ztrmm( run_arg_list_t *args, int check )
+testing_ztrmm_desc( run_arg_list_t *args, int check )
 {
     testdata_t test_data = { .args = args };
     int        hres      = 0;
@@ -124,7 +124,8 @@ testing_ztrmm_init( void )
     test_ztrmm.params = ztrmm_params;
     test_ztrmm.output = ztrmm_output;
     test_ztrmm.outchk = ztrmm_outchk;
-    test_ztrmm.fptr   = testing_ztrmm;
+    test_ztrmm.fptr_desc = testing_ztrmm_desc;
+    test_ztrmm.fptr_std  = NULL;
     test_ztrmm.next   = NULL;
 
     testing_register( &test_ztrmm );
diff --git a/testing/testing_ztrsm.c b/testing/testing_ztrsm.c
index 043debc55915541b76ef2635dd3f4f24470fdd65..8ce17649194f3f1714be00136f42262881de2546 100644
--- a/testing/testing_ztrsm.c
+++ b/testing/testing_ztrsm.c
@@ -23,7 +23,7 @@
 #include <chameleon/flops.h>
 
 int
-testing_ztrsm( run_arg_list_t *args, int check )
+testing_ztrsm_desc( run_arg_list_t *args, int check )
 {
     testdata_t test_data = { .args = args };
     int        hres      = 0;
@@ -115,7 +115,8 @@ testing_ztrsm_init( void )
     test_ztrsm.params = ztrsm_params;
     test_ztrsm.output = ztrsm_output;
     test_ztrsm.outchk = ztrsm_outchk;
-    test_ztrsm.fptr   = testing_ztrsm;
+    test_ztrsm.fptr_desc = testing_ztrsm_desc;
+    test_ztrsm.fptr_std  = NULL;
     test_ztrsm.next   = NULL;
 
     testing_register( &test_ztrsm );
diff --git a/testing/testing_ztrtri.c b/testing/testing_ztrtri.c
index c3a3ad3f4e9d7dc2e23a098ddfd43156941efee2..957ce66f9683bac4bc9511fe58300199f7416d97 100644
--- a/testing/testing_ztrtri.c
+++ b/testing/testing_ztrtri.c
@@ -22,7 +22,7 @@
 #include <chameleon/flops.h>
 
 int
-testing_ztrtri( run_arg_list_t *args, int check )
+testing_ztrtri_desc( run_arg_list_t *args, int check )
 {
     testdata_t test_data = { .args = args };
     int        hres      = 0;
@@ -96,7 +96,8 @@ testing_ztrtri_init( void )
     test_ztrtri.params = ztrtri_params;
     test_ztrtri.output = ztrtri_output;
     test_ztrtri.outchk = ztrtri_outchk;
-    test_ztrtri.fptr   = testing_ztrtri;
+    test_ztrtri.fptr_desc = testing_ztrtri_desc;
+    test_ztrtri.fptr_std  = NULL;
     test_ztrtri.next   = NULL;
 
     testing_register( &test_ztrtri );
diff --git a/testing/testing_zunglq.c b/testing/testing_zunglq.c
index 536554ecd1289e21cda2573b4703173191d18fab..124375253fe77d46f9053f0224c54c408dad37b0 100644
--- a/testing/testing_zunglq.c
+++ b/testing/testing_zunglq.c
@@ -22,7 +22,7 @@
 #include <chameleon/flops.h>
 
 int
-testing_zunglq( run_arg_list_t *args, int check )
+testing_zunglq_desc( run_arg_list_t *args, int check )
 {
     testdata_t test_data = { .args = args };
     int        hres      = 0;
@@ -130,7 +130,8 @@ testing_zunglq_init( void )
     test_zunglq.params = zunglq_params;
     test_zunglq.output = zunglq_output;
     test_zunglq.outchk = zunglq_outchk;
-    test_zunglq.fptr   = testing_zunglq;
+    test_zunglq.fptr_desc = testing_zunglq_desc;
+    test_zunglq.fptr_std  = NULL;
     test_zunglq.next   = NULL;
 
     testing_register( &test_zunglq );
diff --git a/testing/testing_zunglq_hqr.c b/testing/testing_zunglq_hqr.c
index 652efabddceb03658546782c954d6fd39250de0e..2f2051cf7df8af29082211325b27864b2832b47b 100644
--- a/testing/testing_zunglq_hqr.c
+++ b/testing/testing_zunglq_hqr.c
@@ -22,7 +22,7 @@
 #include <chameleon/flops.h>
 
 int
-testing_zunglq_hqr( run_arg_list_t *args, int check )
+testing_zunglq_hqr_desc( run_arg_list_t *args, int check )
 {
     testdata_t test_data = { .args = args };
     int        hres      = 0;
@@ -141,7 +141,8 @@ testing_zunglq_hqr_init( void )
     test_zunglq_hqr.params = zunglq_hqr_params;
     test_zunglq_hqr.output = zunglq_hqr_output;
     test_zunglq_hqr.outchk = zunglq_hqr_outchk;
-    test_zunglq_hqr.fptr   = testing_zunglq_hqr;
+    test_zunglq_hqr.fptr_desc = testing_zunglq_hqr_desc;
+    test_zunglq_hqr.fptr_std  = NULL;
     test_zunglq_hqr.next   = NULL;
 
     testing_register( &test_zunglq_hqr );
diff --git a/testing/testing_zungqr.c b/testing/testing_zungqr.c
index 5916755907cfc122d994f209b18c02ffd8106db4..c7016a15d883ac7691b361bf9c46c38f6e32133b 100644
--- a/testing/testing_zungqr.c
+++ b/testing/testing_zungqr.c
@@ -22,7 +22,7 @@
 #include <chameleon/flops.h>
 
 int
-testing_zungqr( run_arg_list_t *args, int check )
+testing_zungqr_desc( run_arg_list_t *args, int check )
 {
     testdata_t test_data = { .args = args };
     int        hres      = 0;
@@ -130,7 +130,8 @@ testing_zungqr_init( void )
     test_zungqr.params = zungqr_params;
     test_zungqr.output = zungqr_output;
     test_zungqr.outchk = zungqr_outchk;
-    test_zungqr.fptr   = testing_zungqr;
+    test_zungqr.fptr_desc = testing_zungqr_desc;
+    test_zungqr.fptr_std  = NULL;
     test_zungqr.next   = NULL;
 
     testing_register( &test_zungqr );
diff --git a/testing/testing_zungqr_hqr.c b/testing/testing_zungqr_hqr.c
index 773c1dbcdb5e5cc3f51e60d538d30cf181815260..11da4423a697f533aff47bfe98b39a5c30217f42 100644
--- a/testing/testing_zungqr_hqr.c
+++ b/testing/testing_zungqr_hqr.c
@@ -22,7 +22,7 @@
 #include <chameleon/flops.h>
 
 int
-testing_zungqr_hqr( run_arg_list_t *args, int check )
+testing_zungqr_hqr_desc( run_arg_list_t *args, int check )
 {
     testdata_t test_data = { .args = args };
     int        hres      = 0;
@@ -141,7 +141,8 @@ testing_zungqr_hqr_init( void )
     test_zungqr_hqr.params = zungqr_hqr_params;
     test_zungqr_hqr.output = zungqr_hqr_output;
     test_zungqr_hqr.outchk = zungqr_hqr_outchk;
-    test_zungqr_hqr.fptr   = testing_zungqr_hqr;
+    test_zungqr_hqr.fptr_desc = testing_zungqr_hqr_desc;
+    test_zungqr_hqr.fptr_std  = NULL;
     test_zungqr_hqr.next   = NULL;
 
     testing_register( &test_zungqr_hqr );
diff --git a/testing/testing_zunmlq.c b/testing/testing_zunmlq.c
index f2708fa7e46546a30c50efec7269bda90d920cd6..8a95cd75b8db0812c566313e993690b2d1a997ef 100644
--- a/testing/testing_zunmlq.c
+++ b/testing/testing_zunmlq.c
@@ -23,7 +23,7 @@
 #include <chameleon/flops.h>
 
 int
-testing_zunmlq( run_arg_list_t *args, int check )
+testing_zunmlq_desc( run_arg_list_t *args, int check )
 {
     testdata_t test_data = { .args = args };
     int        hres      = 0;
@@ -136,7 +136,8 @@ testing_zunmlq_init( void )
     test_zunmlq.params = zunmlq_params;
     test_zunmlq.output = zunmlq_output;
     test_zunmlq.outchk = zunmlq_outchk;
-    test_zunmlq.fptr   = testing_zunmlq;
+    test_zunmlq.fptr_desc = testing_zunmlq_desc;
+    test_zunmlq.fptr_std  = NULL;
     test_zunmlq.next   = NULL;
 
     testing_register( &test_zunmlq );
diff --git a/testing/testing_zunmlq_hqr.c b/testing/testing_zunmlq_hqr.c
index d657648bd38dfe71b80324971b6e1827221e2f91..166cac58ed42b43aea630a7c0aec4680aa5cd75e 100644
--- a/testing/testing_zunmlq_hqr.c
+++ b/testing/testing_zunmlq_hqr.c
@@ -23,7 +23,7 @@
 #include <chameleon/flops.h>
 
 int
-testing_zunmlq_hqr( run_arg_list_t *args, int check )
+testing_zunmlq_hqr_desc( run_arg_list_t *args, int check )
 {
     testdata_t test_data = { .args = args };
     int        hres      = 0;
@@ -147,7 +147,8 @@ testing_zunmlq_hqr_init( void )
     test_zunmlq_hqr.params = zunmlq_hqr_params;
     test_zunmlq_hqr.output = zunmlq_hqr_output;
     test_zunmlq_hqr.outchk = zunmlq_hqr_outchk;
-    test_zunmlq_hqr.fptr   = testing_zunmlq_hqr;
+    test_zunmlq_hqr.fptr_desc = testing_zunmlq_hqr_desc;
+    test_zunmlq_hqr.fptr_std  = NULL;
     test_zunmlq_hqr.next   = NULL;
 
     testing_register( &test_zunmlq_hqr );
diff --git a/testing/testing_zunmqr.c b/testing/testing_zunmqr.c
index 34fe5bc9a983661c149b1b2315d91ec2ab94e7c3..d612d8db54cf184a7774f9c19046808f8583abd0 100644
--- a/testing/testing_zunmqr.c
+++ b/testing/testing_zunmqr.c
@@ -23,7 +23,7 @@
 #include <chameleon/flops.h>
 
 int
-testing_zunmqr( run_arg_list_t *args, int check )
+testing_zunmqr_desc( run_arg_list_t *args, int check )
 {
     testdata_t test_data = { .args = args };
     int        hres      = 0;
@@ -136,7 +136,8 @@ testing_zunmqr_init( void )
     test_zunmqr.params = zunmqr_params;
     test_zunmqr.output = zunmqr_output;
     test_zunmqr.outchk = zunmqr_outchk;
-    test_zunmqr.fptr   = testing_zunmqr;
+    test_zunmqr.fptr_desc = testing_zunmqr_desc;
+    test_zunmqr.fptr_std  = NULL;
     test_zunmqr.next   = NULL;
 
     testing_register( &test_zunmqr );
diff --git a/testing/testing_zunmqr_hqr.c b/testing/testing_zunmqr_hqr.c
index e4f5e62b20fcbb704deb83f23c85cc4366c74fd8..236374d03869214297b65980137be00a985a3b7c 100644
--- a/testing/testing_zunmqr_hqr.c
+++ b/testing/testing_zunmqr_hqr.c
@@ -23,7 +23,7 @@
 #include <chameleon/flops.h>
 
 int
-testing_zunmqr_hqr( run_arg_list_t *args, int check )
+testing_zunmqr_hqr_desc( run_arg_list_t *args, int check )
 {
     testdata_t test_data = { .args = args };
     int        hres      = 0;
@@ -147,7 +147,8 @@ testing_zunmqr_hqr_init( void )
     test_zunmqr_hqr.params = zunmqr_hqr_params;
     test_zunmqr_hqr.output = zunmqr_hqr_output;
     test_zunmqr_hqr.outchk = zunmqr_hqr_outchk;
-    test_zunmqr_hqr.fptr   = testing_zunmqr_hqr;
+    test_zunmqr_hqr.fptr_desc = testing_zunmqr_hqr_desc;
+    test_zunmqr_hqr.fptr_std  = NULL;
     test_zunmqr_hqr.next   = NULL;
 
     testing_register( &test_zunmqr_hqr );
diff --git a/testing/testings.h b/testing/testings.h
index cf80e572dd19d99359741b1a4f154a25e5ef21ea..bbb8991bd2800dfc037b44ba74600139a9606439 100644
--- a/testing/testings.h
+++ b/testing/testings.h
@@ -142,7 +142,8 @@ typedef struct testing_ {
     const char **params;      /**< Parameters used by the operation                           */
     const char **output;      /**< Additional output parameters generated by the function     */
     const char **outchk;      /**< Check specific output parameters generated by the function */
-    test_fct_t   fptr;        /**< Function performing the test                               */
+    test_fct_t   fptr_std;    /**< Function performing the standard test                      */
+    test_fct_t   fptr_desc;   /**< Function performing the descriptor test                    */
     testing_t   *next;        /**< Pointer to following test                                  */
 } testing_t;