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