const char *filename = "datadesc_usage.out";
gras_error_t
-write_read(gras_datadesc_type_t *type,void *src, void *dst,
- gras_socket_t *sock, int direction);
+write_read(gras_datadesc_type_t type,void *src, void *dst,
+ gras_socket_t sock, int direction);
gras_error_t
-write_read(gras_datadesc_type_t *type,void *src, void *dst,
- gras_socket_t *sock, int direction) {
+write_read(gras_datadesc_type_t type,void *src, void *dst,
+ gras_socket_t sock, int direction) {
gras_error_t errcode;
/* write */
return no_error;
}
-gras_error_t test_int(gras_socket_t *sock, int direction);
-gras_error_t test_float(gras_socket_t *sock, int direction);
-gras_error_t test_double(gras_socket_t *sock, int direction);
-gras_error_t test_array(gras_socket_t *sock, int direction);
-gras_error_t test_intref(gras_socket_t *sock, int direction);
-gras_error_t test_string(gras_socket_t *sock, int direction);
+gras_error_t test_int(gras_socket_t sock, int direction);
+gras_error_t test_float(gras_socket_t sock, int direction);
+gras_error_t test_double(gras_socket_t sock, int direction);
+gras_error_t test_array(gras_socket_t sock, int direction);
+gras_error_t test_intref(gras_socket_t sock, int direction);
+gras_error_t test_string(gras_socket_t sock, int direction);
-gras_error_t test_homostruct(gras_socket_t *sock, int direction);
-gras_error_t test_hetestruct(gras_socket_t *sock, int direction);
-gras_error_t test_nestedstruct(gras_socket_t *sock, int direction);
-gras_error_t test_chain_list(gras_socket_t *sock, int direction);
-gras_error_t test_graph(gras_socket_t *sock, int direction);
+gras_error_t test_homostruct(gras_socket_t sock, int direction);
+gras_error_t test_hetestruct(gras_socket_t sock, int direction);
+gras_error_t test_nestedstruct(gras_socket_t sock, int direction);
+gras_error_t test_chain_list(gras_socket_t sock, int direction);
+gras_error_t test_graph(gras_socket_t sock, int direction);
-gras_error_t test_pbio(gras_socket_t *sock, int direction);
-gras_error_t test_clause(gras_socket_t *sock, int direction);
+gras_error_t test_pbio(gras_socket_t sock, int direction);
+gras_error_t test_clause(gras_socket_t sock, int direction);
/* defined in datadesc_structures.c, which in perl generated */
-gras_error_t test_structures(gras_socket_t *sock, int direction);
+gras_error_t test_structures(gras_socket_t sock, int direction);
-gras_error_t test_int(gras_socket_t *sock, int direction) {
+gras_error_t test_int(gras_socket_t sock, int direction) {
gras_error_t errcode;
int i=5,j;
}
return no_error;
}
-gras_error_t test_float(gras_socket_t *sock, int direction) {
+gras_error_t test_float(gras_socket_t sock, int direction) {
gras_error_t errcode;
float i=5.0,j;
}
return no_error;
}
-gras_error_t test_double(gras_socket_t *sock, int direction) {
+gras_error_t test_double(gras_socket_t sock, int direction) {
gras_error_t errcode;
double i=-3252355.1234,j;
#define SIZE 5
typedef int array[SIZE];
-gras_error_t test_array(gras_socket_t *sock, int direction) {
+gras_error_t test_array(gras_socket_t sock, int direction) {
gras_error_t errcode;
- gras_datadesc_type_t *my_type;
+ gras_datadesc_type_t my_type;
array i = { 35212,-6226,74337,11414,7733};
array j;
}
return no_error;
}
-gras_error_t test_intref(gras_socket_t *sock, int direction) {
+gras_error_t test_intref(gras_socket_t sock, int direction) {
gras_error_t errcode;
- gras_datadesc_type_t *my_type;
+ gras_datadesc_type_t my_type;
int *i,*j;
i=gras_new(int,1);
TRY(write_read(my_type, &i,&j, sock,direction));
if (direction == READ || direction == RW) {
gras_assert(*i == *j);
- gras_free(j);
+ free(j);
}
- gras_free(i);
+ free(i);
return no_error;
}
/***
*** string (dynamic array)
***/
-gras_error_t test_string(gras_socket_t *sock, int direction) {
+gras_error_t test_string(gras_socket_t sock, int direction) {
gras_error_t errcode;
char *i=gras_strdup("Some data"), *j=NULL;
int cpt;
gras_assert4(i[cpt] == j[cpt],"i[%d]=%c != j[%d]=%c",
cpt,i[cpt],cpt,j[cpt]);
}
- gras_free(j);
+ free(j);
}
- gras_free(i);
+ free(i);
return no_error;
}
typedef struct {
int a,b,c,d;
} homostruct;
-gras_error_t test_homostruct(gras_socket_t *sock, int direction) {
+gras_error_t test_homostruct(gras_socket_t sock, int direction) {
gras_error_t errcode;
- gras_datadesc_type_t *my_type;
+ gras_datadesc_type_t my_type;
homostruct *i, *j;
INFO0("---- Test on homogeneous structure ----");
TRY(write_read(my_type, &i,&j, sock,direction));
if (direction == READ || direction == RW) {
- gras_assert(i->a == j->a);
+ gras_assert2(i->a == j->a,"i->a=%d != j->a=%d",i->a,j->a);
gras_assert(i->b == j->b);
gras_assert(i->c == j->c);
gras_assert(i->d == j->d);
- gras_free(j);
+ free(j);
}
- gras_free(i);
+ free(i);
return no_error;
}
unsigned char c2;
unsigned long int l2;
} hetestruct;
-gras_error_t test_hetestruct(gras_socket_t *sock, int direction) {
+gras_error_t test_hetestruct(gras_socket_t sock, int direction) {
gras_error_t errcode;
- gras_datadesc_type_t *my_type;
+ gras_datadesc_type_t my_type;
hetestruct *i, *j;
INFO0("---- Test on heterogeneous structure ----");
gras_assert(i->c2 == j->c2);
gras_assert2(i->l1 == j->l1,"i->l1(=%ld) != j->l1(=%ld)",i->l1,j->l1);
gras_assert(i->l2 == j->l2);
- gras_free(j);
+ free(j);
}
- gras_free(i);
+ free(i);
return no_error;
}
hetestruct hete;
homostruct homo;
} nestedstruct;
-gras_error_t test_nestedstruct(gras_socket_t *sock, int direction) {
+gras_error_t test_nestedstruct(gras_socket_t sock, int direction) {
gras_error_t errcode;
- gras_datadesc_type_t *my_type;
+ gras_datadesc_type_t my_type;
nestedstruct *i, *j;
INFO0("---- Test on nested structures ----");
gras_assert(i->hete.c2 == j->hete.c2);
gras_assert(i->hete.l1 == j->hete.l1);
gras_assert(i->hete.l2 == j->hete.l2);
- gras_free(j);
+ free(j);
}
- gras_free(i);
+ free(i);
return no_error;
}
gras_error_t declare_chained_list_type(void) {
gras_error_t errcode;
- gras_datadesc_type_t *my_type,*ref_my_type;
+ gras_datadesc_type_t my_type,ref_my_type;
my_type=gras_datadesc_struct("chained_list_t");
ref_my_type=gras_datadesc_ref("chained_list_t*",my_type);
void list_free(chained_list_t*l) {
if (l) {
list_free(l->l);
- gras_free(l);
+ free(l);
}
}
int list_eq(chained_list_t*i,chained_list_t*j) {
return 0;
return list_eq(i->l, j->l);
}
-gras_error_t test_chain_list(gras_socket_t *sock, int direction) {
+gras_error_t test_chain_list(gras_socket_t sock, int direction) {
gras_error_t errcode;
chained_list_t *i, *j;
/***
*** graph
***/
-gras_error_t test_graph(gras_socket_t *sock, int direction) {
+gras_error_t test_graph(gras_socket_t sock, int direction) {
gras_error_t errcode;
chained_list_t *i, *j;
)
typedef struct s_pbio pbio_t;
-gras_error_t test_pbio(gras_socket_t *sock, int direction) {
+gras_error_t test_pbio(gras_socket_t sock, int direction) {
gras_error_t errcode;
pbio_t i,j;
int cpt;
int cpt2;
- gras_datadesc_type_t *pbio_type;
+ gras_datadesc_type_t pbio_type;
INFO0("---- Test on the PBIO IEEE struct (also tests GRAS DEFINE TYPE) ----");
pbio_type = gras_datadesc_by_symbol(s_pbio);
};)
typedef struct s_clause Clause;
-gras_error_t test_clause(gras_socket_t *sock, int direction) {
+gras_error_t test_clause(gras_socket_t sock, int direction) {
gras_error_t errcode;
- gras_datadesc_type_t *ddt,*array_t;
+ gras_datadesc_type_t ddt,array_t;
Clause *i,*j;
int cpt;
for (cpt=0; cpt<i->num_lits; cpt++)
gras_assert(i->literals[cpt] == j->literals[cpt]);
- gras_free(j->literals);
- gras_free(j);
+ free(j->literals);
+ free(j);
}
- gras_free(i->literals);
- gras_free(i);
+ free(i->literals);
+ free(i);
return no_error;
}
int main(int argc,char *argv[]) {
gras_error_t errcode;
- gras_socket_t *sock;
+ gras_socket_t sock;
int direction = RW;
int cpt;
char r_arch_char = gras_arch_selfid();
TRYFAIL(test_string(sock,direction));
- TRYFAIL(test_structures(sock,direction));
+ TRYFAIL(test_structures(sock,direction));
TRYFAIL(test_homostruct(sock,direction));
TRYFAIL(test_hetestruct(sock,direction));
print "#define READ 0\n#define WRITE 1\n#define RW 2\n\n";
-print "gras_error_t write_read(gras_datadesc_type_t *type,void *src, void *dst, gras_socket_t *sock, int direction);\n\n";
+print "gras_error_t write_read(gras_datadesc_type_t type,void *src, void *dst, gras_socket_t *sock, int direction);\n\n";
my ($i,$j,$k,$l);
my $max=scalar @types;
-for $i (0..$max-1) { for $j (0..$max-1) { for $k (0..$max-1) {my $l=0;
+my $maxl=0; # set it to "$max-1" to do 2401 tests (takes for ever to compile)
+for $i (0..$max-1) { for $j (0..$max-1) { for $k (0..$max-1) { for $l (0..$maxl) {
print "GRAS_DEFINE_TYPE(".$abrev[$i].$abrev[$j].$abrev[$k].$abrev[$l].",".
"struct ".$abrev[$i].$abrev[$j].$abrev[$k].$abrev[$l]." { ".
$types[$i]." a; ".
$types[$k]." c;".
$types[$l]." d;".
"};)\n";
-}}}
+}}}}
# print "\n#define test(a) do {if (!(a)) { failed = 1; ERROR1(\"%s failed\",#a);}} while (0)\n";
print "\n#define test(a) gras_assert(a)\n";
print "\ngras_error_t test_structures(gras_socket_t *sock, int direction);\n";
print "\ngras_error_t test_structures(gras_socket_t *sock, int direction) {\n";
print " gras_error_t errcode;\n";
-for $i (0..$max-1) { for $j (0..$max-1) { for $k (0..$max-1) {my $l=0;
+for $i (0..$max-1) { for $j (0..$max-1) { for $k (0..$max-1) { for $l (0..$maxl) {
my $struct=$abrev[$i].$abrev[$j].$abrev[$k].$abrev[$l];
print " struct $struct my_$struct = {".$val[$i]."+(".$types[$i].")1,"
.$val[$j]."+(".$types[$j].")2,"
.$val[$k]."+(".$types[$k].")3,"
.$val[$l]."+(".$types[$l].")4}, my_${struct}2;\n";
-}}}
+}}}}
-print " INFO0(\"---- Test on all possible struct having 3 fields (".($max*$max*$max)." structs) ----\");\n";
-for $i (0..$max-1) { for $j (0..$max-1) { for $k (0..$max-1) { my $l=0;
+print " INFO0(\"---- Test on all possible struct having 3 fields (".($max*$max*$max*($maxl+1))." structs) ----\");\n";
+for $i (0..$max-1) { for $j (0..$max-1) { for $k (0..$max-1) { for $l (0..$maxl) {
my $struct=$abrev[$i].$abrev[$j].$abrev[$k].$abrev[$l];
print " TRY(write_read(gras_datadesc_by_symbol($struct), &my_$struct, &my_${struct}2, sock,direction));\n";
print " if (direction == READ || direction == RW) {\n";
print " test(my_$struct.d == my_${struct}2.d);\n";
print " if (!failed) VERB0(\"Passed $struct\");\n";
print " }\n";
-}}}
+}}}}
print " return no_error;\n";
print "}\n";
- ;
+ ;
/* GRAS_LOG_NEW_DEFAULT_CATEGORY(test); */
int main(int argc,char *argv[]) {
- gras_socket_t *sock;
+ gras_socket_t sock;
gras_error_t errcode;
char data_send[256];
/*GRAS_LOG_NEW_DEFAULT_CATEGORY(test);*/
int main(int argc,char *argv[]) {
- gras_socket_t *sock, *conn;
+ gras_socket_t sock, conn;
gras_error_t errcode;
char data_recv[256];
/*GRAS_LOG_NEW_DEFAULT_CATEGORY(test);*/
int main(int argc,char *argv[]) {
- gras_socket_t * sock;
+ gras_socket_t sock;
gras_error_t errcode;
char data_send[256];
char data_recv[256];
/*GRAS_LOG_NEW_DEFAULT_CATEGORY(test);*/
int main(int argc,char *argv[]) {
- gras_socket_t *sock, *conn;
+ gras_socket_t sock, conn;
gras_error_t errcode;
char data_recv[256];
rm -f test.failed test.success test.ignored
if [ xvalgrind = "x$1" ] ; then
- valgrind="libtool --mode=execute valgrind"
+ valgrind="libtool --mode=execute valgrind --show-reachable=yes"
else
valgrind=
fi
#include <gras.h>
/*====[ Prototypes ]=========================================================*/
-gras_cfg_t *make_set(void); /* build a minimal set */
+gras_cfg_t make_set(void); /* build a minimal set */
/*====[ Code ]===============================================================*/
-gras_cfg_t *make_set(){
- gras_cfg_t *set=NULL;
+gras_cfg_t make_set(){
+ gras_cfg_t set=NULL;
gras_error_t errcode;
set = gras_cfg_new();
int main(int argc, char **argv) {
gras_error_t errcode;
- gras_cfg_t *set;
+ gras_cfg_t set;
- gras_dynar_t *dyn;
+ gras_dynar_t dyn;
char *str;
int ival;
set=make_set();
gras_cfg_dump("test set","",set);
gras_cfg_free(&set);
+ gras_cfg_free(&set);
fprintf(stderr,"==== Try to use an unregistered option. (ERROR EXPECTED: 'color' not registered)\n");
set=make_set();
TRYEXPECT(mismatch_error,gras_cfg_set_parse(set,"color:blue"));
gras_cfg_free(&set);
+ gras_cfg_free(&set);
fprintf(stderr,
gras_cfg_set_parse(set,"speed:42 speed:24 speed:34");
gras_cfg_check(set);
gras_cfg_free(&set);
+ gras_cfg_free(&set);
fprintf(stderr,"==== Get single value (Expected: 'speed value: 42')\n");
set=make_set();
gras_cfg_get_int(set,"speed",&ival);
fprintf(stderr,"speed value: %d\n",ival);
gras_cfg_free(&set);
+ gras_cfg_free(&set);
fprintf(stderr,"==== Get multiple values (Expected: 'Count: 3; Options: mquinson;ecaron;alegrand;')\n");
set=make_set();
}
fprintf(stderr,"\n");
gras_cfg_free(&set);
+ gras_cfg_free(&set);
gras_exit();
return 0;
#include <stdio.h>
#include <stdlib.h>
-#define NB_ELM 200000
+#define NB_ELM 20000
#define SIZEOFKEY 1024
static void print_str(void *str);
GRAS_LOG_NEW_DEFAULT_CATEGORY(test,"Logging specific to this test");
-static gras_error_t traverse(gras_dict_t *head) {
- gras_dict_cursor_t *cursor=NULL;
+static gras_error_t traverse(gras_dict_t head) {
+ gras_dict_cursor_t cursor=NULL;
char *key;
char *data;
return no_error;
}
-static gras_error_t countelems(gras_dict_t *head,int*count) {
- gras_dict_cursor_t *cursor;
+static gras_error_t countelems(gras_dict_t head,int*count) {
+ gras_dict_cursor_t cursor;
char *key;
void *data;
*count=0;
int main(int argc,char **argv) {
gras_error_t errcode;
- gras_dict_t *head=NULL;
+ gras_dict_t head=NULL;
int i,j,k, nb;
char *key;
void *data;
}
TRYFAIL(traverse(head));
gras_dict_free(&head);
+ gras_dict_free(&head);
}
GRAS_LOG_EXTERNAL_CATEGORY(dict);
GRAS_LOG_NEW_DEFAULT_CATEGORY(test,"Logging specific to this test");
-static void fill(gras_dict_t **head);
-static void debuged_add(gras_dict_t *head,const char*key);
-static gras_error_t search(gras_dict_t *head,const char*key);
-static gras_error_t debuged_remove(gras_dict_t *head,const char*key);
-static gras_error_t traverse(gras_dict_t *head);
+static void fill(gras_dict_t *head);
+static void debuged_add(gras_dict_t head,const char*key);
+static gras_error_t search(gras_dict_t head,const char*key);
+static gras_error_t debuged_remove(gras_dict_t head,const char*key);
+static gras_error_t traverse(gras_dict_t head);
static void print_str(void *str);
static void print_str(void *str) {
printf("%s",(char*)str);
}
-static void fill(gras_dict_t **head) {
+static void fill(gras_dict_t *head) {
printf("\n Fill in the dictionnary\n");
*head = gras_dict_new();
}
-static void debuged_add(gras_dict_t *head,const char*key)
+static void debuged_add(gras_dict_t head,const char*key)
{
char *data=gras_strdup(key);
printf(" - Add %s\n",key);
- gras_dict_set(head,key,data,&gras_free);
+ gras_dict_set(head,key,data,&free);
if (GRAS_LOG_ISENABLED(dict,gras_log_priority_debug)) {
gras_dict_dump(head,(void (*)(void*))&printf);
fflush(stdout);
}
}
-static gras_error_t search(gras_dict_t *head,const char*key) {
+static gras_error_t search(gras_dict_t head,const char*key) {
void *data;
gras_error_t errcode;
return errcode;
}
-static gras_error_t debuged_remove(gras_dict_t *head,const char*key)
+static gras_error_t debuged_remove(gras_dict_t head,const char*key)
{
gras_error_t errcode;
}
-static gras_error_t traverse(gras_dict_t *head) {
- gras_dict_cursor_t *cursor=NULL;
+static gras_error_t traverse(gras_dict_t head) {
+ gras_dict_cursor_t cursor=NULL;
char *key;
char *data;
int main(int argc,char **argv) {
gras_error_t errcode;
- gras_dict_t *head=NULL;
+ gras_dict_t head=NULL;
char *data;
gras_init_defaultlog(&argc,argv,"dict.thresh=verbose");
TRYFAIL(traverse(head));
fill(&head);
- printf(" Free the dictionnary\n");
+ printf(" Free the dictionnary (twice)\n");
gras_dict_free(&head);
- printf(" Free the dictionnary again\n");
gras_dict_free(&head);
fill(&head);
printf(" - Change some values\n");
printf(" - Change 123 to 'Changed 123'\n");
- gras_dict_set(head,"123",strdup("Changed 123"),&gras_free);
+ gras_dict_set(head,"123",strdup("Changed 123"),&free);
printf(" - Change 123 back to '123'\n");
- gras_dict_set(head,"123",strdup("123"),&gras_free);
+ gras_dict_set(head,"123",strdup("123"),&free);
printf(" - Change 12a to 'Dummy 12a'\n");
- gras_dict_set(head,"12a",strdup("Dummy 12a"),&gras_free);
+ gras_dict_set(head,"12a",strdup("Dummy 12a"),&free);
printf(" - Change 12a to '12a'\n");
- gras_dict_set(head,"12a",strdup("12a"),&gras_free);
+ gras_dict_set(head,"12a",strdup("12a"),&free);
/* gras_dict_dump(head,(void (*)(void*))&printf); */
printf(" - Traverse the resulting dictionnary\n");
/* gras_dict_dump(head,(void (*)(void*))&printf); */
- printf(" Free the dictionnary (twice)\n");
+ printf(" Free the dictionnary twice\n");
gras_dict_free(&head);
gras_dict_free(&head);
GRAS_LOG_NEW_DEFAULT_CATEGORY(test,"Logging specific to this test");
int main(int argc,char *argv[]) {
- gras_dynar_t *d;
+ gras_dynar_t d;
gras_error_t errcode;
int cpt,cursor;
double d1,d2;
gras_assert0(FALSE,
"Damnit, there is something in the empty dynar");
}
- gras_dynar_free(d);
+ gras_dynar_free(&d);
+ gras_dynar_free(&d);
INFO0("==== Push/shift 5000 doubles");
d=gras_dynar_new(sizeof(double),NULL);
"The retrieved value is not the same than the injected one (%f!=%f)",
d1,d2);
}
- gras_dynar_free(d);
+ gras_dynar_free(&d);
+ gras_dynar_free(&d);
INFO0("==== Unshift/pop 5000 doubles");
"The retrieved value is not the same than the injected one (%f!=%f)",
d1,d2);
}
- gras_dynar_free(d);
+ gras_dynar_free(&d);
+ gras_dynar_free(&d);
"The retrieved value is not the same than the injected one at the end (%f!=%f)",
d1,d2);
}
- gras_dynar_free(d);
+ gras_dynar_free(&d);
+ gras_dynar_free(&d);
INFO0("==== Push 5000 double, remove 2000-4000. free the rest");
"Remove a bad value. Got %f, expected %f",
d2,d1);
}
- gras_dynar_free(d);
+ gras_dynar_free(&d);
+ gras_dynar_free(&d);
gras_exit();
return 0;
GRAS_LOG_NEW_DEFAULT_CATEGORY(test,"Logging specific to this test");
int main(int argc,char *argv[]) {
- gras_dynar_t *d;
+ gras_dynar_t d;
gras_error_t errcode;
int i,cpt,cursor;
int *iptr;
gras_dynar_foreach(d,cursor,i){
gras_assert0(0,"Damnit, there is something in the empty dynar");
}
- gras_dynar_free(d);
+ gras_dynar_free(&d);
+ gras_dynar_free(&d);
INFO1("==== Push %d int, set them again 3 times, traverse them, shift them",
NB_ELEM);
d=gras_dynar_new(sizeof(int),NULL);
for (cpt=0; cpt< NB_ELEM; cpt++) {
- gras_dynar_push(d,&cpt);
+ gras_dynar_push_as(d,int,cpt);
DEBUG2("Push %d, length=%lu",cpt, gras_dynar_length(d));
}
for (cursor=0; cursor< NB_ELEM; cursor++) {
cursor,cpt);
}
for (cpt=0; cpt< NB_ELEM; cpt++)
- gras_dynar_set(d,cpt,&cpt);
+ *(int*)gras_dynar_get_ptr(d,cpt) = cpt;
for (cpt=0; cpt< NB_ELEM; cpt++)
- gras_dynar_set(d,cpt,&cpt);
+ *(int*)gras_dynar_get_ptr(d,cpt) = cpt;
+/* gras_dynar_set(d,cpt,&cpt);*/
for (cpt=0; cpt< NB_ELEM; cpt++)
- gras_dynar_set(d,cpt,&cpt);
+ *(int*)gras_dynar_get_ptr(d,cpt) = cpt;
cpt=0;
gras_dynar_foreach(d,cursor,i){
i,cpt);
DEBUG2("Pop %d, length=%lu",cpt, gras_dynar_length(d));
}
- gras_dynar_free(d);
+ gras_dynar_free(&d);
+ gras_dynar_free(&d);
INFO1("==== Unshift/pop %d int",NB_ELEM);
DEBUG2("Push %d, length=%lu",cpt, gras_dynar_length(d));
}
for (cpt=0; cpt< NB_ELEM; cpt++) {
- gras_dynar_pop(d,&i);
+ i=gras_dynar_pop_as(d,int);
gras_assert2(i == cpt,
"The retrieved value is not the same than the injected one (%d!=%d)",
i,cpt);
DEBUG2("Pop %d, length=%lu",cpt, gras_dynar_length(d));
}
- gras_dynar_free(d);
-
+ gras_dynar_free(&d);
+ gras_dynar_free(&d);
INFO1("==== Push %d int, insert 1000 int in the middle, shift everything",NB_ELEM);
d=gras_dynar_new(sizeof(int),NULL);
for (cpt=0; cpt< NB_ELEM; cpt++) {
- gras_dynar_push(d,&cpt);
+ gras_dynar_push_as(d,int,cpt);
DEBUG2("Push %d, length=%lu",cpt, gras_dynar_length(d));
}
for (cpt=0; cpt< 1000; cpt++) {
- gras_dynar_insert_at(d,2500,&cpt);
+ gras_dynar_insert_at_as(d,2500,int,cpt);
DEBUG2("Push %d, length=%lu",cpt, gras_dynar_length(d));
}
"The retrieved value is not the same than the injected one at the end (%d!=%d)",
i,cpt);
}
- gras_dynar_free(d);
+ gras_dynar_free(&d);
+ gras_dynar_free(&d);
INFO1("==== Push %d int, remove 2000-4000. free the rest",NB_ELEM);
d=gras_dynar_new(sizeof(int),NULL);
for (cpt=0; cpt< NB_ELEM; cpt++)
- gras_dynar_push(d,&cpt);
+ gras_dynar_push_as(d,int,cpt);
for (cpt=2000; cpt< 4000; cpt++) {
gras_dynar_remove_at(d,2000,&i);
i,cpt);
DEBUG2("remove %d, length=%lu",cpt, gras_dynar_length(d));
}
- gras_dynar_free(d);
+ gras_dynar_free(&d);
+ gras_dynar_free(&d);
gras_exit();
return 0;
void free_string(void *d);
void free_string(void *d){
- gras_free(*(void**)d);
+ free(*(void**)d);
}
int main(int argc,char *argv[]) {
- gras_dynar_t *d;
+ gras_dynar_t d;
gras_error_t errcode;
int cpt;
char buf[1024];
gras_assert0(FALSE,
"Damnit, there is something in the empty dynar");
}
- gras_dynar_free(d);
+ gras_dynar_free(&d);
+ gras_dynar_free(&d);
INFO1("==== Push %d strings, set them again 3 times, shift them",NB_ELEM);
d=gras_dynar_new(sizeof(char*),&free_string);
gras_assert2 (!strcmp(buf,s2),
"The retrieved value is not the same than the injected one (%s!=%s)",
buf,s2);
- gras_free(s2);
+ free(s2);
}
- gras_dynar_free(d);
+ gras_dynar_free(&d);
+ gras_dynar_free(&d);
INFO1("==== Unshift, traverse and pop %d strings",NB_ELEM);
gras_assert2 (!strcmp(buf,s2),
"The retrieved value is not the same than the injected one (%s!=%s)",
buf,s2);
- gras_free(s2);
+ free(s2);
}
- gras_dynar_free(d);
+ gras_dynar_free(&d);
+ gras_dynar_free(&d);
INFO2("==== Push %d strings, insert %d strings in the middle, shift everything",NB_ELEM,NB_ELEM/5);
gras_assert2(!strcmp(buf,s2),
"The retrieved value is not the same than the injected one at the begining (%s!=%s)",
buf,s2);
- gras_free(s2);
+ free(s2);
}
for (cpt=(NB_ELEM/5)-1; cpt>=0; cpt--) {
sprintf(buf,"%d",cpt);
gras_assert2 (!strcmp(buf,s2),
"The retrieved value is not the same than the injected one in the middle (%s!=%s)",
buf,s2);
- gras_free(s2);
+ free(s2);
}
for (cpt=NB_ELEM/2; cpt< NB_ELEM; cpt++) {
sprintf(buf,"%d",cpt);
gras_assert2 (!strcmp(buf,s2),
"The retrieved value is not the same than the injected one at the end (%s!=%s)",
buf,s2);
- gras_free(s2);
+ free(s2);
}
- gras_dynar_free(d);
+ gras_dynar_free(&d);
+ gras_dynar_free(&d);
INFO3("==== Push %d strings, remove %d-%d. free the rest",NB_ELEM,2*(NB_ELEM/5),4*(NB_ELEM/5));
gras_assert2(!strcmp(buf,s2),
"Remove a bad value. Got %s, expected %s",
s2,buf);
- gras_free(s2);
+ free(s2);
}
- gras_dynar_free(d);
+ gras_dynar_free(&d);
+ gras_dynar_free(&d);
gras_exit();
return 0;
/* payload */
char *data;
-}my_elem_t;
+} s_my_elem_t,*my_elem_t;
-static void fill(gras_set_t **set);
-static void debuged_add(gras_set_t *set,const char*key);
-static void debuged_add_with_data(gras_set_t *set,
+static void fill(gras_set_t *set);
+static void debuged_add(gras_set_t set,const char*key);
+static void debuged_add_with_data(gras_set_t set,
const char *name,
const char *data);
-static gras_error_t search_name(gras_set_t *set,const char*key);
-static gras_error_t search_id(gras_set_t *head,
+static gras_error_t search_name(gras_set_t set,const char*key);
+static gras_error_t search_id(gras_set_t head,
int id,
const char*expected_key);
-static gras_error_t traverse(gras_set_t *set);
+static gras_error_t traverse(gras_set_t set);
static void my_elem_free(void *e) {
- my_elem_t *elm=(my_elem_t*)e;
+ my_elem_t elm=(my_elem_t)e;
if (elm) {
- gras_free(elm->name);
- gras_free(elm->data);
- gras_free(elm);
+ free(elm->name);
+ free(elm->data);
+ free(elm);
}
}
-static void debuged_add_with_data(gras_set_t *set,
+static void debuged_add_with_data(gras_set_t set,
const char *name,
const char *data) {
- my_elem_t *elm;
+ my_elem_t elm;
- elm = gras_new(my_elem_t,1);
+ elm = gras_new(s_my_elem_t,1);
elm->name=gras_strdup(name);
elm->name_len=0;
printf("(->%s)",data);
}
printf("\n");
- gras_set_add(set, (gras_set_elm_t*)elm,
+ gras_set_add(set, (gras_set_elm_t)elm,
&my_elem_free);
}
-static void debuged_add(gras_set_t *set,
+static void debuged_add(gras_set_t set,
const char *name) {
debuged_add_with_data(set, name, name);
}
-static void fill(gras_set_t **set) {
+static void fill(gras_set_t *set) {
printf("\n Fill in the data set\n");
*set=gras_set_new();
debuged_add(*set,"123457");
}
-static gras_error_t search_name(gras_set_t *head,const char*key) {
+static gras_error_t search_name(gras_set_t head,const char*key) {
gras_error_t errcode;
- my_elem_t *elm;
+ my_elem_t elm;
- errcode=gras_set_get_by_name(head,key,(gras_set_elm_t**)&elm);
+ errcode=gras_set_get_by_name(head,key,(gras_set_elm_t*)&elm);
printf(" - Search by name %s. Found %s (under ID %d)\n",
key,
elm? elm->data:"(null)",
return errcode;
}
-static gras_error_t search_id(gras_set_t *head,int id,const char*key) {
- gras_error_t errcode;
- my_elem_t *elm;
+static gras_error_t search_id(gras_set_t head,int id,const char*key) {
+ gras_error_t errcode;
+ my_elem_t elm;
- errcode=gras_set_get_by_id(head,id,(gras_set_elm_t**)&elm);
+ errcode=gras_set_get_by_id(head,id,(gras_set_elm_t*)&elm);
printf(" - Search by id %d. Found %s (data %s)\n",
id,
elm? elm->name:"(null)",
}
-static gras_error_t traverse(gras_set_t *set) {
- gras_set_cursor_t *cursor=NULL;
- my_elem_t *elm=NULL;
+static gras_error_t traverse(gras_set_t set) {
+ gras_set_cursor_t cursor=NULL;
+ my_elem_t elm=NULL;
gras_set_foreach(set,cursor,elm) {
gras_assert0(elm,"Dude ! Got a null elm during traversal!");
int main(int argc,char **argv) {
gras_error_t errcode;
- gras_set_t *set=NULL;
- my_elem_t *elm;
+ gras_set_t set=NULL;
+ my_elem_t elm;
gras_init_defaultlog(&argc,argv,"set.thresh=verbose");
TRYFAIL(traverse(set));
printf(" - Retrive values\n");
- gras_set_get_by_name(set,"123",(gras_set_elm_t**)&elm);
+ gras_set_get_by_name(set,"123",(gras_set_elm_t*)&elm);
assert(elm);
TRYFAIL(strcmp("123",elm->data));
- TRYEXPECT(gras_set_get_by_name(set,"Can't be found",(gras_set_elm_t**)&elm),
+ TRYEXPECT(gras_set_get_by_name(set,"Can't be found",(gras_set_elm_t*)&elm),
mismatch_error);
- TRYEXPECT(gras_set_get_by_name(set,"123 Can't be found",(gras_set_elm_t**)&elm),
+ TRYEXPECT(gras_set_get_by_name(set,"123 Can't be found",(gras_set_elm_t*)&elm),
mismatch_error);
- TRYEXPECT(gras_set_get_by_name(set,"12345678 NOT",(gras_set_elm_t**)&elm),
+ TRYEXPECT(gras_set_get_by_name(set,"12345678 NOT",(gras_set_elm_t*)&elm),
mismatch_error);
TRYFAIL(search_name(set,"12"));