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