/*
* Tests
*/
static void
test_packet_output_gre(void)
{
odp_packet_t pkt = ODP_PACKET_INVALID;
odp_event_t ev;
int res;
struct ofp_ether_header *eth;
struct ofp_ip *ip;
struct ofp_ip *ip_orig;
struct ofp_greip *greip;
if (create_odp_packet_ip4(&pkt, test_frame, sizeof(test_frame),
tun_p2p)) {
CU_FAIL("Fail to create packet");
return;
}
/*
* Packet's destination is GRE tunnel's p2p address, next hop is GRE
* interface. GRE+IP header is prepended. Packet's new destination is
* link local. Packet is put into output queue.
*/
res = ofp_ip_send(pkt, NULL);
CU_ASSERT_EQUAL(res, OFP_PKT_PROCESSED);
res = ofp_send_pending_pkt();
CU_ASSERT_EQUAL(res, OFP_PKT_PROCESSED);
ev = odp_queue_deq(dev->outq_def);
CU_ASSERT_NOT_EQUAL_FATAL(ev, ODP_EVENT_INVALID);
pkt = odp_packet_from_event(ev);
CU_ASSERT_EQUAL_FATAL(odp_packet_len(pkt),
sizeof(test_frame) + 20 + 4);
eth = odp_packet_l2_ptr(pkt, NULL);
if (memcmp(eth->ether_dhost, tun_rem_mac, OFP_ETHER_ADDR_LEN))
CU_FAIL("Bad destination mac address.");
if (memcmp(eth->ether_shost, dev->mac, OFP_ETHER_ADDR_LEN))
CU_FAIL("Bad source mac address.");
ip = odp_packet_l3_ptr(pkt, NULL);
CU_ASSERT_EQUAL(ip->ip_src.s_addr, dev_ip);
CU_ASSERT_EQUAL(ip->ip_dst.s_addr, tun_rem_ip);
CU_ASSERT_EQUAL(ip->ip_p, OFP_IPPROTO_GRE);
greip = (struct ofp_greip *)ip;
CU_ASSERT_EQUAL(greip->gi_g.flags, 0);
CU_ASSERT_EQUAL(greip->gi_g.ptype,
odp_cpu_to_be_16(OFP_ETHERTYPE_IP));
/* inner ip */
ip = (struct ofp_ip *)(greip + 1);
ip_orig = (struct ofp_ip *)(&orig_pkt_data[OFP_ETHER_HDR_LEN]);
if (memcmp(ip, ip_orig, odp_be_to_cpu_16(ip_orig->ip_len)))
CU_FAIL("Inner IP packet error.");
}
/* Test MB_Iterator_CreateFiltered */
void test_mb_p_iter_create_filtered(void) {
int rc;
MBIt_Board *board;
MBIt_Iterator *iterator;
filter_params fp;
fp.lb = TEST_FILTER_LB;
fp.ub = TEST_FILTER_UB;
/* Try invalid mboard */
mb_f = 99999999;
rc = MB_Iterator_CreateFiltered(mb_f, &itr_f, &my_filter, &fp);
CU_ASSERT_EQUAL(rc, MB_ERR_INVALID);
CU_ASSERT_EQUAL(itr_f, MB_NULL_ITERATOR);
/* Try NULL mboard */
mb_f = MB_NULL_MBOARD;
rc = MB_Iterator_CreateFiltered(mb_f, &itr_f, &my_filter, &fp);
CU_ASSERT_EQUAL(rc, MB_ERR_INVALID);
CU_ASSERT_EQUAL(itr_f, MB_NULL_ITERATOR);
/* Populate mboard. Abort on failure */
rc = init_mb_with_content(&mb_f);
CU_ASSERT_EQUAL_FATAL(rc, MB_SUCCESS);
/* Try locked board */
board = (MBIt_Board *)MBI_getMBoardRef(mb_f);
CU_ASSERT_PTR_NOT_NULL_FATAL(board);
board->locked = MB_TRUE;
rc = MB_Iterator_CreateFiltered(mb_f, &itr_f, &my_filter, &fp);
CU_ASSERT_EQUAL(rc, MB_ERR_LOCKED);
CU_ASSERT_EQUAL(itr_f, MB_NULL_ITERATOR);
board->locked = MB_FALSE;
/* Try on "unreadable" boards */
board->is_reader = MB_FALSE;
rc = MB_Iterator_Create(mb_f, &itr_f);
CU_ASSERT_EQUAL(rc, MB_ERR_DISABLED);
CU_ASSERT_EQUAL(itr_f, MB_NULL_ITERATOR);
board->is_reader = MB_TRUE;
/* Create sorted Iterator */
itr_f = MB_NULL_ITERATOR;
rc = MB_Iterator_CreateFiltered(mb_f, &itr_f, &my_filter, &fp);
CU_ASSERT_EQUAL(rc, MB_SUCCESS);
CU_ASSERT_NOT_EQUAL(itr_f, MB_NULL_ITERATOR);
board = (MBIt_Board *)MBI_getMBoardRef(mb_f);
iterator = (MBIt_Iterator *)MBI_getIteratorRef(itr_f);
CU_ASSERT_PTR_NOT_NULL_FATAL(board);
CU_ASSERT_PTR_NOT_NULL_FATAL(iterator);
CU_ASSERT_EQUAL(board->data->elem_size, iterator->msgsize);
CU_ASSERT_EQUAL(iterator->iterating, 0);
CU_ASSERT_PTR_NULL(iterator->cursor);
CU_ASSERT_EQUAL(iterator->mb, mb_f);
}
static void capability_test(const struct capability_answer *ca)
{
qpol_policy_t *q = NULL;
int policy_type = qpol_policy_open_from_file(ca->policy_name, &q, NULL, NULL, QPOL_POLICY_OPTION_NO_NEVERALLOWS);
CU_ASSERT_FATAL(policy_type >= 0);
CU_ASSERT_EQUAL(policy_type, ca->policy_type);
unsigned policy_version;
int retval;
retval = qpol_policy_get_policy_version(q, &policy_version);
CU_ASSERT_EQUAL_FATAL(retval, 0);
CU_ASSERT_EQUAL(policy_version, ca->policy_version);
bool cap;
cap = (bool) qpol_policy_has_capability(q, QPOL_CAP_ATTRIB_NAMES);
CU_ASSERT_EQUAL(cap, ca->has_attributes);
cap = (bool) qpol_policy_has_capability(q, QPOL_CAP_SYN_RULES);
CU_ASSERT_EQUAL(cap, ca->has_syn_rules);
cap = (bool) qpol_policy_has_capability(q, QPOL_CAP_LINE_NUMBERS);
CU_ASSERT_EQUAL(cap, ca->has_line_numbers);
cap = (bool) qpol_policy_has_capability(q, QPOL_CAP_CONDITIONALS);
CU_ASSERT_EQUAL(cap, ca->has_conditionals);
cap = (bool) qpol_policy_has_capability(q, QPOL_CAP_MLS);
CU_ASSERT_EQUAL(cap, ca->has_mls);
cap = (bool) qpol_policy_has_capability(q, QPOL_CAP_POLCAPS);
CU_ASSERT_EQUAL(cap, ca->has_polcaps);
cap = (bool) qpol_policy_has_capability(q, QPOL_CAP_SOURCE);
CU_ASSERT_EQUAL(cap, ca->has_source);
cap = (bool) qpol_policy_has_capability(q, QPOL_CAP_MODULES);
CU_ASSERT_EQUAL(cap, ca->has_modules);
unsigned char ispermissive;
const qpol_type_t *type;
if (ca->enforcing_type != NULL) {
retval = qpol_policy_get_type_by_name(q, ca->enforcing_type, &type);
CU_ASSERT(retval == 0 && type != NULL);
retval = qpol_type_get_ispermissive(q, type, &ispermissive);
CU_ASSERT(retval == 0 && ispermissive == 0);
}
if (ca->permissive_type != NULL) {
retval = qpol_policy_get_type_by_name(q, ca->permissive_type, &type);
CU_ASSERT(retval == 0 && type != NULL);
retval = qpol_type_get_ispermissive(q, type, &ispermissive);
CU_ASSERT(retval == 0 && ispermissive == 1);
}
qpol_policy_destroy(&q);
}
void test_topic_init_and_destroy() {
int ret;
struct topic t;
struct subscriber sub;
ret = topic_init(&t);
CU_ASSERT_EQUAL_FATAL(0, ret);
// would fail if list of subscribers
// was not correctly initialized
ret = list_add(t.subscribers, &sub);
CU_ASSERT_EQUAL_FATAL(0, ret);
ret = topic_destroy(&t);
CU_ASSERT_PTR_NULL_FATAL(t.name);
CU_ASSERT_PTR_NULL_FATAL(t.subscribers);
}
void test_can_read_ihex_rs_from_file_1(void)
{
ihex_recordset_t* r = ihex_rs_from_file("res/hex1.dat");
CU_ASSERT_PTR_NOT_NULL_FATAL(r);
CU_ASSERT_EQUAL_FATAL(r->ihrs_count, 6);
IHEX_ASSERT_REC_EQUAL(&(r->ihrs_records[1]), 0x10, 0x0100, IHEX_DATA, 0x21);
}
static void
test_add_get(void)
{
FmtpProdIndex fileA = 1;
FmtpProdIndex fileB;
int status;
status = piq_add(rq, fileA);
log_flush_error();
CU_ASSERT_EQUAL_FATAL(status, 0);
CU_ASSERT_EQUAL(piq_count(rq), 1);
status = piq_removeNoWait(rq, &fileB);
log_flush_error();
CU_ASSERT_EQUAL_FATAL(status, 0);
CU_ASSERT_EQUAL_FATAL(fileB, fileA);
CU_ASSERT_EQUAL(piq_count(rq), 0);
}
void test_can_read_ihex_rs_from_file_2(void)
{
ihex_recordset_t* r = ihex_rs_from_file("res/big-a.hex");
CU_ASSERT_PTR_NOT_NULL_FATAL(r);
CU_ASSERT_EQUAL_FATAL(r->ihrs_count, 214);
IHEX_ASSERT_REC_EQUAL(&(r->ihrs_records[2]), 0x10, 0x0400, IHEX_DATA, 0x0B);
}
static void
test_add_get(void)
{
VcmtpProdIndex fileA = 1;
VcmtpProdIndex fileB;
int status;
status = piq_add(rq, fileA);
log_log(LOG_ERR);
CU_ASSERT_EQUAL_FATAL(status, 0);
CU_ASSERT_EQUAL(piq_count(rq), 1);
status = piq_removeNoWait(rq, &fileB);
log_log(LOG_ERR);
CU_ASSERT_EQUAL_FATAL(status, 0);
CU_ASSERT_EQUAL_FATAL(fileB, fileA);
CU_ASSERT_EQUAL(piq_count(rq), 0);
}
static void history_messages_count() {
LinphoneCoreManager *marie = linphone_core_manager_new("marie_rc");
LinphoneAddress *jehan_addr = linphone_address_new("<sip:[email protected]>");
LinphoneChatRoom *chatroom;
MSList *messages;
char src_db[256];
char tmp_db[256];
snprintf(src_db,sizeof(src_db), "%s/messages.db", liblinphone_tester_file_prefix);
snprintf(tmp_db,sizeof(tmp_db), "%s/tmp.db", liblinphone_tester_writable_dir_prefix);
CU_ASSERT_EQUAL_FATAL(message_tester_copy_file(src_db, tmp_db), 0);
linphone_core_set_chat_database_path(marie->lc, tmp_db);
chatroom = linphone_core_get_chat_room(marie->lc, jehan_addr);
CU_ASSERT_PTR_NOT_NULL(chatroom);
if (chatroom){
messages=linphone_chat_room_get_history(chatroom,10);
CU_ASSERT_EQUAL(ms_list_size(messages), 10);
ms_list_free_with_data(messages, (void (*)(void*))linphone_chat_message_unref);
messages=linphone_chat_room_get_history(chatroom,1);
CU_ASSERT_EQUAL(ms_list_size(messages), 1);
ms_list_free_with_data(messages, (void (*)(void*))linphone_chat_message_unref);
messages=linphone_chat_room_get_history(chatroom,0);
CU_ASSERT_EQUAL(linphone_chat_room_get_history_size(chatroom), 1270);
CU_ASSERT_EQUAL(ms_list_size(messages), 1270);
/*check the second most recent message*/
CU_ASSERT_STRING_EQUAL(linphone_chat_message_get_text((LinphoneChatMessage *)messages->next->data), "Fore and aft follow each other.");
ms_list_free_with_data(messages, (void (*)(void*))linphone_chat_message_unref);
/*test offset+limit: retrieve the 42th latest message only and check its content*/
messages=linphone_chat_room_get_history_range(chatroom, 42, 42);
CU_ASSERT_EQUAL(ms_list_size(messages), 1);
CU_ASSERT_STRING_EQUAL(linphone_chat_message_get_text((LinphoneChatMessage *)messages->data), "If you open yourself to the Tao is intangible and evasive, yet prefers to keep us at the mercy of the kingdom, then all of the streams of hundreds of valleys because of its limitless possibilities.");
ms_list_free_with_data(messages, (void (*)(void*))linphone_chat_message_unref);
/*test offset without limit*/
messages = linphone_chat_room_get_history_range(chatroom, 1265, -1);
CU_ASSERT_EQUAL(ms_list_size(messages), 1270-1265);
ms_list_free_with_data(messages, (void (*)(void*))linphone_chat_message_unref);
/*test limit without offset*/
messages = linphone_chat_room_get_history_range(chatroom, 0, 5);
CU_ASSERT_EQUAL(ms_list_size(messages), 6);
ms_list_free_with_data(messages, (void (*)(void*))linphone_chat_message_unref);
/*test invalid start*/
messages = linphone_chat_room_get_history_range(chatroom, 1265, 1260);
CU_ASSERT_EQUAL(ms_list_size(messages), 1270-1265);
ms_list_free_with_data(messages, (void (*)(void*))linphone_chat_message_unref);
}
linphone_core_manager_destroy(marie);
linphone_address_destroy(jehan_addr);
remove(tmp_db);
}
void test_add_message_5() {
int ret;
struct list topics;
struct list messages;
list_init(&topics);
list_init(&messages);
// inexistent topic
ret = topic_add_message(&topics, &messages, "foo", "price: 33");
CU_ASSERT_EQUAL_FATAL(TOPIC_NOT_FOUND, ret);
}
static void test_exe_shutdown(void)
{
Executor* exe = exe_new();
Job* job;
int status = exe_submit(exe, waitForStop, NULL, stop, &job);
CU_ASSERT_EQUAL_FATAL(status, 0);
sleep(1);
status = exe_shutdown(exe);
CU_ASSERT_EQUAL(status, 0);
CU_ASSERT_EQUAL(exe_count(exe), 1);
Job* completedJob = exe_getCompleted(exe);
CU_ASSERT_EQUAL_FATAL(status, 0);
CU_ASSERT_EQUAL(exe_count(exe), 0);
CU_ASSERT_PTR_EQUAL(completedJob, job);
CU_ASSERT_TRUE(job_wasStopped(job));
job_free(job);
CU_ASSERT_EQUAL(status, 0);
status = exe_free(exe);
CU_ASSERT_EQUAL(status, 0);
}
static void test_exe_submit(void)
{
int sleep1Result;
Executor* exe = exe_new();
Job* job;
int status = exe_submit(exe, sleep1, &sleep1Result, NULL, &job);
CU_ASSERT_EQUAL_FATAL(status, 0);
CU_ASSERT_EQUAL(exe_count(exe), 1);
Job* completedJob = exe_getCompleted(exe);
CU_ASSERT_EQUAL_FATAL(status, 0);
CU_ASSERT_EQUAL(exe_count(exe), 0);
CU_ASSERT_PTR_EQUAL(completedJob, job);
CU_ASSERT_FALSE(job_wasStopped(job));
CU_ASSERT_EQUAL(job_status(job), 0);
CU_ASSERT_PTR_EQUAL(job_result(job), &sleep1Result);
job_free(job);
CU_ASSERT_EQUAL(status, 0);
status = exe_free(exe);
CU_ASSERT_EQUAL(status, 0);
}
void test_add_message_1() {
topic_before_test();
int ret;
struct list topics;
struct list messages;
struct message *msg;
struct list *stats;
struct msg_statistics *msgstats;
struct subscriber sub1 = {&c1, "hans"};
list_init(&topics);
list_init(&messages);
topic_add_subscriber(&topics, "stocks", &sub1);
// single message
ret = topic_add_message(&topics, &messages, "stocks", "price: 33");
CU_ASSERT_EQUAL_FATAL(0, ret);
CU_ASSERT_EQUAL_FATAL(1, list_len(&messages));
msg = message_find_by_content(&messages, "price: 33");
CU_ASSERT_PTR_NOT_NULL_FATAL(msg);
CU_ASSERT_STRING_EQUAL_FATAL("stocks", msg->topicname);
stats = msg->stats;
CU_ASSERT_EQUAL_FATAL(1, list_len(stats));
msgstats = stats->root->entry;
CU_ASSERT_EQUAL_FATAL(0, msgstats->last_fail);
CU_ASSERT_EQUAL_FATAL(0, msgstats->nattempts);
CU_ASSERT_EQUAL_FATAL(&sub1, msgstats->subscriber);
topic_after_test();
}
void test_queue_in()
{
p1 = (Person*)malloc(sizeof(Person));
char *name1 = (char*)malloc(16);
strcpy(name1, "tom");
p1->name = name1;
p1->age = 22;
p2 = (Person*)malloc(sizeof(Person));
char *name2 = (char*)malloc(16);
strcpy(name2, "jack");
p2->name = name2;
p2->age = 23;
p3 = (Person*)malloc(sizeof(Person));
char *name3 = (char*)malloc(16);
strcpy(name3, "jim");
p3->name = name3;
p3->age = 24;
p4 = (Person*)malloc(sizeof(Person));
char *name4 = (char*)malloc(16);
strcpy(name4, "fitz");
p4->name = name4;
p4->age = 25;
CU_ASSERT_EQUAL_FATAL(queue_in(&queue, p1), 0);
CU_ASSERT_EQUAL_FATAL(queue_in(&queue, p2), 0);
CU_ASSERT_EQUAL_FATAL(queue_in(&queue, p3), 0);
CU_ASSERT_EQUAL_FATAL(queue_in(&queue, p4), 0);
CU_ASSERT_EQUAL_FATAL(queue.queue_size, 4);
CU_ASSERT_EQUAL_FATAL(queue.node_count, 4);
}
void __testListen_Accept_After_Connect()
{
__init_pcap_record(CU_get_current_test()->pName);
int err = 0;
int ret = 0;
my_context server_socket = __target->open(__target, &err);
CU_ASSERT_EQUAL_FATAL(err, 0);
CU_ASSERT_PTR_NOT_NULL_FATAL(server_socket);
struct sockaddr_in addr;
socklen_t len = sizeof(addr);
memset(&addr, 0, len);
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = htonl(INADDR_ANY);
addr.sin_port = htons(10000);
ret = __target->bind(__target, server_socket, (struct sockaddr*)&addr, len, &err);
CU_ASSERT_EQUAL_FATAL(err, 0);
CU_ASSERT_TRUE_FATAL(ret);
ret = __target->listen(__target, server_socket, 3, &err);
CU_ASSERT_EQUAL_FATAL(err, 0);
CU_ASSERT_TRUE_FATAL(ret);
addr.sin_addr.s_addr = inet_addr("10.0.0.100");
my_context client = __reference->open(__reference, &err);
CU_ASSERT_EQUAL_FATAL(err, 0);
CU_ASSERT_PTR_NOT_NULL_FATAL(client);
// printf("aaaaaaaaaaaaaaaaaaaaa\n");
ret = __reference->connect(__reference, client, (struct sockaddr*)&addr, len, &err);
CU_ASSERT_EQUAL_FATAL(err, 0);
CU_ASSERT_TRUE_FATAL(ret);
// printf("aaaaaaaaaaaaaaa\n");
__flush_packets(100);
ret = __target->accept(__target, server_socket, &err);
CU_ASSERT_EQUAL_FATAL(err, 0);
CU_ASSERT_TRUE_FATAL(ret);
// printf("bbbbbbbbbbbbbbbb\n");
application* clientApp = __find_app(__reference, client);
CU_ASSERT_EQUAL(clientApp->active_open_calls, 1);
application* serverApp = __find_app(__target, server_socket);
CU_ASSERT_EQUAL(serverApp->active_open_calls, 0);
CU_ASSERT_EQUAL(list_get_count(serverApp->passive_open_calls), 1);
// printf("cccccccccccccc\n");
__pcap_close();
}
static void test_socketpair(
void)
{
int fds[2];
int status = socketpair(AF_UNIX, SOCK_SEQPACKET, 0, fds);
CU_ASSERT_EQUAL_FATAL(status, 0);
pthread_t thread;
status = pthread_create(&thread, NULL, read_from_fd, fds);
CU_ASSERT_EQUAL_FATAL(status, 0);
CU_ASSERT_EQUAL_FATAL(status, 0);
for (int n = 1; n <= sizeof(buf); n <<= 1) {
(void)printf("Writing %d bytes\n", n);
status = write(fds[1], buf, n); // Can't be fsync()ed
CU_ASSERT_EQUAL_FATAL(status, n);
}
/*
* Closing fds[1] may cause read_from_fd() to return before last record is
* read because the file-descriptor is no longer valid.
*/
status = shutdown(fds[0], 0);
CU_ASSERT_EQUAL_FATAL(status, 0);
status = pthread_join(thread, NULL);
CU_ASSERT_EQUAL_FATAL(status, 0);
close(fds[0]);
close(fds[1]);
}
static void test_concurrency(void)
{
fq = NULL;
int status = fq_new(&fq, QUEUE_SIZE);
CU_ASSERT_EQUAL_FATAL(status, 0);
CU_ASSERT_PTR_NOT_NULL_FATAL(fq);
pthread_barrier_t barrier;
status = pthread_barrier_init(&barrier, NULL, 2);
CU_ASSERT_EQUAL_FATAL(status, 0);
pthread_t writer;
status = pthread_create(&writer, NULL, start_writer, &barrier);
CU_ASSERT_EQUAL_FATAL(status, 0);
pthread_t reader;
status = pthread_create(&reader, NULL, start_reader, &barrier);
CU_ASSERT_EQUAL_FATAL(status, 0);
void* result;
status = pthread_join(writer, &result);
CU_ASSERT_EQUAL_FATAL(status, 0);
int nwritten = *(int*)result;
status = pthread_join(reader, &result);
CU_ASSERT_EQUAL_FATAL(status, 0);
int nread = *(int*)result;
CU_ASSERT_EQUAL(nread, nwritten);
status = pthread_barrier_destroy(&barrier);
CU_ASSERT_EQUAL(status, 0);
fq_free(fq);
}
static void test_func_msg_to_table_nmea(void)
{
int rc;
struct filter_context_t ctx;
struct property_list_t properties;
struct message_t msg_in;
struct message_t msg_out;
const char SCRIPT[] =
"function filter(msg_out, msg_in)\n"
" local t = msg_to_table(msg_in)\n"
" if t == nil then\n"
" return FILTER_DISCARD\n"
" end\n"
" if t.msg_type == MSG_NMEA then\n"
" if t.data.nmea.nmea_type == NMEA_RMB then\n"
" if t.data.nmea.raw == 'hello world' then\n"
" return FILTER_SUCCESS\n"
" end\n"
" end\n"
" end\n"
" return FILTER_FAILURE\n"
"end\n"
"\n"
;
memset(&msg_in, 0, sizeof(msg_in));
memset(&msg_out, 0, sizeof(msg_out));
CU_ASSERT_PTR_NOT_NULL(filter);
CU_ASSERT_PTR_NOT_NULL(filter->init);
CU_ASSERT_PTR_NOT_NULL(filter->func);
CU_ASSERT_PTR_NOT_NULL(filter->exit);
proplist_init(&properties);
proplist_set(&properties, "script", tmpfilename);
prepare_script(SCRIPT);
rc = filter->init(&ctx, &properties);
CU_ASSERT_EQUAL_FATAL(rc, EXIT_SUCCESS);
msg_in.type = MSG_NMEA;
msg_in.data.attr.nmea.type = NMEA_RMB;
strncpy(msg_in.data.attr.nmea.raw, "hello world", sizeof(msg_in.data.attr.nmea.raw));
rc = filter->func(&msg_out, &msg_in, &ctx, &properties);
CU_ASSERT_EQUAL(rc, FILTER_SUCCESS);
CU_ASSERT_EQUAL(filter->exit(&ctx), EXIT_SUCCESS);
proplist_free(&properties);
}
static void create_maced_entry(passwand_entry_t *e) {
memset(e, 0, sizeof(*e));
e->space = (uint8_t*)"hello world";
e->space_len = strlen("hello world");
e->key = (uint8_t*)"hello world";
e->key_len = strlen("hello world");
e->value = (uint8_t*)"hello world";
e->value_len = strlen("hello world");
e->work_factor = 14;
passwand_error_t err = passwand_entry_set_mac("foo bar", e);
CU_ASSERT_EQUAL_FATAL(err, PW_OK);
}
void testMessageID() {
CoapPDU *pdu = NULL;
uint8_t *buffer[4];
for(int i=0; i<4; i++) {
switch(i) {
case 0:
pdu = new CoapPDU((uint8_t*)buffer,4,0);
break;
case 1:
pdu->reset();
break;
case 2:
pdu = new CoapPDU();
break;
case 3:
pdu->reset();
break;
}
uint16_t messageID = 0, readID = 0;
pdu->setMessageID(0x0000);
CU_ASSERT_EQUAL_FATAL(pdu->getMessageID(),0x0000);
pdu->setMessageID(0x0001);
CU_ASSERT_EQUAL_FATAL(pdu->getMessageID(),0x0001);
pdu->setMessageID(0xFFFF);
CU_ASSERT_EQUAL_FATAL(pdu->getMessageID(),0xFFFF);
for(int j=0; j<100; j++) {
messageID = rand()%0xFFFF;
pdu->setMessageID(messageID);
readID = pdu->getMessageID();
CU_ASSERT_EQUAL_FATAL(messageID,readID);
}
if(i%2) {
DBG("%d DELETE",i);
delete pdu;
}
}
}
void testHeaderFirstByteConstruction(void) {
CoapPDU *pdu = NULL;
uint8_t *buffer[64];
for(int constructorType=0; constructorType<4; constructorType++) {
DBG("New iteration: constructorType: %d",constructorType);
switch(constructorType) {
case 0:
pdu = new CoapPDU((uint8_t*)buffer,64,0);
break;
case 1:
pdu->reset();
break;
case 2:
pdu = new CoapPDU();
break;
case 3:
pdu->reset();
break;
}
for(int pduVersion=0; pduVersion<4; pduVersion++) {
for(int pduTypeIndex=0; pduTypeIndex<4; pduTypeIndex++) {
for(int tokenLength=0; tokenLength<9; tokenLength++) {
pdu->setVersion(pduVersion);
pdu->setType(coapTypeVector[pduTypeIndex]);
pdu->setTokenLength(tokenLength);
CU_ASSERT_EQUAL_FATAL(pdu->getVersion(),pduVersion);
CU_ASSERT_EQUAL_FATAL(pdu->getType(),coapTypeVector[pduTypeIndex]);
CU_ASSERT_EQUAL_FATAL(pdu->getTokenLength(),tokenLength);
}
}
}
if(constructorType%2) {
DBG("%d DELETE",constructorType);
delete pdu;
}
}
}
static void test_packet_size_is_less_then_mtu(void)
{
odp_packet_t pkt_orig, pkt_sent;
odp_event_t ev;
int res;
struct ofp_ether_header *eth;
if (create_odp_packet_ip4(&pkt_orig, pkt1_frag1,
sizeof(pkt1_frag1), 0)) {
CU_FAIL("Fail to create packet");
return;
}
res = ofp_ip_output(pkt_orig, &nexthop);
CU_ASSERT_EQUAL(res, OFP_PKT_PROCESSED);
res = ofp_send_pending_pkt();
CU_ASSERT_EQUAL(res, OFP_PKT_PROCESSED);
ev = odp_queue_deq(dev->outq_def);
CU_ASSERT_NOT_EQUAL_FATAL(ev, ODP_EVENT_INVALID);
CU_ASSERT_EQUAL_FATAL(odp_queue_deq(dev->outq_def), ODP_EVENT_INVALID);
pkt_sent = odp_packet_from_event(ev);
CU_ASSERT_EQUAL_FATAL(odp_packet_len(pkt_sent), sizeof(pkt1_frag1));
eth = odp_packet_l2_ptr(pkt_sent, NULL);
if (memcmp(eth->ether_dhost, dst_mac, OFP_ETHER_ADDR_LEN))
CU_FAIL("Bad destination mac address.");
if (memcmp(eth->ether_shost, dev->mac, OFP_ETHER_ADDR_LEN))
CU_FAIL("Bad source mac address.");
if (memcmp(odp_packet_l3_ptr(pkt_sent, NULL),
&orig_pkt_data[OFP_ETHER_HDR_LEN],
sizeof(pkt1_frag1) - OFP_ETHER_HDR_LEN))
CU_FAIL("corrupt l3 + data forwarded");
CU_PASS("Correct packet");
odp_packet_free(pkt_sent);
}
static int numLines(
const char* const pathname)
{
FILE* stream = fopen(pathname, "r");
CU_ASSERT_PTR_NOT_NULL_FATAL(stream);
int n = 0;
char line[_POSIX_MAX_INPUT];
for (; fgets(line, sizeof(line), stream) != NULL; ++n)
;
CU_ASSERT_TRUE_FATAL(feof(stream));
CU_ASSERT_FALSE_FATAL(ferror(stream));
CU_ASSERT_EQUAL_FATAL(fclose(stream), 0);
return n;
}
void _assertLicIds(const GArray* lics, unsigned int n, ...) {
CU_ASSERT_PTR_NOT_NULL_FATAL(lics);
CU_ASSERT_EQUAL_FATAL(lics->len, n);
va_list args;
va_start(args, n);
for (int i=0; i<n; i++) {
int expectedLicId = va_arg(args, int);
CU_ASSERT_EQUAL(license_index(lics, i)->refId, expectedLicId);
}
va_end(args);
}
static void
test_sa_getInetSockAddr(void)
{
static const char* const IP_ADDR = "127.0.0.1";
static const unsigned short PORT = 1;
ServiceAddr* serviceAddr;
int status = sa_new(&serviceAddr, IP_ADDR, PORT);
CU_ASSERT_EQUAL_FATAL(status, 0);
struct sockaddr_storage inetSockAddr;
socklen_t sockLen;
status = sa_getInetSockAddr(serviceAddr, true, &inetSockAddr, &sockLen);
CU_ASSERT_EQUAL_FATAL(status, 0);
CU_ASSERT_EQUAL(((struct sockaddr_in*)&inetSockAddr)->sin_family, AF_INET);
CU_ASSERT_EQUAL(((struct sockaddr_in*)&inetSockAddr)->sin_addr.s_addr,
inet_addr(IP_ADDR));
CU_ASSERT_EQUAL(((struct sockaddr_in*)&inetSockAddr)->sin_port,
htons(PORT));
CU_ASSERT_EQUAL(sockLen, sizeof(struct sockaddr_in));
}
void test_add_message_no_subscriber() {
int ret;
struct list topics;
struct list messages;
struct subscriber sub1 = {&c1, "hans"};
list_init(&topics);
list_init(&messages);
// add and remove sub to create topic
topic_add_subscriber(&topics, "stocks", &sub1);
topic_remove_subscriber(&topics, &sub1);
ret = topic_add_message(&topics, &messages, "stocks", "price: 33");
CU_ASSERT_EQUAL_FATAL(TOPIC_NO_SUBSCRIBERS, ret);
}
void test_msg_remove_subscriber_second() {
topic_before_test();
int ret;
struct list topics;
struct list messages;
struct subscriber sub1 = {&c1, "hans"};
struct subscriber sub2 = {&c2, "jakob"};
struct message *msg;
struct msg_statistics *stat;
list_init(&topics);
list_init(&messages);
topic_add_subscriber(&topics, "stocks", &sub1);
topic_add_subscriber(&topics, "stocks", &sub2);
topic_add_message(&topics, &messages, "stocks", "price: 33");
ret = message_remove_subscriber(&messages, &sub2);
CU_ASSERT_EQUAL_FATAL(0, ret);
msg = message_find_by_content(&messages, "price: 33");
CU_ASSERT_EQUAL_FATAL(1, list_len(msg->stats));
stat = msg->stats->root->entry;
CU_ASSERT_EQUAL_FATAL(&sub1, stat->subscriber);
topic_after_test();
}
static void test_func_msg_to_table_timer(void) /* TODO: move test to test_lua_message? */
{
int rc;
struct filter_context_t ctx;
struct property_list_t properties;
struct message_t msg_in;
struct message_t msg_out;
const char SCRIPT[] =
"function filter(msg_out, msg_in)\n"
" local t = msg_to_table(msg_in)\n"
" if t == nil then\n"
" return FILTER_DISCARD\n"
" end\n"
" if t.msg_type == MSG_TIMER then\n"
" if t.data.timer_id == 12345678 then\n"
" return FILTER_SUCCESS\n"
" end\n"
" end\n"
" return FILTER_FAILURE\n"
"end\n"
"\n"
;
memset(&msg_in, 0, sizeof(msg_in));
memset(&msg_out, 0, sizeof(msg_out));
CU_ASSERT_PTR_NOT_NULL(filter);
CU_ASSERT_PTR_NOT_NULL(filter->init);
CU_ASSERT_PTR_NOT_NULL(filter->func);
CU_ASSERT_PTR_NOT_NULL(filter->exit);
proplist_init(&properties);
proplist_set(&properties, "script", tmpfilename);
prepare_script(SCRIPT);
rc = filter->init(&ctx, &properties);
CU_ASSERT_EQUAL_FATAL(rc, EXIT_SUCCESS);
msg_in.type = MSG_TIMER;
msg_in.data.attr.timer_id = 12345678;
rc = filter->func(&msg_out, &msg_in, &ctx, &properties);
CU_ASSERT_EQUAL(rc, FILTER_SUCCESS);
CU_ASSERT_EQUAL(filter->exit(&ctx), EXIT_SUCCESS);
proplist_free(&properties);
}
void test_count_walk(void) {
const int nr_points = 9;
tree_2k_err_t status;
const int rank = 2, max_points = 10, bucket_size = 1;
double center[] = {0.0, 0.0};
double extent[] = {1.0, 1.0};
tree_2k_t *tree;
int counted_points = 0;
status = tree_2k_alloc(&tree, rank, center, extent,
max_points, bucket_size);
CU_ASSERT_EQUAL_FATAL(status, TREE_2K_SUCCESS);
for (int point_nr = 0; point_nr < nr_points; point_nr++) {
int i = point_nr/3;
int j = point_nr % 3;
double coords[] = {0.1 + (i - 1)*0.3, -0.1 + (j - 1)*0.25};
status = tree_2k_insert(tree, coords, NULL);
CU_ASSERT_EQUAL_FATAL(status, TREE_2K_SUCCESS);
}
CU_ASSERT_EQUAL(tree_2k_get_nr_points(tree), nr_points);
status = tree_2k_walk(tree, &count_points, &counted_points);
CU_ASSERT_EQUAL_FATAL(status, TREE_2K_SUCCESS);
CU_ASSERT_EQUAL(counted_points, tree_2k_get_nr_points(tree));
tree_2k_free(&tree);
}
/**
* Closes the socket on failure.
*
* @param[in] up7 The upstream LDM-7 to be initialized.
* @param[in] sock The socket for the upstream LDM-7.
* @param[in] termFd Termination file-descriptor.
* @retval 0 Success.
*/
static int
up7_init(
Up7* const up7,
const int sock)
{
/*
* 0 => use default read/write buffer sizes.
* `sock` will be closed by `svc_destroy()`.
*/
SVCXPRT* const xprt = svcfd_create(sock, 0, 0);
CU_ASSERT_PTR_NOT_EQUAL_FATAL(xprt, NULL);
/*
* Set the remote address of the RPC server-side transport because
* `svcfd_create()` doesn't.
*/
{
struct sockaddr_in addr;
socklen_t addrLen = sizeof(addr);
int status = getpeername(sock, &addr, &addrLen);
CU_ASSERT_EQUAL_FATAL(status, 0);
CU_ASSERT_EQUAL_FATAL(addrLen, sizeof(addr));
CU_ASSERT_EQUAL_FATAL(addr.sin_family, AF_INET);
xprt->xp_raddr = addr;
xprt->xp_addrlen = addrLen;
}
// Last argument == 0 => don't register with portmapper
bool success = svc_register(xprt, LDMPROG, SEVEN, ldmprog_7, 0);
CU_ASSERT_TRUE_FATAL(success);
up7->xprt = xprt;
return 0;
}
