/* ** main function runs all the tests */ int main (void) { /* Initialize UnitTest */ UT_Init("ut_cfe_evs"); /* Test_Init is a test but also MUST be called 1st and only once */ Test_Init(); Test_IllegalAppID(); Test_UnregisteredApp(); Test_FilterRegistration(); Test_FilterReset(); Test_Format(); Test_Ports(); Test_Logging(); Test_WriteApp(); Test_BadAppCmd(); Test_EventCmd(); Test_FilterCmd(); Test_Misc(); /* Final report on number of errors */ UT_ReportFailures(); exit(0); }
int main( int argc, char **argv) { int rank; /* My Rank (0 or 1) */ int act_size = 0; int flag, np, rval, i; int buffer[SIZE]; double t0; char *Current_Test = NULL; MPI_Status status, status1, status2; int count1, count2; int sizes[4]; MPI_Init(&argc, &argv); MPI_Comm_rank(MPI_COMM_WORLD, &rank); MPI_Comm_size( MPI_COMM_WORLD, &np ); if (np != 2) { fprintf(stderr, "*** This program uses exactly 2 processes! ***\n"); MPI_Abort( MPI_COMM_WORLD, 1 ); } sizes[0] = 0; sizes[1] = 1; sizes[2] = 1000; sizes[3] = SIZE; /* for (i = 0; i < 4; i++ ) { */ for (i = 1; i < 2; i++ ) { act_size = sizes[i]; if (rank == src) { Generate_Data(buffer, SIZE); MPI_Recv( buffer, 0, MPI_INT, dest, 0, MPI_COMM_WORLD, &status ); MPI_Send( buffer, 0, MPI_INT, dest, 0, MPI_COMM_WORLD ); MPI_Ssend( buffer, act_size, MPI_INT, dest, 1, MPI_COMM_WORLD ); MPI_Ssend( buffer, act_size, MPI_INT, dest, 2, MPI_COMM_WORLD ); } else if (rank == dest) { Test_Init("ssendtest", rank); /* Test 1 */ Current_Test = (char*)"Ssend Test (Synchronous Send -> Normal Recieve)"; MPI_Send( buffer, 0, MPI_INT, src, 0, MPI_COMM_WORLD ); MPI_Recv( buffer, 0, MPI_INT, src, 0, MPI_COMM_WORLD, &status ); t0 = MPI_Wtime(); flag = 0; /* This test depends on a working wtime. Make a simple check */ if (t0 == 0 && MPI_Wtime() == 0) { int loopcount = 1000000; /* This test is too severe (systems with fast processors and large MPI_Wtick values can fail. Try harder to test MPI_Wtime */ while (loopcount-- && MPI_Wtime() == 0) ; if (loopcount <= 0) { fprintf( stderr, "MPI_WTIME is returning 0; a working value is needed\n\ for this test.\n" ); Test_Failed(Current_Test); MPI_Abort( MPI_COMM_WORLD, 1 ); } t0 = MPI_Wtime(); }
/******************************************************************************* 函数名: main 功能说明: 主函数 参数: 无 返回值: 无 *******************************************************************************/ int main(void) { Thread_Init(); SysHard_Init(); //系统相关硬件初始化 WDG_Init(5,2000); FIFOInit(); //初始化队列缓冲区 Instruct_Init(); DeviceResetCheck_Init(); Test_Init(); Unit_Init(); while(1) { Process_FIFOData(&rcv433fifo, &rcv_433); //处理接收FIFO Process_FIFOData(&rcv433_shortfifo, &rcv_433short); //处理接收FIFO Thread_Process(); } }
/******************************************************************************* 函数名: main 功能说明: 主函数 参 数: 无 返回值: 无 *******************************************************************************/ int main(void) { Key_Init(); KeyLowPowerHandle(); Thread_Init(); SysHard_Init(); //系统相关硬件初始化 FIFOInit(); //初始化队列缓冲区 Instruct_Init(); DeviceResetCheck_Init(); Test_Init(); Unit_Init(); KeyTimer_Init(); while(1) { Process_FIFOData(&rcv433fifo, &rcv_433); //处理接收FIFO Thread_Process(); } }
END_TEST /** * @brief Test entry point. */ int32_t main(int32_t argc, char **argv) { Test_Init(argc, argv); TCase *tcase = tcase_create("check_r_media"); tcase_add_checked_fixture(tcase, setup, teardown); tcase_add_test(tcase, check_R_RegisterMedia); Suite *suite = suite_create("check_r_media"); suite_add_tcase(suite, tcase); int32_t failed = Test_Run(suite); Test_Shutdown(); return failed; }
/**Function************************************************************* Synopsis [Starts all the packages.] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ void Abc_FrameInit( Abc_Frame_t * pAbc ) { Cmd_Init( pAbc ); Cmd_CommandExecute( pAbc, "set checkread" ); Io_Init( pAbc ); Abc_Init( pAbc ); Fpga_Init( pAbc ); Map_Init( pAbc ); Mio_Init( pAbc ); Super_Init( pAbc ); Libs_Init( pAbc ); Load_Init( pAbc ); Scl_Init( pAbc ); Test_Init( pAbc ); #ifdef USE_ABC2 Abc2_Init( pAbc ); #endif #ifdef USE_ABC85 Abc85_Init( pAbc ); #endif EXT_ABC_INIT(pAbc) // plugin for external functionality }
} END_TEST /** * @brief Test entry point. */ int32_t main(int32_t argc, char **argv) { Test_Init(argc, argv); TCase *tcase = tcase_create("check_mem"); tcase_add_checked_fixture(tcase, setup, teardown); tcase_add_test(tcase, check_Mem_LinkMalloc); tcase_add_test(tcase, check_Mem_CopyString); Suite *suite = suite_create("check_mem"); suite_add_tcase(suite, tcase); int32_t failed = Test_Run(suite); Test_Shutdown(); return failed; }
}END_TEST /* * @brief Test entry point. */ int32_t main(int32_t argc, char **argv) { Test_Init(argc, argv); TCase *tcase = tcase_create("check_master"); tcase_add_checked_fixture(tcase, setup, teardown); tcase_add_test(tcase, check_Ms_AddServer); tcase_add_test(tcase, check_Ms_BlacklistServer); Suite *suite = suite_create("check_master"); suite_add_tcase(suite, tcase); int32_t failed = Test_Run(suite); Test_Shutdown(); return failed; }
}END_TEST /* * @brief Test entry point. */ int32_t main(int32_t argc, char **argv) { Test_Init(argc, argv); TCase *tcase = tcase_create("check_filesystem"); tcase_add_checked_fixture(tcase, setup, teardown); tcase_add_test(tcase, check_Fs_OpenRead); tcase_add_test(tcase, check_Fs_OpenWrite); tcase_add_test(tcase, check_Fs_LoadFile); Suite *suite = suite_create("check_filesystem"); suite_add_tcase(suite, tcase); int32_t failed = Test_Run(suite); Test_Shutdown(); return failed; }
int main( int argc, char **argv) { int rank, size, i, recv_flag, ret, passed; MPI_Status Status; char message[17]; MPI_Init(&argc, &argv); MPI_Comm_rank(MPI_COMM_WORLD, &rank); MPI_Comm_size(MPI_COMM_WORLD, &size); if (rank == 0) { Test_Init("barrier", rank); /* Receive the startup messages from each of the other clients */ for (i = 0; i < size - 1; i++) { MPI_Recv(message, 17, MPI_CHAR, MPI_ANY_SOURCE, 2000, MPI_COMM_WORLD, &Status); } /* Now use Iprobe to make sure no more messages arive for a while */ passed = 1; for (i = 0; i < WAIT_TIMES; i++){ recv_flag = 0; MPI_Iprobe(MPI_ANY_SOURCE, 2000, MPI_COMM_WORLD, &recv_flag, &Status); if (recv_flag) passed = 0; } if (passed) Test_Passed("Barrier Test 1"); else Test_Failed("Barrier Test 1"); /* Now go into the barrier myself */ MPI_Barrier(MPI_COMM_WORLD); /* And get everyones message who came out */ for (i = 0; i < size - 1; i++) { MPI_Recv(message, 13, MPI_CHAR, MPI_ANY_SOURCE, 2000, MPI_COMM_WORLD, &Status); } /* Now use Iprobe to make sure no more messages arive for a while */ passed = 1; for (i = 0; i < WAIT_TIMES; i++){ recv_flag = 0; MPI_Iprobe(MPI_ANY_SOURCE, 2000, MPI_COMM_WORLD, &recv_flag, &Status); if (recv_flag) passed = 0; } if (passed) Test_Passed("Barrier Test 2"); else Test_Failed("Barrier Test 2"); Test_Waitforall( ); ret = Summarize_Test_Results(); Test_Finalize(); MPI_Finalize(); return ret; } else { MPI_Send((char*)"Entering Barrier", 17, MPI_CHAR, 0, 2000, MPI_COMM_WORLD); MPI_Barrier(MPI_COMM_WORLD); MPI_Send((char*)"Past Barrier", 13, MPI_CHAR, 0, 2000, MPI_COMM_WORLD); Test_Waitforall( ); MPI_Finalize(); return 0; } }
int main( int argc, char **argv) { int rank; /* My Rank (0 or 1) */ int act_size = 0; int flag, np, rval, i; int buffer[SIZE]; double t0; char *Current_Test = NULL; MPI_Status status, status1, status2; int count1, count2; int sizes[4]; MPI_Init(&argc, &argv); MPI_Comm_rank(MPI_COMM_WORLD, &rank); MPI_Comm_size( MPI_COMM_WORLD, &np ); /*if (np != 2) { fprintf(stderr, "*** This program uses exactly 2 processes! ***\n"); MPI_Abort( MPI_COMM_WORLD, 1 ); }*/ sizes[0] = 0; sizes[1] = 1; sizes[2] = 1000; sizes[3] = SIZE; /* for (i = 0; i < 4; i++ ) { */ for (i = 1; i < 2; i++ ) { act_size = sizes[i]; if (rank == src) { Generate_Data(buffer, SIZE); MPI_Recv( buffer, 0, MPI_INT, dest, 0, MPI_COMM_WORLD, &status ); MPI_Send( buffer, 0, MPI_INT, dest, 0, MPI_COMM_WORLD ); MPI_Ssend( buffer, act_size, MPI_INT, dest, 1, MPI_COMM_WORLD ); MPI_Ssend( buffer, act_size, MPI_INT, dest, 2, MPI_COMM_WORLD ); } else if (rank == dest) { Test_Init("ssendtest", rank); /* Test 1 */ Current_Test = "Ssend Test (Synchronous Send -> Normal Recieve)"; MPI_Send( buffer, 0, MPI_INT, src, 0, MPI_COMM_WORLD ); MPI_Recv( buffer, 0, MPI_INT, src, 0, MPI_COMM_WORLD, &status ); t0 = MPI_Wtime(); flag = 0; /* This test depends on a working wtime. Make a simple check */ if (t0 == 0 && MPI_Wtime() == 0) { fprintf( stderr, "MPI_WTIME is returning 0; a working value is needed\n\ for this test.\n" ); Test_Failed(Current_Test); fprintf( stderr, "[%i] Aborting\n",rank );fflush(stderr); MPI_Abort( MPI_COMM_WORLD, 1 ); } while (MPI_Wtime() - t0 < MAX_TIME) { MPI_Iprobe( src, 2, MPI_COMM_WORLD, &flag, &status ); if (flag) { Test_Failed(Current_Test); break; } } if (!flag) Test_Passed(Current_Test); MPI_Recv( buffer, act_size, MPI_INT, src, 1, MPI_COMM_WORLD, &status1 ); MPI_Recv( buffer, act_size, MPI_INT, src, 2, MPI_COMM_WORLD, &status2 ); MPI_Get_count( &status1, MPI_INT, &count1 ); MPI_Get_count( &status2, MPI_INT, &count2 ); if (count1 != act_size) { fprintf( stdout, "(1) Wrong count from recv of ssend: got %d (%d)\n", count1, act_size ); } if (status1.MPI_TAG != 1) { fprintf( stdout, "(1) Wrong tag from recv of ssend: got %d\n", status1.MPI_TAG ); } if (count2 != act_size) { fprintf( stdout, "(2) Wrong count from recv of ssend: got %d (%d)\n", count1, act_size ); } if (status2.MPI_TAG != 2) { fprintf( stdout, "(2) Wrong tag from recv of ssend: got %d\n", status2.MPI_TAG ); } }
int main( int argc, char **argv ) { int rank, size, ret, passed, i, *test_array; int stride, count, root; MPI_Datatype newtype; MPI_Comm comm = MPI_COMM_WORLD; /* Set up MPI */ MPI_Init(&argc, &argv); MPI_Comm_rank(comm, &rank); /* Setup the tests */ Test_Init("bcastvec", rank); /* Allow for additional communicators */ MPI_Comm_size(comm, &size); /* MPI_Comm_rank(comm, &rank); */ stride = (rank + 1); test_array = (int *)malloc(size*stride*sizeof(int)); /* Create the vector datatype EXCEPT for process 0 (vector of stride 1 is contiguous) */ if (rank > 0) { count = 1; MPI_Type_vector( size, 1, stride, MPI_INT, &newtype); MPI_Type_commit( &newtype ); } else { count = size; newtype = MPI_INT; } /* Perform the test. Each process in turn becomes the root. After each operation, check that nothing has gone wrong */ passed = 1; for (root = 0; root < size; root++) { /* Fill the array with -1 for unset, rank + i * size for set */ for (i=0; i<size*stride; i++) test_array[i] = -1; if (rank == root) for (i=0; i<size; i++) test_array[i*stride] = rank + i * size; MPI_Bcast( test_array, count, newtype, root, comm ); for (i=0; i<size; i++) { if (test_array[i*stride] != root + i * size) { passed = 0; } } } free(test_array); if (rank != 0) MPI_Type_free( &newtype ); if (!passed) Test_Failed("Simple Broadcast test with datatypes"); else { if (rank == 0) Test_Passed("Simple Broadcast test with datatypes"); } /* Close down the tests */ if (rank == 0) ret = Summarize_Test_Results(); else { ret = 0; } Test_Finalize(); /* Close down MPI */ Test_Waitforall( ); MPI_Finalize(); return ret; }