#include "StdAfx.h"
#include "UnitTestFrameWork.h"
#include "TestP4BridgeClient.h"
#include "..\p4bridge\P4BridgeServer.h"
#include "..\p4bridge\P4BridgeClient.h"
#include "..\p4bridge\ClientManager.h"
#include "..\p4bridge\P4Connection.h"
#include <strtable.h>
#include <strarray.h>
CREATE_TEST_SUITE(TestP4BridgeClient)
TestP4BridgeClient::TestP4BridgeClient(void)
{
UnitTestSuite::RegisterTest(HandleErrorTest, "HandleErrorTest");
UnitTestSuite::RegisterTest(OutputInfoTest, "OutputInfoTest");
UnitTestSuite::RegisterTest(OutputTextTest, "OutputTextTest");
UnitTestSuite::RegisterTest(OutputBinaryTest, "OutputBinaryTest");
UnitTestSuite::RegisterTest(OutputStatTest, "OutputStatTest");
UnitTestSuite::RegisterTest(HandleErrorCallbackTest, "HandleErrorCallbackTest");
UnitTestSuite::RegisterTest(OutputInfoCallbackTest, "OutputInfoCallbackTest");
UnitTestSuite::RegisterTest(OutputTextCallbackTest, "OutputTextCallbackTest");
UnitTestSuite::RegisterTest(OutputBinaryCallbackTest, "OutputBinaryCallbackTest");
UnitTestSuite::RegisterTest(OutputStatCallbackTest, "OutputStatCallbackTest");
UnitTestSuite::RegisterTest(PromptCallbackTest, "PromptCallbackTest");
}
TestP4BridgeClient::~TestP4BridgeClient(void)
{
}
bool TestP4BridgeClient::Setup()
{
return true;
}
bool TestP4BridgeClient::TearDown(char* testName)
{
p4base::PrintMemoryState(testName);
return true;
}
bool TestP4BridgeClient::HandleErrorTest()
{
P4BridgeServer* pServer = new P4BridgeServer(NULL, NULL, NULL, NULL);
P4Connection* pCon = new P4Connection(NULL, pServer, 7);
P4BridgeClient * ui = new P4BridgeClient(pServer, pCon);
//
ui->OutputError( "Ouch" ); // For broken servers
ui->HandleError( 4, 0, "Failed" );
P4ClientError * pFirstErr = ui->GetErrorResults();
ASSERT_NOT_NULL(pFirstErr)
ASSERT_EQUAL(pFirstErr->Severity, -1)
ASSERT_STRING_EQUAL(pFirstErr->Message, "Ouch")
P4ClientError * pNextErr = pFirstErr->Next;
ASSERT_NOT_NULL(pNextErr)
ASSERT_EQUAL(pNextErr->Severity, 4)
ASSERT_STRING_EQUAL(pNextErr->Message, "Failed")
delete pCon;
delete pServer;
return true;
}
bool TestP4BridgeClient::OutputInfoTest()
{
P4BridgeServer* pServer = new P4BridgeServer(NULL, NULL, NULL, NULL);
P4Connection* pCon = new P4Connection(NULL, pServer, 7);
P4BridgeClient * ui = new P4BridgeClient(pServer, pCon);
//
ui->HandleInfoMsg( 0, '0', "Zero" );
ui->HandleInfoMsg( 1, '1', "One" );
ui->HandleInfoMsg( 2, '2', "Two" );
P4ClientInfoMsg * pInfo = ui->GetInfoResults();
ASSERT_NOT_NULL(pInfo)
P4ClientInfoMsg * pCur = pInfo;
int idx = 0;
while (pCur != NULL)
{
ASSERT_TRUE(((char)'0'+idx) == pCur->Level)
switch (idx)
{
case 0:
ASSERT_TRUE(pCur->Level=='0')
ASSERT_TRUE(pCur->MsgCode==0)
ASSERT_STRING_EQUAL(pCur->Message, "Zero")
break;
case 1:
ASSERT_TRUE(pCur->Level=='1')
ASSERT_TRUE(pCur->MsgCode==1)
ASSERT_STRING_EQUAL(pCur->Message, "One")
break;
case 2:
ASSERT_TRUE(pCur->Level=='2')
ASSERT_TRUE(pCur->MsgCode==2)
ASSERT_STRING_EQUAL(pCur->Message, "Two")
break;
}
pCur = pCur->Next;
idx++;
}
delete pCon;
delete pServer;
return true;
}
bool TestP4BridgeClient::OutputTextTest()
{
P4BridgeServer* pServer = new P4BridgeServer(NULL, NULL, NULL, NULL);
P4Connection* pCon = new P4Connection(NULL, pServer, 7);
P4BridgeClient * ui = new P4BridgeClient(pServer, pCon);
//
ui->OutputText( "Zero\n", 5 );
ui->OutputText( "One\n", 4 );
ui->OutputText( "Two\n", 4 );
StrBuf * pStrBuf = ui->GetTextResults();
ASSERT_NOT_NULL(pStrBuf)
char * pText = CopyStr(pStrBuf->Text());
// split the string into lines:
char seps[] = "\r\n";
int idx = 0;
char* lines[4];
lines[0] = NULL;
char*token = NULL;
token = strtok( pText, seps ); // C4996
while( token != NULL )
{
// While there are tokens in "string"
lines[idx++] = token;
// Get next token:
token = strtok( NULL, seps ); // C4996
}
// should have gotten three lines
ASSERT_EQUAL(idx, 3)
ASSERT_STRING_EQUAL(lines[0], "Zero")
ASSERT_STRING_EQUAL(lines[1], "One")
ASSERT_STRING_EQUAL(lines[2], "Two")
delete[] pText;
delete pCon;
delete pServer;
return true;
}
bool TestP4BridgeClient::OutputBinaryTest()
{
P4BridgeServer* pServer = new P4BridgeServer(NULL, NULL, NULL, NULL);
P4Connection* pCon = new P4Connection(NULL, pServer, 7);
P4BridgeClient * ui = new P4BridgeClient(pServer, pCon);
char * StringData = "Zer\0\nOne\nTw\0\n";
ui->OutputBinary( StringData, 5 );
ui->OutputBinary( (StringData + 5), 4 );
ui->OutputBinary( (StringData + 9), 4 );
void * pBinaryData = ui->GetBinaryResults();
ASSERT_NOT_NULL(pBinaryData)
for (int idx = 0; idx < 13; idx++)
{
ASSERT_EQUAL((((char*)pBinaryData)[idx]), (StringData[idx]))
}
delete pCon;
delete pServer;
return true;
}
StrBufDict* Objects[2];
bool TestP4BridgeClient::OutputStatTest()
{
P4BridgeServer* pServer = new P4BridgeServer(NULL, NULL, NULL, NULL);
P4Connection* pCon = new P4Connection(NULL, pServer, 7);
P4BridgeClient * ui = new P4BridgeClient(pServer, pCon);
StrBufDict * pObj1 = new StrBufDict();
pObj1->SetVar("one", "1");
pObj1->SetVar("two", "2");
pObj1->SetVar("three", "3");
pObj1->SetVar("many", "???");
Objects[0] = pObj1;
ui->OutputStat( pObj1 );
StrBufDict * pObj2 = new StrBufDict();
pObj2->SetVar("A", "Ey?");
pObj2->SetVar("B", "Bee");
pObj2->SetVar("C", "See");
Objects[1] = pObj2;
ui->OutputStat( pObj2 );
StrDictListIterator * pTaggedData = ui->GetTaggedOutput();
ASSERT_NOT_NULL(pTaggedData)
StrDictList * curItem = pTaggedData->GetNextItem();
int objIdx = 0;
while (curItem != NULL)
{
KeyValuePair * curEntry = pTaggedData->GetNextEntry();
while (curEntry != NULL)
{
ASSERT_STRING_EQUAL( curEntry->value, Objects[objIdx]->GetVar(curEntry->key)->Text() )
curEntry = pTaggedData->GetNextEntry();
}
objIdx++;
curItem = pTaggedData->GetNextItem();
}
delete pObj1;
delete pObj2;
delete pTaggedData;
delete pCon;
delete pServer;
return true;
}
bool bPassedCallbacksTests = true;
void __stdcall ErrorCallbackFn(int cmdId, int severity, int errorId, const char* msg)
{
if (cmdId != 7)
{
bPassedCallbacksTests = false;
return;
}
if ((severity == -1) && (strcmp(msg, "Ouch") == 0 ))
return; // correct, so no change
if ((severity == 4) && (strcmp(msg, "Failed") == 0 ))
return; // correct, so no change
// not valid
bPassedCallbacksTests = false;
}
bool TestP4BridgeClient::HandleErrorCallbackTest()
{
P4BridgeServer* pServer = new P4BridgeServer(NULL, NULL, NULL, NULL);
ConnectionManager* conMgr = pServer->ConMgr;
P4Connection* pCon = new P4Connection(conMgr, pServer, 7);
P4BridgeClient * ui = new P4BridgeClient(pServer, pCon);
pCon->ui = ui;
// Set the call back function to receive the error output
pServer->SetErrorCallbackFn(ErrorCallbackFn);
ui->OutputError( "Ouch" ); // For broken servers
ASSERT_TRUE(bPassedCallbacksTests);
ui->HandleError( 4, 0, "Failed" );
ASSERT_TRUE(bPassedCallbacksTests);
// pass some bad pointer for callback function. should not crash
// if we do crash, will be picked up in the unit test framework.
pServer->SetErrorCallbackFn((IntIntIntTextCallbackFn *) 0x00);
ui->OutputError( "Ouch" ); // For broken servers
//still alive
pServer->SetErrorCallbackFn((IntIntIntTextCallbackFn *) 0xFFFFFFFF);
ui->OutputError( "Ouch" ); // For broken servers
//still alive
delete pServer;
return true;
}
void __stdcall InfoOutputCallbackFn(int cmdId, int msgId, int level, const char* msg)
{
if (cmdId != 7)
{
bPassedCallbacksTests = false;
return;
}
if ((level == 0) && (strcmp(msg, "Zero") == 0 ))
return; // correct, so no change
if ((level == 1) && (strcmp(msg, "One") == 0 ))
return; // correct, so no change
if ((level == 2) && (strcmp(msg, "Two") == 0 ))
return; // correct, so no change
// not valid
bPassedCallbacksTests = false;
}
bool TestP4BridgeClient::OutputInfoCallbackTest()
{
P4BridgeServer* pServer = new P4BridgeServer(NULL, NULL, NULL, NULL);
ConnectionManager* conMgr = pServer->ConMgr;
P4Connection* pCon = new P4Connection(conMgr, pServer, 7);
P4BridgeClient * ui = new P4BridgeClient(pServer, pCon);
pCon->ui = ui;
// Set the call back function to receive the error output
pServer->SetInfoResultsCallbackFn(InfoOutputCallbackFn);
ui->HandleInfoMsg( 0, '0', "Zero" );
ASSERT_TRUE(bPassedCallbacksTests);
ui->HandleInfoMsg( 1, '1', "One" );
ASSERT_TRUE(bPassedCallbacksTests);
ui->HandleInfoMsg( 2, '2', "Two" );
ASSERT_TRUE(bPassedCallbacksTests);
// pass some bad pointer for callback function. should not crash
// if we do crash, will be picked up in the unit test framework.
pServer->SetInfoResultsCallbackFn((IntIntIntTextCallbackFn *) 0x00);
ui->HandleInfoMsg( 1, '1', "One" );
//still alive
pServer->SetInfoResultsCallbackFn((IntIntIntTextCallbackFn *) 0xFFFFFFFF);
ui->HandleInfoMsg( 1, '1', "One" );
//still alive
delete pServer;
return true;
}
void __stdcall TextOutputCallbackFn(int cmdId, const char* msg)
{
if (cmdId != 7)
{
bPassedCallbacksTests = false;
return;
}
if (strcmp(msg, "Zero") == 0 )
return; // correct, so no change
if (strcmp(msg, "One") == 0 )
return; // correct, so no change
if (strcmp(msg, "Two") == 0 )
return; // correct, so no change
// not valid
bPassedCallbacksTests = false;
}
bool TestP4BridgeClient::OutputTextCallbackTest()
{
P4BridgeServer* pServer = new P4BridgeServer(NULL, NULL, NULL, NULL);
ConnectionManager* conMgr = pServer->ConMgr;
P4Connection* pCon = new P4Connection(conMgr, pServer, 7);
P4BridgeClient * ui = new P4BridgeClient(pServer, pCon);
pCon->ui = ui;
// Set the call back function to receive the error output
pServer->SetTextResultsCallbackFn(TextOutputCallbackFn);
ui->OutputText( "Zero" , 4 );
ASSERT_TRUE(bPassedCallbacksTests);
ui->OutputText( "One", 3 );
ASSERT_TRUE(bPassedCallbacksTests);
ui->OutputText( "Two", 3 );
ASSERT_TRUE(bPassedCallbacksTests);
// pass some bad pointer for callback function. should not crash
// if we do crash, will be picked up in the unit test framework.
pServer->SetTextResultsCallbackFn((TextCallbackFn *) 0x00);
ui->OutputText( "One", 3 );
//still alive
pServer->SetTextResultsCallbackFn((TextCallbackFn *) 0xFFFFFFFF);
ui->OutputText( "One", 3 );
//still alive
delete pServer;
return true;
}
void __stdcall BinaryResultsCallbackFn( int cmdId, void* msg, int cnt)
{
if (cmdId != 7)
{
bPassedCallbacksTests = false;
return;
}
if ((cnt == 5) && (strncmp((char*) msg, "Zero ", cnt) == 0 ))
return; // correct, so no change
if ((cnt == 4) && (strncmp((char*) msg, "One ", cnt) == 0 ))
return; // correct, so no change
if ((cnt == 3) && (strncmp((char*) msg, "Two", cnt) == 0 ))
return; // correct, so no change
// not valid
bPassedCallbacksTests = false;
}
bool TestP4BridgeClient::OutputBinaryCallbackTest()
{
P4BridgeServer* pServer = new P4BridgeServer(NULL, NULL, NULL, NULL);
ConnectionManager* conMgr = pServer->ConMgr;
P4Connection* pCon = new P4Connection(conMgr, pServer, 7);
P4BridgeClient * ui = new P4BridgeClient(pServer, pCon);
pCon->ui = ui;
pServer->SetBinaryResultsCallbackFn(BinaryResultsCallbackFn);
ui->OutputBinary( "Zero ", 5 );
ASSERT_TRUE(bPassedCallbacksTests);
ui->OutputBinary( "One ", 4 );
ASSERT_TRUE(bPassedCallbacksTests);
ui->OutputBinary( "Two", 3 );
ASSERT_TRUE(bPassedCallbacksTests);
// pass some bad pointer for callback function. should not crash
// if we do crash, will be picked up in the unit test framework.
pServer->SetBinaryResultsCallbackFn((BinaryCallbackFn *) 0x00);
ui->OutputBinary( "One ", 4 );
//still alive
pServer->SetBinaryResultsCallbackFn((BinaryCallbackFn *) 0xFFFFFFFF);
ui->OutputBinary( "One ", 4 );
//still alive
delete pServer;
return true;
}
void __stdcall TaggedOutputCallbackFn(int cmdId, int objId, const char* key, const char* val)
{
if (cmdId != 7)
{
bPassedCallbacksTests = false;
return;
}
if (strcmp(val, Objects[objId]->GetVar(key)->Text() ) == 0)
return; // correct, so no change
// not valid
bPassedCallbacksTests = false;
}
bool TestP4BridgeClient::OutputStatCallbackTest()
{
P4BridgeServer* pServer = new P4BridgeServer(NULL, NULL, NULL, NULL);
ConnectionManager* conMgr = pServer->ConMgr;
P4Connection* pCon = new P4Connection(conMgr, pServer, 7);
P4BridgeClient * ui = new P4BridgeClient(pServer, pCon);
pCon->ui = ui;
pServer->SetTaggedOutputCallbackFn(TaggedOutputCallbackFn);
StrBufDict * pObj1 = new StrBufDict();
pObj1->SetVar("one", "1");
pObj1->SetVar("two", "2");
pObj1->SetVar("three", "3");
pObj1->SetVar("many", "???");
Objects[0] = pObj1;
ui->OutputStat( pObj1 );
ASSERT_TRUE(bPassedCallbacksTests);
StrBufDict * pObj2 = new StrBufDict();
pObj2->SetVar("A", "Ey?");
pObj2->SetVar("B", "Bee");
pObj2->SetVar("C", "See");
Objects[1] = pObj2;
ui->OutputStat( pObj2 );
ASSERT_TRUE(bPassedCallbacksTests);
// pass some bad pointer for callback function. should not crash
// if we do crash, will be picked up in the unit test framework.
pServer->SetTaggedOutputCallbackFn((IntTextTextCallbackFn *) 0x00);
ui->OutputStat( pObj1 );
//still alive
pServer->SetTaggedOutputCallbackFn((IntTextTextCallbackFn *) 0xFFFFFFFF);
ui->OutputStat( pObj1 );
//still alive
// if the callbacks use __stdcall, this will cause the app to have an
// unhandled exception, as it corrupts the stack and the SEH in Windows
// does not catch it. It will be caught if the callbacks use __cdecl,
// unfortunately, we cannot specify the calling convention for a C#
// delegate, so the bridge's caller will have to make sure to pass a
// function correct stack image to the library
// pass a function with the wrong parameter list
//ui->SetTaggedOutputCallbackFn((IntTextTextCallbackFn *) BinaryResultsCallbackFn);
//ui->OutputStat( pObj1 );
//still alive
delete pObj1;
delete pObj2;
delete pServer;
return true;
}
void __stdcall MyPromptCallbackFn(int cmdId, const char * msg, char * rspBuf,
int bufsz, int noEcho)
{
if (cmdId != 7)
{
bPassedCallbacksTests = false;
return;
}
if (strcmp(msg, "What's Up?" ) == 0)
{
strcpy(rspBuf, "The Sky");
return; // correct, so no change
}
// not valid
bPassedCallbacksTests = false;
}
bool TestP4BridgeClient::PromptCallbackTest()
{
P4BridgeServer* pServer = new P4BridgeServer(NULL, NULL, NULL, NULL);
ConnectionManager* conMgr = pServer->ConMgr;
P4Connection* pCon = new P4Connection(conMgr, pServer, 7);
P4BridgeClient * ui = new P4BridgeClient(pServer, pCon);
pCon->ui = ui;
pServer->SetPromptCallbackFn(MyPromptCallbackFn);
StrBuf msg("What's Up?");
StrBuf rsp;
int noEcho = 0;
Error *e = new Error();
ui->Prompt( msg, rsp, noEcho, e );
ASSERT_TRUE(bPassedCallbacksTests);
ASSERT_STRING_EQUAL(rsp.Text(), "The Sky");
ASSERT_TRUE(bPassedCallbacksTests);
// pass some bad pointer for callback function. should not crash
// if we do crash, will be picked up in the unit test framework.
pServer->SetPromptCallbackFn((PromptCallbackFn *) 0x00);
ui->Prompt( msg, rsp, noEcho, e );
//still alive
pServer->SetPromptCallbackFn((PromptCallbackFn *) 0xFFFFFFFF);
ui->Prompt( msg, rsp, noEcho, e );
//still alive
// if the callbacks use __stdcall, this will cause the app to have an
// unhandled exception, as it corrupts the stack and the SEH in Windows
// does not catch it. It will be caught if the callbacks use __cdecl,
// unfortunately, we cannot specify the calling convention for a C#
// delegate, so the bridge's caller will have to make sure to pass a
// function correct stack image to the library
// pass a function with the wrong parameter list
//ui->SetPromptCallbackFn((IntTextTextCallbackFn *) BinaryResultsCallbackFn);
//ui->Prompt( msg, rsp, noEcho, e );
//still alive
delete e;
delete pServer;
return true;
}