int main(void){
ESMC_ArraySpec arrayspec; // ESMC_ArraySpec object
char name[80];
char failMsg[80];
int result = 0;
int rc = 0;
int localrc;
int rank = 2;
int rank_out=0;
ESMC_TypeKind typekind;
ESMC_TypeKind typekind_out;
typekind= ESMC_TYPEKIND_I4;
//----------------------------------------------------------------------------
ESMC_TestStart(__FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
//NEX_UTest
// Create an arrayspec object -- cf
strcpy(name, "ArraySpecSet Unit test");
strcpy(failMsg, "Did not return ESMF_SUCCESS");
rc = ESMC_ArraySpecSet(&arrayspec, rank, typekind);
ESMC_Test((rc == ESMF_SUCCESS), name, failMsg, &result, __FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
//NEX_UTest
// Get the data values of an arrayspec object -- cf
strcpy(name, "ArraySpecGet Unit test");
strcpy(failMsg, "Did not return ESMF_SUCCESS");
rc = ESMC_ArraySpecGet(arrayspec, &rank_out, &typekind_out);
ESMC_Test((rc == ESMF_SUCCESS), name, failMsg, &result, __FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
#ifdef ESMF_TESTEXHAUSTIVE
//EX_UTest
// Verify output of ESMC_ArraySpecGet: kind
strcpy(name, "ArraySpecGet: rank Unit test");
strcpy(failMsg, "Rank returned is wrong");
ESMC_Test((rank == rank_out), name, failMsg, &result, __FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
//EX_UTest
// Verify output of ESMC_ArraySpecGet: typekind
strcpy(name, "ArraySpecGet: typekind Unit test");
strcpy(failMsg, "Typekind returned is wrong");
ESMC_Test((typekind == typekind_out), name, failMsg, &result, __FILE__, __LINE__, 0);
#endif
//----------------------------------------------------------------------------
ESMC_TestEnd(result, __FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
return 0;
}
int main(void){
char name[80];
char failMsg[80];
int result = 0;
//----------------------------------------------------------------------------
ESMC_TestStart(__FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
//NEX_UTest
strcpy(name, "Use of ESMC_Test(), true");
strcpy(failMsg, "Dummy fail message");
ESMC_Test(1, name, failMsg, &result, __FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
ESMC_TestEnd(result, __FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
return 0;
}
int main(void){
char name[80];
char failMsg[80];
int result = 0;
int rc;
ESMC_ArraySpec arrayspec;
int *minIndexValues, *maxIndexValues;
ESMC_InterfaceInt minIndex, maxIndex;
ESMC_DistGrid distgrid;
ESMC_Array array;
//----------------------------------------------------------------------------
ESMC_TestStart(__FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
//NEX_UTest
// Set the arrayspec
strcpy(name, "ArraySpecSet");
strcpy(failMsg, "Did not return ESMF_SUCCESS");
rc = ESMC_ArraySpecSet(&arrayspec, 2, ESMC_TYPEKIND_I4);
ESMC_Test((rc==ESMF_SUCCESS), name, failMsg, &result, __FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
//NEX_UTest
strcpy(name, "Set up minIndex");
strcpy(failMsg, "Did not return ESMF_SUCCESS");
minIndexValues = (int *)malloc(2*sizeof(int));
minIndexValues[0] = minIndexValues[1] = 1;
minIndex = ESMC_InterfaceIntCreate(minIndexValues, 2, &rc);
ESMC_Test((rc==ESMF_SUCCESS), name, failMsg, &result, __FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
//NEX_UTest
strcpy(name, "Set up maxIndex");
strcpy(failMsg, "Did not return ESMF_SUCCESS");
maxIndexValues = (int *)malloc(2*sizeof(int));
maxIndexValues[0] = 5;
maxIndexValues[1] = 10;
maxIndex = ESMC_InterfaceIntCreate(maxIndexValues, 2, &rc);
ESMC_Test((rc==ESMF_SUCCESS), name, failMsg, &result, __FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
//NEX_UTest
strcpy(name, "Create 5 x 10 ESMC_DistGrid object");
strcpy(failMsg, "Did not return ESMF_SUCCESS");
distgrid = ESMC_DistGridCreate(minIndex, maxIndex, &rc);
ESMC_Test((rc==ESMF_SUCCESS), name, failMsg, &result, __FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
//NEX_UTest
strcpy(name, "Clean up minIndex");
strcpy(failMsg, "Did not return ESMF_SUCCESS");
free(minIndexValues);
rc = ESMC_InterfaceIntDestroy(&minIndex);
ESMC_Test((rc==ESMF_SUCCESS), name, failMsg, &result, __FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
//NEX_UTest
strcpy(name, "Clean up maxIndex");
strcpy(failMsg, "Did not return ESMF_SUCCESS");
free(maxIndexValues);
rc = ESMC_InterfaceIntDestroy(&maxIndex);
ESMC_Test((rc==ESMF_SUCCESS), name, failMsg, &result, __FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
//NEX_UTest
strcpy(name, "Create ESMC_Array object");
strcpy(failMsg, "Did not return ESMF_SUCCESS");
array = ESMC_ArrayCreate(arrayspec, distgrid, "array1", &rc);
ESMC_Test((rc==ESMF_SUCCESS), name, failMsg, &result, __FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
//NEX_UTest
strcpy(name, "Print ESMC_Array object");
strcpy(failMsg, "Did not return ESMF_SUCCESS");
rc = ESMC_ArrayPrint(array);
ESMC_Test((rc==ESMF_SUCCESS), name, failMsg, &result, __FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
//NEX_UTest
strcpy(name, "Destroy ESMC_DistGrid object");
strcpy(failMsg, "Did not return ESMF_SUCCESS");
rc = ESMC_DistGridDestroy(&distgrid);
ESMC_Test((rc==ESMF_SUCCESS), name, failMsg, &result, __FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
//NEX_UTest
strcpy(name, "Destroy ESMC_Array object");
strcpy(failMsg, "Did not return ESMF_SUCCESS");
rc = ESMC_ArrayDestroy(&array);
ESMC_Test((rc==ESMF_SUCCESS), name, failMsg, &result, __FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
ESMC_TestEnd(result, __FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
return 0;
}
int main(void){
ESMC_State myState; // ESMC_State object
const char* arrayName;
char name[80];
char failMsg[80];
int result = 0;
int rc = 0;
int localrc;
ESMC_ArraySpec arrayspec;
int *minIndexValues, *maxIndexValues;
ESMC_InterfaceInt minIndex, maxIndex;
ESMC_DistGrid distgrid;
ESMC_Array array;
ESMC_Array retrievedArray;
//----------------------------------------------------------------------------
ESMC_TestStart(__FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
//NEX_UTest
// Create a state object -- cf
strcpy(name, "StateCreate Unit test");
strcpy(failMsg, "Did not return ESMF_SUCCESS");
myState = ESMC_StateCreate("stateName",&rc);
ESMC_Test((rc == ESMF_SUCCESS), name, failMsg, &result, __FILE__, __LINE__,0);
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
//NEX_UTest
// Set the arrayspec
strcpy(name, "ArraySpecSet");
strcpy(failMsg, "Did not return ESMF_SUCCESS");
rc = ESMC_ArraySpecSet(&arrayspec, 2, ESMC_TYPEKIND_I4);
ESMC_Test((rc==ESMF_SUCCESS), name, failMsg, &result, __FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
//NEX_UTest
strcpy(name, "Set up minIndex");
strcpy(failMsg, "Did not return ESMF_SUCCESS");
minIndexValues = (int *)malloc(2*sizeof(int));
minIndexValues[0] = minIndexValues[1] = 1;
minIndex = ESMC_InterfaceIntCreate(minIndexValues, 2, &rc);
ESMC_Test((rc==ESMF_SUCCESS), name, failMsg, &result, __FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
//NEX_UTest
strcpy(name, "Set up maxIndex");
strcpy(failMsg, "Did not return ESMF_SUCCESS");
maxIndexValues = (int *)malloc(2*sizeof(int));
maxIndexValues[0] = 5;
maxIndexValues[1] = 10;
maxIndex = ESMC_InterfaceIntCreate(maxIndexValues, 2, &rc);
ESMC_Test((rc==ESMF_SUCCESS), name, failMsg, &result, __FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
//NEX_UTest
strcpy(name, "Create 5 x 10 ESMC_DistGrid object");
strcpy(failMsg, "Did not return ESMF_SUCCESS");
distgrid = ESMC_DistGridCreate(minIndex, maxIndex, &rc);
ESMC_Test((rc==ESMF_SUCCESS), name, failMsg, &result, __FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
//NEX_UTest
strcpy(name, "Clean up minIndex");
strcpy(failMsg, "Did not return ESMF_SUCCESS");
free(minIndexValues);
rc = ESMC_InterfaceIntDestroy(&minIndex);
ESMC_Test((rc==ESMF_SUCCESS), name, failMsg, &result, __FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
//NEX_UTest
strcpy(name, "Clean up maxIndex");
strcpy(failMsg, "Did not return ESMF_SUCCESS");
free(maxIndexValues);
rc = ESMC_InterfaceIntDestroy(&maxIndex);
ESMC_Test((rc==ESMF_SUCCESS), name, failMsg, &result, __FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
//NEX_UTest
strcpy(name, "Create ESMC_Array object");
strcpy(failMsg, "Did not return ESMF_SUCCESS");
array = ESMC_ArrayCreate(arrayspec, distgrid, "array1", &rc);
ESMC_Test((rc==ESMF_SUCCESS), name, failMsg, &result, __FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
//NEX_UTest
strcpy(name, "Retrieve the name of an ESMC_Array object");
strcpy(failMsg, "Did not return ESMF_SUCCESS");
arrayName = ESMC_ArrayGetName(array,&rc);
ESMC_Test((rc==ESMF_SUCCESS), name, failMsg, &result, __FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
//NEX_UTest
strcpy(name, "Verify array object name retrieved");
strcpy(failMsg, "Did not retrieve array name correctly");
ESMC_Test(!strcmp(arrayName, "array1"), name, failMsg, &result, __FILE__,
__LINE__, 0);
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
//NEX_UTest
strcpy(name, "Print ESMC_Array object");
strcpy(failMsg, "Did not return ESMF_SUCCESS");
rc = ESMC_ArrayPrint(array);
ESMC_Test((rc==ESMF_SUCCESS), name, failMsg, &result, __FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
//NEX_UTest
strcpy(name, "Add an Array to a State object");
strcpy(failMsg, "Did not return ESMF_SUCCESS");
rc = ESMC_StateAddArray(myState,array);
ESMC_Test((rc==ESMF_SUCCESS), name, failMsg, &result, __FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
//NEX_UTest
strcpy(name, "Get an array from a state, based on its name");
strcpy(failMsg, "Did not return ESMF_SUCCESS");
rc = ESMC_StateGetArray(myState, "array1", &retrievedArray);
ESMC_Test((rc==ESMF_SUCCESS), name, failMsg, &result, __FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
//NEX_UTest
strcpy(name, "Compare array stored into and array retrieved from a state");
strcpy(failMsg, "Discrepancy on array pointers");
ESMC_Test((array.ptr==retrievedArray.ptr), name, failMsg, &result, __FILE__,
__LINE__, 0);
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
//NEX_UTest
strcpy(name, "Destroy ESMC_DistGrid object");
strcpy(failMsg, "Did not return ESMF_SUCCESS");
rc = ESMC_DistGridDestroy(&distgrid);
ESMC_Test((rc==ESMF_SUCCESS), name, failMsg, &result, __FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
//NEX_UTest
strcpy(name, "Destroy ESMC_Array object");
strcpy(failMsg, "Did not return ESMF_SUCCESS");
rc = ESMC_ArrayDestroy(&array);
ESMC_Test((rc==ESMF_SUCCESS), name, failMsg, &result, __FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
//NEX_UTest
// Destroy a state object -- cf
strcpy(name, "StateDestroy Unit test");
strcpy(failMsg, "Did not return ESMF_SUCCESS");
rc = ESMC_StateDestroy(&myState);
ESMC_Test((rc == ESMF_SUCCESS), name, failMsg, &result, __FILE__, __LINE__,0);
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
ESMC_TestEnd(result, __FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
return 0;
}
int main(void){
char name[80];
char failMsg[80];
int result = 0;
int rc;
// the ESMC_Clock object
ESMC_Clock clock;
//----------------------------------------------------------------------------
ESMC_TestStart(__FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
ESMC_TimeInterval timeStep,runDuration;
ESMC_Time startTime, stopTime, refTime;
ESMC_Calendar calendar;
ESMC_I4 yy1=2006;
ESMC_I4 h1=0;
ESMC_I4 h2=1;
ESMC_CalendarType calType1=ESMC_CAL_GREGORIAN;
int tZ1=-6;
const ESMC_I4 one=1;
ESMC_TimeInterval currSimTime;
ESMC_I8 advanceCount, advanceCount1;
ESMC_I8 initSec, currSec1;
ESMC_R8 initHour, currHour1;
//----------------------------------------------------------------------------
//NEX_UTest
strcpy(name, "Create ESMC_Calendar object");
strcpy(failMsg, "Did not return ESMF_SUCCESS");
calendar = ESMC_CalendarCreate("Gregorian", ESMC_CAL_GREGORIAN, &rc);
ESMC_Test((rc==ESMF_SUCCESS), name, failMsg, &result, __FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
//NEX_UTest
strcpy(name, "Set Start Time");
strcpy(failMsg, "Did not return ESMF_SUCCESS");
rc = ESMC_TimeSet(&startTime, yy1, h1, calendar, calType1, tZ1);
ESMC_Test((rc==ESMF_SUCCESS), name, failMsg, &result, __FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
//NEX_UTest
strcpy(name, "Set Stop Time");
strcpy(failMsg, "Did not return ESMF_SUCCESS");
rc = ESMC_TimeSet(&stopTime, yy1, h2, calendar, calType1, tZ1);
ESMC_Test((rc==ESMF_SUCCESS), name, failMsg, &result, __FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
//NEX_UTest
strcpy(name, "Set a TimeInterval");
strcpy(failMsg, "Did not return ESMF_SUCCESS");
rc = ESMC_TimeIntervalSet(&timeStep, one);
ESMC_Test((rc==ESMF_SUCCESS), name, failMsg, &result, __FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
//NEX_UTest
strcpy(name, "Create ESMC_Clock object");
strcpy(failMsg, "Did not return ESMF_SUCCESS");
clock = ESMC_ClockCreate("TEST_CLOCK", timeStep, startTime, stopTime, &rc);
ESMC_Test((rc==ESMF_SUCCESS), name, failMsg, &result, __FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
//NEX_UTest
strcpy(name, "Print ESMC_Clock object");
strcpy(failMsg, "Did not return ESMF_SUCCESS");
rc = ESMC_ClockPrint(clock);
ESMC_Test((rc==ESMF_SUCCESS), name, failMsg, &result, __FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
//NEX_UTest
strcpy(name, "Get ESMC_Clock object current time and advance count");
strcpy(failMsg, "Did not return ESMF_SUCCESS");
rc = ESMC_ClockGet(clock, &currSimTime, &advanceCount);
ESMC_Test((rc==ESMF_SUCCESS), name, failMsg, &result, __FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
//NEX_UTest
strcpy(name, "Advance the Clock object");
strcpy(failMsg, "Did not return ESMF_SUCCESS");
rc = ESMC_ClockAdvance(clock);
ESMC_Test((rc==ESMF_SUCCESS), name, failMsg, &result, __FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
#ifdef ESMF_TESTEXHAUSTIVE
//----------------------------------------------------------------------------
//EX_UTest
strcpy(name, "Get ESMC_Clock object current time and advance count");
strcpy(failMsg, "Did not return ESMF_SUCCESS");
rc = ESMC_ClockGet(clock, &currSimTime, &advanceCount1);
ESMC_Test((rc==ESMF_SUCCESS), name, failMsg, &result, __FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
//EX_UTest
strcpy(name, "Get currSimTime in seconds and in hours");
strcpy(failMsg, "Did not return ESMF_SUCCESS");
rc = ESMC_TimeIntervalGet(currSimTime, &currSec1, &currHour1);
ESMC_Test((rc==ESMF_SUCCESS), name, failMsg, &result, __FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
//EX_UTest
strcpy(name, "Verify that currSimTime in second units");
strcpy(failMsg, "Did not return 3600");
ESMC_Test((int(currSec1)==3600), name, failMsg, &result, __FILE__, __LINE__,
0);
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
//EX_UTest
strcpy(name, "Verify that currSimTime in hour units");
strcpy(failMsg, "Did not return 1");
ESMC_Test((int(currHour1)==1), name, failMsg, &result, __FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
#endif
//----------------------------------------------------------------------------
//NEX_UTest
strcpy(name, "Destroy ESMC_Clock object");
strcpy(failMsg, "Did not return ESMF_SUCCESS");
rc = ESMC_ClockDestroy(&clock);
ESMC_Test((rc==ESMF_SUCCESS), name, failMsg, &result, __FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
//NEX_UTest
strcpy(name, "Destroy ESMC_Calendar object");
strcpy(failMsg, "Did not return ESMF_SUCCESS");
rc = ESMC_CalendarDestroy(&calendar);
ESMC_Test((rc==ESMF_SUCCESS), name, failMsg, &result, __FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
/*
#ifdef ESMF_TESTEXHAUSTIVE
#if 0
// perform exhaustive tests here;
// see #else below for non-exhaustive tests
// future release will use run-time switching mechanism
// test dynamic allocation of ESMC_Clock
// also tests default constructor
clock_ptr = ESMC_ClockCreate(args, &rc);
sprintf(name, "ESMC_ClockCreate");
sprintf(failMsg, "rc = %d, clock_ptr = %p, args = %f",
rc, clock_ptr, args);
ESMC_Test((clock_ptr!=0 && rc==ESMF_SUCCESS),
name, failMsg, &result, ESMF_SRCLINE);
// test internal dynamic allocation within statically allocated
// ESMC_Clock
rc = clock_ptr->ESMC_ClockConstruct(args);
sprintf(name, "ESMC_ClockConstruct");
sprintf(failMsg, "rc = %d, args = %f", rc, args);
ESMC_Test((rc==ESMF_SUCCESS),
name, failMsg, &result, ESMF_SRCLINE);
// test initialization of members of statically allocated ESMC_Clock
// may want to read back values via Get methods for comparison
rc = clock_ptr->ESMC_ClockSet(args);
sprintf(name, "ESMC_ClockSet");
sprintf(failMsg, "rc = %d, args = %f", rc, args);
ESMC_Test((rc==ESMF_SUCCESS),
name, failMsg, &result, ESMF_SRCLINE);
// test setting of configuration values
ESMC_ClockConfig config_set;
rc = clock_ptr->ESMC_ClockSetConfig(config_set);
sprintf(name, "ESMC_ClockSetConfig");
sprintf(failMsg, "rc = %d, config_set = %f", rc, config_set);
ESMC_Test((rc==ESMF_SUCCESS),
name, failMsg, &result, ESMF_SRCLINE);
// test getting of configuration values,
// compare to values set previously
ESMC_ClockConfig config_get;
rc = clock_ptr->ESMC_ClockGetConfig(&config_get);
sprintf(name, "ESMC_ClockGetConfig");
sprintf(failMsg, "rc = %d, config_get = %f", rc, config_get);
ESMC_Test((rc==ESMF_SUCCESS && config_get == config_set),
name, failMsg, &result, ESMF_SRCLINE);
// test setting of ESMC_Clock members values
<value type> value_set;
rc = clock_ptr->ESMC_ClockSet<Value>(value_set);
sprintf(name, "ESMC_ClockSet<Value>");
sprintf(failMsg, "rc = %d, value_set = %f", rc, value_set);
ESMC_Test((rc==ESMF_SUCCESS),
name, failMsg, &result, ESMF_SRCLINE);
// test getting of ESMC_Clock members values,
// compare to values set previously
<value type> value_get;
rc = clock_ptr->ESMC_ClockGet<Value>(&value_get);
sprintf(name, "ESMC_ClockGet<Value>");
sprintf(failMsg, "rc = %d, value_get = %f", rc, value_get);
ESMC_Test((rc==ESMF_SUCCESS && value_get == value_set),
name, failMsg, &result, ESMF_SRCLINE);
// test validate method via option string
char validate_options[ESMF_MAXSTR];
rc = clock_ptr->ESMC_ClockValidate(validate_options);
sprintf(name, "ESMC_ClockValidate");
sprintf(failMsg, "rc = %d, validate_options = %s", rc, validate_options);
ESMC_Test((rc==ESMF_SUCCESS),
name, failMsg, &result, ESMF_SRCLINE);
// test print method via option string
char print_options[ESMF_MAXSTR];
rc = clock_ptr->ESMC_ClockPrint(print_options);
sprintf(name, "ESMC_ClockPrint");
sprintf(failMsg, "rc = %d, print_options = %s", rc, print_options);
ESMC_Test((rc==ESMF_SUCCESS),
name, failMsg, &result, ESMF_SRCLINE);
// test internal dynamic deallocation within statically allocated
// ESMC_Clock
rc = clock_ptr->ESMC_ClockDestruct();
sprintf(name, "ESMC_ClockDestruct");
sprintf(failMsg, "rc = %d", rc);
ESMC_Test((rc==ESMF_SUCCESS),
name, failMsg, &result, ESMF_SRCLINE);
// test dynamic deallocation of ESMC_Clock
// also tests destructor
rc = ESMC_ClockDestroy(clock_ptr);
sprintf(name, "ESMC_ClockDestroy");
sprintf(failMsg, "rc = %d, clock_ptr = %p", rc, clock_ptr);
ESMC_Test((rc==ESMF_SUCCESS),
name, failMsg, &result, ESMF_SRCLINE);
#endif
#else
// perform non-exhaustive tests here;
// use same templates as above
#endif
*/
//----------------------------------------------------------------------------
ESMC_TestEnd(result, __FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
// return number of failures to environment; 0 = success (all pass)
printf("result = %d\n",result);
return(result);
}
int main(void){
char name[80];
char failMsg[80];
int result = 0;
int rc;
int num_elem, num_node, conn_size;
int num_elements, num_nodes;
ESMC_Mesh mesh;
int pdim=2;
int sdim=3;
int *nodeId;
double *nodeCoord;
int *nodeOwner;
int *elemId;
int *elemType;
int *elemConn;
int *nodeDistG;
int *elemDistG;
//----------------------------------------------------------------------------
ESMC_TestStart(__FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
//NEX_UTest_Multi_Proc_Only
// Create a mesh
strcpy(name, "MeshCreate");
strcpy(failMsg, "Did not return ESMF_SUCCESS");
mesh = ESMC_MeshCreate(&pdim,&sdim,&rc);
ESMC_Test((rc==ESMF_SUCCESS), name, failMsg, &result, __FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
//NEX_UTest_Multi_Proc_Only
// Read input files' header data
strcpy(name, "MeshVTKHeader");
strcpy(failMsg, "Did not return ESMF_SUCCESS");
rc = ESMC_MeshVTKHeader("data/testmesh", &num_elem, &num_node, &conn_size);
ESMC_Test((rc==ESMF_SUCCESS), name, failMsg, &result, __FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
// Allocate the arrays to describe Mesh
nodeId = (int *) malloc (num_node * sizeof (int));
nodeCoord = (double *) malloc (3*num_node * sizeof (double));
nodeOwner = (int *) malloc (num_node * sizeof (int));
elemId = (int *) malloc (num_elem * sizeof (int));
elemType = (int *) malloc (num_elem * sizeof (int));
elemConn = (int *) malloc (conn_size * sizeof (int));
//----------------------------------------------------------------------------
//NEX_UTest_Multi_Proc_Only
// Read input files
strcpy(name, "MeshVTKBody");
strcpy(failMsg, "Did not return ESMF_SUCCESS");
rc = ESMC_MeshVTKBody("data/testmesh", nodeId, nodeCoord, nodeOwner,
elemId, elemType, elemConn);
ESMC_Test((rc==ESMF_SUCCESS), name, failMsg, &result, __FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
// VTKBody returns zero based elemConn, so make them 1 based
for (int i = 0; i < conn_size; i++){
elemConn[i] = elemConn[i]+1;
}
//----------------------------------------------------------------------------
//NEX_UTest_Multi_Proc_Only
// Add node information to the mesh
strcpy(name, "MeshAddNodes");
strcpy(failMsg, "Did not return ESMF_SUCCESS");
rc = ESMC_MeshAddNodes(mesh, &num_node, nodeId, nodeCoord, nodeOwner);
ESMC_Test((rc==ESMF_SUCCESS), name, failMsg, &result, __FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
//NEX_UTest_Multi_Proc_Only
// Add element information to the mesh
strcpy(name, "MeshAddElements");
strcpy(failMsg, "Did not return ESMF_SUCCESS");
rc = ESMC_MeshAddElements(mesh, &num_elem, elemId, elemType, elemConn);
ESMC_Test((rc==ESMF_SUCCESS), name, failMsg, &result, __FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
//NEX_disabled_UTest_Multi_Proc_Only
// Create DisGrids for the nodes and elements of the mesh
//strcpy(name, "MeshCreateDistGrid");
//strcpy(failMsg, "Did not return ESMF_SUCCESS");
//rc = ESMC_MeshCreateDistGrids(mesh, nodeDistG, elemDistG, &num_node,
//&num_elem);
//ESMC_Test((rc==ESMF_SUCCESS), name, failMsg, &result, __FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
//NEX_UTest_Multi_Proc_Only
// Write out the internal mesh data
strcpy(name, "MeshWrite");
strcpy(failMsg, "Did not return ESMF_SUCCESS");
rc = ESMC_MeshWrite(mesh, "MeshOutput");
ESMC_Test((rc==ESMF_SUCCESS), name, failMsg, &result, __FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
//NEX_UTest_Multi_Proc_Only
// Get the number of local nodes
strcpy(name, "MeshGetNumNodes");
strcpy(failMsg, "Did not return ESMF_SUCCESS");
rc = ESMC_MeshGetNumNodes(mesh, &num_nodes);
ESMC_Test((rc==ESMF_SUCCESS), name, failMsg, &result, __FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
//NEX_UTest_Multi_Proc_Only
// Get the number of local elements
strcpy(name, "MeshGetNumElements");
strcpy(failMsg, "Did not return ESMF_SUCCESS");
rc = ESMC_MeshGetNumElements(mesh, &num_elements);
ESMC_Test((rc==ESMF_SUCCESS), name, failMsg, &result, __FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
//NEX_UTest_Multi_Proc_Only
// Free internal mesh memory
strcpy(name, "MeshFreeMemory");
strcpy(failMsg, "Did not return ESMF_SUCCESS");
rc = ESMC_MeshFreeMemory(mesh);
ESMC_Test((rc==ESMF_SUCCESS), name, failMsg, &result, __FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
//NEX_UTest_Multi_Proc_Only
// Destroy mesh object
strcpy(name, "MeshDestroy");
strcpy(failMsg, "Did not return ESMF_SUCCESS");
rc = ESMC_MeshDestroy(&mesh);
ESMC_Test((rc==ESMF_SUCCESS), name, failMsg, &result, __FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
// Free arrays used to create Mesh
free(nodeId);
free(nodeCoord);
free(nodeOwner);
free(elemId);
free(elemType);
free(elemConn);
//----------------------------------------------------------------------------
ESMC_TestEnd(result, __FILE__, __LINE__, 0);
//----------------------------------------------------------------------------
return 0;
}
