void test_create_destroy_writer(void)
{
kaa_platform_message_writer_t *writer = NULL;
char buffer[16];
size_t buffer_size = sizeof(buffer) / sizeof(char);
kaa_error_t error_code = KAA_ERR_NONE;
error_code = kaa_platform_message_writer_create(NULL, buffer, buffer_size);
ASSERT_EQUAL(error_code, KAA_ERR_BADPARAM);
ASSERT_NULL(writer);
error_code = kaa_platform_message_writer_create(&writer, NULL, buffer_size);
ASSERT_EQUAL(error_code, KAA_ERR_BADPARAM);
ASSERT_NULL(writer);
error_code = kaa_platform_message_writer_create(&writer, buffer, 0);
ASSERT_EQUAL(error_code, KAA_ERR_BADPARAM);
ASSERT_NULL(writer);
error_code = kaa_platform_message_writer_create(&writer, buffer, buffer_size);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
ASSERT_NOT_NULL(writer);
ASSERT_EQUAL((writer->end - writer->begin), buffer_size);
ASSERT_EQUAL(writer->begin, writer->current);
kaa_platform_message_writer_destroy(writer);
}
static void test_string_move_create(void **state)
{
(void)state;
ASSERT_NULL(kaa_string_move_create(NULL, NULL));
const char *plain_test_str1 = "test";
kaa_string_t *kaa_str1 = kaa_string_move_create(plain_test_str1, NULL);
ASSERT_NOT_NULL(kaa_str1);
ASSERT_NOT_NULL(kaa_str1->data);
ASSERT_NULL(kaa_str1->destroy);
ASSERT_EQUAL(strcmp(kaa_str1->data, plain_test_str1), 0);
kaa_string_destroy(kaa_str1);
kaa_str1 = NULL;
char *plain_test_str2 = (char *)KAA_MALLOC(strlen(plain_test_str1) + 1);
ASSERT_NOT_NULL(plain_test_str2);
strcpy(plain_test_str2, plain_test_str1);
kaa_string_t *kaa_str2 = kaa_string_move_create(plain_test_str2, &kaa_data_destroy);
ASSERT_NOT_NULL(kaa_str2);
ASSERT_NOT_NULL(kaa_str2->data);
ASSERT_EQUAL(kaa_str2->destroy, &kaa_data_destroy);
ASSERT_EQUAL(strcmp(kaa_str2->data, plain_test_str1), 0);
kaa_string_destroy(kaa_str2);
}
BOOL ISprite::Load(const char *filename, ResourceManager *res, IMemoryPool *pool)
{
ASSERT_NULL(pool);
ASSERT_NULL(filename);
ASSERT_NULL(res);
if (this->Unload())
{
pFilename = filename;
pPool = pool;
pRes = res;
pSprite = static_cast<SpriteObject *>(res->Get(filename, Seed::ObjectSprite, pool));
this->SetRotation(0);
this->SetAnimation(0u);
bChanged = TRUE;
bInitialized = TRUE;
pAnimation = pSprite->GetAnimation(iCurrentAnimation);
pAnimationFrames = pSprite->GetFrames(pAnimation);
pFrame = &pAnimationFrames[iCurrentFrame];
}
return TRUE;
}
BOOL Texture::Load(const char *filename, ResourceManager *res, IMemoryPool *pool)
{
UNUSED(res);
UNUSED(pool);
ASSERT_NULL(res);
ASSERT_NULL(filename);
ASSERT_NULL(pool);
if (this->Unload())
{
image = QImage(filename);
if (image.isNull())
{
return FALSE;
}
image = image.convertToFormat(QImage::Format_ARGB32);
iWidth = image.width();
iHeight = image.height();
iAtlasWidth = iWidth;
iAtlasHeight = iHeight;
//iHalfWidth = iWidth >> 1;
//iHalfHeight = iHeight >> 1;
fWidth = (f32)iWidth / (f32)pScreen->GetWidth();
fHeight = (f32)iHeight / (f32)pScreen->GetHeight();
}
return TRUE;
}
PERIODIC_THREAD_END
void mon_init(void)
{
ASSERT_ONCE();
/* open monitoring socket: */
mon_socket = scl_get_socket("ap_mon");
ASSERT_NOT_NULL(mon_socket);
int64_t hwm = 1;
zmq_setsockopt(mon_socket, ZMQ_SNDHWM, &hwm, sizeof(hwm));
/* create monitoring connection: */
const struct timespec period = {0, 20 * NSEC_PER_MSEC};
pthread_mutexattr_init(&mutexattr);
pthread_mutexattr_setprotocol(&mutexattr, PTHREAD_PRIO_INHERIT);
pthread_mutex_init(&mutex, &mutexattr);
/* init msgpack buffer: */
ASSERT_NULL(msgpack_buf);
msgpack_buf = msgpack_sbuffer_new();
ASSERT_NOT_NULL(msgpack_buf);
ASSERT_NULL(pk);
pk = msgpack_packer_new(msgpack_buf, msgpack_sbuffer_write);
periodic_thread_start(&emitter_thread, mon_emitter, "mon_thread", THREAD_PRIORITY, period, NULL);
}
void StackTest::testPushPopTopSize()
{
adt::Stack<int> stack;
ASSERT_NULL(stack.top());
ASSERT_NULL(stack.pop());
ASSERT_EQUAL(static_cast<size_t>(0), stack.size());
size_t stackSizeToTest = adt::Stack<int>::DEFAULT_RESERVED_SIZE * 2 + 1;
for (int n = 1; static_cast<size_t>(n) <= stackSizeToTest; n++)
{
std::stringstream detail;
detail << "n: " << n;
stack.push(n);
ASSERT_EQUAL_DETAIL(static_cast<size_t>(n), stack.size(), detail);
}
for (int n = stackSizeToTest; static_cast<size_t>(n) > 0; n--)
{
std::stringstream detail;
detail << "n: " << n;
const int* lastTop = stack.pop();
ASSERT_NOT_NULL(lastTop);
if (lastTop)
{
ASSERT_EQUAL_DETAIL(n, *lastTop, detail);
}
}
ASSERT_NULL(stack.top());
ASSERT_NULL(stack.pop());
ASSERT_EQUAL(static_cast<size_t>(0), stack.size());
}
BOOL IFileSystem::Open(const char *fileName, File *file, IMemoryPool *pool)
{
ASSERT_NULL(fileName);
ASSERT_NULL(file);
ASSERT_NULL(pool);
BOOL ret = FALSE;
file->pName = NULL;
file->pData = NULL;
file->pPool = NULL;
file->iSize = 0;
file->bPackaged = FALSE;
if (pPackageManager->IsInitialized())
{
file->pData = pPackageManager->GetFile(fileName, &file->iSize);
if (file->pData)
{
ret = TRUE;
file->pName = fileName;
file->pPool = pool;
file->bPackaged = TRUE;
}
}
return ret;
}
void WidgetContainer::OnInputPointerMove(const EventInputPointer *ev)
{
ASSERT_NULL(ev);
WidgetIterator it = vWidget.begin();
WidgetIterator end = vWidget.end();
for (; it != end; ++it)
{
IWidget *w = (*it);
ASSERT_NULL(w);
bEventConsumed = FALSE;
if (w->IsDisabled())
continue;
if (w->GetObjectType() == Seed::ObjectGuiWidgetContainer)
{
WidgetContainer *wc = reinterpret_cast<WidgetContainer *>(w);
wc->OnInputPointerMove(ev);
bEventConsumed = wc->IsEventConsumed();
if (bEventConsumed)
break;
}
bEventConsumed = this->UpdateStates(ev, w);
//if (UpdateStates(ev, w))
if (bEventConsumed)
break;
}
}
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);
}
BOOL Font::Load(const char *filename, ResourceManager *res, IMemoryPool *pool)
{
ASSERT_NULL(filename);
ASSERT_NULL(res);
ASSERT_NULL(pool);
if (this->Unload())
{
this->pFilename = filename;
this->pRes = res;
this->pPool = pool;
stFile.Close();
SECURITY_CHECK(pFileSystem->Open(filename, &stFile, pool), "Could not open font file.");
const u8 *ptr = static_cast<const u8 *>(stFile.GetData());
ObjectHeader *block = NULL;
READ_STRUCT(block, ObjectHeader, ptr);
SECURITY_CHECK(seed_validate_block(&stFile, block, FONT_OBJECT_MAGIC, FONT_OBJECT_VERSION), "Invalid block header for font.");
READ_F32(this->fTracking, ptr);
READ_F32(this->fSpacing, ptr);
READ_F32(this->fSpaceWidth, ptr);
/*
const char *file = NULL;
READ_STR(file, ptr);
ASSERT_NULL(file);
const char *ext = NULL;
READ_STR(ext, ptr);
*/
u32 file = 0;
READ_U32(file, ptr);
u32 ext = 0;
READ_U32(ext, ptr);
if (ext != SEED_INVALID_ID /*&& pSystem->GetLanguage() != Seed::en_US*/)
{
File extf;
if (pFileSystem->Open(_F(ext), &extf, pool))
{
extf.Close();
this->mFontExt.Load(_F(ext), res, pool);
this->pGlyphs = pDictionary->GetGlyphTable(&this->iTotalGlyphs);
}
}
this->mFont.Load(_F(file), res, pool);
this->fHeight = mFont.GetHeight();
this->fWidth = mFont.GetWidth();
this->bLoaded = TRUE;
}
return bLoaded;
}
void TerrainEffectorPropertytest::test_none_found()
{
ASSERT_NULL(m_world->m_location.m_loc);
ASSERT_EQUAL(m_entity->m_location.m_loc, m_world);
const TerrainProperty * res = m_property->getTerrain(m_entity);
ASSERT_NULL(res);
}
void IInputJoystick::SendEventJoystickDPadMove(const EventInputJoystick *ev)
{
ASSERT_NULL(ev);
for (u32 i = 0; i < arJoystickListeners.Size(); i++)
{
ASSERT_NULL(arJoystickListeners[i]);
arJoystickListeners[i]->OnInputJoystickDPadMove(ev);
}
}
static void test_list_create()
{
kaa_list_t *list = kaa_list_create();
ASSERT_NOT_NULL(list);
ASSERT_EQUAL(kaa_list_get_size(list), 0);
ASSERT_NULL(kaa_list_begin(list));
ASSERT_NULL(kaa_list_back(list));
kaa_list_destroy(list, NULL);
}
CTEST2(tube, manager_getset_data)
{
tube_manager *mgr = data->mgr;
char mgr_data[] = "the manager data";
ASSERT_NULL( tube_manager_get_data(mgr) );
tube_manager_set_data(mgr, mgr_data);
ASSERT_TRUE( tube_manager_get_data(mgr)== mgr_data );
tube_manager_set_data(mgr, NULL);
ASSERT_NULL( tube_manager_get_data(mgr) );
}
CTEST(ls_htable, basics)
{
ls_htable* table;
ls_err err;
ASSERT_TRUE( ls_htable_create(7,
ls_str_hashcode,
ls_str_compare,
&table,
&err) );
ASSERT_EQUAL(ls_htable_get_count(table), 0);
ASSERT_NULL( ls_htable_get(table, "key1") );
ASSERT_NULL( ls_htable_get(table, "key2") );
pvalue = NULL;
ASSERT_TRUE( ls_htable_put(table, "key1", "value one",
test_htable_store_pvalue, &err) );
ASSERT_NULL(pvalue);
ASSERT_EQUAL(ls_htable_get_count(table), 1);
ASSERT_EQUAL(strcmp(ls_htable_get(table, "key1"), "value one"), 0);
ASSERT_NULL( ls_htable_get(table, "key2") );
ASSERT_TRUE( ls_htable_put(table, "key2", "value two",
test_htable_store_pvalue, &err) );
ASSERT_NULL(pvalue);
ASSERT_EQUAL(ls_htable_get_count(table), 2);
ASSERT_EQUAL(strcmp(ls_htable_get(table, "key1"), "value one"), 0);
ASSERT_EQUAL(strcmp(ls_htable_get(table, "key2"), "value two"), 0);
ASSERT_TRUE( ls_htable_put(table, "key1", "val 1", test_htable_store_pvalue,
&err) );
ASSERT_EQUAL(strcmp( (const char*)pvalue, "value one" ), 0);
ASSERT_EQUAL(ls_htable_get_count(table), 2);
ASSERT_EQUAL(strcmp(ls_htable_get(table, "key1"), "val 1"), 0);
ASSERT_EQUAL(strcmp(ls_htable_get(table, "key2"), "value two"), 0);
pvalue = NULL;
ls_htable_remove(table, "key1");
ASSERT_EQUAL(strcmp(pvalue, "val 1"), 0);
ASSERT_EQUAL(ls_htable_get_count(table), 1);
ASSERT_NULL( ls_htable_get(table, "key1") );
ASSERT_EQUAL(strcmp(ls_htable_get(table, "key2"), "value two"), 0);
pvalue = NULL;
ASSERT_TRUE( ls_htable_put(table, "key1", "first value",
test_htable_store_pvalue, &err) );
ASSERT_NULL(pvalue);
ASSERT_EQUAL(ls_htable_get_count(table), 2);
ASSERT_EQUAL(strcmp(ls_htable_get(table, "key1"), "first value"), 0);
ASSERT_EQUAL(strcmp(ls_htable_get(table, "key2"), "value two"), 0);
ls_htable_clear(table);
ASSERT_EQUAL(ls_htable_get_count(table), 0);
ASSERT_NULL( ls_htable_get(table, "key1") );
ASSERT_NULL( ls_htable_get(table, "key2") );
ls_htable_destroy(table);
}
void TerrainEffectorPropertytest::test_not_terrain()
{
ASSERT_NULL(m_world->m_location.m_loc);
ASSERT_EQUAL(m_entity->m_location.m_loc, m_world);
m_world->setProperty("terrain",
new Property<Atlas::Message::MapType>);
const TerrainProperty * res = m_property->getTerrain(m_entity);
ASSERT_NULL(res);
}
void SoundSource::Load(const char *filename, ResourceManager *res, IMemoryPool *pool)
{
ASSERT_NULL(filename);
ASSERT_NULL(pool);
ASSERT_NULL(res);
if (pSoundSystem->IsInitialized())
{
this->Unload();
/* Open file .sound */
SECURITY_CHECK(pFileSystem->Open(filename, &stFile, pool), "Sound object couldn't be opened");
const u8 *ptr = static_cast<const u8 *>(stFile.GetData());
ObjectHeader *block = NULL;
READ_STRUCT(block, ObjectHeader, ptr);
SECURITY_CHECK(seed_validate_block(&stFile, block, SOUND_OBJECT_MAGIC, SOUND_OBJECT_VERSION), "Invalid block header for sound.");
u32 volume = 0;
READ_U32(volume, ptr);
this->fVolume = volume / 100.0f;
u32 flags = 0;
READ_U32(flags, ptr);
this->bLoop = ((flags & 0x01) == 0x01); // FIXME
const char *fname = NULL;
READ_STR(fname, ptr);
ASSERT_NULL(fname);
/* Get the resource */
pSound = static_cast<Sound *>(res->Get(fname, Seed::ObjectSound, pool));
if (iSource)
alDeleteSources(1, &iSource);
ALenum err = alGetError();
alGenSources(1, &iSource);
err = alGetError();
if (err != AL_NO_ERROR)
Info(TAG "Could not create OpenAL Source: %4x", err);
const ALint *buffer = static_cast<const ALint *>(pSound->GetData());
alSourcef(iSource, AL_PITCH, 1.0f);
alSource3f(iSource, AL_POSITION, cPosition.x, cPosition.y, cPosition.z);
alSource3f(iSource, AL_VELOCITY, cVelocity.x, cVelocity.y, cVelocity.z);
alSourcei(iSource, AL_LOOPING, this->bLoop);
alSourcei(iSource, AL_BUFFER, *buffer);
this->SetVolume(this->fVolume);
}
}
INLINE void IFileSystem::SendEventFileSystemLoadCompleted(const EventFileSystem *ev)
{
ASSERT_NULL(ev);
ListenerIterator it = vListeners.begin();
ListenerIterator end = vListeners.end();
for (; it != end; ++it)
{
IEventFileSystemListener *target = (*it);
ASSERT_NULL(target);
target->OnFileSystemLoadCompleted(ev);
}
}
void test_list_create()
{
KAA_TRACE_IN(logger);
kaa_list_t *list = kaa_list_create();
ASSERT_NOT_NULL(list);
ASSERT_EQUAL(kaa_list_get_size(list), 0);
ASSERT_NULL(kaa_list_begin(list));
ASSERT_NULL(kaa_list_back(list));
kaa_list_destroy(list, NULL);
KAA_TRACE_OUT(logger);
}
static void test_parse_grammar(void)
{
struct cspeech_srgs_parser *parser;
parser = cspeech_srgs_parser_new("1234");
ASSERT_NOT_NULL(cspeech_srgs_parse(parser, adhearsion_ask_grammar));
ASSERT_NULL(cspeech_srgs_parse(parser, adhearsion_ask_grammar_bad));
ASSERT_NULL(cspeech_srgs_parse(parser, NULL));
ASSERT_NULL(cspeech_srgs_parse(NULL, adhearsion_ask_grammar));
ASSERT_NULL(cspeech_srgs_parse(NULL, adhearsion_ask_grammar_bad));
ASSERT_NULL(cspeech_srgs_parse(parser, bad_ref_grammar));
cspeech_srgs_parser_destroy(parser);
}
CTEST(txn, begin_with_no_parent)
{
int r;
struct txn *tx1;
struct txn *tx2;
struct txn *tx3;
struct txnmgr *tm = txnmgr_new();
LOGGER *logger = logger_new(NULL, tm);
/* transaction 1 */
r = txn_begin(NULL, logger, TXN_ISO_REPEATABLE, &tx1);
ASSERT_EQUAL(1, r);
ASSERT_EQUAL(0, tx1->txnid);
ASSERT_EQUAL(1, tm->live_root_txnids->used);
ASSERT_EQUAL(tx1->txnid, tm->live_root_txnids->txnids[0]);
/* transaction 2 */
r = txn_begin(NULL, logger, TXN_ISO_REPEATABLE, &tx2);
ASSERT_EQUAL(1, r);
ASSERT_EQUAL(1, tx2->txnid);
ASSERT_EQUAL(tx1->txnid, tx2->txnid_clone->txnids[0]);
ASSERT_EQUAL(tx2->txnid, tx2->txnid_clone->txnids[1]);
/* transaction 3 */
r = txn_begin(NULL, logger, TXN_ISO_SERIALIZABLE, &tx3);
ASSERT_EQUAL(1, r);
ASSERT_EQUAL(2, tx3->txnid);
ASSERT_NULL(tx3->txnid_clone);
logger_free(logger);
txnmgr_free(tm);
}
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_list_push_front()
{
KAA_TRACE_IN(logger);
kaa_list_t *list = kaa_list_create();
ASSERT_NOT_NULL(list);
int32_t *number;
int node_number = 2;
for (int i = 0; i < node_number; ++i) {
number = (int32_t *)KAA_MALLOC(sizeof(int32_t *));
ASSERT_NOT_NULL(number);
*number = rand();
kaa_list_push_front(list, number);
}
ASSERT_EQUAL(kaa_list_get_size(list), node_number);
ASSERT_NOT_NULL(kaa_list_begin(list));
ASSERT_NULL(kaa_list_prev(kaa_list_begin(list)));
ASSERT_EQUAL((*(int32_t *)kaa_list_get_data(kaa_list_begin(list))), *number);
kaa_list_destroy(list, NULL);
KAA_TRACE_OUT(logger);
}
static bool ZbiTestBasic(void) {
BEGIN_TEST;
uint8_t* test_zbi = get_test_zbi();
auto cleanup = fbl::MakeAutoCall([test_zbi]() {
free(test_zbi);
});
ASSERT_NONNULL(test_zbi, "failed to alloc test image");
zbi::Zbi image(test_zbi);
zbi_header_t* trace = nullptr;
ASSERT_EQ(image.Check(&trace), ZBI_RESULT_OK, "malformed image");
// zbi.Check should only give us diagnostics about the error if there was
// an error in the first place.
ASSERT_NULL(trace, "bad header set but image reported okay?");
int count = 0;
zbi_result_t result = image.ForEach(check_contents, &count);
ASSERT_EQ(result, ZBI_RESULT_OK, "content check failed");
ASSERT_EQ(count, 3, "bad bootdata item count");
END_TEST;
}
/**
* Test matching against adhearsion ask grammar
*/
static void test_match_adhearsion_ask_grammar(void)
{
struct cspeech_srgs_parser *parser;
struct cspeech_srgs_grammar *grammar;
char *interpretation;
parser = cspeech_srgs_parser_new("1234");
ASSERT_NOT_NULL((grammar = cspeech_srgs_parse(parser, adhearsion_ask_grammar)));
ASSERT_EQUALS(CSMT_MATCH_END, cspeech_srgs_grammar_match(grammar, "0", &interpretation));
ASSERT_NULL(interpretation);
ASSERT_EQUALS(CSMT_MATCH_END, cspeech_srgs_grammar_match(grammar, "1", &interpretation));
ASSERT_EQUALS(CSMT_MATCH_END, cspeech_srgs_grammar_match(grammar, "2", &interpretation));
ASSERT_EQUALS(CSMT_MATCH_END, cspeech_srgs_grammar_match(grammar, "3", &interpretation));
ASSERT_EQUALS(CSMT_MATCH_END, cspeech_srgs_grammar_match(grammar, "4", &interpretation));
ASSERT_EQUALS(CSMT_MATCH_END, cspeech_srgs_grammar_match(grammar, "5", &interpretation));
ASSERT_EQUALS(CSMT_MATCH_END, cspeech_srgs_grammar_match(grammar, "6", &interpretation));
ASSERT_EQUALS(CSMT_MATCH_END, cspeech_srgs_grammar_match(grammar, "7", &interpretation));
ASSERT_EQUALS(CSMT_MATCH_END, cspeech_srgs_grammar_match(grammar, "8", &interpretation));
ASSERT_EQUALS(CSMT_MATCH_END, cspeech_srgs_grammar_match(grammar, "9", &interpretation));
ASSERT_EQUALS(CSMT_MATCH_END, cspeech_srgs_grammar_match(grammar, "#", &interpretation));
ASSERT_EQUALS(CSMT_MATCH_END, cspeech_srgs_grammar_match(grammar, "*", &interpretation));
ASSERT_EQUALS(CSMT_NO_MATCH, cspeech_srgs_grammar_match(grammar, "A", &interpretation));
ASSERT_EQUALS(CSMT_NO_MATCH, cspeech_srgs_grammar_match(grammar, "27", &interpretation));
ASSERT_EQUALS(CSMT_NO_MATCH, cspeech_srgs_grammar_match(grammar, "223", &interpretation));
ASSERT_EQUALS(CSMT_NO_MATCH, cspeech_srgs_grammar_match(grammar, "0123456789*#", &interpretation));
cspeech_srgs_parser_destroy(parser);
}
/**
* Test signature generation
*/
static void test_signature(void)
{
char signature[S3_SIGNATURE_LENGTH_MAX];
signature[0] = '\0';
ASSERT_STRING_EQUALS("weGrLrc9HDlkYPTepVl0A9VYNlw=", aws_s3_signature(signature, S3_SIGNATURE_LENGTH_MAX, "GET\n\n\nFri, 17 May 2013 19:35:26 GMT\n/rienzo-vault/troporocks.mp3", "hOIZt1oeTX1JzINOMBoKf0BxONRZNQT1J8gIznLx"));
ASSERT_STRING_EQUALS("jZNOcbfWmD/A/f3hSvVzXZjM2HU=", aws_s3_signature(signature, S3_SIGNATURE_LENGTH_MAX, "PUT\nc8fdb181845a4ca6b8fec737b3581d76\ntext/html\nThu, 17 Nov 2005 18:49:58 GMT\nx-amz-magic:abracadabra\nx-amz-meta-author:[email protected]\n/quotes/nelson", "OtxrzxIsfpFjA7SwPzILwy8Bw21TLhquhboDYROV"));
ASSERT_STRING_EQUALS("5m+HAmc5JsrgyDelh9+a2dNrzN8=", aws_s3_signature(signature, S3_SIGNATURE_LENGTH_MAX, "GET\n\n\n\nx-amz-date:Thu, 17 Nov 2005 18:49:58 GMT\nx-amz-magic:abracadabra\n/quotes/nelson", "OtxrzxIsfpFjA7SwPzILwy8Bw21TLhquhboDYROV"));
ASSERT_STRING_EQUALS("OKA87rVp3c4kd59t8D3diFmTfuo=", aws_s3_signature(signature, S3_SIGNATURE_LENGTH_MAX, "", "OtxrzxIsfpFjA7SwPzILwy8Bw21TLhquhboDYROV"));
ASSERT_STRING_EQUALS("OKA87rVp3c4kd59t8D3diFmTfuo=", aws_s3_signature(signature, S3_SIGNATURE_LENGTH_MAX, NULL, "OtxrzxIsfpFjA7SwPzILwy8Bw21TLhquhboDYROV"));
ASSERT_NULL(aws_s3_signature(signature, S3_SIGNATURE_LENGTH_MAX, "GET\n\n\n\nx-amz-date:Thu, 17 Nov 2005 18:49:58 GMT\nx-amz-magic:abracadabra\n/quotes/nelson", ""));
ASSERT_NULL(aws_s3_signature(signature, S3_SIGNATURE_LENGTH_MAX, "", ""));
ASSERT_NULL(aws_s3_signature(signature, S3_SIGNATURE_LENGTH_MAX, NULL, NULL));
ASSERT_NULL(aws_s3_signature(NULL, S3_SIGNATURE_LENGTH_MAX, "PUT\nc8fdb181845a4ca6b8fec737b3581d76\ntext/html\nThu, 17 Nov 2005 18:49:58 GMT\nx-amz-magic:abracadabra\nx-amz-meta-author:[email protected]\n/quotes/nelson", "OtxrzxIsfpFjA7SwPzILwy8Bw21TLhquhboDYROV"));
ASSERT_NULL(aws_s3_signature(signature, 0, "PUT\nc8fdb181845a4ca6b8fec737b3581d76\ntext/html\nThu, 17 Nov 2005 18:49:58 GMT\nx-amz-magic:abracadabra\nx-amz-meta-author:[email protected]\n/quotes/nelson", "OtxrzxIsfpFjA7SwPzILwy8Bw21TLhquhboDYROV"));
ASSERT_STRING_EQUALS("jZNO", aws_s3_signature(signature, 5, "PUT\nc8fdb181845a4ca6b8fec737b3581d76\ntext/html\nThu, 17 Nov 2005 18:49:58 GMT\nx-amz-magic:abracadabra\nx-amz-meta-author:[email protected]\n/quotes/nelson", "OtxrzxIsfpFjA7SwPzILwy8Bw21TLhquhboDYROV"));
}
CTEST(ls_timer, basic)
{
struct timeval small = {100, 100};
struct timeval now;
struct timeval *then;
struct timeval diff;
ls_timer *past;
ls_timer *soon;
ls_err err;
ASSERT_TRUE(ls_timer_create(&small, timer_cb, NULL, &past, &err));
ASSERT_FALSE(gettimeofday(&now, NULL));
ASSERT_TRUE(ls_timer_create_ms(&now, 100, timer_cb, &err, &soon, &err));
then = ls_timer_get_time(soon);
timersub(then,&now,&diff);
ASSERT_EQUAL(100000, diff.tv_usec);
ASSERT_EQUAL(0, diff.tv_sec);
ASSERT_TRUE(ls_timer_get_context(soon) == &err);
ls_timer_exec(soon);
ASSERT_TRUE(ls_timer_less(past, soon));
ASSERT_FALSE(ls_timer_greater(past, soon));
ASSERT_TRUE(ls_timer_greater_tv(soon, &now));
ASSERT_FALSE(ls_timer_is_cancelled(past));
ls_timer_cancel(past);
ASSERT_TRUE(ls_timer_is_cancelled(past));
ASSERT_NULL(ls_timer_get_time(past));
ls_timer_destroy(past);
ls_timer_destroy(soon);
}
INLINE void IWidget::SendOnReleaseOut(const EventWidget *ev)
{
ASSERT_NULL(ev);
IEventWidgetListenerIterator it = vListener.begin();
IEventWidgetListenerIterator end = vListener.end();
for (; it != end; ++it)
{
IEventWidgetListener *obj = (*it);
ASSERT_NULL(obj);
obj->OnWidgetReleaseOut(ev);
if (ev->IsConsumed())
break;
}
}
BOOL FileSystem::Open(const char *fname, File *file, IMemoryPool *pool)
{
ASSERT_NULL(fname);
ASSERT_NULL(file);
ASSERT_NULL(pool);
BOOL ret = FALSE;
FILE *fp = fopen(fname, "rb");
if (fp)
{
fseek(fp, 0L, SEEK_END);
this->iLastLength = ftell(fp);
fseek(fp, 0L, SEEK_SET);
if (iLastLength)
{
void *buff = pMemoryManager->Alloc(this->iLastLength, pDefaultPool, "File", "FileSystem");
ASSERT_NULL(buff);
u32 total = fread(buff, 1, this->iLastLength, fp);
fclose(fp);
if (total != this->iLastLength)
{
Log(TAG "WARNING: fread bytes read mismatch (diff: %d).", iLastLength - total);
Log(TAG "WARNING: %s.", fname);
}
file->iSize = this->iLastLength;
file->pData = buff;
file->pPool = pool;
ret = TRUE;
}
else
{
Log(TAG "WARNING: Empty existing file: %s.", fname);
}
}
else
{
Log(TAG "WARNING: Could not find %s file.", fname);
}
return ret;
}
/* Init */
CTEST(buffer, init) {
http2d_buffer_t buf;
ASSERT_RET_OK (http2d_buffer_init (&buf));
ASSERT_EQUAL (0, buf.len);
ASSERT_EQUAL (0, buf.size);
ASSERT_NULL (buf.buf);
}
