struct channel *
create_data_channel(void) {
static uint8_t cnt;
char buf[256];
struct channel *channel;
lagopus_session_t session;
struct addrunion addr;
uint64_t dpid = 0xabc;
if (s_is_init == false) {
s_is_init = true;
/* init dataplane. */
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, dp_api_init());
/* interface. */
s_interface_info.type = DATASTORE_INTERFACE_TYPE_ETHERNET_RAWSOCK;
s_interface_info.eth_rawsock.port_number = 0;
s_interface_info.eth_dpdk_phy.device = strdup("eth0");
if (s_interface_info.eth_dpdk_phy.device == NULL) {
TEST_FAIL_MESSAGE("device is NULL.");
}
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK,
dp_interface_create(interface_name));
dp_interface_info_set(interface_name, &s_interface_info);
/* port. */
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK,
dp_port_create(port_name));
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK,
dp_port_interface_set(port_name, interface_name));
/* bridge. */
ofp_bridgeq_mgr_initialize(NULL);
s_bridge_info.dpid = dpid;
s_bridge_info.fail_mode = DATASTORE_BRIDGE_FAIL_MODE_SECURE;
s_bridge_info.max_buffered_packets = UINT32_MAX;
s_bridge_info.max_ports = UINT16_MAX;
s_bridge_info.max_tables = UINT8_MAX;
s_bridge_info.max_flows = UINT32_MAX;
s_bridge_info.capabilities = UINT64_MAX;
s_bridge_info.action_types = UINT64_MAX;
s_bridge_info.instruction_types = UINT64_MAX;
s_bridge_info.reserved_port_types = UINT64_MAX;
s_bridge_info.group_types = UINT64_MAX;
s_bridge_info.group_capabilities = UINT64_MAX;
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK,
dp_bridge_create(bridge_name, &s_bridge_info));
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK,
dp_bridge_port_set(bridge_name, port_name, 0));
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK,
ofp_bridgeq_mgr_bridge_register(
dpid,
bridge_name,
&s_bridge_info,
&s_queue_info));
}
if (s_event_manager == NULL) {
s_event_manager = event_manager_alloc();
channel_mgr_initialize(s_event_manager);
}
snprintf(buf, sizeof(buf), "127.0.0.%u", cnt++);//XXX
addrunion_ipv4_set(&addr, buf);
channel_mgr_channel_add(bridge_name, dpid, &addr);
channel_mgr_channel_lookup(bridge_name, &addr, &channel);
session = channel_session_get(channel);
session_write_set(session, s_write_tcp);
session_sockfd_set(session, 3);
channel_version_set(channel, 0x04);
channel_xid_set(channel, s_xid);
return channel;
}
void run_throughput_tests(KineticClient * client, size_t num_ops, size_t value_size)
{
LOGF0("STRESS THREAD: object_size: %zu bytes, count: %zu entries", value_size, num_ops);
// Configure and establish a session with the specified device
KineticSession* session;
const char HmacKeyString[] = "asdfasdf";
KineticSessionConfig config = {
.clusterVersion = 0,
.identity = 1,
.hmacKey = ByteArray_CreateWithCString(HmacKeyString),
};
strncpy(config.host, GetSystemTestHost1(), sizeof(config.host)-1);
config.port = GetSystemTestPort1();
KineticStatus status = KineticClient_CreateSession(&config, client, &session);
if (status != KINETIC_STATUS_SUCCESS) {
char msg[128];
sprintf(msg, "Failed connecting to the Kinetic device w/status: %s", Kinetic_GetStatusDescription(status));
TEST_FAIL_MESSAGE(msg);
}
// Generate test entry data
ByteBuffer test_data = ByteBuffer_Malloc(value_size);
ByteBuffer_AppendDummyData(&test_data, test_data.array.len);
uint8_t tag_data[] = {0x00, 0x01, 0x02, 0x03};
ByteBuffer tag = ByteBuffer_Create(tag_data, sizeof(tag_data), sizeof(tag_data));
uint64_t r = rand();
uint64_t keys[num_ops];
KineticEntry entries[num_ops];
for (uint32_t put = 0; put < num_ops; put++) {
keys[put] = put | (r << 16);
}
// Measure PUT performance
{
OpStatus put_statuses[num_ops];
for (size_t i = 0; i < num_ops; i++) {
put_statuses[i] = (OpStatus){
.sem = KineticSemaphore_Create(),
.status = KINETIC_STATUS_INVALID,
};
};
struct timeval start_time;
gettimeofday(&start_time, NULL);
for (uint32_t put = 0; put < num_ops; put++) {
ByteBuffer key = ByteBuffer_Create(&keys[put], sizeof(keys[put]), sizeof(keys[put]));
KineticSynchronization sync = (put == num_ops - 1)
? KINETIC_SYNCHRONIZATION_FLUSH
: KINETIC_SYNCHRONIZATION_WRITEBACK;
entries[put] = (KineticEntry) {
.key = key,
.tag = tag,
.algorithm = KINETIC_ALGORITHM_SHA1,
.value = test_data,
.synchronization = sync,
};
KineticStatus status = KineticClient_Put(
session,
&entries[put],
&(KineticCompletionClosure) {
.callback = op_finished,
.clientData = &put_statuses[put],
}
);
if (status != KINETIC_STATUS_SUCCESS) {
char msg[128];
sprintf(msg, "PUT failed w/status: %s", Kinetic_GetStatusDescription(status));
TEST_FAIL_MESSAGE(msg);
}
}
for (size_t i = 0; i < num_ops; i++)
{
KineticSemaphore_WaitForSignalAndDestroy(put_statuses[i].sem);
if (put_statuses[i].status != KINETIC_STATUS_SUCCESS) {
char msg[128];
sprintf(msg, "PUT failed w/status: %s", Kinetic_GetStatusDescription(put_statuses[i].status));
TEST_FAIL_MESSAGE(msg);
}
}
struct timeval stop_time;
gettimeofday(&stop_time, NULL);
size_t bytes_written = num_ops * test_data.array.len;
int64_t elapsed_us = ((stop_time.tv_sec - start_time.tv_sec) * 1000000)
+ (stop_time.tv_usec - start_time.tv_usec);
float elapsed_ms = elapsed_us / 1000.0f;
float bandwidth = (bytes_written * 1000.0f) / (elapsed_ms * 1024 * 1024);
LOGF0("PUT Performance: wrote: %.1f kB, duration: %.3f sec, throughput: %.2f MB/sec",
bytes_written / 1024.0f, elapsed_ms / 1000.0f, bandwidth);
}
// Measure GET performance
{
OpStatus get_statuses[num_ops];
for (size_t i = 0; i < num_ops; i++) {
get_statuses[i] = (OpStatus){
.sem = KineticSemaphore_Create(),
.status = KINETIC_STATUS_INVALID,
};
};
ByteBuffer test_get_datas[num_ops];
for (size_t i = 0; i < num_ops; i++)
{
test_get_datas[i] = ByteBuffer_Malloc(value_size);
}
struct timeval start_time;
gettimeofday(&start_time, NULL);
for (uint32_t get = 0; get < num_ops; get++) {
ByteBuffer key = ByteBuffer_Create(&keys[get], sizeof(keys[get]), sizeof(keys[get]));
entries[get] = (KineticEntry) {
.key = key,
.tag = tag,
.value = test_get_datas[get],
};
KineticStatus status = KineticClient_Get(
session,
&entries[get],
&(KineticCompletionClosure) {
.callback = op_finished,
.clientData = &get_statuses[get],
}
);
if (status != KINETIC_STATUS_SUCCESS) {
char msg[128];
sprintf(msg, "GET failed w/status: %s", Kinetic_GetStatusDescription(status));
TEST_FAIL_MESSAGE(msg);
}
}
size_t bytes_read = 0;
for (size_t i = 0; i < num_ops; i++)
{
KineticSemaphore_WaitForSignalAndDestroy(get_statuses[i].sem);
if (get_statuses[i].status != KINETIC_STATUS_SUCCESS) {
char msg[128];
sprintf(msg, "GET failed w/status: %s", Kinetic_GetStatusDescription(get_statuses[i].status));
TEST_FAIL_MESSAGE(msg);
}
else
{
bytes_read += entries[i].value.bytesUsed;
}
}
// Check data for integrity
size_t numFailures = 0;
for (size_t i = 0; i < num_ops; i++) {
int res = memcmp(test_data.array.data, test_get_datas[i].array.data, test_data.array.len);
if (res != 0) {
LOGF0("Failed validating data in object %zu of %zu!", i+1, num_ops);
numFailures++;
}
}
TEST_ASSERT_EQUAL_MESSAGE(0, numFailures, "DATA INTEGRITY CHECK FAILED UPON READBACK!");
// Calculate and report performance
struct timeval stop_time;
gettimeofday(&stop_time, NULL);
int64_t elapsed_us = ((stop_time.tv_sec - start_time.tv_sec) * 1000000)
+ (stop_time.tv_usec - start_time.tv_usec);
float elapsed_ms = elapsed_us / 1000.0f;
float bandwidth = (bytes_read * 1000.0f) / (elapsed_ms * 1024 * 1024);
LOGF0("GET Performance: read: %.1f kB, duration: %.3f sec, throughput: %.2f MB/sec",
bytes_read / 1024.0f, elapsed_ms / 1000.0f, bandwidth);
for (size_t i = 0; i < num_ops; i++) {
ByteBuffer_Free(test_get_datas[i]);
}
}
void
setUp(void) {
struct sockaddr_storage so = {0,0,{0}};
struct sockaddr_in *sin = (struct sockaddr_in *)&so;
struct sockaddr_in6 *sin6;
if (s4 != -1) {
return;
}
sin->sin_family = AF_INET;
sin->sin_port = htons(10022);
sin->sin_addr.s_addr = INADDR_ANY;
s4 = socket(AF_INET, SOCK_STREAM, 0);
if (s4 < 0) {
perror("socket");
exit(1);
}
if (bind(s4, (struct sockaddr *) sin, sizeof(*sin)) < 0) {
perror("bind");
exit(1);
}
if (listen(s4, 5) < 0) {
perror("listen");
exit(1);
}
sin6 = (struct sockaddr_in6 *)&so;
sin6->sin6_family = AF_INET6;
sin6->sin6_port = htons(10023);
sin6->sin6_addr = in6addr_any;
s6 = socket(AF_INET6, SOCK_STREAM, 0);
if (s6 < 0) {
perror("socket");
exit(1);
}
if (bind(s6, (struct sockaddr *) sin6, sizeof(*sin6)) < 0) {
perror("bind");
exit(1);
}
if (listen(s6, 5) < 0) {
perror("listen");
exit(1);
}
/* init datapath. */
TEST_ASSERT_EQUAL(dp_api_init(), LAGOPUS_RESULT_OK);
/* interface. */
interface_info.type = DATASTORE_INTERFACE_TYPE_ETHERNET_RAWSOCK;
interface_info.eth_rawsock.port_number = 0;
interface_info.eth_dpdk_phy.device = strdup("eth0");
if (interface_info.eth_dpdk_phy.device == NULL) {
TEST_FAIL_MESSAGE("device is NULL.");
}
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK,
dp_interface_create(interface_name));
dp_interface_info_set(interface_name, &interface_info);
/* port. */
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK,
dp_port_create(port_name));
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK,
dp_port_interface_set(port_name, interface_name));
/* bridge. */
bridge_info.dpid = dpid;
bridge_info.fail_mode = DATASTORE_BRIDGE_FAIL_MODE_SECURE;
bridge_info.max_buffered_packets = UINT32_MAX;
bridge_info.max_ports = UINT16_MAX;
bridge_info.max_tables = UINT8_MAX;
bridge_info.max_flows = UINT32_MAX;
bridge_info.capabilities = UINT64_MAX;
bridge_info.action_types = UINT64_MAX;
bridge_info.instruction_types = UINT64_MAX;
bridge_info.reserved_port_types = UINT64_MAX;
bridge_info.group_types = UINT64_MAX;
bridge_info.group_capabilities = UINT64_MAX;
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK,
dp_bridge_create(bridge_name, &bridge_info));
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK,
dp_bridge_port_set(bridge_name, port_name, 0));
printf("setup end\n");
}
void test_shunting_yard_should_return_0_if_the_expression_is_null(){
int check;
Stack numberStack;
Stack operatorStack;
Error exception;
String tokenizer = {.rawString = "0", .startIndex = 0, .length=1};
Number number2 = {.type= NUMBER, .value=0};
Token *token1 = (Token*)&number2;
createStack_ExpectAndReturn(&numberStack);
createStack_ExpectAndReturn(&operatorStack);
stringCreate_ExpectAndReturn(NULL,&tokenizer);
Try
{
check = evaluate(NULL);
TEST_FAIL_MESSAGE("Should throw Error no expression ");
}
Catch(exception)
{
TEST_ASSERT_EQUAL(INVALID_EXPRESSION,exception);
}
}
void test_should_return_3_for_1_plus_2(void){
Stack dataStack;
Stack operatorStack;
int check;
//Initialize tokenizer,token and stack
String tokenizer = {.rawString = "1+2", .startIndex = 0, .length=3};
Number number1 = {.type= NUMBER, .value=1};
Number number2 = {.type= NUMBER, .value=2};
Number number3 = {.type= NUMBER, .value=3};
Operator plus = {.type= OPERATOR, .id=ADD, .precedence=70};
createStack_ExpectAndReturn(&dataStack);
createStack_ExpectAndReturn(&operatorStack);
stringCreate_ExpectAndReturn("1+2",&tokenizer);
//Number1
getToken_ExpectAndReturn(&tokenizer, (Token *)&number1);
isNumber_ExpectAndReturn((Token *)&number1, 1);
stackPush_Expect((Token *)&number1, &dataStack);
//Operator token plus
getToken_ExpectAndReturn(&tokenizer, (Token *)&plus);
isNumber_ExpectAndReturn((Token *)&plus, 0);
isOperator_ExpectAndReturn((Token *)&plus, 1);
stackPop_ExpectAndReturn(&operatorStack, NULL);
stackPush_Expect((Token *)&plus, &operatorStack);
//Number2
getToken_ExpectAndReturn(&tokenizer, (Token *)&number2);
isNumber_ExpectAndReturn((Token *)&number2, 1);
stackPush_Expect((Token *)&number2, &dataStack);
getToken_ExpectAndReturn(&tokenizer, NULL);
//Calculation
stackPop_ExpectAndReturn(&operatorStack, (Token *)&plus);
stackPop_ExpectAndReturn(&dataStack, (Token *)&number2);
stackPop_ExpectAndReturn(&dataStack, (Token *)&number1);
createNumberToken_ExpectAndReturn(3, (Token *)&number3);
stackPush_Expect((Token *)&number3, &dataStack);
stackPop_ExpectAndReturn(&operatorStack, NULL);
stackPop_ExpectAndReturn(&dataStack, (Token *)&number3);
destroyStack_Expect(&dataStack);
destroyStack_Expect(&operatorStack);
check = evaluate("1+2");
TEST_ASSERT_EQUAL(3, check);
printf("Answer : %d ",check);
}
void test_should_return_6_for_60_divide_10(void){
Stack dataStack;
Stack operatorStack;
int check;
//Initialize tokenizer,token and stack
String tokenizer = {.rawString = "60/10", .startIndex = 0, .length=3};
Number number60 = {.type= NUMBER, .value=60};
Token *token1 = (Token*)&number60;
Operator divide = {.type= OPERATOR, .id=DIVIDE, .precedence=100};
Token *token2 = (Token*)÷
Number number10 = {.type= NUMBER, .value=10};
Token *token3 = (Token*)&number10;
Number answer = {.type= NUMBER, .value=6};
Token *answerToken = (Token*)&answer;
createStack_ExpectAndReturn(&dataStack);
createStack_ExpectAndReturn(&operatorStack);
stringCreate_ExpectAndReturn("60/10",&tokenizer);
//Number60
getToken_ExpectAndReturn(&tokenizer,token1);
isNumber_ExpectAndReturn(token1,1);
stackPush_Expect(token1,&dataStack);
//Operator token divide
getToken_ExpectAndReturn(&tokenizer,token2);
isNumber_ExpectAndReturn(token2,0);
isOperator_ExpectAndReturn(token2,1);
stackPop_ExpectAndReturn(&operatorStack,NULL);
stackPush_Expect(token2,&operatorStack);
//Number10
getToken_ExpectAndReturn(&tokenizer,token3);
isNumber_ExpectAndReturn(token3,1);
stackPush_Expect(token3,&dataStack);
getToken_ExpectAndReturn(&tokenizer,NULL);
//Calculation
stackPop_ExpectAndReturn(&operatorStack,token2);
stackPop_ExpectAndReturn(&dataStack,token3);
stackPop_ExpectAndReturn(&dataStack,token1);
createNumberToken_ExpectAndReturn(6,answerToken);
stackPush_Expect(answerToken,&dataStack);
stackPop_ExpectAndReturn(&operatorStack,NULL);
stackPop_ExpectAndReturn(&dataStack,answerToken);
destroyStack_Expect(&dataStack);
destroyStack_Expect(&operatorStack);
check=evaluate("60/10");
TEST_ASSERT_EQUAL(6,check);
printf("Answer : %d ",check);
}
void test_evaluate_2_MULTIPLY_3_PLUS_4(void){
int check;
//Initialize tokenizer,token and stack
String tokenizer = {.rawString = "2*3+4", .startIndex = 0, .length = 5};
Number number2 = {.type= NUMBER, .value=2};
Token *token1 = (Token*)&number2;
Operator multiply = {.type= OPERATOR, .id = MULTIPLY ,.precedence=100};
Token *token2 = (Token*)&multiply;
Number number3 = {.type= NUMBER, .value=3};
Token *token3 = (Token*)&number3;
Operator plus = {.type= OPERATOR, .id = ADD ,.precedence=70};
Token *token4 = (Token*)+
Number number4 = {.type= NUMBER, .value=4};
Token *token5 = (Token*)&number4;
Number tempAnswer = {.type=NUMBER, .value=6};
Token *tempAnsToken = (Token*)&tempAnswer;
Number finalAnswer = {.type=NUMBER, .value=10};
Token *finalAnsToken = (Token*)&finalAnswer;
//Evaluate the expression
createStack_ExpectAndReturn(&numStack);
createStack_ExpectAndReturn(&opeStack);
stringCreate_ExpectAndReturn("2*3+4",&tokenizer);
//Number token 2
getToken_ExpectAndReturn(&tokenizer,token1);
isNumber_ExpectAndReturn(token1,1);
stackPush_Expect(token1,&numStack);
//Operator token multiply
getToken_ExpectAndReturn(&tokenizer,token2);
isNumber_ExpectAndReturn(token2,0);
isOperator_ExpectAndReturn(token2,1);
stackPop_ExpectAndReturn(&opeStack,NULL);
stackPush_Expect(token2,&opeStack);
//Number token 3
getToken_ExpectAndReturn(&tokenizer,token3);
isNumber_ExpectAndReturn(token3,1);
stackPush_Expect(token3,&numStack);
//Operator token plus cant push in and pop multiply out to evaluate
getToken_ExpectAndReturn(&tokenizer,token4);
isNumber_ExpectAndReturn(token4,0);
isOperator_ExpectAndReturn(token4,1);
stackPop_ExpectAndReturn(&opeStack,token2);
stackPop_ExpectAndReturn(&numStack,token3);
stackPop_ExpectAndReturn(&numStack,token1);
createNumberToken_ExpectAndReturn(6,tempAnsToken);
stackPush_Expect(tempAnsToken,&numStack);
stackPop_ExpectAndReturn(&opeStack,NULL);
stackPush_Expect(token4,&opeStack);
//Number token 4
getToken_ExpectAndReturn(&tokenizer,token5);
isNumber_ExpectAndReturn(token5,1);
stackPush_Expect(token5,&numStack);
getToken_ExpectAndReturn(&tokenizer,NULL);
//Evaluate expression
stackPop_ExpectAndReturn(&opeStack,token4);
stackPop_ExpectAndReturn(&numStack,token5);
stackPop_ExpectAndReturn(&numStack,tempAnsToken);
createNumberToken_ExpectAndReturn(10,finalAnsToken);
stackPush_Expect(finalAnsToken,&numStack);
stackPop_ExpectAndReturn(&opeStack,NULL);
stackPop_ExpectAndReturn(&numStack,finalAnsToken);
destroyStack_Expect(&numStack);
destroyStack_Expect(&opeStack);
check=evaluate("2*3+4");
TEST_ASSERT_EQUAL(10,check);
printf("Answer : %d ",check);
}
void test_evaluate_2_PLUS_3_MULTIPLY_4_PLUS_5_MULTIPLY_6(void){
int check;
//Initialize tokenizer,token and stack
String tokenizer = {.rawString = "2+3*4+5*6", .startIndex = 0, .length = 9};
Number number2 = {.type= NUMBER, .value=2};
Token *token1 = (Token*)&number2;
Operator plus = {.type= OPERATOR, .id = ADD ,.precedence=70};
Token *token2 = (Token*)+
Number number3 = {.type= NUMBER, .value=3};
Token *token3 = (Token*)&number3;
Operator multiply = {.type= OPERATOR, .id = MULTIPLY ,.precedence=100};
Token *token4 = (Token*)&multiply;
Number number4 = {.type= NUMBER, .value=4};
Token *token5 = (Token*)&number4;
Operator plus1 = {.type= OPERATOR, .id = ADD ,.precedence=70};
Token *token6 = (Token*)&plus1;
Number number5 = {.type= NUMBER, .value=5};
Token *token7 = (Token*)&number5;
Operator multiply1 = {.type= OPERATOR, .id = MULTIPLY ,.precedence=100};
Token *token8 = (Token*)&multiply1;
Number number6 = {.type= NUMBER, .value=6};
Token *token9 = (Token*)&number6;
Number tempAnswer1 = {.type=NUMBER, .value=12};
Token *tempAnsToken1 = (Token*)&tempAnswer1;
Number tempAnswer2 = {.type=NUMBER, .value=14};
Token *tempAnsToken2 = (Token*)&tempAnswer2;
Number tempAnswer3 = {.type=NUMBER, .value=30};
Token *tempAnsToken3 = (Token*)&tempAnswer3;
Number finalAnswer = {.type=NUMBER, .value=44};
Token *finalAnsToken = (Token*)&finalAnswer;
//Evaluate the expression
createStack_ExpectAndReturn(&numStack);
createStack_ExpectAndReturn(&opeStack);
stringCreate_ExpectAndReturn("2+3*4+5*6",&tokenizer);
//Token number 2
getToken_ExpectAndReturn(&tokenizer,token1);
isNumber_ExpectAndReturn(token1,1);
stackPush_Expect(token1,&numStack);
//Operator token plus
getToken_ExpectAndReturn(&tokenizer,token2);
isNumber_ExpectAndReturn(token2,0);
isOperator_ExpectAndReturn(token2,1);
stackPop_ExpectAndReturn(&opeStack,NULL);
stackPush_Expect(token2,&opeStack);
//Token number 3
getToken_ExpectAndReturn(&tokenizer,token3);
isNumber_ExpectAndReturn(token3,1);
stackPush_Expect(token3,&numStack);
//Token operator multiply
getToken_ExpectAndReturn(&tokenizer,token4);
isNumber_ExpectAndReturn(token4,0);
isOperator_ExpectAndReturn(token4,1);
stackPop_ExpectAndReturn(&opeStack,token2);
stackPush_Expect(token2,&opeStack);
stackPush_Expect(token4,&opeStack);
//Token number 4
getToken_ExpectAndReturn(&tokenizer,token5);
isNumber_ExpectAndReturn(token5,1);
stackPush_Expect(token5,&numStack);
//Token operator plus could not push in as multiply has higher
//precedence .
//After evaluate multiply,plus still cannot push in as there is
//one more plus token inside the stack.
//Thus , plus token inside the stack need to be evaluate first
getToken_ExpectAndReturn(&tokenizer,token6);
isNumber_ExpectAndReturn(token6,0);
isOperator_ExpectAndReturn(token6,1);
stackPop_ExpectAndReturn(&opeStack,token4);
stackPop_ExpectAndReturn(&numStack,token5);
stackPop_ExpectAndReturn(&numStack,token3);
createNumberToken_ExpectAndReturn(12,tempAnsToken1);
stackPush_Expect(tempAnsToken1,&numStack);
stackPop_ExpectAndReturn(&opeStack,token2);
stackPop_ExpectAndReturn(&numStack,tempAnsToken1);
stackPop_ExpectAndReturn(&numStack,token1);
createNumberToken_ExpectAndReturn(14,tempAnsToken2);
stackPush_Expect(tempAnsToken2,&numStack);
stackPop_ExpectAndReturn(&opeStack,NULL);
stackPush_Expect(token6,&opeStack);
//Token number 5
getToken_ExpectAndReturn(&tokenizer,token7);
isNumber_ExpectAndReturn(token7,1);
stackPush_Expect(token7,&numStack);
//Token operator multiply
getToken_ExpectAndReturn(&tokenizer,token8);
isNumber_ExpectAndReturn(token8,0);
isOperator_ExpectAndReturn(token8,1);
stackPop_ExpectAndReturn(&opeStack,token6);
stackPush_Expect(token6,&opeStack);
stackPush_Expect(token8,&opeStack);
//Token number 6
getToken_ExpectAndReturn(&tokenizer,token9);
isNumber_ExpectAndReturn(token9,1);
stackPush_Expect(token9,&numStack);
getToken_ExpectAndReturn(&tokenizer,NULL);
//Evaluate expression
stackPop_ExpectAndReturn(&opeStack,token8);
stackPop_ExpectAndReturn(&numStack,token9);
stackPop_ExpectAndReturn(&numStack,token7);
createNumberToken_ExpectAndReturn(30,tempAnsToken3);
stackPush_Expect(tempAnsToken3,&numStack);
stackPop_ExpectAndReturn(&opeStack,token6);
stackPop_ExpectAndReturn(&numStack,tempAnsToken3);
stackPop_ExpectAndReturn(&numStack,tempAnsToken2);
createNumberToken_ExpectAndReturn(44,finalAnsToken);
stackPush_Expect(finalAnsToken,&numStack);
stackPop_ExpectAndReturn(&opeStack,NULL);
stackPop_ExpectAndReturn(&numStack,finalAnsToken);
destroyStack_Expect(&numStack);
destroyStack_Expect(&opeStack);
check=evaluate("2+3*4+5*6");
TEST_ASSERT_EQUAL(44,check);
printf("Answer : %d ",check);
}
void test_evaluate_2_MULTIPLY_3_PLUS_4_MULTIPLY_5_PLUS_6(void){
int check;
//Initialize tokenizer,token and stack
String tokenizer = {.rawString = "2*3+4*5+6", .startIndex = 0, .length = 9};
Number number2 = {.type= NUMBER, .value=2};
Token *token1 = (Token*)&number2;
Operator multiply = {.type= OPERATOR, .id = MULTIPLY ,.precedence=100};
Token *token2 = (Token*)&multiply;
Number number3 = {.type= NUMBER, .value=3};
Token *token3 = (Token*)&number3;
Operator plus = {.type= OPERATOR, .id = ADD ,.precedence=70};
Token *token4 = (Token*)+
Number number4 = {.type= NUMBER, .value=4};
Token *token5 = (Token*)&number4;
Operator multiply1 = {.type= OPERATOR, .id = MULTIPLY ,.precedence=100};
Token *token6 = (Token*)&multiply1;
Number number5 = {.type= NUMBER, .value=5};
Token *token7 = (Token*)&number5;
Operator plus1 = {.type= OPERATOR, .id = ADD ,.precedence=70};
Token *token8 = (Token*)&plus1;
Number number6 = {.type= NUMBER, .value=6};
Token *token9 = (Token*)&number6;
Number tempAnswer1 = {.type=NUMBER, .value=6};
Token *tempAnsToken1 = (Token*)&tempAnswer1;
Number tempAnswer2 = {.type=NUMBER, .value=20};
Token *tempAnsToken2 = (Token*)&tempAnswer2;
Number tempAnswer3 = {.type=NUMBER, .value=26};
Token *tempAnsToken3 = (Token*)&tempAnswer3;
Number finalAnswer = {.type=NUMBER, .value=32};
Token *finalAnsToken = (Token*)&finalAnswer;
//Evaluate the expression
createStack_ExpectAndReturn(&numStack);
createStack_ExpectAndReturn(&opeStack);
stringCreate_ExpectAndReturn("2*3+4*5+6",&tokenizer);
//Token number 2
getToken_ExpectAndReturn(&tokenizer,token1);
isNumber_ExpectAndReturn(token1,1);
stackPush_Expect(token1,&numStack);
//Token operator multiply
getToken_ExpectAndReturn(&tokenizer,token2);
isNumber_ExpectAndReturn(token2,0);
isOperator_ExpectAndReturn(token2,1);
stackPop_ExpectAndReturn(&opeStack,NULL);
stackPush_Expect(token2,&opeStack);
//Token number 3
getToken_ExpectAndReturn(&tokenizer,token3);
isNumber_ExpectAndReturn(token3,1);
stackPush_Expect(token3,&numStack);
//Token operator plus
getToken_ExpectAndReturn(&tokenizer,token4);
isNumber_ExpectAndReturn(token4,0);
isOperator_ExpectAndReturn(token4,1);
stackPop_ExpectAndReturn(&opeStack,token2);
stackPop_ExpectAndReturn(&numStack,token3);
stackPop_ExpectAndReturn(&numStack,token1);
createNumberToken_ExpectAndReturn(6,tempAnsToken1);
stackPush_Expect(tempAnsToken1,&numStack);
stackPop_ExpectAndReturn(&opeStack,NULL);
stackPush_Expect(token4,&opeStack);
//Token number 4
getToken_ExpectAndReturn(&tokenizer,token5);
isNumber_ExpectAndReturn(token5,1);
stackPush_Expect(token5,&numStack);
//Token operator multiply
getToken_ExpectAndReturn(&tokenizer,token6);
isNumber_ExpectAndReturn(token6,0);
isOperator_ExpectAndReturn(token6,1);
stackPop_ExpectAndReturn(&opeStack,token4);
stackPush_Expect(token4,&opeStack);
stackPush_Expect(token6,&opeStack);
//Token number 5
getToken_ExpectAndReturn(&tokenizer,token7);
isNumber_ExpectAndReturn(token7,1);
stackPush_Expect(token7,&numStack);
//Token operator plus
getToken_ExpectAndReturn(&tokenizer,token8);
isNumber_ExpectAndReturn(token8,0);
isOperator_ExpectAndReturn(token8,1);
stackPop_ExpectAndReturn(&opeStack,token6);
stackPop_ExpectAndReturn(&numStack,token7);
stackPop_ExpectAndReturn(&numStack,token5);
createNumberToken_ExpectAndReturn(20,tempAnsToken2);
stackPush_Expect(tempAnsToken2,&numStack);
stackPop_ExpectAndReturn(&opeStack,token4);
stackPop_ExpectAndReturn(&numStack,tempAnsToken2);
stackPop_ExpectAndReturn(&numStack,tempAnsToken1);
createNumberToken_ExpectAndReturn(26,tempAnsToken3);
stackPush_Expect(tempAnsToken3,&numStack);
stackPop_ExpectAndReturn(&opeStack,NULL);
stackPush_Expect(token8,&opeStack);
//Token number 6
getToken_ExpectAndReturn(&tokenizer,token9);
isNumber_ExpectAndReturn(token9,1);
stackPush_Expect(token9,&numStack);
getToken_ExpectAndReturn(&tokenizer,NULL);
//Evaluate expression
stackPop_ExpectAndReturn(&opeStack,token8);
stackPop_ExpectAndReturn(&numStack,token9);
stackPop_ExpectAndReturn(&numStack,tempAnsToken3);
createNumberToken_ExpectAndReturn(32,finalAnsToken);
stackPush_Expect(finalAnsToken,&numStack);
stackPop_ExpectAndReturn(&opeStack,NULL);
stackPop_ExpectAndReturn(&numStack,finalAnsToken);
destroyStack_Expect(&numStack);
destroyStack_Expect(&opeStack);
check=evaluate("2*3+4*5+6");
TEST_ASSERT_EQUAL(32,check);
printf("Answer : %d ",check);
}
void test_2_OR_3_PLUS_4_MULTIPLY_5_MINUS_6_MINUS_10(void){
int check;
String tokenizer = {.rawString = "2|3+4*5-6-10", .startIndex = 0, .length = 11};
Number number2 = {.type= NUMBER, .value=2};
Token *token1 = (Token*)&number2;
Operator OR = {.type= OPERATOR, .id = BITWISE_OR ,.precedence=10};
Token *token2 = (Token*)&OR;
Number number3 = {.type= NUMBER, .value=3};
Token *token3 = (Token*)&number3;
Operator plus = {.type= OPERATOR, .id = ADD ,.precedence=70};
Token *token4 = (Token*)+
Number number4 = {.type= NUMBER, .value=4};
Token *token5 = (Token*)&number4;
Operator multiply = {.type= OPERATOR, .id = MULTIPLY ,.precedence=100};
Token *token6 = (Token*)&multiply;
Number number5 = {.type= NUMBER, .value=5};
Token *token7 = (Token*)&number5;
Operator subtract = {.type= OPERATOR, .id = SUBTRACT ,.precedence=70};
Token *token8 = (Token*)&subtract;
Number number6 = {.type= NUMBER, .value=6};
Token *token9 = (Token*)&number6;
Operator subtract1 = {.type= OPERATOR, .id = SUBTRACT ,.precedence=70};
Token *token10 = (Token*)&subtract1;
Number number10 = {.type= NUMBER, .value=10};
Token *token11 = (Token*)&number10;
Number tempAnswer1 = {.type=NUMBER, .value=20};
Token *tempAnsToken1 = (Token*)&tempAnswer1;
Number tempAnswer2 = {.type=NUMBER, .value=23};
Token *tempAnsToken2 = (Token*)&tempAnswer2;
Number tempAnswer3 = {.type=NUMBER, .value=17};
Token *tempAnsToken3 = (Token*)&tempAnswer3;
Number tempAnswer4 = {.type=NUMBER, .value=7};
Token *tempAnsToken4 = (Token*)&tempAnswer4;
Number finalAnswer = {.type=NUMBER, .value=7};
Token *finalAnsToken = (Token*)&finalAnswer;
//Evaluate the expression
createStack_ExpectAndReturn(&numStack);
createStack_ExpectAndReturn(&opeStack);
stringCreate_ExpectAndReturn("2|3+4*5-6-10",&tokenizer);
//Token number 2
getToken_ExpectAndReturn(&tokenizer,token1);
isNumber_ExpectAndReturn(token1,1);
stackPush_Expect(token1,&numStack);
//Token operator bitwize OR
getToken_ExpectAndReturn(&tokenizer,token2);
isNumber_ExpectAndReturn(token2,0);
isOperator_ExpectAndReturn(token2,1);
stackPop_ExpectAndReturn(&opeStack,NULL);
stackPush_Expect(token2,&opeStack);
//Token number 3
getToken_ExpectAndReturn(&tokenizer,token3);
isNumber_ExpectAndReturn(token3,1);
stackPush_Expect(token3,&numStack);
//Token operator plus
getToken_ExpectAndReturn(&tokenizer,token4);
isNumber_ExpectAndReturn(token4,0);
isOperator_ExpectAndReturn(token4,1);
stackPop_ExpectAndReturn(&opeStack,token2);
stackPush_Expect(token2,&opeStack);
stackPush_Expect(token4,&opeStack);
//Token number 4
getToken_ExpectAndReturn(&tokenizer,token5);
isNumber_ExpectAndReturn(token5,1);
stackPush_Expect(token5,&numStack);
//Token operator multiply
getToken_ExpectAndReturn(&tokenizer,token6);
isNumber_ExpectAndReturn(token6,0);
isOperator_ExpectAndReturn(token6,1);
stackPop_ExpectAndReturn(&opeStack,token4);
stackPush_Expect(token4,&opeStack);
stackPush_Expect(token6,&opeStack);
//Token number 5
getToken_ExpectAndReturn(&tokenizer,token7);
isNumber_ExpectAndReturn(token7,1);
stackPush_Expect(token7,&numStack);
//Token operator minus
getToken_ExpectAndReturn(&tokenizer,token8);
isNumber_ExpectAndReturn(token8,0);
isOperator_ExpectAndReturn(token8,1);
stackPop_ExpectAndReturn(&opeStack,token6);
stackPop_ExpectAndReturn(&numStack,token7);
stackPop_ExpectAndReturn(&numStack,token5);
createNumberToken_ExpectAndReturn(20,tempAnsToken1);
stackPush_Expect(tempAnsToken1,&numStack);
stackPop_ExpectAndReturn(&opeStack,token4);
stackPop_ExpectAndReturn(&numStack,tempAnsToken1);
stackPop_ExpectAndReturn(&numStack,token3);
createNumberToken_ExpectAndReturn(23,tempAnsToken2);
stackPush_Expect(tempAnsToken2,&numStack);
stackPop_ExpectAndReturn(&opeStack,token2);
stackPush_Expect(token2,&opeStack);
stackPush_Expect(token8,&opeStack);
//Token number 6
getToken_ExpectAndReturn(&tokenizer,token9);
isNumber_ExpectAndReturn(token9,1);
stackPush_Expect(token9,&numStack);
//Token operator minus
getToken_ExpectAndReturn(&tokenizer,token10);
isNumber_ExpectAndReturn(token10,0);
isOperator_ExpectAndReturn(token10,1);
stackPop_ExpectAndReturn(&opeStack,token8);
stackPop_ExpectAndReturn(&numStack,token9);
stackPop_ExpectAndReturn(&numStack,tempAnsToken2);
createNumberToken_ExpectAndReturn(17,tempAnsToken3);
stackPush_Expect(tempAnsToken3,&numStack);
stackPop_ExpectAndReturn(&opeStack,token2);
stackPush_Expect(token2,&opeStack);
stackPush_Expect(token10,&opeStack);
//Token number 10
getToken_ExpectAndReturn(&tokenizer,token11);
isNumber_ExpectAndReturn(token11,1);
stackPush_Expect(token11,&numStack);
getToken_ExpectAndReturn(&tokenizer,NULL);
//Evaluate expression
stackPop_ExpectAndReturn(&opeStack,token10);
stackPop_ExpectAndReturn(&numStack,token11);
stackPop_ExpectAndReturn(&numStack,tempAnsToken3);
createNumberToken_ExpectAndReturn(7,tempAnsToken4);
stackPush_Expect(tempAnsToken4,&numStack);
stackPop_ExpectAndReturn(&opeStack,token2);
stackPop_ExpectAndReturn(&numStack,tempAnsToken4);
stackPop_ExpectAndReturn(&numStack,token1);
createNumberToken_ExpectAndReturn(7,finalAnsToken);
stackPush_Expect(finalAnsToken,&numStack);
stackPop_ExpectAndReturn(&opeStack,NULL);
stackPop_ExpectAndReturn(&numStack,finalAnsToken);
destroyStack_Expect(&numStack);
destroyStack_Expect(&opeStack);
check=evaluate("2|3+4*5-6-10");
TEST_ASSERT_EQUAL(7,check);
printf("Answer : %d ",check);
}
void test_should_evaluate_43_HASHTAG_42_and_throw_error_invalid_operator(void){
Stack dataStack;
Stack operatorStack;
int check;
Error e;
//Initialize tokenizer,token and stack
String tokenizer = {.rawString = "43)42", .startIndex = 0};
Number number43 = {.type= NUMBER, .value=43};
Token *token1 = (Token*)&number43;
Operator hashtag = {.type= OPERATOR, .id=RIGHT_PARENTHESIS, .precedence=50};
Token *token2 = (Token*)&hashtag;
Number number42 = {.type= NUMBER, .value=42};
Token *token3 = (Token*)&number42;
createStack_ExpectAndReturn(&dataStack);
createStack_ExpectAndReturn(&operatorStack);
stringCreate_ExpectAndReturn("43#42",&tokenizer);
//44
getToken_ExpectAndReturn(&tokenizer,token1);
isNumber_ExpectAndReturn(token1,1);
stackPush_Expect(token1,&dataStack);
//HASHTAG
getToken_ExpectAndThrow(&tokenizer,UNKNOWN_OPERATOR);
Try{
evaluate("43#42");
TEST_FAIL_MESSAGE("Should throw ERR_INVALID_OPERATOR");
}Catch(e){
TEST_ASSERT_EQUAL(UNKNOWN_OPERATOR,e);
}
}
void test_should_evaluate_left_parenthesis_2_right_parenthesis(void){
Stack dataStack;
Stack operatorStack;
int check;
int e;
//Initialize tokenizer,token and stack
String tokenizer = {.rawString = "(2)", .startIndex = 0, .length = 3};
Operator leftBracket = {.type= OPERATOR, .id = LEFT_PARENTHESIS ,.precedence=2};
Token *token1 = (Token*)&leftBracket;
Number number2 = {.type= NUMBER, .value=2};
Token *token2 = (Token*)&number2;
Operator rightBracket = {.type= OPERATOR, .id = RIGHT_PARENTHESIS ,.precedence=1};
Token *token3 = (Token*)&rightBracket;
Number answer = {.type= NUMBER, .value=2};
Token *answerToken = (Token*)&answer;
createStack_ExpectAndReturn(&dataStack);
createStack_ExpectAndReturn(&operatorStack);
stringCreate_ExpectAndReturn("(2)",&tokenizer);
//Operator token left parenthesis
getToken_ExpectAndReturn(&tokenizer,token1);
isNumber_ExpectAndReturn(token1,0);
isOperator_ExpectAndReturn(token1,1);
stackPop_ExpectAndReturn(&operatorStack,NULL); //If operator stack is null,
stackPush_Expect(token1,&operatorStack); //then push a operator token inside
//Number2
getToken_ExpectAndReturn(&tokenizer,token2);
isNumber_ExpectAndReturn(token2,1);
stackPush_Expect(token2,&dataStack);
//Operator token right parenthesis
getToken_ExpectAndReturn(&tokenizer,token3);
isNumber_ExpectAndReturn(token3,0);
isOperator_ExpectAndReturn(token3,1);
stackPop_ExpectAndReturn(&operatorStack,token1); //Operator stack has token1 inside
stackPop_ExpectAndReturn(&dataStack,token2); //Once left and right bracket is detected, pop the token1 and number token and evaluate
createNumberToken_ExpectAndReturn(2,answerToken);
stackPush_Expect(answerToken,&dataStack);
stackPop_ExpectAndReturn(&operatorStack,NULL);
getToken_ExpectAndReturn(&tokenizer,NULL);
//Evaluate
stackPop_ExpectAndReturn(&operatorStack,NULL);
stackPop_ExpectAndReturn(&dataStack,answerToken);
destroyStack_Expect(&dataStack);
destroyStack_Expect(&operatorStack);
check=evaluate("(2)");
TEST_ASSERT_EQUAL(2,check);
printf("Answer : %d ",check);
}
void test_should_evaluate_left_parenthesis_22_right_parenthesis(void){
Stack dataStack;
Stack operatorStack;
int check;
int e;
//Initialize tokenizer,token and stack
String tokenizer = {.rawString = "(22)", .startIndex = 0, .length = 3};
Operator leftBracket = {.type= OPERATOR, .id = LEFT_PARENTHESIS ,.precedence=2};
Token *token1 = (Token*)&leftBracket;
Number number22 = {.type= NUMBER, .value=22};
Token *token2 = (Token*)&number22;
Operator rightBracket = {.type= OPERATOR, .id = RIGHT_PARENTHESIS ,.precedence=1};
Token *token3 = (Token*)&rightBracket;
Number answer = {.type= NUMBER, .value=22};
Token *answerToken = (Token*)&answer;
createStack_ExpectAndReturn(&dataStack);
createStack_ExpectAndReturn(&operatorStack);
stringCreate_ExpectAndReturn("(22)",&tokenizer);
//Operator token left parenthesis
getToken_ExpectAndReturn(&tokenizer,token1);
isNumber_ExpectAndReturn(token1,0);
isOperator_ExpectAndReturn(token1,1);
stackPop_ExpectAndReturn(&operatorStack,NULL);
stackPush_Expect(token1,&operatorStack);
//Number22
getToken_ExpectAndReturn(&tokenizer,token2);
isNumber_ExpectAndReturn(token2,1);
stackPush_Expect(token2,&dataStack);
//Operator token right parenthesis
getToken_ExpectAndReturn(&tokenizer,token3);
isNumber_ExpectAndReturn(token3,0);
isOperator_ExpectAndReturn(token3,1);
stackPop_ExpectAndReturn(&operatorStack,token1);
stackPop_ExpectAndReturn(&dataStack,token2);
createNumberToken_ExpectAndReturn(22,answerToken);
stackPush_Expect(answerToken,&dataStack);
stackPop_ExpectAndReturn(&operatorStack,NULL);
getToken_ExpectAndReturn(&tokenizer,NULL);
//Evaluate
stackPop_ExpectAndReturn(&operatorStack,NULL);
stackPop_ExpectAndReturn(&dataStack,answerToken);
destroyStack_Expect(&dataStack);
destroyStack_Expect(&operatorStack);
check=evaluate("(22)");
TEST_ASSERT_EQUAL(22,check);
printf("Answer : %d ",check);
}
void test_left_bracket_2_plus_3_right_bracket(void){
Stack dataStack;
Stack operatorStack;
int check;
//Initialize tokenizer,token and stack
String tokenizer = {.rawString = "(2+3)", .startIndex = 0, .length = 5};
Operator leftBracket = {.type= OPERATOR, .id = LEFT_PARENTHESIS ,.precedence=2};
Token *token1 = (Token*)&leftBracket;
Number number2 = {.type= NUMBER, .value=2};
Token *token2 = (Token*)&number2;
Operator plus = {.type= OPERATOR, .id = ADD ,.precedence=60};
Token *token3 = (Token*)+
Number number3 = {.type= NUMBER, .value=3};
Token *token4 = (Token*)&number3;
Operator rightBracket = {.type= OPERATOR, .id = RIGHT_PARENTHESIS ,.precedence=1};
Token *token5 = (Token*)&rightBracket;
Number answer = {.type= NUMBER, .value=5};
Token *ansToken = (Token*)&answer;
createStack_ExpectAndReturn(&dataStack);
createStack_ExpectAndReturn(&operatorStack);
stringCreate_ExpectAndReturn("(2+3)",&tokenizer);
//(
getToken_ExpectAndReturn(&tokenizer,token1);
isNumber_ExpectAndReturn(token1,0);
isOperator_ExpectAndReturn(token1,1);
stackPop_ExpectAndReturn(&operatorStack,NULL);
stackPush_Expect(token1,&operatorStack);
//2
getToken_ExpectAndReturn(&tokenizer,token2);
isNumber_ExpectAndReturn(token2,1);
stackPush_Expect(token2,&dataStack);
//+
getToken_ExpectAndReturn(&tokenizer,token3);
isNumber_ExpectAndReturn(token3,0);
isOperator_ExpectAndReturn(token3,1);
stackPop_ExpectAndReturn(&operatorStack,token1);
stackPush_Expect(token1,&operatorStack);
stackPush_Expect(token3,&operatorStack);
//3
getToken_ExpectAndReturn(&tokenizer,token4);
isNumber_ExpectAndReturn(token4,1);
stackPush_Expect(token4,&dataStack);
//)
getToken_ExpectAndReturn(&tokenizer,token5);
isNumber_ExpectAndReturn(token5,0);
isOperator_ExpectAndReturn(token5,1);
stackPop_ExpectAndReturn(&operatorStack,token3);
stackPop_ExpectAndReturn(&dataStack,token4);
stackPop_ExpectAndReturn(&dataStack,token2);
createNumberToken_ExpectAndReturn(5,ansToken);
stackPush_Expect(ansToken,&dataStack);
stackPop_ExpectAndReturn(&operatorStack,NULL);
getToken_ExpectAndReturn(&tokenizer,NULL);
//Evaluate
stackPop_ExpectAndReturn(&operatorStack,NULL);
stackPop_ExpectAndReturn(&dataStack,ansToken);
destroyStack_Expect(&dataStack);
destroyStack_Expect(&operatorStack);
check=evaluate("(2+3)");
TEST_ASSERT_EQUAL(5,check);
printf("Answer : %d ",check);
}
void test_left_bracket_20_multiply_3_subtract_50_right_bracket(void){
Stack dataStack;
Stack operatorStack;
int check;
//Initialize tokenizer,token and stack
String tokenizer = {.rawString = "(20*3-50)", .startIndex = 0, .length = 7};
Operator leftBracket = {.type= OPERATOR, .id = LEFT_PARENTHESIS ,.precedence=2};
Token *token1 = (Token*)&leftBracket;
Number number20 = {.type= NUMBER, .value=20};
Token *token2 = (Token*)&number20;
Operator multiply = {.type= OPERATOR, .id = MULTIPLY ,.precedence=70};
Token *token3 = (Token*)&multiply;
Number number3 = {.type= NUMBER, .value=3};
Token *token4 = (Token*)&number3;
Operator minus = {.type= OPERATOR, .id = SUBTRACT ,.precedence=60};
Token *token5 = (Token*)−
Number number50 = {.type= NUMBER, .value=50};
Token *token6 = (Token*)&number50;
Operator rightBracket = {.type= OPERATOR, .id = RIGHT_PARENTHESIS ,.precedence=1};
Token *token7 = (Token*)&rightBracket;
Number tempAnswer = {.type= NUMBER, .value=60};
Token *tempAnsToken = (Token*)&tempAnswer;
Number answer = {.type= NUMBER, .value=10};
Token *ansToken = (Token*)&answer;
createStack_ExpectAndReturn(&dataStack);
createStack_ExpectAndReturn(&operatorStack);
stringCreate_ExpectAndReturn("(20*3-50)",&tokenizer);
//(
getToken_ExpectAndReturn(&tokenizer,token1);
isNumber_ExpectAndReturn(token1,0);
isOperator_ExpectAndReturn(token1,1);
stackPop_ExpectAndReturn(&operatorStack,NULL);
stackPush_Expect(token1,&operatorStack);
//20
getToken_ExpectAndReturn(&tokenizer,token2);
isNumber_ExpectAndReturn(token2,1);
stackPush_Expect(token2,&dataStack);
//*
getToken_ExpectAndReturn(&tokenizer,token3);
isNumber_ExpectAndReturn(token3,0);
isOperator_ExpectAndReturn(token3,1);
stackPop_ExpectAndReturn(&operatorStack,token1);
stackPush_Expect(token1,&operatorStack);
stackPush_Expect(token3,&operatorStack);
//3
getToken_ExpectAndReturn(&tokenizer,token4);
isNumber_ExpectAndReturn(token4,1);
stackPush_Expect(token4,&dataStack);
//-
getToken_ExpectAndReturn(&tokenizer,token5);
isNumber_ExpectAndReturn(token5,0);
isOperator_ExpectAndReturn(token5,1);
stackPop_ExpectAndReturn(&operatorStack,token3);
stackPop_ExpectAndReturn(&dataStack,token4);
stackPop_ExpectAndReturn(&dataStack,token2);
createNumberToken_ExpectAndReturn(60,tempAnsToken);
stackPush_Expect(tempAnsToken,&dataStack);
stackPop_ExpectAndReturn(&operatorStack,token1);
stackPush_Expect(token1,&operatorStack);
stackPush_Expect(token5,&operatorStack);
//50
getToken_ExpectAndReturn(&tokenizer,token6);
isNumber_ExpectAndReturn(token6,1);
stackPush_Expect(token6,&dataStack);
// )
getToken_ExpectAndReturn(&tokenizer,token7);
isNumber_ExpectAndReturn(token7,0);
isOperator_ExpectAndReturn(token7,1);
stackPop_ExpectAndReturn(&operatorStack,token5);
stackPop_ExpectAndReturn(&dataStack,token6);
stackPop_ExpectAndReturn(&dataStack,tempAnsToken);
createNumberToken_ExpectAndReturn(10,ansToken);
stackPush_Expect(ansToken,&dataStack);
stackPop_ExpectAndReturn(&operatorStack,NULL);
getToken_ExpectAndReturn(&tokenizer,NULL);
//Evaluate
stackPop_ExpectAndReturn(&operatorStack,NULL);
stackPop_ExpectAndReturn(&dataStack,ansToken);
destroyStack_Expect(&dataStack);
destroyStack_Expect(&operatorStack);
check=evaluate("(20*3-50)");
TEST_ASSERT_EQUAL(10,check);
printf("Answer : %d ",check);
}
void test_logic_not_12_SHOULD_RETURN_0(void){
Stack numStack;
Stack opeStack;
int check;
//Initialize tokenizer,token and stack
String tokenizer = {.rawString = "!12", .startIndex = 0, .length = 2 };
Operator logicNot = {.type= OPERATOR, .id = LOGIC_NOT, .precedence=80};
Token *token1 = (Token*)&logicNot;
Number number12 = {.type= NUMBER, .value=12};
Token *token2 = (Token*)&number12;
Number answer = {.type=NUMBER, .value=0};
Token *ansToken = (Token*)&answer;
//Evaluate the expression
createStack_ExpectAndReturn(&numStack);
createStack_ExpectAndReturn(&opeStack);
stringCreate_ExpectAndReturn("!12",&tokenizer);
//Token operator minus
getToken_ExpectAndReturn(&tokenizer,token1);
isNumber_ExpectAndReturn(token1,0);
isOperator_ExpectAndReturn(token1,1);
stackPop_ExpectAndReturn(&opeStack,NULL);
stackPush_Expect(token1,&opeStack);
//Token number 2
getToken_ExpectAndReturn(&tokenizer,token2);
isNumber_ExpectAndReturn(token2,1);
stackPush_Expect(token2,&numStack);
getToken_ExpectAndReturn(&tokenizer,NULL);
//Evaluate
stackPop_ExpectAndReturn(&opeStack,token1);
stackPop_ExpectAndReturn(&numStack,token2);
stackPop_ExpectAndReturn(&numStack,NULL);
createNumberToken_ExpectAndReturn(0,ansToken);
stackPush_Expect(ansToken,&numStack);
stackPop_ExpectAndReturn(&opeStack,NULL);
stackPop_ExpectAndReturn(&numStack,ansToken);
destroyStack_Expect(&numStack);
destroyStack_Expect(&opeStack);
check=evaluate("!12");
TEST_ASSERT_EQUAL(0,check);
printf("Answer : %d ",check);
}
void test_NEGATIVE_2_SHOULD_RETURN_NEGATIVE_2(void){
Stack numStack;
Stack opeStack;
int check;
//Initialize tokenizer,token and stack
String tokenizer = {.rawString = "-2", .startIndex = 0, .length = 2 };
Operator subtract = {.type= OPERATOR, .id = SUBTRACT, .precedence=60};
Token *token1 = (Token*)&subtract;
Number number2 = {.type= NUMBER, .value=2};
Token *token2 = (Token*)&number2;
Number answer = {.type=NUMBER, .value=-2};
Token *ansToken = (Token*)&answer;
//Evaluate the expression
createStack_ExpectAndReturn(&numStack);
createStack_ExpectAndReturn(&opeStack);
stringCreate_ExpectAndReturn("-2",&tokenizer);
//Token operator minus
getToken_ExpectAndReturn(&tokenizer,token1);
isNumber_ExpectAndReturn(token1,0);
isOperator_ExpectAndReturn(token1,1);
stackPop_ExpectAndReturn(&opeStack,NULL);
stackPush_Expect(token1,&opeStack);
//Token number 2
getToken_ExpectAndReturn(&tokenizer,token2);
isNumber_ExpectAndReturn(token2,1);
stackPush_Expect(token2,&numStack);
getToken_ExpectAndReturn(&tokenizer,NULL);
//Evaluate
stackPop_ExpectAndReturn(&opeStack,token1);
stackPop_ExpectAndReturn(&numStack,token2);
stackPop_ExpectAndReturn(&numStack,NULL);
createNumberToken_ExpectAndReturn(-2,ansToken);
stackPush_Expect(ansToken,&numStack);
stackPop_ExpectAndReturn(&opeStack,NULL);
stackPop_ExpectAndReturn(&numStack,ansToken);
destroyStack_Expect(&numStack);
destroyStack_Expect(&opeStack);
check=evaluate("-2");
TEST_ASSERT_EQUAL(-2,check);
printf("Answer : %d ",check);
}
void test_spiffs_opendir_readdir_rewinddir(const char* dir_prefix)
{
char name_dir_inner_file[64];
char name_dir_inner[64];
char name_dir_file3[64];
char name_dir_file2[64];
char name_dir_file1[64];
snprintf(name_dir_inner_file, sizeof(name_dir_inner_file), "%s/inner/3.txt", dir_prefix);
snprintf(name_dir_inner, sizeof(name_dir_inner), "%s/inner", dir_prefix);
snprintf(name_dir_file3, sizeof(name_dir_file2), "%s/boo.bin", dir_prefix);
snprintf(name_dir_file2, sizeof(name_dir_file2), "%s/2.txt", dir_prefix);
snprintf(name_dir_file1, sizeof(name_dir_file1), "%s/1.txt", dir_prefix);
unlink(name_dir_inner_file);
rmdir(name_dir_inner);
unlink(name_dir_file1);
unlink(name_dir_file2);
unlink(name_dir_file3);
rmdir(dir_prefix);
test_spiffs_create_file_with_text(name_dir_file1, "1\n");
test_spiffs_create_file_with_text(name_dir_file2, "2\n");
test_spiffs_create_file_with_text(name_dir_file3, "\01\02\03");
test_spiffs_create_file_with_text(name_dir_inner_file, "3\n");
DIR* dir = opendir(dir_prefix);
TEST_ASSERT_NOT_NULL(dir);
int count = 0;
const char* names[4];
while(count < 4) {
struct dirent* de = readdir(dir);
if (!de) {
break;
}
printf("found '%s'\n", de->d_name);
if (strcasecmp(de->d_name, "1.txt") == 0) {
TEST_ASSERT_TRUE(de->d_type == DT_REG);
names[count] = "1.txt";
++count;
} else if (strcasecmp(de->d_name, "2.txt") == 0) {
TEST_ASSERT_TRUE(de->d_type == DT_REG);
names[count] = "2.txt";
++count;
} else if (strcasecmp(de->d_name, "inner/3.txt") == 0) {
TEST_ASSERT_TRUE(de->d_type == DT_REG);
names[count] = "inner/3.txt";
++count;
} else if (strcasecmp(de->d_name, "boo.bin") == 0) {
TEST_ASSERT_TRUE(de->d_type == DT_REG);
names[count] = "boo.bin";
++count;
} else {
TEST_FAIL_MESSAGE("unexpected directory entry");
}
}
TEST_ASSERT_EQUAL(count, 4);
rewinddir(dir);
struct dirent* de = readdir(dir);
TEST_ASSERT_NOT_NULL(de);
TEST_ASSERT_EQUAL(0, strcasecmp(de->d_name, names[0]));
seekdir(dir, 3);
de = readdir(dir);
TEST_ASSERT_NOT_NULL(de);
TEST_ASSERT_EQUAL(0, strcasecmp(de->d_name, names[3]));
seekdir(dir, 1);
de = readdir(dir);
TEST_ASSERT_NOT_NULL(de);
TEST_ASSERT_EQUAL(0, strcasecmp(de->d_name, names[1]));
seekdir(dir, 2);
de = readdir(dir);
TEST_ASSERT_NOT_NULL(de);
TEST_ASSERT_EQUAL(0, strcasecmp(de->d_name, names[2]));
TEST_ASSERT_EQUAL(0, closedir(dir));
}
void
test_ofp_flow_reply_create_02(void) {
lagopus_result_t ret = LAGOPUS_RESULT_ANY_FAILURES;
struct flow_stats *flow_stats = NULL;
struct match *match = NULL;
const char *header_data[2] = {
"04 13 ff b8 00 00 00 10 00 01 00 01 00 00 00 00 ",
"04 13 00 58 00 00 00 10 00 01 00 00 00 00 00 00 "
};
const char *body_data[2] = {
"00 48 01 00 00 00 00 02 00 00 00 03 00 04 00 05 "
"00 06 00 07 00 00 00 00 00 00 00 00 00 00 00 08 "
"00 00 00 00 00 00 00 09 00 00 00 00 00 00 00 0a "
"00 01 00 18 00 00 01 10 00 00 00 00 00 00 00 00 "
"00 00 00 00 00 00 00 00",
"00 48 01 00 00 00 00 02 00 00 00 03 00 04 00 05 "
"00 06 00 07 00 00 00 00 00 00 00 00 00 00 00 08 "
"00 00 00 00 00 00 00 09 00 00 00 00 00 00 00 0a "
"00 01 00 18 00 00 01 10 00 00 00 00 00 00 00 00 "
"00 00 00 00 00 00 00 00"
};
size_t nums[2] = {909, 1};
int i;
/* data */
TAILQ_INIT(&s_flow_stats_list);
for (i = 0; i < 910; i++) {
if ((flow_stats = s_flow_stats_alloc()) != NULL) {
/* flow_stats = 48, match = 24, sum = 72 */
flow_stats->ofp.length = 0;
flow_stats->ofp.table_id = 0x01;
flow_stats->ofp.duration_sec = 0x02;
flow_stats->ofp.duration_nsec = 0x03;
flow_stats->ofp.priority = 0x04;
flow_stats->ofp.idle_timeout = 0x05;
flow_stats->ofp.hard_timeout = 0x06;
flow_stats->ofp.flags = 0x07;
flow_stats->ofp.cookie = 0x08;
flow_stats->ofp.packet_count = 0x09;
flow_stats->ofp.byte_count = 0x0a;
if ((match = match_alloc(16)) != NULL) {
match->oxm_class = 0x00;
match->oxm_field = 0x01;
match->oxm_length = 0x10;
TAILQ_INSERT_TAIL(&(flow_stats->match_list), match, entry);
}
TAILQ_INSERT_TAIL(&s_flow_stats_list, flow_stats, entry);
} else {
TEST_FAIL_MESSAGE("allocation error.");
}
}
ret = check_pbuf_list_across_packet_create(s_ofp_flow_reply_create_wrap,
header_data, body_data, nums, 2);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_OK, ret, "create port 0 error.");
/* free */
while ((flow_stats = TAILQ_FIRST(&s_flow_stats_list)) != NULL) {
TAILQ_REMOVE(&s_flow_stats_list, flow_stats, entry);
ofp_match_list_elem_free(&flow_stats->match_list);
ofp_instruction_list_elem_free(&flow_stats->instruction_list);
free(flow_stats);
}
}
