Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
Try to exchange dynars
[simgrid.git] / testsuite / gras / datadesc_usage.c
1 /* $Id$ */
2
3 /* datadesc: test of data description (using file transport).               */
4
5 /* Copyright (c) 2004 Martin Quinson. All rights reserved.                  */
6
7 /* This program is free software; you can redistribute it and/or modify it
8  * under the terms of the license (GNU LGPL) which comes with this package. */
9
10 #include <stdio.h>
11 #include "gras.h"
12
13 #include "gras/DataDesc/datadesc_interface.h"
14 XBT_LOG_NEW_DEFAULT_CATEGORY(test,"Logging specific to this test");
15
16 #define READ  0
17 #define WRITE 1
18 #define RW    2
19
20 int r_arch;
21 const char *filename = "datadesc_usage.out";  
22
23 xbt_error_t
24 write_read(gras_datadesc_type_t type,void *src, void *dst, 
25            gras_socket_t sock, int direction);
26
27 xbt_error_t
28 write_read(gras_datadesc_type_t type,void *src, void *dst, 
29            gras_socket_t sock, int direction) {
30   xbt_error_t errcode;
31    
32   /* write */
33   if (direction == RW) 
34     TRY(gras_socket_client_from_file(filename,&sock));
35   if (direction == WRITE || direction == RW)
36     TRY(gras_datadesc_send(sock, type, src));
37 /*  TRY(gras_datadesc_gen_send(sock, type, src));*/
38   if (direction == RW) 
39     gras_socket_close(sock);
40    
41   /* read */
42   if (direction == RW) 
43     TRY(gras_socket_server_from_file(filename,&sock));
44
45   if (direction == READ || direction == RW)
46     TRY(gras_datadesc_recv(sock, type, r_arch, dst));
47
48   if (direction == RW) 
49     gras_socket_close(sock);
50   
51   return no_error;
52 }
53
54 xbt_error_t test_int(gras_socket_t sock, int direction);
55 xbt_error_t test_float(gras_socket_t sock, int direction);
56 xbt_error_t test_double(gras_socket_t sock, int direction);
57 xbt_error_t test_array(gras_socket_t sock, int direction);
58 xbt_error_t test_dynar_scal(gras_socket_t sock, int direction);
59 xbt_error_t test_intref(gras_socket_t sock, int direction);
60 xbt_error_t test_string(gras_socket_t sock, int direction);
61
62 xbt_error_t test_homostruct(gras_socket_t sock, int direction);
63 xbt_error_t test_hetestruct(gras_socket_t sock, int direction);
64 xbt_error_t test_nestedstruct(gras_socket_t sock, int direction);
65 xbt_error_t test_chain_list(gras_socket_t sock, int direction);
66 xbt_error_t test_graph(gras_socket_t sock, int direction);
67 xbt_error_t test_dynar_ref(gras_socket_t sock, int direction);
68
69 xbt_error_t test_pbio(gras_socket_t sock, int direction);
70 xbt_error_t test_clause(gras_socket_t sock, int direction);
71
72 /* defined in datadesc_structures.c, which in perl generated */
73 xbt_error_t test_structures(gras_socket_t sock, int direction); 
74
75
76
77 xbt_error_t test_int(gras_socket_t sock, int direction) {
78   xbt_error_t errcode;
79   int i=5,j;
80   
81   INFO0("---- Test on integer ----");
82   TRY(write_read(gras_datadesc_by_name("int"), &i,&j, sock,direction));
83   if (direction == READ || direction == RW) {
84     xbt_assert(i == j);
85   }
86   return no_error;
87 }
88 xbt_error_t test_float(gras_socket_t sock, int direction) {
89   xbt_error_t errcode;
90   float i=5.0,j;
91   
92   INFO0("---- Test on float ----");
93   TRY(write_read(gras_datadesc_by_name("float"), &i,&j, sock,direction));
94   if (direction == READ || direction == RW) {
95     xbt_assert2(i == j,"%f != %f",i,j);
96   }
97   return no_error;
98 }
99 xbt_error_t test_double(gras_socket_t sock, int direction) {
100   xbt_error_t errcode;
101   double i=-3252355.1234,j;
102   
103   INFO0("---- Test on double ----");
104   TRY(write_read(gras_datadesc_by_name("double"), &i,&j, sock,direction));
105   if (direction == READ || direction == RW) {
106     xbt_assert2(i == j,"%f != %f",i,j);
107   }
108   return no_error;
109 }
110
111 #define SIZE 5
112 typedef int array[SIZE];
113 xbt_error_t test_array(gras_socket_t sock, int direction) {
114   xbt_error_t errcode;
115   gras_datadesc_type_t my_type;
116   
117   array i = { 35212,-6226,74337,11414,7733};
118   array j;
119   int cpt;
120
121   INFO0("---- Test on fixed array ----");
122
123   my_type=gras_datadesc_array_fixed("fixed int array", 
124                                     gras_datadesc_by_name("int"),
125                                     SIZE);
126
127   TRY(write_read(my_type, &i,&j, sock,direction));
128   if (direction == READ || direction == RW) {
129     for (cpt=0; cpt<SIZE; cpt++) {
130       DEBUG1("Test spot %d",cpt);
131       xbt_assert4(i[cpt] == j[cpt],"i[%d]=%d  !=  j[%d]=%d",
132                    cpt,i[cpt],cpt,j[cpt]);
133     }
134   }
135   return no_error;
136 }
137 /*** Dynar of scalar ***/
138
139 xbt_error_t test_dynar_scal(gras_socket_t sock, int direction){
140   xbt_error_t errcode;
141   gras_datadesc_type_t my_type;
142   xbt_dynar_t i,j;
143   int cpt;
144    
145   INFO0("---- Test on dynar containing integers ----");
146   my_type = gras_datadesc_dynar(gras_datadesc_by_name("int"),NULL);
147   i = xbt_dynar_new(sizeof(int),NULL);
148   for (cpt=0; cpt<64; cpt++) {
149     xbt_dynar_push_as(i,int,cpt); 
150     DEBUG2("Push %d, length=%lu",cpt, xbt_dynar_length(i));
151   }
152 /*  xbt_dynar_dump(i);*/
153   TRY(write_read(my_type, &i,&j, sock, direction));
154 /*  xbt_dynar_dump(j);*/
155   if (direction == READ || direction == RW) {
156      for (cpt=0; cpt<64; cpt++){
157         int ret=xbt_dynar_get_as(j,cpt,int);
158         if (cpt != ret) {
159            CRITICAL3("The retrieved value for cpt=%d is not the same than the injected one (%d!=%d)",
160                      cpt,ret,cpt);
161            xbt_abort();
162         }
163      }
164      xbt_dynar_free(&j);
165   }
166   xbt_dynar_free(&i);
167
168   return no_error;
169 }
170 xbt_error_t test_intref(gras_socket_t sock, int direction) {
171   xbt_error_t errcode;
172   gras_datadesc_type_t my_type;
173   int *i,*j;
174   
175   i=xbt_new(int,1);
176   *i=12345;
177
178   INFO1("---- Test on a reference to an integer (%p) ----",i);
179
180   my_type = gras_datadesc_ref("int*",gras_datadesc_by_name("int"));
181
182   TRY(write_read(my_type, &i,&j, sock,direction));
183   if (direction == READ || direction == RW) {
184     xbt_assert(*i == *j);
185     free(j);
186   }
187   free(i);
188   return no_error;
189 }
190
191 /***
192  *** string (dynamic array)
193  ***/ 
194 xbt_error_t test_string(gras_socket_t sock, int direction) {
195   xbt_error_t errcode;
196   char *i=xbt_strdup("Some data"), *j=NULL;
197   int cpt;
198   
199   INFO0("---- Test on string (ref to dynamic array) ----");
200   TRY(write_read(gras_datadesc_by_name("string"), &i,&j,
201                  sock,direction));
202   if (direction == READ || direction == RW) {
203     for (cpt=0; cpt<strlen(i); cpt++) {
204       xbt_assert4(i[cpt] == j[cpt],"i[%d]=%c  !=  j[%d]=%c",
205                    cpt,i[cpt],cpt,j[cpt]);
206     } 
207     free(j);
208   }
209   free(i);
210   return no_error;
211 }
212
213
214 /***
215  *** homogeneous struct
216  ***/ 
217 typedef struct {
218   int a,b,c,d;
219 } homostruct;
220 xbt_error_t test_homostruct(gras_socket_t sock, int direction) {
221   xbt_error_t errcode;
222   gras_datadesc_type_t my_type;
223   homostruct *i, *j; 
224
225   INFO0("---- Test on homogeneous structure ----");
226   /* create descriptor */
227   my_type=gras_datadesc_struct("homostruct");
228   gras_datadesc_struct_append(my_type,"a",
229                               gras_datadesc_by_name("signed int"));
230   gras_datadesc_struct_append(my_type,"b",
231                               gras_datadesc_by_name("int"));
232   gras_datadesc_struct_append(my_type,"c",
233                               gras_datadesc_by_name("int"));
234   gras_datadesc_struct_append(my_type,"d",
235                               gras_datadesc_by_name("int"));
236   gras_datadesc_struct_close(my_type);
237   my_type=gras_datadesc_ref("homostruct*",
238                             gras_datadesc_by_name("homostruct"));
239
240   /* init a value, exchange it and check its validity*/
241   i=xbt_new(homostruct,1);
242   i->a = 2235;    i->b = 433425;
243   i->c = -23423;  i->d = -235235;
244
245   TRY(write_read(my_type, &i,&j, sock,direction));
246   if (direction == READ || direction == RW) {
247     xbt_assert2(i->a == j->a,"i->a=%d != j->a=%d",i->a,j->a);
248     xbt_assert(i->b == j->b);
249     xbt_assert(i->c == j->c);
250     xbt_assert(i->d == j->d);
251     free(j);
252   }
253   free(i);
254   return no_error;
255 }
256
257 /***
258  *** heterogeneous struct
259  ***/ 
260 typedef struct {
261   unsigned char c1;
262   unsigned long int l1;
263   unsigned char c2;
264   unsigned long int l2;
265 } hetestruct;
266 xbt_error_t test_hetestruct(gras_socket_t sock, int direction) {
267   xbt_error_t errcode;
268   gras_datadesc_type_t my_type;
269   hetestruct *i, *j; 
270
271   INFO0("---- Test on heterogeneous structure ----");
272   /* create descriptor */
273   my_type=gras_datadesc_struct("hetestruct");
274   gras_datadesc_struct_append(my_type,"c1",
275                               gras_datadesc_by_name("unsigned char"));
276   gras_datadesc_struct_append(my_type,"l1",
277                               gras_datadesc_by_name("unsigned long int"));
278   gras_datadesc_struct_append(my_type,"c2",
279                               gras_datadesc_by_name("unsigned char"));
280   gras_datadesc_struct_append(my_type,"l2",
281                               gras_datadesc_by_name("unsigned long int"));
282   gras_datadesc_struct_close(my_type);
283   my_type=gras_datadesc_ref("hetestruct*", gras_datadesc_by_name("hetestruct"));
284
285
286   /* init a value, exchange it and check its validity*/
287   i=xbt_new(hetestruct,1);
288   i->c1 = 's'; i->l1 = 123455;
289   i->c2 = 'e'; i->l2 = 774531;
290
291   TRY(write_read(my_type, &i,&j, sock,direction));
292   if (direction == READ || direction == RW) {
293     xbt_assert(i->c1 == j->c1);
294     xbt_assert(i->c2 == j->c2);
295     xbt_assert2(i->l1 == j->l1,"i->l1(=%ld)  !=  j->l1(=%ld)",i->l1,j->l1);
296     xbt_assert(i->l2 == j->l2);
297     free(j);
298   }
299   free(i);
300   return no_error;
301 }
302
303 /***
304  *** nested struct
305  ***/ 
306 typedef struct {
307   hetestruct hete;
308   homostruct homo;
309 } nestedstruct;
310 xbt_error_t test_nestedstruct(gras_socket_t sock, int direction) {
311   xbt_error_t errcode;
312   gras_datadesc_type_t my_type;
313   nestedstruct *i, *j; 
314
315   INFO0("---- Test on nested structures ----");
316   /* create descriptor */
317   my_type=gras_datadesc_struct("nestedstruct");
318
319   gras_datadesc_struct_append(my_type,"hete",
320                               gras_datadesc_by_name("hetestruct"));
321   gras_datadesc_struct_append(my_type,"homo",
322                               gras_datadesc_by_name("homostruct"));
323   gras_datadesc_struct_close(my_type);
324   my_type=gras_datadesc_ref("nestedstruct*", gras_datadesc_by_name("nestedstruct"));
325
326   /* init a value, exchange it and check its validity*/
327   i=xbt_new(nestedstruct,1);
328   i->homo.a = 235231;  i->homo.b = -124151;
329   i->homo.c = 211551;  i->homo.d = -664222;
330   i->hete.c1 = 's'; i->hete.l1 = 123455;
331   i->hete.c2 = 'e'; i->hete.l2 = 774531;
332
333   TRY(write_read(my_type, &i,&j, sock,direction));
334   if (direction == READ || direction == RW) {
335     xbt_assert(i->homo.a == j->homo.a);
336     xbt_assert(i->homo.b == j->homo.b);
337     xbt_assert(i->homo.c == j->homo.c);
338     xbt_assert(i->homo.d == j->homo.d);
339     xbt_assert(i->hete.c1 == j->hete.c1);
340     xbt_assert(i->hete.c2 == j->hete.c2);
341     xbt_assert(i->hete.l1 == j->hete.l1);
342     xbt_assert(i->hete.l2 == j->hete.l2);
343     free(j);
344   }
345   free(i);
346   return no_error;
347 }
348
349 /***
350  *** chained list
351  ***/ 
352 typedef struct s_chained_list chained_list_t;
353 struct s_chained_list {
354   int          v;
355   chained_list_t *l;
356 };
357 xbt_error_t declare_chained_list_type(void);
358 chained_list_t *cons(int v, chained_list_t *l);
359 void list_free(chained_list_t *l);
360 int list_eq(chained_list_t*i,chained_list_t*j);
361
362 xbt_error_t declare_chained_list_type(void) {
363   xbt_error_t errcode;
364   gras_datadesc_type_t my_type,ref_my_type;
365
366   my_type=gras_datadesc_struct("chained_list_t");
367   ref_my_type=gras_datadesc_ref("chained_list_t*",my_type);
368
369   gras_datadesc_struct_append(my_type,"v", gras_datadesc_by_name("int"));
370   gras_datadesc_struct_append(my_type,"l", ref_my_type);
371   gras_datadesc_struct_close(my_type);
372
373   return no_error;
374 }
375
376 chained_list_t * cons(int v, chained_list_t *l) {
377   chained_list_t *nl = xbt_new(chained_list_t,1);
378   
379   nl->v = v;
380   nl->l = l;
381   
382   return nl;
383 }
384 void list_free(chained_list_t*l) {
385   if (l) {
386     list_free(l->l);
387     free(l);
388   }
389 }
390 int list_eq(chained_list_t*i,chained_list_t*j) {
391   if (!i || !j) return i == j;
392   if (i->v != j->v)
393     return 0;
394   return list_eq(i->l, j->l); 
395 }
396 xbt_error_t test_chain_list(gras_socket_t sock, int direction) {
397   xbt_error_t errcode;
398   chained_list_t *i, *j; 
399
400   INFO0("---- Test on chained list ----");
401
402   /* init a value, exchange it and check its validity*/
403   i = cons( 12355, cons( 246264 , cons( 23263, NULL)));
404   j = NULL;
405
406   TRY(write_read(gras_datadesc_by_name("chained_list_t*"),
407                  &i,&j,
408                  sock,direction));
409   if (direction == READ || direction == RW) {
410     xbt_assert(list_eq(i,j));    
411     list_free(j);
412   }
413
414   list_free(i);
415   return no_error;
416 }
417 /***
418  *** graph
419  ***/
420 xbt_error_t test_graph(gras_socket_t sock, int direction) {
421   xbt_error_t errcode;
422   chained_list_t *i, *j; 
423
424   INFO0("---- Test on graph (cyclique chained list) ----");
425   /* init a value, exchange it and check its validity*/
426   i = cons( 1151515, cons( -232362 , cons( 222552, NULL)));
427   i->l->l->l = i;
428   j = NULL;
429
430   gras_datadesc_cycle_set(gras_datadesc_by_name("chained_list_t*"));
431   TRY(write_read(gras_datadesc_by_name("chained_list_t*"),
432                  &i,&j, sock,direction));
433   if (direction == READ || direction == RW) {
434     
435     DEBUG1("i=%p"         ,i);
436     DEBUG1("i->l=%p"      ,i->l);
437     DEBUG1("i->l->l=%p"   ,i->l->l);
438     DEBUG1("i->l->l->l=%p",i->l->l->l);
439     DEBUG1("j=%p"         ,j);
440     DEBUG1("j->l=%p"      ,j->l);
441     DEBUG1("j->l->l=%p"   ,j->l->l);
442     DEBUG1("j->l->l->l=%p",j->l->l->l);
443     xbt_assert4(j->l->l->l == j,
444                  "Received list is not cyclic. j=%p != j->l->l->l=%p\n"
445                  "j=%p; &j=%p",
446                  j,j->l->l->l, 
447                  j ,&j);
448     j->l->l->l = NULL;
449     i->l->l->l = NULL;
450     xbt_assert(list_eq(i,j));
451
452     list_free(j);
453   }
454   i->l->l->l = NULL; /* do this even in WRITE mode */
455   list_free(i);
456   return no_error;
457 }
458
459
460 /*** Dynar of references ***/
461 static void free_string(void *d){ /* used to free the data in dynar */
462      free(*(void**)d);
463 }
464 xbt_error_t test_dynar_ref(gras_socket_t sock, int direction){
465   xbt_error_t errcode;
466   gras_datadesc_type_t my_type;
467   xbt_dynar_t i,j;
468   char buf[1024];
469   char *s1,*s2;
470   int cpt;
471    
472   INFO0("---- Test on dynar containing integers ----");
473   my_type = gras_datadesc_dynar(gras_datadesc_by_name("string"),&free_string);
474
475   i=xbt_dynar_new(sizeof(char*),&free_string);   
476   for (cpt=0; cpt< 64; cpt++) {
477     sprintf(buf,"%d",cpt);
478     s1=strdup(buf);
479     xbt_dynar_push(i,&s1);
480   }
481
482   TRY(write_read(my_type, &i,&j, sock, direction));
483   if (direction == READ || direction == RW) {
484      for (cpt=0; cpt< 64; cpt++) {
485         sprintf(buf,"%d",cpt);
486         xbt_dynar_shift(j,&s2);
487         xbt_assert2 (!strcmp(buf,s2),
488                      "The retrieved value is not the same than the injected one (%s!=%s)",
489                      buf,s2);
490         free(s2);
491      }
492      xbt_dynar_free(&j);
493   }
494   xbt_dynar_free(&i);
495
496   return no_error;
497 }
498
499
500 /**** PBIO *****/
501 GRAS_DEFINE_TYPE(s_pbio,
502 struct s_pbio{ /* structure presented in the IEEE article */
503   int Cnstatv;
504   double Cstatev[12];
505   int Cnprops;
506   double Cprops[110];
507   int Cndi[4];
508   int Cnshr;
509   int Cnpt;
510   double Cdtime;
511   double Ctime[2];
512   int Cntens;
513   double Cdfgrd0[373][3];
514   double Cdfgrd1[3][3];
515   double Cstress[106];
516   double Cddsdde[106][106];
517 };
518                  )
519 typedef struct s_pbio pbio_t;
520
521 xbt_error_t test_pbio(gras_socket_t sock, int direction) {
522   xbt_error_t errcode;
523   int cpt;
524   int cpt2;
525   gras_datadesc_type_t pbio_type;
526   pbio_t i, j;
527
528   INFO0("---- Test on the PBIO IEEE struct (also tests GRAS DEFINE TYPE) ----");
529   pbio_type = gras_datadesc_by_symbol(s_pbio);
530
531   /* Fill in that damn struct */
532   i.Cnstatv = 325115;
533   for (cpt=0; cpt<12; cpt++) 
534     i.Cstatev[cpt] = ((double) cpt) * -2361.11;
535   i.Cnprops = -37373;
536   for (cpt=0; cpt<110; cpt++)
537     i.Cprops[cpt] = cpt * 100.0;
538   for (cpt=0; cpt<4; cpt++)
539     i.Cndi[cpt] = cpt * 23262;
540   i.Cnshr = -4634;
541   i.Cnpt = 114142;
542   i.Cdtime = -11515.662;
543   i.Ctime[0] = 332523.226;
544   i.Ctime[1] = -26216.113;
545   i.Cntens = 235211411;
546   
547   for (cpt=0; cpt<3; cpt++) {
548     for (cpt2=0; cpt2<373; cpt2++)
549       i.Cdfgrd0[cpt2][cpt] = ((double)cpt) * ((double)cpt2);
550     for (cpt2=0; cpt2<3; cpt2++)
551       i.Cdfgrd1[cpt][cpt2] = -((double)cpt) * ((double)cpt2);
552   }
553   for (cpt=0; cpt<106; cpt++) {
554     i.Cstress[cpt]=(double)cpt * 22.113;
555     for (cpt2=0; cpt2<106; cpt2++) 
556       i.Cddsdde[cpt][cpt2] = ((double)cpt) * ((double)cpt2);
557   }
558   TRY(write_read(gras_datadesc_by_symbol(s_pbio),
559                  &i,&j, sock,direction));
560   if (direction == READ || direction == RW) {
561     /* Check that the data match */
562     xbt_assert(i.Cnstatv == j.Cnstatv);
563     for (cpt=0; cpt<12; cpt++)
564       xbt_assert4(i.Cstatev[cpt] == j.Cstatev[cpt],
565                   "i.Cstatev[%d] (=%f) != j.Cstatev[%d] (=%f)",
566                   cpt,i.Cstatev[cpt],cpt,j.Cstatev[cpt]);
567     xbt_assert(i.Cnprops == j.Cnprops);
568     for (cpt=0; cpt<110; cpt++)
569       xbt_assert(i.Cprops[cpt] == j.Cprops[cpt]);
570     for (cpt=0; cpt<4; cpt++) 
571       xbt_assert(i.Cndi[cpt] == j.Cndi[cpt]);
572     xbt_assert(i.Cnshr == j.Cnshr);
573     xbt_assert(i.Cnpt == j.Cnpt);
574     xbt_assert(i.Cdtime == j.Cdtime);
575     xbt_assert(i.Ctime[0] == j.Ctime[0]);
576     xbt_assert(i.Ctime[1] == j.Ctime[1]);
577     xbt_assert(i.Cntens == j.Cntens);
578     for (cpt=0; cpt<3; cpt++) {
579       for (cpt2=0; cpt2<373; cpt2++)
580         xbt_assert(i.Cdfgrd0[cpt2][cpt] == j.Cdfgrd0[cpt2][cpt]);
581       for (cpt2=0; cpt2<3; cpt2++)
582         xbt_assert(i.Cdfgrd1[cpt][cpt2] == j.Cdfgrd1[cpt][cpt2]);
583     }
584     for (cpt=0; cpt<106; cpt++) {
585       xbt_assert(i.Cstress[cpt] == j.Cstress[cpt]);
586       for (cpt2=0; cpt2<106; cpt2++) 
587         xbt_assert4(i.Cddsdde[cpt][cpt2] == j.Cddsdde[cpt][cpt2],
588                      "%f=i.Cddsdde[%d][%d] != j.Cddsdde[cpt][cpt2]=%f",
589                      i.Cddsdde[cpt][cpt2],cpt,cpt2,j.Cddsdde[cpt][cpt2]);
590     }
591   }
592
593   return no_error;
594 }
595
596 GRAS_DEFINE_TYPE(s_clause,
597 struct s_clause {
598    int num_lits;
599    int *literals GRAS_ANNOTE(size,num_lits); /* Tells GRAS where to find the size */
600 };)
601 typedef struct s_clause Clause;
602
603 xbt_error_t test_clause(gras_socket_t sock, int direction) {
604   xbt_error_t errcode;
605   gras_datadesc_type_t ddt,array_t;
606   Clause *i,*j;
607   int cpt;
608   
609   INFO0("---- Test on struct containing dynamic array and its size (cbps test) ----");
610
611   /* create and fill the struct */
612   i=xbt_new(Clause,1);
613
614   i->num_lits = 5432;
615   i->literals = xbt_new(int, i->num_lits);
616   for (cpt=0; cpt<i->num_lits; cpt++)
617     i->literals[cpt] = cpt * cpt - ((cpt * cpt) / 2);
618   DEBUG3("created data=%p (within %p @%p)",&(i->num_lits),i,&i);
619   DEBUG1("created count=%d",i->num_lits);
620
621   /* create the damn type descriptor */
622   ddt = gras_datadesc_by_symbol(s_clause);
623 /*  gras_datadesc_type_dump(ddt); */
624
625   ddt=gras_datadesc_ref("Clause*",ddt);
626
627   TRY(write_read(ddt, &i,&j, sock,direction));
628   if (direction == READ || direction == RW) {
629     xbt_assert(i->num_lits == j->num_lits);
630     for (cpt=0; cpt<i->num_lits; cpt++)
631       xbt_assert(i->literals[cpt] == j->literals[cpt]);
632     
633     free(j->literals);
634     free(j);
635   }
636   free(i->literals);
637   free(i);
638   return no_error;
639 }
640
641 int main(int argc,char *argv[]) {
642   xbt_error_t errcode;
643   gras_socket_t sock;
644   int direction = RW;
645   int cpt;
646   char r_arch_char = gras_arch_selfid();
647
648   gras_init(&argc,argv,NULL);
649
650   for (cpt=1; cpt<argc; cpt++) {
651     if (!strcmp(argv[cpt], "--read")) {
652       direction = READ;
653     } else if (!strcmp(argv[cpt], "--write")) {
654       direction = WRITE;
655     } else {
656        filename=argv[cpt];
657     }
658   }
659     
660   if (direction == WRITE) {
661     TRYFAIL(gras_socket_client_from_file(filename,&sock));
662     TRY(gras_datadesc_send(sock, gras_datadesc_by_name("char"),
663                            &r_arch_char));
664   }
665   if (direction == READ) {
666     TRYFAIL(gras_socket_server_from_file(filename,&sock));
667     TRY(gras_datadesc_recv(sock, gras_datadesc_by_name("char"),
668                            gras_arch_selfid(), &r_arch_char));
669     INFO3("This datafile was generated on %s (%d), I'm %s.",
670           gras_datadesc_arch_name(r_arch_char),(int)r_arch_char,
671           gras_datadesc_arch_name(gras_arch_selfid()));
672   }
673   r_arch = (int)r_arch_char;
674
675   TRYFAIL(test_int(sock,direction));    
676   TRYFAIL(test_float(sock,direction));  
677   TRYFAIL(test_double(sock,direction));  
678   TRYFAIL(test_array(sock,direction));
679   TRYFAIL(test_dynar_scal(sock,direction));  
680   TRYFAIL(test_intref(sock,direction)); 
681   
682   TRYFAIL(test_string(sock,direction)); 
683
684   TRYFAIL(test_structures(sock,direction));
685
686   TRYFAIL(test_homostruct(sock,direction));
687   TRYFAIL(test_hetestruct(sock,direction));
688   TRYFAIL(test_nestedstruct(sock,direction));
689
690   TRYFAIL(declare_chained_list_type());
691   TRYFAIL(test_chain_list(sock,direction));
692   TRYFAIL(test_graph(sock,direction)); 
693   TRYFAIL(test_dynar_ref(sock,direction));  
694
695   TRYFAIL(test_pbio(sock,direction));
696
697   TRYFAIL(test_clause(sock,direction));
698
699   if (direction != RW) 
700     gras_socket_close(sock);
701   gras_exit();
702   return 0;
703 }
704