TPLTraits.cpp

Go to the documentation of this file.

// @HEADER
// *****************************************************************************
//   Zoltan2: A package of combinatorial algorithms for scientific computing
//
// Copyright 2012 NTESS and the Zoltan2 contributors.
// SPDX-License-Identifier: BSD-3-Clause
// *****************************************************************************
// @HEADER
 
// Unit test for Zoltan2_TPLTraits.hpp
// Passes various zgno_t types to ASSIGN.
// Some combinations should work without error; 
// for these, this test FAILS if ASSIGN throws an error.
// Some combinations should throw an error; 
// for these, this test says it is GOOD if ASSIGN throws an error.
 
#include <Teuchos_RCP.hpp>
#include <Zoltan2_Environment.hpp>
#include <Zoltan2_TPLTraits.hpp>
 
#define MAX(a,b) ((a) > (b) ? (a) : (b))
 
#ifdef HAVE_ZOLTAN2_SCOTCH
// stdint.h for int64_t in scotch header
#include <stdint.h>
extern "C"{
#ifndef HAVE_ZOLTAN2_MPI
#include "scotch.h"
#else
#include "ptscotch.h"
#endif
}
#endif   // HAVE_ZOLTAN2_SCOTCH
 
#ifdef HAVE_ZOLTAN2_PARMETIS
 
extern "C"{
#include "parmetis.h"
}
 
#define PARMETIS_IS_OK 1
 
#endif  // HAVE_ZOLTAN2_MPI
 
 
#define PRINTMSG(s) \
  std::cout << (s) << " " << __FILE__ << ":" << __LINE__ << std::endl
 
int main(int narg, char *arg[])
{
  Tpetra::ScopeGuard tscope(&narg, &arg);
 
  int ierr = 0;
 
  // Test conversions into integers
 
  // Assignments that should always work 
  // (since the zgno value fits in an integer)
  int intIdx;
  try {
    int zgno = 123;
    Zoltan2::TPL_Traits<int,int>::ASSIGN(intIdx, zgno);
  }
  catch (std::exception &e) {
    PRINTMSG("FAIL: int to int");
    ierr++;
  }
 
  try {
    unsigned int zgno = 123;
    Zoltan2::TPL_Traits<int,unsigned int>::ASSIGN(intIdx, zgno);
  }
  catch (std::exception &e) {
    PRINTMSG("FAIL: unsigned int to int");
    ierr++;
  }
 
  try {
    long zgno = 123;
    Zoltan2::TPL_Traits<int,long>::ASSIGN(intIdx, zgno);
  }
  catch (std::exception &e) {
    PRINTMSG("FAIL: long to int");
    ierr++;
  }
 
  try {
    size_t zgno = 123;
    Zoltan2::TPL_Traits<int,size_t>::ASSIGN(intIdx, zgno);
  }
  catch (std::exception &e) {
    PRINTMSG("FAIL: size_t to int");
    ierr++;
  }
 
  // Assignments that should not work
  try {
    long long zgno = (long long)1 << 40;
    Zoltan2::TPL_Traits<int,long long>::ASSIGN(intIdx, zgno);
  }
  catch (std::exception &e) {
    PRINTMSG("GOOD: big long long to int throws exception");
  }
 
  try {
    size_t zgno = (size_t)1 << 40;
    Zoltan2::TPL_Traits<int,size_t>::ASSIGN(intIdx, zgno);
  }
  catch (std::exception &e) {
    PRINTMSG("GOOD: big size_t to int throws exception");
  }
 
  try {
    unsigned zgno = (1 << 31) + 1;
    Zoltan2::TPL_Traits<int,unsigned>::ASSIGN(intIdx, zgno);
  }
  catch (std::exception &e) {
    PRINTMSG("GOOD: huge unsigned to int throws exception");
  }
 
  // Test conversions into size_t
 
  // Assignments that should always work 
 
  size_t sizetIdx;
  try {
    long long zgno = (long long)1 << 40;
    Zoltan2::TPL_Traits<size_t,long long>::ASSIGN(sizetIdx, zgno);
  }
  catch (std::exception &e) {
    PRINTMSG("FAIL: big long long to size_t");
    ierr++;
  }
 
  try {
    size_t zgno = (size_t)1 << 40;
    Zoltan2::TPL_Traits<size_t,size_t>::ASSIGN(sizetIdx, zgno);
  }
  catch (std::exception &e) {
    PRINTMSG("FAIL: big size_t to size_t");
    ierr++;
  }
 
  // Test conversions into int64_t
 
  // Assignments that should always work 
 
  int64_t int64Idx;
  try {
    long long zgno = (long long)1 << 40;
    Zoltan2::TPL_Traits<int64_t,long long>::ASSIGN(int64Idx, zgno);
  }
  catch (std::exception &e) {
    PRINTMSG("FAIL: big long long to int64_t");
    ierr++;
  }
 
  try {
    size_t zgno = (size_t)1 << 40;
    Zoltan2::TPL_Traits<int64_t,size_t>::ASSIGN(int64Idx, zgno);
  }
  catch (std::exception &e) {
    PRINTMSG("FAIL: big size_t to int64_t");
    ierr++;
  }
 
  // Assignments that should not work
  try {
    size_t zgno = ((size_t)1 << 63) + 1 ;
    Zoltan2::TPL_Traits<int64_t,size_t>::ASSIGN(int64Idx, zgno);
  }
  catch (std::exception &e) {
    PRINTMSG("GOOD: huge size_t to int64_t threw exception");
  }
 
#ifdef HAVE_ZOLTAN2_SCOTCH
  // Test conversions into SCOTCH_Num
 
  SCOTCH_Num scotchIdx;
 
  // Assignments that should always work 
  // (since the zgno value fits in an integer)
  try {
    int zgno = 123;
    Zoltan2::TPL_Traits<SCOTCH_Num,int>::ASSIGN(scotchIdx, zgno);
  }
  catch (std::exception &e) {
    PRINTMSG("FAIL: int to SCOTCH_Num");
    ierr++;
  }
 
  try {
    unsigned int zgno = 123;
    Zoltan2::TPL_Traits<SCOTCH_Num,unsigned int>::ASSIGN(scotchIdx, zgno);
  }
  catch (std::exception &e) {
    PRINTMSG("FAIL: unsigned int to SCOTCH_Num");
    ierr++;
  }
 
  try {
    long zgno = 123;
    Zoltan2::TPL_Traits<SCOTCH_Num,long>::ASSIGN(scotchIdx, zgno);
  }
  catch (std::exception &e) {
    PRINTMSG("FAIL: long to SCOTCH_Num");
    ierr++;
  }
 
  try {
    size_t zgno = 123;
    Zoltan2::TPL_Traits<SCOTCH_Num,size_t>::ASSIGN(scotchIdx, zgno);
  }
  catch (std::exception &e) {
    PRINTMSG("FAIL: size_t to SCOTCH_Num");
    ierr++;
  }
 
  if (sizeof(SCOTCH_Num) == 8) {
 
    try {
      long long zgno = (long long)1 << 40;
      Zoltan2::TPL_Traits<SCOTCH_Num,long long>::ASSIGN(scotchIdx, zgno);
    }
    catch (std::exception &e) {
      PRINTMSG("FAIL: big unsigned int to SCOTCH_Num");
      ierr++;
    }
 
    try {
      size_t zgno = (size_t)1 << 40;
      Zoltan2::TPL_Traits<SCOTCH_Num,size_t>::ASSIGN(scotchIdx, zgno);
    }
    catch (std::exception &e) {
      PRINTMSG("FAIL: big size_t to SCOTCH_Num");
      ierr++;
    }
  }
 
  // Assignments that should not work
  if (sizeof(SCOTCH_Num) == 4) {
    try {
      long long zgno = (long long)1 << 40;
      Zoltan2::TPL_Traits<SCOTCH_Num,long long>::ASSIGN(scotchIdx, zgno);
    }
    catch (std::exception &e) {
      PRINTMSG("GOOD: big long long to 4-byte SCOTCH_Num throws exception");
    }
 
    try {
      size_t zgno = (size_t)1 << 40;
      Zoltan2::TPL_Traits<SCOTCH_Num,size_t>::ASSIGN(scotchIdx, zgno);
    }
    catch (std::exception &e) {
      PRINTMSG("GOOD: big size_t to 4-byte SCOTCH_Num throws exception");
    }
  }
 
#endif  // HAVE_ZOLTAN2_SCOTCH
 
#ifdef PARMETIS_IS_OK
  // Test conversions into ParMETIS' idx_t
 
  idx_t parmetisIdx;
 
  // Assignments that should always work 
  // (since the zgno value fits in an integer)
  try {
    int zgno = 123;
    Zoltan2::TPL_Traits<idx_t,int>::ASSIGN(parmetisIdx, zgno);
  }
  catch (std::exception &e) {
    PRINTMSG("FAIL: int to ParMETIS' idx_t");
    ierr++;
  }
 
  try {
    unsigned int zgno = 123;
    Zoltan2::TPL_Traits<idx_t,unsigned int>::ASSIGN(parmetisIdx, zgno);
  }
  catch (std::exception &e) {
    PRINTMSG("FAIL: unsigned int to ParMETIS' idx_t");
    ierr++;
  }
 
  try {
    long zgno = 123;
    Zoltan2::TPL_Traits<idx_t,long>::ASSIGN(parmetisIdx, zgno);
  }
  catch (std::exception &e) {
    PRINTMSG("FAIL: long to ParMETIS' idx_t");
    ierr++;
  }
 
  try {
    size_t zgno = 123;
    Zoltan2::TPL_Traits<idx_t,size_t>::ASSIGN(parmetisIdx, zgno);
  }
  catch (std::exception &e) {
    PRINTMSG("FAIL: size_t to ParMETIS' idx_t");
    ierr++;
  }
 
  if (sizeof(idx_t) == 8) {
 
    try {
      long long zgno = (long long)1 << 40;
      Zoltan2::TPL_Traits<idx_t,long long>::ASSIGN(parmetisIdx, zgno);
    }
    catch (std::exception &e) {
      PRINTMSG("FAIL: big unsigned int to ParMETIS' idx_t");
      ierr++;
    }
 
    try {
      size_t zgno = (size_t)1 << 40;
      Zoltan2::TPL_Traits<idx_t,size_t>::ASSIGN(parmetisIdx, zgno);
    }
    catch (std::exception &e) {
      PRINTMSG("FAIL: big size_t to ParMETIS' idx_t");
      ierr++;
    }
  }
 
  // Assignments that should not work
  if (sizeof(idx_t) == 4) {
    try {
      long long zgno = (long long)1 << 40;
      Zoltan2::TPL_Traits<idx_t,long long>::ASSIGN(parmetisIdx, zgno);
    }
    catch (std::exception &e) {
      PRINTMSG("GOOD: big long long to 4-byte ParMETIS' idx_t throws exception");
    }
 
    try {
      size_t zgno = (size_t)1 << 40;
      Zoltan2::TPL_Traits<idx_t,size_t>::ASSIGN(parmetisIdx, zgno);
    }
    catch (std::exception &e) {
      PRINTMSG("GOOD: big size_t to 4-byte ParMETIS' idx_t throws exception");
    }
  }
#endif
 
  // Test conversions into and from ZOLTAN_ID_PTR
 
  ZOLTAN_ID_PTR zoltanGID = new ZOLTAN_ID_TYPE[4];
 
  {
    typedef char test_t;
    test_t zgno = 'a';
    zoltanGID[0] = 0; zoltanGID[1] = 0; zoltanGID[2] = 0; zoltanGID[3] = 0;
 
    int num_gid = MAX(1, sizeof(test_t) / sizeof(ZOLTAN_ID_TYPE));
    if (Zoltan2::TPL_Traits<ZOLTAN_ID_PTR,test_t>::NUM_ID != num_gid) {
      PRINTMSG("FAIL: NUM_ID wrong for char");
      ierr++;
    }
 
    Zoltan2::TPL_Traits<ZOLTAN_ID_PTR,test_t>::ASSIGN(zoltanGID, zgno);
    if (zoltanGID[0] != ZOLTAN_ID_TYPE(zgno) || zoltanGID[1] != 0 || 
        zoltanGID[2] != 0 || zoltanGID[3] != 0) {
      PRINTMSG("FAIL: char to ZOLTAN_ID_PTR");
      ierr++;
    }
 
    test_t back;
    Zoltan2::TPL_Traits<test_t,ZOLTAN_ID_PTR>::ASSIGN(back, zoltanGID);
    if (back != zgno) {
      PRINTMSG("FAIL: ZOLTAN_ID_PTR to char");
      ierr++;
    }
  }
 
  {
    typedef short test_t;
    test_t zgno = 63;
    zoltanGID[0] = 0; zoltanGID[1] = 0; zoltanGID[2] = 0; zoltanGID[3] = 0;
 
    int num_gid = MAX(1, sizeof(test_t) / sizeof(ZOLTAN_ID_TYPE));
    if (Zoltan2::TPL_Traits<ZOLTAN_ID_PTR,test_t>::NUM_ID != num_gid) {
      PRINTMSG("FAIL: NUM_ID wrong for short");
      ierr++;
    }
 
    Zoltan2::TPL_Traits<ZOLTAN_ID_PTR,test_t>::ASSIGN(zoltanGID, zgno);
    if (zoltanGID[0] != ZOLTAN_ID_TYPE(zgno) || zoltanGID[1] != 0 || 
        zoltanGID[2] != 0 || zoltanGID[3] != 0) {
      PRINTMSG("FAIL: short to ZOLTAN_ID_PTR");
      ierr++;
    }
 
    test_t back;
    Zoltan2::TPL_Traits<test_t,ZOLTAN_ID_PTR>::ASSIGN(back, zoltanGID);
    if (back != zgno) {
      PRINTMSG("FAIL: ZOLTAN_ID_PTR to short");
      ierr++;
    }
  }
 
  {
    typedef int test_t;
    test_t zgno = 123;
    zoltanGID[0] = 0; zoltanGID[1] = 0; zoltanGID[2] = 0; zoltanGID[3] = 0;
 
    int num_gid = MAX(1, sizeof(test_t) / sizeof(ZOLTAN_ID_TYPE));
    if (Zoltan2::TPL_Traits<ZOLTAN_ID_PTR,test_t>::NUM_ID != num_gid) {
      PRINTMSG("FAIL: NUM_ID wrong for int");
      ierr++;
    }
 
    Zoltan2::TPL_Traits<ZOLTAN_ID_PTR,test_t>::ASSIGN(zoltanGID, zgno);
    if (zoltanGID[0] != ZOLTAN_ID_TYPE(zgno) || zoltanGID[1] != 0 || 
        zoltanGID[2] != 0 || zoltanGID[3] != 0) {
      PRINTMSG("FAIL: int to ZOLTAN_ID_PTR");
      ierr++;
    }
 
    test_t back;
    Zoltan2::TPL_Traits<test_t,ZOLTAN_ID_PTR>::ASSIGN(back, zoltanGID);
    if (back != zgno) {
      PRINTMSG("FAIL: ZOLTAN_ID_PTR to int");
      ierr++;
    }
  }
 
  {
    typedef unsigned int test_t;
    test_t zgno = 456;
    zoltanGID[0] = 0; zoltanGID[1] = 0; zoltanGID[2] = 0; zoltanGID[3] = 0;
 
    int num_gid = MAX(1, sizeof(test_t) / sizeof(ZOLTAN_ID_TYPE));
    if (Zoltan2::TPL_Traits<ZOLTAN_ID_PTR,test_t>::NUM_ID != num_gid) {
      PRINTMSG("FAIL: NUM_ID wrong for unsigned int");
      ierr++;
    }
 
    Zoltan2::TPL_Traits<ZOLTAN_ID_PTR,test_t>::ASSIGN(zoltanGID, zgno);
    if (zoltanGID[0] != zgno || zoltanGID[1] != 0 || 
        zoltanGID[2] != 0 || zoltanGID[3] != 0) {
      PRINTMSG("FAIL: unsigned int to ZOLTAN_ID_PTR");
      ierr++;
    }
 
    test_t back;
    Zoltan2::TPL_Traits<test_t,ZOLTAN_ID_PTR>::ASSIGN(back, zoltanGID);
    if (back != zgno) {
      PRINTMSG("FAIL: ZOLTAN_ID_PTR to unsigned int");
      ierr++;
    }
  }
 
  {
    typedef long long test_t;
    test_t zgno = ((test_t)1 << 34) + (test_t)17;
    zoltanGID[0] = 0; zoltanGID[1] = 0; zoltanGID[2] = 0; zoltanGID[3] = 0;
 
    int num_gid = MAX(1, sizeof(test_t) / sizeof(ZOLTAN_ID_TYPE));
    if (Zoltan2::TPL_Traits<ZOLTAN_ID_PTR,test_t>::NUM_ID != num_gid) {
      PRINTMSG("FAIL: NUM_ID wrong for long long");
      ierr++;
    }
 
    Zoltan2::TPL_Traits<ZOLTAN_ID_PTR,test_t>::ASSIGN(zoltanGID, zgno);
    if (sizeof(ZOLTAN_ID_TYPE) == sizeof(unsigned int)) {
      if (zoltanGID[0] != 17 || zoltanGID[1] != 4 || 
          zoltanGID[2] != 0 || zoltanGID[3] != 0) {
        PRINTMSG("FAIL: long long to ZOLTAN_ID_PTR");
        ierr++;
      }
    }
    else if (sizeof(ZOLTAN_ID_TYPE) == sizeof(unsigned long long)) {
      if (test_t(zoltanGID[0]) != zgno || zoltanGID[1] != 0 ||
          zoltanGID[2] != 0 || zoltanGID[3] != 0) {
        PRINTMSG("FAIL: long long to ZOLTAN_ID_PTR");
        ierr++;
      }
    }
    else {
      // should never get here 
      PRINTMSG("FAIL: unknown sizeof(ZOLTAN_ID_TYPE)");
      ierr++;
    }
 
 
    test_t back;
    Zoltan2::TPL_Traits<test_t,ZOLTAN_ID_PTR>::ASSIGN(back, zoltanGID);
    if (back != zgno) {
      std::cout << "back " << back << " != zgno " << zgno << std::endl;
      PRINTMSG("FAIL: ZOLTAN_ID_PTR to long long");
      ierr++;
    }
  }
 
  {
    typedef unsigned long long test_t;
    test_t zgno = ((test_t)1 << 36) + (test_t)25;
    zoltanGID[0] = 0; zoltanGID[1] = 0; zoltanGID[2] = 0; zoltanGID[3] = 0;
 
    int num_gid = MAX(1, sizeof(test_t) / sizeof(ZOLTAN_ID_TYPE));
    if (Zoltan2::TPL_Traits<ZOLTAN_ID_PTR,test_t>::NUM_ID != num_gid) {
      PRINTMSG("FAIL: NUM_ID wrong for unsigned long long");
      ierr++;
    }
 
    Zoltan2::TPL_Traits<ZOLTAN_ID_PTR,test_t>::ASSIGN(zoltanGID, zgno);
    if (sizeof(ZOLTAN_ID_TYPE) == sizeof(unsigned int)) {
      if (zoltanGID[0] != 25 || zoltanGID[1] != 16 || 
          zoltanGID[2] != 0 || zoltanGID[3] != 0) {
        PRINTMSG("FAIL: unsigned long long to ZOLTAN_ID_PTR");
        ierr++;
      }
    }
    else if (sizeof(ZOLTAN_ID_TYPE) == sizeof(unsigned long long)) {
      if (zoltanGID[0] != zgno || zoltanGID[1] != 0 ||
          zoltanGID[2] != 0 || zoltanGID[3] != 0) {
        PRINTMSG("FAIL: long long to ZOLTAN_ID_PTR");
        ierr++;
      }
    }
    else {
      // should never get here 
      PRINTMSG("FAIL: unknown sizeof(ZOLTAN_ID_TYPE)");
      ierr++;
    }
 
 
 
    test_t back;
    Zoltan2::TPL_Traits<test_t,ZOLTAN_ID_PTR>::ASSIGN(back, zoltanGID);
    if (back != zgno) {
      std::cout << "back " << back << " != zgno " << zgno << std::endl;
      PRINTMSG("FAIL: ZOLTAN_ID_PTR to unsigned long long");
      ierr++;
    }
  }
 
  {
    typedef size_t test_t;
    test_t zgno = 0;
    for (size_t i = 0; i < 8*sizeof(test_t); i++) zgno += (test_t)1<<i;
    zoltanGID[0] = 0; zoltanGID[1] = 0; zoltanGID[2] = 0; zoltanGID[3] = 0;
 
    int num_gid = MAX(1, sizeof(test_t) / sizeof(ZOLTAN_ID_TYPE));
    if (Zoltan2::TPL_Traits<ZOLTAN_ID_PTR,test_t>::NUM_ID != num_gid) {
      PRINTMSG("FAIL: NUM_ID wrong for size_t");
      ierr++;
    }
 
    Zoltan2::TPL_Traits<ZOLTAN_ID_PTR,test_t>::ASSIGN(zoltanGID, zgno);
    for (int i = 0; i < num_gid; i++)
      if (zoltanGID[i] != std::numeric_limits<ZOLTAN_ID_TYPE>::max()) {
        PRINTMSG("FAIL: size_t to ZOLTAN_ID_PTR");
        ierr++;
      }
    for (int i = num_gid; i < 4; i++)
      if (zoltanGID[i] != 0) {
        PRINTMSG("FAIL: size_t to ZOLTAN_ID_PTR");
        ierr++;
      }
 
    test_t back;
    Zoltan2::TPL_Traits<test_t,ZOLTAN_ID_PTR>::ASSIGN(back, zoltanGID);
    if (back != zgno) {
      std::cout << "back " << back << " != zgno " << zgno << std::endl;
      PRINTMSG("FAIL: ZOLTAN_ID_PTR to size_t");
      ierr++;
    }
  }
  delete [] zoltanGID;
 
 
  if (ierr == 0)
    std::cout << "PASS" << std::endl;
  else
    std::cout << "FAIL" << std::endl;
 
  return 0;
}