fanasina/y_project
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

add verbose variable for testing, update tensor and dimension repo

Browse Source
This commit is contained in:
fanasina
2024-01-17 20:19:37 +01:00
parent baf01c6fa2
commit 38dcee4e20
14 changed files with 583 additions and 102 deletions
Download Patch File Download Diff File Expand all files Collapse all files
dimension_t/src/dimension_t/dimension_t.c
+55 -17
View File
@@ -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 incr(long int i) { return i + 1; }
long int decr(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 * dimension *
create_dim(size_t sz){ create_dim(size_t sz){
return CREATE_PERMUTATION_TYPE_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; i<d->size; ++i)
printf("[%ld: %ld] |", i,d->perm[i]);
printf("\n");
}
void updateRankDim(dimension *dim){ void updateRankDim(dimension *dim){
dim->rank=1; dim->rank=1;
for(size_t i=0; i<dim->size; ++i) for(size_t i=0; i<dim->size; ++i)
dim->rank *=dim->perm[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 begin = 0;
long int end = dim.size - 1; long int end = dim->size - 1;
long int (*iter)(long int); iter = &incr; long int (*iter)(long int); iter = &incr;
bool (*cond)(long int, long int); cond = &isLessEqThan; bool (*cond)(long int, long int); cond = &isLessEqThan;
if (endian) { if (endian) {
begin = dim.size - 1; end = 0; begin = dim->size - 1; end = 0;
iter = &decr; cond = &isGreatEqThan; iter = &decr; cond = &isGreatEqThan;
} }
@@ -37,38 +73,40 @@ size_t LineFromCoord(size_t *coo, dimension dim){
long int sm = 0; long int sm = 0;
for (long int i = begin; cond(i, end); i = iter(i)) { for (long int i = begin; cond(i, end); i = iter(i)) {
sm += (coo[i] * pp); sm += (coo[i] * pp);
pp *= dim.perm[i]; pp *= dim->perm[i];
} }
return sm; return sm;
} }
void vCoordFromLin(size_t *ret, size_t line, dimension *dim ){
size_t* CoordFromLin(size_t line, dimension dim){
size_t *ret; long int begin = 0, end = dim->size - 1;
ret=malloc(dim.size*sizeof(size_t));
long int begin = 0, end = dim.size - 1;
long int (*iter)(long int) = incr; long int (*iter)(long int) = incr;
bool (*cond)(long int, long int) = isLessThan; bool (*cond)(long int, long int) = isLessThan;
if (endian == false) { if (endian == false) {
//if (endian) { //if (endian) {
begin = dim.size - 1; end = 0; begin = dim->size - 1; end = 0;
iter = decr; cond = isGreatThan; iter = decr; cond = isGreatThan;
} }
//prlong intf("to coor begin = %d end = %d \n", begin, end); //prlong intf("to coor begin = %d end = %d \n", begin, end);
long int sm = line; 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)) { for (long int i = begin; cond(i, end); i = iter(i)) {
//prlong intf(" i: %d ", i); //prlong intf(" i: %d ", i);
pp /= dim.perm[i]; pp /= dim->perm[i];
ret[i] = sm / pp; ret[i] = sm / pp;
sm %= pp; sm %= pp;
//prlong intf("sm[%d] = %d , pp=%d ; ", i, sm, pp); //prlong intf("sm[%d] = %d , pp=%d ; ", i, sm, pp);
} }
ret[end] = sm; 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;
} }
dimension_t/src/dimension_t/dimension_t.h
+9 -3
View File
@@ -8,11 +8,17 @@ extern bool endian;
typedef struct PERMUTATION_TYPE_SIZE_T dimension ; typedef struct PERMUTATION_TYPE_SIZE_T dimension ;
dimension * create_dim(size_t size); 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); void updateRankDim(dimension *dim);
size_t LineFromCoord(size_t *coo, dimension dim); size_t LineFromCoord(size_t *coo, dimension *dim);
size_t* CoordFromLin(size_t line, dimension dim); size_t* CoordFromLin(size_t line, dimension *dim);
void vCoordFromLin(size_t *ret, size_t line, dimension *dim );
#endif /* __DIMENSION_T__H__ */ #endif /* __DIMENSION_T__H__ */
dimension_t/test/is_good.c
+2 -2
View File
@@ -45,13 +45,13 @@ TEST(Coord_linear){
updateRankDim(D); updateRankDim(D);
size_t line=255; size_t line=255;
size_t *coord = CoordFromLin(line,*D); size_t *coord = CoordFromLin(line,D);
for(size_t i=0; i<D->size; ++i){ for(size_t i=0; i<D->size; ++i){
LOG("coo[%ld]=%ld\n",i,coord[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){ int main(int argc, char **argv){
tensor_t/Makefile
+6 -6
View File
@@ -5,11 +5,11 @@ PERMDIR=$(PWD)/../ypermutation_t
DIMDIR=$(PWD)/../dimension_t DIMDIR=$(PWD)/../dimension_t
INCLUDE_TENS=$(PWD)/src
INCLUDE_PERMDIR=$(PERMDIR)/src INCLUDE_PERMDIR=$(PERMDIR)/src
INCLUDE_DIMDIR=$(DIMDIR)/src INCLUDE_DIMDIR=$(DIMDIR)/src
INCLUDE_TOOLDIR=$(TOOLDIR)/include 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_DIR=$(ROOT_DIR)/src
#SRC=$(wildcard */*/*.c) #SRC=$(wildcard */*/*.c)
@@ -33,14 +33,14 @@ PERMSRC_O=$(PERMDIR)/src/permutation_t/permutation_t.o
OBJ=$(TENSRC_O) OBJ=$(TENSRC_O)
TOPTARGETS := all clean TOPTARGETS := all clean
DEP=$(DIMDIR) #$(PERMDIR) DEP=$(DIMDIR) $(PERMDIR)
$(TOPTARGETS): $(DEP) $(TOPTARGETS): $(DEP)
all: $(DIMSRC_O) all: $(TENSRC_O)
$(TENSRC_O) : $(TENSRC) $(DIMSRC_O) $(TENSRC_O) : $(TENSRC) $(DIMSRC_O) $(PERMSRC_O)
$(CC) -o $@ -c $< $(CFLAGS) $(CC) -o $@ -c $^ $(CFLAGS)
#$(DIMSRC_O) : $(DIMSRC) $(PERMSRC_O) #$(DIMSRC_O) : $(DIMSRC) $(PERMSRC_O)
# $(CC) -o $@ -c $< $(CFLAGS) # $(CC) -o $@ -c $< $(CFLAGS)
tensor_t/src/tensor_t/tensor_t.c
+233 -6
View File
@@ -1,11 +1,238 @@
#include "tensor_t/tensor_t.h" #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)\ #define GEN_FUNC_TENSOR(type)\
struct tensor_##type CREATE_TENSOR_##type(struct dimension_t dim){\ tensor_##type* CREATE_TENSOR_##type(dimension *dim){\
struct tensor_##type r_tens=malloc(sizeof(tensor_t##type));\ tensor_##type *r_tens=malloc(sizeof(tensor_##type));\
r_tens->x=malloc(sizeof(type)*dim->size);\ updateRankDim(dim);\
r_tens->dim = dim;\
r_tens->x = malloc(sizeof(type)*dim->rank);\
return r_tens;\ 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; i<M0->dim->rank; ++i){\
for(size_t j=0; j<M1->dim->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<...<l=n / xl = y0,x{l+1}=y1, x{n}=yl et zi=xi i<n-l et zj=y{j-(n-l)} j>=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);
tensor_t/src/tensor_t/tensor_t.h
+8 -2
View File
@@ -5,13 +5,19 @@
#define GENERATE_TENSOR_TYPE(type) \ #define GENERATE_TENSOR_TYPE(type) \
struct tensor_##type{\ struct tensor_##type{\
dimension dim;\ dimension *dim;\
type *x;\ type *x;\
};\ };\
typedef struct tensor_##type tensor_##type;\ 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__ */ #endif /* __TENSOR_T__H__ */
ypermutation_t/compile.sh
+2 -2
View File
@@ -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 #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 #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
ypermutation_t/src/is_good.c
+1 -1
View File
@@ -90,7 +90,7 @@ TEST(expect){
int b = 6; int b = 6;
EXPECT_EQ(a,b); EXPECT_EQ(a,b);
//SKIP(); //SKIP();
SKIP("on skip eq string\n"); SKIP("%s","on skip eq string\n");
EXPECT_EQ_TYPE_STRING("hello","hello"); EXPECT_EQ_TYPE_STRING("hello","hello");
float f1 = 1.00019999, f2=1.00019999; float f1 = 1.00019999, f2=1.00019999;
EXPECT_EQ_TYPE_FLOAT(f1,f2); EXPECT_EQ_TYPE_FLOAT(f1,f2);
ypermutation_t/src/permutation_t/permutation_t.c
+7
View File
@@ -41,6 +41,13 @@ int sign(long int a){
p->perm = malloc(size * sizeof(type));\ p->perm = malloc(size * sizeof(type));\
return p;\ 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;i<size;++i) p->perm[i] = perm[i];\
return p;\
}\
\ \
PERMUTATION_TYPE_SIZE_T * TRANSLATE_TO_SET_THEORIC_SIZE_T_##type(const PERMUTATION_##type *p ){\ PERMUTATION_TYPE_SIZE_T * TRANSLATE_TO_SET_THEORIC_SIZE_T_##type(const PERMUTATION_##type *p ){\
if (p == NULL) return NULL;\ if (p == NULL) return NULL;\
ypermutation_t/src/permutation_t/permutation_t.h
+1
View File
@@ -19,6 +19,7 @@
\ \
typedef struct PERMUTATION_##type PERMUTATION_##type;\ typedef struct PERMUTATION_##type PERMUTATION_##type;\
PERMUTATION_##type * CREATE_PERMUTATION_##type(size_t size);\ 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 );\ PERMUTATION_TYPE_SIZE_T * TRANSLATE_TO_SET_THEORIC_SIZE_T_##type(const PERMUTATION_##type *p );\
bool IS_PERMUTATION_##type(const PERMUTATION_##type *p );\ bool IS_PERMUTATION_##type(const PERMUTATION_##type *p );\
size_t TabToPlaceAlgo_##type(const PERMUTATION_##type *p);\ size_t TabToPlaceAlgo_##type(const PERMUTATION_##type *p);\
ytest_t/include_ytest/include/ftest/ftest.h
+116 -31
View File
@@ -57,7 +57,11 @@
#define GE >= #define GE >=
#define NE != #define NE !=
#define NORMAL 0
#define VERB 1
#define NOVERB 2
extern long int verb;
extern FILE **f_ou_th; extern FILE **f_ou_th;
extern bool debug; extern bool debug;
extern bool unicolour; extern bool unicolour;
@@ -306,30 +310,59 @@ GEN_EXPECTED_OP_TYPE_FUNC(NE, TYPE_STRING)
/* /*
* only expect * 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) \ #define HANDLE_OP_EXPECT_NAME(OP,type,var1,var2,name_f,msg_call) \
do{ \ do{ \
if(is_parallel_nb == 0){\ if(is_parallel_nb == 0){\
if(expected_##OP##_##type(var1, var2)){ \ 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{ \ else{ \
/*PRINT_LOC("Failure\nExpected %s of these values:\n %s\n\tWhich is: %s\n %s\n\tWhich is: %s\n\n"\ /*IFTESTFAIL_NAME(OP,type,var1,var2,name_f,msg_call);*/ \
,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"\
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, 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 { \ }else { \
if(expected_##OP##_name_##type(var1, var2, name_f)){ \ 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); \ /*IFTESTPASS_NAME(OP,type,var1,var2,name_f,msg_call);*/ \
/*PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed %s \n\n",name_f);*/ \ 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{ \ else{ \
/*PRINT_LOC("Failure\nExpected %s of these values:\n %s\n\tWhich is: %s\n %s\n\tWhich is: %s\n\n"\ /*IFTESTFAIL_NAME(OP,type,var1,var2,name_f,msg_call);*/ \
,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"\
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, 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); }while(0);
@@ -340,15 +373,42 @@ do{ \
* old combined macros HANDLE_OP_EXPECT_ASSERT for ASSERT and EXPECT * old combined macros HANDLE_OP_EXPECT_ASSERT for ASSERT and EXPECT
* is_assert : 0 for EXPECT and 1 for ASSERT * 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) \ #define HANDLE_OP_EXPECT_ASSERT(OP,type,var1,var2,is_assert) \
do{ \ do{ \
if(is_parallel_nb == 0){\ if(is_parallel_nb == 0){\
if(expected_##OP##_##type(var1, var2)){ \ 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{ \ else{ \
/*PRINT_LOC("Failure\nExpected %s of these values:\n %s\n\tWhich is: %s\n %s\n\tWhich is: %s\n\n"\ /*IFTESTFAIL_(var1,var2) ; */ \
,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"\ 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, 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__); \ 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 { \ }else { \
if(expected_##OP##_name_##type(var1, var2, __func__)){ \ 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{ \ else{ \
/*PRINT_LOC("Failure\nExpected %s of these values:\n %s\n\tWhich is: %s\n %s\n\tWhich is: %s\n\n"\ /*IFTESTFAIL_(var1,var2) ; */ \
,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"\ 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, 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__); \ 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); }while(0);
@@ -378,22 +443,32 @@ do{ \
do{ \ do{ \
if(is_parallel_nb == 0){\ if(is_parallel_nb == 0){\
if(expected_##OP##_##type(var1, var2)){ \ 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{ \ else{ \
/*PRINT_LOC("Failure\nExpected %s of these values:\n %s\n\tWhich is: %s\n %s\n\tWhich is: %s\n\n"\ /*IFTESTFAIL_ ;*/ \
,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"\ 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, 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__); \ PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n",__func__); \
} \ } \
}else { \ }else { \
if(expected_##OP##_name_##type(var1, var2, __func__)){ \ 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{ \ else{ \
/*PRINT_LOC("Failure\nExpected %s of these values:\n %s\n\tWhich is: %s\n %s\n\tWhich is: %s\n\n"\ /*IFTESTFAIL_(var1,var2) ; */ \
,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"\ 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, 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__); \ 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{ \ do{ \
if(is_parallel_nb == 0){\ if(is_parallel_nb == 0){\
if(expected_##OP##_##type(var1, var2)){ \ 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{ \ else{ \
/*PRINT_LOC("Failure\nExpected %s of these values:\n %s\n\tWhich is: %s\n %s\n\tWhich is: %s\n\n"\ /*IFTESTFAIL_(var1,var2) ; */ \
,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"\ 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, 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__); \ 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 { \ }else { \
if(expected_##OP##_name_##type(var1, var2, __func__)){ \ 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{ \ else{ \
/*PRINT_LOC("Failure\nExpected %s of these values:\n %s\n\tWhich is: %s\n %s\n\tWhich is: %s\n\n"\ /*IFTESTFAIL_(var1,var2) ; */ \
,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"\ 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, 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__); \ PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n",__func__); \
ytest_t/libytest.so
BIN
View File
Binary file not shown.
ytest_t/yftest/include/ftest/ftest.h
+116 -31
View File
@@ -57,7 +57,11 @@
#define GE >= #define GE >=
#define NE != #define NE !=
#define NORMAL 0
#define VERB 1
#define NOVERB 2
extern long int verb;
extern FILE **f_ou_th; extern FILE **f_ou_th;
extern bool debug; extern bool debug;
extern bool unicolour; extern bool unicolour;
@@ -306,30 +310,59 @@ GEN_EXPECTED_OP_TYPE_FUNC(NE, TYPE_STRING)
/* /*
* only expect * 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) \ #define HANDLE_OP_EXPECT_NAME(OP,type,var1,var2,name_f,msg_call) \
do{ \ do{ \
if(is_parallel_nb == 0){\ if(is_parallel_nb == 0){\
if(expected_##OP##_##type(var1, var2)){ \ 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{ \ else{ \
/*PRINT_LOC("Failure\nExpected %s of these values:\n %s\n\tWhich is: %s\n %s\n\tWhich is: %s\n\n"\ /*IFTESTFAIL_NAME(OP,type,var1,var2,name_f,msg_call);*/ \
,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"\
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, 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 { \ }else { \
if(expected_##OP##_name_##type(var1, var2, name_f)){ \ 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); \ /*IFTESTPASS_NAME(OP,type,var1,var2,name_f,msg_call);*/ \
/*PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed %s \n\n",name_f);*/ \ 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{ \ else{ \
/*PRINT_LOC("Failure\nExpected %s of these values:\n %s\n\tWhich is: %s\n %s\n\tWhich is: %s\n\n"\ /*IFTESTFAIL_NAME(OP,type,var1,var2,name_f,msg_call);*/ \
,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"\
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, 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); }while(0);
@@ -340,15 +373,42 @@ do{ \
* old combined macros HANDLE_OP_EXPECT_ASSERT for ASSERT and EXPECT * old combined macros HANDLE_OP_EXPECT_ASSERT for ASSERT and EXPECT
* is_assert : 0 for EXPECT and 1 for ASSERT * 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) \ #define HANDLE_OP_EXPECT_ASSERT(OP,type,var1,var2,is_assert) \
do{ \ do{ \
if(is_parallel_nb == 0){\ if(is_parallel_nb == 0){\
if(expected_##OP##_##type(var1, var2)){ \ 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{ \ else{ \
/*PRINT_LOC("Failure\nExpected %s of these values:\n %s\n\tWhich is: %s\n %s\n\tWhich is: %s\n\n"\ /*IFTESTFAIL_(var1,var2) ; */ \
,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"\ 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, 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__); \ 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 { \ }else { \
if(expected_##OP##_name_##type(var1, var2, __func__)){ \ 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{ \ else{ \
/*PRINT_LOC("Failure\nExpected %s of these values:\n %s\n\tWhich is: %s\n %s\n\tWhich is: %s\n\n"\ /*IFTESTFAIL_(var1,var2) ; */ \
,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"\ 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, 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__); \ 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); }while(0);
@@ -378,22 +443,32 @@ do{ \
do{ \ do{ \
if(is_parallel_nb == 0){\ if(is_parallel_nb == 0){\
if(expected_##OP##_##type(var1, var2)){ \ 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{ \ else{ \
/*PRINT_LOC("Failure\nExpected %s of these values:\n %s\n\tWhich is: %s\n %s\n\tWhich is: %s\n\n"\ /*IFTESTFAIL_ ;*/ \
,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"\ 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, 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__); \ PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n",__func__); \
} \ } \
}else { \ }else { \
if(expected_##OP##_name_##type(var1, var2, __func__)){ \ 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{ \ else{ \
/*PRINT_LOC("Failure\nExpected %s of these values:\n %s\n\tWhich is: %s\n %s\n\tWhich is: %s\n\n"\ /*IFTESTFAIL_(var1,var2) ; */ \
,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"\ 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, 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__); \ 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{ \ do{ \
if(is_parallel_nb == 0){\ if(is_parallel_nb == 0){\
if(expected_##OP##_##type(var1, var2)){ \ 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{ \ else{ \
/*PRINT_LOC("Failure\nExpected %s of these values:\n %s\n\tWhich is: %s\n %s\n\tWhich is: %s\n\n"\ /*IFTESTFAIL_(var1,var2) ; */ \
,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"\ 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, 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__); \ 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 { \ }else { \
if(expected_##OP##_name_##type(var1, var2, __func__)){ \ 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{ \ else{ \
/*PRINT_LOC("Failure\nExpected %s of these values:\n %s\n\tWhich is: %s\n %s\n\tWhich is: %s\n\n"\ /*IFTESTFAIL_(var1,var2) ; */ \
,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"\ 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, 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__); \ PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n",__func__); \
ytest_t/yftest/src/ftest/ftest.c
+27 -1
View File
@@ -40,6 +40,7 @@ struct failed_lists{
#define default_removelog 0 #define default_removelog 0
//#define default_parallel_nb 1 //#define default_parallel_nb 1
#define default_parallel_nb_opt 1 #define default_parallel_nb_opt 1
#define default_verb NORMAL
/* /*
@@ -49,6 +50,7 @@ struct failed_lists{
/* /*
* begin variable option * begin variable option
*/ */
long int verb=NORMAL;
bool some_thing_wrong = 0; 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 = 0;
bool is_parallel_nb_opt = 0; bool is_parallel_nb_opt = 0;
bool is_verb = 0;
bool log_parallel = true; bool log_parallel = true;
bool progress = true; // false; 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\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"*/ /*"\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){ if(array_TYPE_SIZE_T){
for(int i=0; i< cur_array_TYPE_SIZE_T; ++i){ 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 ! 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){ long int extract_num_after_equal_symbole_in_string(char * in_str){
size_t len=strlen(in_str); size_t len=strlen(in_str);
long int val=0, p=1; long int val=0, p=1;
int added=0; int added=0;
for(long i=len-1; i>=0; --i){ for(long i=len-1; i>=0; --i){
PRINT_DEBUG("(%s)[%ld]=%c\n",in_str,i,in_str[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' ){ if(in_str[i] >= '0' && in_str[i] <= '9' ){
val += p * (in_str[i]-'0'); val += p * (in_str[i]-'0');
p *= 10; p *= 10;
@@ -603,6 +628,7 @@ void parse_options(int argc, char **argv){
IF_OPTION_NO_ARG(gtestlike) IF_OPTION_NO_ARG(gtestlike)
//IF_OPTION_WITH_ARG_NUM(parallel_nb) //IF_OPTION_WITH_ARG_NUM(parallel_nb)
IF_OPTION_WITH_ARG_NUM(parallel_nb_opt) 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(savelog)
IF_OPTION_WITH_ARG_STR(timeunit) IF_OPTION_WITH_ARG_STR(timeunit)
IF_OPTION_WITH_ARG_STR(bar_progress) IF_OPTION_WITH_ARG_STR(bar_progress)