void MyMoneyBalanceCacheTest::testClear()
{
QVERIFY(m->size() == 0);
testInsert();
QVERIFY(m->size() == 4);
// Delete an item that is not in the cache. The cache should
// be unaffected.
m->clear("A000003", QDate(2010, 9, 17));
QVERIFY(m->size() == 4);
// Now delete a value before the last one in the account.
// All values after it should also be gone.
m->clear("A000001", QDate(2010, 9, 17));
QVERIFY(m->size() == 3);
// Verify that the items not deleted still exist
m->clear("A000001");
QVERIFY(m->size() == 2);
m->clear();
QVERIFY(m->size() == 0);
// Verify that searching for something not in the list is safe
try {
m->clear("A000001");
} catch (const MyMoneyException &) {
QFAIL("Unexpected exception");
}
}
//main()
int main(int argc, char** argv){
bool is_colored = (argc > 1 && tolower(argv[1][0]) == 'c') && isatty(STDOUT_FILENO);
colored_out coloroutput;
if (is_colored)
{
coloroutput.set_expected_file("soln_testbst.out");
int status = coloroutput.start();
if (status < 0) return 0;
}
cout << "\t\t\tTESTING INSERTIONS\n\n";
testInsert();
cout << "\t\t\tTESTING FINDS\n\n";
testFind();
cout << "\t\t\tTESTING REMOVALS\n\n";
testRemove();
cout << "\t\t\tTESTING KEY SORT\n\n";
testKeySort();
cout << "\t\t\tTESTING LEVEL ORDER\n\n";
testLevelOrder();
return 0;
}
int main(void) {
testInsert();
testDelete();
testSearch();
testHeight();
testIsCorrectBST();
}
void runTests(void) {
testNewHeap();
testFindLargestChild();
testDelete();
testInsert();
testSort();
}
int main()
{
AString error;
AUrl url("odbc://*****:*****@localhost/aos_global/");
AODBCServer db(url);
//a_AMySQLServer equivalent
// AUrl url("mysql://*****:*****@localhost/aos/");
// AMySQLServer db(url);
if (!db.init(error))
{
db.debugDump();
std::cerr << error << std::endl;
return -1;
}
testInsert(db);
testUpdate(db);
testSelect(db);
testDelete(db);
return 0;
}
int
main(int argc, char **argv)
{
testNew();
testFree();
testInsert();
UnitTest_report();
}
int main()
{
testInOrderPrint();
testPreOrderPrint();
testPostOrderPrint();
testSearch();
testIsEquiv();
testInsert();
printf("###########################\n");
}
void MyMoneyBalanceCacheTest::testRetrieve()
{
testInsert();
MyMoneyBalanceCacheItem item = m->balance("A000003", QDate(2010, 9, 17));
QVERIFY(! item.isValid());
item = m->balance("A000001", QDate(2010, 9, 16));
QVERIFY(item.isValid());
QVERIFY(item.balance() == MyMoneyMoney(10, 100));
QVERIFY(item.date() == QDate(2010, 9, 16));
item = m->balance("A000001", QDate(2010, 9, 17));
QVERIFY(! item.isValid());
item = m->balance("A000001", QDate(2010, 9, 18));
QVERIFY(item.isValid());
QVERIFY(item.balance() == MyMoneyMoney(20, 100));
QVERIFY(item.date() == QDate(2010, 9, 18));
// Test bad acct
item = m->mostRecentBalance("A000003", QDate(2010, 9, 17));
QVERIFY(! item.isValid());
// Test date too old
item = m->mostRecentBalance("A000001", QDate(2010, 9, 15));
QVERIFY(!item.isValid());
// Test date found
item = m->mostRecentBalance("A000001", QDate(2010, 9, 16));
QVERIFY(item.isValid());
QVERIFY(item.balance() == MyMoneyMoney(10, 100));
QVERIFY(item.date() == QDate(2010, 9, 16));
// Test date in between
item = m->mostRecentBalance("A000001", QDate(2010, 9, 17));
QVERIFY(item.isValid());
QVERIFY(item.balance() == MyMoneyMoney(10, 100));
QVERIFY(item.date() == QDate(2010, 9, 16));
// Test date found
item = m->mostRecentBalance("A000001", QDate(2010, 9, 18));
QVERIFY(item.isValid());
QVERIFY(item.balance() == MyMoneyMoney(20, 100));
QVERIFY(item.date() == QDate(2010, 9, 18));
// Test date later than all entries
item = m->mostRecentBalance("A000001", QDate(2010, 9, 19));
QVERIFY(item.isValid());
QVERIFY(item.balance() == MyMoneyMoney(20, 100));
QVERIFY(item.date() == QDate(2010, 9, 18));
}
bool TestBTree::doTest()
{
if( benchmark )
{
doBenchmark();
return true;
}
else
{
return testRandom() && testClear() && testIteration()
&& testComparisons() && testSearching() && testSwap()
&& testInsert() && testErase() && testCopy();
}
}
int main() {
testCreate();
// TODO insert duplicate
testInsert();
// Linked list head delete test
/*LL_Delete( &head, 2, compare_ints );*/
/*LL_Delete( &head, 8, compare_ints );*/
/*LL_show(head);*/
printf("\nEnd of program.");
// 2 4 8
return EXIT_SUCCESS;
}
int main()
{
TerminalState *state = new VTTerminalState();
Logger::getInstance()->setLogLevel(Logger::ERROR);
state->enableShiftText(true);
//Populate test data.
for (int i = 0; i < 40; i++)
{
for (int j = 0; j < 80; j++)
{
terminalBuffer[i][j] = (rand() % 95) + 32;
}
}
testInit(state);
testCursor(state);
testOrigin(state);
testCursorMoveBackward(state);
testCursorMoveForward(state);
testCursorMoveUp(state);
testCursorMoveDown(state);
state->addTerminalModeFlags(TS_TM_ORIGIN);
testCursorMoveBackward(state);
testCursorMoveForward(state);
state->removeTerminalModeFlags(TS_TM_ORIGIN);
testCursorMoveUpOrigin(state);
testCursorMoveDownOrigin(state);
testInsert(state);
testExpandedBuffer(state);
testErase(state);
testInsertShift(state);
testDelete(state);
testVT((VTTerminalState *)state);
testGraphicsState();
delete state;
return 0;
}
int main() {
printf("\n---------Test de parcours de l'arbre de test---------\n");
Client* sentinelle = createSampleTree();
printf("\n\nParcours Prefixe : \n");
parcoursPrefixe(sentinelle);
printf("\n\nParcours Infixe : \n");
parcoursInfixe(sentinelle);
freeTree(sentinelle);
printf("\n---------Création d'un arbre par insertion aléatoire de ces mêmes éléments---------\n");
sentinelle = testInsert();
printf("\n\nParcours Infixe testInsert : \n");
parcoursInfixe(sentinelle);
printf("\n\nParcours Prefixe testInsert : \n");
parcoursPrefixe(sentinelle);
printf("\n\nsuppression de 1 : \n");
deleteNode(sentinelle, 1);
parcoursPrefixe(sentinelle);
printf("\n\nsuppression de 7 : \n");
deleteNode(sentinelle, 7);
parcoursPrefixe(sentinelle);
freeTree(sentinelle);
printf("\n---------Création d'un arbre pour test du cas doubleBlack---------\n");
sentinelle = createSampleTreeDoubleBlack();
parcoursPrefixe(sentinelle);
printf("\n\nsuppression de 15 : (cas simple)\n");
deleteNode(sentinelle, 15);
parcoursPrefixe(sentinelle);
printf("\n\nsuppression de 14 : (DoubleBlack récursif)\n");
deleteNode(sentinelle, 14);
parcoursPrefixe(sentinelle);
printf("\n\nsuppression de 7 : (root)\n");
deleteNode(sentinelle, 7);
parcoursPrefixe(sentinelle);
// printf("\n\nsuppression de 7 : \n");
// deleteNode(sentinelle, 7);
// parcoursPrefixe(sentinelle);
freeTree(sentinelle);
return 0;
}
void MyMoneyBalanceCacheTest::testEmpty()
{
QVERIFY(m->isEmpty());
testInsert();
QVERIFY(! m->isEmpty());
}
void MyMoneyBalanceCacheTest::testSize()
{
QVERIFY(m->size() == 0);
testInsert();
QVERIFY(m->size() == 4);
}
int main()
{
// testErase();
testInsert();
return 0;
}
void QueryEvaluatorTest::testQE() {
/** SIMPLE source code
procedure First{
x = 2; // 1
z = 3; // 2
call Second;} // 3
procedure Second{
x = 0; // 4
i = 5; // 5
while i { // 6
x = x + 2 * y // 7
if m then { // 8
m = n;} // 9
else {
n = Second;} // 10
call Third; // 11
i = i - 1;} // 12
if x then { // 13
x = x + 1; // 14
while m { // 15
m = m - 1;}} // 16
else {
z = 1;} // 17
z = z + x + i; // 18
y = z + 2; // 19
x = x * y + z;} // 20
procedure Third{
z = 5; // 21
v = z;} // 22
**/
pk = new PKBController();
synonymTable = map<string, string>();
TNode stmt1("ASSIGN_NODE", "x = 2", 1, 0);
TNode stmt2("ASSIGN_NODE", "z = 3", 2, 0);
TNode stmt3("CALL_NODE", "Second", 3, 0);
TNode stmt4("ASSIGN_NODE", "x = 0", 4, 1);
TNode stmt5("ASSIGN_NODE", "i = 5", 5, 1);
TNode stmt6("WHILE_NODE", "i", 6, 1);
TNode stmt7("ASSIGN_NODE", "x = x + 2 * y", 7, 1);
TNode stmt8("IF_NODE", "m", 8, 1);
TNode stmt9("ASSIGN_NODE", "m = n", 9, 1);
TNode stmt10("ASSIGN_NODE", "n = Second", 10, 1);
TNode stmt11("CALL_NODE", "Third", 11, 1);
TNode stmt12("ASSIGN_NODE", "i = i - 1", 12, 1);
TNode stmt13("IF_NODE", "x", 13, 1);
TNode stmt14("ASSIGN_NODE", "x = x + 1", 14, 1);
TNode stmt15("WHILE_NODE", "m", 15, 1);
TNode stmt16("ASSIGN_NODE", "m = m - 1", 16, 1);
TNode stmt17("ASSIGN_NODE", "z = 1", 17, 1);
TNode stmt18("ASSIGN_NODE", "z = z + x + i", 18, 1);
TNode stmt19("ASSIGN_NODE", "y = z + 2", 19, 1);
TNode stmt20("ASSIGN_NODE", "x = x * y + z", 20, 1);
TNode stmt21("ASSIGN_NODE", "z = 5", 21, 2);
TNode stmt22("ASSIGN_NODE", "v = z", 22, 2);
pk->statementTable->insertStatement(&stmt1);
pk->statementTable->insertStatement(&stmt2);
pk->statementTable->insertStatement(&stmt3);
pk->statementTable->insertStatement(&stmt4);
pk->statementTable->insertStatement(&stmt5);
pk->statementTable->insertStatement(&stmt6);
pk->statementTable->insertStatement(&stmt7);
pk->statementTable->insertStatement(&stmt8);
pk->statementTable->insertStatement(&stmt9);
pk->statementTable->insertStatement(&stmt10);
pk->statementTable->insertStatement(&stmt11);
pk->statementTable->insertStatement(&stmt12);
pk->statementTable->insertStatement(&stmt13);
pk->statementTable->insertStatement(&stmt14);
pk->statementTable->insertStatement(&stmt15);
pk->statementTable->insertStatement(&stmt16);
pk->statementTable->insertStatement(&stmt17);
pk->statementTable->insertStatement(&stmt18);
pk->statementTable->insertStatement(&stmt19);
pk->statementTable->insertStatement(&stmt20);
pk->statementTable->insertStatement(&stmt21);
pk->statementTable->insertStatement(&stmt22);
pk->procTable->insertProc("First"); // 0
pk->procTable->insertProc("Second"); // 1
pk->procTable->insertProc("Third"); // 2
pk->varTable->insertVar("x"); // 0
pk->varTable->insertVar("z"); // 1
pk->varTable->insertVar("i"); // 2
pk->varTable->insertVar("y"); // 3
pk->varTable->insertVar("m"); // 4
pk->varTable->insertVar("n"); // 5
pk->varTable->insertVar("Second"); // 6
pk->varTable->insertVar("v"); // 7
pk->constantTable->insertConst(2);
pk->constantTable->insertConst(3);
pk->constantTable->insertConst(0);
pk->constantTable->insertConst(5);
pk->constantTable->insertConst(1);
pk->followsTable->insertFollows(1, 2);
pk->followsTable->insertFollows(2, 3);
pk->followsTable->insertFollows(4, 5);
pk->followsTable->insertFollows(5, 6);
pk->followsTable->insertFollows(6, 13);
pk->followsTable->insertFollows(13, 18);
pk->followsTable->insertFollows(18, 19);
pk->followsTable->insertFollows(19, 20);
pk->followsTable->insertFollows(21, 22);
pk->followsTable->insertFollows(7, 8);
pk->followsTable->insertFollows(8, 11);
pk->followsTable->insertFollows(11, 12);
pk->followsTable->insertFollows(14, 15);
pk->parentTable->insertParent(6, 7);
pk->parentTable->insertParent(6, 8);
pk->parentTable->insertParent(6, 11);
pk->parentTable->insertParent(6, 12);
pk->parentTable->insertParent(8, 9);
pk->parentTable->insertParent(8, 10);
pk->parentTable->insertParent(13, 14);
pk->parentTable->insertParent(13, 15);
pk->parentTable->insertParent(13, 17);
pk->parentTable->insertParent(15, 16);
pk->callsTable->insertCalls(0, 1);
pk->callsTable->insertCalls(1, 2);
pk->modifiesTable->insertModifiesProc(0, 0);
pk->modifiesTable->insertModifiesProc(0, 1);
pk->modifiesTable->insertModifiesProc(0, 2);
pk->modifiesTable->insertModifiesProc(0, 3);
pk->modifiesTable->insertModifiesProc(0, 4);
pk->modifiesTable->insertModifiesProc(0, 5);
pk->modifiesTable->insertModifiesProc(0, 7);
pk->modifiesTable->insertModifiesProc(1, 0);
pk->modifiesTable->insertModifiesProc(1, 1);
pk->modifiesTable->insertModifiesProc(1, 2);
pk->modifiesTable->insertModifiesProc(1, 3);
pk->modifiesTable->insertModifiesProc(1, 4);
pk->modifiesTable->insertModifiesProc(1, 5);
pk->modifiesTable->insertModifiesProc(1, 7);
pk->modifiesTable->insertModifiesProc(2, 1);
pk->modifiesTable->insertModifiesProc(2, 7);
pk->modifiesTable->insertModifiesStmt(1, 0);
pk->modifiesTable->insertModifiesStmt(2, 1);
pk->modifiesTable->insertModifiesStmt(3, 0);
pk->modifiesTable->insertModifiesStmt(3, 2);
pk->modifiesTable->insertModifiesStmt(3, 4);
pk->modifiesTable->insertModifiesStmt(3, 5);
pk->modifiesTable->insertModifiesStmt(3, 1);
pk->modifiesTable->insertModifiesStmt(3, 3);
pk->modifiesTable->insertModifiesStmt(3, 7);
pk->modifiesTable->insertModifiesStmt(4, 0);
pk->modifiesTable->insertModifiesStmt(5, 2);
pk->modifiesTable->insertModifiesStmt(6, 0);
pk->modifiesTable->insertModifiesStmt(6, 4);
pk->modifiesTable->insertModifiesStmt(6, 5);
pk->modifiesTable->insertModifiesStmt(6, 1);
pk->modifiesTable->insertModifiesStmt(6, 7);
pk->modifiesTable->insertModifiesStmt(6, 2);
pk->modifiesTable->insertModifiesStmt(7, 0);
pk->modifiesTable->insertModifiesStmt(8, 4);
pk->modifiesTable->insertModifiesStmt(8, 5);
pk->modifiesTable->insertModifiesStmt(9, 4);
pk->modifiesTable->insertModifiesStmt(10, 5);
pk->modifiesTable->insertModifiesStmt(11, 1);
pk->modifiesTable->insertModifiesStmt(11, 7);
pk->modifiesTable->insertModifiesStmt(12, 2);
pk->modifiesTable->insertModifiesStmt(13, 0);
pk->modifiesTable->insertModifiesStmt(13, 4);
pk->modifiesTable->insertModifiesStmt(13, 1);
pk->modifiesTable->insertModifiesStmt(14, 0);
pk->modifiesTable->insertModifiesStmt(15, 4);
pk->modifiesTable->insertModifiesStmt(16, 4);
pk->modifiesTable->insertModifiesStmt(17, 1);
pk->modifiesTable->insertModifiesStmt(18, 1);
pk->modifiesTable->insertModifiesStmt(19, 3);
pk->modifiesTable->insertModifiesStmt(20, 0);
pk->modifiesTable->insertModifiesStmt(21, 1);
pk->modifiesTable->insertModifiesStmt(22, 7);
pk->usesTable->insertUsesProc(0, 0);
pk->usesTable->insertUsesProc(0, 1);
pk->usesTable->insertUsesProc(0, 2);
pk->usesTable->insertUsesProc(0, 3);
pk->usesTable->insertUsesProc(0, 4);
pk->usesTable->insertUsesProc(0, 5);
pk->usesTable->insertUsesProc(0, 6);
pk->usesTable->insertUsesProc(1, 0);
pk->usesTable->insertUsesProc(1, 1);
pk->usesTable->insertUsesProc(1, 2);
pk->usesTable->insertUsesProc(1, 3);
pk->usesTable->insertUsesProc(1, 4);
pk->usesTable->insertUsesProc(1, 5);
pk->usesTable->insertUsesProc(1, 6);
pk->usesTable->insertUsesProc(2, 1);
pk->usesTable->insertUsesStmt(3, 0);
pk->usesTable->insertUsesStmt(3, 1);
pk->usesTable->insertUsesStmt(3, 2);
pk->usesTable->insertUsesStmt(3, 3);
pk->usesTable->insertUsesStmt(3, 4);
pk->usesTable->insertUsesStmt(3, 5);
pk->usesTable->insertUsesStmt(3, 6);
pk->usesTable->insertUsesStmt(6, 2);
pk->usesTable->insertUsesStmt(6, 0);
pk->usesTable->insertUsesStmt(6, 3);
pk->usesTable->insertUsesStmt(6, 4);
pk->usesTable->insertUsesStmt(6, 5);
pk->usesTable->insertUsesStmt(6, 6);
pk->usesTable->insertUsesStmt(6, 1);
pk->usesTable->insertUsesStmt(7, 0);
pk->usesTable->insertUsesStmt(7, 3);
pk->usesTable->insertUsesStmt(8, 4);
pk->usesTable->insertUsesStmt(8, 5);
pk->usesTable->insertUsesStmt(8, 6);
pk->usesTable->insertUsesStmt(9, 5);
pk->usesTable->insertUsesStmt(10, 6);
pk->usesTable->insertUsesStmt(11, 1);
pk->usesTable->insertUsesStmt(12, 2);
pk->usesTable->insertUsesStmt(13, 0);
pk->usesTable->insertUsesStmt(13, 4);
pk->usesTable->insertUsesStmt(14, 0);
pk->usesTable->insertUsesStmt(15, 4);
pk->usesTable->insertUsesStmt(16, 4);
pk->usesTable->insertUsesStmt(18, 1);
pk->usesTable->insertUsesStmt(18, 0);
pk->usesTable->insertUsesStmt(18, 2);
pk->usesTable->insertUsesStmt(19, 1);
pk->usesTable->insertUsesStmt(20, 0);
pk->usesTable->insertUsesStmt(20, 1);
pk->usesTable->insertUsesStmt(20, 3);
pk->usesTable->insertUsesStmt(22, 1);
pk->constructCalls();
pk->constructFollows();
pk->constructModifies();
pk->constructParent();
// pk->constructNext();
pk->constructUses();
synonymTable["s1"]="stmt";
synonymTable["s2"]="stmt";
synonymTable["a1"]="assign";
synonymTable["a2"]="assign";
synonymTable["w1"]="while";
synonymTable["w2"]="while";
synonymTable["i1"]="if";
synonymTable["i2"]="if";
synonymTable["v1"]="variable";
synonymTable["v2"]="variable";
synonymTable["proc1"]="procedure";
synonymTable["proc2"]="procedure";
synonymTable["c1"]="call";
synonymTable["c2"]="call";
synonymTable["l1"]="prog_line";
synonymTable["l2"]="prog_line";
synonymTable["const1"]="constant";
synonymTable["const2"]="constant";
testInsert();
testValidate();
testConvertString();
}
