debug all leak mem with valgrind in ftest and tensor rep

.gitignore

@@ -7,3 +7,5 @@ log*
 */**/**.o
 launch_*
 eEcomp
+*massif*
+*xtmemory*

dimension_t/src/dimension_t/dimension_t.c

@@ -1,5 +1,7 @@
 #include "dimension_t/dimension_t.h"
 
+#define min(x,y) (((x)<(y))?(x):(y)) 
+
 bool endian=true;
 
 bool isLessEqThan(long int a, long int b) { return a <= b; }
@@ -10,6 +12,14 @@ long int incr(long int i) { return i + 1; }
 long int decr(long int i) { return i - 1; }
 
 dimension* init_dim(size_t *t, size_t sz){
+  dimension *d = malloc(sizeof(dimension));
+  d->size=sz;
+  d->perm=t;
+  updateRankDim(d);
+  return d;
+}
+
+dimension* init_copy_dim(size_t *t, size_t sz){
   dimension *d = INIT_COPY_PERMUTATION_TYPE_SIZE_T(t,sz);
   updateRankDim(d);
   return d;
@@ -18,6 +28,66 @@ dimension *
 create_dim(size_t sz){
   return CREATE_PERMUTATION_TYPE_SIZE_T(sz);
 }
+void free_dimension(dimension *d){
+  free_permut_TYPE_SIZE_T(d);
+}
+
+dimension* sub_copy_minus_dim_head(dimension *root, size_t minusSubdim){
+  if(minusSubdim < (root->size)){
+    dimension *d = INIT_COPY_PERMUTATION_TYPE_SIZE_T(root->perm, (root->size)-minusSubdim);
+    updateRankDim(d);
+    return d;
+  }
+  return NULL;
+}
+
+dimension* sub_copy_minus_dim_tail(dimension *root, size_t minusSubdim){
+  if(minusSubdim < (root->size)){
+    dimension *d = INIT_COPY_PERMUTATION_TYPE_SIZE_T((root->perm)+minusSubdim, (root->size)-minusSubdim);
+    updateRankDim(d);
+    return d;
+  }
+  return NULL;
+}
+
+dimension* sub_copy_dim_head(dimension *root, size_t subdim){
+  if(subdim < (root->size)){
+    dimension *d = INIT_COPY_PERMUTATION_TYPE_SIZE_T(root->perm, subdim);
+    updateRankDim(d);
+    return d;
+  }
+  return NULL;
+}
+
+dimension* sub_copy_dim_tail(dimension *root, size_t subdim){
+  if(subdim < (root->size)){
+    dimension *d = INIT_COPY_PERMUTATION_TYPE_SIZE_T((root->perm)+(root->size - subdim), subdim);
+    updateRankDim(d);
+    return d;
+  }
+  return NULL;
+}
+
+void add_copy_dimension(dimension **d, dimension *d0, dimension *d1) {
+    (*d) = create_dim(d0->size + d1->size);
+    for (size_t i = 0; i < d0->size; i++) (*d)->perm[i] = d0->perm[i];
+    for (size_t i = 0; i < d1->size; i++) (*d)->perm[d0->size + i] = d1->perm[i];
+    updateRankDim(*d);
+}
+
+void min_copy_dimension(dimension **d, dimension *d0, dimension *d1) {
+    size_t mindim = min(d0->size,d1->size) ;
+    (*d)=create_dim(mindim);
+
+       for (size_t i = 0; i < mindim; i++) {
+            if (d0->perm[i] > d1->perm[i]) (*d)->perm[i] = d1->perm[i];
+            else (*d)->perm[i] = d0->perm[i];
+        }
+    updateRankDim(*d);
+}
+
+
+
 
 dimension* sub_minus_dim_head(dimension *root, size_t minusSubdim){
   if(minusSubdim < (root->size)){
@@ -53,8 +123,6 @@ dimension* sub_dim_tail(dimension *root, size_t subdim){
 }
 void add_dimension(dimension **d, dimension *d0, dimension *d1) {
     (*d) = create_dim(d0->size + d1->size);
-    //printf("d size : %ld\n",(*d)->size);
-    (*d)->perm = malloc(sizeof(size_t)*((*d)->size));
     for (size_t i = 0; i < d0->size; i++) (*d)->perm[i] = d0->perm[i];
     for (size_t i = 0; i < d1->size; i++) (*d)->perm[d0->size + i] = d1->perm[i];
     updateRankDim(*d);

dimension_t/src/dimension_t/dimension_t.h

@@ -9,12 +9,22 @@ typedef struct PERMUTATION_TYPE_SIZE_T dimension ;
 
 dimension * create_dim(size_t size);
 dimension* init_dim(size_t *t, size_t sz);
+dimension* init_copy_dim(size_t *t, size_t sz);
+void free_dimension(dimension *d);
 
 dimension* sub_minus_dim_head(dimension *t, size_t minusSubdim);
 dimension* sub_minus_dim_tail(dimension *t, size_t minusSubdim);
 dimension* sub_dim_head(dimension *t, size_t subdim);
 dimension* sub_dim_tail(dimension *t, size_t subdim);
 
+dimension* sub_copy_minus_dim_head(dimension *t, size_t minusSubdim);
+dimension* sub_copy_minus_dim_tail(dimension *t, size_t minusSubdim);
+dimension* sub_copy_dim_head(dimension *t, size_t sub_copydim);
+dimension* sub_copy_dim_tail(dimension *t, size_t sub_copydim);
+
+void add_copy_dimension(dimension **d, dimension *d0, dimension *d1);
+void min_copy_dimension(dimension **d, dimension *d0, dimension *d1);
+
 void add_dimension(dimension **d, dimension *d0, dimension *d1);
 void min_dimension(dimension **d, dimension *d0, dimension *d1);
 

tensor_t/src/kernel_2d_ProdContractnTensor.cl

@@ -1,36 +1,75 @@
-
+__kernel void prodContractnTensor2dLin_TYPE_FLOAT(long unsigned int dSubRank, long unsigned int dMRank, __global const float *M0x , __global const float *M1x, __global float *Mx ){
-
-
-__kernel void prodContractnTensorLin_TYPE_FLOAT(long unsigned int dSubRank, long unsigned int dMRank, __global const float *M0x , __global const float *M1x, __global float *Mx ){
 
     //Get the index of the current element to be processed 
-    size_t i = get_global_id(0);
+    //size_t i = get_global_id(0);
-    size_t k, a0_id, a1_id, n0_id, n1_id;
+    //size_t j = get_global_id(1);
-    a0_id = i / dSubRank; 
+    
-    a1_id = i % dSubRank; 
+    size_t i = get_group_id(0)*get_local_size(0) + get_local_id(0);
-    Mx[i] = 0; 
+    size_t j = get_group_id(1)*get_local_size(1) + get_local_id(1);
+
+    size_t  k, n0_id, n1_id;
+    size_t ind = i * dSubRank + j;
+    Mx[ind] = 0; 
         for (k = 0;  k < dMRank; k++) {
-            n0_id = a0_id * dMRank + k;
+            n0_id = i * dMRank + k;
-            n1_id = a1_id + dSubRank * k;
+            n1_id = j + dSubRank * k;
-            Mx[i] += M0x[n0_id] * M1x[n1_id];
+            Mx[ind] += M0x[n0_id] * M1x[n1_id];
         }
 }
 
-__kernel void prodContractnTensorLin_TYPE_DOUBLE(long unsigned int dSubRank, long unsigned int dMRank, __global const double *M0x , __global const double *M1x, __global double *Mx ){
+__kernel void prodContractnTensor2dLin_TYPE_DOUBLE(long unsigned int dSubRank, long unsigned int dMRank, __global const double *M0x , __global const double *M1x, __global double *Mx ){
 
     //Get the index of the current element to be processed 
-    size_t i = get_global_id(0);
+    //size_t i = get_global_id(0);
-    size_t k, a0_id, a1_id, n0_id, n1_id;
+    //size_t j = get_global_id(1);
-    a0_id = i / dSubRank; 
+    
-    a1_id = i % dSubRank; 
+    size_t i = get_group_id(0)*get_local_size(0) + get_local_id(0);
-    Mx[i] = 0; 
+    size_t j = get_group_id(1)*get_local_size(1) + get_local_id(1);
+
+    size_t k, n0_id, n1_id;
+    size_t ind = i * dSubRank + j;
+    Mx[ind] = 0; 
         for (k = 0;  k < dMRank; k++) {
-            n0_id = a0_id * dMRank + k;
+            n0_id = i * dMRank + k;
-            n1_id = a1_id + dSubRank * k;
+            n1_id = j + dSubRank * k;
-            Mx[i] += M0x[n0_id] * M1x[n1_id];
+            Mx[ind] += M0x[n0_id] * M1x[n1_id];
         }
 }
 
+__kernel void prodContractnTensor2dLiniNotEndian_TYPE_FLOAT(long unsigned int dSubRank, long unsigned int dMRank, __global const float *M0x , __global const float *M1x, __global float *Mx ){
 
+    //Get the index of the current element to be processed 
+    //size_t i = get_global_id(0);
+    //size_t j = get_global_id(1);
+    
+    size_t i = get_group_id(0)*get_local_size(0) + get_local_id(0);
+    size_t j = get_group_id(1)*get_local_size(1) + get_local_id(1);
 
+    size_t k, n0_id, n1_id;
+    size_t ind = i + dSubRank * j;
+    Mx[ind] = 0; 
+        for (k = 0;  k < dMRank; k++) {
+            n0_id = i + dMRank * k;
+            n1_id = j * dSubRank + k;
+            Mx[ind] += M0x[n0_id] * M1x[n1_id];
+        }
+}
 
+__kernel void prodContractnTensor2dLinNotEndian_TYPE_DOUBLE(long unsigned int dSubRank, long unsigned int dMRank, __global const double *M0x , __global const double *M1x, __global double *Mx ){
+
+    //Get the index of the current element to be processed 
+    //size_t i = get_global_id(0);
+    //size_t j = get_global_id(1);
+    
+    size_t i = get_group_id(0)*get_local_size(0) + get_local_id(0);
+    size_t j = get_group_id(1)*get_local_size(1) + get_local_id(1);
+
+    size_t k, n0_id, n1_id;
+    size_t ind = i + dSubRank * j;
+    Mx[ind] = 0; 
+        for (k = 0;  k < dMRank; k++) {
+            n0_id = i + dMRank * k;
+            n1_id = j * dSubRank + k;
+            Mx[ind] += M0x[n0_id] * M1x[n1_id];
+        }
+}

tensor_t/src/kernel_2d_ProdTensor.cl

@@ -11,7 +11,7 @@ __kernel void prodTensor2dLin_TYPE_FLOAT(long unsigned int M1rank, __global cons
     Mx[k] = M0x[i] * M1x[j]; 
 }
 
-__kernel void prodTensori2dLin_TYPE_DOUBLE(long unsigned int M1rank, __global const double *M0x , __global const double *M1x, __global double *Mx ){
+__kernel void prodTensor2dLin_TYPE_DOUBLE(long unsigned int M1rank, __global const double *M0x , __global const double *M1x, __global double *Mx ){
 
     //Get the index of the current element to be processed
     size_t i = get_group_id(0)*get_local_size(0) + get_local_id(0);
@@ -51,9 +51,3 @@ __kernel void prodTensori2dLinNotEndian_TYPE_DOUBLE(long unsigned int M0rank, __
     Mx[k] = M0x[i] * M1x[j]; 
 
 }
-
-
-
-
-
-

tensor_t/src/kernel_ProdContractnTensor.cl

@@ -1,6 +1,3 @@
-
-
-
 __kernel void prodContractnTensorLin_TYPE_FLOAT(long unsigned int dSubRank, long unsigned int dMRank, __global const float *M0x , __global const float *M1x, __global float *Mx ){
 
     //Get the index of the current element to be processed 
@@ -64,7 +61,3 @@ __kernel void prodContractnTensorLinNotEndian_TYPE_DOUBLE(long unsigned int dSub
             Mx[i] += M0x[n0_id] * M1x[n1_id];
         }
 }
-
-
-
-

tensor_t/src/kernel_ProdTensor.cl

@@ -33,8 +33,3 @@ __kernel void prodTensorLinNotEndian_TYPE_DOUBLE(long unsigned int M0rank, __glo
     size_t j = k / M0rank;
     Mx[k] = M0x[i] * M1x[j]; 
 }
-
-
-
-
-

tensor_t/src/tensor_t/cl_tensor_t.c

@@ -28,14 +28,15 @@
     cl_uint ret_num_devices; \
     cl_uint ret_num_platforms; \
     cl_int ret = clGetPlatformIDs(1, &platform_id, &ret_num_platforms); \
+    checkError(ret,__func__,"Error: Failed to get platform ID ");\
     ret = clGetDeviceIDs( platform_id, CL_DEVICE_TYPE_DEFAULT, 1, \
             &device_id, &ret_num_devices); \
     size_t returned_size = 0;\
 	  size_t max_workgroup_size = 0;\
-	  ret = clGetDeviceInfo(device_id, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof(size_t), &max_workgroup_size, &returned_size);\
+	  /*ret = clGetDeviceInfo(device_id, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof(size_t), &max_workgroup_size, &returned_size);\
     checkError(ret,__func__,"Error: Failed to retrieve device info!");\
     printf(" ===========================================================++> return size: %ld\n max group sz: %ld\n", returned_size, max_workgroup_size);\
-\
+*/\
 /*int gpu = 1;\
     ret = clGetDeviceIDs( platform_id, gpu ? CL_DEVICE_TYPE_GPU : CL_DEVICE_TYPE_CPU, 1, \
             &device_id, &ret_num_devices); */\
@@ -136,6 +137,7 @@
     ret |= clReleaseCommandQueue(command_queue); \
     ret |= clReleaseContext(context); \
     checkError(ret,__func__,"Error: Failed to clean up! ");\
+    free(source_str);
 
 #define GEN_cl_FUNC_TENSOR(type)\
 \
@@ -214,6 +216,7 @@ void cl_tensorContractnProd_##type(tensor_##type** MM, tensor_##type *M0, tensor
     dSubRank = dSub0->rank;\
     \
   }\
+  printf("func_cl_name = %s ......... \n",func_cl_name);\
   SETUP_cl_KERNEL_(type,file_cl_src,func_cl_name);\
   \
     /*/ Set the arguments of the kernel  */ \
@@ -228,7 +231,7 @@ void cl_tensorContractnProd_##type(tensor_##type** MM, tensor_##type *M0, tensor
   READ_BUF_N_CLEANUP(type)\
 \
 } \
-\
+ \
 \
 void cl2d_tensorProd_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1, size_t div0Wsz, size_t div1Wsz) {  \
     dimension *dd;  \
@@ -262,6 +265,67 @@ void cl2d_tensorProd_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type
   READ_BUF_N_CLEANUP(type)\
 }  \
 \
+void cl2d_tensorContractnProd_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1, size_t contractionNumber, size_t div0Wsz, size_t div1Wsz) {\
+\
+    size_t len0 = M0->dim->size - contractionNumber;\
+    size_t len1 = M1->dim->size - contractionNumber;\
+\
+    size_t* tsub0 = malloc(sizeof(size_t) *len0);\
+    size_t* tsub1 = malloc(sizeof(size_t) *len1);\
+    size_t* tDk1 = malloc(sizeof(size_t) *contractionNumber);\
+    size_t* tDk0 = malloc(sizeof(size_t) *contractionNumber);\
+    subArray(tsub0, M0->dim->perm, 0, len0, 0);\
+    subArray(tsub1, M1->dim->perm, 0, len1, contractionNumber);\
+    subArray(tDk1, M1->dim->perm, 0, contractionNumber, 0);\
+    subArray(tDk0, M0->dim->perm, 0, contractionNumber, len0);\
+    dimension *dSub0 = init_dim(tsub0, len0);\
+    dimension *dSub1 = init_dim(tsub1, len1);\
+    dimension *dM1 = init_dim(tDk1, contractionNumber);\
+    dimension *dM0 = init_dim(tDk0, contractionNumber);\
+    dimension *dM;\
+    min_dimension(&dM, dM0, dM1);\
+    \
+    dimension *dd;\
+    add_dimension(&dd, dSub0, dSub1);\
+    updateRankDim(dd);\
+    *MM = CREATE_TENSOR_##type(dd);\
+    tensor_##type *M= *MM;\
+    char *file_cl_src = "../src/kernel_2d_ProdContractnTensor.cl"; \
+    char *func_cl_nameEndian = "prodContractnTensor2dLin_" #type; \
+    char *func_cl_nameNotEndian = "prodContractnTensor2dLinNotEndian_" #type; \
+    char *func_cl_name; \
+    size_t dSubRank;\
+  if(endian){\
+    func_cl_name = func_cl_nameEndian;\
+    dSubRank = dSub1->rank;\
+    \
+  }else{\
+    func_cl_name = func_cl_nameNotEndian;\
+    dSubRank = dSub0->rank;\
+    \
+  }\
+  SETUP_cl_KERNEL_(type,file_cl_src,func_cl_name);\
+  /*size_t cl_dev_max_w_sz,sz_val;\
+  ret = clGetDeviceInfo(device_id, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof(size_t), &cl_dev_max_w_sz, &sz_val);\
+  printf("CL_DEVICE_MAX_WORK_GROUP_SIZE = :  %ld, sz :%ld\n ",cl_dev_max_w_sz, sz_val);\
+  */\
+    /*/ Set the arguments of the kernel  */ \
+    ret |= clSetKernelArg(kernel, 0, sizeof(size_t), (void *)&dSubRank); \
+    ret |= clSetKernelArg(kernel, 1, sizeof(size_t), (void *)&(dM->rank)); \
+    ret |= clSetKernelArg(kernel, 2, sizeof(cl_mem), (void *)&M0_mem_obj); \
+    ret |= clSetKernelArg(kernel, 3, sizeof(cl_mem), (void *)&M1_mem_obj); \
+    ret |= clSetKernelArg(kernel, 4, sizeof(cl_mem), (void *)&M_mem_obj); \
+    checkError(ret,__func__,"Error: Failed to set kernel arguments! ");\
+ \
+  /*printf("EXEC_cl_2d_KERNEL(type,%ld,%ld,%ld,%ld)\n",dSub0->rank,dSub1->rank,div0Wsz,div1Wsz);\
+  */EXEC_cl_2d_KERNEL(type,dSub0->rank,dSub1->rank,div0Wsz,div1Wsz);\
+  READ_BUF_N_CLEANUP(type)\
+\
+} \
+\
+
+
+
 
 void checkError(cl_int error, const char *func_name, char *msg) {
     if (error != CL_SUCCESS) {

tensor_t/src/tensor_t/cl_tensor_t.h

@@ -19,7 +19,7 @@
 void cl_tensorProd_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1); \
 void cl_tensorContractnProd_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1, size_t contractionNumber); \
 void cl2d_tensorProd_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1, size_t div0Wsz, size_t div1Wsz); \
-/*void cl2d_tensorContractnProd_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1, size_t contractionNumber, size_t div0Wsz, size_t div1Wsz);*/ \
+void cl2d_tensorContractnProd_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1, size_t contractionNumber, size_t div0Wsz, size_t div1Wsz); \
 
 CL_GENERATE_TENSOR_TYPE(TYPE_FLOAT);
 CL_GENERATE_TENSOR_TYPE(TYPE_DOUBLE);

tensor_t/src/tensor_t/tensor_t.c

@@ -23,6 +23,27 @@ void printArraySzt(size_t *a, size_t sz,char *msg){
   printf("\n");
 }
 
+
+#define FREE_COORD_\
+  free(coord0);\
+  free(coord1);\
+  free(coord);\
+
+#define FREE_t \
+    free( tsub0 );\
+    free( tsub1 );\
+    free( tDk1 );\
+    free( tDk0 );
+
+#define FREE_dM_S_\
+  free_dimension(dM0);\
+  free_dimension(dM1);\
+  free_dimension(dM);\
+  free_dimension(dSub0);\
+  free_dimension(dSub1);\
+
+
+
 #define GEN_FUNC_TENSOR(type)\
   tensor_##type* CREATE_TENSOR_##type(dimension *dim){\
     tensor_##type *r_tens=malloc(sizeof(tensor_##type));\
@@ -32,24 +53,37 @@ void printArraySzt(size_t *a, size_t sz,char *msg){
     return r_tens;\
   }\
 \
-  tensor_##type * sub_minus_tensor_head_##type(tensor_##type *rootens, size_t minuSubdim, size_t rankInDim){\
+  tensor_##type* CREATE_TENSOR_FROM_CPY_DIM_##type(dimension *dim){\
+    tensor_##type *r_tens=malloc(sizeof(tensor_##type));\
+    r_tens->dim = init_copy_dim(dim->perm,dim->size);\
+    r_tens->x = malloc(sizeof(type)*dim->rank);\
+    return r_tens;\
+  }\
+\
+  void free_tensor_##type(tensor_##type *  tens){\
+    if(tens){\
+      free_dimension(tens->dim);\
+      free(tens->x);\
+      free(tens);\
+    }\
+  }\
+/*  tensor_##type * sub_minus_tensor_head_##type(tensor_##type *rootens, size_t minuSubdim, size_t rankInDim){\
     dimension *rdim= rootens->dim;\
     dimension *dS_t = sub_minus_dim_tail(rdim,rdim->size - minuSubdim);\
     if(rankInDim < dS_t->rank){\
       dimension *dS_h = sub_minus_dim_head(rdim,minuSubdim);\
       tensor_##type *ret_ens = malloc(sizeof(tensor_##type));\
       ret_ens->dim = dS_h;\
-      /*ret_ens->x = (rootens->x)+rankInDim*dS_t->rank;*/\
+      ret_ens->x = malloc(sizeof(type)*dS_h->rank);\
       if(endian){\
-        ret_ens->x = malloc(sizeof(type)*dS_h->rank);\
         for(size_t i=0; i<dS_h->rank; ++i){\
-          ret_ens->x[i]=rootens->x[i*dS_t->rank + rankInDim];\
+            ret_ens->x[i]=rootens->x[i*dS_t->rank + rankInDim];\
-          /*printf("%ld: [i:%ld] | %ld : [%ld ]\n",dS_t->rank, i,dS_h->rank,i*dS_h->rank + rankInDim);*/\
           \
         }\
       }else{\
-        ret_ens->x = (rootens->x)+rankInDim*dS_h->rank;\
+        for(size_t i=0; i<dS_h->rank; ++i){\
-      \
+          ret_ens->x[i]=rootens->x[i + dS_h->rank * rankInDim];\
+        }\
       }\
       return ret_ens;\
     }\
@@ -63,15 +97,15 @@ void printArraySzt(size_t *a, size_t sz,char *msg){
       dimension *dS_t = sub_minus_dim_tail(rdim,minuSubdim);\
       tensor_##type *ret_ens = malloc(sizeof(tensor_##type));\
       ret_ens->dim = dS_t;\
-      if(endian==false){\
         ret_ens->x = malloc(sizeof(type)*dS_t->rank);\
+      if(endian==false){\
         for(size_t i=0; i<dS_t->rank; ++i){\
           ret_ens->x[i]=rootens->x[i*dS_h->rank + rankInDim];\
-          /*printf("%ld: [i:%ld] | %ld : [%ld ]\n",dS_t->rank, i,dS_h->rank,i*dS_h->rank + rankInDim);*/\
-          \
         }\
       }else{\
-        ret_ens->x = (rootens->x)+rankInDim*dS_t->rank;\
+        for(size_t i=0; i<dS_t->rank; ++i){\
+          ret_ens->x[i]=rootens->x[i + dS_t->rank * rankInDim];\
+        }\
       \
       }\
       return ret_ens;\
@@ -80,23 +114,21 @@ void printArraySzt(size_t *a, size_t sz,char *msg){
   }\
   \
   tensor_##type * sub_tensor_head_##type(tensor_##type *rootens, size_t subdim, size_t rankInDim){\
-    /*return sub_minus_tensor_head_##type(rootens,rootens->dim->size - subdim, rankInDim);*/\
     dimension *rdim= rootens->dim;\
     dimension *dS_t = sub_dim_tail(rdim,rdim->size - subdim);\
     if(rankInDim < dS_t->rank){\
       dimension *dS_h = sub_dim_head(rdim,subdim);\
       tensor_##type *ret_ens = malloc(sizeof(tensor_##type));\
       ret_ens->dim = dS_h;\
-      /*ret_ens->x = (rootens->x)+rankInDim*dS_t->rank;*/\
-      if(endian){\
         ret_ens->x = malloc(sizeof(type)*dS_h->rank);\
+      if(endian){\
         for(size_t i=0; i<dS_h->rank; ++i){\
           ret_ens->x[i]=rootens->x[i*dS_t->rank + rankInDim];\
-          /*printf("%ld: [i:%ld] | %ld : [%ld ]\n",dS_t->rank, i,dS_h->rank,i*dS_h->rank + rankInDim);*/\
-          \
         }\
       }else{\
-        ret_ens->x = (rootens->x)+rankInDim*dS_h->rank;\
+        for(size_t i=0; i<dS_h->rank; ++i){\
+          ret_ens->x[i]=rootens->x[i + dS_h->rank * rankInDim];\
+        }\
       \
       }\
       return ret_ens;\
@@ -104,28 +136,142 @@ void printArraySzt(size_t *a, size_t sz,char *msg){
     return NULL;\
   }\
   tensor_##type * sub_tensor_tail_##type(tensor_##type *rootens, size_t subdim, size_t rankInDim){ \
-    /*return sub_minus_tensor_tail_##type(rootens,rootens->dim->size - subdim, rankInDim);*/\
     dimension *rdim= rootens->dim;\
     dimension *dS_h = sub_dim_head(rdim,rdim->size - subdim);\
     if(rankInDim < dS_h->rank){\
       dimension *dS_t = sub_dim_tail(rdim,subdim);\
       tensor_##type *ret_ens = malloc(sizeof(tensor_##type));\
       ret_ens->dim = dS_t;\
-      if(endian==false){\
         ret_ens->x = malloc(sizeof(type)*dS_t->rank);\
+      if(endian==false){\
         for(size_t i=0; i<dS_t->rank; ++i){\
           ret_ens->x[i]=rootens->x[i*dS_h->rank + rankInDim];\
-          /*printf("%ld: [i:%ld] | %ld : [%ld ]\n",dS_t->rank, i,dS_h->rank,i*dS_h->rank + rankInDim);*/\
-          \
         }\
       }else{\
-        ret_ens->x = (rootens->x)+rankInDim*dS_t->rank;\
+        for(size_t i=0; i<dS_t->rank; ++i){\
+          ret_ens->x[i]=rootens->x[i + dS_t->rank * rankInDim];\
+        }\
       \
       }\
       return ret_ens;\
     }\
     return NULL;\
   }\
+*/  \
+  tensor_##type * sub_copy_minus_tensor_head_##type(tensor_##type *rootens, size_t minuSubdim, size_t rankInDim){\
+    dimension *rdim= rootens->dim;\
+    dimension *dS_t = sub_copy_minus_dim_tail(rdim,rdim->size - minuSubdim);\
+    if(rankInDim < dS_t->rank){\
+      dimension *dS_h = sub_copy_minus_dim_head(rdim,minuSubdim);\
+      tensor_##type *ret_ens = CREATE_TENSOR_##type(dS_h);\
+      /*malloc(sizeof(tensor_##type));\
+      ret_ens->dim = dS_h;\
+      ret_ens->x = malloc(sizeof(type)*dS_h->rank);*/\
+      if(endian){\
+        /*ret_ens->x = malloc(sizeof(type)*dS_h->rank);\
+        */for(size_t i=0; i<dS_h->rank; ++i){\
+            ret_ens->x[i]=rootens->x[i*dS_t->rank + rankInDim];\
+          /*printf("%ld: [i:%ld] | %ld : [%ld ]\n",dS_t->rank, i,dS_h->rank,i*dS_h->rank + rankInDim);*/\
+          \
+        }\
+      }else{\
+        /*ret_ens->x = (rootens->x)+rankInDim*dS_h->rank;*/\
+        for(size_t i=0; i<dS_h->rank; ++i){\
+          ret_ens->x[i]=rootens->x[i + dS_h->rank * rankInDim];\
+        }\
+      }\
+      free_dimension(dS_t);\
+      return ret_ens;\
+    }\
+    free_dimension(dS_t);\
+    return NULL;\
+  }\
+  \
+  tensor_##type * sub_copy_minus_tensor_tail_##type(tensor_##type *rootens, size_t minuSubdim, size_t rankInDim){\
+    dimension *rdim= rootens->dim;\
+    dimension *dS_h = sub_copy_minus_dim_head(rdim,rdim->size - minuSubdim);\
+    if(rankInDim < dS_h->rank){\
+      dimension *dS_t = sub_copy_minus_dim_tail(rdim,minuSubdim);\
+      tensor_##type *ret_ens = CREATE_TENSOR_##type(dS_t);\
+      /*tensor_##type *ret_ens = malloc(sizeof(tensor_##type));\
+      ret_ens->dim = dS_t;\
+      ret_ens->x = malloc(sizeof(type)*dS_t->rank);\
+      */if(endian==false){\
+        for(size_t i=0; i<dS_t->rank; ++i){\
+          ret_ens->x[i]=rootens->x[i*dS_h->rank + rankInDim];\
+        }\
+      }else{\
+        /*ret_ens->x = (rootens->x)+rankInDim*dS_t->rank;*/\
+        for(size_t i=0; i<dS_t->rank; ++i){\
+          ret_ens->x[i]=rootens->x[i + dS_t->rank * rankInDim];\
+        }\
+      \
+      }\
+      free_dimension(dS_h);\
+      return ret_ens;\
+    }\
+    free_dimension(dS_h);\
+    return NULL;\
+  }\
+  \
+  tensor_##type * sub_copy_tensor_head_##type(tensor_##type *rootens, size_t sub_copydim, size_t rankInDim){\
+    /*return sub_copy_minus_tensor_head_##type(rootens,rootens->dim->size - sub_copydim, rankInDim);*/\
+    dimension *rdim= rootens->dim;\
+    dimension *dS_t = sub_copy_dim_tail(rdim,rdim->size - sub_copydim);\
+    if(rankInDim < dS_t->rank){\
+      dimension *dS_h = sub_copy_dim_head(rdim,sub_copydim);\
+      tensor_##type *ret_ens = CREATE_TENSOR_##type(dS_h);\
+      /*tensor_##type *ret_ens = malloc(sizeof(tensor_##type));\
+      ret_ens->dim = dS_h;\
+      ret_ens->x = malloc(sizeof(type)*dS_h->rank);\
+      */if(endian){\
+        for(size_t i=0; i<dS_h->rank; ++i){\
+          ret_ens->x[i]=rootens->x[i*dS_t->rank + rankInDim];\
+          /*printf("%ld: [i:%ld] | %ld : [%ld ]\n",dS_t->rank, i,dS_h->rank,i*dS_h->rank + rankInDim);*/\
+        }\
+      }else{\
+        /*ret_ens->x = (rootens->x)+rankInDim*dS_h->rank;*/\
+        for(size_t i=0; i<dS_h->rank; ++i){\
+          ret_ens->x[i]=rootens->x[i + dS_h->rank * rankInDim];\
+          /*printf("%ld: [i:%ld] | %ld : [%ld ]\n",dS_t->rank, i,dS_h->rank,i*dS_h->rank + rankInDim);*/\
+        }\
+      \
+      }\
+      free_dimension(dS_t);\
+      return ret_ens;\
+    }\
+    free_dimension(dS_t);\
+    return NULL;\
+  }\
+  tensor_##type * sub_copy_tensor_tail_##type(tensor_##type *rootens, size_t sub_copydim, size_t rankInDim){ \
+    /*return sub_copy_minus_tensor_tail_##type(rootens,rootens->dim->size - sub_copydim, rankInDim);*/\
+    dimension *rdim= rootens->dim;\
+    dimension *dS_h = sub_copy_dim_head(rdim,rdim->size - sub_copydim);\
+    if(rankInDim < dS_h->rank){\
+      dimension *dS_t = sub_copy_dim_tail(rdim,sub_copydim);\
+      tensor_##type *ret_ens = CREATE_TENSOR_##type(dS_t);\
+      /*tensor_##type *ret_ens = malloc(sizeof(tensor_##type));\
+      ret_ens->dim = dS_t;\
+      ret_ens->x = malloc(sizeof(type)*dS_t->rank);\
+      */if(endian==false){\
+        for(size_t i=0; i<dS_t->rank; ++i){\
+          ret_ens->x[i]=rootens->x[i*dS_h->rank + rankInDim];\
+          /*printf("%ld: [i:%ld] | %ld : [%ld ]\n",dS_t->rank, i,dS_h->rank,i*dS_h->rank + rankInDim);*/\
+        }\
+      }else{\
+        /*ret_ens->x = (rootens->x)+rankInDim*dS_t->rank;*/\
+        for(size_t i=0; i<dS_t->rank; ++i){\
+          ret_ens->x[i]=rootens->x[i + dS_t->rank * rankInDim];\
+          /*printf("%ld: [i:%ld] | %ld : [%ld ]\n",dS_t->rank, i,dS_h->rank,i*dS_h->rank + rankInDim);*/\
+        }\
+      \
+      }\
+      free_dimension(dS_h);\
+      return ret_ens;\
+    }\
+    free_dimension(dS_h);\
+    return NULL;\
+  }\
   \
 void tensorProdNotOpt_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1) {  \
   dimension *dd;  \
@@ -149,6 +295,7 @@ void tensorProdNotOpt_##type(tensor_##type **MM, tensor_##type *M0, tensor_##typ
         M->x[i] = M0->x[lin0] * M1->x[lin1];  \
   /*printf(" M->x[%ld] = M0->x[%ld] * M1->x[%ld] ::: %f = %f * %f \n",i,lin0,lin1, M->x[i] , M0->x[lin0] , M1->x[lin1]);*/\
     }  \
+    FREE_COORD_ ; \
 }  \
 \
 \
@@ -203,7 +350,7 @@ void tensorContractnProd_##type(tensor_##type** MM, tensor_##type *M0, tensor_##
   printDebug_dimension(dM0,"dM0");\
   printDebug_dimension(dM1,"dM1");*/\
     dimension *dM;\
-    min_dimension(&dM, dM0, dM1);\
+    min_copy_dimension(&dM, dM0, dM1);\
   /*printDebug_dimension(dM,"dM");*/\
     \
     dimension *dd;\
@@ -213,21 +360,7 @@ void tensorContractnProd_##type(tensor_##type** MM, tensor_##type *M0, tensor_##
     *MM = CREATE_TENSOR_##type(dd);\
     tensor_##type *M= *MM;\
 \
-    /*size_t* coord;\
+   \
-    coord = malloc(sizeof(size_t)* M->dim->size);\
-\
-    size_t* coord0 , lin0;\
-    coord0 = malloc(sizeof(size_t)* len0);\
-    size_t* coord1, lin1;\
-    coord1 = malloc(sizeof(size_t)* len1);\
-\
-    size_t* coordM0 ;\
-    coordM0 = malloc(sizeof(size_t)* M0->dim->size);\
-    size_t* coordM1 ;\
-    coordM1 = malloc(sizeof(size_t)* M1->dim->size);\
-\
-    size_t* Koord ;\
-    Koord = malloc(sizeof(size_t)* contractionNumber);*/\
 \
     size_t a0_id, a1_id, n0_id, n1_id;\
     for (size_t i = 0; i < M->dim->rank; i++) {\
@@ -239,11 +372,6 @@ void tensorContractnProd_##type(tensor_##type** MM, tensor_##type *M0, tensor_##
           a0_id=i%dSub0->rank;\
           a1_id=i/dSub0->rank;\
         }\
-        /*vCoordFromLin(coord, i, M->dim);\
-        subArray(coord0, coord, 0, len0, 0);\
-        subArray(coord1, coord, 0, len1, len0);\
-        printf("i:%ld=>  c0: %ld vs %ld \n",i,LineFromCoord(coord0,dSub0),a0_id);\
-        printf("i:%ld=>  c1: %ld vs %ld \n",i,LineFromCoord(coord1,dSub1),a1_id);*/\
         M->x[i] = 0;\
         for (size_t k = 0; k < dM->rank; k++) {\
           if(endian){\
@@ -255,19 +383,10 @@ void tensorContractnProd_##type(tensor_##type** MM, tensor_##type *M0, tensor_##
             n1_id= a1_id*dM->rank + k;\
           }\
             M->x[i] += M0->x[n0_id] * M1->x[n1_id];\
-            /*vCoordFromLin(Koord, k, dM);\
+            \
-            concatArray(coordM0, coord0, Koord, 0, 0, len0, 0, contractionNumber);\
-            concatArray(coordM1, Koord, coord1, 0, 0, contractionNumber, 0, len1);\
-            lin0 = LineFromCoord(coordM0, M0->dim);\
-            lin1 = LineFromCoord(coordM1, M1->dim);\
-            printf("k:%ld, lin0:%ld, vs n0: %ld\n",k,lin0,n0_id);\
-            printf("k:%ld, lin1:%ld, vs n1: %ld\n",k,lin1,n1_id);*/\
-            /*M->x[i] += M0->x[lin0] * M1->x[lin1];*/\
-          /*printf("M[%ld]:%f += M0[%ld]:%f * M1[%ld]:%f | \n",i,M->x[i],n0_id,M0->x[n0_id],n1_id,M1->x[n1_id]);*/\
-          /*printf("k:%ld |i:%ld |lin0:%ld | lin1:%ld | ",k,i,lin0,lin1);*/\
         }\
-      /*printf("\n");*/\
     }\
+    FREE_dM_S_ \
 }\
 struct arg_Prod_##type{\
   type *M0x;\
@@ -309,9 +428,10 @@ void tensorProdThread_##type(tensor_##type **MM, tensor_##type *M0, tensor_##typ
     arg_th[i]->M1x=M1->x;\
     arg_th[i]->Mx=M->x;\
     arg_th[i]->beginRange = i*(M->dim->rank)/nbthread ;\
-    if(i < nbthread - 1 ) arg_th[i]->endRange = (i+1)*(M->dim->rank)/nbthread ;\
+    arg_th[i]->endRange = (i+1)*(M->dim->rank)/nbthread ;\
+    /*if(i < nbthread - 1 ) arg_th[i]->endRange = (i+1)*(M->dim->rank)/nbthread ;\
     else arg_th[i]->endRange = M->dim->rank ;\
-    if(endian){\
+    */if(endian){\
       arg_th[i]->MRank = M1->dim->rank;\
     }\
     else{\
@@ -322,27 +442,39 @@ void tensorProdThread_##type(tensor_##type **MM, tensor_##type *M0, tensor_##typ
 \
   for(size_t i=0; i< nbthread; ++i){\
     pthread_join(thrd[i], NULL);\
+    free(arg_th[i]);\
   }\
 \
+  free(thrd);\
+  free(arg_th);\
 }  \
 \
+struct arg_Pro2d_##type{\
+  type *M0x;\
+  type *M1x;\
+  type *Mx;\
+  size_t beginRange;\
+  size_t endRange;\
+  size_t M0Rank;\
+  size_t M1Rank;\
+};\
 void* runProd_thread2d_##type(void *arg){\
-  struct arg_Prod_##type *arg_t = arg;\
+  struct arg_Pro2d_##type *arg_t = arg;\
   size_t k;\
     for (size_t i = arg_t->beginRange; i < arg_t->endRange; i++) {\
-      for (size_t j = 0; j < arg_t->MRank; j++) {\
+      for (size_t j = 0; j < arg_t->M1Rank; j++) {\
         if(endian){\
-          k = i * arg_t->MRank + j;\
+          k = i * arg_t->M1Rank + j;\
         }\
         else{\
-          k =i + arg_t->MRank * j ;\
+          k =i + arg_t->M0Rank * j ;\
         }\
-        arg_t->Mx[k] += arg_t->M0x[i] * arg_t->M1x[j];\
+        arg_t->Mx[k] = arg_t->M0x[i] * arg_t->M1x[j];\
       }\
    }\
 }\
 \
-void tensorProdThread2d_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1, size_t nbthread) {  \
+void tensorProdThrea2d_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1, size_t nbthread) {  \
     dimension *dd;  \
     add_dimension(&dd, M0->dim, M1->dim); \
     (*MM)=CREATE_TENSOR_##type(dd);  \
@@ -350,29 +482,29 @@ void tensorProdThread2d_##type(tensor_##type **MM, tensor_##type *M0, tensor_##t
     \
     \
   pthread_t *thrd = malloc(nbthread * sizeof(pthread_t));\
-  struct arg_Prod_##type **arg_th = malloc( nbthread * sizeof(struct arg_Prod_##type *));\
+  struct arg_Pro2d_##type **arg_th = malloc( nbthread * sizeof(struct arg_Pro2d_##type *));\
 \
   for(size_t i = 0; i < nbthread; ++i){\
-    arg_th[i]=malloc(sizeof(struct arg_Prod_##type));\
+    arg_th[i]=malloc(sizeof(struct arg_Pro2d_##type));\
     arg_th[i]->M0x=M0->x;\
     arg_th[i]->M1x=M1->x;\
     arg_th[i]->Mx=M->x;\
-    arg_th[i]->beginRange = i*(M->dim->rank)/nbthread ;\
+    arg_th[i]->beginRange = i*(M0->dim->rank)/nbthread ;\
-    if(i < nbthread - 1 ) arg_th[i]->endRange = (i+1)*(M->dim->rank)/nbthread ;\
+    arg_th[i]->endRange = (i+1)*(M0->dim->rank)/nbthread ;\
-    else arg_th[i]->endRange = M->dim->rank ;\
+    /*if(i < nbthread - 1 ) arg_th[i]->endRange = (i+1)*(M0->dim->rank)/nbthread ;\
-    if(endian){\
+    else arg_th[i]->endRange = M0->dim->rank ;\
-      arg_th[i]->MRank = M1->dim->rank;\
+    */arg_th[i]->M1Rank = M1->dim->rank;\
-    }\
+      arg_th[i]->M0Rank = M0->dim->rank;\
-    else{\
+    pthread_create(&thrd[i], NULL, runProd_thread2d_##type, (void*)arg_th[i]);\
-      arg_th[i]->MRank = M0->dim->rank;\
-    }\
-    pthread_create(&thrd[i], NULL, runProd_thread_##type, (void*)arg_th[i]);\
   }\
 \
   for(size_t i=0; i< nbthread; ++i){\
     pthread_join(thrd[i], NULL);\
+    free(arg_th[i]);\
   }\
 \
+  free(thrd);\
+  free(arg_th);\
 }  \
 struct arg_ProdContract_##type{\
   type *M0x;\
@@ -431,7 +563,7 @@ void tensorContractnProdThread_##type(tensor_##type** MM, tensor_##type *M0, ten
     dimension *dM1 = init_dim(tDk1, contractionNumber);\
     dimension *dM0 = init_dim(tDk0, contractionNumber);\
     dimension *dM;\
-    min_dimension(&dM, dM0, dM1);\
+    min_copy_dimension(&dM, dM0, dM1);\
     \
     dimension *dd;\
     add_dimension(&dd, dSub0, dSub1);\
@@ -464,8 +596,12 @@ void tensorContractnProdThread_##type(tensor_##type** MM, tensor_##type *M0, ten
 \
   for(size_t i=0; i< nbthread; ++i){\
     pthread_join(thrd[i], NULL);\
+    free(arg_th[i]);\
   }\
 \
+  free(thrd);\
+  free(arg_th);\
+  FREE_dM_S_ ; \
 }\
 void tensorContractnProdNotOpt_##type(tensor_##type** MM, tensor_##type *M0, tensor_##type *M1, size_t contractionNumber) {\
    /* if (!checkMatchProdtensor(M0->dim, M1->dim, contractionNumber)) {\
@@ -496,7 +632,7 @@ void tensorContractnProdNotOpt_##type(tensor_##type** MM, tensor_##type *M0, ten
   printDebug_dimension(dM0,"dM0");\
   printDebug_dimension(dM1,"dM1");*/\
     dimension *dM;\
-    min_dimension(&dM, dM0, dM1);\
+    min_copy_dimension(&dM, dM0, dM1);\
   /*printDebug_dimension(dM,"dM");*/\
     \
     dimension *dd;\
@@ -539,6 +675,11 @@ void tensorContractnProdNotOpt_##type(tensor_##type** MM, tensor_##type *M0, ten
         }\
       /*printf("\n");*/\
     }\
+    FREE_COORD_ ; \
+    free(coordM0);\
+    free(coordM1);\
+    free(Koord); \
+    FREE_dM_S_ ; \
 }\
 \
 

tensor_t/src/tensor_t/tensor_t.h

@@ -14,15 +14,20 @@ struct tensor_##type{\
 };\
 typedef struct tensor_##type tensor_##type;\
 tensor_##type * CREATE_TENSOR_##type(dimension *dim); \
-tensor_##type * sub_minus_tensor_head_##type(tensor_##type *rootens, size_t minuSubdim, size_t rankInDim); \
+void free_tensor_##type(tensor_##type *  tens); \
+/*tensor_##type * sub_minus_tensor_head_##type(tensor_##type *rootens, size_t minuSubdim, size_t rankInDim); \
 tensor_##type * sub_minus_tensor_tail_##type(tensor_##type *rootens, size_t minuSubdim, size_t rankInDim); \
 tensor_##type * sub_tensor_head_##type(tensor_##type *rootens, size_t subdim, size_t rankInDim); \
 tensor_##type * sub_tensor_tail_##type(tensor_##type *rootens, size_t subdim, size_t rankInDim); \
+*/tensor_##type * sub_copy_minus_tensor_head_##type(tensor_##type *rootens, size_t minuSubdim, size_t rankInDim); \
+tensor_##type * sub_copy_minus_tensor_tail_##type(tensor_##type *rootens, size_t minuSubdim, size_t rankInDim); \
+tensor_##type * sub_copy_tensor_head_##type(tensor_##type *rootens, size_t sub_copydim, size_t rankInDim); \
+tensor_##type * sub_copy_tensor_tail_##type(tensor_##type *rootens, size_t sub_copydim, size_t rankInDim); \
 void tensorProdNotOpt_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1); \
 void tensorProd_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1); \
 void tensorContractnProd_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1, size_t contractionNumber); \
 void tensorProdThread_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1,size_t nbthread); \
-void tensorProdThread2d_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1,size_t nbthread); \
+void tensorProdThrea2d_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1,size_t nbthread); \
 void tensorContractnProdThread_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1, size_t contractionNumber, size_t nbthread); \
 void tensorContractnProdNotOpt_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1, size_t contractionNumber); \
 

tensor_t/test/Makefile

@@ -11,7 +11,7 @@ YPERMDIR=$(PWD)/../../ypermutation_t
 TENSDIR=$(PWD)/..
 DIMDIR=$(PWD)/../../dimension_t
 INCLUDE_DIR=$(PWD)/../src
-CFLAGS=-I$(INCLUDE_DIR) -I$(YPERMDIR)/src -I$(YTESTDIR)/include_ytest/include -I$(DIMDIR)/src -I$(TENSDIR)/src
+CFLAGS=-I$(INCLUDE_DIR) -I$(YPERMDIR)/src -I$(YTESTDIR)/include_ytest/include -I$(DIMDIR)/src -I$(TENSDIR)/src #"-D DEBUG=1"
 LDFLAGS=-L$(YTESTDIR) -lytest -lOpenCL
 
 #SRC_DIR=$(ROOT_DIR)/src

tensor_t/test/is_good.c

@@ -17,6 +17,8 @@
 //#include "permutation_t/permutation_t.h"
 #include "tensor_t/tensor_t.h"
 
+#define VALGRING_ 1
+
 TEST(rank){
   dimension *D=create_dim(4);
   D->perm[0]=2;
@@ -28,6 +30,7 @@ TEST(rank){
   tensor_TYPE_FLOAT *tf = CREATE_TENSOR_TYPE_FLOAT(D);
   EXPECT_EQ(tf->dim->rank, 180);
 
+  free_tensor_TYPE_FLOAT(tf);
 }
 
 void print_tensor_float(tensor_TYPE_FLOAT *M, char *msg){
@@ -36,18 +39,23 @@ void print_tensor_float(tensor_TYPE_FLOAT *M, char *msg){
     return;
   }
   LOG("================= %s ===============\n",msg);
+
+#if VALGRING_
   for(size_t i=0; i<M->dim->rank;++i)
       LOG("[%ld]: %f ",i,M->x[i]);
   
+#endif
     LOG("%s","\n");
 }
 
 
 void print_tensor_double(tensor_TYPE_DOUBLE *M, char *msg){
   LOG("================= %s ===============\n",msg);
+#if VALGRING_
   for(size_t i=0; i<M->dim->rank;++i)
       LOG("[%ld]: %lf ",i,M->x[i]);
   
+#endif
     LOG("%s","\n");
 }
 
@@ -67,9 +75,9 @@ TEST(tensorMinusSubhead_ ){
   LOG("M0->dim->rank = %ld\n",M0->dim->rank);
   for(size_t i=0; i<M0->dim->rank;++i) M0->x[i]=i*0.1 +1;
 
-  endian=false;
+  //endian=false;
   size_t rnkId = 1;
-  tensor_TYPE_FLOAT *s2h = sub_minus_tensor_head_TYPE_FLOAT(M0,1,rnkId);
+  tensor_TYPE_FLOAT *s2h = sub_copy_minus_tensor_head_TYPE_FLOAT(M0,1,rnkId);
 
   print_tensor_float(M0, "M0 for sub");
   print_tensor_float(s2h, "sub s2h of M0");
@@ -84,6 +92,9 @@ TEST(tensorMinusSubhead_ ){
       EXPECT_EQ_TYPE_FLOAT(M0->x[LineFromCoord((size_t[]){i0,i1,rnkId},M0->dim)],s2h->x[LineFromCoord((size_t[]){i0,i1},s2h->dim)]);
     }  
   }
+
+  free_tensor_TYPE_FLOAT(M0);
+  free_tensor_TYPE_FLOAT(s2h);
 }
 
 TEST(tensorMinusSubtail ){
@@ -102,12 +113,13 @@ TEST(tensorMinusSubtail ){
   LOG("M0->dim->rank = %ld\n",M0->dim->rank);
   for(size_t i=0; i<M0->dim->rank;++i) M0->x[i]=i*0.1 +1;
 
-
+  tensor_TYPE_FLOAT *s1t = sub_copy_minus_tensor_tail_TYPE_FLOAT(M0,1,5);
-  tensor_TYPE_FLOAT *s1t = sub_minus_tensor_tail_TYPE_FLOAT(M0,1,5);
 
   print_tensor_float(M0, "M0 for sub");
   print_tensor_float(s1t, "sub s2t of M0 from 5");
 
+  free_tensor_TYPE_FLOAT(M0);
+  free_tensor_TYPE_FLOAT(s1t);
 }
 
 
@@ -129,7 +141,7 @@ TEST(tensorMinusSubtail ){
 
   //endian=false;
   size_t rnkId=3;
-  tensor_TYPE_FLOAT *s2t = sub_minus_tensor_tail_TYPE_FLOAT(M0,1,rnkId);
+  tensor_TYPE_FLOAT *s2t = sub_copy_minus_tensor_tail_TYPE_FLOAT(M0,1,rnkId);
 
 
 
@@ -143,6 +155,8 @@ TEST(tensorMinusSubtail ){
     }  
   }
 
+  free_tensor_TYPE_FLOAT(M0);
+  free_tensor_TYPE_FLOAT(s2t);
 }
 
 TEST(tensorSubhead_ ){
@@ -161,9 +175,9 @@ TEST(tensorSubhead_ ){
   LOG("M0->dim->rank = %ld\n",M0->dim->rank);
   for(size_t i=0; i<M0->dim->rank;++i) M0->x[i]=i*0.1 +1;
 
-  endian=false;
+  //endian=false;
   size_t rnkId = 1;
-  tensor_TYPE_FLOAT *s2h = sub_tensor_head_TYPE_FLOAT(M0,2,rnkId);
+  tensor_TYPE_FLOAT *s2h = sub_copy_tensor_head_TYPE_FLOAT(M0,2,rnkId);
 
   print_tensor_float(M0, "M0 for sub");
   print_tensor_float(s2h, "sub s2h of M0");
@@ -178,6 +192,8 @@ TEST(tensorSubhead_ ){
       EXPECT_EQ_TYPE_FLOAT(M0->x[LineFromCoord((size_t[]){i0,i1,rnkId},M0->dim)],s2h->x[LineFromCoord((size_t[]){i0,i1},s2h->dim)]);
     }  
   }
+  free_tensor_TYPE_FLOAT(M0);
+  free_tensor_TYPE_FLOAT(s2h);
 }
 TEST(tensorSubtail ){
   dimension *d0=create_dim(3);
@@ -196,10 +212,13 @@ TEST(tensorSubtail ){
   for(size_t i=0; i<M0->dim->rank;++i) M0->x[i]=i*0.1 +1;
 
 
-  tensor_TYPE_FLOAT *s1t = sub_tensor_tail_TYPE_FLOAT(M0,2,5);
+  tensor_TYPE_FLOAT *s1t = sub_copy_tensor_tail_TYPE_FLOAT(M0,2,5);
 
   print_tensor_float(M0, "M0 for sub");
   print_tensor_float(s1t, "sub s2t of M0 from 5");
+  
+  free_tensor_TYPE_FLOAT(M0);
+  free_tensor_TYPE_FLOAT(s1t);
 
 }
 
@@ -222,7 +241,7 @@ TEST(tensorSubtail ){
 
   //endian=false;
   size_t rnkId=3;
-  tensor_TYPE_FLOAT *s2t = sub_tensor_tail_TYPE_FLOAT(M0,2,rnkId);
+  tensor_TYPE_FLOAT *s2t = sub_copy_tensor_tail_TYPE_FLOAT(M0,2,rnkId);
 
 
 
@@ -236,23 +255,32 @@ TEST(tensorSubtail ){
     }  
   }
 
+  free_tensor_TYPE_FLOAT(M0);
+  free_tensor_TYPE_FLOAT(s2t);
 }
 
 TEST(tensorProd ){
   dimension *d0=create_dim(3);
   dimension *d1=create_dim(2);
+#if VALGRING_
+  d0->perm[0]=5;
+  d0->perm[1]=2; //3;
+  d0->perm[2]=3;
 
-  d0->perm[0]=2;
-  d0->perm[1]=3;
-  d0->perm[2]=2;
-  
   d1->perm[0]=2;
-  d1->perm[1]=3;
+  d1->perm[1]=3;//3;
 
-  updateRankDim(d0);
+#else
-  updateRankDim(d1);
 
 
+  d0->perm[0]=35;
+  d0->perm[1]=32; //3;
+  d0->perm[2]=23;
+
+  d1->perm[0]=32;
+  d1->perm[1]=23;//3;
+#endif
+
   tensor_TYPE_FLOAT *M0 = CREATE_TENSOR_TYPE_FLOAT(d0);
   tensor_TYPE_FLOAT *M1 = CREATE_TENSOR_TYPE_FLOAT(d1);
 
@@ -277,18 +305,37 @@ TEST(tensorProd ){
   EXPECT_ARRAY_EQ_TYPE_FLOAT(M->x,M->dim->rank,Mn->x,Mn->dim->rank);
 
   print_tensor_float(Mn,"Mn");
+  
+  free_tensor_TYPE_FLOAT(M0);
+  free_tensor_TYPE_FLOAT(M1);
+  free_tensor_TYPE_FLOAT(M);
+  free_tensor_TYPE_FLOAT(Mn);
 }
 
 TEST(tensorContractnProd_TYPE_FLOAT ){
   dimension *d0=create_dim(3);
-  dimension *d1=create_dim(2);
+  dimension *d1=create_dim(3);
-
+#if VALGRING_
-  d0->perm[0]=2;
+  d0->perm[0]=5;
-  d0->perm[1]=3;
+  d0->perm[1]=2; //3;
-  d0->perm[2]=2;
+  d0->perm[2]=3;
 
   d1->perm[0]=2;
-  d1->perm[1]=3;
+  d1->perm[1]=3;//3;
+  d1->perm[2]=8;
+
+#else
+
+
+  d0->perm[0]=35;
+  d0->perm[1]=32; //3;
+  d0->perm[2]=23;
+
+  d1->perm[0]=32;
+  d1->perm[1]=23;//3;
+  d1->perm[2]=44;
+#endif
+
 
   updateRankDim(d0);
   updateRankDim(d1);
@@ -308,8 +355,8 @@ TEST(tensorContractnProd_TYPE_FLOAT ){
   tensor_TYPE_FLOAT *M;
   tensor_TYPE_FLOAT *MnO;
 
-  tensorContractnProd_TYPE_FLOAT(&M, M0,M1,1);
+  tensorContractnProd_TYPE_FLOAT(&M, M0,M1,2);
-  tensorContractnProdNotOpt_TYPE_FLOAT(&MnO, M0,M1,1);
+  tensorContractnProdNotOpt_TYPE_FLOAT(&MnO, M0,M1,2);
 
 
   print_tensor_float(M,"M");
@@ -320,12 +367,27 @@ TEST(tensorContractnProd_TYPE_FLOAT ){
     
   EXPECT_ARRAY_EQ_TYPE_FLOAT(M->x,M->dim->rank,MnO->x,MnO->dim->rank);
 
+  free_tensor_TYPE_FLOAT(M);
+  free_tensor_TYPE_FLOAT(MnO);
+  free_tensor_TYPE_FLOAT(M0);
+  free_tensor_TYPE_FLOAT(M1);
 
 }
 
 TEST(tensorContractnProd_TYPE_FLOAT2 ){
   dimension *d0=create_dim(3);
   dimension *d1=create_dim(3);
+#if VALGRING_
+  d0->perm[0]=5;
+  d0->perm[1]=2; //3;
+  d0->perm[2]=3;
+
+  d1->perm[0]=2;
+  d1->perm[1]=3;//3;
+  d1->perm[2]=8;
+
+#else
+
 
   d0->perm[0]=35;
   d0->perm[1]=32; //3;
@@ -334,6 +396,7 @@ TEST(tensorContractnProd_TYPE_FLOAT2 ){
   d1->perm[0]=32;
   d1->perm[1]=23;//3;
   d1->perm[2]=44;
+#endif
 
   updateRankDim(d0);
   updateRankDim(d1);
@@ -365,12 +428,26 @@ TEST(tensorContractnProd_TYPE_FLOAT2 ){
     
   //EXPECT_ARRAY_EQ_TYPE_FLOAT(M->x,M->dim->rank,MnO->x,MnO->dim->rank);
 
+  free_tensor_TYPE_FLOAT(M);
+  free_tensor_TYPE_FLOAT(MnO);
+  free_tensor_TYPE_FLOAT(M0);
+  free_tensor_TYPE_FLOAT(M1);
 
 }
 
 TEST(tensorContractnProd_TYPE_DOUBLE2 ){
   dimension *d0=create_dim(3);
   dimension *d1=create_dim(3);
+#if VALGRING_
+  d0->perm[0]=5;
+  d0->perm[1]=2; //3;
+  d0->perm[2]=3;
+
+  d1->perm[0]=2;
+  d1->perm[1]=3;//3;
+  d1->perm[2]=8;
+
+#else
 
   d0->perm[0]=125;
   d0->perm[1]=52; //3;
@@ -379,6 +456,7 @@ TEST(tensorContractnProd_TYPE_DOUBLE2 ){
   d1->perm[0]=52;
   d1->perm[1]=63;//3;
   d1->perm[2]=54;
+#endif
 
   updateRankDim(d0);
   updateRankDim(d1);
@@ -410,6 +488,10 @@ TEST(tensorContractnProd_TYPE_DOUBLE2 ){
     
   EXPECT_ARRAY_EQ_TYPE_DOUBLE(M->x,M->dim->rank,MnO->x,MnO->dim->rank);
 
+  free_tensor_TYPE_DOUBLE(M);
+  free_tensor_TYPE_DOUBLE(MnO);
+  free_tensor_TYPE_DOUBLE(M0);
+  free_tensor_TYPE_DOUBLE(M1);
 
 }
 
@@ -417,6 +499,16 @@ TEST(tensorContractnProd_TYPE_DOUBLE2 ){
 TEST(VStensorContractnProd_TYPE_DOUBLE2 ){
   dimension *d0=create_dim(3);
   dimension *d1=create_dim(3);
+#if VALGRING_
+  d0->perm[0]=5;
+  d0->perm[1]=2; //3;
+  d0->perm[2]=3;
+
+  d1->perm[0]=2;
+  d1->perm[1]=3;//3;
+  d1->perm[2]=8;
+
+#else
 
   d0->perm[0]=125;
   d0->perm[1]=52; //3;
@@ -425,6 +517,7 @@ TEST(VStensorContractnProd_TYPE_DOUBLE2 ){
   d1->perm[0]=52;
   d1->perm[1]=63;//3;
   d1->perm[2]=154;
+#endif
 
   updateRankDim(d0);
   updateRankDim(d1);
@@ -456,12 +549,26 @@ TEST(VStensorContractnProd_TYPE_DOUBLE2 ){
     
   EXPECT_ARRAY_EQ_TYPE_DOUBLE(M->x,M->dim->rank,MnO->x,MnO->dim->rank);
 
+  free_tensor_TYPE_DOUBLE(M);
+  free_tensor_TYPE_DOUBLE(MnO);
+  free_tensor_TYPE_DOUBLE(M0);
+  free_tensor_TYPE_DOUBLE(M1);
 
 }
 
 TEST(Pthread_tensorContractnProd_TYPE_DOUBLE2 ){
   dimension *d0=create_dim(3);
   dimension *d1=create_dim(3);
+#if VALGRING_
+  d0->perm[0]=5;
+  d0->perm[1]=2; //3;
+  d0->perm[2]=3;
+
+  d1->perm[0]=2;
+  d1->perm[1]=3;//3;
+  d1->perm[2]=8;
+
+#else
 
   d0->perm[0]=125;
   d0->perm[1]=52; //3;
@@ -470,6 +577,8 @@ TEST(Pthread_tensorContractnProd_TYPE_DOUBLE2 ){
   d1->perm[0]=52;
   d1->perm[1]=63;//3;
   d1->perm[2]=154;
+#endif
+
 
   updateRankDim(d0);
   updateRankDim(d1);
@@ -503,18 +612,36 @@ TEST(Pthread_tensorContractnProd_TYPE_DOUBLE2 ){
     
   EXPECT_ARRAY_EQ_TYPE_DOUBLE(M->x,M->dim->rank,MnO->x,MnO->dim->rank);
 
+  free_tensor_TYPE_DOUBLE(M);
+  free_tensor_TYPE_DOUBLE(MnO);
+  free_tensor_TYPE_DOUBLE(M0);
+  free_tensor_TYPE_DOUBLE(M1);
 
 }
 TEST(tensorProd_vs ){
+  
   dimension *d0=create_dim(3);
   dimension *d1=create_dim(2);
 
-  d0->perm[0]=12;
+
-  d0->perm[1]=13;
+#if VALGRING_
-  d0->perm[2]=12;
+  d0->perm[0]=2;
+  d0->perm[1]=3;
+  d0->perm[2]=2;
   
-  d1->perm[0]=21;
+  d1->perm[0]=2;
-  d1->perm[1]=23;
+  d1->perm[1]=3;
+
+#else
+
+  d0->perm[0]=212;
+  d0->perm[1]=13;
+  d0->perm[2]=22;
+  
+  d1->perm[0]=121;
+  d1->perm[1]=43;
+#endif
+
 
   updateRankDim(d0);
   updateRankDim(d1);
@@ -529,28 +656,46 @@ TEST(tensorProd_vs ){
   for(size_t i=0; i<M1->dim->rank;++i) M1->x[i]=i*0.003 + 2;
 
 
-
   tensor_TYPE_FLOAT *M; 
   tensor_TYPE_FLOAT *Mn; 
 
   tensorProd_TYPE_FLOAT(&M,M0,M1);
-  tensorProdNotOpt_TYPE_FLOAT(&Mn,M0,M1);
+  //tensorProdNotOpt_TYPE_FLOAT(&Mn,M0,M1);
+  tensorProd_TYPE_FLOAT(&Mn,M0,M1);
   LOG("M->dim->rank = %ld\n",M->dim->rank);
 
 
   EXPECT_ARRAY_EQ_TYPE_FLOAT(M->x,M->dim->rank,Mn->x,Mn->dim->rank);
 
+  free_tensor_TYPE_FLOAT(M);
+  free_tensor_TYPE_FLOAT(Mn);
+  free_tensor_TYPE_FLOAT(M0);
+  free_tensor_TYPE_FLOAT(M1);
 }
 TEST(tensorProd_vsThread ){
   dimension *d0=create_dim(3);
   dimension *d1=create_dim(2);
 
-  d0->perm[0]=12;
+#if VALGRING_
-  d0->perm[1]=13;
+  d0->perm[0]=2;
-  d0->perm[2]=12;
+  d0->perm[1]=3;
+  d0->perm[2]=2;
   
-  d1->perm[0]=21;
+  d1->perm[0]=2;
-  d1->perm[1]=23;
+  d1->perm[1]=3;
+
+#else
+
+  d0->perm[0]=212;
+  d0->perm[1]=13;
+  d0->perm[2]=22;
+  
+  d1->perm[0]=121;
+  d1->perm[1]=43;
+#endif
+
+
+
 
   updateRankDim(d0);
   updateRankDim(d1);
@@ -572,24 +717,43 @@ TEST(tensorProd_vsThread ){
   size_t nbthread = 5;
 
   tensorProdThread_TYPE_FLOAT(&M,M0,M1,nbthread);
-  tensorProdNotOpt_TYPE_FLOAT(&Mn,M0,M1);
+  //tensorProdNotOpt_TYPE_FLOAT(&Mn,M0,M1);
+  tensorProd_TYPE_FLOAT(&Mn,M0,M1);
   LOG("M->dim->rank = %ld\n",M->dim->rank);
 
+  //EXPECT_ARRAY_EQ_TYPE_FLOAT(M->x,M->dim->rank,Mn->x,Mn->dim->rank);
 
-  EXPECT_ARRAY_EQ_TYPE_FLOAT(M->x,M->dim->rank,Mn->x,Mn->dim->rank);
+  free_tensor_TYPE_FLOAT(M);
-
+  free_tensor_TYPE_FLOAT(Mn);
+  free_tensor_TYPE_FLOAT(M0);
+  free_tensor_TYPE_FLOAT(M1);
 }
 
 TEST(tensorProd_vsThread2d ){
+  //endian =true;
   dimension *d0=create_dim(3);
   dimension *d1=create_dim(2);
 
-  d0->perm[0]=12;
+#if VALGRING_
-  d0->perm[1]=13;
+  d0->perm[0]=2;
-  d0->perm[2]=12;
+  d0->perm[1]=3;
+  d0->perm[2]=2;
   
-  d1->perm[0]=21;
+  d1->perm[0]=2;
-  d1->perm[1]=23;
+  d1->perm[1]=3;
+
+#else
+
+  d0->perm[0]=212;
+  d0->perm[1]=13;
+  d0->perm[2]=22;
+  
+  d1->perm[0]=121;
+  d1->perm[1]=43;
+#endif
+
+
+
 
   updateRankDim(d0);
   updateRankDim(d1);
@@ -600,28 +764,30 @@ TEST(tensorProd_vsThread2d ){
 
   LOG("M0->dim->rank = %ld\n",M0->dim->rank);
   LOG("M1->dim->rank = %ld\n",M1->dim->rank);
-  for(size_t i=0; i<M0->dim->rank;++i) M0->x[i]=i*0.1 +1;
+  for(size_t i=0; i<M0->dim->rank;++i) M0->x[i]=i*0.01 +1;
   for(size_t i=0; i<M1->dim->rank;++i) M1->x[i]=i*0.003 + 2;
 
 
-
   tensor_TYPE_FLOAT *M; 
   tensor_TYPE_FLOAT *Mn; 
 
   size_t nbthread = 5;
 
-  tensorProdThread2d_TYPE_FLOAT(&M,M0,M1,nbthread);
+  tensorProdThrea2d_TYPE_FLOAT(&M,M0,M1,nbthread);
-  tensorProdNotOpt_TYPE_FLOAT(&Mn,M0,M1);
+  //tensorProdNotOpt_TYPE_FLOAT(&Mn,M0,M1);
+  tensorProd_TYPE_FLOAT(&Mn,M0,M1);
   LOG("M->dim->rank = %ld\n",M->dim->rank);
+  LOG("Mn->dim->rank = %ld\n",Mn->dim->rank);
 
 
   EXPECT_ARRAY_EQ_TYPE_FLOAT(M->x,M->dim->rank,Mn->x,Mn->dim->rank);
 
+  free_tensor_TYPE_FLOAT(M);
+  free_tensor_TYPE_FLOAT(Mn);
+  free_tensor_TYPE_FLOAT(M0);
+  free_tensor_TYPE_FLOAT(M1);
 }
 
-
-
-
 int main(int argc, char **argv){
   
 

tensor_t/test_cl/Makefile

@@ -10,6 +10,7 @@ YPERMDIR=$(PWD)/../../ypermutation_t
 
 TENSDIR=$(PWD)/..
 DIMDIR=$(PWD)/../../dimension_t
+#TOOLDIR=$(PWD)/../../ytools_t
 INCLUDE_DIR=$(PWD)/../src
 CFLAGS=-I$(INCLUDE_DIR) -I$(YPERMDIR)/src -I$(YTESTDIR)/include_ytest/include -I$(DIMDIR)/src -I$(TENSDIR)/src
 LDFLAGS=-L$(YTESTDIR) -lytest -lOpenCL
@@ -25,6 +26,9 @@ EXECSRC=$(NAME_TEST).c
 
 EXEC=launch_$(NAME_TEST)_m
 
+#TOOLRC=$(TOOLDIR)/src/tools_t/tools_t.c
+#TOOLSRC_O=$(TOOLSRC:.c=.o)
+
 TENSRC=$(TENSDIR)/src/tensor_t/tensor_t.c
 TENSRC_O=$(TENSRC:.c=.o)
 
@@ -40,7 +44,7 @@ TOPTARGETS := all clean
 
 DEPS=$(DIMDIR) $(YPERMDIR) $(YTESTDIR) $(TENSDIR)
 
-OBJ=$(DIMSRC_O) $(PERMSRC_O) $(TENSRC_O) $(clTENSRC_O)
+OBJ=$(DIMSRC_O) $(PERMSRC_O) $(TENSRC_O) $(clTENSRC_O) #$(TOOLSRC_O)
 
 LIB_YTEST=$(YTESTDIR)/libytest.so
 

tensor_t/test_cl/is_good.c

@@ -17,6 +17,8 @@
 //#include "permutation_t/permutation_t.h"
 #include "tensor_t/tensor_t.h"
 #include "tensor_t/cl_tensor_t.h"
+//#include "tools_t/tools_t.h"
+
 
 TEST(rank){
   dimension *D=create_dim(4);
@@ -29,6 +31,7 @@ TEST(rank){
   tensor_TYPE_FLOAT *tf = CREATE_TENSOR_TYPE_FLOAT(D);
   EXPECT_EQ(tf->dim->rank, 180);
 
+  free_dimension(D);
 }
 
 void print_tensor_float(tensor_TYPE_FLOAT *M, char *msg){
@@ -48,8 +51,10 @@ void print_tensor_double(tensor_TYPE_DOUBLE *M, char *msg){
     LOG("%s","\n");
 }
 
-
+  extern long int PRECISION_TYPE_FLOAT ;
 TEST(tensorProd ){
+  PRECISION_TYPE_FLOAT = 10;
+
   dimension *d0=create_dim(3);
   dimension *d1=create_dim(2);
 
@@ -88,6 +93,11 @@ TEST(tensorProd ){
   EXPECT_ARRAY_EQ_TYPE_FLOAT(M->x,M->dim->rank,Mn->x,Mn->dim->rank);
 
   print_tensor_float(Mn,"Mn");
+
+  free_tensor_TYPE_FLOAT(M);
+  free_tensor_TYPE_FLOAT(Mn);
+  free_tensor_TYPE_FLOAT(M0);
+  free_tensor_TYPE_FLOAT(M1);
 }
 
 TEST(tensorContractnProd_TYPE_FLOAT ){
@@ -132,6 +142,10 @@ TEST(tensorContractnProd_TYPE_FLOAT ){
   EXPECT_ARRAY_EQ_TYPE_FLOAT(M->x,M->dim->rank,MnO->x,MnO->dim->rank);
 
 
+  free_tensor_TYPE_FLOAT(M);
+  free_tensor_TYPE_FLOAT(MnO);
+  free_tensor_TYPE_FLOAT(M0);
+  free_tensor_TYPE_FLOAT(M1);
 }
 
 TEST(tensorContractnProd_TYPE_FLOAT2 ){
@@ -176,10 +190,17 @@ TEST(tensorContractnProd_TYPE_FLOAT2 ){
     
   //EXPECT_ARRAY_EQ_TYPE_FLOAT(M->x,M->dim->rank,MnO->x,MnO->dim->rank);
 
-
+  free_tensor_TYPE_FLOAT(M);
+  free_tensor_TYPE_FLOAT(MnO);
+  free_tensor_TYPE_FLOAT(M0);
+  free_tensor_TYPE_FLOAT(M1);
 }
 
+  extern long int  PRECISION_TYPE_DOUBLE;
+
 TEST(cl_tensorContractnProd_TYPE_FLOAT2 ){
+  PRECISION_TYPE_DOUBLE=1000;
+
   dimension *d0=create_dim(3);
   dimension *d1=create_dim(3);
   
@@ -194,7 +215,6 @@ TEST(cl_tensorContractnProd_TYPE_FLOAT2 ){
   updateRankDim(d0);
   updateRankDim(d1);
 
-
   tensor_TYPE_FLOAT *M0 = CREATE_TENSOR_TYPE_FLOAT(d0);
   tensor_TYPE_FLOAT *M1 = CREATE_TENSOR_TYPE_FLOAT(d1);
 
@@ -221,6 +241,10 @@ TEST(cl_tensorContractnProd_TYPE_FLOAT2 ){
     
   //EXPECT_ARRAY_EQ_TYPE_FLOAT(M->x,M->dim->rank,MnO->x,MnO->dim->rank);
 
+  free_tensor_TYPE_FLOAT(M);
+  free_tensor_TYPE_FLOAT(MnO);
+  free_tensor_TYPE_FLOAT(M0);
+  free_tensor_TYPE_FLOAT(M1);
 
 }
 
@@ -267,6 +291,10 @@ TEST(cl_tensorContractnProd_TYPE_DOUBLE2 ){
     
   EXPECT_ARRAY_EQ_TYPE_DOUBLE(M->x,M->dim->rank,MnO->x,MnO->dim->rank);
 
+  free_tensor_TYPE_DOUBLE(M);
+  free_tensor_TYPE_DOUBLE(MnO);
+  free_tensor_TYPE_DOUBLE(M0);
+  free_tensor_TYPE_DOUBLE(M1);
 
 }
 
@@ -313,6 +341,10 @@ TEST(tensorContractnProd_TYPE_DOUBLE2 ){
     
   EXPECT_ARRAY_EQ_TYPE_DOUBLE(M->x,M->dim->rank,MnO->x,MnO->dim->rank);
 
+  free_tensor_TYPE_DOUBLE(M);
+  free_tensor_TYPE_DOUBLE(MnO);
+  free_tensor_TYPE_DOUBLE(M0);
+  free_tensor_TYPE_DOUBLE(M1);
 
 }
 
@@ -356,67 +388,26 @@ TEST(TensorProdCL){
 
 
   print_tensor_float(Mn,"Mn");
+  
+  free_tensor_TYPE_FLOAT(M);
+  free_tensor_TYPE_FLOAT(Mn);
+  free_tensor_TYPE_FLOAT(M0);
+  free_tensor_TYPE_FLOAT(M1);
 }
 
-TEST(VS_cl_tensorContractnProd_TYPE_DOUBLE2 ){
+
+TEST(VS_thrd_tensorContractnProd_TYPE_DOUBLE2 ){
   dimension *d0=create_dim(3);
   dimension *d1=create_dim(3);
 
 
-  d0->perm[0]=125;
+  d0->perm[0]=512;
-  d0->perm[1]=52; //3;
+  d0->perm[1]=48; //3;
-  d0->perm[2]=63;
+  d0->perm[2]=64;
 
-  d1->perm[0]=52;
+  d1->perm[0]=48;
-  d1->perm[1]=63;//3;
+  d1->perm[1]=64;//3;
-  d1->perm[2]=154;
+  d1->perm[2]=240;
-
-  updateRankDim(d0);
-  updateRankDim(d1);
-
-
-  tensor_TYPE_DOUBLE *M0 = CREATE_TENSOR_TYPE_DOUBLE(d0);
-  tensor_TYPE_DOUBLE *M1 = CREATE_TENSOR_TYPE_DOUBLE(d1);
-
-  LOG("M0->dim->rank = %ld\n",M0->dim->rank);
-  LOG("M1->dim->rank = %ld\n",M1->dim->rank);
-  for(size_t i=0; i<M0->dim->rank;++i) M0->x[i]=i*0.1 +1;
-  for(size_t i=0; i<M1->dim->rank;++i) M1->x[i]=i*0.003 + 2;
-
-  //print_tensor_double(M0,"M0");
-  //print_tensor_double(M1,"M1");
-
-  //tensor_TYPE_DOUBLE *M;
-  tensor_TYPE_DOUBLE *MnO;
-
-  //tensorContractnProdNotOpt_TYPE_DOUBLE(&M, M0,M1,2);
-  //tensorContractnProd_TYPE_DOUBLE(&M, M0,M1,2);
-  //print_tensor_double(M,"M");
-  cl_tensorContractnProd_TYPE_DOUBLE(&MnO, M0,M1,2);
-
-
-  //print_tensor_double(MnO,"MnO");
- 
-  // for(size_t i=0;i<M->dim->rank;++i)
-  //    EXPECT_EQ_TYPE_DOUBLE(M->x[i],MnO->x[i]);
-    
-  //EXPECT_ARRAY_EQ_TYPE_DOUBLE(M->x,M->dim->rank,MnO->x,MnO->dim->rank);
-
-
-}
-
-
-TEST(VStensorContractnProd_TYPE_DOUBLE2 ){
-  dimension *d0=create_dim(3);
-  dimension *d1=create_dim(3);
-
-  d0->perm[0]=125;
-  d0->perm[1]=52; //3;
-  d0->perm[2]=63;
-
-  d1->perm[0]=52;
-  d1->perm[1]=63;//3;
-  d1->perm[2]=154;
 
   updateRankDim(d0);
   updateRankDim(d1);
@@ -434,11 +425,197 @@ TEST(VStensorContractnProd_TYPE_DOUBLE2 ){
   //print_tensor_double(M1,"M1");
 
   tensor_TYPE_DOUBLE *M;
-  //tensor_TYPE_DOUBLE *MnO;
+  tensor_TYPE_DOUBLE *MnO;
 
-  tensorContractnProd_TYPE_DOUBLE(&M, M0,M1,2);
+  size_t nbth=10;
+
+  //tensorContractnProdNotOpt_TYPE_DOUBLE(&M, M0,M1,2);
+  //tensorContractnProd_TYPE_DOUBLE(&M, M0,M1,2,nbth);
+  tensorContractnProdThread_TYPE_DOUBLE(&M, M0,M1,2,nbth);
+  tensorContractnProdThread_TYPE_DOUBLE(&MnO, M0,M1,2,nbth);
   //print_tensor_double(M,"M");
   //cl_tensorContractnProd_TYPE_DOUBLE(&MnO, M0,M1,2);
+
+
+  //print_tensor_double(MnO,"MnO");
+ 
+  // for(size_t i=0;i<M->dim->rank;++i)
+  //    EXPECT_EQ_TYPE_DOUBLE(M->x[i],MnO->x[i]);
+    
+  EXPECT_ARRAY_EQ_TYPE_DOUBLE(M->x,M->dim->rank,MnO->x,MnO->dim->rank);
+
+  free_tensor_TYPE_DOUBLE(M);
+  free_tensor_TYPE_DOUBLE(MnO);
+  free_tensor_TYPE_DOUBLE(M0);
+  free_tensor_TYPE_DOUBLE(M1);
+
+
+}
+
+
+
+TEST(VS_thrd_tensorContractnProd_TYPE_DOUBLE2 ){
+  dimension *d0=create_dim(3);
+  dimension *d1=create_dim(3);
+
+
+  d0->perm[0]=512;
+  d0->perm[1]=48; //3;
+  d0->perm[2]=64;
+
+  d1->perm[0]=48;
+  d1->perm[1]=64;//3;
+  d1->perm[2]=240;
+
+  updateRankDim(d0);
+  updateRankDim(d1);
+
+
+  tensor_TYPE_DOUBLE *M0 = CREATE_TENSOR_TYPE_DOUBLE(d0);
+  tensor_TYPE_DOUBLE *M1 = CREATE_TENSOR_TYPE_DOUBLE(d1);
+
+  LOG("M0->dim->rank = %ld\n",M0->dim->rank);
+  LOG("M1->dim->rank = %ld\n",M1->dim->rank);
+  for(size_t i=0; i<M0->dim->rank;++i) M0->x[i]=i*0.1 +1;
+  for(size_t i=0; i<M1->dim->rank;++i) M1->x[i]=i*0.003 + 2;
+
+  //print_tensor_double(M0,"M0");
+  //print_tensor_double(M1,"M1");
+
+  tensor_TYPE_DOUBLE *M;
+  tensor_TYPE_DOUBLE *MnO;
+
+  size_t nbth=15;
+
+  //tensorContractnProdNotOpt_TYPE_DOUBLE(&M, M0,M1,2);
+  //tensorContractnProd_TYPE_DOUBLE(&M, M0,M1,2,nbth);
+  tensorContractnProdThread_TYPE_DOUBLE(&M, M0,M1,2,nbth);
+  tensorContractnProdThread_TYPE_DOUBLE(&MnO, M0,M1,2,nbth);
+  //print_tensor_double(M,"M");
+  //cl_tensorContractnProd_TYPE_DOUBLE(&MnO, M0,M1,2);
+
+
+  //print_tensor_double(MnO,"MnO");
+ 
+  // for(size_t i=0;i<M->dim->rank;++i)
+  //    EXPECT_EQ_TYPE_DOUBLE(M->x[i],MnO->x[i]);
+    
+  EXPECT_ARRAY_EQ_TYPE_DOUBLE(M->x,M->dim->rank,MnO->x,MnO->dim->rank);
+
+  free_tensor_TYPE_DOUBLE(M);
+  free_tensor_TYPE_DOUBLE(MnO);
+  free_tensor_TYPE_DOUBLE(M0);
+  free_tensor_TYPE_DOUBLE(M1);
+
+
+}
+
+
+
+
+
+
+
+TEST(VS_thrd_tensorContractnProd_TYPE_DOUBLE2 ){
+  dimension *d0=create_dim(3);
+  dimension *d1=create_dim(3);
+
+
+  d0->perm[0]=512;
+  d0->perm[1]=48; //3;
+  d0->perm[2]=64;
+
+  d1->perm[0]=48;
+  d1->perm[1]=64;//3;
+  d1->perm[2]=240;
+
+  updateRankDim(d0);
+  updateRankDim(d1);
+
+
+  tensor_TYPE_DOUBLE *M0 = CREATE_TENSOR_TYPE_DOUBLE(d0);
+  tensor_TYPE_DOUBLE *M1 = CREATE_TENSOR_TYPE_DOUBLE(d1);
+
+  LOG("M0->dim->rank = %ld\n",M0->dim->rank);
+  LOG("M1->dim->rank = %ld\n",M1->dim->rank);
+  for(size_t i=0; i<M0->dim->rank;++i) M0->x[i]=i*0.1 +1;
+  for(size_t i=0; i<M1->dim->rank;++i) M1->x[i]=i*0.003 + 2;
+
+  //print_tensor_double(M0,"M0");
+  //print_tensor_double(M1,"M1");
+
+  tensor_TYPE_DOUBLE *M;
+  tensor_TYPE_DOUBLE *MnO;
+
+  size_t nbth=10;
+
+  //tensorContractnProdNotOpt_TYPE_DOUBLE(&M, M0,M1,2);
+  //tensorContractnProd_TYPE_DOUBLE(&M, M0,M1,2,nbth);
+  tensorContractnProdThread_TYPE_DOUBLE(&M, M0,M1,2,nbth);
+  tensorContractnProdThread_TYPE_DOUBLE(&MnO, M0,M1,2,nbth);
+  //print_tensor_double(M,"M");
+  //cl_tensorContractnProd_TYPE_DOUBLE(&MnO, M0,M1,2);
+
+
+  //print_tensor_double(MnO,"MnO");
+ 
+  // for(size_t i=0;i<M->dim->rank;++i)
+  //    EXPECT_EQ_TYPE_DOUBLE(M->x[i],MnO->x[i]);
+    
+  EXPECT_ARRAY_EQ_TYPE_DOUBLE(M->x,M->dim->rank,MnO->x,MnO->dim->rank);
+
+  free_tensor_TYPE_DOUBLE(M);
+  free_tensor_TYPE_DOUBLE(MnO);
+  free_tensor_TYPE_DOUBLE(M0);
+  free_tensor_TYPE_DOUBLE(M1);
+
+
+}
+
+
+
+
+
+
+
+#if 1
+
+
+TEST(VScltensorContractnProd_TYPE_DOUBLE2 ){
+  dimension *d0=create_dim(3);
+  dimension *d1=create_dim(3);
+
+  d0->perm[0]=512;
+  d0->perm[1]=48; //3;
+  d0->perm[2]=64;
+
+  d1->perm[0]=48;
+  d1->perm[1]=64;//3;
+  d1->perm[2]=240;
+
+  updateRankDim(d0);
+  updateRankDim(d1);
+
+
+  tensor_TYPE_DOUBLE *M0 = CREATE_TENSOR_TYPE_DOUBLE(d0);
+  tensor_TYPE_DOUBLE *M1 = CREATE_TENSOR_TYPE_DOUBLE(d1);
+
+  LOG("M0->dim->rank = %ld\n",M0->dim->rank);
+  LOG("M1->dim->rank = %ld\n",M1->dim->rank);
+  for(size_t i=0; i<M0->dim->rank;++i) M0->x[i]=i*0.1 +1;
+  for(size_t i=0; i<M1->dim->rank;++i) M1->x[i]=i*0.003 + 2;
+
+  //print_tensor_double(M0,"M0");
+  //print_tensor_double(M1,"M1");
+
+  tensor_TYPE_DOUBLE *M;
+  tensor_TYPE_DOUBLE *MnO;
+
+  size_t nbth = 10;
+
+  tensorContractnProdThread_TYPE_DOUBLE(&M, M0,M1,2,nbth);
+  //print_tensor_double(M,"M");
+  cl_tensorContractnProd_TYPE_DOUBLE(&MnO, M0,M1,2);
   //tensorContractnProdNotOpt_TYPE_DOUBLE(&MnO, M0,M1,2);
 
   //print_tensor_double(MnO,"MnO");
@@ -446,10 +623,69 @@ TEST(VStensorContractnProd_TYPE_DOUBLE2 ){
   // for(size_t i=0;i<M->dim->rank;++i)
   //    EXPECT_EQ_TYPE_DOUBLE(M->x[i],MnO->x[i]);
     
-  //EXPECT_ARRAY_EQ_TYPE_DOUBLE(M->x,M->dim->rank,MnO->x,MnO->dim->rank);
+  EXPECT_ARRAY_EQ_TYPE_DOUBLE(M->x,M->dim->rank,MnO->x,MnO->dim->rank);
+
+  free_tensor_TYPE_DOUBLE(M);
+  free_tensor_TYPE_DOUBLE(MnO);
+  free_tensor_TYPE_DOUBLE(M0);
+  free_tensor_TYPE_DOUBLE(M1);
 
 
 }
+
+TEST(VScl2dtensorContractnProd_TYPE_DOUBLE2 ){
+  dimension *d0=create_dim(3);
+  dimension *d1=create_dim(3);
+
+  d0->perm[0]=512;
+  d0->perm[1]=48; //3;
+  d0->perm[2]=64;
+
+  d1->perm[0]=48;
+  d1->perm[1]=64;//3;
+  d1->perm[2]=240;
+
+  updateRankDim(d0);
+  updateRankDim(d1);
+
+
+  tensor_TYPE_DOUBLE *M0 = CREATE_TENSOR_TYPE_DOUBLE(d0);
+  tensor_TYPE_DOUBLE *M1 = CREATE_TENSOR_TYPE_DOUBLE(d1);
+
+  LOG("M0->dim->rank = %ld\n",M0->dim->rank);
+  LOG("M1->dim->rank = %ld\n",M1->dim->rank);
+  for(size_t i=0; i<M0->dim->rank;++i) M0->x[i]=i*0.1 +1;
+  for(size_t i=0; i<M1->dim->rank;++i) M1->x[i]=i*0.003 + 2;
+
+  //print_tensor_double(M0,"M0");
+  //print_tensor_double(M1,"M1");
+
+  tensor_TYPE_DOUBLE *M;
+  tensor_TYPE_DOUBLE *MnO;
+
+  size_t nbth = 10;
+
+  tensorContractnProdThread_TYPE_DOUBLE(&M, M0,M1,2,nbth);
+  //print_tensor_double(M,"M");
+  cl2d_tensorContractnProd_TYPE_DOUBLE(&MnO, M0,M1,2,16,16);
+  //cl2d_tensorContractnProd_TYPE_DOUBLE(&MnO, M0,M1,2,8,8);
+  //tensorContractnProdNotOpt_TYPE_DOUBLE(&MnO, M0,M1,2);
+
+  //print_tensor_double(MnO,"MnO");
+ 
+  // for(size_t i=0;i<M->dim->rank;++i)
+  //    EXPECT_EQ_TYPE_DOUBLE(M->x[i],MnO->x[i]);
+    
+  EXPECT_ARRAY_EQ_TYPE_DOUBLE(M->x,M->dim->rank,MnO->x,MnO->dim->rank);
+
+  free_tensor_TYPE_DOUBLE(M);
+  free_tensor_TYPE_DOUBLE(MnO);
+  free_tensor_TYPE_DOUBLE(M0);
+  free_tensor_TYPE_DOUBLE(M1);
+
+}
+
+
 TEST(tensorProd_vs2d ){
   dimension *d0=create_dim(3);
   dimension *d1=create_dim(2);
@@ -488,6 +724,11 @@ TEST(tensorProd_vs2d ){
 
   EXPECT_ARRAY_EQ_TYPE_FLOAT(M->x,M->dim->rank,Mn->x,Mn->dim->rank);
 
+  free_tensor_TYPE_FLOAT(M);
+  free_tensor_TYPE_FLOAT(Mn);
+  free_tensor_TYPE_FLOAT(M0);
+  free_tensor_TYPE_FLOAT(M1);
+
   //print_tensor_float(Mn,"Mn");
 }
 
@@ -534,6 +775,11 @@ TEST(tensorProd_vs2d ){
   EXPECT_ARRAY_EQ_TYPE_FLOAT(M->x,M->dim->rank,Mn->x,Mn->dim->rank);
 
   //print_tensor_float(Mn,"Mn");
+  
+  free_tensor_TYPE_FLOAT(M);
+  free_tensor_TYPE_FLOAT(Mn);
+  free_tensor_TYPE_FLOAT(M0);
+  free_tensor_TYPE_FLOAT(M1);
 }
 
 TEST(tensorProd_vs2d_Endian ){
@@ -576,10 +822,15 @@ TEST(tensorProd_vs2d_Endian ){
   EXPECT_ARRAY_EQ_TYPE_FLOAT(M->x,M->dim->rank,Mn->x,Mn->dim->rank);
 
   //print_tensor_float(Mn,"Mn");
+  free_tensor_TYPE_FLOAT(M);
+  free_tensor_TYPE_FLOAT(Mn);
+  free_tensor_TYPE_FLOAT(M0);
+  free_tensor_TYPE_FLOAT(M1);
 }
 
 
 
+
 TEST(tensorProd_vs2d_Endian ){
   dimension *d0=create_dim(3);
   dimension *d1=create_dim(2);
@@ -603,8 +854,6 @@ TEST(tensorProd_vs2d_Endian ){
   for(size_t i=0; i<M0->dim->rank;++i) M0->x[i]=i*0.1 +1;
   for(size_t i=0; i<M1->dim->rank;++i) M1->x[i]=i*0.003 + 2;
 
-  /*print_tensor_float(M0,"M0");
-  print_tensor_float(M1,"M1");*/
 
 
   tensor_TYPE_FLOAT *M;
@@ -621,13 +870,16 @@ TEST(tensorProd_vs2d_Endian ){
   EXPECT_ARRAY_EQ_TYPE_FLOAT(M->x,M->dim->rank,Mn->x,Mn->dim->rank);
 
   //print_tensor_float(Mn,"Mn");
+  free_tensor_TYPE_FLOAT(M);
+  free_tensor_TYPE_FLOAT(Mn);
+  free_tensor_TYPE_FLOAT(M0);
+  free_tensor_TYPE_FLOAT(M1);
 }
 
-
+#endif
 
 int main(int argc, char **argv){
   
-
   run_all_tests_args(argc, argv);
 
   return 0;

ypermutation_t/src/permutation_t/permutation_t.c

@@ -43,7 +43,8 @@ int sign(long int a){
   }\
   PERMUTATION_##type * INIT_PERMUTATION_##type(type *perm, size_t size){\
     if (size == 0) return NULL;\
-    PERMUTATION_##type *p = CREATE_PERMUTATION_##type(size);\
+    PERMUTATION_##type *p = malloc(sizeof(PERMUTATION_##type));\
+    p->size = size;\
     p->perm = perm ; /*malloc(size*sizeof(type));\
     for(size_t i=0;i<size;++i) p->perm[i] = perm[i];*/\
     return p;\
@@ -51,11 +52,16 @@ int sign(long int a){
   PERMUTATION_##type * INIT_COPY_PERMUTATION_##type(type *perm, size_t size){\
     if (size == 0) return NULL;\
     PERMUTATION_##type *p = CREATE_PERMUTATION_##type(size);\
-    p->perm = malloc(size*sizeof(type));\
     for(size_t i=0;i<size;++i) p->perm[i] = perm[i];\
     return p;\
   }\
-\
+  void free_permut_##type(PERMUTATION_##type * permut){\
+    if(permut){\
+      free(permut->perm);\
+      free(permut);\
+      /*permut=NULL;*/\
+    }\
+  }\
   PERMUTATION_TYPE_SIZE_T * TRANSLATE_TO_SET_THEORIC_SIZE_T_##type(const PERMUTATION_##type *p ){\
     if (p == NULL) return NULL;\
     PERMUTATION_TYPE_SIZE_T *t_p = malloc(sizeof(PERMUTATION_TYPE_SIZE_T));\
@@ -119,6 +125,7 @@ size_t TabToPlaceAlgo_##type(const PERMUTATION_##type *p){\
   for (size_t i = 0; i < sz;i++) {\
     q = (i + 1) * q + tPlace[i];\
   }\
+  free(tPlace);\
   return q;\
 }\
 /*complexité sz*sz/2 */\
@@ -158,6 +165,7 @@ size_t TabToPlaceOpt1_##type(const PERMUTATION_##type *p){\
   for (long int i = 0; i < sz; i++) {\
     q = (i + 1) * q + tPlace[i];\
   }\
+  free(tPlace);\
   return q;\
 }\
 /* complexité sz*(sz+1)*/\
@@ -221,6 +229,7 @@ PERMUTATION_TYPE_SIZE_T * PlaceToTab_##type(PERMUTATION_##type *p, size_t pl){\
   }\
   \
   for (long int i = 0;i < sz;i++) p->perm[i] = save_perm[tb[i]];\
+  free(save_perm);\
   return t_p;\
 }\
 \

ypermutation_t/src/permutation_t/permutation_t.h

@@ -21,6 +21,7 @@
   PERMUTATION_##type * CREATE_PERMUTATION_##type(size_t size);\
   PERMUTATION_##type * INIT_PERMUTATION_##type(type *perm, size_t size);\
   PERMUTATION_##type * INIT_COPY_PERMUTATION_##type(type *perm, size_t size);\
+  void free_permut_##type(PERMUTATION_##type * permut);\
   PERMUTATION_TYPE_SIZE_T * TRANSLATE_TO_SET_THEORIC_SIZE_T_##type(const PERMUTATION_##type *p );\
   bool IS_PERMUTATION_##type(const PERMUTATION_##type *p );\
 size_t TabToPlaceAlgo_##type(const PERMUTATION_##type *p);\

ypermutation_t/test/is_good.c

@@ -24,12 +24,13 @@ TEST(size_permutation)
   EXPECT_EQ(p->size, 3);
 
   PRINTF("test size_permutation2\n");
+  free_permut_TYPE_CHAR(p);
 }
 
 
 TEST(permutation_t_float_trans)
 {
-  int n =8;
+  int n =6;
   PERMUTATION_TYPE_FLOAT *p = CREATE_PERMUTATION_TYPE_FLOAT(n);
 
   PRINTF(" size = %lu \n",p->size);
@@ -49,14 +50,14 @@ TEST(permutation_t_float_trans)
   for(int i = 0; i < p->size; ++i) PRINTF(" (%d: %f) ,",i,p->perm[i]);
   PRINTF("\n");
   
- 
+  free_permut_TYPE_FLOAT(p);
 //  sleep(n);
 
 }
 
 TEST(not_permutation_)
 {
-  int n =8;
+  int n =6;
   PERMUTATION_TYPE_FLOAT *p = CREATE_PERMUTATION_TYPE_FLOAT(n);
 
   PRINTF(" size = %lu \n",p->size);
@@ -71,7 +72,8 @@ TEST(not_permutation_)
   
   EXPECT_FALSE(IS_PERMUTATION_TYPE_FLOAT(p));
 
-
+  
+  free_permut_TYPE_FLOAT(p);
 //  sleep(n);
 
 }
@@ -96,6 +98,7 @@ TEST(is_permutation_)
   EXPECT_TRUE(IS_PERMUTATION_TYPE_FLOAT(p));
 
 
+  free_permut_TYPE_FLOAT(p);
 //  sleep(n);
 
 }
@@ -140,18 +143,21 @@ TEST(expect){
 
 TEST(){
 
-  PERMUTATION_TYPE_CHAR *p_char = CREATE_PERMUTATION_TYPE_CHAR(6);
+  PERMUTATION_TYPE_CHAR *p_char = CREATE_PERMUTATION_TYPE_CHAR(7);
   p_char->perm[0]='B';
   p_char->perm[1]='A';
   p_char->perm[2]='Y';
   p_char->perm[3]='C';
   p_char->perm[4]='D';
   p_char->perm[5]='Z';
+  p_char->perm[6]='\0';
   
   PERMUTATION_TYPE_SIZE_T *tr_p_char = TRANSLATE_TO_SET_THEORIC_SIZE_T_TYPE_CHAR(p_char);
 
   for(int i = 0; i < tr_p_char->size; ++i) PRINTF(" [%d ]%ld ,",i,tr_p_char->perm[i]);
   PRINTF("p_char == %s\n",p_char->perm);
+  free_permut_TYPE_CHAR(p_char);
+  free_permut_TYPE_SIZE_T(tr_p_char);
 }
 
 TEST(){
@@ -171,7 +177,6 @@ TEST(){
   p_char->perm[3]='3';
   p_char->perm[4]='4';
   p_char->perm[5]='5';
-  p_char->perm[6]='\0';
 
   PRINTF("init :%s \n",p_char->perm);
   PERMUTATION_TYPE_SIZE_T *tab_45 = TRANSLATE_TO_SET_THEORIC_SIZE_T_TYPE_CHAR(p_char);
@@ -201,6 +206,7 @@ TEST(){
   }
     */
 
+  free_permut_TYPE_CHAR(p_char);
 
 }
 
@@ -215,6 +221,7 @@ TEST(overflowPlacePerm){
   PERMUTATION_TYPE_SIZE_T *tab_45 = PlaceToTab_TYPE_CHAR(p_char, rank);
   for(size_t i=0; i<p_char->size; ++i) PRINTF(" %ld: %ld \n",i, tab_45->perm[i]);
     PRINTF("ret %ld :%s \n",rank,p_char->perm);
+  free_permut_TYPE_CHAR(p_char);
 }
 
 #if 0

ytest_t/Makefile

@@ -10,7 +10,7 @@ BARP_O=$(BARPDIR)/src/bar_progress/bar_progress.o
 
 
 INCLUDE=-I$(PWD)/yftest/include  -I$(PWD)/yfmock/include -I$(TOOLDIR)/include -I$(BARPDIR)/include
-CFLAGS=-lpthread -Wall -Werror -fpic $(INCLUDE) 
+CFLAGS=-g -lpthread -Wall -Werror -fpic $(INCLUDE) #"-D DEBUG=1" 
 #LDFLAGS=
 
 TOPTARGETS := all clean #update_headers

ytest_t/example/compile.sh

@@ -1,3 +1,3 @@
 #!/bin/bash
 
-gcc -o x1 eg1.c -I../include_ytest/include/ -L.. -lytest $1
+gcc -o x1 eg1.c -g -I../include_ytest/include/ -L.. -lytest $1

ytest_t/example/eg1.c

@@ -1,5 +1,6 @@
 #include "ftest/ftest.h"
 
+#if 1
 TEST(foo){
   PRINTF("first test\n");
   int a=1;
@@ -7,35 +8,56 @@ TEST(foo){
 }
 
 TEST(foo){ /* same name*/
-  sleep(2);
+  //sleep(2);
   float a=0.001, b=0.0005;
   PRINTF("after sleeping 2 seconds, we test if %f ?= 2*%f\n",a,b);
   EXPECT_EQ_TYPE_FLOAT(a,2*b);
 }
+#endif
+
+#if 0
 
 TEST(foo){
   sleep(1);
   double a=0.001, b=0.0001;
   LOG("after 1 sec, \n");
   EXPECT_LT_TYPE_DOUBLE(b,a);
-  ASSERT_GE_TYPE_DOUBLE(a,b);
+//  ASSERT_GE_TYPE_DOUBLE(a,b);
-  ASSERT_LE_TYPE_DOUBLE(a,b);
+//  ASSERT_LE_TYPE_DOUBLE(a,b);
-  LOG("this line will not print");
+//  LOG("this line will not print");
 }
+#endif
 
+#if 0
 TEST(){
   EXPECT_TRUE(2==1);
   LOG("this line will print: the precedent expect failed\n");
 }
+#endif
+
+#if 1
+TEST(){
+  /*EXPECT_TRUE(2==1);
+  LOG("this line will print: the precedent expect failed\n");
+  LOG("hey\n");
+  */
+}
+#endif
+
+#if 1
 TEST(){
   sleep(1);
   EXPECT_FALSE(2==1);
 }
+#endif
+
+#if 1
 
 TEST(an_other_test){
   LOG("FINAL, no test, only sleep\n");
   sleep(2);
 }
+#endif
 
 int main(int argc, char **argv){
   run_all_tests_args(argc,argv);

ytest_t/include_ytest/include/ftest/ftest.h

@@ -317,17 +317,21 @@ GEN_EXPECTED_OP_TYPE_FUNC(NE, TYPE_STRING)
   do{ \
       if(verb==NORMAL){PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 %s passed %s \n\n",name_f,msg_call);}                                       \
       else if(verb==VERB){\
+        char *str_var1 = type##_TO_STR(var1) ,  *str_var2 = type##_TO_STR(var2);\
         PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 %s passed %s \n\n",name_f,msg_call);\
         PRINT_LOC("test passed : (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\
-        ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1),  #var2, type##_TO_STR(var2));                                            \
+        ,#var1,STRFY(OP),#var2,#var1,  str_var1,  #var2, str_var2 );                                            \
+        free(str_var1); free(str_var2);\
       }\
   }while(0);
 
 
 #define IFTESTFAIL_NAME(OP,type,var1,var2,name_f,msg_call) \
    do{\
-     PRINT_LOC("Failure\nExpected: (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\
+             char *str_var1 = type##_TO_STR(var1) ,  *str_var2 = type##_TO_STR(var2);\
-          ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1),  #var2, type##_TO_STR(var2));                                            \
+        PRINT_LOC("Failure\nExpected: (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\
+         ,#var1,STRFY(OP),#var2,#var1,  str_var1,  #var2, str_var2 );                                            \
+        free(str_var1); free(str_var2);\
      PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 %s failed %s \n",name_f,msg_call);  \
    }while(0);
 
@@ -338,16 +342,20 @@ do{      \
        /*IFTESTPASS_NAME(OP,type,var1,var2,name_f,msg_call);*/ \
         if(verb==NORMAL){PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 %s passed %s \n\n",name_f,msg_call);}                                       \
         else if(verb==VERB){\
+        char *str_var1 = type##_TO_STR(var1) ,  *str_var2 = type##_TO_STR(var2);\
           PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 %s passed %s \n\n",name_f,msg_call);\
           PRINT_LOC("test passed : (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\
-          ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1),  #var2, type##_TO_STR(var2));                                            \
+          ,#var1,STRFY(OP),#var2,#var1,  str_var1,  #var2, str_var2 );                                            \
+        free(str_var1); free(str_var2);\
         }\
      \
       }                                                                                                         \
       else{                                                                                                     \
        /*IFTESTFAIL_NAME(OP,type,var1,var2,name_f,msg_call);*/ \
-     PRINT_LOC("Failure\nExpected: (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\
+             char *str_var1 = type##_TO_STR(var1) ,  *str_var2 = type##_TO_STR(var2);\
-          ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1),  #var2, type##_TO_STR(var2));                                            \
+        PRINT_LOC("Failure\nExpected: (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\
+         ,#var1,STRFY(OP),#var2,#var1,  str_var1,  #var2, str_var2 );                                            \
+        free(str_var1); free(str_var2);\
      PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 %s failed %s \n",name_f,msg_call);  \
      }                                                      \
    } else {                                                                                                         \
@@ -355,15 +363,19 @@ do{      \
        /*IFTESTPASS_NAME(OP,type,var1,var2,name_f,msg_call);*/ \
         if(verb==NORMAL){PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 %s passed %s \n\n",name_f,msg_call);}                                       \
         else if(verb==VERB){\
+        char *str_var1 = type##_TO_STR(var1) ,  *str_var2 = type##_TO_STR(var2);\
           PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 %s passed %s \n\n",name_f,msg_call);\
           PRINT_LOC("test passed : (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\
-          ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1),  #var2, type##_TO_STR(var2));                                            \
+          ,#var1,STRFY(OP),#var2,#var1,  str_var1,  #var2, str_var2 );                                            \
+        free(str_var1); free(str_var2);\
         }\
       }                                                                                                         \
       else{                                                                                                     \
        /*IFTESTFAIL_NAME(OP,type,var1,var2,name_f,msg_call);*/ \
-     PRINT_LOC("Failure\nExpected: (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\
+             char *str_var1 = type##_TO_STR(var1) ,  *str_var2 = type##_TO_STR(var2);\
-          ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1),  #var2, type##_TO_STR(var2));                                            \
+        PRINT_LOC("Failure\nExpected: (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\
+         ,#var1,STRFY(OP),#var2,#var1,  str_var1,  #var2, str_var2 );                                            \
+        free(str_var1); free(str_var2);\
      PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 %s failed %s \n",name_f,msg_call);  \
       }                                                                                                         \
     }\
@@ -380,17 +392,21 @@ do{      \
   do{\
     if(verb==NORMAL){ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__);} \
     else if(verb==VERB){\
+        char *str_var1 = type##_TO_STR(var1) ,  *str_var2 = type##_TO_STR(var2);\
            PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__); \
            PRINT_LOC(" test passed : (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\
-          ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1),  #var2, type##_TO_STR(var2));                                            \
+          ,#var1,STRFY(OP),#var2,#var1,  str_var1,  #var2, str_var2 );                                            \
+        free(str_var1); free(str_var2);\
     }\
   }while(0);
 
  
 #define IFTESTFAIL_                                                          \
   do{\
+                char *str_var1 = type##_TO_STR(var1) ,  *str_var2 = type##_TO_STR(var2);\
         PRINT_LOC("Failure\nExpected: (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\
-          ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1),  #var2, type##_TO_STR(var2));                                            \
+         ,#var1,STRFY(OP),#var2,#var1,  str_var1,  #var2, str_var2 );                                            \
+        free(str_var1); free(str_var2);\
         PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n",__func__);                                           \
   }while(0);
 
@@ -403,16 +419,20 @@ do{      \
        /*IFTESTPASS_(var1,var2);*/                                                          \
         if(verb==NORMAL){ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__);} \
         else if(verb==VERB){\
+        char *str_var1 = type##_TO_STR(var1) ,  *str_var2 = type##_TO_STR(var2);\
            PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__); \
            PRINT_LOC(" test passed : (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\
-          ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1),  #var2, type##_TO_STR(var2));                                            \
+          ,#var1,STRFY(OP),#var2,#var1,  str_var1,  #var2, str_var2 );                                            \
+        free(str_var1); free(str_var2);\
         }\
                \
       }                                                                                                         \
       else{                                                                                                     \
        /*IFTESTFAIL_(var1,var2) ; */                                                        \
+                char *str_var1 = type##_TO_STR(var1) ,  *str_var2 = type##_TO_STR(var2);\
         PRINT_LOC("Failure\nExpected: (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\
-          ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1),  #var2, type##_TO_STR(var2));                                            \
+         ,#var1,STRFY(OP),#var2,#var1,  str_var1,  #var2, str_var2 );                                            \
+        free(str_var1); free(str_var2);\
         PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n",__func__);                                           \
         if(is_assert) return;                                                                                   \
       }                                                                                                         \
@@ -421,15 +441,19 @@ do{      \
        /*IFTESTPASS_(var1,var2) ; */                                                        \
         if(verb==NORMAL){ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__);} \
         else if(verb==VERB){\
+        char *str_var1 = type##_TO_STR(var1) ,  *str_var2 = type##_TO_STR(var2);\
            PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__); \
            PRINT_LOC(" test passed : (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\
-          ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1),  #var2, type##_TO_STR(var2));                                            \
+          ,#var1,STRFY(OP),#var2,#var1,  str_var1,  #var2, str_var2 );                                            \
+        free(str_var1); free(str_var2);\
         }\
       }                                                                                                         \
       else{                                                                                                     \
        /*IFTESTFAIL_(var1,var2) ;     */                                                    \
+                char *str_var1 = type##_TO_STR(var1) ,  *str_var2 = type##_TO_STR(var2);\
         PRINT_LOC("Failure\nExpected: (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\
-          ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1),  #var2, type##_TO_STR(var2));                                            \
+         ,#var1,STRFY(OP),#var2,#var1,  str_var1,  #var2, str_var2 );                                            \
+        free(str_var1); free(str_var2);\
         PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n",__func__);                                           \
        if(is_assert) return;                                                                                   \
       }                                                                                                         \
@@ -448,15 +472,19 @@ do{      \
        /*IFTESTPASS_ ;*/                                                         \
         if(verb==NORMAL){ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__);} \
         else if(verb==VERB){\
+        char *str_var1 = type##_TO_STR(var1) ,  *str_var2 = type##_TO_STR(var2);\
            PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__); \
            PRINT_LOC(" test passed : (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\
-          ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1),  #var2, type##_TO_STR(var2));                                            \
+          ,#var1,STRFY(OP),#var2,#var1,  str_var1,  #var2, str_var2 );                                            \
+        free(str_var1); free(str_var2);\
         }\
       }                                                                                                         \
       else{                                                                                                     \
        /*IFTESTFAIL_ ;*/                                                         \
+                char *str_var1 = type##_TO_STR(var1) ,  *str_var2 = type##_TO_STR(var2);\
         PRINT_LOC("Failure\nExpected: (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\
-          ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1),  #var2, type##_TO_STR(var2));                                            \
+         ,#var1,STRFY(OP),#var2,#var1,  str_var1,  #var2, str_var2 );                                            \
+        free(str_var1); free(str_var2);\
         PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n",__func__);                                           \
       }                                                                                                         \
    }else {                                                                                                         \
@@ -464,15 +492,19 @@ do{      \
        /*IFTESTPASS_(var1,var2) ; */                                                        \
         if(verb==NORMAL){ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__);} \
         else if(verb==VERB){\
+        char *str_var1 = type##_TO_STR(var1) ,  *str_var2 = type##_TO_STR(var2);\
            PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__); \
            PRINT_LOC(" test passed : (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\
-          ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1),  #var2, type##_TO_STR(var2));                                            \
+          ,#var1,STRFY(OP),#var2,#var1,  str_var1,  #var2, str_var2 );                                            \
+        free(str_var1); free(str_var2);\
         }\
       }                                                                                                         \
       else{                                                                                                     \
        /*IFTESTFAIL_(var1,var2) ; */                                                        \
+                char *str_var1 = type##_TO_STR(var1) ,  *str_var2 = type##_TO_STR(var2);\
         PRINT_LOC("Failure\nExpected: (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\
-          ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1),  #var2, type##_TO_STR(var2));                                            \
+         ,#var1,STRFY(OP),#var2,#var1,  str_var1,  #var2, str_var2 );                                            \
+        free(str_var1); free(str_var2);\
         PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n",__func__);                                           \
       }                                                                                                         \
     }\
@@ -485,15 +517,19 @@ do{      \
        /*IFTESTPASS_(var1,var2) ; */                                                        \
         if(verb==NORMAL){ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__);} \
         else if(verb==VERB){\
+        char *str_var1 = type##_TO_STR(var1) ,  *str_var2 = type##_TO_STR(var2);\
            PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__); \
            PRINT_LOC(" test passed : (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\
-          ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1),  #var2, type##_TO_STR(var2));                                            \
+          ,#var1,STRFY(OP),#var2,#var1,  str_var1,  #var2, str_var2 );                                            \
+        free(str_var1); free(str_var2);\
         }\
       }                                                                                                         \
       else{                                                                                                     \
        /*IFTESTFAIL_(var1,var2) ; */                                                        \
+                char *str_var1 = type##_TO_STR(var1) ,  *str_var2 = type##_TO_STR(var2);\
         PRINT_LOC("Failure\nExpected: (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\
-          ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1),  #var2, type##_TO_STR(var2));                                            \
+         ,#var1,STRFY(OP),#var2,#var1,  str_var1,  #var2, str_var2 );                                            \
+        free(str_var1); free(str_var2);\
         PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n",__func__);                                           \
         return;                                                                                   \
       }                                                                                                         \
@@ -502,15 +538,19 @@ do{      \
        /*IFTESTPASS_(var1,var2) ; */                                                        \
         if(verb==NORMAL){ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__);} \
         else if(verb==VERB){\
+        char *str_var1 = type##_TO_STR(var1) ,  *str_var2 = type##_TO_STR(var2);\
            PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__); \
            PRINT_LOC(" test passed : (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\
-          ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1),  #var2, type##_TO_STR(var2));                                            \
+          ,#var1,STRFY(OP),#var2,#var1,  str_var1,  #var2, str_var2 );                                            \
+        free(str_var1); free(str_var2);\
         }\
       }                                                                                                         \
       else{                                                                                                     \
        /*IFTESTFAIL_(var1,var2) ; */                                                        \
+                char *str_var1 = type##_TO_STR(var1) ,  *str_var2 = type##_TO_STR(var2);\
         PRINT_LOC("Failure\nExpected: (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\
-          ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1),  #var2, type##_TO_STR(var2));                                            \
+         ,#var1,STRFY(OP),#var2,#var1,  str_var1,  #var2, str_var2 );                                            \
+        free(str_var1); free(str_var2);\
         PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n",__func__);                                           \
         return;                                                                                   \
       }                                                                                                         \

ytest_t/include_ytest/include/ftest/ftest_array.h

@@ -17,17 +17,24 @@ do{      \
         else if(verb==VERB){\
           PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 %s passed %s \n\n",name_f,msg_call);\
           PRINT_LOC("test passed: (%s) %s (%s) \n\n",#var1,STRFY(OP),#var2);                                            \
-          for(size_t i=0; i < min(sz1,sz2);++i) \
+          for(size_t i=0; i < min(sz1,sz2);++i) {\
-            PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\
+              char *str_var1 = type##_TO_STR(var1[i]), *str_var2 = type##_TO_STR(var2[i]);\
-              ,#var1,i, type##_TO_STR(var1[i]),  #var2,i, type##_TO_STR(var2[i]));                                            \
+              PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\
+              ,#var1,i, str_var1,  #var2,i, str_var2);                                            \
+              free(str_var1); free(str_var2);\
+           }\
         }\
      \
       }                                                                                                         \
       else{                                                                                                     \
         PRINT_LOC("Failure\nExpected: (%s) %s (%s) \n\n",#var1,STRFY(OP),#var2);                                            \
         for(size_t i=0; i < min(sz1,sz2);++i)\
-          if (!(var1[i] OP var2[i])) PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\
+          if (!(COMPARE_N_##type((void*)(var1 + i),(void*)(var2 + i)) OP 0)) {\
-            ,#var1,i, type##_TO_STR(var1[i]),  #var2,i, type##_TO_STR(var2[i]));                                            \
+           char *str_var1 = type##_TO_STR(var1[i]), *str_var2 = type##_TO_STR(var2[i]);\
+           PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\
+            ,#var1,i, str_var1,  #var2,i, str_var2);                                            \
+           free(str_var1); free(str_var2);\
+          }\
         PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n",__func__);                                           \
                                                          \
    }else {                                                                                                         \
@@ -36,16 +43,23 @@ do{      \
         else if(verb==VERB){\
           PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 %s passed %s \n\n",name_f,msg_call);\
           PRINT_LOC("test passed: (%s) %s (%s) \n\n",#var1,STRFY(OP),#var2);                                            \
-          for(size_t i=0; i < min(sz1,sz2);++i) \
+          for(size_t i=0; i < min(sz1,sz2);++i) {\
-            PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\
+              char *str_var1 = type##_TO_STR(var1[i]), *str_var2 = type##_TO_STR(var2[i]);\
-              ,#var1,i, type##_TO_STR(var1[i]),  #var2,i, type##_TO_STR(var2[i]));                                            \
+              PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\
+              ,#var1,i, str_var1,  #var2,i, str_var2);                                            \
+              free(str_var1); free(str_var2);\
+           }\
         }\
       }                                                                                                         \
       else{                                                                                                     \
         PRINT_LOC("Failure\nExpected: (%s) %s (%s) \n\n",#var1,STRFY(OP),#var2);                                            \
         for(size_t i=0; i < min(sz1,sz2);++i)\
-          if (!(var1[i] OP var2[i])) PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\
+          if (!(COMPARE_N_##type((void*)(var1 + i),(void*)(var2 + i)) OP 0)) {\
-            ,#var1,i, type##_TO_STR(var1[i]),  #var2,i, type##_TO_STR(var2[i]));                                            \
+           char *str_var1 = type##_TO_STR(var1[i]), *str_var2 = type##_TO_STR(var2[i]);\
+           PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\
+            ,#var1,i, str_var1,  #var2,i, str_var2);                                            \
+           free(str_var1); free(str_var2);\
+          }\
         PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n",__func__);                                           \
       }                                                                                                         \
     }\
@@ -66,16 +80,23 @@ do{      \
         else if(verb==VERB){\
            PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__); \
           PRINT_LOC("test passed: (%s) %s (%s) \n\n",#var1,STRFY(OP),#var2);                                            \
-          for(size_t i=0; i < min(sz1,sz2);++i) \
+          for(size_t i=0; i < min(sz1,sz2);++i) {\
-            PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\
+              char *str_var1 = type##_TO_STR(var1[i]), *str_var2 = type##_TO_STR(var2[i]);\
-              ,#var1,i, type##_TO_STR(var1[i]),  #var2,i, type##_TO_STR(var2[i]));                                            \
+              PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\
+              ,#var1,i, str_var1,  #var2,i, str_var2);                                            \
+              free(str_var1); free(str_var2);\
+           }\
         }\
       }                                                                                                         \
       else{                                                                                                     \
         PRINT_LOC("Failure\nExpected: (%s) %s (%s) \n\n",#var1,STRFY(OP),#var2);                                            \
         for(size_t i=0; i < min(sz1,sz2);++i)\
-          if (!(var1[i] OP var2[i])) PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\
+          if (!(COMPARE_N_##type((void*)(var1 + i),(void*)(var2 + i)) OP 0)) {\
-            ,#var1,i, type##_TO_STR(var1[i]),  #var2,i, type##_TO_STR(var2[i]));                                            \
+           char *str_var1 = type##_TO_STR(var1[i]), *str_var2 = type##_TO_STR(var2[i]);\
+           PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\
+            ,#var1,i, str_var1,  #var2,i, str_var2);                                            \
+           free(str_var1); free(str_var2);\
+          }\
         PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n",__func__);                                           \
       }                                                                                                         \
    }else {                                                                                                         \
@@ -84,16 +105,23 @@ do{      \
         else if(verb==VERB){\
            PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__); \
           PRINT_LOC("test passed: (%s) %s (%s) \n\n",#var1,STRFY(OP),#var2);                                            \
-          for(size_t i=0; i < min(sz1,sz2);++i) \
+          for(size_t i=0; i < min(sz1,sz2);++i) {\
-            PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\
+              char *str_var1 = type##_TO_STR(var1[i]), *str_var2 = type##_TO_STR(var2[i]);\
-              ,#var1,i, type##_TO_STR(var1[i]),  #var2,i, type##_TO_STR(var2[i]));                                            \
+              PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\
+              ,#var1,i, str_var1,  #var2,i, str_var2);                                            \
+              free(str_var1); free(str_var2);\
+           }\
         }\
       }                                                                                                         \
       else{                                                                                                     \
         PRINT_LOC("Failure\nExpected: (%s) %s (%s) \n\n",#var1,STRFY(OP),#var2);                                            \
         for(size_t i=0; i < min(sz1,sz2);++i)\
-          if (!(var1[i] OP var2[i])) PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\
+          if (!(COMPARE_N_##type((void*)(var1 + i),(void*)(var2 + i)) OP 0)) {\
-            ,#var1,i, type##_TO_STR(var1[i]),  #var2,i, type##_TO_STR(var2[i]));                                            \
+           char *str_var1 = type##_TO_STR(var1[i]), *str_var2 = type##_TO_STR(var2[i]);\
+           PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\
+            ,#var1,i, str_var1,  #var2,i, str_var2);                                            \
+           free(str_var1); free(str_var2);\
+          }\
         PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n",__func__);                                           \
       }                                                                                                         \
     }\
@@ -107,16 +135,23 @@ do{      \
         else if(verb==VERB){\
            PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__); \
           PRINT_LOC("test passed: (%s) %s (%s) \n\n",#var1,STRFY(OP),#var2);                                            \
-          for(size_t i=0; i < min(sz1,sz2);++i) \
+          for(size_t i=0; i < min(sz1,sz2);++i) {\
-            PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\
+              char *str_var1 = type##_TO_STR(var1[i]), *str_var2 = type##_TO_STR(var2[i]);\
-              ,#var1,i, type##_TO_STR(var1[i]),  #var2,i, type##_TO_STR(var2[i]));                                            \
+              PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\
+              ,#var1,i, str_var1,  #var2,i, str_var2);                                            \
+              free(str_var1); free(str_var2);\
+           }\
         }\
       }                                                                                                         \
       else{                                                                                                     \
         PRINT_LOC("Failure\nExpected: (%s) %s (%s) \n\n",#var1,STRFY(OP),#var2);                                            \
         for(size_t i=0; i < min(sz1,sz2);++i)\
-          if (!(var1[i] OP var2[i])) PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\
+          if (!(COMPARE_N_##type((void*)(var1 + i),(void*)(var2 + i)) OP 0)) {\
-            ,#var1,i, type##_TO_STR(var1[i]),  #var2,i, type##_TO_STR(var2[i]));                                            \
+           char *str_var1 = type##_TO_STR(var1[i]), *str_var2 = type##_TO_STR(var2[i]);\
+           PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\
+            ,#var1,i, str_var1,  #var2,i, str_var2);                                            \
+           free(str_var1); free(str_var2);\
+          }\
         PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n",__func__);                                           \
         return;                                                                                   \
       }                                                                                                         \
@@ -126,16 +161,23 @@ do{      \
         else if(verb==VERB){\
            PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__); \
           PRINT_LOC("test passed: (%s) %s (%s) \n\n",#var1,STRFY(OP),#var2);                                            \
-          for(size_t i=0; i < min(sz1,sz2);++i) \
+          for(size_t i=0; i < min(sz1,sz2);++i) {\
-            PRINTF("Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\
+              char *str_var1 = type##_TO_STR(var1[i]), *str_var2 = type##_TO_STR(var2[i]);\
-              ,#var1,i, type##_TO_STR(var1[i]),  #var2,i, type##_TO_STR(var2[i]));                                            \
+              PRINTF("Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\
+              ,#var1,i, str_var1,  #var2,i, str_var2);                                            \
+              free(str_var1); free(str_var2);\
+           }\
         }\
       }                                                                                                         \
       else{                                                                                                     \
         PRINT_LOC("Failure\nExpected: (%s) %s (%s) \n\n",#var1,STRFY(OP),#var2);                                            \
         for(size_t i=0; i < min(sz1,sz2);++i)\
-          if (!(var1[i] OP var2[i])) PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\
+          if (!(COMPARE_N_##type((void*)(var1 + i),(void*)(var2 + i)) OP 0)) {\
-            ,#var1,i, type##_TO_STR(var1[i]),  #var2,i, type##_TO_STR(var2[i]));                                            \
+           char *str_var1 = type##_TO_STR(var1[i]), *str_var2 = type##_TO_STR(var2[i]);\
+           PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\
+            ,#var1,i, str_var1,  #var2,i, str_var2);                                            \
+           free(str_var1); free(str_var2);\
+          }\
         PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n",__func__);                                           \
         return;                                                                                   \
       }                                                                                                         \

ytest_t/include_ytest/include/tools_t/tools_t.h

@@ -23,8 +23,6 @@
   #define F_ERR stderr
 #endif
 
-
-
 /*
 #ifndef SECOND
   #define SECOND 0
@@ -38,6 +36,14 @@ double diff_timespec_milliseconds(struct timespec time_stop, struct timespec tim
 long diff_timespec_nanoseconds(struct timespec time_stop, struct timespec time_start);
 */
 
+#if 1
+
+extern long int PRECISION_TYPE_FLOAT ;
+extern long int PRECISION_TYPE_DOUBLE ;
+extern long int PRECISION_TYPE_L_DOUBLE ;
+
+#endif
+
 void gotoxy(int x, int y);
 //void get_cursor_position(int *col, int *rows);
 

ytest_t/test/is_good.c

@@ -56,7 +56,7 @@ TEST(){
 
 
 TEST(){
-  sleep(3);
+//  sleep(3);
   int a = 5;
   long b = 5;
   ASSERT_EQ(a,b);
@@ -66,7 +66,7 @@ TEST(){
 }
 
 TEST(expect){
-  sleep(2);
+//  sleep(2);
   int a = 5;
   int b = 6;
   EXPECT_EQ(a,b);
@@ -96,8 +96,11 @@ TEST(lessThan){
   EXPECT_LT(a,b);
   EXPECT_LT(b,a);
 
+  double da=0.1,db=0.2;
+  EXPECT_LT_TYPE_DOUBLE(da,db);
+  EXPECT_LT_TYPE_DOUBLE(db,da);
 }
-
+#if 0
 TEST(sleep){sleep(2);}
 TEST(sleep){sleep(2);}
 TEST(sleep){sleep(2);}
@@ -140,8 +143,10 @@ TEST(sleep){sleep(1);}
 TEST(sleep){sleep(1);}
 TEST(sleep){sleep(1);}
 TEST(sleep){sleep(1);}
+#endif
 
 
+#if 1
 MOCK_FUNC(int, f_mock, (), ())
   
 EXPECT_MOCK_CALL(int,f_mock, (),false, 2)  {
@@ -313,6 +318,7 @@ TEST(f7_mock_test){
   PRINTF("second call f7 : %d\n",v1);
 
 }
+#endif
 
 
 int main(int argc, char **argv){

ytest_t/yftest/include/ftest/ftest.h

@@ -317,17 +317,21 @@ GEN_EXPECTED_OP_TYPE_FUNC(NE, TYPE_STRING)
   do{ \
       if(verb==NORMAL){PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 %s passed %s \n\n",name_f,msg_call);}                                       \
       else if(verb==VERB){\
+        char *str_var1 = type##_TO_STR(var1) ,  *str_var2 = type##_TO_STR(var2);\
         PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 %s passed %s \n\n",name_f,msg_call);\
         PRINT_LOC("test passed : (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\
-        ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1),  #var2, type##_TO_STR(var2));                                            \
+        ,#var1,STRFY(OP),#var2,#var1,  str_var1,  #var2, str_var2 );                                            \
+        free(str_var1); free(str_var2);\
       }\
   }while(0);
 
 
 #define IFTESTFAIL_NAME(OP,type,var1,var2,name_f,msg_call) \
    do{\
-     PRINT_LOC("Failure\nExpected: (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\
+             char *str_var1 = type##_TO_STR(var1) ,  *str_var2 = type##_TO_STR(var2);\
-          ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1),  #var2, type##_TO_STR(var2));                                            \
+        PRINT_LOC("Failure\nExpected: (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\
+         ,#var1,STRFY(OP),#var2,#var1,  str_var1,  #var2, str_var2 );                                            \
+        free(str_var1); free(str_var2);\
      PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 %s failed %s \n",name_f,msg_call);  \
    }while(0);
 
@@ -338,16 +342,20 @@ do{      \
        /*IFTESTPASS_NAME(OP,type,var1,var2,name_f,msg_call);*/ \
         if(verb==NORMAL){PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 %s passed %s \n\n",name_f,msg_call);}                                       \
         else if(verb==VERB){\
+        char *str_var1 = type##_TO_STR(var1) ,  *str_var2 = type##_TO_STR(var2);\
           PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 %s passed %s \n\n",name_f,msg_call);\
           PRINT_LOC("test passed : (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\
-          ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1),  #var2, type##_TO_STR(var2));                                            \
+          ,#var1,STRFY(OP),#var2,#var1,  str_var1,  #var2, str_var2 );                                            \
+        free(str_var1); free(str_var2);\
         }\
      \
       }                                                                                                         \
       else{                                                                                                     \
        /*IFTESTFAIL_NAME(OP,type,var1,var2,name_f,msg_call);*/ \
-     PRINT_LOC("Failure\nExpected: (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\
+             char *str_var1 = type##_TO_STR(var1) ,  *str_var2 = type##_TO_STR(var2);\
-          ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1),  #var2, type##_TO_STR(var2));                                            \
+        PRINT_LOC("Failure\nExpected: (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\
+         ,#var1,STRFY(OP),#var2,#var1,  str_var1,  #var2, str_var2 );                                            \
+        free(str_var1); free(str_var2);\
      PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 %s failed %s \n",name_f,msg_call);  \
      }                                                      \
    } else {                                                                                                         \
@@ -355,15 +363,19 @@ do{      \
        /*IFTESTPASS_NAME(OP,type,var1,var2,name_f,msg_call);*/ \
         if(verb==NORMAL){PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 %s passed %s \n\n",name_f,msg_call);}                                       \
         else if(verb==VERB){\
+        char *str_var1 = type##_TO_STR(var1) ,  *str_var2 = type##_TO_STR(var2);\
           PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 %s passed %s \n\n",name_f,msg_call);\
           PRINT_LOC("test passed : (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\
-          ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1),  #var2, type##_TO_STR(var2));                                            \
+          ,#var1,STRFY(OP),#var2,#var1,  str_var1,  #var2, str_var2 );                                            \
+        free(str_var1); free(str_var2);\
         }\
       }                                                                                                         \
       else{                                                                                                     \
        /*IFTESTFAIL_NAME(OP,type,var1,var2,name_f,msg_call);*/ \
-     PRINT_LOC("Failure\nExpected: (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\
+             char *str_var1 = type##_TO_STR(var1) ,  *str_var2 = type##_TO_STR(var2);\
-          ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1),  #var2, type##_TO_STR(var2));                                            \
+        PRINT_LOC("Failure\nExpected: (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\
+         ,#var1,STRFY(OP),#var2,#var1,  str_var1,  #var2, str_var2 );                                            \
+        free(str_var1); free(str_var2);\
      PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 %s failed %s \n",name_f,msg_call);  \
       }                                                                                                         \
     }\
@@ -380,17 +392,21 @@ do{      \
   do{\
     if(verb==NORMAL){ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__);} \
     else if(verb==VERB){\
+        char *str_var1 = type##_TO_STR(var1) ,  *str_var2 = type##_TO_STR(var2);\
            PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__); \
            PRINT_LOC(" test passed : (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\
-          ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1),  #var2, type##_TO_STR(var2));                                            \
+          ,#var1,STRFY(OP),#var2,#var1,  str_var1,  #var2, str_var2 );                                            \
+        free(str_var1); free(str_var2);\
     }\
   }while(0);
 
  
 #define IFTESTFAIL_                                                          \
   do{\
+                char *str_var1 = type##_TO_STR(var1) ,  *str_var2 = type##_TO_STR(var2);\
         PRINT_LOC("Failure\nExpected: (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\
-          ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1),  #var2, type##_TO_STR(var2));                                            \
+         ,#var1,STRFY(OP),#var2,#var1,  str_var1,  #var2, str_var2 );                                            \
+        free(str_var1); free(str_var2);\
         PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n",__func__);                                           \
   }while(0);
 
@@ -403,16 +419,20 @@ do{      \
        /*IFTESTPASS_(var1,var2);*/                                                          \
         if(verb==NORMAL){ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__);} \
         else if(verb==VERB){\
+        char *str_var1 = type##_TO_STR(var1) ,  *str_var2 = type##_TO_STR(var2);\
            PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__); \
            PRINT_LOC(" test passed : (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\
-          ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1),  #var2, type##_TO_STR(var2));                                            \
+          ,#var1,STRFY(OP),#var2,#var1,  str_var1,  #var2, str_var2 );                                            \
+        free(str_var1); free(str_var2);\
         }\
                \
       }                                                                                                         \
       else{                                                                                                     \
        /*IFTESTFAIL_(var1,var2) ; */                                                        \
+                char *str_var1 = type##_TO_STR(var1) ,  *str_var2 = type##_TO_STR(var2);\
         PRINT_LOC("Failure\nExpected: (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\
-          ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1),  #var2, type##_TO_STR(var2));                                            \
+         ,#var1,STRFY(OP),#var2,#var1,  str_var1,  #var2, str_var2 );                                            \
+        free(str_var1); free(str_var2);\
         PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n",__func__);                                           \
         if(is_assert) return;                                                                                   \
       }                                                                                                         \
@@ -421,15 +441,19 @@ do{      \
        /*IFTESTPASS_(var1,var2) ; */                                                        \
         if(verb==NORMAL){ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__);} \
         else if(verb==VERB){\
+        char *str_var1 = type##_TO_STR(var1) ,  *str_var2 = type##_TO_STR(var2);\
            PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__); \
            PRINT_LOC(" test passed : (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\
-          ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1),  #var2, type##_TO_STR(var2));                                            \
+          ,#var1,STRFY(OP),#var2,#var1,  str_var1,  #var2, str_var2 );                                            \
+        free(str_var1); free(str_var2);\
         }\
       }                                                                                                         \
       else{                                                                                                     \
        /*IFTESTFAIL_(var1,var2) ;     */                                                    \
+                char *str_var1 = type##_TO_STR(var1) ,  *str_var2 = type##_TO_STR(var2);\
         PRINT_LOC("Failure\nExpected: (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\
-          ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1),  #var2, type##_TO_STR(var2));                                            \
+         ,#var1,STRFY(OP),#var2,#var1,  str_var1,  #var2, str_var2 );                                            \
+        free(str_var1); free(str_var2);\
         PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n",__func__);                                           \
        if(is_assert) return;                                                                                   \
       }                                                                                                         \
@@ -448,15 +472,19 @@ do{      \
        /*IFTESTPASS_ ;*/                                                         \
         if(verb==NORMAL){ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__);} \
         else if(verb==VERB){\
+        char *str_var1 = type##_TO_STR(var1) ,  *str_var2 = type##_TO_STR(var2);\
            PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__); \
            PRINT_LOC(" test passed : (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\
-          ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1),  #var2, type##_TO_STR(var2));                                            \
+          ,#var1,STRFY(OP),#var2,#var1,  str_var1,  #var2, str_var2 );                                            \
+        free(str_var1); free(str_var2);\
         }\
       }                                                                                                         \
       else{                                                                                                     \
        /*IFTESTFAIL_ ;*/                                                         \
+                char *str_var1 = type##_TO_STR(var1) ,  *str_var2 = type##_TO_STR(var2);\
         PRINT_LOC("Failure\nExpected: (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\
-          ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1),  #var2, type##_TO_STR(var2));                                            \
+         ,#var1,STRFY(OP),#var2,#var1,  str_var1,  #var2, str_var2 );                                            \
+        free(str_var1); free(str_var2);\
         PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n",__func__);                                           \
       }                                                                                                         \
    }else {                                                                                                         \
@@ -464,15 +492,19 @@ do{      \
        /*IFTESTPASS_(var1,var2) ; */                                                        \
         if(verb==NORMAL){ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__);} \
         else if(verb==VERB){\
+        char *str_var1 = type##_TO_STR(var1) ,  *str_var2 = type##_TO_STR(var2);\
            PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__); \
            PRINT_LOC(" test passed : (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\
-          ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1),  #var2, type##_TO_STR(var2));                                            \
+          ,#var1,STRFY(OP),#var2,#var1,  str_var1,  #var2, str_var2 );                                            \
+        free(str_var1); free(str_var2);\
         }\
       }                                                                                                         \
       else{                                                                                                     \
        /*IFTESTFAIL_(var1,var2) ; */                                                        \
+                char *str_var1 = type##_TO_STR(var1) ,  *str_var2 = type##_TO_STR(var2);\
         PRINT_LOC("Failure\nExpected: (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\
-          ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1),  #var2, type##_TO_STR(var2));                                            \
+         ,#var1,STRFY(OP),#var2,#var1,  str_var1,  #var2, str_var2 );                                            \
+        free(str_var1); free(str_var2);\
         PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n",__func__);                                           \
       }                                                                                                         \
     }\
@@ -485,15 +517,19 @@ do{      \
        /*IFTESTPASS_(var1,var2) ; */                                                        \
         if(verb==NORMAL){ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__);} \
         else if(verb==VERB){\
+        char *str_var1 = type##_TO_STR(var1) ,  *str_var2 = type##_TO_STR(var2);\
            PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__); \
            PRINT_LOC(" test passed : (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\
-          ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1),  #var2, type##_TO_STR(var2));                                            \
+          ,#var1,STRFY(OP),#var2,#var1,  str_var1,  #var2, str_var2 );                                            \
+        free(str_var1); free(str_var2);\
         }\
       }                                                                                                         \
       else{                                                                                                     \
        /*IFTESTFAIL_(var1,var2) ; */                                                        \
+                char *str_var1 = type##_TO_STR(var1) ,  *str_var2 = type##_TO_STR(var2);\
         PRINT_LOC("Failure\nExpected: (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\
-          ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1),  #var2, type##_TO_STR(var2));                                            \
+         ,#var1,STRFY(OP),#var2,#var1,  str_var1,  #var2, str_var2 );                                            \
+        free(str_var1); free(str_var2);\
         PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n",__func__);                                           \
         return;                                                                                   \
       }                                                                                                         \
@@ -502,15 +538,19 @@ do{      \
        /*IFTESTPASS_(var1,var2) ; */                                                        \
         if(verb==NORMAL){ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__);} \
         else if(verb==VERB){\
+        char *str_var1 = type##_TO_STR(var1) ,  *str_var2 = type##_TO_STR(var2);\
            PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__); \
            PRINT_LOC(" test passed : (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\
-          ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1),  #var2, type##_TO_STR(var2));                                            \
+          ,#var1,STRFY(OP),#var2,#var1,  str_var1,  #var2, str_var2 );                                            \
+        free(str_var1); free(str_var2);\
         }\
       }                                                                                                         \
       else{                                                                                                     \
        /*IFTESTFAIL_(var1,var2) ; */                                                        \
+                char *str_var1 = type##_TO_STR(var1) ,  *str_var2 = type##_TO_STR(var2);\
         PRINT_LOC("Failure\nExpected: (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\
-          ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1),  #var2, type##_TO_STR(var2));                                            \
+         ,#var1,STRFY(OP),#var2,#var1,  str_var1,  #var2, str_var2 );                                            \
+        free(str_var1); free(str_var2);\
         PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n",__func__);                                           \
         return;                                                                                   \
       }                                                                                                         \

ytest_t/yftest/include/ftest/ftest_array.h

@@ -17,17 +17,24 @@ do{      \
         else if(verb==VERB){\
           PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 %s passed %s \n\n",name_f,msg_call);\
           PRINT_LOC("test passed: (%s) %s (%s) \n\n",#var1,STRFY(OP),#var2);                                            \
-          for(size_t i=0; i < min(sz1,sz2);++i) \
+          for(size_t i=0; i < min(sz1,sz2);++i) {\
-            PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\
+              char *str_var1 = type##_TO_STR(var1[i]), *str_var2 = type##_TO_STR(var2[i]);\
-              ,#var1,i, type##_TO_STR(var1[i]),  #var2,i, type##_TO_STR(var2[i]));                                            \
+              PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\
+              ,#var1,i, str_var1,  #var2,i, str_var2);                                            \
+              free(str_var1); free(str_var2);\
+           }\
         }\
      \
       }                                                                                                         \
       else{                                                                                                     \
         PRINT_LOC("Failure\nExpected: (%s) %s (%s) \n\n",#var1,STRFY(OP),#var2);                                            \
         for(size_t i=0; i < min(sz1,sz2);++i)\
-          if (!(var1[i] OP var2[i])) PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\
+          if (!(COMPARE_N_##type((void*)(var1 + i),(void*)(var2 + i)) OP 0)) {\
-            ,#var1,i, type##_TO_STR(var1[i]),  #var2,i, type##_TO_STR(var2[i]));                                            \
+           char *str_var1 = type##_TO_STR(var1[i]), *str_var2 = type##_TO_STR(var2[i]);\
+           PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\
+            ,#var1,i, str_var1,  #var2,i, str_var2);                                            \
+           free(str_var1); free(str_var2);\
+          }\
         PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n",__func__);                                           \
                                                          \
    }else {                                                                                                         \
@@ -36,16 +43,23 @@ do{      \
         else if(verb==VERB){\
           PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 %s passed %s \n\n",name_f,msg_call);\
           PRINT_LOC("test passed: (%s) %s (%s) \n\n",#var1,STRFY(OP),#var2);                                            \
-          for(size_t i=0; i < min(sz1,sz2);++i) \
+          for(size_t i=0; i < min(sz1,sz2);++i) {\
-            PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\
+              char *str_var1 = type##_TO_STR(var1[i]), *str_var2 = type##_TO_STR(var2[i]);\
-              ,#var1,i, type##_TO_STR(var1[i]),  #var2,i, type##_TO_STR(var2[i]));                                            \
+              PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\
+              ,#var1,i, str_var1,  #var2,i, str_var2);                                            \
+              free(str_var1); free(str_var2);\
+           }\
         }\
       }                                                                                                         \
       else{                                                                                                     \
         PRINT_LOC("Failure\nExpected: (%s) %s (%s) \n\n",#var1,STRFY(OP),#var2);                                            \
         for(size_t i=0; i < min(sz1,sz2);++i)\
-          if (!(var1[i] OP var2[i])) PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\
+          if (!(COMPARE_N_##type((void*)(var1 + i),(void*)(var2 + i)) OP 0)) {\
-            ,#var1,i, type##_TO_STR(var1[i]),  #var2,i, type##_TO_STR(var2[i]));                                            \
+           char *str_var1 = type##_TO_STR(var1[i]), *str_var2 = type##_TO_STR(var2[i]);\
+           PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\
+            ,#var1,i, str_var1,  #var2,i, str_var2);                                            \
+           free(str_var1); free(str_var2);\
+          }\
         PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n",__func__);                                           \
       }                                                                                                         \
     }\
@@ -66,16 +80,23 @@ do{      \
         else if(verb==VERB){\
            PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__); \
           PRINT_LOC("test passed: (%s) %s (%s) \n\n",#var1,STRFY(OP),#var2);                                            \
-          for(size_t i=0; i < min(sz1,sz2);++i) \
+          for(size_t i=0; i < min(sz1,sz2);++i) {\
-            PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\
+              char *str_var1 = type##_TO_STR(var1[i]), *str_var2 = type##_TO_STR(var2[i]);\
-              ,#var1,i, type##_TO_STR(var1[i]),  #var2,i, type##_TO_STR(var2[i]));                                            \
+              PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\
+              ,#var1,i, str_var1,  #var2,i, str_var2);                                            \
+              free(str_var1); free(str_var2);\
+           }\
         }\
       }                                                                                                         \
       else{                                                                                                     \
         PRINT_LOC("Failure\nExpected: (%s) %s (%s) \n\n",#var1,STRFY(OP),#var2);                                            \
         for(size_t i=0; i < min(sz1,sz2);++i)\
-          if (!(var1[i] OP var2[i])) PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\
+          if (!(COMPARE_N_##type((void*)(var1 + i),(void*)(var2 + i)) OP 0)) {\
-            ,#var1,i, type##_TO_STR(var1[i]),  #var2,i, type##_TO_STR(var2[i]));                                            \
+           char *str_var1 = type##_TO_STR(var1[i]), *str_var2 = type##_TO_STR(var2[i]);\
+           PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\
+            ,#var1,i, str_var1,  #var2,i, str_var2);                                            \
+           free(str_var1); free(str_var2);\
+          }\
         PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n",__func__);                                           \
       }                                                                                                         \
    }else {                                                                                                         \
@@ -84,16 +105,23 @@ do{      \
         else if(verb==VERB){\
            PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__); \
           PRINT_LOC("test passed: (%s) %s (%s) \n\n",#var1,STRFY(OP),#var2);                                            \
-          for(size_t i=0; i < min(sz1,sz2);++i) \
+          for(size_t i=0; i < min(sz1,sz2);++i) {\
-            PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\
+              char *str_var1 = type##_TO_STR(var1[i]), *str_var2 = type##_TO_STR(var2[i]);\
-              ,#var1,i, type##_TO_STR(var1[i]),  #var2,i, type##_TO_STR(var2[i]));                                            \
+              PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\
+              ,#var1,i, str_var1,  #var2,i, str_var2);                                            \
+              free(str_var1); free(str_var2);\
+           }\
         }\
       }                                                                                                         \
       else{                                                                                                     \
         PRINT_LOC("Failure\nExpected: (%s) %s (%s) \n\n",#var1,STRFY(OP),#var2);                                            \
         for(size_t i=0; i < min(sz1,sz2);++i)\
-          if (!(var1[i] OP var2[i])) PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\
+          if (!(COMPARE_N_##type((void*)(var1 + i),(void*)(var2 + i)) OP 0)) {\
-            ,#var1,i, type##_TO_STR(var1[i]),  #var2,i, type##_TO_STR(var2[i]));                                            \
+           char *str_var1 = type##_TO_STR(var1[i]), *str_var2 = type##_TO_STR(var2[i]);\
+           PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\
+            ,#var1,i, str_var1,  #var2,i, str_var2);                                            \
+           free(str_var1); free(str_var2);\
+          }\
         PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n",__func__);                                           \
       }                                                                                                         \
     }\
@@ -107,16 +135,23 @@ do{      \
         else if(verb==VERB){\
            PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__); \
           PRINT_LOC("test passed: (%s) %s (%s) \n\n",#var1,STRFY(OP),#var2);                                            \
-          for(size_t i=0; i < min(sz1,sz2);++i) \
+          for(size_t i=0; i < min(sz1,sz2);++i) {\
-            PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\
+              char *str_var1 = type##_TO_STR(var1[i]), *str_var2 = type##_TO_STR(var2[i]);\
-              ,#var1,i, type##_TO_STR(var1[i]),  #var2,i, type##_TO_STR(var2[i]));                                            \
+              PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\
+              ,#var1,i, str_var1,  #var2,i, str_var2);                                            \
+              free(str_var1); free(str_var2);\
+           }\
         }\
       }                                                                                                         \
       else{                                                                                                     \
         PRINT_LOC("Failure\nExpected: (%s) %s (%s) \n\n",#var1,STRFY(OP),#var2);                                            \
         for(size_t i=0; i < min(sz1,sz2);++i)\
-          if (!(var1[i] OP var2[i])) PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\
+          if (!(COMPARE_N_##type((void*)(var1 + i),(void*)(var2 + i)) OP 0)) {\
-            ,#var1,i, type##_TO_STR(var1[i]),  #var2,i, type##_TO_STR(var2[i]));                                            \
+           char *str_var1 = type##_TO_STR(var1[i]), *str_var2 = type##_TO_STR(var2[i]);\
+           PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\
+            ,#var1,i, str_var1,  #var2,i, str_var2);                                            \
+           free(str_var1); free(str_var2);\
+          }\
         PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n",__func__);                                           \
         return;                                                                                   \
       }                                                                                                         \
@@ -126,16 +161,23 @@ do{      \
         else if(verb==VERB){\
            PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__); \
           PRINT_LOC("test passed: (%s) %s (%s) \n\n",#var1,STRFY(OP),#var2);                                            \
-          for(size_t i=0; i < min(sz1,sz2);++i) \
+          for(size_t i=0; i < min(sz1,sz2);++i) {\
-            PRINTF("Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\
+              char *str_var1 = type##_TO_STR(var1[i]), *str_var2 = type##_TO_STR(var2[i]);\
-              ,#var1,i, type##_TO_STR(var1[i]),  #var2,i, type##_TO_STR(var2[i]));                                            \
+              PRINTF("Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\
+              ,#var1,i, str_var1,  #var2,i, str_var2);                                            \
+              free(str_var1); free(str_var2);\
+           }\
         }\
       }                                                                                                         \
       else{                                                                                                     \
         PRINT_LOC("Failure\nExpected: (%s) %s (%s) \n\n",#var1,STRFY(OP),#var2);                                            \
         for(size_t i=0; i < min(sz1,sz2);++i)\
-          if (!(var1[i] OP var2[i])) PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\
+          if (!(COMPARE_N_##type((void*)(var1 + i),(void*)(var2 + i)) OP 0)) {\
-            ,#var1,i, type##_TO_STR(var1[i]),  #var2,i, type##_TO_STR(var2[i]));                                            \
+           char *str_var1 = type##_TO_STR(var1[i]), *str_var2 = type##_TO_STR(var2[i]);\
+           PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\
+            ,#var1,i, str_var1,  #var2,i, str_var2);                                            \
+           free(str_var1); free(str_var2);\
+          }\
         PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n",__func__);                                           \
         return;                                                                                   \
       }                                                                                                         \

ytest_t/yftest/src/ftest/ftest.c

@@ -34,6 +34,7 @@ struct failed_lists{
   char *name;
   struct failed_lists *next;
 };
+void clear_all_falied_list(struct failed_lists **flist);
 
 #define default_ordered 0
 #define default_unicolour 0
@@ -188,7 +189,7 @@ void append_failed_list(struct failed_lists **fn_failed_list ,const char *name_f
       tmp_failed_l = tmp_failed_l->next; 
     }
     tmp_failed_l = malloc(sizeof(struct failed_lists));
-    tmp_failed_l->name = malloc(strlen(name_failed));
+    tmp_failed_l->name = malloc(strlen(name_failed)+1);
     strcpy(tmp_failed_l->name, name_failed);
     tmp_failed_l->next = NULL;
     rec_tmp->next = tmp_failed_l;
@@ -196,7 +197,7 @@ void append_failed_list(struct failed_lists **fn_failed_list ,const char *name_f
   }
   else{
     *fn_failed_list = malloc(sizeof(struct failed_lists));
-    (*fn_failed_list)->name = malloc(strlen(name_failed));
+    (*fn_failed_list)->name = malloc(strlen(name_failed)+1);
     strcpy((*fn_failed_list)->name, name_failed);
     (*fn_failed_list)->next = NULL;
   }
@@ -240,7 +241,7 @@ size_t extract_num__f(const char *name_f){
  /* TEST_funcname___NUM -> TEST(funcname) */
 char* extract_func_edited_TEST_from_exec_func_name(char* func_name){
   size_t len=strlen(func_name);
-  char *ret_name=malloc(len);
+  char *ret_name=malloc(len+1);
   strcpy(ret_name, func_name);
   char *pad="____";
   size_t len_pad=strlen(pad); 
@@ -266,15 +267,17 @@ void setup_variables_before_exec(){
     size_t len_bp = strlen(bar_progress);
     size_t len_db = strlen(default_bar_progress);
     if( len_bp >= len_db ){
-      char *tmp_bp=malloc(len_bp);
+      char *tmp_bp=malloc(len_bp+1);
       strcpy(tmp_bp,bar_progress);  
       tmp_bp[2]='u';
+      free(bar_progress);
       bar_progress=tmp_bp;
     }
     else{
       char *tmp_bp=malloc(len_bp);
       strcpy(tmp_bp,default_bar_progress);  
       tmp_bp[2]='u';
+      free(default_bar_progress);
       default_bar_progress=tmp_bp;
     }
   }
@@ -569,7 +572,7 @@ void extract_to_array_TYPE_STRING(char * in_str){
       val[cur_val++]='\0';
 
       PRINT_DEBUG("val_str=(((%s) cur_val=[%ld]\n",val,cur_val);
-      array_TYPE_STRING[cur_array_TYPE_STRING]=malloc(strlen(val));
+      array_TYPE_STRING[cur_array_TYPE_STRING]=malloc(strlen(val)+1);
       strcpy(array_TYPE_STRING[cur_array_TYPE_STRING++],val);
       cur_val=0;
     }
@@ -578,10 +581,11 @@ void extract_to_array_TYPE_STRING(char * in_str){
       val[cur_val++]='\0';
       PRINT_DEBUG("val_str=(%s) cur_val=[%ld]\n",val,cur_val);
    
-      array_TYPE_STRING[cur_array_TYPE_STRING]=malloc(strlen(val));
+      array_TYPE_STRING[cur_array_TYPE_STRING]=malloc(strlen(val)+1);
       strcpy(array_TYPE_STRING[cur_array_TYPE_STRING++],val);
 
   }
+  free(val);
 }
 
 
@@ -736,17 +740,18 @@ bool expected_##OP##_name_##type(type var1, type var2,const char * name){
 }\
 bool expected_array_##OP##_##type(type *var1, long int sz1, type *var2, long int sz2){                                            \
   if(sz1 OP sz2){\
-    size_t count=0;\
     if(sz1 == sz2){\
+      size_t count_ = 0;\
       for(size_t i=0;i<sz1;++i){\
-        if(COMPARE_N_##type(&var1[i], &var2[i]) OP 0)\
+        /*if(COMPARE_N_##type((void*)&var1[i],(void*)&var2[i]) OP 0)\
-          ++count;\
+        */if(COMPARE_N_##type((void*)(var1 + i),(void*)(var2 + i)) OP 0)\
+          ++count_;\
         else{ \
           INCREMENT(count_fail_local); /*++count_fail_local*/                                                                 \
           return false;\
         }\
       }\
-      if(count==sz1){                                                \
+      if(count_ == sz1){                                                \
         INCREMENT(count_pass_local); /*++count_pass_local*/                                                                 \
         return true;                                                                          \
       }\
@@ -761,17 +766,17 @@ bool expected_array_##OP##_##type(type *var1, long int sz1, type *var2, long int
 } \
 bool expected_array_##OP##_name_##type(type *var1, long int sz1, type *var2, long int sz2, const char * name){                                            \
   if(sz1 OP sz2){\
-    size_t count=0;\
     if(sz1 == sz2){\
+      size_t count_=0;\
       for(size_t i=0;i<sz1;++i){\
-        if(COMPARE_N_##type(&var1[i], &var2[i]) OP 0)\
+        if(COMPARE_N_##type((void*)&var1[i], (void*)&var2[i]) OP 0)\
-          ++count;\
+          ++count_;\
         else {\
           INCREMENT_EXPECT(fail,name);\
           return false;\
         }\
       }\
-      if(count==sz1){                                                \
+      if(count_ == sz1){                                                \
         INCREMENT_EXPECT(pass,name);\
         return true;                                                                          \
       }\
@@ -922,7 +927,7 @@ append_func(void (*run)(void), char *name){
   if(f_beging == NULL){
     f_beging = malloc(sizeof(struct func));
     f_static = f_beging;
-    f_static->name = malloc(strlen(name));
+    f_static->name = malloc(strlen(name)+1);
     strcpy(f_static->name,name);
     f_static->run = run;
     f_static->next = NULL;
@@ -930,7 +935,7 @@ append_func(void (*run)(void), char *name){
   else{
     struct func *tmp = malloc(sizeof(struct func));
     tmp->run = run;
-    tmp->name = malloc(strlen(name));
+    tmp->name = malloc(strlen(name)+1);
     strcpy(tmp->name,name);
     tmp->next = NULL;
     f_static->next = tmp;
@@ -1002,7 +1007,10 @@ stat_end_run(size_t ntst, struct timespec start_t){
 bool is_in_array_##type(type *array, type val){\
   bool found = false;\
   for(size_t i = 0; i < cur_array_##type; ++i){\
-    PRINT_DEBUG("compare |%s| in array and val: |%s|\n",type##_TO_STR(array[i]), type##_TO_STR(val));\
+    /*char * strarr = type##_TO_STR(array[i]), *strval = type##_TO_STR(val);\
+    PRINT_DEBUG("compare |%s| in array and val: |%s|\n",strarr, strval);\
+    free(strarr);free(strval);\
+    */PRINT_DEBUG("compare |%s| in array and val: |%s|\n",type##_TO_STR(array[i]), type##_TO_STR(val));\
     if(COMPARE_N_##type((void*)(array[i]),(void*)val  ) == 0 ){\
       found = true;\
       break;\
@@ -1016,6 +1024,9 @@ bool is_in_array_##type(type *array, type val){\
 bool is_in_array_##type(type *array, type val){\
   bool found = false;\
   for(size_t i = 0; i < cur_array_##type; ++i){\
+    /*char * strarr = type##_TO_STR(array[i]), *strval = type##_TO_STR(val);\
+    PRINT_DEBUG("compare |%s| in array and val: |%s|\n",strarr, strval);\
+    free(strarr);free(strval);*/\
     PRINT_DEBUG("compare |%s| in array and val: |%s|\n",type##_TO_STR(array[i]), type##_TO_STR(val));\
     if(COMPARE_N_##type((void*)(&array[i]),(void*)&val  ) == 0 ){\
       found = true;\
@@ -1036,7 +1047,7 @@ GEN_IS_IN_ARRAY_NUM(TYPE_SIZE_T)
 void extract_name_test_from_name(char *name_org, char **name_f){
   size_t len=strlen(name_org); 
   long cur=-1;
-  char *name_test=malloc(len);
+  char *name_test=malloc(len+1);
   for(size_t i=0; i<len; ++i){
     if(cur == -1 && name_org[i]=='(')
       cur=0;
@@ -1092,6 +1103,7 @@ void execute_all(struct func *fun){
   current_fn = tmp;
 }
 
+void _purge_t();
 
 void
 run_all_tests()
@@ -1111,6 +1123,9 @@ run_all_tests()
 
    if(progress)  pthread_join(thrd_progress, NULL);
 
+ #if 0
+  _purge_t();
+#endif
 }
 
 /*
@@ -1321,6 +1336,9 @@ final_parallel_test_()
   free(count_pass_thread);
   free(count_fail_thread);
 
+  for(size_t i=0; i< parallel_nb; ++i)
+    clear_all_falied_list(&thread_test_failed_l[i]);
+
   free(thread_test_failed_l);
 
   
@@ -1364,8 +1382,11 @@ final_parallel_test_()
     for(size_t i=0; i<=parallel_nb; ++i){
       remove(log_name_file_thrd[i]);
       PRINT_DEBUG("file log of treard[%ld] removed\n",i);
+      free(log_name_file_thrd[i]);
     }
+    free(log_name_file_thrd);
   }
+  
 
 }
 
@@ -1406,6 +1427,10 @@ if(progress)  pthread_join(thrd_progress, NULL);
   free(thrd);
   
   final_parallel_test_();
+
+#if 0
+  _purge_t();
+#endif
 }
 
 void run_all_tests_args(int argc, char **argv){
@@ -1417,27 +1442,84 @@ void run_all_tests_args(int argc, char **argv){
   if(is_parallel_nb) run_all_tests_parallel(parallel_nb);
   else run_all_tests();
 }
-
 void 
 clear_all_func(struct func **fun)
 {
-  struct func *tmp = *fun, *ttmp;
+  if(*fun){
-  while(tmp != NULL){
+    struct func *tmp = *fun, *ttmp;
-    ttmp = tmp;
+    while(tmp != NULL){
-    tmp = tmp->next;
+      free(tmp->name);
-    free(ttmp);
+      ttmp = tmp;
+      tmp = tmp->next;
+      free(ttmp);
+    }
+    *fun=NULL;
+  }
+}
+void 
+clear_all_falied_list(struct failed_lists **flist)
+{
+  if(*flist){
+    struct failed_lists *tmp = *flist, *ttmp;
+    while(tmp != NULL){
+      free(tmp->name);
+
+      ttmp = tmp;
+      tmp = tmp->next;
+      free(ttmp);
+    }
+    *flist=NULL;
   }
 }
 /*
  * to purge func list!
  * optionnal but good practice
  */
+void
+_purge_t()
+{
+  
+ #if 0
+  clear_all_func(&f_beging);
+  clear_all_falied_list(&failed_l);
+
+#endif 
+  if(array_TYPE_SIZE_T){
+    free(array_TYPE_SIZE_T);
+    array_TYPE_SIZE_T = NULL;
+  }
+  if(array_TYPE_STRING) {
+    for(int i=0; i< cur_array_TYPE_STRING; ++i){
+      free(array_TYPE_STRING[i]);
+    }
+    free(array_TYPE_STRING);
+    array_TYPE_STRING = NULL;
+  }
+
+  PRINT_DEBUG("%s\n","_purge_t done ");
+}
+
+
+
 __attribute__((destructor)) 
 void
 purge_tests()
 {
-  struct func *tmp = f_beging;
+
-  clear_all_func(&tmp); 
+ #if 1
+  clear_all_func(&f_beging);
+  clear_all_falied_list(&failed_l);
+#endif
+  if(array_TYPE_SIZE_T){
+    free(array_TYPE_SIZE_T);
+  }
+  if(array_TYPE_STRING) {
+    for(int i=0; i< cur_array_TYPE_STRING; ++i){
+      free(array_TYPE_STRING[i]);
+    }
+    free(array_TYPE_STRING);
+  }
+
   PRINT_DEBUG("%s\n","purge done");
   
 }

ytools_t/include/tools_t/tools_t.h

@@ -23,8 +23,6 @@
   #define F_ERR stderr
 #endif
 
-
-
 /*
 #ifndef SECOND
   #define SECOND 0
@@ -38,6 +36,14 @@ double diff_timespec_milliseconds(struct timespec time_stop, struct timespec tim
 long diff_timespec_nanoseconds(struct timespec time_stop, struct timespec time_start);
 */
 
+#if 1
+
+extern long int PRECISION_TYPE_FLOAT ;
+extern long int PRECISION_TYPE_DOUBLE ;
+extern long int PRECISION_TYPE_L_DOUBLE ;
+
+#endif
+
 void gotoxy(int x, int y);
 //void get_cursor_position(int *col, int *rows);
 

ytools_t/src/tools_t/tools_t.c

@@ -1,11 +1,13 @@
 #include "tools_t/tools_t.h"
 
 
+
 void gotoxy(int x, int y)
 {
     printf("%c[%d;%df", 0x1B, y, x);
 }
 
+
 /*
 void get_cursor_position(int *col, int *rows)
 {
@@ -48,9 +50,10 @@ long diff_timespec_nanoseconds(struct timespec time_stop, struct timespec time_s
 #define GEN_TO_STR_N(type,size,format)  \
   TYPE_STRING type##_TO_STR(type var){  \
     char *ret = malloc(size);                     \
-    sprintf(ret,format,var);            \
+    int szret = sprintf(ret,format,var);            \
-    ret[strlen(ret)]='\0';              \
+    ret[szret]='\0';              \
-    return ret; }
+    return ret;                         \
+  }\
 
 GEN_TO_STR_N(TYPE_CHAR,2,"%c")
 GEN_TO_STR_N(TYPE_U_CHAR,2,"%c")
@@ -67,6 +70,8 @@ TYPE_STRING TYPE_STRING_TO_STR(TYPE_STRING var){
   return var;
 }
 
+#if 0
+
 #define PRECISION_TYPE_CHAR 1
 #define PRECISION_TYPE_U_CHAR 1
 #define PRECISION_TYPE_INT 1
@@ -77,22 +82,44 @@ TYPE_STRING TYPE_STRING_TO_STR(TYPE_STRING var){
 
 // with gcc we can change value of theses  PRECISION_TYPES below with: gcc -D PRECISION_TYPE_FLOAT=100000 for instance!
 #ifndef PRECISION_TYPE_FLOAT 
-  /*#define PRECISION_TYPE_FLOAT 100000000*/
+  #define PRECISION_TYPE_FLOAT 100000000
-  #define PRECISION_TYPE_FLOAT 10
+  /*#define PRECISION_TYPE_FLOAT 10*/
 #endif
 #ifndef PRECISION_TYPE_DOUBLE
-  /*#define PRECISION_TYPE_DOUBLE 100000000000*/
+  #define PRECISION_TYPE_DOUBLE 100000000000
-  #define PRECISION_TYPE_DOUBLE 1000
+  /*#define PRECISION_TYPE_DOUBLE 1000*/
 #endif
 #ifndef PRECISION_TYPE_L_DOUBLE
   #define PRECISION_TYPE_L_DOUBLE 100000000000000
 #endif
 
+#endif
+
+#if 1
+
+long int PRECISION_TYPE_CHAR  = 1;
+long int PRECISION_TYPE_U_CHAR  = 1;
+long int PRECISION_TYPE_INT  = 1;
+long int PRECISION_TYPE_U_INT  = 1;
+long int PRECISION_TYPE_L_INT  = 1;
+long int PRECISION_TYPE_U_L_INT  = 1;
+long int PRECISION_TYPE_SIZE_T  = 1;
+
+long int PRECISION_TYPE_FLOAT  = 100000000;
+long int PRECISION_TYPE_DOUBLE  = 100000000000;
+long int PRECISION_TYPE_L_DOUBLE  = 100000000000000;
+
+#endif
+
+
+
 #define GENERATE_FUNCTION_NUMERIC(type)\
   int COMPARE_N_##type(const void *a, const  void *b){              \
-    type diff = (*(type*)a - *(type*)b)*PRECISION_##type;           \
+    type diff = (*(type*)a - *(type*)b) * PRECISION_##type;           \
-    PRINT_DEBUG_(" diff = %s a=%s b=%s \n",type##_TO_STR(diff),type##_TO_STR(*(type*)a), type##_TO_STR(*(type*)b));\
+    /*char *str_diff = type##_TO_STR(diff), *str_a = type##_TO_STR(*(type*)a), *str_b = type##_TO_STR(*(type*)b);\
-    if ((diff < 1) && (diff > -1) ) return 0;                       \
+    PRINT_DEBUG_(" diff = %s a=%s b=%s PRECISION : %ld\n",str_diff, str_a, str_b, PRECISION_##type);\
+    free(str_diff); free(str_a); free(str_b);\
+    */if ((diff < 1) && (diff > -1) ) return 0;                       \
     return diff;                                                    \
   }                                                                 \
                                                                     \