自学教程：C++ ASSERT_NULL函数代码示例

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

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
C++ ASSERT_OK函数代码示例
C++ ASSERT_NO_THROW函数代码示例