void task1(void *unused(arg))
{
printf("%s start\n", __FUNCTION__);
XTEST(rinoo_task_self() == sched->driver.current);
rinoo_task_run(sched, task2, sched);
XTEST(rinoo_task_self() == sched->driver.current);
printf("%s end\n", __FUNCTION__);
}
/**
* Main function for this unit test
*
*
* @return 0 if test passed
*/
int main()
{
XTEST(rinoo_task_self() == NULL);
sched = rinoo_sched();
XTEST(sched != NULL);
XTEST(rinoo_task_run(sched, task1, sched) == 0);
rinoo_sched_destroy(sched);
XPASS();
}
void task2(void *arg)
{
t_sched *sched = arg;
printf("%s start\n", __FUNCTION__);
XTEST(checker == 1);
rinoo_task_run(sched, task3, sched);
XTEST(checker == 3);
printf("%s end\n", __FUNCTION__);
}
/**
* Main function for this unit test
*
*
* @return 0 if test passed
*/
int main()
{
t_sched *sched;
sched = rinoo_sched();
XTEST(sched != NULL);
XTEST(rinoo_task_start(sched, task_func, sched) == 0);
rinoo_sched_loop(sched);
rinoo_sched_destroy(sched);
XPASS();
}
/**
* Main function for this unit test
*
*
* @return 0 if test passed
*/
int main()
{
t_sched *sched;
sched = rinoo_sched();
XTEST(sched != NULL);
XTEST(rinoo_task_run(sched, task1, sched) == 0);
rinoo_sched_destroy(sched);
XTEST(checker == 3);
XPASS();
}
/**
* Main function for this unit test.
*
*
* @return 0 if test passed
*/
int main()
{
t_sched *sched;
sched = rinoo_sched();
XTEST(sched != NULL);
XTEST(rinoo_task_start(sched, http_server, sched) == 0);
XTEST(rinoo_task_start(sched, http_client, sched) == 0);
rinoo_sched_loop(sched);
rinoo_sched_destroy(sched);
XPASS();
}
void task(void *unused(arg))
{
t_sched *cur;
printf("%s start\n", __FUNCTION__);
cur = rinoo_sched_self();
XTEST(cur != NULL);
XTEST(cur->id >= 0 && cur->id <= NBSPAWNS);
XTEST(checker[cur->id] == 0);
checker[cur->id] = 1;
printf("%s end\n", __FUNCTION__);
}
/**
* Main function for this unit test.
*
*
* @return 0 if test passed
*/
int main()
{
t_sched *sched;
sched = rinoo_sched();
XTEST(sched != NULL);
XTEST(rinoo_task_start(sched, server_func, NULL) == 0);
XTEST(rinoo_task_start(sched, client_func, NULL) == 0);
rinoo_sched_loop(sched);
rinoo_sched_destroy(sched);
XPASS();
}
void http_server_process(void *socket)
{
t_buffer content;
t_http http;
XTEST(rinoo_http_init(socket, &http) == 0);
XTEST(rinoo_http_request_get(&http));
http.response.code = 200;
strtobuffer(&content, HTTP_CONTENT);
XTEST(rinoo_http_response_send(&http, &content) == 0);
rinoo_http_destroy(&http);
rinoo_socket_destroy(socket);
}
void server_func(void *unused(arg))
{
t_socket *server;
t_socket *client;
server = rinoo_tcp_server(rinoo_sched_self(), IP_ANY, 4242);
XTEST(server != NULL);
client = rinoo_tcp_accept(server, NULL, NULL);
XTEST(client != NULL);
rinoo_log("client accepted");
rinoo_task_start(rinoo_sched_self(), process_client, client);
rinoo_socket_destroy(server);
}
////////////////////////////////////////////////////////////////
// CStream::WriteBytes
//
/////////////////////////////////////////////////////////////////
HRESULT CStream::WriteBytes(REFIID riid, DBLENGTH ulOffset, DBLENGTH cBytes, void* pBuffer, DBLENGTH* pcbWritten)
{
HRESULT hr = S_OK;
BOOL bUseDefault = FALSE;
ULONG cbWritten = 0;
//Determine object type
if(riid != IID_ISequentialStream && riid != IID_ILockBytes && riid != IID_IStream)
bUseDefault = TRUE;
//IID_ISequentialStream
if((riid == IID_ISequentialStream && m_pISequentialStream) || (bUseDefault && m_pISequentialStream))
{
//ISequentialStream::Write
//TODO64: I*::Write only takes a ULONG
XTEST(hr = m_pISequentialStream->Write(pBuffer, (ULONG)cBytes, &cbWritten));
TESTC(TRACE_METHOD(hr, L"ISequentialStream::Write(0x%p, %d, &%d)", pBuffer, cBytes, cbWritten));
}
//IID_ILockBytes
else if((riid == IID_ILockBytes && m_pILockBytes) || (bUseDefault && m_pILockBytes))
{
ULARGE_INTEGER ulgOffset;
ulgOffset.QuadPart = ulOffset;
//ILockBytes::WriteAt
//TODO64: I*::Write only takes a ULONG
XTEST(hr = m_pILockBytes->WriteAt(ulgOffset, pBuffer, (ULONG)cBytes, &cbWritten));
TESTC(TRACE_METHOD(hr, L"ILockBytes::WriteAt(%d, 0x%p, %d, &%d)", ulOffset, pBuffer, cBytes, cbWritten));
}
//IID_IStream
else if((riid == IID_IStream && m_pIStream) || (bUseDefault && m_pIStream))
{
//IStream::Write
//TODO64: I*::Write only takes a ULONG
XTEST(hr = m_pIStream->Write(pBuffer, (ULONG)cBytes, &cbWritten));
TESTC(TRACE_METHOD(hr, L"IStream::Write(0x%p, %d, &%d)", pBuffer, cBytes, cbWritten));
}
// else if(m_pIStorage)
// {
//TODO
// }
else
{
TESTC(hr = E_FAIL);
}
CLEANUP:
if(pcbWritten)
*pcbWritten = cbWritten;
return hr;
}
int main()
{
int i;
int min;
tmytest *head;
t_rinoorbtree tree;
t_rinoorbtree_node *node;
tmytest tab[RINOO_HEADTEST_NB_ELEM];
XTEST(rinoorbtree(&tree, cmp_func, NULL) == 0);
for (i = 0; i < RINOO_HEADTEST_NB_ELEM; i++) {
tab[i].val = random();
if (i == 0 || min > tab[i].val) {
min = tab[i].val;
}
XTEST(rinoorbtree_put(&tree, &tab[i].node) == 0);
XTEST(tree.head != NULL);
head = container_of(tree.head, tmytest, node);
XTEST(head->val == min);
}
rinoorbtree_flush(&tree);
for (i = 0; i < RINOO_HEADTEST_NB_ELEM; i++) {
tab[i].val = i;
XTEST(rinoorbtree_put(&tree, &tab[i].node) == 0);
XTEST(tree.head != NULL);
}
for (i = 0; i < RINOO_HEADTEST_NB_ELEM; i++) {
node = rinoorbtree_head(&tree);
XTEST(node != NULL);
head = container_of(node, tmytest, node);
XTEST(head->val == i);
rinoorbtree_remove(&tree, node);
}
XPASS();
}
/**
* Main function for this unit test.
*
*
* @return 0 if test passed
*/
int main()
{
t_sched *sched;
mkdir(TEST_DIRECTORY, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH);
sched = rinoo_sched();
XTEST(sched != NULL);
XTEST(rinoo_task_start(sched, check_file, sched) == 0);
XTEST(rinoo_task_start(sched, event_generator, sched) == 0);
rinoo_sched_loop(sched);
rinoo_sched_destroy(sched);
rmdir(TEST_DIRECTORY);
XPASS();
}
void client_func(void *unused(arg))
{
t_buffer buffer;
t_socket *client;
client = rinoo_tcp_client(rinoo_sched_self(), IP_LOOPBACK, 4242, 0);
XTEST(client != NULL);
str = malloc(sizeof(*str) * TRANSFER_SIZE);
XTEST(str != NULL);
memset(str, 'a', TRANSFER_SIZE);
buffer_static(&buffer, str, TRANSFER_SIZE);
XTEST(rinoo_socket_writeb(client, &buffer) == TRANSFER_SIZE);
rinoo_socket_destroy(client);
}
void process_client(void *socket)
{
t_buffer *buffer;
buffer = buffer_create(NULL);
XTEST(buffer != NULL);
while (rinoo_socket_readb(socket, buffer) > 0) {
rinoo_log("receiving...");
}
XTEST(buffer_size(buffer) == TRANSFER_SIZE);
XTEST(buffer_strncmp(buffer, str, TRANSFER_SIZE) == 0);
buffer_destroy(buffer);
free(str);
rinoo_socket_destroy(socket);
}
void http_server(void *sched)
{
t_ip ip;
uint16_t port;
t_socket *server;
t_socket *client;
server = rinoo_tcp_server(sched, IP_ANY, 4242);
XTEST(server != NULL);
client = rinoo_tcp_accept(server, &ip, &port);
XTEST(client != NULL);
rinoo_log("server - accepting client (%s:%d)", inet_ntoa(*(struct in_addr *) &ip), port);
rinoo_task_start(sched, http_server_process, client);
rinoo_socket_destroy(server);
}
/**
* Main function for this unit test
*
*
* @return 0 if test passed
*/
int main()
{
uint32_t i;
t_buffer *buffer1;
buffer1 = buffer_create(NULL);
XTEST(buffer1 != NULL);
for (i = 0; i < ARRAY_SIZE(strings) - 1; i++) {
buffer_add(buffer1, strings[i], strlen(strings[i]));
XTEST(buffer_strcasecmp(buffer1, strings[i + 1]) < 0);
buffer_erase(buffer1, buffer_size(buffer1));
}
buffer_destroy(buffer1);
XPASS();
}
/**
* Main function for this unit test.
*
* @return 0 if test passed
*/
int main()
{
t_rinoosched *sched;
big_buffer = malloc(sizeof(*big_buffer) * BUFFER_SIZE);
XTEST(big_buffer != NULL);
memset(big_buffer, 'x', sizeof(*big_buffer) * BUFFER_SIZE);
sched = rinoo_sched();
XTEST(sched != NULL);
XTEST(rinoo_task_start(sched, server_func, sched) == 0);
XTEST(rinoo_task_start(sched, client_func, sched) == 0);
rinoo_sched_loop(sched);
rinoo_sched_destroy(sched);
free(big_buffer);
XPASS();
}
void dns_test(void *arg)
{
t_ip ip;
XTEST(rinoo_dns_ip_get(arg, "google.com", &ip) == 0);
rinoo_log("IP: %s", inet_ntoa(ip.v4.sin_addr));
}
/////////////////////////////////////////////////////////////////
// HRESULT CDataSource::AdminCreateDataSource
//
/////////////////////////////////////////////////////////////////
HRESULT CDataSource::AdminCreateDataSource(CAggregate* pCAggregate, ULONG cPropSets, DBPROPSET* rgPropSets, REFIID riid, IUnknown** ppIUnknown)
{
HRESULT hr = S_OK;
DWORD dwCreateOpts = GetOptions()->m_dwCreateOpts;
if(m_pIDBDataSourceAdmin)
{
//IDBDataSourceAdmin::CreateDataSource
XTEST(hr = m_pIDBDataSourceAdmin->CreateDataSource(cPropSets, rgPropSets, pCAggregate, riid, ppIUnknown));
TRACE_METHOD(hr, L"IDBDataSourceAdmin::CreateDataSource(%d, 0x%p, 0x%p, %s, &0x%p)", cPropSets, rgPropSets, pCAggregate, GetInterfaceName(riid), ppIUnknown ? *ppIUnknown : NULL);
//Display any property errors...
TESTC(hr = DisplayPropErrors(hr, cPropSets, rgPropSets));
//Handle Aggregation
if(pCAggregate)
pCAggregate->HandleAggregation(riid, ppIUnknown);
//We are now Initialized
m_fInitialized = TRUE;
//Obtain all interfaces, now that we are initialized
TESTC(hr = AutoQI(dwCreateOpts));
}
CLEANUP:
return hr;
}
/////////////////////////////////////////////////////////////////
// HRESULT CDataset::GetCellData
//
/////////////////////////////////////////////////////////////////
HRESULT CDataset::GetCellData(DBORDINAL ulStartCell, DBORDINAL ulEndCell)
{
HRESULT hr = E_FAIL;
if(m_pIMDDataset)
{
//NOTE: Using cbRowSize of IAccessor::CreateAccessor
//Because this method fetches properties for more than one cell,
//the provider should know how long each row is. In this context, a "row" means the area
//allocated in the consumer's buffer to hold all properties pertaining to one cell.
//This information should be given in the cbRowSize parameter of IAccessor::CreateAccessor.
//If the value of this parameter is zero, the consumer wants to fetch only one row of data
//(one cell). In this case, it is an error to specify a ulStartCell different from the
//ulEndCell.
//Because of the above in the OLAP spec, we need to make sure our buffer is large enough
//to hold the number of requested cells...
if(ulEndCell > ulStartCell && m_cbRowSize)
SAFE_REALLOC(m_pData, BYTE, m_cbRowSize * (ulEndCell - ulStartCell + 1));
//IMDDataset::GetCellData
XTEST(hr = m_pIMDDataset->GetCellData(m_hAccessor, ulStartCell, ulEndCell, m_pData));
TESTC(TRACE_METHOD(hr, L"IMDDataset::GetCellData(0x%p, 0x%Id, 0x%Id, 0x%p)", m_hAccessor, ulStartCell, ulEndCell, m_pData));
}
CLEANUP:
return hr;
}
void task(void *unused(arg))
{
printf("%s start\n", __FUNCTION__);
XTEST(checker == 0);
checker = 1;
printf("%s end\n", __FUNCTION__);
}
void task_func(void *sched)
{
struct timeval prev;
printf("%s start\n", __FUNCTION__);
XTEST(gettimeofday(&prev, NULL) == 0);
rinoo_task_wait(sched, 100);
XTEST(check_time(&prev, 100) == 0);
rinoo_task_wait(sched, 200);
XTEST(check_time(&prev, 200) == 0);
rinoo_task_wait(sched, 500);
XTEST(check_time(&prev, 500) == 0);
rinoo_task_wait(sched, 1000);
XTEST(check_time(&prev, 1000) == 0);
printf("%s end\n", __FUNCTION__);
}
void process_client(void *arg)
{
int i;
char b;
t_buffer *buffers[4];
t_buffer buffer[4];
t_rinoosocket *socket = arg;
buffer_static(&buffer[0], big_buffer, BUFFER_SIZE);
buffers[0] = &buffer[0];
rinoo_log("server - client accepted");
rinoo_log("server - sending %d bytes", BUFFER_SIZE);
XTEST(rinoo_socket_writev(socket, buffers, 1) == BUFFER_SIZE);
rinoo_log("server - receiving 'b'");
XTEST(rinoo_socket_read(socket, &b, 1) == 1);
XTEST(b == 'b');
for (i = 0; i < 4; i++) {
buffer_static(&buffer[i], big_buffer + (i * (BUFFER_SIZE / 4)), BUFFER_SIZE / 4);
buffers[i] = &buffer[i];
}
rinoo_log("server - sending %d bytes", BUFFER_SIZE);
XTEST(rinoo_socket_writev(socket, buffers, 4) == BUFFER_SIZE);
rinoo_log("server - receiving 'b'");
XTEST(rinoo_socket_read(socket, &b, 1) == 1);
XTEST(b == 'b');
rinoo_log("server - receiving nothing");
XTEST(rinoo_socket_read(socket, &b, 1) == -1);
rinoo_socket_destroy(socket);
}
/**
* Main function for this unit test.
*
* @return 0 if test passed
*/
int main()
{
t_rinoossl_ctx *ssl;
ssl = rinoo_ssl_context();
XTEST(ssl != NULL);
rinoo_ssl_context_destroy(ssl);
XPASS();
}
void *server_thread(void *unused(arg))
{
char b;
t_rinoosched *sched;
t_rinoosocket *server;
t_rinoosocket *client;
struct sockaddr_in addr;
sched = rinoo_sched();
XTEST(sched != NULL);
server = rinoo_socket(sched, &socket_class_tcp);
XTEST(server != NULL);
addr.sin_port = htons(4242);
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = 0;
XTEST(rinoo_socket_bind(server, (struct sockaddr *) &addr, sizeof(addr), 42) == 0);
rinoo_log("server listening...");
client = rinoo_socket_accept(server, (struct sockaddr *) &addr, (socklen_t *)(int[]){(sizeof(struct sockaddr))});
void process_client(void *arg)
{
char a;
t_rinoosocket *socket = arg;
rinoo_log("server - client accepted");
rinoo_log("server - receiving nothing, waiting timeout");
XTEST(rinoo_socket_read(socket, &a, 1) <= 0);
rinoo_socket_destroy(socket);
}
void server_func(void *arg)
{
t_rinoosocket *server;
t_rinoosocket *client;
struct sockaddr_in6 addr = { 0 };
t_rinoosched *sched = arg;
server = rinoo_socket(sched, &socket_class_tcp6);
XTEST(server != NULL);
addr.sin6_port = htons(4242);
addr.sin6_family = AF_INET6;
addr.sin6_addr = in6addr_any;
XTEST(rinoo_socket_bind(server, (struct sockaddr *) &addr, sizeof(addr), 42) == 0);
rinoo_log("server listening...");
client = rinoo_socket_accept(server, NULL, NULL);
XTEST(client != NULL);
rinoo_task_start(sched, process_client, client);
rinoo_socket_destroy(server);
}
void client_func(void *arg)
{
char a;
struct sockaddr_in6 addr = { 0 };
t_rinoosocket *socket;
t_rinoosched *sched = arg;
socket = rinoo_socket(sched, &socket_class_tcp6);
XTEST(socket != NULL);
addr.sin6_port = htons(4242);
addr.sin6_family = AF_INET6;
addr.sin6_addr = in6addr_loopback;
XTEST(rinoo_socket_connect(socket, (struct sockaddr *) &addr, sizeof(addr)) == 0);
rinoo_log("client - connected");
rinoo_socket_timeout(socket, 1000);
XTEST(rinoo_socket_read(socket, &a, 1) == -1);
rinoo_log("server - timeout");
perror("socket");
rinoo_socket_destroy(socket);
}
void check_file(void *sched)
{
int i;
t_inotify *inotify;
t_inotify_event *event;
inotify = rinoo_inotify(sched);
rinoo_inotify_add_watch(inotify, "/tmp", INOTIFY_CREATE | INOTIFY_DELETE, true);
for (i = 0; i < NB_EVENT && (event = rinoo_inotify_event(inotify)) != NULL; i++) {
if (event->type & INOTIFY_CREATE) {
rinoo_log("File created.");
nb_create_event++;
} else if (event->type & INOTIFY_DELETE) {
rinoo_log("File deleted.");
nb_rm_event++;
}
}
XTEST(nb_create_event == nb_create);
XTEST(nb_rm_event == nb_rm);
rinoo_inotify_destroy(inotify);
}
