MU_TEST(marshal, basic_verify_null_failure)
{
static const unsigned char bytes[] =
{
/* -42 */
0xFF, 0xD6,
/* 2 */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
};
LWMsgTypeSpec* type = basic_spec;
LWMsgBuffer buffer = {0};
basic_struct *out;
buffer.base = buffer.cursor = (void*) bytes;
buffer.end = buffer.base + sizeof(bytes);
MU_ASSERT_EQUAL(
MU_TYPE_INTEGER,
lwmsg_data_unmarshal(dcontext, type, &buffer, (void**) (void*) &out),
LWMSG_STATUS_EOF);
}
/*
Testing the various runnables introduced with QtDispatch
*/
extern "C" void Qt_runnable_lambda(){
MU_BEGIN_TEST(Qt_runnable_lambda);
TestRunnable test_run;
for(int i = 0; i < 5; i++)
test_run.run(i);
MU_ASSERT_EQUAL(counter, 1+2+3+4);
counter = 0;
iter_block_run = QDispatchMakeIterationRunnable([=](size_t index){
counter += index;
});
block_run = QDispatchMakeRunnable([=]{
counter += 5;
});
exec_runnables();
MU_END_TEST;
}
MU_TEST(Atomic, InterlockedCompareExchange)
{
pthread_t threads[EXCHANGE_THREADS];
EXCHANGE_INFO info[EXCHANGE_THREADS];
int i;
LONG volatile lValue = 0;
for (i = 0; i < EXCHANGE_THREADS; i++)
{
info[i].plValue = &lValue;
info[i].lOldValue = i;
info[i].lNewValue = i+1;
pthread_create(&threads[i], NULL, AtomicExchangeThread, &info[i]);
}
BarrierOpen();
for (i = 0; i < EXCHANGE_THREADS; i++)
{
pthread_join(threads[i], NULL);
}
MU_ASSERT_EQUAL(MU_TYPE_INTEGER, InterlockedRead(&lValue), EXCHANGE_THREADS);
}
MU_TEST(mon_strstr, mon_strstr_str_vide) {
const char *str = "" ;
const char *result ;
result = mon_strstr(str, "CDEZ") ;
MU_ASSERT_EQUAL(result, NULL) ;
}
MU_TEST(mon_strstr, mon_strstr_str_not_found) {
const char *str = "0123456789" ;
const char *result ;
result = mon_strstr(str, "346") ;
MU_ASSERT_EQUAL(result, NULL) ;
}
MU_TEST(mon_strlen, strlen_multi0) {
char str[] = {'A','A','A','A','A','A','\0','A','A','\0'} ;
MU_ASSERT_EQUAL(mon_strlen(str), 6) ;
}
void group_notify(void* data){
dispatch_queue_t m = dispatch_get_main_queue();
dispatch_queue_t c = dispatch_get_current_queue();
MU_ASSERT_EQUAL(m, c);
MU_PASS("Great!");
}
MU_TEST(mon_strncmp, monstrncmp_n_restrict) {
MU_ASSERT_EQUAL(mon_strncmp("ABCDEF","ABCTYU", 3), 0) ;
}
MU_TEST(mon_strncmp, mon_strncmp_a_equals_b_vide) {
MU_ASSERT_EQUAL(mon_strncmp("","", 0), 0) ;
}
MU_TEST(mon_strlen, strlen_non_ascii) {
MU_ASSERT_EQUAL(mon_strlen("12345ééé"), 8) ;
}
MU_TEST(mon_strchr, mon_strchr_c_found) {
const char *str = "ABCDEF" ;
const char *result ;
result = mon_strchr(str, 'D') ;
MU_ASSERT_EQUAL(result, str+3) ;
}
MU_TEST(mon_strlen, strlen5) {
MU_ASSERT_EQUAL(mon_strlen("12345"), 5) ;
}
MU_TEST(mon_strcat, mon_strcat_a_b_vide) {
char *result ;
strcpy(dest, "PREM") ;
result = mon_strcat(dest, "") ;
MU_ASSERT_EQUAL(strcmp(result,"PREM"), 0) ;
}
MU_TEST(mon_strcat, mon_strcat_a_vide_et_b) {
char *result ;
strcpy(dest, "") ;
result = mon_strcat(dest, "IJKLM") ;
MU_ASSERT_EQUAL(strcmp(result,"IJKLM"), 0) ;
}
MU_TEST(mon_strstr, mon_strstr_needle_vide) {
const char *str = "0123456789" ;
const char *result ;
result = mon_strstr(str, "") ;
MU_ASSERT_EQUAL(result, str) ;
}
MU_TEST(mon_strstr, mon_strstr_found_ends) {
const char *str = "0123456789" ;
const char *result ;
result = mon_strstr(str, "789") ;
MU_ASSERT_EQUAL(result, str+7) ;
}
MU_TEST(mon_strchr, mon_strchr_c_not_found) {
const char *str = "ABCDEF" ;
const char *result ;
result = mon_strchr(str, 'G') ;
MU_ASSERT_EQUAL(result, NULL) ;
}
MU_TEST(mon_strcmp, mon_strcmp_a_equals_b_non_vide) {
MU_ASSERT_EQUAL(mon_strcmp("UIO","UIO"), 0) ;
}
MU_TEST(mon_strchr, mon_strchr_c_first_found) {
const char *str = "ABCDECFG" ;
const char *result ;
result = mon_strchr(str, 'C') ;
MU_ASSERT_EQUAL(result, str+2) ;
}
MU_TEST(mon_strncmp, mon_strncmp_a_equals_b_n_too_large) {
MU_ASSERT_EQUAL(mon_strncmp("","", 6), 0) ;
}
MU_TEST(mon_strlen, strlen0) {
MU_ASSERT_EQUAL(mon_strlen(""), 0) ;
}
MU_TEST(mon_strchr, mon_strchr_empty_string) {
const char *str = "" ;
const char *result ;
result = mon_strchr(str, 'C') ;
MU_ASSERT_EQUAL(result, NULL) ;
}
MU_TEST(stress, parallel)
{
Data data;
pthread_t threads[NUM_THREADS];
int i;
LWMsgContext* context = NULL;
LWMsgProtocol* protocol = NULL;
LWMsgPeer* client = NULL;
LWMsgPeer* server = NULL;
CounterRequest request;
CounterReply* reply;
LWMsgCall* call;
LWMsgParams in = LWMSG_PARAMS_INITIALIZER;
LWMsgParams out = LWMSG_PARAMS_INITIALIZER;
LWMsgTime timeout = {1, 0};
MU_TRY(lwmsg_context_new(NULL, &context));
lwmsg_context_set_log_function(context, lwmsg_test_log_function, NULL);
MU_TRY(lwmsg_protocol_new(context, &protocol));
MU_TRY(lwmsg_protocol_add_protocol_spec(protocol, counterprotocol_spec));
MU_TRY(lwmsg_peer_new(context, protocol, &server));
MU_TRY(lwmsg_peer_add_dispatch_spec(server, counter_dispatch));
MU_TRY(lwmsg_peer_add_listen_endpoint(server, LWMSG_CONNECTION_MODE_LOCAL, TEST_ENDPOINT, 0600));
MU_TRY(lwmsg_peer_set_max_listen_clients(server, MAX_CLIENTS));
MU_TRY(lwmsg_peer_set_timeout(server, LWMSG_TIMEOUT_IDLE, &timeout));
MU_TRY(lwmsg_peer_start_listen(server));
MU_TRY(lwmsg_peer_new(context, protocol, &client));
MU_TRY(lwmsg_peer_add_connect_endpoint(client, LWMSG_CONNECTION_MODE_LOCAL, TEST_ENDPOINT));
request.counter = 0;
MU_TRY(lwmsg_peer_acquire_call(client, &call));
in.tag = COUNTER_OPEN;
in.data = &request;
MU_TRY(lwmsg_call_dispatch(call, &in, &out, NULL, NULL));
MU_ASSERT_EQUAL(MU_TYPE_INTEGER, out.tag, COUNTER_OPEN_SUCCESS);
lwmsg_call_release(call);
data.client = client;
data.handle = out.data;
data.iters = NUM_ITERS;
data.go = 0;
pthread_mutex_init(&data.lock, NULL);
pthread_cond_init(&data.event, NULL);
pthread_mutex_lock(&data.lock);
for (i = 0; i < NUM_THREADS; i++)
{
pthread_create(&threads[i], NULL, add_thread, &data);
}
data.go = 1;
pthread_cond_broadcast(&data.event);
pthread_mutex_unlock(&data.lock);
for (i = 0; i < NUM_THREADS; i++)
{
pthread_join(threads[i], NULL);
}
MU_TRY(lwmsg_peer_acquire_call(client, &call));
in.tag = COUNTER_READ;
in.data = data.handle;
MU_TRY(lwmsg_call_dispatch(call, &in, &out, NULL, NULL));
MU_ASSERT_EQUAL(MU_TYPE_INTEGER, out.tag, COUNTER_READ_SUCCESS);
reply = out.data;
MU_ASSERT_EQUAL(MU_TYPE_INTEGER, reply->counter, NUM_THREADS * NUM_ITERS);
lwmsg_call_destroy_params(call, &out);
lwmsg_call_release(call);
MU_TRY(lwmsg_peer_acquire_call(client, &call));
in.tag = COUNTER_CLOSE;
in.data = data.handle;
MU_TRY(lwmsg_call_dispatch(call, &in, &out, NULL, NULL));
MU_ASSERT_EQUAL(MU_TYPE_INTEGER, out.tag, COUNTER_CLOSE_SUCCESS);
lwmsg_call_destroy_params(call, &out);
lwmsg_call_release(call);
MU_TRY(lwmsg_peer_disconnect(client));
lwmsg_peer_delete(client);
MU_TRY(lwmsg_peer_stop_listen(server));
lwmsg_peer_delete(server);
pthread_mutex_destroy(&data.lock);
pthread_cond_destroy(&data.event);
}
