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

void test_evaluatePrefixesAndNumber_should_stop_the_loop_after_encounter_a_number(void){	CEXCEPTION_T e;	Stack *numberStack=createStack();	Stack *operatorStack=createStack();	Text *newText=textNew("-+-20+");	String *tokenizer = stringNew(newText);	//printf("Test evaluatePrefix should stop the loop after encounter number/n");		Token *token=getToken(tokenizer);	evaluatePrefixesAndNumber(tokenizer,token,numberStack,operatorStack);	TEST_ASSERT_NOT_NULL(token);	TEST_ASSERT_EQUAL_OPERATOR(MINUS_OP,stackPop(operatorStack));	TEST_ASSERT_EQUAL_OPERATOR(PLUS_OP,stackPop(operatorStack));	TEST_ASSERT_EQUAL_OPERATOR(MINUS_OP,stackPop(operatorStack));	TEST_ASSERT_EQUAL_NUMBER(20,stackPop(numberStack));}

void test_FA_extract1bitsACCESSBANKED_should_throw_error(void){	int value;	int e;		Text *text = textNew("135");	String *str = stringNew(text);		extractACCESSBANKED_ExpectAndThrow(str, 2);	Try{		value = extract1bitsACCESSBANKED(str, 0x123);	}Catch(e){		TEST_ASSERT_EQUAL(ERR_ILLEGAL_ARGUMENT, e);			}}

void test_evaluatePrefixesAndNumber_should_push_more_than_one_prefix_operator_and_number_into_stack_with_loop(void){	Token *token;	Stack *numberStack=createStack();	Stack *operatorStack=createStack();		Text *newText=textNew("-+14");	String *tokenizer = stringNew(newText);	//printf("Test evaluatePrefix push more than one prefix operator with loop/n");	token=getToken(tokenizer);	evaluatePrefixesAndNumber(tokenizer,token,numberStack,operatorStack);	TEST_ASSERT_EQUAL_OPERATOR(PLUS_OP,stackPop(operatorStack));	TEST_ASSERT_EQUAL_OPERATOR(MINUS_OP,stackPop(operatorStack));	TEST_ASSERT_EQUAL_NUMBER(14,stackPop(numberStack));	TEST_ASSERT_NOT_NULL(token);	}

void test_NS_operand1_ERR_EMPTY_ARGUMENT_should_throw_error(void){	int value;	int e;		Text *text = textNew("135");	String *str = stringNew(text);		extractValue_ExpectAndThrow(str, 3);		Try{		value = NS(str);	}Catch(e){		TEST_ASSERT_EQUAL(ERR_EMPTY_ARGUMENT, e);	}	}

/* Get the substring location out from the string  * input : *			start is the start location for the substring *			length is the total character of the substring * return : *		 	return the subString	 */String *stringSubString(String *str , int start , int length){	String *subStr = stringNew(str->string);		if(start >= strlen(subStr->string))	{		subStr->startindex = strlen(subStr->string);		subStr->length = 0;		return subStr;	}		subStr->startindex = start;	subStr->length = length;	// printf("start = %d/n" , subStr->startindex);	// printf("length = %d/n" , subStr->length);	return subStr;}

/*! *  bmfCreate() * *      Input:  dir (<optional> directory holding pixa of character set) *              fontsize (4, 6, 8, ... , 20) *      Return: bmf (holding the bitmap font and associated information) * *  Notes: *      (1) If @dir == null, this generates the font bitmaps from a *          compiled string. *      (2) Otherwise, this tries to read a pre-computed pixa file with the *          95 ascii chars in it.  If the file is not found, it then *          attempts to generate the pixa and associated baseline *          data from a tiff image containing all the characters.  If *          that fails, it uses the compiled string. */L_BMF *bmfCreate(const char  *dir,          l_int32      fontsize){L_BMF   *bmf;PIXA  *pixa;    PROCNAME("bmfCreate");    if (fontsize < 4 || fontsize > 20 || (fontsize % 2))        return (L_BMF *)ERROR_PTR("fontsize must be in {4, 6, ..., 20}",                                  procName, NULL);    if ((bmf = (L_BMF *)CALLOC(1, sizeof(L_BMF))) == NULL)        return (L_BMF *)ERROR_PTR("bmf not made", procName, NULL);    if (!dir) {  /* Generate from a string */        L_INFO("Generating pixa of bitmap fonts from string/n", procName);        pixa = pixaGenerateFontFromString(fontsize, &bmf->baseline1,                                          &bmf->baseline2, &bmf->baseline3);    } else {  /* Look for the pixa in a directory */        L_INFO("Locating pixa of bitmap fonts in a file/n", procName);        pixa = pixaGetFont(dir, fontsize, &bmf->baseline1, &bmf->baseline2,                           &bmf->baseline3);        if (!pixa) {  /* Not found; make it from a file */            L_INFO("Generating pixa of bitmap fonts from file/n", procName);            pixa = pixaGenerateFontFromFile(dir, fontsize, &bmf->baseline1,                                            &bmf->baseline2, &bmf->baseline3);            if (!pixa) {  /* Not made; make it from a string after all */                L_ERROR("Failed to make font; use string/n", procName);                pixa = pixaGenerateFontFromString(fontsize, &bmf->baseline1,                                          &bmf->baseline2, &bmf->baseline3);            }        }    }    if (!pixa) {        bmfDestroy(&bmf);        return (L_BMF *)ERROR_PTR("font pixa not made", procName, NULL);    }    bmf->pixa = pixa;    bmf->size = fontsize;    if (dir) bmf->directory = stringNew(dir);    bmfMakeAsciiTables(bmf);    return bmf;}

void test_FA_operand2_ERR_ILLEGAL_ARGUMENT_should_mock_and_throw_error(void){	int value;	int e;		Text *text = textNew("135");	String *str = stringNew(text);		extractValue_ExpectAndReturn(str, 0x35);	extractACCESSBANKED_ExpectAndThrow(str, 2);		Try{		value = FA(str);	}Catch(e){		TEST_ASSERT_EQUAL(ERR_ILLEGAL_ARGUMENT, e);			}}

void test_evaluatePrefixesAndNumber_should_throw_error_cannot_convert_prefix(void){	CEXCEPTION_T e;	Token *token;	Stack *numberStack=createStack();	Stack *operatorStack=createStack();		Text *newText=textNew("*18");	String *tokenizer = stringNew(newText);	//printf("Test evaluatePrefix throw error cannot convert to prefix/n");	token=getToken(tokenizer);	Try{		evaluatePrefixesAndNumber(tokenizer,token,numberStack,operatorStack);		TEST_FAIL_MESSAGE("Cannot convert to prefix");	}Catch(e){		TEST_ASSERT_EQUAL(ERR_CANNOT_CONVERT_TO_PREFIX,e);	}}

void test_evaluatePrefixesAndNumber_should_throw_error_expect_a_number_after_prefix_operator(void){	CEXCEPTION_T e;	Token *token;	Stack *numberStack=createStack();	Stack *operatorStack=createStack();		Text *newText=textNew("-");	String *tokenizer = stringNew(newText);	//printf("Test evaluatePrefix throw error throw error expect a number after prefix operator/n");	token=getToken(tokenizer);	Try{		evaluatePrefixesAndNumber(tokenizer,token,numberStack,operatorStack);		TEST_FAIL_MESSAGE("Cannot expecting number");	}Catch(e){		TEST_ASSERT_EQUAL(ERR_EXPECTING_NUMBER,e);	}}

void test_fsfd_operand2_ERR_NO_ARGUMENT_should_mock_and_throw_error(void){	int value;	int e;		Text *text = textNew("");	String *str = stringNew(text);		extractValue_ExpectAndThrow(str, 4);		Try{		value = FSFD(str);	}Catch(e){		TEST_ASSERT_EQUAL(ERR_NO_ARGUMENT, e);			}	}

int evaluateExpression(char *expression){	Token *token;	Stack *numberStack=createStack();	Stack *operatorStack=createStack();	if(expression ==NULL){		Throw(ERR_NO_ARGUMENT);	}	Text *newText=textNew(expression);	String *tokenizer = stringNew(newText);			token=getToken(tokenizer);	if(token->type == IDENTIFIER_TOKEN){		Throw(ERR_NOT_ACCEPT_IDENTIFIER);	}else{	while(token!=NULL){		if(isOperator(token)){			if(((Operator*)token)->info->affix!=PREFIX)			tryConvertToPrefix((Operator*)token);		stackPush(token,operatorStack);		}else if(isNumber(token)){			stackPush(token,numberStack);			break;		}else			Throw(ERR_INVALID_IDENTIFIER);		token=getToken(tokenizer);		if(token==NULL)			break;	}			}		while((token=getToken(tokenizer))!=NULL ){		evaluatePostfixesPrefixesAndInfixes(expression,token,numberStack,operatorStack);	}	evaluateAllOperatorOnStack(numberStack,operatorStack);	Number *result=(Number*)stackPop(numberStack);	destroyStack(numberStack);	if(operatorStack !=NULL){		destroyStack(operatorStack);	}	return result->value;	}

String *stringRemoveWordContaining(String *string, char containSet[]){		int i = string->start;	int j = 0;	int k = 0;	int status;	int conValue = 0;		String *string2 = stringNew(string->text);	string2->start = string->start;	string2->length = 0;		while(containSet[k] > string->length){		conValue++;		k++;	}	while(string->text->string[i] != 0){		while(containSet[j] != 0){			if(string->text->string[i] == containSet[j]){				string2->length++;				string->start++;				string->length--;				goto getValue;			}else{				status++;			}			j++;		}				if(status >= conValue){			return string2;		}				getValue:		j = 0;		i++;	}		return string2;}

void test_evaluatePrefixesAndNumber_evaluate_divide_multiply_should_throw_error_expecting_number(void){	CEXCEPTION_T e;	Token *token;	Stack *numberStack=createStack();	Stack *operatorStack=createStack();		Text *newText=textNew("/*");	String *tokenizer = stringNew(newText);	token=getToken(tokenizer);	token=getToken(tokenizer);	Try	{		evaluatePrefixesAndNumber("/*",token,numberStack,operatorStack);	}	Catch(e)	{		TEST_ASSERT_EQUAL(ERR_CANNOT_CONVERT_TO_PREFIX,e);	}}

/*! * /brief   recogGetClassString() * * /param[in]    recog * /param[in]    index into array of char types * /param[out]   pcharstr string representation; *                        returns an empty string on error * /return  0 if found, 1 on error * * <pre> * Notes: *      (1) Extracts a copy of the string from sa_text, which *          the caller must free. *      (2) Caller must check the function return value. * </pre> */l_int32recogGetClassString(L_RECOG  *recog,                    l_int32   index,                    char    **pcharstr){    PROCNAME("recogGetClassString");    if (!pcharstr)        return ERROR_INT("&charstr not defined", procName, 1);    *pcharstr = stringNew("");    if (!recog)        return ERROR_INT("recog not defined", procName, 2);    if (index < 0 || index >= recog->setsize)        return ERROR_INT("invalid index", procName, 1);    LEPT_FREE(*pcharstr);    *pcharstr = sarrayGetString(recog->sa_text, index, L_COPY);    return 0;}

/*! * /brief   makeBarrelshiftString() */static char *makeBarrelshiftString(l_int32  delx,    /* j - cx */                      l_int32  dely)    /* i - cy */{l_int32  absx, absy;char     bigbuf[L_BUF_SIZE];    PROCNAME("makeBarrelshiftString");    if (delx < -31 || delx > 31)        return (char *)ERROR_PTR("delx out of bounds", procName, NULL);    if (dely < -31 || dely > 31)        return (char *)ERROR_PTR("dely out of bounds", procName, NULL);    absx = L_ABS(delx);    absy = L_ABS(dely);    if ((delx == 0) && (dely == 0))        sprintf(bigbuf, "(*sptr)");    else if ((delx == 0) && (dely < 0))        sprintf(bigbuf, "(*(sptr %s))", wplstrm[absy - 1]);    else if ((delx == 0) && (dely > 0))        sprintf(bigbuf, "(*(sptr %s))", wplstrp[absy - 1]);    else if ((delx < 0) && (dely == 0))        sprintf(bigbuf, "((*(sptr) >> %d) | (*(sptr - 1) << %d))",              absx, 32 - absx);    else if ((delx > 0) && (dely == 0))        sprintf(bigbuf, "((*(sptr) << %d) | (*(sptr + 1) >> %d))",              absx, 32 - absx);    else if ((delx < 0) && (dely < 0))        sprintf(bigbuf, "((*(sptr %s) >> %d) | (*(sptr %s - 1) << %d))",              wplstrm[absy - 1], absx, wplstrm[absy - 1], 32 - absx);    else if ((delx > 0) && (dely < 0))        sprintf(bigbuf, "((*(sptr %s) << %d) | (*(sptr %s + 1) >> %d))",              wplstrm[absy - 1], absx, wplstrm[absy - 1], 32 - absx);    else if ((delx < 0) && (dely > 0))        sprintf(bigbuf, "((*(sptr %s) >> %d) | (*(sptr %s - 1) << %d))",              wplstrp[absy - 1], absx, wplstrp[absy - 1], 32 - absx);    else  /*  ((delx > 0) && (dely > 0))  */        sprintf(bigbuf, "((*(sptr %s) << %d) | (*(sptr %s + 1) >> %d))",              wplstrp[absy - 1], absx, wplstrp[absy - 1], 32 - absx);    return stringNew(bigbuf);}

/*! *  sarrayGetString() * *      Input:  sarray *              index   (to the index-th string) *              copyflag  (L_NOCOPY or L_COPY) *      Return: string, or null on error * *  Notes: *      (1) Legacy usage decrees that we always use 0 to get the *          pointer to the string itself, and 1 to get a copy of *          the string. *      (2) See usage comments at the top of this file. *      (3) To get a pointer to the string itself, use for copyflag: *             L_NOCOPY or 0 or FALSE *          To get a copy of the string, use for copyflag: *             L_COPY or 1 or TRUE *          The const values of L_NOCOPY and L_COPY are guaranteed not *          to change. */char *sarrayGetString(SARRAY  *sa,                l_int32  index,                l_int32  copyflag){    PROCNAME("sarrayGetString");    if (!sa)        return (char *)ERROR_PTR("sa not defined", procName, NULL);    if (index < 0 || index >= sa->n)        return (char *)ERROR_PTR("index not valid", procName, NULL);    if (copyflag != L_NOCOPY && copyflag != L_COPY)        return (char *)ERROR_PTR("invalid copyflag", procName, NULL);    if (copyflag == L_NOCOPY)        return sa->array[index];    else  /* L_COPY */        return stringNew(sa->array[index]);}

void test_evaluatePrefixesAndNumber_evaluate_should_push_negative_into_operatorStack_and_5_into_number_stack(void){	Token *token;		Stack *numberStack=createStack();	Stack *operatorStack=createStack();		Text *newText=textNew("-5");	String *tokenizer = stringNew(newText);	//-	token=getToken(tokenizer);	evaluatePrefixesAndNumber("-5",token,numberStack,operatorStack);	TEST_ASSERT_NOT_NULL(token);	TEST_ASSERT_EQUAL_STRING("-",((Operator*)token)->info->symbol);	TEST_ASSERT_EQUAL(MINUS_OP,((Operator*)token)->info->id);	//5	token=getToken(tokenizer);	evaluatePrefixesAndNumber("-5",token,numberStack,operatorStack);	TEST_ASSERT_NOT_NULL(token);	TEST_ASSERT_EQUAL(5,((Number*)token)->value);}

/*! * /brief   l_genDescrString() * * /param[in]    filein input file of serialized data * /param[in]    ifunc index into set of functions in generated file * /param[in]    itype index into type of function to be used * /return  description string for this decoding function */static char *l_genDescrString(const char  *filein,                 l_int32      ifunc,                 l_int32      itype){char   buf[256];char  *tail;    PROCNAME("l_genDescrString");    if (!filein)        return (char *)ERROR_PTR("filein not defined", procName, NULL);    splitPathAtDirectory(filein, NULL, &tail);    snprintf(buf, sizeof(buf), " *     %-2d       %-10s    %-14s   %s",             ifunc, l_assoc[itype].type, l_assoc[itype].reader, tail);    LEPT_FREE(tail);    return stringNew(buf);}

void test_evaluatePrefixesAndNumber_evaluate_negative_positive_should_throw_error_expecting_number(void){	CEXCEPTION_T e;	Token *token;	Stack *numberStack=createStack();	Stack *operatorStack=createStack();		Text *newText=textNew("-+");	String *tokenizer = stringNew(newText);	token=getToken(tokenizer);	token=getToken(tokenizer);	token=getToken(tokenizer);	Try	{		evaluatePrefixesAndNumber("-+",token,numberStack,operatorStack);	}	Catch(e)	{		TEST_ASSERT_EQUAL(ERR_EXPECTING_NUMBER,e);	}}

/*! *  gplotCreate() * *      Input:  rootname (root for all output files) *              outformat (GPLOT_PNG, GPLOT_PS, GPLOT_EPS, GPLOT_X11, *                         GPLOT_LATEX) *              title  (<optional> overall title) *              xlabel (<optional> x axis label) *              ylabel (<optional> y axis label) *      Return: gplot, or null on error * *  Notes: *      (1) This initializes the plot. *      (2) The 'title', 'xlabel' and 'ylabel' strings can have spaces, *          double quotes and backquotes, but not single quotes. */GPLOT  *gplotCreate(const char  *rootname,            l_int32      outformat,            const char  *title,            const char  *xlabel,            const char  *ylabel){char    buf[L_BUF_SIZE];GPLOT  *gplot;    PROCNAME("gplotCreate");    if (!rootname)        return (GPLOT *)ERROR_PTR("rootname not defined", procName, NULL);    if (outformat != GPLOT_PNG && outformat != GPLOT_PS &&        outformat != GPLOT_EPS && outformat != GPLOT_X11 &&        outformat != GPLOT_LATEX)        return (GPLOT *)ERROR_PTR("outformat invalid", procName, NULL);    if ((gplot = (GPLOT *)CALLOC(1, sizeof(GPLOT))) == NULL)        return (GPLOT *)ERROR_PTR("gplot not made", procName, NULL);    gplot->cmddata = sarrayCreate(0);    gplot->datanames = sarrayCreate(0);    gplot->plotdata = sarrayCreate(0);    gplot->plottitles = sarrayCreate(0);    gplot->plotstyles = numaCreate(0);        /* Save title, labels, rootname, outformat, cmdname, outname */    gplot->rootname = stringNew(rootname);    gplot->outformat = outformat;    snprintf(buf, L_BUF_SIZE, "%s.cmd", rootname);    gplot->cmdname = stringNew(buf);    if (outformat == GPLOT_PNG)        snprintf(buf, L_BUF_SIZE, "%s.png", rootname);    else if (outformat == GPLOT_PS)        snprintf(buf, L_BUF_SIZE, "%s.ps", rootname);    else if (outformat == GPLOT_EPS)        snprintf(buf, L_BUF_SIZE, "%s.eps", rootname);    else if (outformat == GPLOT_LATEX)        snprintf(buf, L_BUF_SIZE, "%s.tex", rootname);    else  /* outformat == GPLOT_X11 */        buf[0] = '/0';    gplot->outname = stringNew(buf);    if (title) gplot->title = stringNew(title);    if (xlabel) gplot->xlabel = stringNew(xlabel);    if (ylabel) gplot->ylabel = stringNew(ylabel);    return gplot;}

void test_all(void) {    String *toCompare;    Text *text = textNew(" /t/t ahaha /t/t    ");    String *str = stringNew(text);    String *str2 = stringAssign(str);    TEST_ASSERT_EQUAL(2,text->reference);    toCompare = stringDel(str); //still got 1    TEST_ASSERT_EQUAL(2,text->reference);    TEST_ASSERT_EQUAL(1,toCompare->reference);    toCompare = stringDel(str); //no more    //unable to TEST_ASSERT_EQUAL, bad memory because already removed    TEST_ASSERT_EQUAL(1,text->reference);    stringTrim(str);    TEST_ASSERT_EQUAL(4,str->start);    TEST_ASSERT_EQUAL(5,str->length);}

void test_evaluatePrefixesAndNumber_evaluate_multiply_should_throw_error_cannot_convert_to_prefix_operator(void){	CEXCEPTION_T e;	Token *token;	Stack *numberStack=createStack();	Stack *operatorStack=createStack();		Text *newText=textNew("*");	String *tokenizer = stringNew(newText);		//(	token=getToken(tokenizer);	Try	{		evaluatePrefixesAndNumber("*",token,numberStack,operatorStack);		TEST_FAIL_MESSAGE("Should throw Error no expression ");	}	Catch(e)	{		TEST_ASSERT_EQUAL(ERR_CANNOT_CONVERT_TO_PREFIX ,e);	}}

void test_evaluatePrefixesAndNumber_evaluate_opening_bracket_7(void){	Token *token;	Stack *numberStack=createStack();	Stack *operatorStack=createStack();		Text *newText=textNew("(7");	String *tokenizer = stringNew(newText);		//(	token=getToken(tokenizer);	evaluatePrefixesAndNumber("(7",token,numberStack,operatorStack);	TEST_ASSERT_NOT_NULL(token);	TEST_ASSERT_EQUAL_STRING("(",((Operator*)token)->info->symbol);	TEST_ASSERT_EQUAL(OPENING_BRACKET_OP,((Operator*)token)->info->id);		//7	token=getToken(tokenizer);	evaluatePrefixesAndNumber("(7",token,numberStack,operatorStack);	TEST_ASSERT_NOT_NULL(token);	TEST_ASSERT_EQUAL(7,((Number*)token)->value);}

String *stringRemoveWordNotContaining(String *string,char delimiters[]){	int i=0,j=0;		String *stringA = stringNew(string->text);	stringA->length = 0;		while(string->text->string[i]!=0){	while(delimiters[j] != 0){		if(string->text->string[i] == delimiters[j]){				stringA->start = string->start;								stringA->length = i-string->start;					string->start = i;				string->length = string->length - stringA->length ;				return stringA;		}		j++;		}		j=0;		i++;	}		return stringA; }

void evaluatePrefixesAndNumber(char *expression,Token *token,Stack *numberStack,Stack *operatorStack){	Text *newText=textNew(expression);	String *tokenizer = stringNew(newText);		if(token==NULL){		Throw(ERR_EXPECTING_NUMBER);	}else {		while(1){			if(isNumber(token)){				stackPush(token,numberStack);				break;			}else if(isOperator(token)){				if(((Operator*)token)->info->affix !=PREFIX)					tryConvertToPrefix((Operator*)token);				stackPush(token,operatorStack);			}else				Throw(ERR_INVALID_IDENTIFIER);			token=getToken(tokenizer);			if(token==NULL)				break;		}	}	}

/******************************************************************************************* *	This function is to evaluate the expression which contains numbers and operators and *	return the results in number form. *	This function is a prototype function which use as reference to *	improve in the evaluateExpression(char*expression) function. *	Thus, this function could not evaluate expression like -2,*2,(((2))), +-+-2... * *	input  : expression *	output : none *	return : ((Number*)token)->value *********************************************************************************************/int evaluate(char *expression){	Token *token;	Number *result;	Stack *numberStack=createStack();	Stack *operatorStack=createStack();	if(expression ==NULL){		Throw(ERR_NO_ARGUMENT);	}	Text *newText=textNew(expression);	String *tokenizer = stringNew(newText);	while((token=getToken(tokenizer))!=NULL ){		if(isNumber(token)){			stackPush(token,numberStack);		} else if(isOperator(token)) {			if(((Operator*)token)->info->id==OPENING_BRACKET_OP || ((Operator*)token)->info->id==CLOSING_BRACKET_OP) {				tryEvaluatePrefixOperatorOnStackThenPush((Operator*)token,numberStack,operatorStack);			} else{				tryEvaluateOperatorOnStackThenPush((Operator*)token,numberStack,operatorStack);			}		}	}	if(operatorStack == NULL){		operatorPrefixEvaluate(numberStack ,(Operator*)token);	}else{		evaluateAllOperatorOnStack(numberStack,operatorStack);	}	result=(Number*)stackPop(numberStack);	destroyStack(numberStack);	if(operatorStack !=NULL){		destroyStack(operatorStack);	}	return result->value;}