void test_topic_list_listeners_adding_and_removing(void)
{
KAA_TRACE_IN(context->logger);
err = kaa_get_topics(context->notification_manager, &topics);
ASSERT_EQUAL(err, KAA_ERR_NONE);
err = kaa_add_topic_list_listener(context->notification_manager, &topic_listener, &id);
ASSERT_EQUAL(err, KAA_ERR_NONE);
err = kaa_add_topic_list_listener(context->notification_manager, &topic_listener, &id);
ASSERT_NOT_EQUAL(err, KAA_ERR_NONE);
err = kaa_add_topic_list_listener(context->notification_manager, &topic_listener_2, &id2);
ASSERT_EQUAL(err, KAA_ERR_NONE);
err = kaa_remove_topic_list_listener(context->notification_manager, &id);
ASSERT_EQUAL(err, KAA_ERR_NONE);
err = kaa_remove_topic_list_listener(context->notification_manager, &id);
ASSERT_NOT_EQUAL(err, KAA_ERR_NONE);
err = kaa_remove_topic_list_listener(context->notification_manager, &id2);
ASSERT_EQUAL(err, KAA_ERR_NONE);
KAA_TRACE_OUT(context->logger);
}
void test_allocate_log_record_buffer(void)
{
KAA_TRACE_IN(logger);
kaa_error_t error_code;
void *storage;
error_code = ext_unlimited_log_storage_create(&storage, logger);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
error_code = ext_log_storage_allocate_log_record_buffer(storage, NULL);
ASSERT_NOT_EQUAL(error_code, KAA_ERR_NONE);
kaa_log_record_t record1 = { NULL, 0 };
error_code = ext_log_storage_allocate_log_record_buffer(storage, &record1);
ASSERT_NOT_EQUAL(error_code, KAA_ERR_NONE);
ASSERT_NULL(record1.data);
kaa_log_record_t record2 = { NULL, 256 };
error_code = ext_log_storage_allocate_log_record_buffer(storage, &record2);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
ASSERT_NOT_NULL(record2.data);
ext_log_storage_deallocate_log_record_buffer(storage, &record2);
ext_log_storage_destroy(storage);
KAA_TRACE_OUT(logger);
}
void test_profile_update(void **state)
{
(void)state;
char* pattern = "a94a8fe5ccb19ba61c4c0873d391e987982fbbd3";
kaa_error_t err;
char* body = "test";
kaa_digest calculated_hash;
err = ext_calculate_sha_hash(NULL, 50, calculated_hash);
ASSERT_NOT_EQUAL(err, KAA_ERR_NONE);
err = ext_calculate_sha_hash(body, 0, calculated_hash);
ASSERT_EQUAL(err, KAA_ERR_NONE);
err = ext_calculate_sha_hash(body, 4, NULL);
ASSERT_NOT_EQUAL(err, KAA_ERR_NONE);
err = ext_calculate_sha_hash(body, 4, calculated_hash);
ASSERT_EQUAL(err, KAA_ERR_NONE);
char buf[SHA_1_DIGEST_LENGTH * 2 + 1];
for (int i = 0; i < SHA_1_DIGEST_LENGTH; ++i) {
sprintf(&buf[i * 2], "%02x", calculated_hash[i]);
}
ASSERT_EQUAL(0, memcmp(buf, pattern, SHA_1_DIGEST_LENGTH * 2));
}
void test_subscriptions(void)
{
KAA_TRACE_IN(context->logger);
err = kaa_subscribe_to_topic(context->notification_manager, &topic_id, false);
ASSERT_EQUAL(err, KAA_ERR_NONE);
err = kaa_unsubscribe_from_topic(context->notification_manager, &topic_id, false);
ASSERT_EQUAL(err, KAA_ERR_NONE);
uint64_t fake_ids[2] = { 22, 11 };
err = kaa_subscribe_to_topics(context->notification_manager, fake_ids, 2, false);
ASSERT_NOT_EQUAL(err, KAA_ERR_NONE);
err = kaa_unsubscribe_from_topics(context->notification_manager, fake_ids, 2, false);
ASSERT_NOT_EQUAL(err, KAA_ERR_NONE);
uint64_t existing_ids[1] = { 22 };
err = kaa_subscribe_to_topics(context->notification_manager, existing_ids, 1, false);
ASSERT_EQUAL(err, KAA_ERR_NONE);
err = kaa_unsubscribe_from_topics(context->notification_manager, existing_ids, 1, false);
ASSERT_EQUAL(err, KAA_ERR_NONE);
KAA_TRACE_OUT(context->logger);
}
CTEST2(bloom, compare)
{
ASSERT_EQUAL(0, bloom_compare(data->b1, data->b2));
data->b1->bitsize--;
ASSERT_NOT_EQUAL(0, bloom_compare(data->b1, data->b2));
data->b2->bitsize--;
ASSERT_EQUAL(0, bloom_compare(data->b1, data->b2));
data->b1->bitsize++;
data->b2->bitsize++;
data->b1->size--;
ASSERT_NOT_EQUAL(0, bloom_compare(data->b1, data->b2));
data->b2->size--;
ASSERT_EQUAL(0, bloom_compare(data->b1, data->b2));
data->b1->size++;
data->b2->size++;
data->b1->a[0]++;
ASSERT_NOT_EQUAL(0, bloom_compare(data->b1, data->b2));
data->b2->a[0]++;
ASSERT_EQUAL(0, bloom_compare(data->b1, data->b2));
data->b1->a[0]--;
data->b2->a[0]--;
}
/**
* Test that items can be pushed and popped to and from
* the MIDIMessageQueue.
*/
int test001_message_queue( void ) {
struct MIDIMessageQueue * queue = MIDIMessageQueueCreate();
struct MIDIMessage * message[3] = {
MIDIMessageCreate( MIDI_STATUS_NOTE_ON ),
MIDIMessageCreate( MIDI_STATUS_POLYPHONIC_KEY_PRESSURE ),
MIDIMessageCreate( MIDI_STATUS_NOTE_OFF )
};
struct MIDIMessage * m;
size_t length;
MIDIKey key = 60;
ASSERT_NOT_EQUAL( queue, NULL, "Could not create message queue." );
ASSERT_NOT_EQUAL( message[0], NULL, "Could not create message 0." );
ASSERT_NOT_EQUAL( message[1], NULL, "Could not create message 1." );
ASSERT_NOT_EQUAL( message[2], NULL, "Could not create message 2." );
ASSERT_NO_ERROR( MIDIMessageSet( message[0], MIDI_KEY, sizeof(MIDIKey), &key ),
"Could not set key for message 0." );
ASSERT_NO_ERROR( MIDIMessageSet( message[1], MIDI_KEY, sizeof(MIDIKey), &key ),
"Could not set key for message 1." );
ASSERT_NO_ERROR( MIDIMessageSet( message[2], MIDI_KEY, sizeof(MIDIKey), &key ),
"Could not set key for message 2." );
ASSERT_NO_ERROR( MIDIMessageQueuePush( queue, message[0] ),
"Could not enqueue message 0." );
ASSERT_NO_ERROR( MIDIMessageQueuePush( queue, message[1] ),
"Could not enqueue message 1." );
ASSERT_NO_ERROR( MIDIMessageQueuePush( queue, message[2] ),
"Could not enqueue message 2." );
ASSERT_NO_ERROR( MIDIMessageQueuePeek( queue, &m ),
"Could not peek into queue." );
ASSERT_EQUAL( m, message[0], "Queue returned wrong message." );
ASSERT_NO_ERROR( MIDIMessageQueueGetLength( queue, &length),
"Could not determine queue length." );
ASSERT_EQUAL( length, 3, "Message queue returned wrong length." );
ASSERT_NO_ERROR( MIDIMessageQueuePop( queue, &m), "Could not pop message." );
ASSERT_EQUAL( m, message[0], "Queue returned wrong message." );
MIDIMessageRelease( m );
ASSERT_NO_ERROR( MIDIMessageQueuePop( queue, &m), "Could not pop message." );
ASSERT_EQUAL( m, message[1], "Queue returned wrong message." );
MIDIMessageRelease( m );
ASSERT_NO_ERROR( MIDIMessageQueueGetLength( queue, &length),
"Could not determine queue length." );
ASSERT_EQUAL( length, 1, "Message queue returned wrong length." );
MIDIMessageRelease( message[0] );
MIDIMessageRelease( message[1] );
MIDIMessageRelease( message[2] );
MIDIMessageQueueRelease( queue );
return 0;
}
CTEST2(bloom, add)
{
ASSERT_EQUAL(0, bloom_compare(data->b1, data->b2));
bloom_add_str(data->b1, "abc", 3);
ASSERT_NOT_EQUAL(0, bloom_compare(data->b1, data->b2));
memset(data->b1->a, 0x00, data->b1->size);
ASSERT_EQUAL(0, bloom_compare(data->b1, data->b2));
bloom_add_num(data->b2, 0x5A7AD);
ASSERT_NOT_EQUAL(0, bloom_compare(data->b1, data->b2));
}
CTEST(ls_htable, hash_int)
{
/* simply test that the hashcodes are different/same */
ASSERT_EQUAL(ls_int_hashcode((void*)25), ls_int_hashcode((void*)25));
ASSERT_NOT_EQUAL(ls_int_hashcode((void*)42), ls_int_hashcode((void*)25));
ASSERT_NOT_EQUAL(ls_int_hashcode((void*)-1231), ls_int_hashcode((void*)25));
ASSERT_NOT_EQUAL(ls_int_hashcode((void*)0), ls_int_hashcode((void*)25));
ASSERT_NOT_EQUAL(ls_int_hashcode((void*)1236423), ls_int_hashcode((void*)25));
ASSERT_EQUAL(ls_int_compare((void*)25, (void*)25), 0);
ASSERT_TRUE(ls_int_compare((void*)42, (void*)25) > 0);
ASSERT_TRUE(ls_int_compare((void*)-1231, (void*)25) < 0);
ASSERT_TRUE(ls_int_compare((void*)0, (void*)25) < 0);
ASSERT_TRUE(ls_int_compare((void*)1236423, (void*)25) > 0);
}
void test_noop_decision_on_failure(void **state)
{
(void)state;
size_t DEFAULT_UPLOAD_VOLUME_THRESHOLD = 8 * 1024;
size_t DEFAULT_UPLOAD_COUNT_THRESHOLD = 64;
kaa_error_t error_code = ext_log_upload_strategy_change_strategy(strategy,
KAA_LOG_UPLOAD_VOLUME_STRATEGY);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
error_code = ext_log_upload_strategy_set_threshold_volume(strategy, DEFAULT_UPLOAD_VOLUME_THRESHOLD);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
error_code = ext_log_upload_strategy_set_threshold_count(strategy, DEFAULT_UPLOAD_COUNT_THRESHOLD);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
error_code = ext_log_upload_strategy_on_failure(NULL, NO_APPENDERS_CONFIGURED);
ASSERT_NOT_EQUAL(error_code, KAA_ERR_NONE);
error_code = ext_log_upload_strategy_on_failure(strategy, NO_APPENDERS_CONFIGURED);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
test_log_storage_context_t log_storage_context;
log_storage_context.total_size = DEFAULT_UPLOAD_VOLUME_THRESHOLD;
log_storage_context.record_count = DEFAULT_UPLOAD_COUNT_THRESHOLD;
ext_log_upload_decision_t upload_decision = ext_log_upload_strategy_decide(strategy,
&log_storage_context);
ASSERT_EQUAL(upload_decision, NOOP);
}
void test_meta_extension_get_size_failed(void)
{
KAA_TRACE_IN(logger);
kaa_error_t error_code = kaa_meta_data_request_get_size(NULL);
ASSERT_NOT_EQUAL(error_code, KAA_ERR_NONE);
}
void EditableMapObject::SetName(string name, int8_t langCode)
{
strings::Trim(name);
if (name.empty())
return;
ASSERT_NOT_EQUAL(StringUtf8Multilang::kDefaultCode, langCode,
("Direct editing of default name is deprecated."));
if (!Editor::Instance().OriginalFeatureHasDefaultName(GetID()))
{
const auto mwmInfo = GetID().m_mwmId.GetInfo();
if (mwmInfo)
{
vector<int8_t> mwmLanguages;
mwmInfo->GetRegionData().GetLanguages(mwmLanguages);
if (CanUseAsDefaultName(langCode, mwmLanguages))
m_name.AddString(StringUtf8Multilang::kDefaultCode, name);
}
}
m_name.AddString(langCode, name);
}
void StatisicsPropertyintegration::test_copy()
{
StatisticsProperty * pb =
m_char1->modPropertyClass<StatisticsProperty>("char_type");
ASSERT_NOT_EQUAL(pb, m_char_property);
}
void test_notification_listeners_adding_and_removing(void)
{
KAA_TRACE_IN(context->logger);
err = kaa_add_notification_listener(context->notification_manager, &listener, &id);
ASSERT_EQUAL(err, KAA_ERR_NONE);
err = kaa_add_notification_listener(context->notification_manager, &listener, &id);
ASSERT_NOT_EQUAL(err, KAA_ERR_NONE);
err = kaa_add_notification_listener(context->notification_manager, &listener_2, &id2);
ASSERT_EQUAL(err, KAA_ERR_NONE);
err = kaa_remove_notification_listener(context->notification_manager, &id);
ASSERT_EQUAL(err, KAA_ERR_NONE);
err = kaa_remove_notification_listener(context->notification_manager, &id);
ASSERT_NOT_EQUAL(err, KAA_ERR_NONE);
err = kaa_remove_notification_listener(context->notification_manager, &id2);
ASSERT_EQUAL(err, KAA_ERR_NONE);
err = kaa_add_optional_notification_listener(context->notification_manager, &listener, &topic_id, &id);
ASSERT_EQUAL(err, KAA_ERR_NONE);
err = kaa_add_optional_notification_listener(context->notification_manager, &listener, &topic_id, &id);
ASSERT_NOT_EQUAL(err, KAA_ERR_NONE);
err = kaa_add_optional_notification_listener(context->notification_manager, &listener_2, &topic_id, &id2);
ASSERT_EQUAL(err, KAA_ERR_NONE);
*(uint32_t *)pointer_to_sqn = KAA_HTONL((uint32_t) 100); // Need to change sqn
err = kaa_platform_protocol_process_server_sync(context->platform_protocol, buffer_pointer, size);
ASSERT_EQUAL(err, KAA_ERR_NONE);
ASSERT_EQUAL(listener_has_been_notified, true); // whether callback has been called
err = kaa_remove_optional_notification_listener(context->notification_manager, &topic_id, &id);
ASSERT_EQUAL(err, KAA_ERR_NONE);
err = kaa_remove_optional_notification_listener(context->notification_manager, &topic_id, &id);
ASSERT_NOT_EQUAL(err, KAA_ERR_NONE);
err = kaa_remove_optional_notification_listener(context->notification_manager, &topic_id, &id2);
ASSERT_EQUAL(err, KAA_ERR_NONE);
KAA_TRACE_OUT(context->logger);
}
void test_kaa_deque_first_last()
{
kaa_error_t error_code = KAA_ERR_NONE;
error_code = kaa_deque_first(NULL, NULL);
ASSERT_EQUAL(error_code, KAA_ERR_BADPARAM);
error_code = kaa_deque_last(NULL, NULL);
ASSERT_EQUAL(error_code, KAA_ERR_BADPARAM);
kaa_deque_t *deque = NULL;
error_code = kaa_deque_create(&deque);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
ASSERT_NOT_NULL(deque);
error_code = kaa_deque_first(deque, NULL);
ASSERT_EQUAL(error_code, KAA_ERR_BADPARAM);
error_code = kaa_deque_last(deque, NULL);
ASSERT_EQUAL(error_code, KAA_ERR_BADPARAM);
kaa_deque_iterator_t *it = NULL;
error_code = kaa_deque_first(NULL, &it);
ASSERT_EQUAL(error_code, KAA_ERR_BADPARAM);
error_code = kaa_deque_last(NULL, &it);
ASSERT_EQUAL(error_code, KAA_ERR_BADPARAM);
error_code = kaa_deque_first(deque, &it);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
ASSERT_NULL(it);
error_code = kaa_deque_last(deque, &it);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
ASSERT_NULL(it);
kaa_deque_push_back_data(deque, "data");
ASSERT_EQUAL(kaa_deque_size(deque), 1);
kaa_deque_iterator_t *it1 = NULL;
error_code = kaa_deque_first(deque, &it1);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
ASSERT_NOT_NULL(it1);
kaa_deque_iterator_t *it2 = NULL;
error_code = kaa_deque_last(deque, &it2);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
ASSERT_NOT_NULL(it2);
ASSERT_EQUAL(it1, it2);
kaa_deque_push_back_data(deque, "data");
ASSERT_EQUAL(kaa_deque_size(deque), 2);
error_code = kaa_deque_first(deque, &it1);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
ASSERT_NOT_NULL(it1);
error_code = kaa_deque_last(deque, &it2);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
ASSERT_NOT_NULL(it2);
ASSERT_NOT_EQUAL(it1, it2);
kaa_deque_destroy(deque, &test_kaa_deque_destroy_stub);
}
CTEST(ls_htable, hash_str)
{
/* simply test that the hashcodes are different/same */
ASSERT_EQUAL(ls_str_hashcode("key1"), ls_str_hashcode("key1"));
ASSERT_NOT_EQUAL(ls_str_hashcode("key2"), ls_str_hashcode("key1"));
ASSERT_NOT_EQUAL(ls_str_hashcode("Key1"), ls_str_hashcode("key1"));
ASSERT_NOT_EQUAL(ls_str_hashcode("KEY1"), ls_str_hashcode("key1"));
ASSERT_NOT_EQUAL(ls_str_hashcode("KEY_ONE"), ls_str_hashcode("key1"));
ASSERT_NOT_EQUAL(ls_str_hashcode(""), ls_str_hashcode("key1"));
ASSERT_EQUAL(ls_str_compare("key1", "key1"), 0);
ASSERT_TRUE(ls_str_compare("key2", "key1") > 0);
ASSERT_TRUE(ls_str_compare("Key1", "key1") < 0);
ASSERT_TRUE(ls_str_compare("KEY1", "key1") < 0);
ASSERT_TRUE(ls_str_compare("KEY_ONE", "key1") < 0);
ASSERT_TRUE(ls_str_compare("", "key1") < 0);
}
void test_meta_extension_serialize_failed(void)
{
KAA_TRACE_IN(logger);
kaa_error_t error_code;
const size_t buffer_size = 6;
char buffer[buffer_size];
kaa_platform_message_writer_t *writer;
error_code = kaa_platform_message_writer_create(&writer, buffer, buffer_size);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
error_code = kaa_meta_data_request_serialize(NULL, NULL, 0);
ASSERT_NOT_EQUAL(error_code, KAA_ERR_NONE);
error_code = kaa_meta_data_request_serialize(NULL, (kaa_platform_message_writer_t *)!NULL, 0);
ASSERT_NOT_EQUAL(error_code, KAA_ERR_NONE);
kaa_platform_message_writer_destroy(writer);
}
/*
* Do a traversal of the space with non-uniform tile dimensions.
*/
CTEST2(tile_traverse, tile_weird_dim)
{
idx_t const nmodes = 5;
for(idx_t m=0; m < nmodes; ++m) {
data->dims[m] = m+1;
}
for(idx_t m=0; m < nmodes; ++m) {
/* empty tiles */
__fill_arr(data->coords, nmodes, 0);
/* the number of tiles that the traversal should go through */
idx_t ntiles = 1;
for(idx_t m2=0; m2 < nmodes; ++m2) {
if(m2 != m) {
ntiles *= data->dims[m2];
}
}
/* now ensure every idx in the mode sees that it is the end */
for(idx_t d=0; d < data->dims[m]; ++d) {
idx_t startid = get_next_tileid(TILE_BEGIN, data->dims, nmodes, m, d);
/* compute start id manually */
data->coords[m] = d;
idx_t const manual = get_tile_id(data->dims, nmodes, data->coords);
ASSERT_EQUAL(manual, startid);
/* Iterate over all tiles and also check last+1. Start from one because
* TILE_BEGIN has already happened. */
idx_t id = startid;
for(idx_t t=1; t < ntiles; ++t) {
id = get_next_tileid(id, data->dims, nmodes, m, d);
ASSERT_NOT_EQUAL(startid, id);
ASSERT_NOT_EQUAL(TILE_END, id);
}
id = get_next_tileid(id, data->dims, nmodes, m, d);
ASSERT_EQUAL(TILE_END, id);
}
}
}
void FileData::Seek(uint64_t pos)
{
ASSERT_NOT_EQUAL(m_Op, OP_APPEND, (m_FileName, m_Op, pos));
#ifdef OMIM_OS_TIZEN
result const error = m_File->Seek(Tizen::Io::FILESEEKPOSITION_BEGIN, pos);
if (IsFailed(error))
MYTHROW(Writer::SeekException, (m_FileName, m_Op, error, pos));
#else
if (fseek64(m_File, pos, SEEK_SET))
MYTHROW(Writer::SeekException, (GetErrorProlog(), pos));
#endif
}
void test_create_strategy(void **state)
{
(void)state;
(void)state;
void *tmp_strategy = NULL;
kaa_error_t error_code = ext_log_upload_strategy_create(&kaa_context, NULL,
KAA_LOG_UPLOAD_VOLUME_STRATEGY);
ASSERT_NOT_EQUAL(error_code, KAA_ERR_NONE);
error_code = ext_log_upload_strategy_create(NULL, &tmp_strategy, KAA_LOG_UPLOAD_VOLUME_STRATEGY);
ASSERT_NOT_EQUAL(error_code, KAA_ERR_NONE);
error_code = ext_log_upload_strategy_create(&kaa_context, &tmp_strategy, 0);
ASSERT_NOT_EQUAL(error_code, KAA_ERR_NONE);
error_code = ext_log_upload_strategy_create(&kaa_context, &tmp_strategy, KAA_LOG_UPLOAD_VOLUME_STRATEGY);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
ASSERT_NOT_NULL(tmp_strategy);
ext_log_upload_strategy_destroy(tmp_strategy);
}
void test_create_unlimited_storage(void)
{
KAA_TRACE_IN(logger);
kaa_error_t error_code;
void *storage;
error_code = ext_unlimited_log_storage_create(NULL, NULL);
ASSERT_NOT_EQUAL(error_code, KAA_ERR_NONE);
error_code = ext_unlimited_log_storage_create(&storage, NULL);
ASSERT_NOT_EQUAL(error_code, KAA_ERR_NONE);
error_code = ext_unlimited_log_storage_create(NULL, logger);
ASSERT_NOT_EQUAL(error_code, KAA_ERR_NONE);
error_code = ext_unlimited_log_storage_create(&storage, logger);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
ext_log_storage_destroy(storage);
KAA_TRACE_OUT(logger);
}
void test_create_limited_storage(void)
{
KAA_TRACE_IN(logger);
kaa_error_t error_code;
void *storage;
const size_t OVERFLOW_PERCENTAGE = 152;
const size_t ALLOWED_PERCENTAGE = 99;
const size_t ALL_LOGS_PERCENTAGE = 100;
error_code = ext_limited_log_storage_create(NULL, NULL, 0, 0);
ASSERT_NOT_EQUAL(error_code, KAA_ERR_NONE);
error_code = ext_limited_log_storage_create(&storage, NULL, 0, 0);
ASSERT_NOT_EQUAL(error_code, KAA_ERR_NONE);
error_code = ext_limited_log_storage_create(&storage, logger, 0, 0);
ASSERT_NOT_EQUAL(error_code, KAA_ERR_NONE);
error_code = ext_limited_log_storage_create(&storage, logger, SIZE_MAX, 0);
ASSERT_NOT_EQUAL(error_code, KAA_ERR_NONE);
error_code = ext_limited_log_storage_create(&storage, logger, SIZE_MAX, OVERFLOW_PERCENTAGE);
ASSERT_NOT_EQUAL(error_code, KAA_ERR_NONE);
error_code = ext_limited_log_storage_create(&storage, logger, 100, ALLOWED_PERCENTAGE);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
ext_log_storage_destroy(storage);
error_code = ext_limited_log_storage_create(&storage, logger, 100, ALL_LOGS_PERCENTAGE);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
ext_log_storage_destroy(storage);
KAA_TRACE_OUT(logger);
}
/**
* Test that lists can be created and items can be added and reference counting works.
*/
int test001_list( void ) {
struct MIDIList * list = MIDIListCreate( TestType );
ASSERT_NOT_EQUAL( list, NULL, "Could not create list!" );
ASSERT_NO_ERROR( MIDIListAdd( list, &_testitem ), "Could not add item." );
ASSERT_EQUAL( _testitem.refs, 2, "Item was not retained." );
ASSERT_NO_ERROR( MIDIListRemove( list, &_testitem ), "Could not add item." );
ASSERT_EQUAL( _testitem.refs, 1, "Item was not released." );
ASSERT_NO_ERROR( MIDIListAdd( list, &_testitem ), "Could not add item." );
ASSERT_EQUAL( _testitem.refs, 2, "Item was not retained." );
MIDIListRelease( list );
ASSERT_EQUAL( _testitem.refs, 1, "Item was not released on destruction." );
return 0;
}
void test_kaatcp_parser()
{
KAA_TRACE_IN(logger);
kaatcp_parser_handlers_t handlers = { NULL, &connack_listener, &disconnect_listener, &kaasync_listener, &ping_listener };
kaatcp_parser_t parser;
parser.payload_buffer_size = 1;
parser.payload = KAA_CALLOC(parser.payload_buffer_size, sizeof(char));
kaatcp_error_t rval = kaatcp_parser_init(&parser, &handlers);
ASSERT_EQUAL(rval, KAATCP_ERR_NONE);
char connack_and_ping_messages[] = { 0x20, 0x02, 0x00, 0x03, 0xD0, 0x00 };
rval = kaatcp_parser_process_buffer(&parser, connack_and_ping_messages, 6);
ASSERT_EQUAL(rval, KAATCP_ERR_NONE);
ASSERT_NOT_EQUAL(ping_received, 0);
ASSERT_NOT_EQUAL(connack_received, 0);
unsigned char kaa_sync_message[] = { 0xF0, 0x0D, 0x00, 0x06, 'K', 'a', 'a', 't', 'c', 'p', 0x01, 0x00, 0x05, 0x14, 0xFF };
rval = kaatcp_parser_process_buffer(&parser, (const char *)kaa_sync_message, 15);
ASSERT_EQUAL(rval, KAATCP_ERR_NONE);
ASSERT_NOT_EQUAL(kaasync_received, 0);
unsigned char disconnect_message[] = { 0xE0, 0x02, 0x00, 0x01 };
rval = kaatcp_parser_process_buffer(&parser, (const char *) disconnect_message, 4);
ASSERT_EQUAL(rval, KAATCP_ERR_NONE);
ASSERT_NOT_EQUAL(disconnect_received, 0);
KAA_FREE(parser.payload);
KAA_TRACE_OUT(logger);
}
void test_create_strategy(void)
{
KAA_TRACE_IN(logger);
kaa_error_t error_code = KAA_ERR_NONE;
void *tmp_strategy = NULL;
error_code = ext_log_upload_strategy_create(&kaa_context, NULL, KAA_LOG_UPLOAD_VOLUME_STRATEGY);
ASSERT_NOT_EQUAL(error_code, KAA_ERR_NONE);
error_code = ext_log_upload_strategy_create(NULL, &tmp_strategy, KAA_LOG_UPLOAD_VOLUME_STRATEGY);
ASSERT_NOT_EQUAL(error_code, KAA_ERR_NONE);
error_code = ext_log_upload_strategy_create(&kaa_context, &tmp_strategy, 0);
ASSERT_NOT_EQUAL(error_code, KAA_ERR_NONE);
error_code = ext_log_upload_strategy_create(&kaa_context, &tmp_strategy, KAA_LOG_UPLOAD_VOLUME_STRATEGY);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
ASSERT_NOT_NULL(tmp_strategy);
ext_log_upload_strategy_destroy(tmp_strategy);
KAA_TRACE_OUT(logger);
}
/**
* Test that apply functionality works.
*/
int test002_list( void ) {
int a, b, c;
int v = 123;
struct MIDIList * list = MIDIListCreate( TestType );
ASSERT_NOT_EQUAL( list, NULL, "Could not create list!" );
ASSERT_NO_ERROR( MIDIListAdd( list, &a ), "Could not add item." );
ASSERT_NO_ERROR( MIDIListAdd( list, &b ), "Could not add item." );
ASSERT_NO_ERROR( MIDIListAdd( list, &c ), "Could not add item." );
ASSERT_NO_ERROR( MIDIListApply( list, &v, &_apply_set ), "Could not apply set function." );
ASSERT_EQUAL( a, v, "Setter did not set list item a." );
ASSERT_EQUAL( b, v, "Setter did not set list item b." );
ASSERT_EQUAL( c, v, "Setter did not set list item c." );
MIDIListRelease( list );
return 0;
}
void kaasync_listener(void *context, kaatcp_kaasync_t *message)
{
kaasync_received = 1;
ASSERT_EQUAL(message->sync_header.protocol_name_length, 6);
ASSERT_EQUAL(strcmp(message->sync_header.protocol_name, "Kaatcp"), 0);
ASSERT_EQUAL(message->sync_header.protocol_version, PROTOCOL_VERSION);
ASSERT_EQUAL(message->sync_header.message_id, 5);
ASSERT_NOT_EQUAL((message->sync_header.flags & KAA_SYNC_ENCRYPTED_BIT), 0);
ASSERT_EQUAL((message->sync_header.flags & KAA_SYNC_ZIPPED_BIT), 0);
ASSERT_EQUAL((message->sync_header.flags & KAA_SYNC_REQUEST_BIT), 0);
ASSERT_EQUAL(message->sync_request_size, 1);
ASSERT_EQUAL((uint8_t)message->sync_request[0], 0xFF);
kaatcp_parser_kaasync_destroy(message);
}
/*
* Test get_tile_id on out of bounds values.
*/
CTEST2(tile_traverse, get_tile_id_oob)
{
idx_t const nmodes = MAX_NMODES;
for(idx_t m=0; m < nmodes; ++m) {
data->dims[m] = m+1;
data->coords[m] = m+1;
}
/* check out of bounds */
ASSERT_EQUAL(TILE_ERR, get_tile_id(data->dims, nmodes, data->coords));
for(idx_t m=0; m < nmodes; ++m) {
data->coords[m] = m;
}
ASSERT_NOT_EQUAL(TILE_ERR, get_tile_id(data->dims, nmodes, data->coords));
/* check each mode individually */
for(idx_t m=0; m < nmodes; ++m) {
++data->coords[m];
ASSERT_EQUAL(TILE_ERR, get_tile_id(data->dims, nmodes, data->coords));
--data->coords[m];
}
}
static int
test_date_to_time_to_date_utc_fails_on_leap_second(void)
{
glktimeval_t intermediate;
glkdate_t date;
glk_date_to_time_utc(&TEST_LEAPSEC_DATE, &intermediate);
glk_time_to_date_utc(&intermediate, &date);
ASSERT_EQUAL(TEST_LEAPSEC_YEAR, date.year);
ASSERT_NOT_EQUAL(TEST_LEAPSEC_MONTH, date.month);
ASSERT_NOT_EQUAL(TEST_LEAPSEC_DAY, date.day);
ASSERT_NOT_EQUAL(TEST_LEAPSEC_WEEKDAY, date.weekday);
ASSERT_NOT_EQUAL(TEST_LEAPSEC_HOUR, date.hour);
ASSERT_NOT_EQUAL(TEST_LEAPSEC_MINUTE, date.minute);
ASSERT_NOT_EQUAL(TEST_LEAPSEC_SECOND, date.second);
ASSERT_EQUAL(TEST_LEAPSEC_MICROSEC, date.microsec);
SUCCEED;
}
void test_distributed_strings(redis::client & c)
{
redis::distributed_string sh_str1("sh_str1", c);
test("not existing distributed_string");
{
// Check uninitialized/missing string
ASSERT_EQUAL(sh_str1.exists(), false);
ASSERT_EQUAL(sh_str1 == redis::client::missing_value(), true);
ASSERT_EQUAL(sh_str1 != "asdf", true);
}
test("empty distributed_string");
{
// Check initialized empty string
sh_str1 = "";
ASSERT_EQUAL(sh_str1.exists(), true);
ASSERT_EQUAL(sh_str1 == "", true);
ASSERT_EQUAL(sh_str1 != "asdf", true);
}
test("initialized distributed_string");
{
// Check initialized string
sh_str1 = "asdf";
ASSERT_EQUAL(sh_str1.exists(), true);
ASSERT_EQUAL(sh_str1 != redis::client::missing_value(), true);
ASSERT_EQUAL(sh_str1 != "", true);
ASSERT_EQUAL(sh_str1 == "asdf", true);
}
test("append to distributed_string");
{
sh_str1.append("123");
ASSERT_EQUAL(sh_str1 == "asdf123", true);
sh_str1 += "456";
ASSERT_EQUAL(sh_str1 == "asdf123456", true);
}
test("substr on distributed_string");
{
ASSERT_EQUAL(sh_str1.substr(0, 3), string("asdf"));
ASSERT_EQUAL(sh_str1.substr(4, 7), string("1234"));
}
string str1 = sh_str1;
ASSERT_EQUAL(str1, sh_str1.str());
sh_str1.del();
ASSERT_EQUAL(sh_str1.exists(), false);
ASSERT_EQUAL(sh_str1.setnx("asdf"), true);
ASSERT_EQUAL(sh_str1.setnx("asdf123"), false);
cerr << "Time to life of 'sh_str1': " << sh_str1.ttl() << endl;
ASSERT_EQUAL(sh_str1.ttl(), -1);
sh_str1.expire(100);
int ttl = sh_str1.ttl();
ASSERT_EQUAL(ttl > 0, true);
sleep(1);
ASSERT_EQUAL(ttl > sh_str1.ttl(), true);
ASSERT_EQUAL(sh_str1.type(), redis::client::datatype_string);
string oldVal = sh_str1.getset("asdf123");
ASSERT_EQUAL(oldVal, string("asdf"));
ASSERT_EQUAL(sh_str1.str(), string("asdf123"));
redis::distributed_string sh_str2("sh_str2", "asdf123", c);
ASSERT_EQUAL(sh_str1, sh_str2);
sh_str2 = "asdf123456";
ASSERT_NOT_EQUAL(sh_str1, sh_str2);
sh_str1 = sh_str2;
ASSERT_EQUAL(sh_str1, sh_str2);
}
CTEST(ctest, test_assert_not_equal) {
ASSERT_NOT_EQUAL(123, 456);
ASSERT_NOT_EQUAL(123, 123);
}
