void ASTTest::testInstances() {
CPPUNIT_ASSERT(dynamic_cast<AST*>(ast));
AST* asd = AST::getInstance();
AST* qwe = AST::getInstance();
CPPUNIT_ASSERT(asd->contains("Alice"));
CPPUNIT_ASSERT(qwe->contains("Alice"));
ProcNode* pn = new ProcNode("Bob");
StmtLstNode* sln = new StmtLstNode("then");
pn->linkStmtLstNode(sln);
asd->addProcNode(pn);
ProcNode* pget = asd->getProcNode("Bob");
CPPUNIT_ASSERT(NULL != pget);
string expname = "Bob";
CPPUNIT_ASSERT_EQUAL(expname, pget->getName());
CPPUNIT_ASSERT_EQUAL(pn, pget);
StmtLstNode* sget = pget->getStmtLstNode();
CPPUNIT_ASSERT_EQUAL(sln, sget);
string sname = "then";
CPPUNIT_ASSERT_EQUAL(sname, sget->getName());
return;
}
void PQLIntegration::setUp() {
/* testing this source
procedure chocs {
a=4; //1
while i { //2
k = 3; //3
while j { //4
i=1; //5
j=2; //6
}
b=5; //7
j=2+3+4; //8
}
}
*/
// to set up the ast manually
AST* ast = AST::getInstance();
ProcNode* proc = new ProcNode("chocs");
StmtLstNode* procsl = new StmtLstNode();
proc->linkStmtLstNode(procsl);
AssgNode* assg1 = new AssgNode(1);
VarNode* a1 = new VarNode("a");
ConstNode* c1 = new ConstNode("4");
assg1->linkVarNode(a1);
assg1->linkExprNode(c1);
procsl->linkStmtNode(assg1);
WhileNode* while1 = new WhileNode(2);
VarNode* i1 = new VarNode("i");
while1->linkVarNode(i1);
StmtLstNode* whilesl1 = new StmtLstNode();
while1->linkStmtLstNode(whilesl1);
procsl->linkStmtNode(while1);
AssgNode* assg2 = new AssgNode(3);
VarNode* k1 = new VarNode("k");
assg2->linkVarNode(k1);
ConstNode* c2 = new ConstNode("3");
assg2->linkExprNode(c2);
whilesl1->linkStmtNode(assg2);
WhileNode* while2 = new WhileNode(4);
VarNode* j1 = new VarNode("j");
while2->linkVarNode(j1);
StmtLstNode* whilesl2 = new StmtLstNode();
while2->linkStmtLstNode(whilesl2);
whilesl1->linkStmtNode(while2);
AssgNode* assg3 = new AssgNode(5);
VarNode* i2 = new VarNode("i");
assg3->linkVarNode(i2);
ConstNode* c3 = new ConstNode("1");
assg3->linkExprNode(c3);
whilesl2->linkStmtNode(assg3);
AssgNode* assg4 = new AssgNode(6);
VarNode* j2 = new VarNode("j");
assg4->linkVarNode(j2);
ConstNode* c4 = new ConstNode("2");
assg4->linkExprNode(c4);
whilesl2->linkStmtNode(assg4);
AssgNode* assg5 = new AssgNode(7);
VarNode* b1 = new VarNode("b");
assg5->linkVarNode(b1);
ConstNode* c5 = new ConstNode("5");
assg5->linkExprNode(c5);
whilesl1->linkStmtNode(assg5);
AssgNode* assg6 = new AssgNode(8);
VarNode* j6 = new VarNode("j");
OpNode* plus2_1 = new OpNode("+");
ConstNode* four2 = new ConstNode("4");
OpNode* plus2_2 = new OpNode("+");
ConstNode* three2 = new ConstNode("3");
ConstNode* two2 = new ConstNode("2");
plus2_2->linkRightNode(three2);
plus2_2->linkLeftNode(two2);
plus2_1->linkRightNode(four2);
plus2_1->linkLeftNode(plus2_2);
assg6->linkVarNode(j6);
assg6->linkExprNode(plus2_1);
procsl->linkStmtNode(assg6);
ast->addProcNode(proc);
// to set up the stmttable manually
StmtTable* stable = StmtTable::getInstance();
Statement* stmt1 = new Statement();
stmt1->setStmtNum(1);
stmt1->setType(ASSIGN_STMT_);
stmt1->setFollowsAfter(2);
string modifiesArray1[] = {"a"};
set<string> mods1(modifiesArray1, modifiesArray1 + 1);
stmt1->setModifies(mods1);
stmt1->setTNodeRef(assg1);
stable->addStmt(stmt1);
Statement* stmt2 = new Statement();
stmt2->setStmtNum(2);
stmt2->setType(WHILE_STMT_);
stmt2->setFollowsBefore(1);
string modifiesArray2[] = {"k", "i", "j", "b"};
set<string> mods2(modifiesArray2, modifiesArray2 + 4);
string usesArray2[] = {"i", "j"};
set<string> uses2(usesArray2, usesArray2 + 2);
stmt2->setModifies(mods2);
stmt2->setUses(uses2);
stmt2->setTNodeRef(while1);
int children2[] = {3, 4, 7};
stmt2->setChildren(set<int>(children2, children2+3));
stable->addStmt(stmt2);
Statement* stmt3 = new Statement();
stmt3->setStmtNum(3);
stmt3->setType(ASSIGN_STMT_);
stmt3->setFollowsAfter(4);
set<string> mods3 = set<string>();
mods3.emplace("k");
stmt3->setModifies(mods3);
stmt3->setTNodeRef(assg2);
stmt3->setParent(2);
stable->addStmt(stmt3);
Statement* stmt4 = new Statement();
stmt4->setStmtNum(4);
stmt4->setType(WHILE_STMT_);
stmt4->setFollowsBefore(3);
stmt4->setFollowsAfter(7);
set<string> mods4 = set<string>();
mods4.emplace("i");
mods4.emplace("j");
set<string> uses4 = set<string>();
uses4.emplace("j");
stmt4->setModifies(mods4);
stmt4->setUses(uses4);
set<int> children3 = *new set<int>();
children3.emplace(5);
children3.emplace(6);
stmt4->setChildren(children3);
stmt4->setTNodeRef(while2);
stmt4->setParent(2);
stable->addStmt(stmt4);
Statement* stmt5 = new Statement();
stmt5->setStmtNum(5);
stmt5->setType(ASSIGN_STMT_);
stmt5->setFollowsAfter(6);
set<string> mods5= set<string>();
mods5.emplace("i");
stmt5->setModifies(mods5);
stmt5->setTNodeRef(assg3);
stmt5->setParent(4);
stable->addStmt(stmt5);
Statement* stmt6 = new Statement();
stmt6->setStmtNum(6);
stmt6->setType(ASSIGN_STMT_);
stmt6->setFollowsBefore(5);
set<string> mods6= set<string>();
mods6.emplace("j");
stmt6->setModifies(mods6);
stmt6->setTNodeRef(assg4);
stmt6->setParent(4);
stable->addStmt(stmt6);
Statement* stmt7 = new Statement();
stmt7->setStmtNum(7);
stmt7->setType(ASSIGN_STMT_);
stmt7->setFollowsBefore(4);
stmt7->setFollowsAfter(8);
set<string> mods7= set<string>();
mods7.emplace("b");
stmt7->setModifies(mods7);
stmt7->setTNodeRef(assg5);
stmt7->setParent(2);
stable->addStmt(stmt7);
Statement* stmt8 = new Statement();
stmt8->setStmtNum(8);
stmt8->setType(ASSIGN_STMT_);
set<string> mods8 = set<string>();
mods8.emplace("j");
stmt8->setModifies(mods8);
stmt8->setFollowsBefore(7);
stmt8->setTNodeRef(assg6);
stmt8->setParent(2);
stable->addStmt(stmt8);
// to set up the vartable manually
VarTable* vtable = VarTable::getInstance();
Variable* va = new Variable("a");
va->addModifyingStmt(1);
va->addTNode(a1);
vtable->addVariable(va);
Variable* vi = new Variable("i");
vi->addModifyingStmt(2);
vi->addModifyingStmt(5);
vi->addUsingStmt(2);
vi->addTNode(i1);
vi->addTNode(i2);
vtable->addVariable(vi);
Variable* vj = new Variable("j");
vj->addModifyingStmt(2);
vj->addModifyingStmt(4);
vj->addModifyingStmt(6);
vj->addModifyingStmt(8);
vj->addUsingStmt(4);
vj->addTNode(j1);
vj->addTNode(j2);
vtable->addVariable(vj);
Variable* vk = new Variable("k");
vk->addModifyingStmt(2);
vk->addModifyingStmt(3);
vk->addTNode(k1);
vtable->addVariable(vk);
Variable* vb = new Variable("b");
vb->addModifyingStmt(2);
vb->addModifyingStmt(7);
vb->addTNode(b1);
vtable->addVariable(vb);
ConstTable* ctable = ConstTable::getInstance();
//Populate Constant Table
Constant* const1 = new Constant();
const1->addAppearsIn(5);
const1->addTNodeRef(c3);
const1->setConstName("1");
ctable->addConst(const1);
Constant* const2 = new Constant();
const2->addAppearsIn(6);
const2->addAppearsIn(8);
const2->addTNodeRef(c4);
const2->addTNodeRef(two2);
const2->setConstName("2");
ctable->addConst(const2);
Constant* const3 = new Constant();
const3->addAppearsIn(3);
const3->addAppearsIn(8);
const3->addTNodeRef(c2);
const3->addTNodeRef(three2);
const3->setConstName("3");
ctable->addConst(const3);
Constant* const4 = new Constant();
const4->addAppearsIn(1);
const4->addAppearsIn(8);
const4->addTNodeRef(c1);
const4->addTNodeRef(four2);
const4->setConstName("4");
ctable->addConst(const4);
Constant* const5 = new Constant();
const5->addAppearsIn(7);
const5->addTNodeRef(c5);
const5->setConstName("5");
ctable->addConst(const5);
}
void QueryEvaluatorTest::setUp() {
/* testing this source
procedure chocs {
a=4;
while i {
k = 3;
while j {
i=1;
j=2;
}
b=5;
}
}
*/
// to set up the ast manually
AST* ast = AST::getInstance();
ProcNode* proc = new ProcNode("chocs");
StmtLstNode* procsl = new StmtLstNode();
proc->linkStmtLstNode(procsl);
AssgNode* assg1 = new AssgNode(1);
VarNode* a1 = new VarNode("a");
assg1->linkVarNode(a1);
ConstNode* cn4 = new ConstNode("4");
assg1->linkExprNode(cn4);
procsl->linkStmtNode(assg1);
WhileNode* while1 = new WhileNode(2);
VarNode* i1 = new VarNode("i");
while1->linkVarNode(i1);
StmtLstNode* whilesl1 = new StmtLstNode();
while1->linkStmtLstNode(whilesl1);
procsl->linkStmtNode(while1);
AssgNode* assg2 = new AssgNode(3);
VarNode* k1 = new VarNode("k");
assg2->linkVarNode(k1);
ConstNode* cn3 = new ConstNode("3");
assg2->linkExprNode(cn3);
whilesl1->linkStmtNode(assg2);
WhileNode* while2 = new WhileNode(4);
VarNode* j1 = new VarNode("j");
while2->linkVarNode(j1);
StmtLstNode* whilesl2 = new StmtLstNode();
while2->linkStmtLstNode(whilesl2);
whilesl1->linkStmtNode(while2);
AssgNode* assg3 = new AssgNode(5);
VarNode* i2 = new VarNode("i");
assg3->linkVarNode(i2);
ConstNode* cn1 = new ConstNode("1");
assg3->linkExprNode(cn1);
whilesl2->linkStmtNode(assg3);
AssgNode* assg4 = new AssgNode(6);
VarNode* j2 = new VarNode("j");
assg4->linkVarNode(j2);
ConstNode* cn2 = new ConstNode("2");
assg4->linkExprNode(cn2);
whilesl2->linkStmtNode(assg4);
AssgNode* assg5 = new AssgNode(7);
VarNode* b1 = new VarNode("b");
assg5->linkVarNode(b1);
ConstNode* cn5 = new ConstNode("5");
assg5->linkExprNode(cn5);
whilesl1->linkStmtNode(assg5);
ast->addProcNode(proc);
// to set up the stmttable manually
StmtTable* stable = StmtTable::getInstance();
Statement* stmt1 = new Statement();
stmt1->setStmtNum(1);
stmt1->setType(ASSIGN_STMT_);
stmt1->setFollowsAfter(2);
string modifiesArray1[] = {"a"};
set<string> mods1(modifiesArray1, modifiesArray1 + 1);
stmt1->setModifies(mods1);
stmt1->setTNodeRef(assg1);
stable->addStmt(stmt1);
Statement* stmt2 = new Statement();
stmt2->setStmtNum(2);
stmt2->setType(WHILE_STMT_);
stmt2->setFollowsBefore(1);
string modifiesArray2[] = {"k", "i", "j", "b"};
set<string> mods2(modifiesArray2, modifiesArray2 + 4);
string usesArray2[] = {"i", "j"};
set<string> uses2(usesArray2, usesArray2 + 2);
stmt2->setModifies(mods2);
stmt2->setUses(uses2);
stmt2->setTNodeRef(while1);
int children2[] = {3, 4, 7};
stmt2->setChildren(set<int>(children2, children2+3));
stable->addStmt(stmt2);
Statement* stmt3 = new Statement();
stmt3->setStmtNum(3);
stmt3->setType(ASSIGN_STMT_);
stmt3->setFollowsAfter(4);
set<string> mods3 = set<string>();
mods3.emplace("k");
stmt3->setModifies(mods3);
stmt3->setTNodeRef(assg2);
stmt3->setParent(2);
stable->addStmt(stmt3);
Statement* stmt4 = new Statement();
stmt4->setStmtNum(4);
stmt4->setType(WHILE_STMT_);
stmt4->setFollowsBefore(3);
stmt4->setFollowsAfter(7);
set<string> mods4 = set<string>();
mods4.emplace("i");
mods4.emplace("j");
set<string> uses4 = set<string>();
uses4.emplace("j");
stmt4->setModifies(mods4);
stmt4->setUses(uses4);
stmt4->setTNodeRef(while2);
stmt4->setParent(2);
stable->addStmt(stmt4);
Statement* stmt5 = new Statement();
stmt5->setStmtNum(5);
stmt5->setType(ASSIGN_STMT_);
stmt5->setFollowsAfter(6);
set<string> mods5= set<string>();
mods5.emplace("i");
stmt5->setModifies(mods5);
stmt5->setTNodeRef(assg3);
stmt5->setParent(4);
stable->addStmt(stmt5);
Statement* stmt6 = new Statement();
stmt6->setStmtNum(6);
stmt6->setType(ASSIGN_STMT_);
stmt6->setFollowsBefore(5);
set<string> mods6= set<string>();
mods6.emplace("j");
stmt6->setModifies(mods6);
stmt6->setTNodeRef(assg4);
stmt6->setParent(4);
stable->addStmt(stmt6);
Statement* stmt7 = new Statement();
stmt7->setStmtNum(7);
stmt7->setType(ASSIGN_STMT_);
stmt7->setFollowsBefore(4);
set<string> mods7= set<string>();
mods7.emplace("b");
stmt7->setModifies(mods7);
stmt7->setTNodeRef(assg5);
stmt7->setParent(2);
stable->addStmt(stmt7);
// to set up the vartable manually
VarTable* vtable = VarTable::getInstance();
Variable* va = new Variable("a");
va->addModifyingStmt(1);
va->addTNode(a1);
vtable->addVariable(va);
Variable* vi = new Variable("i");
vi->addModifyingStmt(2);
vi->addModifyingStmt(5);
vi->addUsingStmt(2);
vi->addTNode(i1);
vi->addTNode(i2);
vtable->addVariable(vi);
Variable* vj = new Variable("j");
vj->addModifyingStmt(2);
vj->addModifyingStmt(4);
vj->addModifyingStmt(6);
vj->addUsingStmt(4);
vj->addTNode(j1);
vj->addTNode(j2);
vtable->addVariable(vj);
Variable* vk = new Variable("k");
vk->addModifyingStmt(2);
vk->addModifyingStmt(3);
vk->addTNode(k1);
vtable->addVariable(vk);
Variable* vb = new Variable("b");
vb->addModifyingStmt(2);
vb->addModifyingStmt(7);
vb->addTNode(b1);
vtable->addVariable(vb);
// to set up the const table manually
/* testing this source
procedure chocs {
a=4;
while i {
k = 3;
while j {
i=1;
j=2;
}
b=5;
}
}
*/
ConstTable* ctable = ConstTable::getInstance();
Constant* c4 = new Constant("4");
c4->addTNodeRef(cn4);
c4->addAppearsIn(1);
ctable->addConst(c4);
Constant* c3 = new Constant("3");
c3->addTNodeRef(cn4);
c3->addAppearsIn(3);
ctable->addConst(c3);
Constant* c1 = new Constant("1");
c1->addTNodeRef(cn3);
c1->addAppearsIn(5);
ctable->addConst(c1);
Constant* c2 = new Constant("2");
c2->addTNodeRef(cn2);
c2->addAppearsIn(6);
ctable->addConst(c2);
Constant* c5 = new Constant("5");
c5->addTNodeRef(cn5);
c5->addAppearsIn(7);
ctable->addConst(c5);
}
void FollowsClauseTest::setUp() {
/* testing this source
procedure zumba {
i = 1; //1
j = 2; //2
k = 3; //3
}
Follows(1, 2) == true;
*/
// to set up the ast manually
AST* ast = AST::getInstance();
ProcNode* proc = new ProcNode("zumba");
StmtLstNode* procsl = new StmtLstNode();
proc->linkStmtLstNode(procsl);
AssgNode* assg1 = new AssgNode(1);
VarNode* i = new VarNode("i");
ConstNode* one = new ConstNode("1");
assg1->linkVarNode(i);
assg1->linkExprNode(one);
procsl->linkStmtNode(assg1);
AssgNode* assg2 = new AssgNode(2);
VarNode* j = new VarNode("j");
ConstNode* two = new ConstNode("2");
assg2->linkVarNode(j);
assg2->linkExprNode(two);
procsl->linkStmtNode(assg2);
AssgNode* assg3 = new AssgNode(3);
VarNode* k = new VarNode("k");
ConstNode* three = new ConstNode("3");
assg3->linkVarNode(j);
assg3->linkExprNode(three);
procsl->linkStmtNode(assg3);
ast->addProcNode(proc);
// to set up the stmttable manually
StmtTable* stable = StmtTable::getInstance();
Statement* stmt1 = new Statement();
stmt1->setStmtNum(1);
stmt1->setType(ASSIGN_STMT_);
stmt1->setFollowsAfter(2);
stable->addStmt(stmt1);
Statement* stmt2 = new Statement();
stmt2->setStmtNum(2);
stmt2->setType(ASSIGN_STMT_);
stmt2->setFollowsBefore(1);
stmt2->setFollowsAfter(3);
stable->addStmt(stmt2);
Statement* stmt3 = new Statement();
stmt3->setStmtNum(3);
stmt3->setType(ASSIGN_STMT_);
stmt3->setFollowsBefore(2);
stable->addStmt(stmt3);
}
void PatternAssgTest::setUp() {
/* testing this source
procedure zumba {
i = 1+2; //1
j = 2+3+4; //2
k = 3; //3
}
Follows(1, 2) == true;
*/
// to set up the ast manually
AST* ast = AST::getInstance();
ProcNode* proc = new ProcNode("zumba");
StmtLstNode* procsl = new StmtLstNode();
proc->linkStmtLstNode(procsl);
AssgNode* assg1 = new AssgNode(1);
VarNode* i1 = new VarNode("i");
assg1->linkVarNode(i1);
OpNode* plus1 = new OpNode("+");
ConstNode* one1 = new ConstNode("1");
ConstNode* two1 = new ConstNode("2");
plus1->linkLeftNode(one1);
plus1->linkRightNode(two1);
assg1->linkExprNode(plus1);
procsl->linkStmtNode(assg1);
AssgNode* assg2 = new AssgNode(2);
VarNode* j2 = new VarNode("j");
OpNode* plus2_1 = new OpNode("+");
ConstNode* four2 = new ConstNode("4");
OpNode* plus2_2 = new OpNode("+");
ConstNode* three2 = new ConstNode("3");
ConstNode* two2 = new ConstNode("2");
plus2_2->linkRightNode(three2);
plus2_2->linkLeftNode(two2);
plus2_1->linkRightNode(four2);
plus2_1->linkLeftNode(plus2_2);
assg2->linkVarNode(j2);
assg2->linkExprNode(plus2_1);
procsl->linkStmtNode(assg2);
AssgNode* assg3 = new AssgNode(3);
VarNode* k3 = new VarNode("k");
ConstNode* three3 = new ConstNode("3");
assg3->linkVarNode(k3);
assg3->linkExprNode(three3);
procsl->linkStmtNode(assg3);
ast->addProcNode(proc);
// to set up the stmttable manually
StmtTable* stable = StmtTable::getInstance();
Statement* stmt1 = new Statement();
stmt1->setStmtNum(1);
stmt1->setType(ASSIGN_STMT_);
stmt1->setFollowsAfter(2);
string ivar = "i";
set<string> uses1 = set<string>();
uses1.emplace(ivar);
stmt1->setModifies(uses1);
stmt1->setTNodeRef(assg1);
stable->addStmt(stmt1);
Statement* stmt2 = new Statement();
stmt2->setStmtNum(2);
stmt2->setType(ASSIGN_STMT_);
stmt2->setFollowsBefore(1);
stmt2->setFollowsAfter(3);
string jvar = "j";
set<string> uses2 = set<string>();
uses2.emplace(jvar);
stmt2->setModifies(uses2);
stmt2->setTNodeRef(assg2);
stable->addStmt(stmt2);
Statement* stmt3 = new Statement();
stmt3->setStmtNum(3);
stmt3->setType(ASSIGN_STMT_);
stmt3->setFollowsBefore(2);
string kvar = "k";
set<string> uses3 = set<string>();
uses3.emplace(kvar);
stmt3->setModifies(uses3);
stmt3->setTNodeRef(assg3);
stable->addStmt(stmt3);
}