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; }