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); }