int main (int argc, char **argv)
{
time_t t;
TEST_SUITE(sarien);
game.sbuf = malloc (_WIDTH * _HEIGHT);
game.hires = malloc (_WIDTH * 2 * _HEIGHT);
printf ("Sarien %s tests (build %s %s)\n", VERSION, __DATE__, __TIME__);
printf ("Current time: %s\n", ctime (&t));
sarien = test_initialize ("Sarien");
test_register_module (sarien, test_flag, "flag operations");
test_register_module (sarien, test_arith, "arithmetic operations");
test_register_module (sarien, test_random, "random numbers");
test_register_module (sarien, test_format, "string formatting");
test_register_module (sarien, test_picture, "picture drawing");
test_register_module (sarien, test_inventory, "inventory");
test_run_modules (sarien);
test_summarize (sarien);
free (game.sbuf);
free (game.hires);
return 0;
}
void test_pipeutils(IUnitTest* _ts)
{
TEST_SUITE(_ts,_T("Pipe"),_T("pipe utils"));
DWORD data1 = 0;
get_hex(_T("9d0bDCfe"),data1);
ok(EQL(data1,0x9d0bdcfe),_T("get_hex() error"));
WORD data2 = 0;
get_hex(_T("DCfe"),data2);
ok(EQL(data2,0xdcfe),_T("get_hex() error"));
BYTE data3 = 0;
get_hex(_T("a1"),data3);
ok(EQL(data3,0xa1),_T("get_hex() error"));
CString str;
guid_tostring(CPipeDataAGUID,str);
GUID guid;
string_toguid(str,guid);
ok(is_equal(guid,CPipeDataAGUID),_T("bad guid opeartions"));
CString guidstr1(_T("{12345678-1234-1234-1212121212121212}"));
ok(string_toguid(guidstr1,guid),_T("guid verify failed"));
CString badstr2(_T("12345678-1234-1234-1212121212121212}"));
ok(!string_toguid(badstr2,guid),_T("guid verify failed"));
CString badstr3(_T("{1234567-1234-1234-1212121212121212}"));
ok(!string_toguid(badstr3,guid),_T("guid verify failed"));
}
TEST_END_CASE
int main(int argc, char **argv)
{
if (sd_booted() <= 0)
return 77;
return test_run_suite(TEST_SUITE(edbus,
TEST_CASE(verify),
TEST_END));
}
int main (int argc, char ** argv)
{
printf ("CYPTO TESTS\n");
printf ("==================\n\n");
init (argc, argv);
TEST_SUITE (PLUGIN_NAME);
print_result (PLUGIN_NAME);
return nbError;
}
void test_CNamedPipeWrap_simple(IUnitTest* _ts)
{
//TEST_SUITE(_ts,);
TEST_SUITE(_ts,_T("Pipe"),_T("CNamedPipeWrap class tests"));
CNamedPipeWrap serverpipe;
CNamedPipeWrap clientpipe;
const LPCTSTR szPipeName = _T("test_pipe");
CEvent stopevnt(FALSE,TRUE);
ok(serverpipe.create(szPipeName,stopevnt,PIPE_ACCESS_INBOUND,PIPE_READMODE_BYTE|PIPE_TYPE_BYTE,false),_T("server pipe create error"));
ok(clientpipe.open(_T("."),szPipeName,GENERIC_WRITE,NMPWAIT_USE_DEFAULT_WAIT,PIPE_READMODE_BYTE,false),_T("client pipe open error"));
bool bstoped = false;
ok(serverpipe.connect(bstoped) && !bstoped,_T("server pipe connect error"));
CString data(_T("0123456789"));
string_converter<TCHAR,WCHAR> converted(data);
DWORD dwMetaData = PDM_Data;
ok(clientpipe.write_pipe((LPVOID)(LPCWSTR)converted,converted.get_length()*sizeof(WCHAR),dwMetaData),_T("client pipe write failed"));
LPVOID pbuf = NULL;
DWORD sz = 0;
DWORD dwReadedMetaData = PDM_Null;
ok(serverpipe.read_pipe(pbuf,sz,dwReadedMetaData,true),_T("server pipe read data failed"));
ok(sz!=0,_T("server pipe read data failed (size == 0)"));
ok(EQL(dwReadedMetaData,dwMetaData),_T("server pipe data differnt in meta type"));
CString readed = string_converter<WCHAR,TCHAR>((WCHAR*)pbuf,sz/sizeof(WCHAR));
ok(!readed.Compare(data),_T("readed by server pipe data not equal to written by client pipe data"));
delete[] trace_free(pbuf);
pbuf = NULL;
ok(clientpipe.write_pipe(pbuf,0,PDM_Data),_T("client pipe write error"));
pbuf = NULL;
sz = 0;
dwReadedMetaData = PDM_Null;
ok(serverpipe.read_pipe(pbuf,sz,dwReadedMetaData,true),_T("server pipe read data failed"));
delete[] trace_free(pbuf);
ok(serverpipe.disconnect(),_T("service pipe disconnect error"));
clientpipe.close();
serverpipe.close();
}
void test_ServerThread(IUnitTest* _ts)
{
TEST_SUITE(_ts,_T("Pipe"),_T("Pipe Server thread"));
//TRACE(_T("Test server thread ------------------------------------\n"));
CServer1* pserver = trace_alloc(new CServer1(_T("test_pipe")));
pserver->start();
Sleep(100);
CTime t1 = CTime::GetCurrentTime();
delete trace_free(pserver);
CTime t2 = CTime::GetCurrentTime();
CTimeSpan dif = t2 - t1;
ok(dif.GetSeconds()<5,_T("closing pipe server to long"));
}
void test_clientserver_simple(IUnitTest* _ts)
{
TEST_SUITE(_ts,_T("Pipe"),_T("simple client server communication"));
//TRACE(_T("--------------------------- test clien-server ---------------------------\n"));
const CString sPipeName(_T("test_pipe"));
CClientPipeComm client;
CServer1 server(sPipeName);
server.start();
Sleep(500);
ok(client.open(_T("."),sPipeName),_T("client open error"));
DWORD dwerr = GetLastError();
CDataPipeA senddata;
//send data first time
senddata.m_strdata = _T("test string");
senddata.m_ld = 61578;
ok(client.save(&senddata),_T("client save data error"));
DWORD res = ::WaitForSingleObject(server.m_recieved,10000);
ok(EQL(res,WAIT_OBJECT_0),_T("server failed to recieve data"));
ok(EQL(1,server.m_recievedcnt),_T("bad server recieve counter"));
ok(EQL(server.m_datagetted,senddata),_T("server recieved bad data"));
server.m_recieved.ResetEvent();
//TRACE(_T("---------------------------\n"));
//send data second time
senddata.m_strdata = _T("test string2");
senddata.m_ld = 781506;
ok(client.save(&senddata),_T("client save data error"));
res = ::WaitForSingleObject(server.m_recieved,10000);
ok(EQL(res,WAIT_OBJECT_0),_T("server failed to recieve data"));
ok(EQL(2,server.m_recievedcnt),_T("bad server recieve counter"));
ok(EQL(server.m_datagetted,senddata),_T("server recieved bad data"));
}
TEST_FUNC(test_basic_hashtable2_nbuckets),
TEST_FUNC(test_basic_height_balanced_tree),
TEST_FUNC(test_basic_path_reduction_tree),
TEST_FUNC(test_basic_red_black_tree),
TEST_FUNC(test_basic_skiplist),
TEST_FUNC(test_basic_splay_tree),
TEST_FUNC(test_basic_treap),
TEST_FUNC(test_basic_weight_balanced_tree),
TEST_FUNC(test_version_string),
CU_TEST_INFO_NULL
};
#define TEST_SUITE(suite) { #suite, NULL, NULL, suite }
CU_SuiteInfo test_suites[] = {
TEST_SUITE(basic_tests),
CU_SUITE_INFO_NULL
};
int
main()
{
CU_initialize_registry();
CU_register_suites(test_suites);
CU_basic_set_mode(CU_BRM_NORMAL);
CU_basic_run_tests();
CU_cleanup_registry();
return 0;
}
int main(int argc, char **argv)
{
RUN_TEST_SUITES(TEST_SUITE(Calculator), TEST_SUITE(Dummy));
return ERRORS_COUNT;
}
void test_CPipeReadBuffer(IUnitTest* _ts)
{
TEST_SUITE(_ts,_T("Pipe"),_T("buffer operations"));
CPipeReadedBuffer buffer;
CPipeReadedBuffer::PipeBufferErrorsEn bufferr = CPipeReadedBuffer::PBE_Success;
ok(buffer.is_empty(),_T("created buffer is not empty"));
const DWORD allocate_size = 100;
const DWORD blksz_1 = 122;
const DWORD blksz_1_aligned = align(blksz_1,QWORD());
const DWORD blksz_2 = 10;
const DWORD blksz_2_aligned = align(blksz_2,QWORD());
const DWORD blksz_3 = 15;
const DWORD blksz_3_aligned = align(blksz_3,QWORD());
LPVOID pbuf = NULL;
pbuf = buffer.alloc_chunk(allocate_size);
ok(is_all(pbuf,allocate_size,(BYTE)0),_T("alloc_chunk() not zeros memory"));
ok(buffer.get_firstBlockRealSize()==0,_T("allocated chunk is not counted"));
LPDWORD pdwbuf = (LPDWORD)pbuf;
pdwbuf[0] = PDM_Data;
pdwbuf[1] = blksz_1;
ok(buffer.get_firstBlockRealSize()==allocate_size-sizeof(DWORD)*2,_T("bad real size"));
ok(buffer.get_firstBlockSendedSize()==blksz_1,_T("allocated chunk is not counted"));
ok(buffer.get_firstBlockMetaData()==PDM_Data,_T("no metadata DWORD in data chunk"));
pbuf = buffer.alloc_chunk(allocate_size);
fill_fortest((LPVOID)(pdwbuf+2),allocate_size-sizeof(DWORD)*2);
DWORD cnt = blksz_1 - (allocate_size-sizeof(DWORD)*2);
fill_fortest(pbuf,cnt,(byte)(blksz_1-cnt));
ok(buffer.get_firstBlockRealSize()==blksz_1,_T("not processed block after it was already readed"));
ok(buffer.get_firstBlockSendedSize()==blksz_1,_T("bad real size"));
pdwbuf = (LPDWORD) ((LPBYTE)pbuf + blksz_1_aligned - (allocate_size-sizeof(DWORD)*2));
pdwbuf[0] = PDM_Data;
pdwbuf[1] = blksz_2;
fill_fortest((LPVOID)(pdwbuf+2),blksz_2);
pdwbuf = (LPDWORD)(
(LPBYTE)pbuf
+ blksz_1_aligned - (allocate_size - sizeof(DWORD)*2)
+ sizeof(DWORD)*2
+ blksz_2_aligned
);
pdwbuf[0] = PDM_Data;
pdwbuf[1] = blksz_3;
fill_fortest((LPVOID)(pdwbuf+2),blksz_3);
LPVOID preadbuf = NULL;
DWORD dwsize = 0;
DWORD dwMetaData = PDM_Null;
ok(EQL(CPipeReadedBuffer::PBE_Success,buffer.read(preadbuf,dwsize,dwMetaData,true))
&& EQL(dwMetaData,PDM_Data)
,_T("read error")
);
ok(EQL(dwsize,blksz_1),_T("read error"));
ok(test_filling(preadbuf,dwsize),_T("inccorrect data was readed"));
ok(buffer.get_firstBlockRealSize()==blksz_2,_T("incorrect buffer size"));
ok(buffer.get_firstBlockSendedSize()==blksz_2,_T("incorrect sended buffer size"));
delete[] trace_free(preadbuf);
dwsize = blksz_2+2;//set incorrect size
preadbuf = trace_alloc(new BYTE[dwsize]);
//test errors
dwMetaData = PDM_Null;
ok(EQL(CPipeReadedBuffer::PBE_WrongBufferSize,buffer.read(preadbuf,dwsize,dwMetaData,false))
,_T("read return not PBE_WrongBufferSize")
);
ok(buffer.get_firstBlockRealSize()==blksz_2,_T("incorrect buffer size"));
ok(buffer.get_firstBlockSendedSize()==blksz_2,_T("incorrect sended buffer size"));
dwMetaData = PDM_Null;
ok(EQL(CPipeReadedBuffer::PBE_InvalidArg,buffer.read(preadbuf,dwsize,dwMetaData,true))
,_T("read return not PBE_InvalidArg")
);
ok(buffer.get_firstBlockRealSize()==blksz_2,_T("incorrect buffer size"));
ok(buffer.get_firstBlockSendedSize()==blksz_2,_T("incorrect sended buffer size"));
delete[] trace_free(preadbuf);
dwsize = blksz_2;
preadbuf = trace_alloc(new BYTE[dwsize]);
ok(EQL(CPipeReadedBuffer::PBE_Success,buffer.read(preadbuf,dwsize,dwMetaData,false))
&& EQL(dwMetaData,PDM_Data)
,_T("read return not PBE_Success")
);
ok(test_filling(preadbuf,dwsize),_T("incorrect data was readed"));
ok(EQL(buffer.get_firstBlockRealSize(),blksz_3),_T("incorrect real size"));
ok(EQL(buffer.get_firstBlockSendedSize(),blksz_3),_T("incorrect sended size"));
ok(EQL(buffer.free_firstBlock(),CPipeReadedBuffer::PBE_Success),_T("error while free first block"));
ok(EQL(buffer.free_firstBlock(),CPipeReadedBuffer::PBE_DataNotReady),_T("free_firstBlock return not PBE_DataNotReady"));
delete[] trace_free(preadbuf);
}
void test_CSharedEvent(IUnitTest* _ts)
{
TEST_SUITE(_ts,_T("Pipe"),_T("CSharedEvent class"));
}