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

void VerifySticker::runTest(){    QProcess avrdude;    emit testMessage(testName(), infoMessage, stickerNum,             QString("Verifying sticker ") + QString::number(stickerNum));    selectSticker(stickerNum);    avrdude.start("./avrdude", QStringList()            << "-C" << configFile            << "-c" << "linuxgpio"            << "-P" << "linuxgpio"            << "-p" << partName            << "-U" << (QString("flash:v:") + firmwareFile)    );    if (!avrdude.waitForStarted()) {        testError("Unable to start avrdude");        return;    }    avrdude.closeWriteChannel();    if (!avrdude.waitForFinished()) {        testError("avrdude never finished");        return;    }    if (avrdude.exitCode()) {        testError(QString("Failed to verify"));        return;    }    emit testMessage(testName(), testPass, stickerNum, "Test passed");}

static voidtestGetType(    PKIX_PL_Object *obj,    PKIX_PL_Object *obj2,    PKIX_PL_Object *obj3){    PKIX_UInt32 testType;    PKIX_TEST_STD_VARS();    PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Object_GetType(obj, &testType, plContext));    if (testType != 1000)        testError("Object 1 returned the wrong type");    PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Object_GetType(obj2, &testType, plContext));    if (testType != 2000)        testError("Object 2 returned the wrong type");    PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Object_GetType(obj3, &testType, plContext));    if (testType != 1000)        testError("Object 3 returned the wrong type");cleanup:    PKIX_TEST_RETURN();}

static voidtestCompare(    PKIX_PL_Object *obj2,    PKIX_PL_Object *obj4){    PKIX_Int32 cmpResult;    PKIX_TEST_STD_VARS();    *(char *)obj2 = 0x20;    *(char *)obj4 = 0x10;    PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Object_Compare(obj2, obj4, &cmpResult, plContext));    if (cmpResult <= 0)        testError("Invalid Result from Object Compare");    PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Object_Compare(obj4, obj2, &cmpResult, plContext));    if (cmpResult >= 0)        testError("Invalid Result from Object Compare");    PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Object_Compare(obj4, obj4, &cmpResult, plContext));    *(char *)obj2 = 0x10;    if (cmpResult != 0)        testError("Invalid Result from Object Compare");cleanup:    PKIX_TEST_RETURN();}

int ProgramSenoko::prepGPIO(void){    QFile exportFile("/sys/class/gpio/export");    if (!exportFile.open(QIODevice::WriteOnly)) {        testError(QString() + "Unable to open GPIO export file: " + exportFile.errorString());        return 1;    }    exportFile.write("149");    exportFile.close();    QFile directionFile("/sys/class/gpio/gpio149/direction");    if (!directionFile.open(QIODevice::WriteOnly)) {        testError(QString() + "Unable to open GPIO149 direction file: " + directionFile.errorString());        return 1;    }    directionFile.write("out/n");    directionFile.close();    QFile valueFile("/sys/class/gpio/gpio149/value");    if (!valueFile.open(QIODevice::WriteOnly)) {        testError(QString() + "Unable to open GPIO149 value file: " + valueFile.errorString());        return 1;    }    valueFile.write("0/n");    valueFile.close();    return 0;}

static voidtestMaxLoggingLevel(PKIX_Logger *logger){        PKIX_UInt32 level = 0;        PKIX_TEST_STD_VARS();        subTest("PKIX_Logger_GetMaxLoggingLevel");        PKIX_TEST_EXPECT_NO_ERROR(PKIX_Logger_GetMaxLoggingLevel                (logger, &level, plContext));        if (level != 0) {                testError("Incorrect Logger MaxLoggingLevel returned");        }        subTest("PKIX_Logger_SetMaxLoggingLevel");        PKIX_TEST_EXPECT_NO_ERROR(PKIX_Logger_SetMaxLoggingLevel                (logger, 3, plContext));        subTest("PKIX_Logger_GetMaxLoggingLevel");        PKIX_TEST_EXPECT_NO_ERROR(PKIX_Logger_GetMaxLoggingLevel                (logger, &level, plContext));        if (level != 3) {                testError("Incorrect Logger MaxLoggingLevel returned");        }cleanup:        PKIX_TEST_RETURN();}

void read_map_t(char *name, peak_param *peak, map_t *kMap, mapType_t type, error **err){  testError(kMap->length!=peak->resol[0]*peak->resol[1], peak_match, "Resolution match error", *err, __LINE__); forwardError(*err, __LINE__,);  FILE *file = fopen_err(name, "r", err); forwardError(*err, __LINE__,);    char buffer[STRING_LENGTH_MAX], *buffer1;  int buffer2, count = 0;  double *kappa = kMap->kappa;    //-- Read  int c = fgetc(file);  while (c != EOF) {    if (c == (int)'#') buffer1 = fgets(buffer, STRING_LENGTH_MAX, file);    else {      testError(count>=kMap->length, peak_overflow, "Too many pixels", *err, __LINE__); forwardError(*err, __LINE__,);      ungetc(c, file);      buffer2 = fscanf(file, "%*f %*f %lf/n", &kappa[count]);      count++;    }    c = fgetc(file);  }  fclose(file);    //-- Length check  testError(count!=kMap->length, peak_match, "Array length error", *err, __LINE__); forwardError(*err, __LINE__,);  kMap->type = type;  printf("/"%s/" read/n", name);  return;}

static voidtestComponent(PKIX_Logger *logger){        PKIX_ERRORCLASS compName = (PKIX_ERRORCLASS)NULL;        PKIX_ERRORCLASS compNameReturn = (PKIX_ERRORCLASS)NULL;        PKIX_Boolean cmpResult = PKIX_FALSE;        PKIX_TEST_STD_VARS();        subTest("PKIX_Logger_GetLoggingComponent");        PKIX_TEST_EXPECT_NO_ERROR(PKIX_Logger_GetLoggingComponent                (logger, &compName, plContext));        if (compName != (PKIX_ERRORCLASS)NULL) {                testError("Incorrect Logger Component returned. expect <NULL>");        }        subTest("PKIX_Logger_SetLoggingComponent");        PKIX_TEST_EXPECT_NO_ERROR(PKIX_Logger_SetLoggingComponent                (logger, PKIX_LIST_ERROR, plContext));        subTest("PKIX_Logger_GetLoggingComponent");        PKIX_TEST_EXPECT_NO_ERROR(PKIX_Logger_GetLoggingComponent                (logger, &compNameReturn, plContext));        if (compNameReturn != PKIX_LIST_ERROR) {                testError("Incorrect Logger Component returned.");        }cleanup:        PKIX_TEST_RETURN();}

void SetStickerFuse::runTest(){    QProcess avrdude;    emit testMessage(testName(), infoMessage, stickerNum,             QString("Setting fuse ") + fuseName             + " to 0x" + QString::number(fuseValue, 16));    selectSticker(stickerNum);    avrdude.start("./avrdude", QStringList()            << "-C" << configFile            << "-c" << "linuxgpio"            << "-P" << "linuxgpio"            << "-p" << partName            << "-U" << (QString()                   + fuseName + ":w:0x" + QString::number(fuseValue, 16) + ":m")    );    if (!avrdude.waitForStarted()) {        testError("Unable to start avrdude");        return;    }    avrdude.closeWriteChannel();    if (!avrdude.waitForFinished()) {        testError("avrdude never finished");        return;    }    if (avrdude.exitCode()) {        testError(QString("avrdude returned an error: ") + avrdude.readAll());        return;    }}

/* * Compare two CSSM_DATEs. Returns nonzero on error.  */static int compareDates(	const CSSM_DATE *refDate,		// what we tried to set, or NULL	const CSSM_DATE *keyDate,	const char *op,	CSSM_BOOL quiet){	if(refDate == NULL) {		/* make sure key date is empty */		bool isZero = true;		unsigned char *cp = (unsigned char *)keyDate;		for(unsigned i=0; i<sizeof(CSSM_DATE); i++) {			if(*cp++ != 0) {				isZero = false;				break;			}		}		if(!isZero) {			printf("%s: refDate NULL, non-empty keyDate/n", op);			return testError(quiet);		}		else {			return 0;		}	}	if(memcmp(refDate, keyDate, sizeof(CSSM_DATE))) {		printf("%s: refDate/keyDate MISCOMPARE/n", op);		return testError(quiet);	}	else {		return 0;	}}

static voidtest_KeyUsages(void){    PKIX_ComCertSelParams *goodParams = NULL;    PKIX_PL_OID *ekuOid = NULL;    PKIX_List *setExtKeyUsage = NULL;    PKIX_List *getExtKeyUsage = NULL;    PKIX_UInt32 getKeyUsage = 0;    PKIX_UInt32 setKeyUsage = 0x1FF;    PKIX_Boolean isEqual = PKIX_FALSE;    PKIX_TEST_STD_VARS();    subTest("PKIX_ComCertSelParams_Create");    PKIX_TEST_EXPECT_NO_ERROR(PKIX_ComCertSelParams_Create(&goodParams, plContext));    subTest("PKIX_ComCertSelParams_SetKeyUsage");    PKIX_TEST_EXPECT_NO_ERROR(PKIX_ComCertSelParams_SetKeyUsage(goodParams, setKeyUsage, plContext));    subTest("PKIX_ComCertSelParams_GetKeyUsage");    PKIX_TEST_EXPECT_NO_ERROR(PKIX_ComCertSelParams_GetKeyUsage(goodParams, &getKeyUsage, plContext));    if (setKeyUsage != getKeyUsage) {        testError("unexpected KeyUsage mismatch <expect equal>");    }    subTest("PKIX_PL_OID List create and append");    PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_Create(&setExtKeyUsage, plContext));    PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_OID_Create("1.3.6.1.5.5.7.3.1", &ekuOid, plContext));    PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_AppendItem(setExtKeyUsage, (PKIX_PL_Object *)ekuOid, plContext));    PKIX_TEST_DECREF_BC(ekuOid);    PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_OID_Create("1.3.6.1.5.5.7.3.8", &ekuOid, plContext));    PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_AppendItem(setExtKeyUsage, (PKIX_PL_Object *)ekuOid, plContext));    PKIX_TEST_DECREF_BC(ekuOid);    subTest("PKIX_ComCertSelParams_SetExtendedKeyUsage");    PKIX_TEST_EXPECT_NO_ERROR(PKIX_ComCertSelParams_SetExtendedKeyUsage(goodParams, setExtKeyUsage, plContext));    subTest("PKIX_ComCertSelParams_GetExtendedKeyUsage");    PKIX_TEST_EXPECT_NO_ERROR(PKIX_ComCertSelParams_GetExtendedKeyUsage(goodParams, &getExtKeyUsage, plContext));    PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Object_Equals((PKIX_PL_Object *)setExtKeyUsage,                                                    (PKIX_PL_Object *)getExtKeyUsage,                                                    &isEqual,                                                    plContext));    if (isEqual == PKIX_FALSE) {        testError("unexpected ExtKeyUsage mismatch <expect equal>");    }cleanup:    PKIX_TEST_DECREF_AC(ekuOid);    PKIX_TEST_DECREF_AC(setExtKeyUsage);    PKIX_TEST_DECREF_AC(getExtKeyUsage);    PKIX_TEST_DECREF_AC(goodParams);    PKIX_TEST_RETURN();}

	//TODO: make it robust	Playback::Playback(const string &file_name, float volume) :m_file_name(file_name) {		DASSERT(isInitialized());		memset(m_buffer_ids, 0, sizeof(m_buffer_ids));		m_source_id = 0;		try {			alGetError();			alGenBuffers(max_buffers, (ALuint*)m_buffer_ids);			testError("Error while creating buffers for music playback.");			alGenSources(1, (ALuint*)&m_source_id);			testError("Error while creating source for music playback.");					m_decoder.reset(new MP3Decoder(m_file_name));			for(int n = 0; n < max_buffers; n++)				feedMoreData(m_buffer_ids[n]);			alSource3f(m_source_id, AL_POSITION,		0.0f, 0.0f, 0.0f);			alSource3f(m_source_id, AL_VELOCITY,		0.0f, 0.0f, 0.0f);			alSource3f(m_source_id, AL_DIRECTION,		0.0f, 0.0f, 0.0f);			alSourcef (m_source_id, AL_ROLLOFF_FACTOR,	0.0f);			alSourcei (m_source_id, AL_SOURCE_RELATIVE, AL_TRUE);						alSourcePlay(m_source_id);			m_mode = mode_playing;		}		catch(...) {			free();			throw;		}	}

void addNoise(map_t *kMap, map_t *nMap, error **err){  testError(kMap->N1!=nMap->N1, peak_match, "Map size error", *err, __LINE__); forwardError(*err, __LINE__,);  testError(kMap->N2!=nMap->N2, peak_match, "Map size error", *err, __LINE__); forwardError(*err, __LINE__,);  testError(!((kMap->type==kappa_map && nMap->type==noise_map) || (kMap->type==K_map && nMap->type==N_map)), peak_mapType, "Map type error", *err, __LINE__); forwardError(*err, __LINE__,);    int i;  for (i=0; i<kMap->length; i++) kMap->kappa[i] += nMap->kappa[i];  if (kMap->type==kappa_map) kMap->type = kn_map;  else                       kMap->type = KN_map;  return;}

/* * Common, flexible, error-tolerant symmetric key generator. */static int genSymKey(	CSSM_CSP_HANDLE 	cspHand,	CSSM_KEY_PTR		symKey,	uint32 				alg,	const char			*keyAlgStr,	uint32 				keySizeInBits,	CSSM_KEYATTR_FLAGS	keyAttr,	CSSM_KEYUSE			keyUsage,	CSSM_RETURN			expectRtn,	CSSM_BOOL			quiet,	CSSM_BOOL 			freeKey,			// true: free the key on exit	const char			*testStr){	CSSM_RETURN			crtn;	CSSM_CC_HANDLE 		ccHand;	CSSM_DATA			dummyLabel = {4, (uint8 *)"foo"};	int					irtn;		memset(symKey, 0, sizeof(CSSM_KEY));	crtn = CSSM_CSP_CreateKeyGenContext(cspHand,		alg,		keySizeInBits,	// keySizeInBits		NULL,			// Seed		NULL,			// Salt		NULL,			// StartDate		NULL,			// EndDate		NULL,			// Params		&ccHand);	if(crtn) {		printError("CSSM_CSP_CreateKeyGenContext", crtn);		return testError(quiet);	}	crtn = CSSM_GenerateKey(ccHand,		keyUsage,		keyAttr,		&dummyLabel,		NULL,			// ACL		symKey);	if(crtn != expectRtn) {		printf("***Testing %s for alg %s:/n", testStr, keyAlgStr);		printf("   CSSM_GenerateKey: expect %s/n",	cssmErrToStr(expectRtn));		printf("   CSSM_GenerateKey: got    %s/n",  cssmErrToStr(crtn));		irtn = testError(quiet);	}	else {		irtn = 0;	}	CSSM_DeleteContext(ccHand);	if(freeKey && (crtn == CSSM_OK)) {		cspFreeKey(cspHand, symKey);	}	return irtn;}

static int doVerify(	CSSM_CSP_HANDLE	cspHand,	const char *algStr,	CSSM_KEY_PTR key,			// private	CSSM_ALGORITHMS sigAlg,	CSSM_RETURN expRtn,			// expected result	CSSM_BOOL quiet){	uint8 ptextData[PTEXT_SIZE];	CSSM_DATA ptext = {PTEXT_SIZE, ptextData};	uint8 sigData[PTEXT_SIZE];	CSSM_DATA sig = {PTEXT_SIZE, sigData};		simpleGenData(&ptext, PTEXT_SIZE, PTEXT_SIZE);	memset(sigData, 0, PTEXT_SIZE);		CSSM_CC_HANDLE cryptHand = 0;	CSSM_RETURN crtn;		crtn = CSSM_CSP_CreateSignatureContext(cspHand,		sigAlg,		NULL,				// passPhrase		key,		&cryptHand);	if(crtn) {		printError("CSSM_CSP_CreateSignatureContext (2)", crtn);		return testError(quiet);	}	int irtn = 0;	crtn = CSSM_VerifyData(cryptHand,		&ptext,		1,		CSSM_ALGID_NONE,		&sig);	if(crtn != expRtn) {		if(expRtn == CSSM_OK) {			printError("CSSM_VerifyData", crtn);			printf("Unexpected error verifying with %s/n", algStr);		}		else {			printf("***Verify with %s: expected %s, got %s./n",				algStr, cssmErrToStr(expRtn),				cssmErrToStr(crtn));		}		irtn = testError(quiet);	}	CSSM_DeleteContext(cryptHand);	return irtn;}

static voidtestContextCallback(PKIX_Logger *logger, PKIX_Logger *logger2){        PKIX_Logger_LogCallback cb = NULL;        PKIX_PL_Object *context = NULL;        PKIX_Boolean cmpResult = PKIX_FALSE;        PKIX_UInt32 length;        PKIX_TEST_STD_VARS();        subTest("PKIX_Logger_GetLoggerContext");        PKIX_TEST_EXPECT_NO_ERROR(PKIX_Logger_GetLoggerContext                (logger2, &context, plContext));        testEqualsHelper                ((PKIX_PL_Object *)logger, context, PKIX_TRUE, plContext);        subTest("PKIX_Logger_GetLogCallback");        PKIX_TEST_EXPECT_NO_ERROR(PKIX_Logger_GetLogCallback                (logger, &cb, plContext));        if (cb != testLoggerCallback) {                testError("Incorrect Logger Callback returned");        }cleanup:        PKIX_TEST_DECREF_AC(context);        PKIX_TEST_RETURN();}

staticvoid testRealloc(PKIX_UInt32 **array){        PKIX_UInt32 i, arraySize = 20;        PKIX_TEST_STD_VARS();        PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Realloc(*array,                            (PKIX_UInt32)(arraySize*sizeof (unsigned int)),                            (void **) array, plContext));        /* Fill in the new elements */        (void) printf ("Setting new portion of array to a[i] = i.../n");        for (i = arraySize/2; i < arraySize; i++) {                (*array)[i] = i;                if ((*array)[i] != i)                        testError("Array has incorrect contents");        }        /* New elements should be reflected. The old should be the same */        (void) printf("/tArray: a[0] = %d, a[15] = %d, a[17] = %d./n",                      (*array)[0], (*array)[15], (*array)[17]);cleanup:        PKIX_TEST_RETURN();}

staticPKIX_Error *testLoggerCallback(        PKIX_Logger *logger,        PKIX_PL_String *message,        PKIX_UInt32 logLevel,        PKIX_ERRORCLASS logComponent,        void *plContext){        char *comp = NULL;        char *msg = NULL;        char result[100];        static int callCount = 0;        PKIX_TEST_STD_VARS();        msg = PKIX_String2ASCII(message, plContext);        PR_snprintf(result, 100, "Logging %s (%s): %s",                levels[logLevel], PKIX_ERRORCLASSNAMES[logComponent], msg);        subTest(result);        callCount++;        if (callCount > 1) {                testError("Incorrect number of Logger Callback <expect 1>");        }cleanup:        PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Free(msg, plContext));        PKIX_TEST_RETURN();}

static void test_GetDepth(        PKIX_PolicyNode *depth1Node,        PKIX_PolicyNode *depth2Node,        PKIX_PolicyNode *depth3Node){        PKIX_UInt32 depth1 = 0;        PKIX_UInt32 depth2 = 0;        PKIX_UInt32 depth3 = 0;        PKIX_TEST_STD_VARS();        subTest("PKIX_PolicyNode_GetDepth");        PKIX_TEST_EXPECT_NO_ERROR(PKIX_PolicyNode_GetDepth                (depth1Node, &depth1, plContext));        PKIX_TEST_EXPECT_NO_ERROR(PKIX_PolicyNode_GetDepth                (depth2Node, &depth2, plContext));        PKIX_TEST_EXPECT_NO_ERROR(PKIX_PolicyNode_GetDepth                (depth3Node, &depth3, plContext));        if ((depth1 != 1) || (depth2 != 2) || (depth3 != 3)) {                testError("GetDepth returned unexpected value");        }cleanup:        PKIX_TEST_RETURN();}

static void test_IsCritical(        PKIX_PolicyNode *goodNode,        PKIX_PolicyNode *equalNode,        PKIX_PolicyNode *diffNode){        PKIX_Boolean goodBool = PKIX_FALSE;        PKIX_Boolean equalBool = PKIX_FALSE;        PKIX_Boolean diffBool = PKIX_FALSE;        PKIX_TEST_STD_VARS();        subTest("PKIX_PolicyNode_IsCritical");        PKIX_TEST_EXPECT_NO_ERROR(PKIX_PolicyNode_IsCritical                (goodNode, &goodBool, plContext));        PKIX_TEST_EXPECT_NO_ERROR(PKIX_PolicyNode_IsCritical                (equalNode, &equalBool, plContext));        PKIX_TEST_EXPECT_NO_ERROR(PKIX_PolicyNode_IsCritical                (diffNode, &diffBool, plContext));        if ((!goodBool) || (!equalBool) || (diffBool)) {                testError("IsCritical returned unexpected value");        }cleanup:        PKIX_TEST_RETURN();}

void doFFTSmoothing(peak_param *peak, map_t *kMap, FFT_t *transformer, error **err){  testError((kMap->type!=kappa_map && kMap->type!=noise_map && kMap->type!=kn_map), peak_mapType, "Map type error", *err, __LINE__); forwardError(*err, __LINE__,);  reset_FFT_t(transformer);    int M1 = transformer->N1;  int N1 = kMap->N1;  int N2 = kMap->N2;    //-- Fill transformer->before and add zero-padding  int i, j;  for (i=0; i<N1; i++) {    for (j=0; j<N2; j++) {      transformer->before[i+j*M1] = kMap->kappa[i+j*N1];    }  }    execute_FFT_t(transformer);    //-- Retrieve values from transformer->after, set to smoothed->kappa  for (i=0; i<N1; i++) {    for (j=0; j<N2; j++) {      kMap->kappa[i+j*N1] = transformer->after[i+j*M1];    }  }    if (kMap->type == kappa_map)      kMap->type = K_map;  else if (kMap->type == noise_map) kMap->type = N_map;  else                              kMap->type = KN_map;    if (peak->printMode != 1) printf("Smoothing with FFT done/n");  return;}

staticvoid testMalloc(PKIX_UInt32 **array){        PKIX_UInt32 i, arraySize = 10;        PKIX_TEST_STD_VARS();        /* Create an integer array of size 10 */        PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Malloc(                            (PKIX_UInt32)(arraySize*sizeof (unsigned int)),                            (void **) array, plContext));        /* Fill in some values */        (void) printf ("Setting array[i] = i.../n");        for (i = 0; i < arraySize; i++) {                (*array)[i] = i;                if ((*array)[i] != i)                        testError("Array has incorrect contents");        }        /* Memory now reflects changes */        (void) printf("/tArray: a[0] = %d, a[5] = %d, a[7] = %d./n",                    (*array[0]), (*array)[5], (*array)[7]);cleanup:        PKIX_TEST_RETURN();}

/** * @brief   Configure video format emitted by encoder output port. * @author  Tuomas Jormola * Copyright 
C++ testFileUrl函数代码示例
C++ testDataFromFile函数代码示例