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