diff --git a/dimension_t/src/dimension_t/dimension_t.c b/dimension_t/src/dimension_t/dimension_t.c index cf2e339..adf6e7c 100644 --- a/dimension_t/src/dimension_t/dimension_t.c +++ b/dimension_t/src/dimension_t/dimension_t.c @@ -9,27 +9,63 @@ bool isGreatThan(long int a, long int b) { return a > b; } 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 = INIT_PERMUTATION_TYPE_SIZE_T(t,sz); + updateRankDim(d); + return d; +} dimension * create_dim(size_t sz){ return CREATE_PERMUTATION_TYPE_SIZE_T(sz); } +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); +} + +void min_dimension(dimension **d, dimension *d0, dimension *d1) { + if (d0->size > d1->size) { + *d = d1; + } + else if (d0->size < d1->size) { + *d = d0; + } + else { // d0->size = d1->size + *d = d0; + for (size_t i = 0; i < d0->size; i++) { + if (d0->perm[i] > d1->perm[i]) (*d)->perm[i] = d1->perm[i]; + } + } + updateRankDim(*d); +} + +void printDebug_dimension(dimension *d,char *msg){ + + printf("%s / dim->size = %ld | dim->rank = %ld \n",msg,d->size,d->rank); + for(size_t i=0; isize; ++i) + printf("[%ld: %ld] |", i,d->perm[i]); + printf("\n"); +} + void updateRankDim(dimension *dim){ dim->rank=1; for(size_t i=0; isize; ++i) dim->rank *=dim->perm[i]; } -size_t LineFromCoord(size_t *coo, dimension dim){ +size_t LineFromCoord(size_t *coo, dimension *dim){ long int begin = 0; - long int end = dim.size - 1; + long int end = dim->size - 1; long int (*iter)(long int); iter = &incr; bool (*cond)(long int, long int); cond = &isLessEqThan; if (endian) { - begin = dim.size - 1; end = 0; + begin = dim->size - 1; end = 0; iter = &decr; cond = &isGreatEqThan; } @@ -37,38 +73,40 @@ size_t LineFromCoord(size_t *coo, dimension dim){ long int sm = 0; for (long int i = begin; cond(i, end); i = iter(i)) { sm += (coo[i] * pp); - pp *= dim.perm[i]; + pp *= dim->perm[i]; } return sm; } - -size_t* CoordFromLin(size_t line, dimension dim){ - size_t *ret; - ret=malloc(dim.size*sizeof(size_t)); - long int begin = 0, end = dim.size - 1; +void vCoordFromLin(size_t *ret, size_t line, dimension *dim ){ + + long int begin = 0, end = dim->size - 1; long int (*iter)(long int) = incr; bool (*cond)(long int, long int) = isLessThan; if (endian == false) { //if (endian) { - begin = dim.size - 1; end = 0; + begin = dim->size - 1; end = 0; iter = decr; cond = isGreatThan; } //prlong intf("to coor begin = %d end = %d \n", begin, end); long int sm = line; - long int pp = dim.rank; + long int pp = dim->rank; for (long int i = begin; cond(i, end); i = iter(i)) { //prlong intf(" i: %d ", i); - pp /= dim.perm[i]; + pp /= dim->perm[i]; ret[i] = sm / pp; sm %= pp; //prlong intf("sm[%d] = %d , pp=%d ; ", i, sm, pp); } ret[end] = sm; - - return ret; - +} + +size_t* CoordFromLin(size_t line, dimension *dim){ + size_t *ret; + ret=malloc(dim->size*sizeof(size_t)); + vCoordFromLin(ret,line,dim); + return ret; } diff --git a/dimension_t/src/dimension_t/dimension_t.h b/dimension_t/src/dimension_t/dimension_t.h index cdc9f61..cf80c00 100644 --- a/dimension_t/src/dimension_t/dimension_t.h +++ b/dimension_t/src/dimension_t/dimension_t.h @@ -8,11 +8,17 @@ extern bool endian; typedef struct PERMUTATION_TYPE_SIZE_T dimension ; dimension * create_dim(size_t size); +dimension* init_dim(size_t *t, size_t sz); + +void add_dimension(dimension **d, dimension *d0, dimension *d1); +void min_dimension(dimension **d, dimension *d0, dimension *d1); + +void printDebug_dimension(dimension *d, char *msg); void updateRankDim(dimension *dim); -size_t LineFromCoord(size_t *coo, dimension dim); -size_t* CoordFromLin(size_t line, dimension dim); - +size_t LineFromCoord(size_t *coo, dimension *dim); +size_t* CoordFromLin(size_t line, dimension *dim); +void vCoordFromLin(size_t *ret, size_t line, dimension *dim ); #endif /* __DIMENSION_T__H__ */ diff --git a/dimension_t/test/is_good.c b/dimension_t/test/is_good.c index 46447cd..fa81f44 100644 --- a/dimension_t/test/is_good.c +++ b/dimension_t/test/is_good.c @@ -45,13 +45,13 @@ TEST(Coord_linear){ updateRankDim(D); size_t line=255; - size_t *coord = CoordFromLin(line,*D); + size_t *coord = CoordFromLin(line,D); for(size_t i=0; isize; ++i){ LOG("coo[%ld]=%ld\n",i,coord[i]); } - EXPECT_EQ(line, LineFromCoord(coord, *D)); + EXPECT_EQ(line, LineFromCoord(coord, D)); } int main(int argc, char **argv){ diff --git a/tensor_t/Makefile b/tensor_t/Makefile index 5c154a6..00a350d 100644 --- a/tensor_t/Makefile +++ b/tensor_t/Makefile @@ -5,11 +5,11 @@ PERMDIR=$(PWD)/../ypermutation_t DIMDIR=$(PWD)/../dimension_t - +INCLUDE_TENS=$(PWD)/src INCLUDE_PERMDIR=$(PERMDIR)/src INCLUDE_DIMDIR=$(DIMDIR)/src INCLUDE_TOOLDIR=$(TOOLDIR)/include -CFLAGS=-I$(INCLUDE_TOOLDIR) -I$(INCLUDE_PERMDIR) -I$(INCLUDE_DIMDIR) -I./src +CFLAGS=-I$(INCLUDE_TOOLDIR) -I$(INCLUDE_PERMDIR) -I$(INCLUDE_DIMDIR) -I$(INCLUDE_TENS) #SRC_DIR=$(ROOT_DIR)/src #SRC=$(wildcard */*/*.c) @@ -33,14 +33,14 @@ PERMSRC_O=$(PERMDIR)/src/permutation_t/permutation_t.o OBJ=$(TENSRC_O) TOPTARGETS := all clean -DEP=$(DIMDIR) #$(PERMDIR) +DEP=$(DIMDIR) $(PERMDIR) $(TOPTARGETS): $(DEP) -all: $(DIMSRC_O) +all: $(TENSRC_O) -$(TENSRC_O) : $(TENSRC) $(DIMSRC_O) - $(CC) -o $@ -c $< $(CFLAGS) +$(TENSRC_O) : $(TENSRC) $(DIMSRC_O) $(PERMSRC_O) + $(CC) -o $@ -c $^ $(CFLAGS) #$(DIMSRC_O) : $(DIMSRC) $(PERMSRC_O) # $(CC) -o $@ -c $< $(CFLAGS) diff --git a/tensor_t/src/tensor_t/tensor_t.c b/tensor_t/src/tensor_t/tensor_t.c index 79ef9da..01d3fad 100644 --- a/tensor_t/src/tensor_t/tensor_t.c +++ b/tensor_t/src/tensor_t/tensor_t.c @@ -1,11 +1,238 @@ #include "tensor_t/tensor_t.h" +void subArray(size_t* dst, size_t* src, size_t debDst, size_t finDst, size_t debSrc) { + for (size_t i = debDst; i < finDst; i++) { + dst[i] = src[i + debSrc]; + } +} + + +void concatArray(size_t* dst, size_t* src0, size_t* src1, size_t debDst, size_t debSrc0, size_t finSrc0, size_t debSrc1, size_t finSrc1) { + size_t i = debDst; + for (size_t j = debSrc0; j < finSrc0; j++) { + dst[i++] = src0[j]; + } + for (size_t j = debSrc1; j < finSrc1; j++) { + dst[i++] = src1[j]; + } +} + +void printArraySzt(size_t *a, size_t sz,char *msg){ + printf("======== %s ======= size: %ld\n",msg,sz); + for(size_t i=0; i< sz; ++i) + printf("[%ld : %ld ] ",i,a[i]); + printf("\n"); +} + #define GEN_FUNC_TENSOR(type)\ - struct tensor_##type CREATE_TENSOR_##type(struct dimension_t dim){\ - struct tensor_##type r_tens=malloc(sizeof(tensor_t##type));\ - r_tens->x=malloc(sizeof(type)*dim->size);\ + tensor_##type* CREATE_TENSOR_##type(dimension *dim){\ + tensor_##type *r_tens=malloc(sizeof(tensor_##type));\ + updateRankDim(dim);\ + r_tens->dim = dim;\ + r_tens->x = malloc(sizeof(type)*dim->rank);\ return r_tens;\ - } - - + }\ +\ +void tensorProdNotOpt_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1) { \ + dimension *dd; \ + add_dimension(&dd, M0->dim, M1->dim); \ + (*MM)=CREATE_TENSOR_##type(dd); \ + tensor_##type *M = *MM; \ + size_t* coord; \ + coord = malloc(sizeof(size_t)*(dd->size)); \ + size_t* coord0 , lin0; \ + coord0 = malloc(sizeof(size_t)* M0->dim->size); \ + size_t* coord1 , lin1; \ + coord1 = malloc(sizeof(size_t)* M1->dim->size); \ + for (size_t i = 0; i < dd->rank; i++) { \ + vCoordFromLin(coord, i, M->dim); \ + subArray(coord0, coord, 0, M0->dim->size, 0); \ + subArray(coord1, coord, 0, M1->dim->size, M0->dim->size); \ + \ + lin0=LineFromCoord(coord0, M0->dim); \ + lin1=LineFromCoord(coord1, M1->dim); \ + \ + 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]);*/\ + } \ +} \ +\ +void tensorProd_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1) { \ + dimension *dd; \ + add_dimension(&dd, M0->dim, M1->dim); \ + (*MM)=CREATE_TENSOR_##type(dd); \ + tensor_##type *M = *MM; \ + size_t m_idx;\ + for(size_t i=0; idim->rank; ++i){\ + for(size_t j=0; jdim->rank; ++j){\ + m_idx= i*M1->dim->rank + j ;\ + M->x[m_idx]=M0->x[i]*M1->x[j];\ + /*printf("[%ld|%ld:(%ld,%ld)]",x_idx++,m_idx,i,j);*/\ + }\ + }\ +} \ +\ +/* M[x0,x1,x3..xn] X M[y0,y1,y3..ym] = M[z0,z1...zp] (deep = l > 0) /exists 1<= l<...=n-l alor p=n+m-2l\ + M[x0,x1,x3..xl x{l+1}...xn] X M[xn,x{n-1},x{n-2}...xl y{l+1} ..ym] = M[x0,x1..xly{l+1}...y{n+m-2l}] (deep = l > 0)\ +M[[i][j]]=sum_{[k]}M0[[i][k]]*M[[k][j]]*/\ +\ +void tensorContractnProd_##type(tensor_##type** MM, tensor_##type *M0, tensor_##type *M1, size_t nestingDepth) {\ + /* if (!checkMatchProdtensor(M0->dim, M1->dim, nestingDepth)) {\ + prsize_tf("Deep = %d\n", nestingDepth);\ + }*/\ +\ + size_t len0 = M0->dim->size - nestingDepth;\ + size_t len1 = M1->dim->size - nestingDepth;\ +\ + size_t* tsub0 = malloc(sizeof(size_t) *len0);\ + size_t* tsub1 = malloc(sizeof(size_t) *len1);\ + size_t* tDk1 = malloc(sizeof(size_t) *nestingDepth);\ + size_t* tDk0 = malloc(sizeof(size_t) *nestingDepth);\ + subArray(tsub0, M0->dim->perm, 0, len0, 0);\ + subArray(tsub1, M1->dim->perm, 0, len1, nestingDepth);\ + subArray(tDk1, M1->dim->perm, 0, nestingDepth, 0);\ + subArray(tDk0, M0->dim->perm, 0, nestingDepth, len0);\ + printArraySzt(tsub0,len0,"tsub0");\ + printArraySzt(tsub1,len1,"tsub1");\ + printArraySzt(tDk0,nestingDepth,"tDk0");\ + printArraySzt(tDk1,nestingDepth,"tDk1");\ + dimension *dSub0 = init_dim(tsub0, len0);\ + dimension *dSub1 = init_dim(tsub1, len1);\ + dimension *dM1 = init_dim(tDk1, nestingDepth);\ + dimension *dM0 = init_dim(tDk0, nestingDepth);\ + printDebug_dimension(dSub0,"dSub0");\ + printDebug_dimension(dSub1,"dSub1");\ + printDebug_dimension(dM0,"dM0");\ + printDebug_dimension(dM1,"dM1");\ + dimension *dM;\ + min_dimension(&dM, dM0, dM1);\ + printDebug_dimension(dM,"dM");\ + \ + dimension *dd;\ + add_dimension(&dd, dSub0, dSub1);\ + printDebug_dimension(dd,"dd");\ + updateRankDim(dd);\ + *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)* nestingDepth);\ +\ + size_t a0_id, a1_id, n0_id, n1_id;\ + for (size_t i = 0; i < M->dim->rank; i++) {\ + /*vCoordFromLin(coord, i, M->dim);\ + subArray(coord0, coord, 0, len0, 0);\ + subArray(coord1, coord, 0, len1, len0);*/\ + a0_id=i/dSub1->rank;\ + a1_id=i%dSub1->rank;\ + /*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++) {\ + /*vCoordFromLin(Koord, k, dM);\ + concatArray(coordM0, coord0, Koord, 0, 0, len0, 0, nestingDepth);\ + concatArray(coordM1, Koord, coord1, 0, 0, nestingDepth, 0, len1);\ + lin0 = LineFromCoord(coordM0, M0->dim);\ + lin1 = LineFromCoord(coordM1, M1->dim);*/\ + n0_id= a0_id*dM->rank + k;\ + n1_id= a1_id + dSub1->rank * k;\ + /*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];*/\ + M->x[i] += M0->x[n0_id] * M1->x[n1_id];\ + /*printf("M[%ld]:%f += M0[%ld]:%f * M1[%ld]:%f | ",i,M->x[i],lin0,M0->x[lin0],lin1,M1->x[lin1]);*/\ + /*printf("k:%ld |i:%ld |lin0:%ld | lin1:%ld | ",k,i,lin0,lin1);*/\ + }\ + /*printf("\n");*/\ + }\ +}\ +void tensorContractnProdNotOpt_##type(tensor_##type** MM, tensor_##type *M0, tensor_##type *M1, size_t nestingDepth) {\ + /* if (!checkMatchProdtensor(M0->dim, M1->dim, nestingDepth)) {\ + prsize_tf("Deep = %d\n", nestingDepth);\ + }*/\ +\ + size_t len0 = M0->dim->size - nestingDepth;\ + size_t len1 = M1->dim->size - nestingDepth;\ +\ + size_t* tsub0 = malloc(sizeof(size_t) *len0);\ + size_t* tsub1 = malloc(sizeof(size_t) *len1);\ + size_t* tDk1 = malloc(sizeof(size_t) *nestingDepth);\ + size_t* tDk0 = malloc(sizeof(size_t) *nestingDepth);\ + subArray(tsub0, M0->dim->perm, 0, len0, 0);\ + subArray(tsub1, M1->dim->perm, 0, len1, nestingDepth);\ + subArray(tDk1, M1->dim->perm, 0, nestingDepth, 0);\ + subArray(tDk0, M0->dim->perm, 0, nestingDepth, len0);\ + printArraySzt(tsub0,len0,"tsub0");\ + printArraySzt(tsub1,len1,"tsub1");\ + printArraySzt(tDk0,nestingDepth,"tDk0");\ + printArraySzt(tDk1,nestingDepth,"tDk1");\ + dimension *dSub0 = init_dim(tsub0, len0);\ + dimension *dSub1 = init_dim(tsub1, len1);\ + dimension *dM1 = init_dim(tDk1, nestingDepth);\ + dimension *dM0 = init_dim(tDk0, nestingDepth);\ + printDebug_dimension(dSub0,"dSub0");\ + printDebug_dimension(dSub1,"dSub1");\ + printDebug_dimension(dM0,"dM0");\ + printDebug_dimension(dM1,"dM1");\ + dimension *dM;\ + min_dimension(&dM, dM0, dM1);\ + printDebug_dimension(dM,"dM");\ + \ + dimension *dd;\ + add_dimension(&dd, dSub0, dSub1);\ + printDebug_dimension(dd,"dd");\ + updateRankDim(dd);\ + *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)* nestingDepth);\ +\ + for (size_t i = 0; i < M->dim->rank; i++) {\ + vCoordFromLin(coord, i, M->dim);\ + subArray(coord0, coord, 0, len0, 0);\ + subArray(coord1, coord, 0, len1, len0);\ + M->x[i] = 0;\ + for (size_t k = 0; k < dM->rank; k++) {\ + vCoordFromLin(Koord, k, dM);\ + concatArray(coordM0, coord0, Koord, 0, 0, len0, 0, nestingDepth);\ + concatArray(coordM1, Koord, coord1, 0, 0, nestingDepth, 0, len1);\ + lin0 = LineFromCoord(coordM0, M0->dim);\ + lin1 = LineFromCoord(coordM1, M1->dim);\ + M->x[i] += M0->x[lin0] * M1->x[lin1];\ + /*printf("M[%ld]:%f += M0[%ld]:%f * M1[%ld]:%f | ",i,M->x[i],lin0,M0->x[lin0],lin1,M1->x[lin1]);*/\ + /*printf("k:%ld |i:%ld |lin0:%ld | lin1:%ld | ",k,i,lin0,lin1);*/\ + }\ + /*printf("\n");*/\ + }\ +}\ +\ +GEN_FUNC_TENSOR(TYPE_FLOAT); +GEN_FUNC_TENSOR(TYPE_DOUBLE); diff --git a/tensor_t/src/tensor_t/tensor_t.h b/tensor_t/src/tensor_t/tensor_t.h index d6072de..860ecd7 100644 --- a/tensor_t/src/tensor_t/tensor_t.h +++ b/tensor_t/src/tensor_t/tensor_t.h @@ -5,13 +5,19 @@ #define GENERATE_TENSOR_TYPE(type) \ struct tensor_##type{\ - dimension dim;\ + dimension *dim;\ type *x;\ };\ typedef struct tensor_##type tensor_##type;\ -struct tensor_##type CREATE_TENSOR_##type(struct dimension_t dim); \ +tensor_##type * CREATE_TENSOR_##type(dimension *dim); \ +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 nestingDepth); \ +void tensorContractnProdNotOpt_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1, size_t nestingDepth); \ +GENERATE_TENSOR_TYPE(TYPE_FLOAT); +GENERATE_TENSOR_TYPE(TYPE_DOUBLE); #endif /* __TENSOR_T__H__ */ diff --git a/ypermutation_t/compile.sh b/ypermutation_t/compile.sh index af85642..c0f6e5b 100644 --- a/ypermutation_t/compile.sh +++ b/ypermutation_t/compile.sh @@ -13,10 +13,10 @@ fi -gcc -o launch_is_good_c $1 -L$PWD/../ $2 -lytest -I../include_ytest/include src/permutation_t/permutation_t.c src/set_theoric_t/set_theoric_t.c -I./src +gcc -o launch_is_good_c $1 -L$PWD/../ytest_t/ $2 -lytest -I../include_ytest/include src/permutation_t/permutation_t.c src/set_theoric_t/set_theoric_t.c -I./src #gcc -o launch_is_good_c $1 $2 -lytest -I../include_ytest src/permutation_t/permutation_t.o src/set_theoric_t/set_theoric_t.o -I./src -export LD_LIBRARY_PATH=$PWD/../:LD_LIBRARY_PATH +export LD_LIBRARY_PATH=$PWD/../ytest_t:LD_LIBRARY_PATH #gcc $1 src/ftest/ftest.c src/fmock/fmock.c src/tools_t/tools_t.c src/bar_progress/bar_progress.c src/permutation_t/permutation_t.c src/set_theoric_t/set_theoric_t.c -I./include $2 -o launch_is_good_c -lpthread diff --git a/ypermutation_t/src/is_good.c b/ypermutation_t/src/is_good.c index b62472c..5df1146 100644 --- a/ypermutation_t/src/is_good.c +++ b/ypermutation_t/src/is_good.c @@ -90,7 +90,7 @@ TEST(expect){ int b = 6; EXPECT_EQ(a,b); //SKIP(); - SKIP("on skip eq string\n"); + SKIP("%s","on skip eq string\n"); EXPECT_EQ_TYPE_STRING("hello","hello"); float f1 = 1.00019999, f2=1.00019999; EXPECT_EQ_TYPE_FLOAT(f1,f2); diff --git a/ypermutation_t/src/permutation_t/permutation_t.c b/ypermutation_t/src/permutation_t/permutation_t.c index 95910d2..0bfa231 100644 --- a/ypermutation_t/src/permutation_t/permutation_t.c +++ b/ypermutation_t/src/permutation_t/permutation_t.c @@ -41,6 +41,13 @@ int sign(long int a){ p->perm = malloc(size * sizeof(type));\ return p;\ }\ + PERMUTATION_##type * INIT_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;iperm[i] = perm[i];\ + return p;\ + }\ \ PERMUTATION_TYPE_SIZE_T * TRANSLATE_TO_SET_THEORIC_SIZE_T_##type(const PERMUTATION_##type *p ){\ if (p == NULL) return NULL;\ diff --git a/ypermutation_t/src/permutation_t/permutation_t.h b/ypermutation_t/src/permutation_t/permutation_t.h index 4d52f96..0ea6f12 100644 --- a/ypermutation_t/src/permutation_t/permutation_t.h +++ b/ypermutation_t/src/permutation_t/permutation_t.h @@ -19,6 +19,7 @@ \ typedef struct PERMUTATION_##type PERMUTATION_##type;\ PERMUTATION_##type * CREATE_PERMUTATION_##type(size_t size);\ + PERMUTATION_##type * INIT_PERMUTATION_##type(type *perm, size_t size);\ 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);\ diff --git a/ytest_t/include_ytest/include/ftest/ftest.h b/ytest_t/include_ytest/include/ftest/ftest.h index 3b99355..f72a58e 100644 --- a/ytest_t/include_ytest/include/ftest/ftest.h +++ b/ytest_t/include_ytest/include/ftest/ftest.h @@ -57,7 +57,11 @@ #define GE >= #define NE != +#define NORMAL 0 +#define VERB 1 +#define NOVERB 2 +extern long int verb; extern FILE **f_ou_th; extern bool debug; extern bool unicolour; @@ -306,30 +310,59 @@ GEN_EXPECTED_OP_TYPE_FUNC(NE, TYPE_STRING) /* * only expect */ + +#define IFTESTPASS_NAME(OP,type,var1,var2,name_f,msg_call) \ + 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){\ + 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)); \ + }\ + }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"\ + ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1), #var2, type##_TO_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); + #define HANDLE_OP_EXPECT_NAME(OP,type,var1,var2,name_f,msg_call) \ do{ \ if(is_parallel_nb == 0){\ if(expected_##OP##_##type(var1, var2)){ \ - PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 %s passed %s \n\n",name_f,msg_call); \ + /*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){\ + 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)); \ + }\ + \ } \ else{ \ - /*PRINT_LOC("Failure\nExpected %s of these values:\n %s\n\tWhich is: %s\n %s\n\tWhich is: %s\n\n"\ - ,DESCRIPTION_##OP,#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"\ + /*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"\ ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1), #var2, type##_TO_STR(var2)); \ - PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 %s failed %s \n",name_f,msg_call); \ - } \ + PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 %s failed %s \n",name_f,msg_call); \ + \ }else { \ if(expected_##OP##_name_##type(var1, var2, name_f)){ \ - PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 %s passed %s \n\n",name_f,msg_call); \ - /*PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed %s \n\n",name_f);*/ \ + /*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){\ + 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)); \ + }\ } \ else{ \ - /*PRINT_LOC("Failure\nExpected %s of these values:\n %s\n\tWhich is: %s\n %s\n\tWhich is: %s\n\n"\ - ,DESCRIPTION_##OP ,#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"\ + /*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"\ ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1), #var2, type##_TO_STR(var2)); \ - PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 %s failed %s \n",name_f,msg_call); \ + PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 %s failed %s \n",name_f,msg_call); \ } \ }\ }while(0); @@ -340,15 +373,42 @@ do{ \ * old combined macros HANDLE_OP_EXPECT_ASSERT for ASSERT and EXPECT * is_assert : 0 for EXPECT and 1 for ASSERT */ + +#define IFTESTPASS_ \ + 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){\ + 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)); \ + }\ + }while(0); + + +#define IFTESTFAIL_ \ + do{\ + 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)); \ + PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n",__func__); \ + }while(0); + + + #define HANDLE_OP_EXPECT_ASSERT(OP,type,var1,var2,is_assert) \ do{ \ if(is_parallel_nb == 0){\ if(expected_##OP##_##type(var1, var2)){ \ - PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__); \ + /*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){\ + 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)); \ + }\ + \ } \ else{ \ - /*PRINT_LOC("Failure\nExpected %s of these values:\n %s\n\tWhich is: %s\n %s\n\tWhich is: %s\n\n"\ - ,DESCRIPTION_##OP,#var1, type##_TO_STR(var1), #var2, type##_TO_STR(var2)); */ \ + /*IFTESTFAIL_(var1,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)); \ PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n",__func__); \ @@ -356,15 +416,20 @@ do{ \ } \ }else { \ if(expected_##OP##_name_##type(var1, var2, __func__)){ \ - PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__); \ + /*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){\ + 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)); \ + }\ } \ else{ \ - /*PRINT_LOC("Failure\nExpected %s of these values:\n %s\n\tWhich is: %s\n %s\n\tWhich is: %s\n\n"\ - ,DESCRIPTION_##OP ,#var1, type##_TO_STR(var1), #var2, type##_TO_STR(var2));*/ \ + /*IFTESTFAIL_(var1,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)); \ PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n",__func__); \ - if(is_assert) return; \ + if(is_assert) return; \ } \ }\ }while(0); @@ -378,22 +443,32 @@ do{ \ do{ \ if(is_parallel_nb == 0){\ if(expected_##OP##_##type(var1, var2)){ \ - PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__); \ + /*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){\ + 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)); \ + }\ } \ else{ \ - /*PRINT_LOC("Failure\nExpected %s of these values:\n %s\n\tWhich is: %s\n %s\n\tWhich is: %s\n\n"\ - ,DESCRIPTION_##OP,#var1, type##_TO_STR(var1), #var2, type##_TO_STR(var2)); */ \ + /*IFTESTFAIL_ ;*/ \ 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)); \ PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n",__func__); \ } \ }else { \ if(expected_##OP##_name_##type(var1, var2, __func__)){ \ - PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__); \ + /*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){\ + 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)); \ + }\ } \ else{ \ - /*PRINT_LOC("Failure\nExpected %s of these values:\n %s\n\tWhich is: %s\n %s\n\tWhich is: %s\n\n"\ - ,DESCRIPTION_##OP ,#var1, type##_TO_STR(var1), #var2, type##_TO_STR(var2));*/ \ + /*IFTESTFAIL_(var1,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)); \ PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n",__func__); \ @@ -405,11 +480,16 @@ do{ \ do{ \ if(is_parallel_nb == 0){\ if(expected_##OP##_##type(var1, var2)){ \ - PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__); \ + /*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){\ + 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)); \ + }\ } \ else{ \ - /*PRINT_LOC("Failure\nExpected %s of these values:\n %s\n\tWhich is: %s\n %s\n\tWhich is: %s\n\n"\ - ,DESCRIPTION_##OP,#var1, type##_TO_STR(var1), #var2, type##_TO_STR(var2)); */ \ + /*IFTESTFAIL_(var1,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)); \ PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n",__func__); \ @@ -417,11 +497,16 @@ do{ \ } \ }else { \ if(expected_##OP##_name_##type(var1, var2, __func__)){ \ - PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__); \ + /*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){\ + 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)); \ + }\ } \ else{ \ - /*PRINT_LOC("Failure\nExpected %s of these values:\n %s\n\tWhich is: %s\n %s\n\tWhich is: %s\n\n"\ - ,DESCRIPTION_##OP ,#var1, type##_TO_STR(var1), #var2, type##_TO_STR(var2));*/ \ + /*IFTESTFAIL_(var1,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)); \ PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n",__func__); \ diff --git a/ytest_t/libytest.so b/ytest_t/libytest.so index 6e36020..fab6718 100644 Binary files a/ytest_t/libytest.so and b/ytest_t/libytest.so differ diff --git a/ytest_t/yftest/include/ftest/ftest.h b/ytest_t/yftest/include/ftest/ftest.h index 3b99355..f72a58e 100644 --- a/ytest_t/yftest/include/ftest/ftest.h +++ b/ytest_t/yftest/include/ftest/ftest.h @@ -57,7 +57,11 @@ #define GE >= #define NE != +#define NORMAL 0 +#define VERB 1 +#define NOVERB 2 +extern long int verb; extern FILE **f_ou_th; extern bool debug; extern bool unicolour; @@ -306,30 +310,59 @@ GEN_EXPECTED_OP_TYPE_FUNC(NE, TYPE_STRING) /* * only expect */ + +#define IFTESTPASS_NAME(OP,type,var1,var2,name_f,msg_call) \ + 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){\ + 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)); \ + }\ + }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"\ + ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1), #var2, type##_TO_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); + #define HANDLE_OP_EXPECT_NAME(OP,type,var1,var2,name_f,msg_call) \ do{ \ if(is_parallel_nb == 0){\ if(expected_##OP##_##type(var1, var2)){ \ - PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 %s passed %s \n\n",name_f,msg_call); \ + /*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){\ + 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)); \ + }\ + \ } \ else{ \ - /*PRINT_LOC("Failure\nExpected %s of these values:\n %s\n\tWhich is: %s\n %s\n\tWhich is: %s\n\n"\ - ,DESCRIPTION_##OP,#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"\ + /*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"\ ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1), #var2, type##_TO_STR(var2)); \ - PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 %s failed %s \n",name_f,msg_call); \ - } \ + PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 %s failed %s \n",name_f,msg_call); \ + \ }else { \ if(expected_##OP##_name_##type(var1, var2, name_f)){ \ - PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 %s passed %s \n\n",name_f,msg_call); \ - /*PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed %s \n\n",name_f);*/ \ + /*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){\ + 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)); \ + }\ } \ else{ \ - /*PRINT_LOC("Failure\nExpected %s of these values:\n %s\n\tWhich is: %s\n %s\n\tWhich is: %s\n\n"\ - ,DESCRIPTION_##OP ,#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"\ + /*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"\ ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1), #var2, type##_TO_STR(var2)); \ - PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 %s failed %s \n",name_f,msg_call); \ + PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 %s failed %s \n",name_f,msg_call); \ } \ }\ }while(0); @@ -340,15 +373,42 @@ do{ \ * old combined macros HANDLE_OP_EXPECT_ASSERT for ASSERT and EXPECT * is_assert : 0 for EXPECT and 1 for ASSERT */ + +#define IFTESTPASS_ \ + 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){\ + 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)); \ + }\ + }while(0); + + +#define IFTESTFAIL_ \ + do{\ + 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)); \ + PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n",__func__); \ + }while(0); + + + #define HANDLE_OP_EXPECT_ASSERT(OP,type,var1,var2,is_assert) \ do{ \ if(is_parallel_nb == 0){\ if(expected_##OP##_##type(var1, var2)){ \ - PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__); \ + /*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){\ + 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)); \ + }\ + \ } \ else{ \ - /*PRINT_LOC("Failure\nExpected %s of these values:\n %s\n\tWhich is: %s\n %s\n\tWhich is: %s\n\n"\ - ,DESCRIPTION_##OP,#var1, type##_TO_STR(var1), #var2, type##_TO_STR(var2)); */ \ + /*IFTESTFAIL_(var1,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)); \ PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n",__func__); \ @@ -356,15 +416,20 @@ do{ \ } \ }else { \ if(expected_##OP##_name_##type(var1, var2, __func__)){ \ - PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__); \ + /*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){\ + 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)); \ + }\ } \ else{ \ - /*PRINT_LOC("Failure\nExpected %s of these values:\n %s\n\tWhich is: %s\n %s\n\tWhich is: %s\n\n"\ - ,DESCRIPTION_##OP ,#var1, type##_TO_STR(var1), #var2, type##_TO_STR(var2));*/ \ + /*IFTESTFAIL_(var1,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)); \ PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n",__func__); \ - if(is_assert) return; \ + if(is_assert) return; \ } \ }\ }while(0); @@ -378,22 +443,32 @@ do{ \ do{ \ if(is_parallel_nb == 0){\ if(expected_##OP##_##type(var1, var2)){ \ - PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__); \ + /*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){\ + 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)); \ + }\ } \ else{ \ - /*PRINT_LOC("Failure\nExpected %s of these values:\n %s\n\tWhich is: %s\n %s\n\tWhich is: %s\n\n"\ - ,DESCRIPTION_##OP,#var1, type##_TO_STR(var1), #var2, type##_TO_STR(var2)); */ \ + /*IFTESTFAIL_ ;*/ \ 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)); \ PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n",__func__); \ } \ }else { \ if(expected_##OP##_name_##type(var1, var2, __func__)){ \ - PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__); \ + /*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){\ + 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)); \ + }\ } \ else{ \ - /*PRINT_LOC("Failure\nExpected %s of these values:\n %s\n\tWhich is: %s\n %s\n\tWhich is: %s\n\n"\ - ,DESCRIPTION_##OP ,#var1, type##_TO_STR(var1), #var2, type##_TO_STR(var2));*/ \ + /*IFTESTFAIL_(var1,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)); \ PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n",__func__); \ @@ -405,11 +480,16 @@ do{ \ do{ \ if(is_parallel_nb == 0){\ if(expected_##OP##_##type(var1, var2)){ \ - PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__); \ + /*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){\ + 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)); \ + }\ } \ else{ \ - /*PRINT_LOC("Failure\nExpected %s of these values:\n %s\n\tWhich is: %s\n %s\n\tWhich is: %s\n\n"\ - ,DESCRIPTION_##OP,#var1, type##_TO_STR(var1), #var2, type##_TO_STR(var2)); */ \ + /*IFTESTFAIL_(var1,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)); \ PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n",__func__); \ @@ -417,11 +497,16 @@ do{ \ } \ }else { \ if(expected_##OP##_name_##type(var1, var2, __func__)){ \ - PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__); \ + /*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){\ + 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)); \ + }\ } \ else{ \ - /*PRINT_LOC("Failure\nExpected %s of these values:\n %s\n\tWhich is: %s\n %s\n\tWhich is: %s\n\n"\ - ,DESCRIPTION_##OP ,#var1, type##_TO_STR(var1), #var2, type##_TO_STR(var2));*/ \ + /*IFTESTFAIL_(var1,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)); \ PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n",__func__); \ diff --git a/ytest_t/yftest/src/ftest/ftest.c b/ytest_t/yftest/src/ftest/ftest.c index 7078001..5a2cfab 100644 --- a/ytest_t/yftest/src/ftest/ftest.c +++ b/ytest_t/yftest/src/ftest/ftest.c @@ -40,6 +40,7 @@ struct failed_lists{ #define default_removelog 0 //#define default_parallel_nb 1 #define default_parallel_nb_opt 1 +#define default_verb NORMAL /* @@ -49,6 +50,7 @@ struct failed_lists{ /* * begin variable option */ +long int verb=NORMAL; bool some_thing_wrong = 0; @@ -96,6 +98,7 @@ size_t parallel_nb_opt = 0; /* to solve debug option */ bool is_parallel_nb = 0; bool is_parallel_nb_opt = 0; +bool is_verb = 0; bool log_parallel = true; bool progress = true; // false; @@ -335,6 +338,10 @@ void usage(int argc, char **argv){ "\t\tto print debug by using PRINT_DEBUG, by default PRINT_DEBUG is not print unless -d is set\n" /*"\t\t-d need to be set at the end of all options if -p is use, to avoid sigfault because the parallel env is not yet set for debug print parallel\n\n"*/ ); + printf( "\t -v, --verb = integer or macro: NORMAL or VERB or NOVERB \n" + "\t\tto chage test result printing: NORMAL=0, VERB=1, NOVERB=2 or integers not equal to 0 or 1 \n" + ); + if(array_TYPE_SIZE_T){ for(int i=0; i< cur_array_TYPE_SIZE_T; ++i){ @@ -365,13 +372,31 @@ const char* extract_string_after_equal_symbole_in_string(const char * in_str){ return NULL; // check for '\0' or ' ' return ! } + + +#define COMPARE_STR_TO_DEFS(defined,in_str)\ + /*LOG(" ===================== ======== %s vs %s =========== \n",in_str,#defined);*/\ + if(strcmp(in_str, #defined)==0){\ + return defined;\ + } + long int extract_num_after_equal_symbole_in_string(char * in_str){ + size_t len=strlen(in_str); long int val=0, p=1; int added=0; for(long i=len-1; i>=0; --i){ PRINT_DEBUG("(%s)[%ld]=%c\n",in_str,i,in_str[i]); - if(in_str[i]=='=') return val; + if(in_str[i]=='=') { + if(added) return val; + + COMPARE_STR_TO_DEFS(NORMAL,in_str+i+1); + COMPARE_STR_TO_DEFS(VERB,in_str+i+1); + COMPARE_STR_TO_DEFS(NOVERB,in_str+i+1); + + return -1; + + } if(in_str[i] >= '0' && in_str[i] <= '9' ){ val += p * (in_str[i]-'0'); p *= 10; @@ -603,6 +628,7 @@ void parse_options(int argc, char **argv){ IF_OPTION_NO_ARG(gtestlike) //IF_OPTION_WITH_ARG_NUM(parallel_nb) IF_OPTION_WITH_ARG_NUM(parallel_nb_opt) + IF_OPTION_WITH_ARG_NUM(verb) IF_OPTION_WITH_ARG_STR(savelog) IF_OPTION_WITH_ARG_STR(timeunit) IF_OPTION_WITH_ARG_STR(bar_progress)