void
test_Initialization(void) {
TEST_ASSERT_EQUAL_UINT(RECV_INIT, free_recvbuffs());
TEST_ASSERT_EQUAL_UINT(0, full_recvbuffs());
TEST_ASSERT_FALSE(has_full_recv_buffer());
TEST_ASSERT_NULL(get_full_recv_buffer());
}
void test_parse_request_without_args() {
parse("~chaser,start~");
TEST_ASSERT_EQUAL_UINT(1, request_count);
TEST_ASSERT_EQUAL_UINT(0, error_count);
TEST_ASSERT_EQUAL_STRING("chaser", requests[0].program);
TEST_ASSERT_EQUAL_STRING("start", requests[0].request);
}
void test_parse_recovery_from_data_outside_frame() {
parse("data~chaser,start~");
TEST_ASSERT_EQUAL_UINT(1, request_count);
TEST_ASSERT_EQUAL_UINT(1, error_count);
TEST_ASSERT_EQUAL_UINT(SLURP_ERROR_FRAMING, errors[0].code);
TEST_ASSERT_EQUAL_STRING("chaser", requests[0].program);
TEST_ASSERT_EQUAL_STRING("start", requests[0].request);
}
void test_parse_recovery_from_missing_request() {
parse("~chaser~~chaser,start~");
TEST_ASSERT_EQUAL_UINT(1, request_count);
TEST_ASSERT_EQUAL_UINT(1, error_count);
TEST_ASSERT_EQUAL_UINT(SLURP_ERROR_MISSING_REQUEST, errors[0].code);
TEST_ASSERT_EQUAL_STRING("chaser", requests[0].program);
TEST_ASSERT_EQUAL_STRING("start", requests[0].request);
}
void
test_GetAndFree(void) {
u_long initial = free_recvbuffs();
recvbuf_t* buf = get_free_recv_buffer();
TEST_ASSERT_EQUAL_UINT(initial-1, free_recvbuffs());
freerecvbuf(buf);
TEST_ASSERT_EQUAL_UINT(initial, free_recvbuffs());
}
void test_should_register_buffer_event_source_when_event_listener_added() {
uint8_t buffer_data[BUFFER_MAX_ELEMENTS];
struct buffer buffer = buffer_init(buffer_data, BUFFER_MAX_ELEMENTS, sizeof(uint8_t));
buffer_event_add_listener(&buffer, buffer_event_handler);
TEST_ASSERT_EQUAL_UINT(1, event_source_count());
TEST_ASSERT_EQUAL_UINT(EVENT_CATEGORY_BUFFER, ((event_source*) first_event_source())->super.descriptor.category);
TEST_ASSERT_EQUAL_UINT(&buffer, first_event_source()->super.descriptor.address);
}
void test_parse_consecutive_requests_and_errors() {
parse("data~chaser,start~~chaser,~~chaser,stop~data");
TEST_ASSERT_EQUAL_UINT(2, request_count);
TEST_ASSERT_EQUAL_UINT(3, error_count);
TEST_ASSERT_EQUAL_UINT(SLURP_ERROR_FRAMING, errors[0].code);
TEST_ASSERT_EQUAL_UINT(SLURP_ERROR_MISSING_REQUEST, errors[1].code);
TEST_ASSERT_EQUAL_UINT(SLURP_ERROR_FRAMING, errors[2].code);
TEST_ASSERT_EQUAL_STRING("chaser", requests[0].program);
TEST_ASSERT_EQUAL_STRING("start", requests[0].request);
TEST_ASSERT_EQUAL_STRING("chaser", requests[1].program);
TEST_ASSERT_EQUAL_STRING("stop", requests[1].request);
}
void test_parse_request_with_args() {
parse("~chaser,trail,length,\x08,bright,\xff~");
TEST_ASSERT_EQUAL_UINT(1, request_count);
TEST_ASSERT_EQUAL_UINT(0, error_count);
TEST_ASSERT_EQUAL_STRING("chaser", requests[0].program);
TEST_ASSERT_EQUAL_STRING("trail", requests[0].request);
TEST_ASSERT_EQUAL_UINT(2, requests[0].args_length);
TEST_ASSERT_EQUAL_STRING("length", requests[0].arg_names[0]);
TEST_ASSERT_EQUAL_STRING("\x08", requests[0].arg_values[0]);
TEST_ASSERT_EQUAL_STRING("bright", requests[0].arg_names[1]);
TEST_ASSERT_EQUAL_STRING("\xff", requests[0].arg_values[1]);
}
void test_default_hash_func() {
uint64_t i1 = 1, i2 = 1001;
// these two should collide because of the %
TEST_ASSERT_EQUAL_UINT(map->hash_func(&i1, map->capacity),
map->hash_func(&i2, map->capacity));
// these two hash obtained by default hash_func should be equal (since the first 8-byte is the same)
TEST_ASSERT_EQUAL_UINT(map->hash_func("1234567890", map->capacity),
map->hash_func("1234567809", map->capacity));
}
void test_parse_consecutive_split_requests_no_args() {
parse("~chas");
parse("er,sta");
parse("rt~~");
parse("chaser");
parse(",stop~");
TEST_ASSERT_EQUAL_UINT(2, request_count);
TEST_ASSERT_EQUAL_UINT(0, error_count);
TEST_ASSERT_EQUAL_STRING("chaser", requests[0].program);
TEST_ASSERT_EQUAL_STRING("start", requests[0].request);
TEST_ASSERT_EQUAL_STRING("chaser", requests[1].program);
TEST_ASSERT_EQUAL_STRING("stop", requests[1].request);
}
void test_parse_consecutive_mixed_requests() {
parse("~chaser,start~~chaser,trail,length,\x08,bright,\xff~~chaser,stop~");
TEST_ASSERT_EQUAL_UINT(3, request_count);
TEST_ASSERT_EQUAL_UINT(0, error_count);
TEST_ASSERT_EQUAL_STRING("chaser", requests[0].program);
TEST_ASSERT_EQUAL_STRING("start", requests[0].request);
TEST_ASSERT_EQUAL_STRING("chaser", requests[1].program);
TEST_ASSERT_EQUAL_STRING("trail", requests[1].request);
TEST_ASSERT_EQUAL_UINT(2, requests[1].args_length);
TEST_ASSERT_EQUAL_STRING("length", requests[1].arg_names[0]);
TEST_ASSERT_EQUAL_STRING("\x08", requests[1].arg_values[0]);
TEST_ASSERT_EQUAL_STRING("bright", requests[1].arg_names[1]);
TEST_ASSERT_EQUAL_STRING("\xff", requests[1].arg_values[1]);
TEST_ASSERT_EQUAL_STRING("chaser", requests[2].program);
TEST_ASSERT_EQUAL_STRING("stop", requests[2].request);
}
void test_parse_split_request_with_args() {
parse("~chas");
parse("er");
parse(",");
parse("tra");
parse("il,len");
parse("gth,");
parse("\x08");
parse("~");
TEST_ASSERT_EQUAL_UINT(1, request_count);
TEST_ASSERT_EQUAL_UINT(0, error_count);
TEST_ASSERT_EQUAL_STRING("chaser", requests[0].program);
TEST_ASSERT_EQUAL_STRING("trail", requests[0].request);
TEST_ASSERT_EQUAL_UINT(1, requests[0].args_length);
TEST_ASSERT_EQUAL_STRING("length", requests[0].arg_names[0]);
TEST_ASSERT_EQUAL_STRING("\x08", requests[0].arg_values[0]);
}
void test_detect_truncation() {
char buffer[SLURP_REQUEST_MAX_LENGTH];
uint8_t length = slurp_serialize_request(&basic_request, buffer, SLURP_REQUEST_MAX_LENGTH);
TEST_ASSERT_TRUE(length > 0);
char short_buffer[8];
length = slurp_serialize_request(&basic_request, short_buffer, 8);
TEST_ASSERT_EQUAL_UINT(0, length);
}
void
test_GetAndFill(void) {
// int initial = free_recvbuffs();
recvbuf_t* buf = get_free_recv_buffer();
add_full_recv_buffer(buf);
TEST_ASSERT_EQUAL_UINT(1, full_recvbuffs());
TEST_ASSERT_TRUE(has_full_recv_buffer());
TEST_ASSERT_EQUAL_PTR(buf, get_full_recv_buffer());
}
void test_keys() {
char *keys[] = { "key", "keys2", "1234567890", "1234567809" };
char *values[] = { "value", "value2", "9090", "0909" };
linked_list *keys_list = hash_map_keys(map);
TEST_ASSERT_EQUAL_UINT(0, linked_list_size(keys_list));
for (int i = 0; i < sizeof(keys) / sizeof(*keys); i++) {
hash_map_put(map, keys[i], values[i]);
}
keys_list = hash_map_keys(map);
TEST_ASSERT_EQUAL_UINT(4, linked_list_size(keys_list));
linked_list_node *node = linked_list_head(keys_list);
for (int i = 0; i < sizeof(keys) / sizeof(*keys); i++) {
TEST_ASSERT_EQUAL_STRING(keys[i], node->data);
node = node->next;
}
}
void testNotEqualUInts(void)
{
_UU16 v0, v1;
v0 = 9000;
v1 = 9001;
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_UINT(v0, v1);
VERIFY_FAILS_END
}
void test_clear() {
hash_map_put(map, "key", "value");
hash_map_put(map, "key2", "value2");
hash_map_put(map, "key3", "value3");
hash_map_clear(map);
TEST_ASSERT_EQUAL_UINT(0, hash_map_size(map));
TEST_ASSERT_NULL(hash_map_get(map, "key"));
TEST_ASSERT_NULL(hash_map_get(map, "key2"));
TEST_ASSERT_NULL(hash_map_get(map, "key3"));
}
void test_should_raise_single_event_on_buffer_full() {
uint8_t buffer_data[BUFFER_MAX_ELEMENTS];
struct buffer buffer = buffer_init(buffer_data, BUFFER_MAX_ELEMENTS, sizeof(uint8_t));
buffer_event_add_listener(&buffer, buffer_event_handler);
for (uint8_t i = 0; i < BUFFER_MAX_ELEMENTS - 1; i++) {
buffer_push_overflow(&buffer, &i);
event_tick();
}
TEST_ASSERT_EQUAL_UINT(0, callback_count);
buffer_push_overflow(&buffer, &(uint8_t){ 1 });
event_tick();
TEST_ASSERT_EQUAL_UINT(1, callback_count);
TEST_ASSERT_EQUAL_PTR(&buffer, last_event.descriptor.address);
TEST_ASSERT_BITS_HIGH(BUFFER_FULL, last_event.flags);
for (uint8_t i = 0; i < BUFFER_MAX_ELEMENTS; i++) {
buffer_push_overflow(&buffer, &i);
event_tick();
}
TEST_ASSERT_EQUAL_UINT(1, callback_count);
}
void testNotEqualUInts(void)
{
int failed;
_UU16 v0, v1;
v0 = 9000;
v1 = 9001;
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_UINT(v0, v1);
EXPECT_ABORT_END
failed = Unity.CurrentTestFailed;
Unity.CurrentTestFailed = 0;
TEST_ASSERT_MESSAGE(1U == failed, "This is expected");
}
void testEqualUints(void)
{
unsigned int v0, v1;
unsigned int *p0, *p1;
v0 = 19467;
v1 = 19467;
p0 = &v0;
p1 = &v1;
TEST_ASSERT_EQUAL_UINT(1837, 1837);
TEST_ASSERT_EQUAL_UINT(v0, v1);
TEST_ASSERT_EQUAL_UINT(19467, v1);
TEST_ASSERT_EQUAL_UINT(v0, 19467);
TEST_ASSERT_EQUAL_UINT(*p0, v1);
TEST_ASSERT_EQUAL_UINT(*p0, *p1);
TEST_ASSERT_EQUAL_UINT(*p0, 19467);
TEST_ASSERT_EQUAL_UINT(60872u, 60872u);
}
void testEqualUShorts(void)
{
unsigned short v0, v1;
unsigned short *p0, *p1;
v0 = 19467;
v1 = 19467;
p0 = &v0;
p1 = &v1;
TEST_ASSERT_EQUAL_UINT(1837, 1837);
TEST_ASSERT_EQUAL_UINT(2987, 2987);
TEST_ASSERT_EQUAL_UINT(v0, v1);
TEST_ASSERT_EQUAL_UINT(19467, v1);
TEST_ASSERT_EQUAL_UINT(v0, 19467);
TEST_ASSERT_EQUAL_UINT(*p0, v1);
TEST_ASSERT_EQUAL_UINT(*p0, *p1);
TEST_ASSERT_EQUAL_UINT(*p0, 19467);
}
void
test_MicrosecondsExact(void)
{
/* 0.5 can be represented exact in both l_fp and timeval. */
const struct timeval input = {10, 500000}; /* 0.5 exact */
const l_fp expected = {{10}, HALF}; /* 0.5 exact */
l_fp actual;
TVTOTS(&input, &actual);
/* Compare the fractional part with an absolute error given. */
TEST_ASSERT_EQUAL_UINT(expected.l_ui, actual.l_ui);
double expectedDouble, actualDouble;
M_LFPTOD(0, expected.l_uf, expectedDouble);
M_LFPTOD(0, actual.l_uf, actualDouble);
/* The error should be less than 0.5 us */
TEST_ASSERT_DOUBLE_WITHIN(0.0000005, expectedDouble, actualDouble);
}
void test_size() {
TEST_ASSERT_EQUAL_UINT(0, hash_map_size(map));
hash_map_put(map, "key", "value");
TEST_ASSERT_EQUAL_UINT(1, hash_map_size(map));
hash_map_put(map, "key2", "value");
TEST_ASSERT_EQUAL_UINT(2, hash_map_size(map));
// if the same key was updated, size should not change
hash_map_put(map, "key", "value2");
TEST_ASSERT_EQUAL_UINT(2, hash_map_size(map));
// if hashs collide, size should still work
hash_map_put(map, "1234567890", "9090");
hash_map_put(map, "1234567809", "0909");
TEST_ASSERT_EQUAL_UINT(4, hash_map_size(map));
hash_map_remove(map, "key");
hash_map_remove(map, "key2");
hash_map_remove(map, "1234567890");
hash_map_remove(map, "1234567809");
TEST_ASSERT_EQUAL_UINT(0, hash_map_size(map));
}
static void dwGetDataMockCallback(dwDevice_t* actualDev, uint8_t* data, unsigned int actualDataLength, int cmock_num_calls) {
TEST_ASSERT_EQUAL_PTR(dwGetDataContexts[cmock_num_calls].expectedDev, actualDev);
TEST_ASSERT_EQUAL_UINT(dwGetDataContexts[cmock_num_calls].expectedDataLength, actualDataLength);
memcpy(data, &dwGetDataContexts[cmock_num_calls].packet, actualDataLength);
}
void test_remove_non_existent() {
hash_map_remove(map, "not here");
TEST_ASSERT_EQUAL_UINT(0, hash_map_size(map));
}
void test_parse_data_outside_frame() {
parse("data~");
TEST_ASSERT_EQUAL_UINT(0, request_count);
TEST_ASSERT_EQUAL_UINT(1, error_count);
TEST_ASSERT_EQUAL_UINT(SLURP_ERROR_FRAMING, errors[0].code);
}
void test_parse_missing_program() {
parse("~~");
TEST_ASSERT_EQUAL_UINT(0, request_count);
TEST_ASSERT_EQUAL_UINT(1, error_count);
TEST_ASSERT_EQUAL_UINT(SLURP_ERROR_MISSING_PROGRAM, errors[0].code);
}
void test_parse_missing_request_no_delim() {
parse("~chaser~");
TEST_ASSERT_EQUAL_UINT(0, request_count);
TEST_ASSERT_EQUAL_UINT(1, error_count);
TEST_ASSERT_EQUAL_UINT(SLURP_ERROR_MISSING_REQUEST, errors[0].code);
}
