teshsuite/smpi/mpich3-test/datatype/lbub.c

   1 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */
   2 /*
   3  *  (C) 2001 by Argonne National Laboratory.
   4  *      See COPYRIGHT in top-level directory.
   5  */
   6 #include "mpi.h"
   7 #include <stdio.h>
   8 #include <stdlib.h>
   9 #include "mpitest.h"
  10 #include "mpitestconf.h"
  11 #ifdef HAVE_STRING_H
  12 #include <string.h>
  13 #endif
  14
  15 /*
  16    The default behavior of the test routines should be to briefly indicate
  17    the cause of any errors - in this test, that means that verbose needs
  18    to be set. Verbose should turn on output that is independent of error
  19    levels.
  20 */
  21 static int verbose = 1;
  22
  23 /* tests */
  24 int int_with_lb_ub_test(void);
  25 int contig_of_int_with_lb_ub_test(void);
  26 int contig_negextent_of_int_with_lb_ub_test(void);
  27 int vector_of_int_with_lb_ub_test(void);
  28 int vector_blklen_of_int_with_lb_ub_test(void);
  29 int vector_blklen_stride_of_int_with_lb_ub_test(void);
  30 int vector_blklen_stride_negextent_of_int_with_lb_ub_test(void);
  31 int vector_blklen_negstride_negextent_of_int_with_lb_ub_test(void);
  32 int int_with_negextent_test(void);
  33 int vector_blklen_negstride_of_int_with_lb_ub_test(void);
  34
  35 /* helper functions */
  36 int parse_args(int argc, char **argv);
  37
  38 int main(int argc, char **argv)
  39 {
  40     int err, errs = 0;
  41
  42     MTest_Init( &argc, &argv );
  43     parse_args(argc, argv);
  44
  45     /* To improve reporting of problems about operations, we
  46        change the error handler to errors return */
  47     MPI_Comm_set_errhandler( MPI_COMM_WORLD, MPI_ERRORS_RETURN );
  48
  49     /* perform some tests */
  50     err = int_with_lb_ub_test();
  51     if (err && verbose) fprintf(stderr, "found %d errors in simple lb/ub test\n", err);
  52     errs += err;
  53
  54     err = contig_of_int_with_lb_ub_test();
  55     if (err && verbose) fprintf(stderr, "found %d errors in contig test\n", err);
  56     errs += err;
  57
  58     err = contig_negextent_of_int_with_lb_ub_test();
  59     if (err && verbose) fprintf(stderr, "found %d errors in negextent contig test\n", err);
  60     errs += err;
  61
  62     err = vector_of_int_with_lb_ub_test();
  63     if (err && verbose) fprintf(stderr, "found %d errors in simple vector test\n", err);
  64     errs += err;
  65
  66     err = vector_blklen_of_int_with_lb_ub_test();
  67     if (err && verbose) fprintf(stderr, "found %d errors in vector blklen test\n", err);
  68     errs += err;
  69
  70     err = vector_blklen_stride_of_int_with_lb_ub_test();
  71     if (err && verbose) fprintf(stderr, "found %d errors in strided vector test\n", err);
  72     errs += err;
  73
  74     err = vector_blklen_negstride_of_int_with_lb_ub_test();
  75     if (err && verbose) fprintf(stderr, "found %d errors in negstrided vector test\n", err);
  76     errs += err;
  77
  78     err = int_with_negextent_test();
  79     if (err && verbose) fprintf(stderr, "found %d errors in negextent lb/ub test\n", err);
  80     errs += err;
  81
  82     err = vector_blklen_stride_negextent_of_int_with_lb_ub_test();
  83     if (err && verbose) fprintf(stderr, "found %d errors in strided negextent vector test\n", err);
  84     errs += err;
  85
  86     err = vector_blklen_negstride_negextent_of_int_with_lb_ub_test();
  87     if (err && verbose) fprintf(stderr, "found %d errors in negstrided negextent vector test\n", err);
  88     errs += err;
  89
  90     MTest_Finalize( errs );
  91     MPI_Finalize();
  92     return 0;
  93 }
  94
  95 int parse_args(int argc, char **argv)
  96 {
  97     /*
  98     int ret;
  99
 100     while ((ret = getopt(argc, argv, "v")) >= 0)
 101     {
 102         switch (ret) {
 103             case 'v':
 104                 verbose = 1;
 105                 break;
 106         }
 107     }
 108     */
 109     if (argc > 1 && strcmp(argv[1], "-v") == 0)
 110         verbose = 1;
 111     return 0;
 112 }
 113
 114 int int_with_lb_ub_test(void)
 115 {
 116     int err, errs = 0, val;
 117     MPI_Aint lb, extent, aval, true_lb;
 118     int blocks[3] = { 1, 4, 1 };
 119     MPI_Aint disps[3] = { -3, 0, 6 };
 120     MPI_Datatype types[3] = { MPI_LB, MPI_BYTE, MPI_UB };
 121
 122     MPI_Datatype eviltype;
 123
 124     err = MPI_Type_struct(3, blocks, disps, types, &eviltype);
 125     if (err != MPI_SUCCESS) {
 126         errs++;
 127         if (verbose) fprintf(stderr, "  MPI_Type_struct failed.\n");
 128         if (verbose) MTestPrintError( err  );
 129     }
 130
 131     err = MPI_Type_size(eviltype, &val);
 132     if (err != MPI_SUCCESS) {
 133         errs++;
 134         if (verbose) fprintf(stderr, "  MPI_Type_size failed.\n");
 135         if (verbose) MTestPrintError( err  );
 136     }
 137
 138     if (val != 4) {
 139         errs++;
 140         if (verbose) fprintf(stderr, "  size of type = %d; should be %d\n", val, 4);
 141     }
 142
 143     err = MPI_Type_extent(eviltype, &aval);
 144     if (err != MPI_SUCCESS) {
 145         errs++;
 146         if (verbose) fprintf(stderr, "  MPI_Type_extent failed.\n");
 147         if (verbose) MTestPrintError( err  );
 148     }
 149
 150     if (aval != 9) {
 151         errs++;
 152         if (verbose) fprintf(stderr, "  extent of type = %ld; should be %d\n", (long) aval, 9);
 153     }
 154
 155     err = MPI_Type_lb(eviltype, &aval);
 156     if (err != MPI_SUCCESS) {
 157         errs++;
 158         if (verbose) fprintf(stderr, "  MPI_Type_lb failed.\n");
 159         if (verbose) MTestPrintError( err  );
 160     }
 161
 162     if (aval != -3) {
 163         errs++;
 164         if (verbose) fprintf(stderr, "  lb of type = %d; should be %d\n", (int) aval, -3);
 165     }
 166
 167     err = MPI_Type_get_extent(eviltype, &lb, &extent);
 168     if (err != MPI_SUCCESS) {
 169         errs++;
 170         if (verbose) fprintf(stderr, "  MPI_Type_get_extent failed.\n");
 171         if (verbose) MTestPrintError( err  );
 172     }
 173
 174     if (lb != -3) {
 175         errs++;
 176         if (verbose) fprintf(stderr, "  lb of type = %d; should be %d\n",
 177                              (int) aval, -3);
 178     }
 179
 180     if (extent != 9) {
 181         errs++;
 182         if (verbose) fprintf(stderr, "  extent of type = %d; should be %d\n",
 183                              (int) extent, 9);
 184     }
 185
 186     err = MPI_Type_ub(eviltype, &aval);
 187     if (err != MPI_SUCCESS) {
 188         errs++;
 189         if (verbose) fprintf(stderr, "  MPI_Type_ub failed.\n");
 190         if (verbose) MTestPrintError( err  );
 191     }
 192
 193     if (aval != 6) {
 194         errs++;
 195         if (verbose) fprintf(stderr, "  ub of type = %d; should be %d\n", (int) aval, 6);
 196     }
 197
 198     err = MPI_Type_get_true_extent(eviltype, &true_lb, &aval);
 199     if (err != MPI_SUCCESS) {
 200         errs++;
 201         if (verbose) fprintf(stderr, "  MPI_Type_get_true_extent failed.\n");
 202         if (verbose) MTestPrintError( err  );
 203     }
 204
 205     if (true_lb != 0) {
 206         errs++;
 207         if (verbose) fprintf(stderr, "  true_lb of type = %d; should be %d\n", (int) true_lb, 0);
 208     }
 209
 210     if (aval != 4) {
 211         errs++;
 212         if (verbose) fprintf(stderr, "  true extent of type = %d; should be %d\n", (int) aval, 4);
 213     }
 214
 215     MPI_Type_free(&eviltype);
 216
 217     return errs;
 218 }
 219
 220 int contig_of_int_with_lb_ub_test(void)
 221 {
 222     int err, errs = 0, val;
 223     MPI_Aint lb, extent, aval, true_lb;
 224     int blocks[3] = { 1, 4, 1 };
 225     MPI_Aint disps[3] = { -3, 0, 6 };
 226     MPI_Datatype types[3] = { MPI_LB, MPI_BYTE, MPI_UB };
 227     char *typemapstring = 0;
 228
 229     MPI_Datatype inttype, eviltype;
 230
 231     /* build same type as in int_with_lb_ub_test() */
 232     typemapstring = (char*)"{ (LB,-3),4*(BYTE,0),(UB,6) }";
 233     err = MPI_Type_struct(3, blocks, disps, types, &inttype);
 234     if (err != MPI_SUCCESS) {
 235         errs++;
 236         if (verbose) fprintf(stderr, "  MPI_Type_struct of %s failed.\n",
 237                              typemapstring );
 238         if (verbose) MTestPrintError( err  );
 239         /* no point in continuing */
 240         return errs;
 241     }
 242
 243     typemapstring=(char*)"{ (LB,-3),4*(BYTE,0),(UB,6),(LB,6),4*(BYTE,9),(UB,15),(LB,15),4*(BYTE,18),(UB,24)}";
 244     err = MPI_Type_contiguous(3, inttype, &eviltype);
 245     if (err != MPI_SUCCESS) {
 246         errs++;
 247         if (verbose) fprintf(stderr, "  MPI_Type_contiguous of %s failed.\n",
 248                              typemapstring );
 249         if (verbose) MTestPrintError( err  );
 250         /* no point in continuing */
 251         return errs;
 252     }
 253
 254     err = MPI_Type_size(eviltype, &val);
 255     if (err != MPI_SUCCESS) {
 256         errs++;
 257         if (verbose) fprintf(stderr, "  MPI_Type_size of %s failed.\n",
 258                              typemapstring );
 259         if (verbose) MTestPrintError( err  );
 260     }
 261
 262     if (val != 12) {
 263         errs++;
 264         if (verbose) fprintf(stderr, "  size of type = %d; should be %d\n",
 265                              val, 12);
 266     }
 267
 268     err = MPI_Type_extent(eviltype, &aval);
 269     if (err != MPI_SUCCESS) {
 270         errs++;
 271         if (verbose) fprintf(stderr, "  MPI_Type_extent failed.\n");
 272         if (verbose) MTestPrintError( err  );
 273     }
 274
 275     if (aval != 27) {
 276         errs++;
 277         if (verbose) fprintf(stderr, "  extent of type = %d; should be %d\n", (int) aval, 27);
 278         if (verbose) fprintf( stderr, " for type %s\n", typemapstring );
 279     }
 280
 281     err = MPI_Type_lb(eviltype, &aval);
 282     if (err != MPI_SUCCESS) {
 283         errs++;
 284         if (verbose) fprintf(stderr, "  MPI_Type_lb failed.\n");
 285         if (verbose) MTestPrintError( err  );
 286     }
 287
 288     if (aval != -3) {
 289         errs++;
 290         if (verbose) fprintf(stderr, "  lb of type = %d from Type_lb; should be %d in %s\n", (int) aval, -3, typemapstring );
 291     }
 292
 293     err = MPI_Type_get_extent(eviltype, &lb, &extent);
 294     if (err != MPI_SUCCESS) {
 295         errs++;
 296         if (verbose) fprintf(stderr, "  MPI_Type_get_extent failed.\n");
 297         if (verbose) MTestPrintError( err  );
 298     }
 299
 300     if (lb != -3) {
 301         errs++;
 302         if (verbose) fprintf(stderr, "  lb of type = %d from Type_get_extent; should be %d in %s\n",
 303                              (int) aval, -3, typemapstring );
 304     }
 305
 306     if (extent != 27) {
 307         errs++;
 308         if (verbose) fprintf(stderr, "  extent of type = %d from Type_get_extent; should be %d in %s\n",
 309                              (int) extent, 27, typemapstring);
 310     }
 311
 312     err = MPI_Type_ub(eviltype, &aval);
 313     if (err != MPI_SUCCESS) {
 314         errs++;
 315         if (verbose) fprintf(stderr, "  MPI_Type_ub failed.\n");
 316         if (verbose) MTestPrintError( err  );
 317     }
 318
 319     if (aval != 24) {
 320         errs++;
 321         if (verbose) fprintf(stderr, "  ub of type = %d in Type_ub; should be %din %s\n", (int) aval, 24, typemapstring);
 322     }
 323
 324     err = MPI_Type_get_true_extent(eviltype, &true_lb, &aval);
 325     if (err != MPI_SUCCESS) {
 326         errs++;
 327         if (verbose) fprintf(stderr, "  MPI_Type_get_true_extent failed.\n");
 328         if (verbose) MTestPrintError( err  );
 329     }
 330
 331     if (true_lb != 0) {
 332         errs++;
 333         if (verbose) fprintf(stderr, "  true_lb of type = %d; should be %d in %s\n", (int) true_lb, 0, typemapstring);
 334     }
 335
 336     if (aval != 22) {
 337         errs++;
 338         if (verbose) fprintf(stderr, "  true extent of type = %d; should be %d in %s\n", (int) aval, 22, typemapstring);
 339     }
 340
 341     MPI_Type_free( &inttype );
 342     MPI_Type_free( &eviltype );
 343
 344     return errs;
 345 }
 346
 347 int contig_negextent_of_int_with_lb_ub_test(void)
 348 {
 349     int err, errs = 0, val;
 350     MPI_Aint lb, extent, aval, true_lb;
 351     int blocks[3] = { 1, 4, 1 };
 352     MPI_Aint disps[3] = { 6, 0, -3 };
 353     MPI_Datatype types[3] = { MPI_LB, MPI_BYTE, MPI_UB };
 354     char *typemapstring = 0;
 355
 356     MPI_Datatype inttype, eviltype;
 357
 358     /* build same type as in int_with_lb_ub_test() */
 359     typemapstring = (char*)"{ (LB,6),4*(BYTE,0),(UB,-3) }";
 360     err = MPI_Type_struct(3, blocks, disps, types, &inttype);
 361     if (err != MPI_SUCCESS) {
 362         errs++;
 363         if (verbose) fprintf(stderr, "  MPI_Type_struct of %s failed.\n",
 364                              typemapstring );
 365         if (verbose) MTestPrintError( err  );
 366         /* No point in continuing */
 367         return errs;
 368     }
 369
 370     typemapstring = (char*)"{ (LB,6),4*(BYTE,0),(UB,-3),(LB,-3),4*(BYTE,-9),(UB,-12),(LB,-12),4*(BYTE,-18),(UB,-21) }";
 371     err = MPI_Type_contiguous(3, inttype, &eviltype);
 372     if (err != MPI_SUCCESS) {
 373         errs++;
 374         if (verbose) fprintf(stderr, "  MPI_Type_contiguous of %s failed.\n",
 375                              typemapstring);
 376         if (verbose) MTestPrintError( err  );
 377         /* No point in continuing */
 378         return errs;
 379     }
 380
 381     err = MPI_Type_size(eviltype, &val);
 382     if (err != MPI_SUCCESS) {
 383         errs++;
 384         if (verbose) fprintf(stderr, "  MPI_Type_size of %s failed.\n",
 385                              typemapstring);
 386         if (verbose) MTestPrintError( err  );
 387     }
 388
 389     if (val != 12) {
 390         errs++;
 391         if (verbose) fprintf(stderr, "  size of type = %d; should be %d\n", val, 12);
 392     }
 393
 394     err = MPI_Type_extent(eviltype, &aval);
 395     if (err != MPI_SUCCESS) {
 396         errs++;
 397         if (verbose) fprintf(stderr, "  MPI_Type_extent failed.\n");
 398         if (verbose) MTestPrintError( err  );
 399     }
 400
 401     if (aval != 9) {
 402         errs++;
 403         if (verbose) fprintf(stderr, "  extent of type = %d; should be %d\n", (int) aval, 9);
 404     }
 405
 406     err = MPI_Type_lb(eviltype, &aval);
 407     if (err != MPI_SUCCESS) {
 408         errs++;
 409         if (verbose) fprintf(stderr, "  MPI_Type_lb failed.\n");
 410         if (verbose) MTestPrintError( err  );
 411     }
 412
 413     if (aval != -12) {
 414         errs++;
 415         if (verbose) fprintf(stderr, "  lb of type = %d; should be %d\n", (int) aval, -12);
 416     }
 417
 418     err = MPI_Type_get_extent(eviltype, &lb, &extent);
 419     if (err != MPI_SUCCESS) {
 420         errs++;
 421         if (verbose) fprintf(stderr, "  MPI_Type_get_extent failed.\n");
 422         if (verbose) MTestPrintError( err  );
 423     }
 424
 425     if (lb != -12) {
 426         errs++;
 427         if (verbose) fprintf(stderr, "  lb of type = %d; should be %d\n",
 428                              (int) aval, -12);
 429     }
 430
 431     if (extent != 9) {
 432         errs++;
 433         if (verbose) fprintf(stderr, "  extent of type = %d; should be %d\n",
 434                              (int) extent, 9);
 435     }
 436
 437     err = MPI_Type_ub(eviltype, &aval);
 438     if (err != MPI_SUCCESS) {
 439         errs++;
 440         if (verbose) fprintf(stderr, "  MPI_Type_ub failed.\n");
 441         if (verbose) MTestPrintError( err  );
 442     }
 443
 444     if (aval != -3) {
 445         errs++;
 446         if (verbose) fprintf(stderr, "  ub of type = %d; should be %d\n", (int) aval, -3);
 447     }
 448
 449     err = MPI_Type_get_true_extent(eviltype, &true_lb, &aval);
 450     if (err != MPI_SUCCESS) {
 451         errs++;
 452         if (verbose) fprintf(stderr, "  MPI_Type_get_true_extent failed.\n");
 453         if (verbose) MTestPrintError( err  );
 454     }
 455
 456     if (true_lb != -18) {
 457         errs++;
 458         if (verbose) fprintf(stderr, "  true_lb of type = %d; should be %d\n", (int) true_lb, -18);
 459     }
 460
 461     if (aval != 22) {
 462         errs++;
 463         if (verbose) fprintf(stderr, "  true extent of type = %d; should be %d\n", (int) aval, 22);
 464     }
 465
 466     MPI_Type_free( &inttype );
 467     MPI_Type_free( &eviltype );
 468
 469     return errs;
 470 }
 471
 472 int vector_of_int_with_lb_ub_test(void)
 473 {
 474     int err, errs = 0, val;
 475     MPI_Aint lb, extent, aval, true_lb;
 476     int blocks[3] = { 1, 4, 1 };
 477     MPI_Aint disps[3] = { -3, 0, 6 };
 478     MPI_Datatype types[3] = { MPI_LB, MPI_BYTE, MPI_UB };
 479
 480     MPI_Datatype inttype, eviltype;
 481
 482     /* build same type as in int_with_lb_ub_test() */
 483     err = MPI_Type_struct(3, blocks, disps, types, &inttype);
 484     if (err != MPI_SUCCESS) {
 485         errs++;
 486         if (verbose) fprintf(stderr, "  MPI_Type_struct failed.\n");
 487         if (verbose) MTestPrintError( err  );
 488         /* no point in continuing */
 489         return errs;
 490     }
 491
 492     err = MPI_Type_vector(3, 1, 1, inttype, &eviltype);
 493     if (err != MPI_SUCCESS) {
 494         errs++;
 495         if (verbose) fprintf(stderr, "  MPI_Type_vector failed.\n");
 496         if (verbose) MTestPrintError( err  );
 497         /* no point in continuing */
 498         return errs;
 499     }
 500
 501     err = MPI_Type_size(eviltype, &val);
 502     if (err != MPI_SUCCESS) {
 503         errs++;
 504         if (verbose) fprintf(stderr, "  MPI_Type_size failed.\n");
 505         if (verbose) MTestPrintError( err  );
 506     }
 507
 508     if (val != 12) {
 509         errs++;
 510         if (verbose) fprintf(stderr, "  size of type = %d; should be %d\n", val, 12);
 511     }
 512
 513     err = MPI_Type_extent(eviltype, &aval);
 514     if (err != MPI_SUCCESS) {
 515         errs++;
 516         if (verbose) fprintf(stderr, "  MPI_Type_extent failed.\n");
 517         if (verbose) MTestPrintError( err  );
 518     }
 519
 520     if (aval != 27) {
 521         errs++;
 522         if (verbose) fprintf(stderr, "  extent of type = %d; should be %d\n", (int) aval, 27);
 523     }
 524
 525     err = MPI_Type_lb(eviltype, &aval);
 526     if (err != MPI_SUCCESS) {
 527         errs++;
 528         if (verbose) fprintf(stderr, "  MPI_Type_lb failed.\n");
 529         if (verbose) MTestPrintError( err  );
 530     }
 531
 532     if (aval != -3) {
 533         errs++;
 534         if (verbose) fprintf(stderr, "  lb of type = %d; should be %d\n", (int) aval, -3);
 535     }
 536
 537     err = MPI_Type_get_extent(eviltype, &lb, &extent);
 538     if (err != MPI_SUCCESS) {
 539         errs++;
 540         if (verbose) fprintf(stderr, "  MPI_Type_get_extent failed.\n");
 541         if (verbose) MTestPrintError( err  );
 542     }
 543
 544     if (lb != -3) {
 545         errs++;
 546         if (verbose) fprintf(stderr, "  lb of type = %d; should be %d\n",
 547                              (int) aval, -3);
 548     }
 549
 550     if (extent != 27) {
 551         errs++;
 552         if (verbose) fprintf(stderr, "  extent of type = %d; should be %d\n",
 553                              (int) extent, 27);
 554     }
 555
 556     err = MPI_Type_ub(eviltype, &aval);
 557     if (err != MPI_SUCCESS) {
 558         errs++;
 559         if (verbose) fprintf(stderr, "  MPI_Type_ub failed.\n");
 560         if (verbose) MTestPrintError( err  );
 561     }
 562
 563     if (aval != 24) {
 564         errs++;
 565         if (verbose) fprintf(stderr, "  ub of type = %d; should be %d\n", (int) aval, 24);
 566     }
 567
 568     err = MPI_Type_get_true_extent(eviltype, &true_lb, &aval);
 569     if (err != MPI_SUCCESS) {
 570         errs++;
 571         if (verbose) fprintf(stderr, "  MPI_Type_get_true_extent failed.\n");
 572         if (verbose) MTestPrintError( err  );
 573     }
 574
 575     if (true_lb != 0) {
 576         errs++;
 577         if (verbose) fprintf(stderr, "  true_lb of type = %d; should be %d\n", (int) true_lb, 0);
 578     }
 579
 580     if (aval != 22) {
 581         errs++;
 582         if (verbose) fprintf(stderr, "  true extent of type = %d; should be %d\n", (int) aval, 22);
 583     }
 584
 585     MPI_Type_free( &inttype );
 586     MPI_Type_free( &eviltype );
 587
 588     return errs;
 589 }
 590
 591 /*
 592  * blklen = 4
 593  */
 594 int vector_blklen_of_int_with_lb_ub_test(void)
 595 {
 596     int err, errs = 0, val;
 597     MPI_Aint lb, extent, aval, true_lb;
 598     int blocks[3] = { 1, 4, 1 };
 599     MPI_Aint disps[3] = { -3, 0, 6 };
 600     MPI_Datatype types[3] = { MPI_LB, MPI_BYTE, MPI_UB };
 601
 602     MPI_Datatype inttype, eviltype;
 603
 604     /* build same type as in int_with_lb_ub_test() */
 605     err = MPI_Type_struct(3, blocks, disps, types, &inttype);
 606     if (err != MPI_SUCCESS) {
 607         errs++;
 608         if (verbose) fprintf(stderr, "  MPI_Type_struct failed.\n");
 609         if (verbose) MTestPrintError( err  );
 610         /* no point in continuing */
 611         return errs;
 612     }
 613
 614     err = MPI_Type_vector(3, 4, 1, inttype, &eviltype);
 615     if (err != MPI_SUCCESS) {
 616         errs++;
 617         if (verbose) fprintf(stderr, "  MPI_Type_vector failed.\n");
 618         if (verbose) MTestPrintError( err  );
 619         /* no point in continuing */
 620         return errs;
 621     }
 622
 623     err = MPI_Type_size(eviltype, &val);
 624     if (err != MPI_SUCCESS) {
 625         errs++;
 626         if (verbose) fprintf(stderr, "  MPI_Type_size failed.\n");
 627         if (verbose) MTestPrintError( err  );
 628     }
 629
 630     if (val != 48) {
 631         errs++;
 632         if (verbose) fprintf(stderr, "  size of type = %d; should be %d\n", val, 48);
 633     }
 634
 635     err = MPI_Type_extent(eviltype, &aval);
 636     if (err != MPI_SUCCESS) {
 637         errs++;
 638         if (verbose) fprintf(stderr, "  MPI_Type_extent failed.\n");
 639         if (verbose) MTestPrintError( err  );
 640     }
 641
 642     if (aval != 54) {
 643         errs++;
 644         if (verbose) fprintf(stderr, "  extent of type = %d; should be %d\n", (int) aval, 54);
 645     }
 646
 647     err = MPI_Type_lb(eviltype, &aval);
 648     if (err != MPI_SUCCESS) {
 649         errs++;
 650         if (verbose) fprintf(stderr, "  MPI_Type_lb failed.\n");
 651         if (verbose) MTestPrintError( err  );
 652     }
 653
 654     if (aval != -3) {
 655         errs++;
 656         if (verbose) fprintf(stderr, "  lb of type = %d; should be %d\n", (int) aval, -3);
 657         if (verbose) MTestPrintError( err  );
 658     }
 659
 660     err = MPI_Type_get_extent(eviltype, &lb, &extent);
 661     if (err != MPI_SUCCESS) {
 662         errs++;
 663         if (verbose) fprintf(stderr, "  MPI_Type_get_extent failed.\n");
 664         if (verbose) MTestPrintError( err  );
 665     }
 666
 667     if (lb != -3) {
 668         errs++;
 669         if (verbose) fprintf(stderr, "  lb of type = %d; should be %d\n",
 670                              (int) aval, -3);
 671     }
 672
 673     if (extent != 54) {
 674         errs++;
 675         if (verbose) fprintf(stderr, "  extent of type = %d; should be %d\n",
 676                              (int) extent, 54);
 677     }
 678
 679     err = MPI_Type_ub(eviltype, &aval);
 680     if (err != MPI_SUCCESS) {
 681         errs++;
 682         if (verbose) fprintf(stderr, "  MPI_Type_ub failed.\n");
 683         if (verbose) MTestPrintError( err  );
 684     }
 685
 686     if (aval != 51) {
 687         errs++;
 688         if (verbose) fprintf(stderr, "  ub of type = %d; should be %d\n", (int) aval, 51);
 689     }
 690
 691     err = MPI_Type_get_true_extent(eviltype, &true_lb, &aval);
 692     if (err != MPI_SUCCESS) {
 693         errs++;
 694         if (verbose) fprintf(stderr, "  MPI_Type_get_true_extent failed.\n");
 695         if (verbose) MTestPrintError( err  );
 696     }
 697
 698     if (true_lb != 0) {
 699         errs++;
 700         if (verbose) fprintf(stderr, "  true_lb of type = %d; should be %d\n", (int) true_lb, 0);
 701     }
 702
 703     if (aval != 49) {
 704         errs++;
 705         if (verbose) fprintf(stderr, "  true extent of type = %d; should be %d\n", (int) aval, 49);
 706     }
 707
 708     MPI_Type_free( &inttype );
 709     MPI_Type_free( &eviltype );
 710
 711     return errs;
 712 }
 713
 714 int vector_blklen_stride_of_int_with_lb_ub_test(void)
 715 {
 716     int err, errs = 0, val;
 717     MPI_Aint lb, extent, aval, true_lb;
 718     int blocks[3] = { 1, 4, 1 };
 719     MPI_Aint disps[3] = { -3, 0, 6 };
 720     MPI_Datatype types[3] = { MPI_LB, MPI_BYTE, MPI_UB };
 721     char *typemapstring = 0;
 722
 723     MPI_Datatype inttype, eviltype;
 724
 725     /* build same type as in int_with_lb_ub_test() */
 726     typemapstring = (char*)"{ (LB,-3),4*(BYTE,0),(UB,6) }";
 727     err = MPI_Type_struct(3, blocks, disps, types, &inttype);
 728     if (err != MPI_SUCCESS) {
 729         errs++;
 730         if (verbose) fprintf(stderr, "  MPI_Type_struct of %s failed.\n",
 731                              typemapstring );
 732         if (verbose) MTestPrintError( err  );
 733         /* No point in continuing */
 734         return errs;
 735     }
 736
 737     err = MPI_Type_vector(3, 4, 5, inttype, &eviltype);
 738     if (err != MPI_SUCCESS) {
 739         errs++;
 740         if (verbose) fprintf(stderr, "  MPI_Type_vector failed.\n");
 741         if (verbose) MTestPrintError( err  );
 742         /* no point in continuing */
 743         return errs;
 744     }
 745
 746     err = MPI_Type_size(eviltype, &val);
 747     if (err != MPI_SUCCESS) {
 748         errs++;
 749         if (verbose) fprintf(stderr, "  MPI_Type_size failed.\n");
 750         if (verbose) MTestPrintError( err  );
 751     }
 752
 753     if (val != 48) {
 754         errs++;
 755         if (verbose) fprintf(stderr, "  size of type = %d; should be %d\n", val, 48);
 756     }
 757
 758     err = MPI_Type_extent(eviltype, &aval);
 759     if (err != MPI_SUCCESS) {
 760         errs++;
 761         if (verbose) fprintf(stderr, "  MPI_Type_extent failed.\n");
 762         if (verbose) MTestPrintError( err  );
 763     }
 764
 765     if (aval != 126) {
 766         errs++;
 767         if (verbose) fprintf(stderr, "  extent of type = %d; should be %d\n", (int) aval, 126);
 768     }
 769
 770     err = MPI_Type_lb(eviltype, &aval);
 771     if (err != MPI_SUCCESS) {
 772         errs++;
 773         if (verbose) fprintf(stderr, "  MPI_Type_lb failed.\n");
 774         if (verbose) MTestPrintError( err  );
 775     }
 776
 777     if (aval != -3) {
 778         errs++;
 779         if (verbose) fprintf(stderr, "  lb of type = %d; should be %d\n", (int) aval, -3);
 780     }
 781
 782     err = MPI_Type_get_extent(eviltype, &lb, &extent);
 783     if (err != MPI_SUCCESS) {
 784         errs++;
 785         if (verbose) fprintf(stderr, "  MPI_Type_get_extent failed.\n");
 786         if (verbose) MTestPrintError( err  );
 787     }
 788
 789     if (lb != -3) {
 790         errs++;
 791         if (verbose) fprintf(stderr, "  lb of type = %d; should be %d\n",
 792                              (int) aval, -3);
 793     }
 794
 795     if (extent != 126) {
 796         errs++;
 797         if (verbose) fprintf(stderr, "  extent of type = %d; should be %d\n",
 798                              (int) extent, 126);
 799     }
 800
 801     err = MPI_Type_ub(eviltype, &aval);
 802     if (err != MPI_SUCCESS) {
 803         errs++;
 804         if (verbose) fprintf(stderr, "  MPI_Type_ub failed.\n");
 805         if (verbose) MTestPrintError( err  );
 806     }
 807
 808     if (aval != 123) {
 809         errs++;
 810         if (verbose) fprintf(stderr, "  ub of type = %d; should be %d\n", (int) aval, 123);
 811     }
 812
 813     err = MPI_Type_get_true_extent(eviltype, &true_lb, &aval);
 814     if (err != MPI_SUCCESS) {
 815         errs++;
 816         if (verbose) fprintf(stderr, "  MPI_Type_get_true_extent failed.\n");
 817         if (verbose) MTestPrintError( err  );
 818     }
 819
 820     if (true_lb != 0) {
 821         errs++;
 822         if (verbose) fprintf(stderr, "  true_lb of type = %d; should be %d\n", (int) true_lb, 0);
 823     }
 824
 825     if (aval != 121) {
 826         errs++;
 827         if (verbose) fprintf(stderr, "  true extent of type = %d; should be %d\n", (int) aval, 121);
 828     }
 829
 830     MPI_Type_free( &inttype );
 831     MPI_Type_free( &eviltype );
 832
 833     return errs;
 834 }
 835
 836 int vector_blklen_negstride_of_int_with_lb_ub_test(void)
 837 {
 838     int err, errs = 0, val;
 839     MPI_Aint lb, extent, aval, true_lb;
 840     int blocks[3] = { 1, 4, 1 };
 841     MPI_Aint disps[3] = { -3, 0, 6 };
 842     MPI_Datatype types[3] = { MPI_LB, MPI_BYTE, MPI_UB };
 843
 844     MPI_Datatype inttype, eviltype;
 845
 846     /* build same type as in int_with_lb_ub_test() */
 847     err = MPI_Type_struct(3, blocks, disps, types, &inttype);
 848     if (err != MPI_SUCCESS) {
 849         errs++;
 850         if (verbose) fprintf(stderr, "  MPI_Type_struct failed.\n");
 851         if (verbose) MTestPrintError( err  );
 852         /* no point in continuing */
 853         return errs;
 854     }
 855
 856     err = MPI_Type_vector(3, 4, -5, inttype, &eviltype);
 857     if (err != MPI_SUCCESS) {
 858         errs++;
 859         if (verbose) fprintf(stderr, "  MPI_Type_vector failed.\n");
 860         if (verbose) MTestPrintError( err  );
 861         /* no point in continuing */
 862         return errs;
 863     }
 864
 865     err = MPI_Type_size(eviltype, &val);
 866     if (err != MPI_SUCCESS) {
 867         errs++;
 868         if (verbose) fprintf(stderr, "  MPI_Type_size failed.\n");
 869         if (verbose) MTestPrintError( err  );
 870     }
 871
 872     if (val != 48) {
 873         errs++;
 874         if (verbose) fprintf(stderr, "  size of type = %d; should be %d\n", val, 48);
 875     }
 876
 877     err = MPI_Type_extent(eviltype, &aval);
 878     if (err != MPI_SUCCESS) {
 879         errs++;
 880         if (verbose) fprintf(stderr, "  MPI_Type_extent failed.\n");
 881         if (verbose) MTestPrintError( err  );
 882     }
 883
 884     if (aval != 126) {
 885         errs++;
 886         if (verbose) fprintf(stderr, "  extent of type = %d; should be %d\n", (int) aval, 126);
 887     }
 888
 889     err = MPI_Type_lb(eviltype, &aval);
 890     if (err != MPI_SUCCESS) {
 891         errs++;
 892         if (verbose) fprintf(stderr, "  MPI_Type_lb failed.\n");
 893         if (verbose) MTestPrintError( err  );
 894     }
 895
 896     if (aval != -93) {
 897         errs++;
 898         if (verbose) fprintf(stderr, "  lb of type = %d; should be %d\n", (int) aval, -93);
 899     }
 900
 901     err = MPI_Type_get_extent(eviltype, &lb, &extent);
 902     if (err != MPI_SUCCESS) {
 903         errs++;
 904         if (verbose) fprintf(stderr, "  MPI_Type_get_extent failed.\n");
 905         if (verbose) MTestPrintError( err  );
 906     }
 907
 908     if (lb != -93) {
 909         errs++;
 910         if (verbose) fprintf(stderr, "  lb of type = %d; should be %d\n",
 911                              (int) aval, -93);
 912     }
 913
 914     if (extent != 126) {
 915         errs++;
 916         if (verbose) fprintf(stderr, "  extent of type = %d; should be %d\n",
 917                              (int) extent, 126);
 918     }
 919
 920     err = MPI_Type_ub(eviltype, &aval);
 921     if (err != MPI_SUCCESS) {
 922         errs++;
 923         if (verbose) fprintf(stderr, "  MPI_Type_ub failed.\n");
 924         if (verbose) MTestPrintError( err  );
 925     }
 926
 927     if (aval != 33) {
 928         errs++;
 929         if (verbose) fprintf(stderr, "  ub of type = %d; should be %d\n", (int) aval, 33);
 930     }
 931
 932     err = MPI_Type_get_true_extent(eviltype, &true_lb, &aval);
 933     if (err != MPI_SUCCESS) {
 934         errs++;
 935         if (verbose) fprintf(stderr, "  MPI_Type_get_true_extent failed.\n");
 936         if (verbose) MTestPrintError( err  );
 937     }
 938
 939     if (true_lb != -90) {
 940         errs++;
 941         if (verbose) fprintf(stderr, "  true_lb of type = %d; should be %d\n", (int) true_lb, -90);
 942     }
 943
 944     if (aval != 121) {
 945         errs++;
 946         if (verbose) fprintf(stderr, "  true extent of type = %d; should be %d\n", (int) aval, 121);
 947     }
 948
 949     MPI_Type_free( &inttype );
 950     MPI_Type_free( &eviltype );
 951
 952     return errs;
 953 }
 954
 955 int int_with_negextent_test(void)
 956 {
 957     int err, errs = 0, val;
 958     MPI_Aint lb, extent, aval, true_lb;
 959     int blocks[3] = { 1, 4, 1 };
 960     MPI_Aint disps[3] = { 6, 0, -3 };
 961     MPI_Datatype types[3] = { MPI_LB, MPI_BYTE, MPI_UB };
 962     char *typemapstring =0;
 963
 964     MPI_Datatype eviltype;
 965
 966     typemapstring = (char*)"{ (LB,6),4*(BYTE,0),(UB,-3) }";
 967     err = MPI_Type_struct(3, blocks, disps, types, &eviltype);
 968     if (err != MPI_SUCCESS) {
 969         errs++;
 970         if (verbose) fprintf(stderr, "  MPI_Type_struct of %s failed.\n",
 971                              typemapstring );
 972         if (verbose) MTestPrintError( err  );
 973         /* No point in contiuing */
 974         return errs;
 975     }
 976
 977     err = MPI_Type_size(eviltype, &val);
 978     if (err != MPI_SUCCESS) {
 979         errs++;
 980         if (verbose) fprintf(stderr, "  MPI_Type_size failed.\n");
 981         if (verbose) MTestPrintError( err  );
 982     }
 983
 984     if (val != 4) {
 985         errs++;
 986         if (verbose) fprintf(stderr, "  size of type = %d; should be %d\n", val, 4);
 987     }
 988
 989     err = MPI_Type_extent(eviltype, &aval);
 990     if (err != MPI_SUCCESS) {
 991         errs++;
 992         if (verbose) fprintf(stderr, "  MPI_Type_extent failed.\n");
 993         if (verbose) MTestPrintError( err  );
 994     }
 995
 996     if (aval != -9) {
 997         errs++;
 998         if (verbose) fprintf(stderr, "  extent of type = %d; should be %d\n", (int) aval, -9);
 999     }
1000
1001     err = MPI_Type_lb(eviltype, &aval);
1002     if (err != MPI_SUCCESS) {
1003         errs++;
1004         if (verbose) fprintf(stderr, "  MPI_Type_lb failed.\n");
1005         if (verbose) MTestPrintError( err  );
1006     }
1007
1008     if (aval != 6) {
1009         errs++;
1010         if (verbose) fprintf(stderr, "  lb of type = %d; should be %d\n", (int) aval, 6);
1011     }
1012
1013     err = MPI_Type_get_extent(eviltype, &lb, &extent);
1014     if (err != MPI_SUCCESS) {
1015         errs++;
1016         if (verbose) fprintf(stderr, "  MPI_Type_get_extent failed.\n");
1017         if (verbose) MTestPrintError( err  );
1018     }
1019
1020     if (lb != 6) {
1021         errs++;
1022         if (verbose) fprintf(stderr, "  lb of type = %d; should be %d\n",
1023                              (int) aval, 6);
1024     }
1025
1026     if (extent != -9) {
1027         errs++;
1028         if (verbose) fprintf(stderr, "  extent of type = %d; should be %d\n",
1029                              (int) extent, -9);
1030     }
1031
1032     err = MPI_Type_ub(eviltype, &aval);
1033     if (err != MPI_SUCCESS) {
1034         errs++;
1035         if (verbose) fprintf(stderr, "  MPI_Type_ub failed.\n");
1036         if (verbose) MTestPrintError( err  );
1037     }
1038
1039     if (aval != -3) {
1040         errs++;
1041         if (verbose) fprintf(stderr, "  ub of type = %d; should be %d\n", (int) aval, -3);
1042     }
1043
1044     err = MPI_Type_get_true_extent(eviltype, &true_lb, &aval);
1045     if (err != MPI_SUCCESS) {
1046         errs++;
1047         if (verbose) fprintf(stderr, "  MPI_Type_get_true_extent failed.\n");
1048         if (verbose) MTestPrintError( err  );
1049     }
1050
1051     if (true_lb != 0) {
1052         errs++;
1053         if (verbose) fprintf(stderr, "  true_lb of type = %d; should be %d\n", (int) true_lb, 0);
1054     }
1055
1056     if (aval != 4) {
1057         errs++;
1058         if (verbose) fprintf(stderr, "  true extent of type = %d; should be %d\n", (int) aval, 4);
1059     }
1060
1061     MPI_Type_free(&eviltype);
1062
1063     return errs;
1064 }
1065
1066 int vector_blklen_stride_negextent_of_int_with_lb_ub_test(void)
1067 {
1068     int err, errs = 0, val;
1069     MPI_Aint lb, extent, true_lb, aval;
1070     int blocks[3] = { 1, 4, 1 };
1071     MPI_Aint disps[3] = { 6, 0, -3 };
1072     MPI_Datatype types[3] = { MPI_LB, MPI_BYTE, MPI_UB };
1073     MPI_Datatype inttype, eviltype;
1074     char *typemapstring = 0;
1075
1076     /* build same type as in int_with_lb_ub_test() */
1077     typemapstring = (char*)"{ (LB,6),4*(BYTE,0),(UB,-3) }";
1078     err = MPI_Type_struct(3, blocks, disps, types, &inttype);
1079     if (err != MPI_SUCCESS) {
1080         errs++;
1081         if (verbose) fprintf(stderr, "  MPI_Type_struct of %s failed.\n",
1082                              typemapstring );
1083         if (verbose) MTestPrintError( err  );
1084         /* No point in continuing */
1085         return errs;
1086     }
1087
1088     err = MPI_Type_vector(3, 4, 5, inttype, &eviltype);
1089     if (err != MPI_SUCCESS) {
1090         errs++;
1091         if (verbose) fprintf(stderr, "  MPI_Type_vector failed.\n");
1092         if (verbose) MTestPrintError( err  );
1093         /* no point in continuing */
1094         return errs;
1095     }
1096
1097     err = MPI_Type_size(eviltype, &val);
1098     if (err != MPI_SUCCESS) {
1099         errs++;
1100         if (verbose) fprintf(stderr, "  MPI_Type_size failed.\n");
1101         if (verbose) MTestPrintError( err  );
1102     }
1103
1104     if (val != 48) {
1105         errs++;
1106         if (verbose) fprintf(stderr, "  size of type = %d; should be %d\n", val, 48);
1107     }
1108
1109     err = MPI_Type_extent(eviltype, &aval);
1110     if (err != MPI_SUCCESS) {
1111         errs++;
1112         if (verbose) fprintf(stderr, "  MPI_Type_extent failed.\n");
1113         if (verbose) MTestPrintError( err  );
1114     }
1115
1116     if (aval != 108) {
1117         errs++;
1118         if (verbose) fprintf(stderr, "  extent of type = %d; should be %d\n", (int) aval, 108);
1119     }
1120
1121     err = MPI_Type_lb(eviltype, &aval);
1122     if (err != MPI_SUCCESS) {
1123         errs++;
1124         if (verbose) fprintf(stderr, "  MPI_Type_lb failed.\n");
1125         if (verbose) MTestPrintError( err  );
1126     }
1127
1128     if (aval != -111) {
1129         errs++;
1130         if (verbose) fprintf(stderr, "  lb of type = %d; should be %d\n", (int) aval, -111);
1131     }
1132
1133     err = MPI_Type_get_extent(eviltype, &lb, &extent);
1134     if (err != MPI_SUCCESS) {
1135         errs++;
1136         if (verbose) fprintf(stderr, "  MPI_Type_get_extent failed.\n");
1137         if (verbose) MTestPrintError( err  );
1138     }
1139
1140     if (lb != -111) {
1141         errs++;
1142         if (verbose) fprintf(stderr, "  lb of type = %d; should be %d\n",
1143                              (int) aval, -111);
1144     }
1145
1146     if (extent != 108) {
1147         errs++;
1148         if (verbose) fprintf(stderr, "  extent of type = %d; should be %d\n",
1149                              (int) extent, 108);
1150     }
1151
1152     err = MPI_Type_ub(eviltype, &aval);
1153     if (err != MPI_SUCCESS) {
1154         errs++;
1155         if (verbose) fprintf(stderr, "  MPI_Type_ub failed.\n");
1156         if (verbose) MTestPrintError( err  );
1157     }
1158
1159     if (aval != -3) {
1160         errs++;
1161         if (verbose) fprintf(stderr, "  ub of type = %d; should be %d\n", (int) aval, -3);
1162     }
1163
1164     err = MPI_Type_get_true_extent(eviltype, &true_lb, &aval);
1165     if (err != MPI_SUCCESS) {
1166         errs++;
1167         if (verbose) fprintf(stderr, "  MPI_Type_get_true_extent failed.\n");
1168         if (verbose) MTestPrintError( err  );
1169     }
1170
1171     if (true_lb != -117) {
1172         errs++;
1173         if (verbose) fprintf(stderr, "  true_lb of type = %d; should be %d\n", (int) true_lb, -117);
1174     }
1175
1176     if (aval != 121) {
1177         errs++;
1178         if (verbose) fprintf(stderr, "  true extent of type = %d; should be %d\n", (int) aval, 121);
1179     }
1180
1181     MPI_Type_free( &inttype );
1182     MPI_Type_free( &eviltype );
1183
1184     return errs;
1185 }
1186
1187 int vector_blklen_negstride_negextent_of_int_with_lb_ub_test(void)
1188 {
1189     int err, errs = 0, val;
1190     MPI_Aint extent, lb, aval, true_lb;
1191     int blocks[3] = { 1, 4, 1 };
1192     MPI_Aint disps[3] = { 6, 0, -3 };
1193     MPI_Datatype types[3] = { MPI_LB, MPI_BYTE, MPI_UB };
1194
1195     MPI_Datatype inttype, eviltype;
1196
1197     /* build same type as in int_with_lb_ub_test() */
1198     err = MPI_Type_struct(3, blocks, disps, types, &inttype);
1199     if (err != MPI_SUCCESS) {
1200         errs++;
1201         if (verbose) fprintf(stderr, "  MPI_Type_struct failed.\n");
1202         if (verbose) MTestPrintError( err  );
1203         /* no point in continuing */
1204         return errs;
1205     }
1206
1207     err = MPI_Type_vector(3, 4, -5, inttype, &eviltype);
1208     if (err != MPI_SUCCESS) {
1209         errs++;
1210         if (verbose) fprintf(stderr, "  MPI_Type_vector failed.\n");
1211         if (verbose) MTestPrintError( err  );
1212         /* no point in continuing */
1213         return errs;
1214     }
1215
1216     err = MPI_Type_size(eviltype, &val);
1217     if (err != MPI_SUCCESS) {
1218         errs++;
1219         if (verbose) fprintf(stderr, "  MPI_Type_size failed.\n");
1220         if (verbose) MTestPrintError( err  );
1221     }
1222
1223     if (val != 48) {
1224         errs++;
1225         if (verbose) fprintf(stderr, "  size of type = %d; should be %d\n", val, 48);
1226     }
1227
1228     err = MPI_Type_extent(eviltype, &aval);
1229     if (err != MPI_SUCCESS) {
1230         errs++;
1231         if (verbose) fprintf(stderr, "  MPI_Type_extent failed.\n");
1232         if (verbose) MTestPrintError( err  );
1233     }
1234
1235     if (aval != 108) {
1236         errs++;
1237         if (verbose) fprintf(stderr, "  extent of type = %ld; should be %d\n", (long) aval, 108);
1238     }
1239
1240     err = MPI_Type_lb(eviltype, &aval);
1241     if (err != MPI_SUCCESS) {
1242         errs++;
1243         if (verbose) fprintf(stderr, "  MPI_Type_lb failed.\n");
1244         if (verbose) MTestPrintError( err  );
1245     }
1246
1247     if (aval != -21) {
1248         errs++;
1249         if (verbose) fprintf(stderr, "  lb of type = %ld; should be %d\n", (long) aval, -21);
1250     }
1251
1252     err = MPI_Type_get_extent(eviltype, &lb, &extent);
1253     if (err != MPI_SUCCESS) {
1254         errs++;
1255         if (verbose) fprintf(stderr, "  MPI_Type_get_extent failed.\n");
1256         if (verbose) MTestPrintError( err  );
1257     }
1258
1259     if (lb != -21) {
1260         errs++;
1261         if (verbose) fprintf(stderr, "  lb of type = %ld; should be %d\n",
1262                              (long) aval, -21);
1263     }
1264
1265     if (extent != 108) {
1266         errs++;
1267         if (verbose) fprintf(stderr, "  extent of type = %ld; should be %d\n",
1268                              (long) extent, 108);
1269     }
1270
1271
1272     err = MPI_Type_ub(eviltype, &aval);
1273     if (err != MPI_SUCCESS) {
1274         errs++;
1275         if (verbose) fprintf(stderr, "  MPI_Type_ub failed.\n");
1276         if (verbose) MTestPrintError( err  );
1277     }
1278
1279     if (aval != 87) {
1280         errs++;
1281         if (verbose) fprintf(stderr, "  ub of type = %ld; should be %d\n", (long) aval, 87);
1282     }
1283
1284     err = MPI_Type_get_true_extent(eviltype, &true_lb, &aval);
1285     if (err != MPI_SUCCESS) {
1286         errs++;
1287         if (verbose) fprintf(stderr, "  MPI_Type_get_true_extent failed.\n");
1288         if (verbose) MTestPrintError( err  );
1289     }
1290
1291     if (true_lb != -27) {
1292         errs++;
1293         if (verbose) fprintf(stderr, "  true_lb of type = %ld; should be %d\n", (long) true_lb, -27);
1294     }
1295
1296     if (aval != 121) {
1297         errs++;
1298         if (verbose) fprintf(stderr, "  true extent of type = %ld; should be %d\n", (long) aval, 121);
1299     }
1300
1301     MPI_Type_free( &inttype );
1302     MPI_Type_free( &eviltype );
1303
1304     return errs;
1305 }