text: /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */
  /*
   *
   *  (C) 2001 by Argonne National Laboratory.
   *      See COPYRIGHT in top-level directory.
   */
  
  /*
     Test the group routines
     (some tested elsewere)
  
  MPI_Group_compare
  MPI_Group_excl
  MPI_Group_intersection
  MPI_Group_range_excl
  MPI_Group_rank
  MPI_Group_size
  MPI_Group_translate_ranks
  MPI_Group_union
  
   */
  #include "mpi.h"
  #include <stdio.h>
  /* stdlib.h Needed for malloc declaration */
  #include <stdlib.h>
  #include "mpitest.h"
  
  int main(int argc, char **argv)
  {
      int errs = 0;
      MPI_Group basegroup;
      MPI_Group g1, g2, g3, g4, g5, g6, g7, g8, g9, g10;
      MPI_Group g3a, g3b;
      MPI_Comm comm, newcomm, splitcomm, dupcomm;
      int i, grp_rank, rank, grp_size, size, result;
      int nranks, *ranks, *ranks_out;
      int range[1][3];
      int worldrank;
  
      MTest_Init(&argc, &argv);
      MPI_Comm_rank(MPI_COMM_WORLD, &worldrank);
  
      comm = MPI_COMM_WORLD;
  
      MPI_Comm_group(comm, &basegroup);
      MPI_Comm_rank(comm, &rank);
      MPI_Comm_size(comm, &size);
  
  /* Get the basic information on this group */
      MPI_Group_rank(basegroup, &grp_rank);
      if (grp_rank != rank) {
          errs++;
          fprintf(stdout, "group rank %d != comm rank %d\n", grp_rank, rank);
      }
  
      MPI_Group_size(basegroup, &grp_size);
      if (grp_size != size) {
          errs++;
          fprintf(stdout, "group size %d != comm size %d\n", grp_size, size);
      }
  
  
  /* Form a new communicator with inverted ranking */
      MPI_Comm_split(comm, 0, size - rank, &newcomm);
      MPI_Comm_group(newcomm, &g1);
      ranks = (int *) malloc(size * sizeof(int));
      ranks_out = (int *) malloc(size * sizeof(int));
      for (i = 0; i < size; i++)
          ranks[i] = i;
      nranks = size;
      MPI_Group_translate_ranks(g1, nranks, ranks, basegroup, ranks_out);
      for (i = 0; i < size; i++) {
          if (ranks_out[i] != (size - 1) - i) {
              errs++;
              fprintf(stdout, "Translate ranks got %d expected %d\n", ranks_out[i], (size - 1) - i);
          }
      }
  
  /* Check Compare */
      MPI_Group_compare(basegroup, g1, &result);
      if (result != MPI_SIMILAR) {
          errs++;
          fprintf(stdout, "Group compare should have been similar, was %d\n", result);
      }
      MPI_Comm_dup(comm, &dupcomm);
      MPI_Comm_group(dupcomm, &g2);
      MPI_Group_compare(basegroup, g2, &result);
      if (result != MPI_IDENT) {
          errs++;
          fprintf(stdout, "Group compare should have been ident, was %d\n", result);
      }
      MPI_Comm_split(comm, rank < size / 2, rank, &splitcomm);
      MPI_Comm_group(splitcomm, &g3);
      MPI_Group_compare(basegroup, g3, &result);
      if (result != MPI_UNEQUAL) {
          errs++;
          fprintf(stdout, "Group compare should have been unequal, was %d\n", result);
      }
  
      /* Build two groups that have this process and one other, but do not
       * have the same processes */
      ranks[0] = rank;
      ranks[1] = (rank + 1) % size;
      MPI_Group_incl(basegroup, 2, ranks, &g3a);
      ranks[1] = (rank + size - 1) % size;
      MPI_Group_incl(basegroup, 2, ranks, &g3b);
      MPI_Group_compare(g3a, g3b, &result);
      if (result != MPI_UNEQUAL) {
          errs++;
          fprintf(stdout,
                  "Group compare of equal sized but different groups should have been unequal, was %d\n",
                  result);
      }
  
  
  /* Build two new groups by excluding members; use Union to put them
     together again */
  
  /* Exclude 0 */
      for (i = 0; i < size; i++)
          ranks[i] = i;
      MPI_Group_excl(basegroup, 1, ranks, &g4);
  /* Exclude 1-(size-1) */
      MPI_Group_excl(basegroup, size - 1, ranks + 1, &g5);
      MPI_Group_union(g5, g4, &g6);
      MPI_Group_compare(basegroup, g6, &result);
      if (result != MPI_IDENT) {
          int usize;
          errs++;
          /* See ordering requirements on union */
          fprintf(stdout, "Group excl and union did not give ident groups\n");
          fprintf(stdout, "[%d] result of compare was %d\n", rank, result);
          MPI_Group_size(g6, &usize);
          fprintf(stdout, "Size of union is %d, should be %d\n", usize, size);
      }
      MPI_Group_union(basegroup, g4, &g7);
      MPI_Group_compare(basegroup, g7, &result);
      if (result != MPI_IDENT) {
          int usize;
          errs++;
          fprintf(stdout, "Group union of overlapping groups failed\n");
          fprintf(stdout, "[%d] result of compare was %d\n", rank, result);
          MPI_Group_size(g7, &usize);
          fprintf(stdout, "Size of union is %d, should be %d\n", usize, size);
      }
  
  /* Use range_excl instead of ranks */
      /* printf ("range excl\n"); fflush(stdout); */
      range[0][0] = 1;
      range[0][1] = size - 1;
      range[0][2] = 1;
      MPI_Group_range_excl(basegroup, 1, range, &g8);
      /* printf("out  of range excl\n"); fflush(stdout); */
      MPI_Group_compare(g5, g8, &result);
      /* printf("out of compare\n"); fflush(stdout); */
      if (result != MPI_IDENT) {
          errs++;
          fprintf(stdout, "Group range excl did not give ident groups\n");
      }
  
      /* printf("intersection\n"); fflush(stdout); */
      MPI_Group_intersection(basegroup, g4, &g9);
      MPI_Group_compare(g9, g4, &result);
      if (result != MPI_IDENT) {
          errs++;
          fprintf(stdout, "Group intersection did not give ident groups\n");
      }
  
  /* Exclude EVERYTHING and check against MPI_GROUP_EMPTY */
      /* printf("range excl all\n"); fflush(stdout); */
      range[0][0] = 0;
      range[0][1] = size - 1;
      range[0][2] = 1;
      MPI_Group_range_excl(basegroup, 1, range, &g10);
  
      /* printf("done range excl all\n"); fflush(stdout); */
      MPI_Group_compare(g10, MPI_GROUP_EMPTY, &result);
      /* printf("done compare to MPI_GROUP_EMPTY\n"); fflush(stdout); */
  
      if (result != MPI_IDENT) {
          errs++;
          fprintf(stdout, "MPI_GROUP_EMPTY didn't compare against empty group\n");
      }
  
      /* printf("freeing groups\n"); fflush(stdout); */
      MPI_Group_free(&basegroup);
      MPI_Group_free(&g1);
      MPI_Group_free(&g2);
      MPI_Group_free(&g3);
      MPI_Group_free(&g3a);
      MPI_Group_free(&g3b);
      MPI_Group_free(&g4);
      MPI_Group_free(&g5);
      MPI_Group_free(&g6);
      MPI_Group_free(&g7);
      MPI_Group_free(&g8);
      MPI_Group_free(&g9);
      MPI_Group_free(&g10);
      MPI_Comm_free(&dupcomm);
      MPI_Comm_free(&splitcomm);
      MPI_Comm_free(&newcomm);
  
      free(ranks);
      free(ranks_out);
      MTest_Finalize(errs);
      return MTestReturnValue(errs);
  }
  