HRESULT CTestPolling::Test3()
{
HRESULT hr = S_OK;
const size_t c_maxSockets = 10;
ChkA(TestInit(c_maxSockets, 0));
ChkA(_spPolling->Add(3, IPOLLING_READ));
ChkA(_spPolling->Remove(3));
ChkA(_spPolling->Add(5, IPOLLING_READ));
ChkA(_spPolling->Add(7, IPOLLING_READ));
ChkA(_spPolling->Add(9, IPOLLING_READ));
ChkA(_spPolling->Remove(5));
ChkA(_spPolling->Add(11, IPOLLING_READ));
ChkA(_spPolling->Add(13, IPOLLING_READ));
ChkA(_spPolling->Remove(7));
ChkA(_spPolling->Add(15, IPOLLING_READ));
ChkA(_spPolling->Add(17, IPOLLING_READ));
ChkA(_spPolling->Add(19, IPOLLING_READ));
ChkA(_spPolling->Remove(11));
ChkA(_spPolling->Add(21, IPOLLING_READ));
ChkA(_spPolling->Add(23, IPOLLING_READ));
ChkA(_spPolling->Add(25, IPOLLING_READ));
ChkA(_spPolling->Add(27, IPOLLING_READ));
ChkA(_spPolling->Remove(13));
Cleanup:
return hr;
}
//================================================================================
void ATHEngine::Init()
{
// Load from config
LoadConfig();
// Create the operating system construct for the game
if (!CreateViewport())
return;
#ifdef _WIN32
// Start the renderer
m_pRenderer = ATHRenderer::GetInstance();
m_pRenderer->Initialize(m_hWnd, m_hInstance, m_nScreenWidth, m_nScreenHeight, m_bFullscreen, m_bVsync);
m_pRenderer->SetDebugLines(m_bDebugLines);
// Setup input management
m_pInputManager = ATHInputManager::GetInstance();
m_pInputManager->Init(m_hWnd, m_hInstance, m_nScreenWidth, m_nScreenWidth, m_nScreenWidth / 2, m_nScreenWidth / 2);
// Start Audio Manager
m_pAudioManager = ATHAudio::GetInstance();
m_pAudioManager->InitXAudio2();
#endif // _WIN32
// Create event manager
m_pEventManager = ATHEventManager::GetInstance();
// Setup Object manager
m_pObjectManager = new ATHObjectManager();
m_pObjectManager->Init();
// Test init code
TestInit();
m_bShutdown = false;
}
int main(int argc, char** argv)
{
unsigned short usRes = 0;
if((usRes = TestHeartPokers()))
{
printf("Test Heart Pokers Error at %u\n", usRes);
return 1;
}
if((usRes = TestDiamondPokers()))
{
printf("Test Diamond Pokers Error at %u\n", usRes);
return 1;
}
if((usRes = TestSpadePokers()))
{
printf("Test Spade Pokers Error at %u\n", usRes);
return 1;
}
if((usRes = TestClubPokers()))
{
printf("Test Club Pokers Error at %u\n", usRes);
return 1;
}
if((usRes = TestInit()))
{
printf("Test Init Error at %u\n", usRes);
return 1;
}
printf("Test Success\n");
return 0;
}
void CLogger::VPrint(unsigned int Filter, const char* Format, va_list& argList) {
TestInit();
char Buffer[4096];
{
//weirdly, it is found, sometime it crashed in vsnprintf
//so, to protect it for the multithreading
gs_lock->Lock();
string_vnprintf(Buffer, sizeof(Buffer), Format, argList);
gs_lock->Unlock();
}
Output(Filter, Buffer);
}
int
main(int argc, char *argv[])
{
/* Initialize testing framework */
TestInit(argv[0], NULL, NULL);
/* Tests are generally arranged from least to most complexity... */
AddTest("config", test_configure, cleanup_configure, "Configure definitions", NULL);
AddTest("metadata", test_metadata, cleanup_metadata, "Encode/decode metadata code", NULL);
AddTest("tst", test_tst, NULL, "Ternary Search Trees", NULL);
AddTest("heap", test_heap, NULL, "Memory Heaps", NULL);
AddTest("skiplist", test_skiplist, NULL, "Skip Lists", NULL);
AddTest("refstr", test_refstr, NULL, "Reference Counted Strings", NULL);
AddTest("file", test_file, cleanup_file, "Low-Level File I/O", NULL);
AddTest("h5s", test_h5s, cleanup_h5s, "Dataspaces", NULL);
AddTest("coords", test_coords, cleanup_coords, "Dataspace coordinates", NULL);
AddTest("attr", test_attr, cleanup_attr, "Attributes", NULL);
AddTest("select", test_select, cleanup_select, "Selections", NULL);
AddTest("time", test_time, cleanup_time, "Time Datatypes", NULL);
AddTest("reference", test_reference, cleanup_reference, "References", NULL);
AddTest("vltypes", test_vltypes, cleanup_vltypes, "Variable-Length Datatypes", NULL);
AddTest("vlstrings", test_vlstrings, cleanup_vlstrings, "Variable-Length Strings", NULL);
AddTest("iterate", test_iterate, cleanup_iterate, "Group & Attribute Iteration", NULL);
AddTest("array", test_array, cleanup_array, "Array Datatypes", NULL);
AddTest("genprop", test_genprop, cleanup_genprop, "Generic Properties", NULL);
AddTest("misc", test_misc, cleanup_misc, "Miscellaneous", NULL);
/* Display testing information */
TestInfo(argv[0]);
/* Parse command line arguments */
TestParseCmdLine(argc,argv);
/* Perform requested testing */
PerformTests();
/* Display test summary, if requested */
if (GetTestSummary())
TestSummary();
/* Clean up test files, if allowed */
if (GetTestCleanup() && !getenv("HDF5_NOCLEANUP"))
TestCleanup();
return (GetTestNumErrs());
} /* end main() */
void ConsoleOut::Dump(uint32_t Filter, const void* pUserData, size_t UserSize)
{
TestInit();
if ((pUserData) && (UserSize > 0))
{
char Str[80];
size_t i;
uint8_t* pData;
size_t Size;
size_t StartingOfs;
size_t EndingOfs;
pData = BEHAVIAC_ALIGN_PTR(uint8_t*, pUserData, 16);
StartingOfs = (size_t)BEHAVIAC_DIFF_PTR(pUserData, pData);
EndingOfs = StartingOfs + UserSize;
Size = BEHAVIAC_ROUND(EndingOfs, 16);
for (i = 0; i < (Size / 16); i++)
{
memset(Str, ' ', sizeof(Str));
string_snprintf(Str, sizeof(Str), "%p", pData + i * 16);
Str[8] = ':';
for (size_t j = 0; j < 16; j++)
{
size_t Ofs = i * 16 + j;
size_t Index = (j * 3) + ((j > 7) ? 11 : 10);
if ((Ofs >= StartingOfs) && (Ofs < EndingOfs))
{
string_snprintf(Str + Index, sizeof(Str) - Index, "%02X", pData[Ofs]);
Str[Index + 2] = ' ';
//Str[60+j] = Str::IsPrintable(pData[Ofs]) ? pData[Ofs] : '.';
Str[60 + j] = pData[Ofs];
}
}
Str[76] = '\n';
Str[77] = 0;
Output(Filter, Str);
} // for(i = 0; i < (Size / 16) ; i++)
} // if((pData) && (Size > 0))
void CLogger::PrintLines(ETagLogLevel Filter, const char* pStr) {
BEHAVIAC_UNUSED_VAR(Filter);
TestInit();
const int kMaxStringLength = 2048;
int count = 0;
char line[kMaxStringLength];
while (*pStr != '\0' && *pStr != '\n') {
line[count++] = *pStr++;
}
if (*pStr == '\n') {
line[count++] = *pStr++;
}
line[count++] = '\0';
BEHAVIAC_ASSERT(count < kMaxStringLength);
count = 0;
//the first line
OutputDecoratedLine(Filter, line);
while (*pStr != '\0') {
while (*pStr != '\0' && *pStr != '\n') {
line[count++] = *pStr++;
}
if (*pStr == '\n') {
line[count++] = *pStr++;
}
line[count++] = '\0';
BEHAVIAC_ASSERT(count < kMaxStringLength);
count = 0;
OutputLine(line);
}
}
int main(int argc, char **argv)
{
int server_sock, session_sock;
if (argc > 1) TestInit(0);
server_sock = OpenUDPSocket( 1701 );
session_sock = OpenPPPoL2TPSocket();
/* Try sending packets first to see if that helps */
// SendRawPacket( server_sock, 1701, control_packet, sizeof( control_packet ) );
// SendRawPacket( server_sock, 1701, data_packet, sizeof( data_packet ) );
fcntl( server_sock, F_SETFL, O_NONBLOCK );
fcntl( session_sock, F_SETFL, O_NONBLOCK );
CheckPipe( server_sock );
ConnectSock( session_sock, server_sock, 1701, 1, 2, 3, 4 );
system( "./subtest-proc" );
SendRawPacket( server_sock, 1701, control_packet, sizeof( control_packet ) );
SendRawPacket( server_sock, 1701, data_packet, sizeof( data_packet ) );
system( "./subtest-proc" );
CheckPipe( server_sock );
CheckPipe( session_sock );
system( "./subtest-proc" );
/* Close session socket first, because other way round breaks right now */
TestPrintf( "Closing session socket\n" );
close( session_sock );
TestPrintf( "Closing server socket\n" );
close( server_sock );
return 0;
}
// simplest of all tests. Just set a file descriptor and see that it's available
// repeat many times
HRESULT CTestPolling::Test1()
{
HRESULT hr = S_OK;
HRESULT hrResult;
size_t size;
PollEvent event;
int fd;
int count = 0;
srand(100);
ChkA(TestInit(10, 10));
size = _pipes.size();
hrResult = _spPolling->WaitForNextEvent(&event, 0);
ChkIfA(hrResult != S_FALSE, E_UNEXPECTED);
// one event at a time model
for (int index = 0; index < 100; index++)
{
size_t item = rand() % size;
ChkA(WritePipe(&_pipes[item]));
ConsumeEvent(&fd, &count);
ChkIfA(fd != _pipes[item].readpipe, E_UNEXPECTED);
ChkIfA(count != 1, E_UNEXPECTED);
}
hrResult = _spPolling->WaitForNextEvent(&event, 0);
ChkIfA(hrResult != S_FALSE, E_UNEXPECTED);
Cleanup:
return hr;
}
int my_main(const char* str_latero_ip, int print_response, int npack,
unsigned int* dacval, int dacval_cnt,
char rd, char wr, int addr, int value, char dst_main, char dst_io, int testpattern )
{
latero_conn latero;
/*
struct sockaddr_in si_server, si_other;
int s, ii, slen=sizeof(si_other);
char pktbuff[BUFLEN];
char rspbuff[BUFLEN];
*/
int ii;
uint8_t blades[64];
uint16_t dio_out = 0x0000;
// For raw address commands
uint16_t saddr = 0x0000;
uint16_t sdata = 0x0000;
latero_dst_device destination;
int numbytes = 0;
latero_pkt_t response;
printf("Init Connection: ");
if ( ii = init_connection( &latero, str_latero_ip ) < 0 ) {
printf("Error (%d)!\n",ii );
return(-1);
} else {
printf("OK.\n");
}
// Sanitize the dac values
for(ii = 0 ; ii < 4 ; ii++ ) {
if (ii < dacval_cnt ) {
setDAC( &latero, ii, dacval[ii] );
}
}
/*
for(ii = 0 ; ii<64 ; ii++ ) {
blades[ii] = ii;
}
setBlades( &latero, blades );
*/
// Run a few test cases here
TestInit();
ii = 0;
switch(testpattern) {
case 1:
TestSplit1(&latero);
sleep(1);
TestSplit2(&latero);
break;
case 2:
TestAllpin(&latero);
break;
case 3:
TestRow(&latero);
sleep(1);
TestCol(&latero);
break;
case 4:
// Test continuously without stopping
while(1) {
printf("%d ", ii);
TestRow(&latero);
printf("%d ", ii);
TestCol(&latero);
ii++;
}
break;
}
/* Just on led is turned on... */
setDIO( &latero, 0xDEAC );
// setDAC( &latero, 0x0, 0x1234 );
// setDAC( &latero, 0x1, 0x5678 );
// setDAC( &latero, 0x2, 0x9ABC );
// setDAC( &latero, 0x3, 0xDEF0 );
printf("Sending\n");
sendNormalPacket( &latero, &response );
printf("printing\n");
printPacket( &response );
/*
printf("Test Connection\n");
if( test_connection( &latero ) < 0 ) {
fprintf(stderr,"The test_connection() failed\n");
} else {
printf("Connection with Latero is OK.\n");
}
*/
if( rd > 0 || wr > 0 ) {
saddr = addr & 0xFFFF;
sdata = value & 0xFFFF;
if ( dst_main > 0 ) {
destination = LATERO_CONTROLLER;
} else if ( dst_io > 0 ) {
destination = LATERO_IO;
}
if( rd > 0 ) {
rawRead( &latero, destination, saddr, &sdata );
printf("Data Read at address 0x%4.4X = 0x%4.4X\n", saddr,sdata);
} else { /* Write */
rawWrite(&latero, destination, saddr, sdata );
printf("0x%4.4X written at address 0x%4.4X\n", sdata,saddr );
}
} else {
// Normal Latero Packets
//fillNormalPacket(PKT_TYPE_FULL, dac, blades, dio_out, &packetSend);
}
return( close_connection( &latero ) );
}
// create a polling set
HRESULT CTestPolling::Test2()
{
// simulate the following events in random order:
// socket added (did it succeed as expected)
// incoming data (write to a random pipe)
// WaitForNextEvent called (did it return an expected result/socket)
// Remove socket last notified about
HRESULT hr = S_OK;
HRESULT hrResult;
PollEvent event;
const size_t c_maxSockets = 10;
srand(100);
ChkA(TestInit(c_maxSockets, 0));
hrResult = _spPolling->WaitForNextEvent(&event, 0);
ChkIfA(hrResult != S_FALSE, E_UNEXPECTED);
for (size_t index = 0; index < 1000; index++)
{
int randresult = ::rand() % 4;
switch (randresult)
{
case 0:
{
// simulate a new socket being added
if (_pipes.size() >= c_maxSockets)
{
continue;
}
ChkA(CreateAndAddPipe());
break;
}
case 1:
{
// simulate incoming data
size_t size = _pipes.size();
size_t itemindex;
if (size == 0)
{
continue;
}
itemindex = rand() % size;
ChkA(WritePipe(&_pipes[itemindex]));
break;
}
case 2:
case 3:
{
int fd;
size_t pending = GetPendingCount();
if (pending == 0)
{
continue;
}
ChkA(ConsumeEvent(&fd, NULL));
if (randresult == 3)
{
// simulate removing this pipe from the set
ChkA(RemovePipe(FindPipePairIndex(fd)));
}
break;
} // case
} // switch
} // for
Cleanup:
return hr;
}
EXTERN UINT YICALL KernelMain()
{
/* struct aa test;
YI_PLIST_HEAD ptest;
ptest=&test.list;
YI_LIST_ENTRY(ptest, struct aa, list)->list.pNext = 0;*/
#if CFG_VBE == 1
YIDrawFillRect(0, 0, 800, 600, 0);
#endif /* CFG_VBE */
#if (CFG_DEBUG == 1)
YIDbgInitDebug();
/*YIDebugPoint();*/
#endif
YIIntInitialize();
/* __asm__("cli\n\thlt");*/
YMInitialize();
YITimeInitialize();
/* YIDebugPoint(); */
YIDriverKBInitialize();
YIDriverPs2MouInitialize();
YIDriverComInitialize();
#if CFG_KERNEL_SCHED_METHOD_RM == 1
YIKeSchedRMInit();
#endif /* CFG_KERNEL_SCHED_METHOD_RM */
#if CFG_KERNEL_SCHED_METHOD_TIMESLICE == 1
YIKeSchedRMInit();
#endif /* CFG_KERNEL_SCHED_METHOD_TIMESLICE */
/* YIRtlKernelMsg("Welcome to YingOS! Copyright(C) 2004-2005");*/
YIRtlKernelMsg("\n +-----------------------------------------+\n");
YIRtlKernelMsg(" |Welcome to Ver: 1.0.0 |\n");
YIRtlKernelMsg(" | |\n");
YIRtlKernelMsg(" |__ __ ____ _____ |\n");
YIRtlKernelMsg(" |\\ \\ / /_ / __ \\ / ____||\n");
YIRtlKernelMsg(" | \\ \\_/ /(_) _ __ __ _ | | | || (___ |\n");
YIRtlKernelMsg(" | \\ / | || '_ \\ / _` || | | | \\___ \\ |\n");
YIRtlKernelMsg(" | | | | || | | || (_| || |__| | ____) ||\n");
YIRtlKernelMsg(" | |_| |_||_| |_| \\__, | \\____/ |_____/ |\n");
YIRtlKernelMsg(" | |___/ |\n");
YIRtlKernelMsg(" |-----------------------------------------|\n");
YIRtlKernelMsg(" | Copyright (2004-2005) Devin Wang |\n");
YIRtlKernelMsg(" +-----------------------------------------+\n");
#if CFG_GUI > 0
YIRtlKernelMsg(" ÄúºÃ,»¶ÓʹÓÃYingOS!\n");
#endif /* CFG_GUI */
YIDrawFillRect(100, 100, 200, 200, 0x0000ff00);
/* YIDebugPoint();*/
TestInit();
/*YIHLT(); */
/* YIDebugPoint(); */
/* YIHalExitCritical(); */
YIHalReSched();
/*asm("sti");
for(;;)
{
asm("hlt");
}*/
return 0;
}
int main(int argc, char **argv)
{
int server_sock1, session_sock1;
int server_sock2, session_sock2;
if (argc > 1) TestInit(0);
server_sock1 = OpenUDPSocket( 1701 );
session_sock1 = OpenPPPoL2TPSocket();
server_sock2 = OpenUDPSocket( 1702 );
session_sock2 = OpenPPPoL2TPSocket();
#if 0
/* Try sending packets first to see if that helps */
SendTestPacket( server_sock1, 1702 );
SendTestPacket( server_sock2, 1701 );
#endif
fcntl( server_sock1, F_SETFL, O_NONBLOCK );
fcntl( session_sock1, F_SETFL, O_NONBLOCK );
fcntl( server_sock2, F_SETFL, O_NONBLOCK );
fcntl( session_sock2, F_SETFL, O_NONBLOCK );
fcntl( server_sock1, F_SETFD, FD_CLOEXEC );
fcntl( session_sock1, F_SETFD, FD_CLOEXEC );
fcntl( server_sock2, F_SETFD, FD_CLOEXEC );
fcntl( session_sock2, F_SETFD, FD_CLOEXEC );
CheckPipe( server_sock1 );
CheckPipe( server_sock2 );
ConnectSock( session_sock1, server_sock1, 1702, 1, 2, 3, 4 );
ConnectSock( session_sock2, server_sock2, 1701, 3, 4, 1, 2 );
system( "./subtest-proc" );
SendTestPacket( session_sock1, 1702 );
SendTestPacket( session_sock2, 1701 );
system( "./subtest-proc" );
CheckPipe( server_sock1 );
CheckPipe( session_sock1 );
CheckPipe( server_sock2 );
CheckPipe( session_sock2 );
if (argc == 0)
{
StartLoopingFunction( session_sock1, 0, 0 );
StartLoopingFunction( session_sock2, 0, 0 );
StartLoopingFunction( server_sock1, 1702, 0 );
StartLoopingFunction( server_sock2, 1701, 0 );
}
else
{
StartLoopingFunction( session_sock1, 0, 1000 );
StartLoopingFunction( session_sock2, 0, 2000 );
StartLoopingFunction( server_sock1, 1702, 3000 );
StartLoopingFunction( server_sock2, 1701, 4000 );
}
if (argc == 0)
{
char buf[16];
fprintf( stdout, "Press any key to continue\n" );
fgets( buf, 10, stdin );
}
else
{
fprintf(stdout, "Waiting 60 seconds...\n");
sleep(60);
}
system( "./subtest-proc" );
TestPrintf( "Closing server2 socket\n" );
close( server_sock2 );
TestPrintf( "Closing session2 socket\n" );
close( session_sock2 );
TestPrintf( "Closing session1 socket\n" );
close( session_sock1 );
TestPrintf( "Closing server1 socket\n" );
close( server_sock1 );
return 0;
}
int main(int argc, char **argv)
{
int mpi_size, mpi_rank; /* mpi variables */
H5Ptest_param_t ndsets_params, ngroups_params;
H5Ptest_param_t collngroups_params;
H5Ptest_param_t io_mode_confusion_params;
/* Un-buffer the stdout and stderr */
setbuf(stderr, NULL);
setbuf(stdout, NULL);
MPI_Init(&argc, &argv);
MPI_Comm_size(MPI_COMM_WORLD, &mpi_size);
MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank);
dim0 = ROW_FACTOR*mpi_size;
dim1 = COL_FACTOR*mpi_size;
if (MAINPROCESS) {
printf("===================================\n");
printf("PHDF5 TESTS START\n");
printf("===================================\n");
}
H5open();
h5_show_hostname();
/* Initialize testing framework */
TestInit(argv[0], usage, parse_options);
/* Tests are generally arranged from least to most complexity... */
AddTest("mpiodup", test_fapl_mpio_dup, NULL,
"fapl_mpio duplicate", NULL);
AddTest("posixdup", test_fapl_mpiposix_dup, NULL,
"fapl_mpiposix duplicate", NULL);
AddTest("split", test_split_comm_access, NULL,
"dataset using split communicators", PARATESTFILE);
AddTest("idsetw", dataset_writeInd, NULL,
"dataset independent write", PARATESTFILE);
AddTest("idsetr", dataset_readInd, NULL,
"dataset independent read", PARATESTFILE);
AddTest("cdsetw", dataset_writeAll, NULL,
"dataset collective write", PARATESTFILE);
AddTest("cdsetr", dataset_readAll, NULL,
"dataset collective read", PARATESTFILE);
AddTest("eidsetw", extend_writeInd, NULL,
"extendible dataset independent write", PARATESTFILE);
AddTest("eidsetr", extend_readInd, NULL,
"extendible dataset independent read", PARATESTFILE);
AddTest("ecdsetw", extend_writeAll, NULL,
"extendible dataset collective write", PARATESTFILE);
AddTest("ecdsetr", extend_readAll, NULL,
"extendible dataset collective read", PARATESTFILE);
AddTest("eidsetw2", extend_writeInd2, NULL,
"extendible dataset independent write #2", PARATESTFILE);
AddTest("selnone", none_selection_chunk, NULL,
"chunked dataset with none-selection", PARATESTFILE);
AddTest("calloc", test_chunk_alloc, NULL,
"parallel extend Chunked allocation on serial file", PARATESTFILE);
AddTest("fltread", test_filter_read, NULL,
"parallel read of dataset written serially with filters", PARATESTFILE);
#ifdef H5_HAVE_FILTER_DEFLATE
AddTest("cmpdsetr", compress_readAll, NULL,
"compressed dataset collective read", PARATESTFILE);
#endif /* H5_HAVE_FILTER_DEFLATE */
ndsets_params.name = PARATESTFILE;
ndsets_params.count = ndatasets;
AddTest("ndsetw", multiple_dset_write, NULL,
"multiple datasets write", &ndsets_params);
ngroups_params.name = PARATESTFILE;
ngroups_params.count = ngroups;
AddTest("ngrpw", multiple_group_write, NULL,
"multiple groups write", &ngroups_params);
AddTest("ngrpr", multiple_group_read, NULL,
"multiple groups read", &ngroups_params);
AddTest("compact", compact_dataset, NULL,
"compact dataset test", PARATESTFILE);
collngroups_params.name = PARATESTFILE;
collngroups_params.count = ngroups;
AddTest("cngrpw", collective_group_write, NULL,
"collective group and dataset write", &collngroups_params);
AddTest("ingrpr", independent_group_read, NULL,
"independent group and dataset read", &collngroups_params);
AddTest("bigdset", big_dataset, NULL,
"big dataset test", PARATESTFILE);
AddTest("fill", dataset_fillvalue, NULL,
"dataset fill value", PARATESTFILE);
AddTest("cchunk1",
coll_chunk1,NULL, "simple collective chunk io",PARATESTFILE);
AddTest("cchunk2",
coll_chunk2,NULL, "noncontiguous collective chunk io",PARATESTFILE);
AddTest("cchunk3",
coll_chunk3,NULL, "multi-chunk collective chunk io",PARATESTFILE);
AddTest("cchunk4",
coll_chunk4,NULL, "collective chunk io with partial non-selection ",PARATESTFILE);
if((mpi_size < 3)&& MAINPROCESS ) {
printf("Collective chunk IO optimization APIs ");
printf("needs at least 3 processes to participate\n");
printf("Collective chunk IO API tests will be skipped \n");
}
AddTest((mpi_size <3)? "-cchunk5":"cchunk5" ,
coll_chunk5,NULL,
"linked chunk collective IO without optimization",PARATESTFILE);
AddTest((mpi_size < 3)? "-cchunk6" : "cchunk6",
coll_chunk6,NULL,
"multi-chunk collective IO without optimization",PARATESTFILE);
AddTest((mpi_size < 3)? "-cchunk7" : "cchunk7",
coll_chunk7,NULL,
"linked chunk collective IO with optimization",PARATESTFILE);
AddTest((mpi_size < 3)? "-cchunk8" : "cchunk8",
coll_chunk8,NULL,
"linked chunk collective IO transferring to multi-chunk",PARATESTFILE);
AddTest((mpi_size < 3)? "-cchunk9" : "cchunk9",
coll_chunk9,NULL,
"multiple chunk collective IO with optimization",PARATESTFILE);
AddTest((mpi_size < 3)? "-cchunk10" : "cchunk10",
coll_chunk10,NULL,
"multiple chunk collective IO transferring to independent IO",PARATESTFILE);
/* irregular collective IO tests*/
AddTest("ccontw",
coll_irregular_cont_write,NULL,
"collective irregular contiguous write",PARATESTFILE);
AddTest("ccontr",
coll_irregular_cont_read,NULL,
"collective irregular contiguous read",PARATESTFILE);
AddTest("cschunkw",
coll_irregular_simple_chunk_write,NULL,
"collective irregular simple chunk write",PARATESTFILE);
AddTest("cschunkr",
coll_irregular_simple_chunk_read,NULL,
"collective irregular simple chunk read",PARATESTFILE);
AddTest("ccchunkw",
coll_irregular_complex_chunk_write,NULL,
"collective irregular complex chunk write",PARATESTFILE);
AddTest("ccchunkr",
coll_irregular_complex_chunk_read,NULL,
"collective irregular complex chunk read",PARATESTFILE);
#if 0
if((mpi_size > 3) && MAINPROCESS) {
printf("Collective irregular chunk IO tests haven't been tested \n");
printf(" for the number of process greater than 3.\n");
printf("Please try with the number of process \n");
printf(" no greater than 3 for collective irregular chunk IO test.\n");
printf("Collective irregular chunk tests will be skipped \n");
}
AddTest((mpi_size > 3) ? "-ccontw" : "ccontw",
coll_irregular_cont_write,NULL,
"collective irregular contiguous write",PARATESTFILE);
AddTest((mpi_size > 3) ? "-ccontr" : "ccontr",
coll_irregular_cont_read,NULL,
"collective irregular contiguous read",PARATESTFILE);
AddTest((mpi_size > 3) ? "-cschunkw" : "cschunkw",
coll_irregular_simple_chunk_write,NULL,
"collective irregular simple chunk write",PARATESTFILE);
AddTest((mpi_size > 3) ? "-cschunkr" : "cschunkr",
coll_irregular_simple_chunk_read,NULL,
"collective irregular simple chunk read",PARATESTFILE);
AddTest((mpi_size > 3) ? "-ccchunkw" : "ccchunkw",
coll_irregular_complex_chunk_write,NULL,
"collective irregular complex chunk write",PARATESTFILE);
AddTest((mpi_size > 3) ? "-ccchunkr" : "ccchunkr",
coll_irregular_complex_chunk_read,NULL,
"collective irregular complex chunk read",PARATESTFILE);
#endif
AddTest("null", null_dataset, NULL,
"null dataset test", PARATESTFILE);
io_mode_confusion_params.name = PARATESTFILE;
io_mode_confusion_params.count = 0; /* value not used */
AddTest("I/Omodeconf", io_mode_confusion, NULL,
"I/O mode confusion test -- hangs quickly on failure",
&io_mode_confusion_params);
/* Display testing information */
TestInfo(argv[0]);
/* setup file access property list */
fapl = H5Pcreate (H5P_FILE_ACCESS);
H5Pset_fapl_mpio(fapl, MPI_COMM_WORLD, MPI_INFO_NULL);
/* Parse command line arguments */
TestParseCmdLine(argc, argv);
if (facc_type == FACC_MPIPOSIX && MAINPROCESS) {
printf("===================================\n"
" Using MPIPOSIX driver\n"
"===================================\n");
}
if (dxfer_coll_type == DXFER_INDEPENDENT_IO && MAINPROCESS) {
printf("===================================\n"
" Using Independent I/O with file set view to replace collective I/O \n"
"===================================\n");
}
/* Perform requested testing */
PerformTests();
/* make sure all processes are finished before final report, cleanup
* and exit.
*/
MPI_Barrier(MPI_COMM_WORLD);
/* Display test summary, if requested */
if (MAINPROCESS && GetTestSummary())
TestSummary();
/* Clean up test files */
h5_cleanup(FILENAME, fapl);
nerrors += GetTestNumErrs();
/* Gather errors from all processes */
{
int temp;
MPI_Allreduce(&nerrors, &temp, 1, MPI_INT, MPI_MAX, MPI_COMM_WORLD);
nerrors=temp;
}
if (MAINPROCESS) { /* only process 0 reports */
printf("===================================\n");
if (nerrors)
printf("***PHDF5 tests detected %d errors***\n", nerrors);
else
printf("PHDF5 tests finished with no errors\n");
printf("===================================\n");
}
/* close HDF5 library */
H5close();
/* MPI_Finalize must be called AFTER H5close which may use MPI calls */
MPI_Finalize();
/* cannot just return (nerrors) because exit code is limited to 1byte */
return(nerrors!=0);
}
HRESULT ViewTest2::Run()
{
// Make a special VwGraphics (#define BASELINE in compiling it turns on special features).
// This VwGraphics will not draw (2nd arg false) but will record attempts at drawing into
// the baseline.
m_psts = NewObj SilTestSite();
m_qst.Attach(m_psts);
m_qvg.Attach(NewObj VwGraphics(m_psts, false, true));
m_qst->SetBaselineFile(SmartBstr(L"c:\\fw\\testlog\\log\\VwGraphics").Bstr());
// Todo LukeU(JohnT): make an off-screen bitmap HDC and initialize the VwGraphics to use it.
// Here is your off-screen bitmap and memory surface
HDC hdcScr, hdcMem;
hdcScr = GetDC(NULL);
hdcMem = CreateCompatibleDC(hdcScr);
HBITMAP hBitmap = CreateCompatibleBitmap(hdcMem, 400, 400);
SelectObject(hdcMem, hBitmap);
ReleaseDC(NULL, hdcScr);
m_qvg->Initialize(hdcMem);
// Make a dummy root site for the Root box to talk back to
m_qtrs.Attach(NewObj VwTestRootSite);
m_qtrs->SetVgObject(m_qvg);
Rect rcSrc(0, 0, 96, 96);
Rect rcDst(0, 0, 96, 96);
m_qtrs->SetSrcRoot(rcSrc);
m_qtrs->SetDstRoot(rcDst);
// Make our view constructor.
m_qtvc.Attach(NewObj TestStVc);
// Put some dummy data into a cache. HVO 1 identifies the text as a whole.
// Arbitrarily objects 2, 3, and 4 are the three paragraphs of our test data.
m_qda.Attach(NewObj VwCacheDa);
HVO rghvoPara[3] = {2, 3, 4};
m_qda->CacheVecProp(1, kflidStText_Paragraphs, rghvoPara, 3);
ITsStrFactoryPtr qtsf;
qtsf.CreateInstance(CLSID_TsStrFactory);
ITsStringPtr qtss;
int enc = 100;
StrUni stuPara0 = L"This is the first paragraph";
StrUni stuPara1 = L"Here is another paragraph, quite silly and trivial but it should "
L"help test things";
StrUni stuPara2 = L"I try to keep the text in these quite different so they can't be "
L"confused";
CheckHr(qtsf->MakeStringRgch(stuPara0.Chars(), stuPara0.Length(), enc, &qtss));
m_qda->CacheStringProp(rghvoPara[0], kflidStTxtPara_Contents, qtss);
CheckHr(qtsf->MakeStringRgch(stuPara1.Chars(), stuPara1.Length(), enc, &qtss));
m_qda->CacheStringProp(rghvoPara[1], kflidStTxtPara_Contents, qtss);
CheckHr(qtsf->MakeStringRgch(stuPara2.Chars(), stuPara2.Length(), enc, &qtss));
m_qda->CacheStringProp(rghvoPara[2], kflidStTxtPara_Contents, qtss);
ITsPropsBldrPtr qtpb;
qtpb.CreateInstance(CLSID_TsPropsBldr);
StrUni stuNormal = L"Normal";
CheckHr(qtpb->SetStrPropValue(kspNamedStyle, stuNormal.Bstr()));
// Make the root box and initialize it.
m_qrootb.CreateInstance(CLSID_VwRootBox);
// OK, we have a root box set up. Now we can try some tests on it!
TestInit();
TestDataAccess();
TestLayout(350);
TestDrawRoot();
TestOverlay();
TestMakeSimpleSel();
TestMakeTextSelection();
TestKeys();
TestMouse();
Testget_Site();
TestLoseFocus();
TestListener();
m_qrootb->Close();
m_qrootb.Clear();
m_qda.Clear();
DeleteDC(hdcMem);
DeleteObject(hBitmap);
return S_OK;
}
//************************************************
//*操纵杆输入线程
//************************************************
DWORD WINAPI t1::InputThreadProcedure(LPVOID lpStartupParam)
{
// get the data we passed to the thread. Note that we don't have to use this
// at all if we don't want
MYDATA* pMyData = (MYDATA*)lpStartupParam;
// access some imaginary members of MYDATA, which you can define on
// your own later
pMyData->nTime = GetCurrentTime(); // imaginary function I created
pMyData->nNumber = 5;
// here's the thread's main loop ?kind of like the main loop in WinMain
MSG msg;
int i;
for (;;)
{
//处理外部消息
if (PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE))
{
GetMessage(&msg, NULL, 0, 0);
if (msg.message == WM_THREADSTOP)
break; // only way out of the for( ;; ) loop
TranslateMessage(&msg);
DispatchMessage(&msg);
}
else
{
switch (m_TestState)
{
case STATE_DISPLAYINSTURCTION:
case STATE_DISPLAYNEXT:
case STATE_DISPLAYOPTION:
//呈现开始选项，等待按任意键开始测试
if (JoystickUpdate())
{
for (i = 0; i<8; i++)
{
if (IsButtonDown(KEY_YES))
{
m_TrialNo++;
TestInit();
m_TestState = STATE_DISPLAYOBJ;
break;
}
}
}
break;
case STATE_DISPLAYOBJ:
case STATE_MOVINGOBJ:
//测试过程中获得操纵杆输入
if (JoystickUpdate())
{
JoyX = GetXAxis();//GetYAxis();//
JoyY = GetYAxis();//-GetZAxis();//
if (m_Setting.m_MoveMode == MODE_MOVEROATE)
{
JoyZ = GetZAxis();//GetXAxis();//
post_fai = (float)(JoyZ - post_fai0)*(3600.0 / 1024.0) / m_HardSetting.m_KnobSensitive;//GetZAxis()*PI/400.0;
while (post_fai<-180)
{
post_fai = post_fai + 360;
}
while (post_fai>180)
{
post_fai = post_fai - 360;
}
}
}
break;
case STATE_OVER:
//测试结束，等待按任意键退出
if (JoystickUpdate())
{
for (i = 0; i<12; i++)
{
if (IsButtonDown(i))
{
PostThreadMessage(dwInputThreadID, WM_THREADSTOP, 0, 0);
m_TestState = STATE_NEXT;// STATE_EXIT --> STATE_NEXT
}
}
}
break;
default:
break;
}
// do the task ?add in your own stuff here
// yield to other threads, because we almost never get messages
// (note that we may be yielding to WinMain too)
//以键盘代替操纵杆
if (JOY == 0)
{
if (IsButtonDown(DIK_ESCAPE))
{
PostThreadMessage(dwInputThreadID, WM_THREADSTOP, 0, 0);
m_TestState = STATE_EXIT;
}
}
}
Sleep(1);
}
g_nThreadExitCount++;
return 0;
}
/**
* Provide an alternate "main loop" via StartCompetition().
*
* This specific StartCompetition() implements "main loop" behaviour synced with the DS packets
*/
void IterativeRobot::StartCompetition()
{
HALReport(HALUsageReporting::kResourceType_Framework, HALUsageReporting::kFramework_Iterative);
LiveWindow *lw = LiveWindow::GetInstance();
// first and one-time initialization
SmartDashboard::init();
NetworkTable::GetTable("LiveWindow")->GetSubTable("~STATUS~")->PutBoolean("LW Enabled", false);
RobotInit();
// We call this now (not in Prestart like default) so that the robot
// won't enable until the initialization has finished. This is useful
// because otherwise it's sometimes possible to enable the robot
// before the code is ready.
HALNetworkCommunicationObserveUserProgramStarting();
// loop forever, calling the appropriate mode-dependent function
lw->SetEnabled(false);
while (true)
{
// Call the appropriate function depending upon the current robot mode
if (IsDisabled())
{
// call DisabledInit() if we are now just entering disabled mode from
// either a different mode or from power-on
if(!m_disabledInitialized)
{
lw->SetEnabled(false);
DisabledInit();
m_disabledInitialized = true;
// reset the initialization flags for the other modes
m_autonomousInitialized = false;
m_teleopInitialized = false;
m_testInitialized = false;
}
HALNetworkCommunicationObserveUserProgramDisabled();
DisabledPeriodic();
}
else if (IsAutonomous())
{
// call AutonomousInit() if we are now just entering autonomous mode from
// either a different mode or from power-on
if(!m_autonomousInitialized)
{
lw->SetEnabled(false);
AutonomousInit();
m_autonomousInitialized = true;
// reset the initialization flags for the other modes
m_disabledInitialized = false;
m_teleopInitialized = false;
m_testInitialized = false;
}
HALNetworkCommunicationObserveUserProgramAutonomous();
AutonomousPeriodic();
}
else if (IsTest())
{
// call TestInit() if we are now just entering test mode from
// either a different mode or from power-on
if(!m_testInitialized)
{
lw->SetEnabled(true);
TestInit();
m_testInitialized = true;
// reset the initialization flags for the other modes
m_disabledInitialized = false;
m_autonomousInitialized = false;
m_teleopInitialized = false;
}
HALNetworkCommunicationObserveUserProgramTest();
TestPeriodic();
}
else
{
// call TeleopInit() if we are now just entering teleop mode from
// either a different mode or from power-on
if(!m_teleopInitialized)
{
lw->SetEnabled(false);
TeleopInit();
m_teleopInitialized = true;
// reset the initialization flags for the other modes
m_disabledInitialized = false;
m_autonomousInitialized = false;
m_testInitialized = false;
Scheduler::GetInstance()->SetEnabled(true);
}
HALNetworkCommunicationObserveUserProgramTeleop();
TeleopPeriodic();
}
// wait for driver station data so the loop doesn't hog the CPU
m_ds->WaitForData();
}
}
int main(int argc,
char **argv) {
int opt;
uint64_t sleep_start_usec = kDefaultSleepStartMicroSeconds;
uint64_t sleep_end_usec = kDefaultSleepEndMicroSeconds;
uint64_t sleep_incr_usec = kDefaultSleepIncrMicroSeconds;
uint64_t sleep_usec;
uint64_t min_sleep;
uint64_t max_sleep;
uint64_t total_usec;
char *nacl_verbosity = getenv("NACLVERBOSITY");
struct TestFunctorArg arg;
int alarmer = 1;
static void (*const test_tbl[])(void *) = {
TestAbsWait, TestRelWait,
};
size_t ix;
while (EOF != (opt = getopt(argc, argv,"aAc:C:e:f:F:i:s:v"))) {
switch (opt) {
case 'a':
alarmer = 1;
break;
case 'A':
alarmer = 0;
break;
case 'c':
gSchedulerMinFuzzConst = strtoul(optarg, (char **) 0, 0);
break;
case 'C':
gSchedulerMaxMin = strtoul(optarg, (char **) 0, 0);
break;
case 'e':
sleep_end_usec = strtoul(optarg, (char **) 0, 0);
break;
case 'f':
gSchedulerMinFuzzFactor = atof(optarg);
break;
case 'F':
gSchedulerMaxFuzzFactor = atof(optarg);
break;
case 'i':
sleep_incr_usec = strtoul(optarg, (char **) 0, 0);
break;
case 's':
sleep_start_usec = strtoul(optarg, (char **) 0, 0);
break;
case 'v':
++gVerbosity;
break;
default:
fprintf(stderr,
"Usage: nacl_sync_cond_test [flags]\n"
" where flags specify the range of condition variable\n"
" wait times:\n"
" -a use an alarm thread to detect significant oversleep\n"
" -A do not use an alarm thread\n"
" -s start microseconds\n"
" -e end microseconds\n"
" -i increment microseconds\n"
" -f scheduler fuzz factor (double; for min elapsed time)\n"
" -F scheduler fuzz factor (double; max elapsed time)\n"
" -c scheduler fuzz constant (int, uS)\n"
" allow actual elapsed time to be this much less\n"
" than requested.\n"
" -C scheduler fuzz constant (int, uS)\n"
" max allowed elapsed time is at least this\n"
);
return 1;
}
}
NaClAllModulesInit();
NaClLogSetVerbosity((NULL == nacl_verbosity)
? 0 : strtol(nacl_verbosity, (char **) 0, 0));
TestInit();
ASSERT_MSG(sleep_end_usec > sleep_start_usec,
"nonsensical start/end times");
ASSERT_MSG(0 < sleep_incr_usec,
"nonsensical increment time");
/*
* sum of [m..n) by k is (m+n)(n-m)/k/2, and we run Rel and Abs, so
* the expected time is twice the sum
*/
total_usec = (sleep_end_usec + sleep_start_usec)
* (sleep_end_usec - sleep_start_usec) / sleep_incr_usec;
printf("Test should take approximately %"NACL_PRId64
".%06"NACL_PRId64" seconds"
" on an unloaded machine.\n",
total_usec / kMicroXinX, total_usec % kMicroXinX);
for (sleep_usec = sleep_start_usec;
sleep_usec < sleep_end_usec;
sleep_usec += sleep_incr_usec) {
if (gVerbosity) {
printf("testing wait limit of %"NACL_PRId64
" microseconds.\n", sleep_usec);
}
arg.sleep_usec = sleep_usec;
min_sleep = (int64_t) (gSchedulerMinFuzzFactor * sleep_usec);
if (min_sleep < gSchedulerMinFuzzConst) {
min_sleep = 0;
} else {
min_sleep -= gSchedulerMinFuzzConst;
}
max_sleep = (uint64_t) (gSchedulerMaxFuzzFactor * sleep_usec);
if (max_sleep < gSchedulerMaxMin) {
max_sleep = gSchedulerMaxMin;
}
for (ix = 0; ix < NACL_ARRAY_SIZE(test_tbl); ++ix) {
FunctorDelays(test_tbl[ix], &arg, sleep_usec, min_sleep, max_sleep,
alarmer);
}
}
TestFini();
NaClAllModulesFini();
printf("PASS\n");
return 0;
}
/**
* Provide an alternate "main loop" via StartCompetition().
*
* This specific StartCompetition() implements "main loop" behavior like that of the FRC
* control system in 2008 and earlier, with a primary (slow) loop that is
* called periodically, and a "fast loop" (a.k.a. "spin loop") that is
* called as fast as possible with no delay between calls.
*/
void IterativeRobot::StartCompetition()
{
LiveWindow *lw = LiveWindow::GetInstance();
// first and one-time initialization
SmartDashboard::init();
NetworkTable::GetTable("LiveWindow")->GetSubTable("~STATUS~")->PutBoolean("LW Enabled", false);
RobotInit();
// loop forever, calling the appropriate mode-dependent function
lw->SetEnabled(false);
while (true)
{
// Call the appropriate function depending upon the current robot mode
if (IsDisabled())
{
// call DisabledInit() if we are now just entering disabled mode from
// either a different mode or from power-on
if(!m_disabledInitialized)
{
lw->SetEnabled(false);
DisabledInit();
m_disabledInitialized = true;
// reset the initialization flags for the other modes
m_autonomousInitialized = false;
m_teleopInitialized = false;
m_testInitialized = false;
}
if (NextPeriodReady())
{
// TODO: HALNetworkCommunicationObserveUserProgramDisabled();
DisabledPeriodic();
}
}
else if (IsAutonomous())
{
// call AutonomousInit() if we are now just entering autonomous mode from
// either a different mode or from power-on
if(!m_autonomousInitialized)
{
lw->SetEnabled(false);
AutonomousInit();
m_autonomousInitialized = true;
// reset the initialization flags for the other modes
m_disabledInitialized = false;
m_teleopInitialized = false;
m_testInitialized = false;
}
if (NextPeriodReady())
{
// TODO: HALNetworkCommunicationObserveUserProgramAutonomous();
AutonomousPeriodic();
}
}
else if (IsTest())
{
// call TestInit() if we are now just entering test mode from
// either a different mode or from power-on
if(!m_testInitialized)
{
lw->SetEnabled(true);
TestInit();
m_testInitialized = true;
// reset the initialization flags for the other modes
m_disabledInitialized = false;
m_autonomousInitialized = false;
m_teleopInitialized = false;
}
if (NextPeriodReady())
{
// TODO: HALNetworkCommunicationObserveUserProgramTest();
TestPeriodic();
}
}
else
{
// call TeleopInit() if we are now just entering teleop mode from
// either a different mode or from power-on
if(!m_teleopInitialized)
{
lw->SetEnabled(false);
TeleopInit();
m_teleopInitialized = true;
// reset the initialization flags for the other modes
m_disabledInitialized = false;
m_autonomousInitialized = false;
m_testInitialized = false;
Scheduler::GetInstance()->SetEnabled(true);
}
if (NextPeriodReady())
{
// TODO: HALNetworkCommunicationObserveUserProgramTeleop();
TeleopPeriodic();
}
}
// wait for driver station data so the loop doesn't hog the CPU
m_ds.WaitForData();
}
}
/**
* @brief This sets up this suite
*
* @return 0 success, otherwise failure
*/
FCT_SETUP_BGN() {
TestInit();
memset(write_buffer, 0, WRITE_BUFFER_SIZE);
attoHTTPInit();
}
