void test_updateTheString_should_return_NULL_when_the_identifier_is_not_defined()
{
String testTokenizer;
testTokenizer.rawString = "12+num1";
testTokenizer.startIndex = 0;
testTokenizer.length = 7;
String *newTokenizer;
free(getToken(&testTokenizer));
free(getToken(&testTokenizer));
Identifier testIdentifier;
testIdentifier.name = malloc (5);
stringCopy("num1",testIdentifier.name,0,5);
testIdentifier.type=IDENTIFIER;
Error exception;
getElement_ExpectAndReturn(DefineList, testIdentifier.name,NULL);
//Now start put the identifier and tokenizer into the function.
Try
{
newTokenizer = getFromListAndUpdate(&testTokenizer,testIdentifier.name);
}
Catch(exception)
{
TEST_ASSERT_EQUAL(UNDEFINED_IDENTIFIER,exception);
TEST_ASSERT_EQUAL_STRING("Undefined Identifier! ",errorMessage.message);
}
free(testIdentifier.name);
}
void test_updateTheString_should_update_the_string_object_if_the_identifier_is_being_in_front_of_the_expression()
{
String *testTokenizer =malloc(sizeof(String));
testTokenizer->rawString = "num1+12";
testTokenizer->startIndex = 0;
testTokenizer->length = 7;
String *newTokenizer;
Token *testToken;
Operator *opeToken;
Number *numToken;
Identifier *testIdentifier= malloc (sizeof(Identifier));
testIdentifier->name = malloc (5);
stringCopy("num1",testIdentifier->name,0,5);
testIdentifier->type=IDENTIFIER;
DefineElement element;
element.ID = "num1";
element.actualID = "4";
getElement_ExpectAndReturn(DefineList, testIdentifier->name,&element);
//Now start put the identifier and tokenizer into the function.
newTokenizer = getFromListAndUpdate(testTokenizer,testIdentifier->name);
TEST_ASSERT_EQUAL(4,newTokenizer->length);
TEST_ASSERT_EQUAL(0,newTokenizer->startIndex);
//check the string inside the String.
TEST_ASSERT_EQUAL('4',newTokenizer->rawString[0]);
TEST_ASSERT_EQUAL('+',newTokenizer->rawString[1]);
TEST_ASSERT_EQUAL('1',newTokenizer->rawString[2]);
TEST_ASSERT_EQUAL('2',newTokenizer->rawString[3]);
TEST_ASSERT_EQUAL_STRING("4+12",newTokenizer->rawString);
//Since the string been recreate try to get token from it until the last of the string.
testToken = getToken(newTokenizer); //Should be 4.
TEST_ASSERT_EQUAL(NUMBER,*testToken);
numToken = (Number*)testToken;
TEST_ASSERT_EQUAL(NUMBER,numToken->type);
TEST_ASSERT_EQUAL(4,numToken->value);
free(numToken);
testToken = getToken(newTokenizer); //Should be +.
TEST_ASSERT_EQUAL(OPERATOR,*testToken);
opeToken = (Operator*)testToken;
TEST_ASSERT_EQUAL(OPERATOR,opeToken->type);
TEST_ASSERT_EQUAL(ADD,opeToken->id);
free(opeToken);
testToken = getToken(newTokenizer); //Should be 12.
TEST_ASSERT_EQUAL(NUMBER,*testToken);
numToken = (Number*)testToken;
TEST_ASSERT_EQUAL(NUMBER,numToken->type);
TEST_ASSERT_EQUAL(12,numToken->value);
free(numToken);
testToken = getToken(newTokenizer); //Should be NULL.
TEST_ASSERT_NULL(testToken);
free(newTokenizer);
free(testIdentifier->name);
free(testIdentifier);
free(testTokenizer);
}
void test_updateTheString_should_update_the_string_object_as_defined_by_user()
{
String *testTokenizer =malloc(sizeof(String));
testTokenizer->rawString = "12+num1";
testTokenizer->startIndex = 0;
testTokenizer->length = 7;
String *newTokenizer;
Token *testToken;
Number *numToken;
free(getToken(testTokenizer));
free(getToken(testTokenizer));
Identifier *testIdentifier= malloc (sizeof(Identifier));
testIdentifier->name = malloc (5);
stringCopy("num1",testIdentifier->name,0,5);
testIdentifier->type=IDENTIFIER;
DefineElement element;
element.ID = "num1";
element.actualID = "4";
getElement_ExpectAndReturn(DefineList, testIdentifier->name,&element);
//Now start put the identifier and tokenizer into the function.
newTokenizer = getFromListAndUpdate(testTokenizer,testIdentifier->name);
TEST_ASSERT_EQUAL(1,newTokenizer->length);
TEST_ASSERT_EQUAL(3,newTokenizer->startIndex);
//check the string inside the String.
TEST_ASSERT_EQUAL('1',newTokenizer->rawString[0]);
TEST_ASSERT_EQUAL('2',newTokenizer->rawString[1]);
TEST_ASSERT_EQUAL('+',newTokenizer->rawString[2]);
TEST_ASSERT_EQUAL('4',newTokenizer->rawString[3]);
TEST_ASSERT_EQUAL_STRING("12+4",newTokenizer->rawString);
//Since the string been recreate try to get token from it until the last of the string.
testToken = getToken(newTokenizer); //Should be 4.
TEST_ASSERT_EQUAL(NUMBER,*testToken);
numToken = (Number*)testToken;
TEST_ASSERT_EQUAL(NUMBER,numToken->type);
TEST_ASSERT_EQUAL(4,numToken->value);
free(numToken);
testToken = getToken(newTokenizer); //Should be NULL.
TEST_ASSERT_NULL(testToken);
free(newTokenizer);
free(testIdentifier->name);
free(testIdentifier);
free(testTokenizer);
}
void test_updateTheString_will_update_the_identifier_when_meet_it()
{
String *testTokenizer =malloc(sizeof(String));
testTokenizer->rawString = "num1+num2";
testTokenizer->startIndex = 0;
testTokenizer->length = 9;
Token *testToken;
Number *numToken;
Operator *opeToken;
Identifier *testIdentifier= malloc (sizeof(Identifier));
testIdentifier->name = malloc (5);
stringCopy("num1",testIdentifier->name,0,5);
testIdentifier->type=IDENTIFIER;
DefineElement element;
element.ID = "num1";
element.actualID = "4";
Identifier *testIdentifier1= malloc (sizeof(Identifier));
testIdentifier1->name = malloc (5);
stringCopy("num2",testIdentifier1->name,0,5);
testIdentifier1->type=IDENTIFIER;
DefineElement element1;
element1.ID = "num2";
element1.actualID = "12";
getElement_ExpectAndReturn(DefineList, testIdentifier->name,&element);
getElement_ExpectAndReturn(DefineList, testIdentifier1->name,&element1);
//Now start put the identifier and tokenizer into the function.
testTokenizer = getFromListAndUpdate(testTokenizer,testIdentifier->name);
TEST_ASSERT_EQUAL(6,testTokenizer->length);
TEST_ASSERT_EQUAL(0,testTokenizer->startIndex);
//check the string inside the String.
TEST_ASSERT_EQUAL_STRING("4+num2",testTokenizer->rawString);
testToken = getToken(testTokenizer); //Should be 4.
TEST_ASSERT_EQUAL(NUMBER,*testToken);
numToken = (Number*)testToken;
TEST_ASSERT_EQUAL(NUMBER,numToken->type);
TEST_ASSERT_EQUAL(4,numToken->value);
free(numToken);
testToken = getToken(testTokenizer); //Should be +.
TEST_ASSERT_EQUAL(OPERATOR,*testToken);
opeToken = (Operator*)testToken;
TEST_ASSERT_EQUAL(OPERATOR,opeToken->type);
TEST_ASSERT_EQUAL(ADD,opeToken->id);
testTokenizer = getFromListAndUpdate(testTokenizer,testIdentifier1->name);
TEST_ASSERT_EQUAL(2,testTokenizer->length);
TEST_ASSERT_EQUAL(2,testTokenizer->startIndex);
//check the string inside the String.
TEST_ASSERT_EQUAL_STRING("4+12",testTokenizer->rawString);
free(opeToken);
free(testIdentifier1->name);
free(testIdentifier->name);
free(testIdentifier);
free(testIdentifier1);
free(testTokenizer);
}
void test_updateTheString_should_update_the_string_object_for_longer_expression_of_user_define_and_a_longer_expression()
{
String *testTokenizer =malloc(sizeof(String));
testTokenizer->rawString = "num1+12+5+99+89";
testTokenizer->startIndex = 0;
testTokenizer->length = 15;
String *newTokenizer;
Token *testToken;
Operator *opeToken;
Number *numToken;
Identifier *testIdentifier= malloc (sizeof(Identifier));
testIdentifier->name = malloc (5);
stringCopy("num1",testIdentifier->name,0,5);
testIdentifier->type=IDENTIFIER;
DefineElement element;
element.ID = "num1";
element.actualID = "4-99+8-456";
getElement_ExpectAndReturn(DefineList, testIdentifier->name,&element);
//Now start put the identifier and tokenizer into the function.
newTokenizer = getFromListAndUpdate(testTokenizer,testIdentifier->name);
TEST_ASSERT_EQUAL(21,newTokenizer->length);
TEST_ASSERT_EQUAL(0,newTokenizer->startIndex);
//check the string inside the String.
TEST_ASSERT_EQUAL_STRING("4-99+8-456+12+5+99+89",newTokenizer->rawString);
//Since the string been recreate try to get token from it until the last of the string.
testToken = getToken(newTokenizer); //Should be 4.
TEST_ASSERT_EQUAL(NUMBER,*testToken);
numToken = (Number*)testToken;
TEST_ASSERT_EQUAL(NUMBER,numToken->type);
TEST_ASSERT_EQUAL(4,numToken->value);
free(numToken);
testToken = getToken(newTokenizer); //Should be -.
TEST_ASSERT_EQUAL(OPERATOR,*testToken);
opeToken = (Operator*)testToken;
TEST_ASSERT_EQUAL(OPERATOR,opeToken->type);
TEST_ASSERT_EQUAL(SUBTRACT,opeToken->id);
free(opeToken);
testToken = getToken(newTokenizer); //Should be 99.
TEST_ASSERT_EQUAL(NUMBER,*testToken);
numToken = (Number*)testToken;
TEST_ASSERT_EQUAL(NUMBER,numToken->type);
TEST_ASSERT_EQUAL(99,numToken->value);
free(numToken);
testToken = getToken(newTokenizer); //Should be +.
TEST_ASSERT_EQUAL(OPERATOR,*testToken);
opeToken = (Operator*)testToken;
TEST_ASSERT_EQUAL(OPERATOR,opeToken->type);
TEST_ASSERT_EQUAL(ADD,opeToken->id);
free(opeToken);
testToken = getToken(newTokenizer); //Should be 8.
TEST_ASSERT_EQUAL(NUMBER,*testToken);
numToken = (Number*)testToken;
TEST_ASSERT_EQUAL(NUMBER,numToken->type);
TEST_ASSERT_EQUAL(8,numToken->value);
free(numToken);
testToken = getToken(newTokenizer); //Should be -.
TEST_ASSERT_EQUAL(OPERATOR,*testToken);
opeToken = (Operator*)testToken;
TEST_ASSERT_EQUAL(OPERATOR,opeToken->type);
TEST_ASSERT_EQUAL(SUBTRACT,opeToken->id);
free(opeToken);
testToken = getToken(newTokenizer); //Should be 456.
TEST_ASSERT_EQUAL(NUMBER,*testToken);
numToken = (Number*)testToken;
TEST_ASSERT_EQUAL(NUMBER,numToken->type);
TEST_ASSERT_EQUAL(456,numToken->value);
free(numToken);
testToken = getToken(newTokenizer); //Should be +.
TEST_ASSERT_EQUAL(OPERATOR,*testToken);
opeToken = (Operator*)testToken;
TEST_ASSERT_EQUAL(OPERATOR,opeToken->type);
TEST_ASSERT_EQUAL(ADD,opeToken->id);
free(opeToken);
testToken = getToken(newTokenizer); //Should be 12.
TEST_ASSERT_EQUAL(NUMBER,*testToken);
numToken = (Number*)testToken;
TEST_ASSERT_EQUAL(NUMBER,numToken->type);
TEST_ASSERT_EQUAL(12,numToken->value);
free(numToken);
testToken = getToken(newTokenizer); //Should be +.
TEST_ASSERT_EQUAL(OPERATOR,*testToken);
opeToken = (Operator*)testToken;
TEST_ASSERT_EQUAL(OPERATOR,opeToken->type);
TEST_ASSERT_EQUAL(ADD,opeToken->id);
free(opeToken);
testToken = getToken(newTokenizer); //Should be 5.
TEST_ASSERT_EQUAL(NUMBER,*testToken);
numToken = (Number*)testToken;
TEST_ASSERT_EQUAL(NUMBER,numToken->type);
TEST_ASSERT_EQUAL(5,numToken->value);
free(numToken);
testToken = getToken(newTokenizer); //Should be +.
TEST_ASSERT_EQUAL(OPERATOR,*testToken);
opeToken = (Operator*)testToken;
TEST_ASSERT_EQUAL(OPERATOR,opeToken->type);
TEST_ASSERT_EQUAL(ADD,opeToken->id);
free(opeToken);
testToken = getToken(newTokenizer); //Should be 99.
TEST_ASSERT_EQUAL(NUMBER,*testToken);
numToken = (Number*)testToken;
TEST_ASSERT_EQUAL(NUMBER,numToken->type);
TEST_ASSERT_EQUAL(99,numToken->value);
free(numToken);
testToken = getToken(newTokenizer); //Should be +.
TEST_ASSERT_EQUAL(OPERATOR,*testToken);
opeToken = (Operator*)testToken;
TEST_ASSERT_EQUAL(OPERATOR,opeToken->type);
TEST_ASSERT_EQUAL(ADD,opeToken->id);
free(opeToken);
testToken = getToken(newTokenizer); //Should be 89.
TEST_ASSERT_EQUAL(NUMBER,*testToken);
numToken = (Number*)testToken;
TEST_ASSERT_EQUAL(NUMBER,numToken->type);
TEST_ASSERT_EQUAL(89,numToken->value);
free(numToken);
testToken = getToken(newTokenizer); //Should be NULL.
TEST_ASSERT_NULL(testToken);
free(testIdentifier->name);
free(testIdentifier);
free(testTokenizer);
}
/*
This function will generate a string
Input:
*expression which contain the string(expression)
Output:
none
return:
Tokenizer which pass to the getToken to generate token.
Throw:
UNDEFINED_IDENTIFIER if the expression contained undefined identifier
INVALID_EXPRESSION if the expression contained invalid expression (not following format)
*/
String *stringCreate(char *expression) {
int length = strlen(expression);
String *newString = malloc (sizeof(String));
char *newRawString = malloc (length+1);
int tempIndex,stringStartLocation,lengthOfTheIdentifier=0;
Token *newToken;
char name[20];
Error exception;
stringCopy(expression, newRawString, 0, length);
newString->rawString = newRawString;
newString->startIndex = 0;
newString->length = strlen(newString->rawString);
Try
{
for(tempIndex=0;tempIndex<=newString->length;tempIndex++)
{
if (isalpha(newString->rawString[tempIndex])||(newString->rawString[tempIndex])=='.')
{
stringStartLocation=tempIndex;
do
{
lengthOfTheIdentifier++;
tempIndex++;
}while(isalnum(newString->rawString[tempIndex])||(newString->rawString[tempIndex]=='.'));
stringCopy(newString->rawString,name,stringStartLocation,lengthOfTheIdentifier);
newToken=(Token*)checkIdentifier(name);
tempIndex-=lengthOfTheIdentifier+1;
if(newToken==NULL)
{
if(name[0]==48||name[0]==98
||name[0]==100||name[0]==104
||name[0]==111)
{
newString = convertBasedNumberToBase10Number(newString);
newString->startIndex++;
}
else
{
newString = getFromListAndUpdate(newString, name);
}
}
else if(newToken!=NULL)
{
tempIndex += lengthOfTheIdentifier;
}
lengthOfTheIdentifier=0;
}
else
{
if(newString->rawString[tempIndex]==48||newString->rawString[tempIndex]==98
||newString->rawString[tempIndex]==100||newString->rawString[tempIndex]==104
||newString->rawString[tempIndex]==111)
{
newString = convertBasedNumberToBase10Number(newString);
}
newString->startIndex++;
}
}
}
Catch(exception)
{
errorMessage.rawString = newString->rawString;
errorMessage.position = newString->startIndex;
if(exception == UNDEFINED_IDENTIFIER)
{
Throw(UNDEFINED_IDENTIFIER);
}
else if(exception == INVALID_EXPRESSION)
{
Throw(INVALID_EXPRESSION);
}
}
newString->startIndex=0;
return newString;
}
