static rc testConstant (void) { Constant *c; char *str; c = createConstInt(1); ASSERT_EQUALS_INT(1, INT_VALUE(c), "constant int 1"); c = createConstFloat(2.0); ASSERT_EQUALS_FLOAT(2.0, FLOAT_VALUE(c), "constant float 2.0"); c = createConstBool(TRUE); ASSERT_EQUALS_INT(TRUE, BOOL_VALUE(c), "constant boolean TRUE"); str = strdup("test"); c = createConstString(str); ASSERT_EQUALS_STRING("test", STRING_VALUE(c), "constant string \"test\""); return PASS; }
static rc testFunctionCall(void) { FunctionCall *a; Constant *c; a = createFunctionCall ("f", LIST_MAKE(createConstInt(1), createConstInt(2))); c = (Constant *) getNthOfListP(a->args, 0); ASSERT_EQUALS_INT(1, INT_VALUE(c), "first arg is 1 const"); ASSERT_EQUALS_STRING("f", a->functionname, "function name is f"); return PASS; }
static rc testAttributeReference (void) { AttributeReference *a, *b; a = createAttributeReference("test"); b = makeNode(AttributeReference); b->name = "test"; b->fromClauseItem = INVALID_ATTR; b->attrPosition = INVALID_ATTR; b->outerLevelsUp = INVALID_ATTR; b->attrType = DT_STRING; ASSERT_EQUALS_INT(a->type, T_AttributeReference, "type is attribute reference"); ASSERT_EQUALS_INT(a->type, b->type, "types are the same"); ASSERT_EQUALS_INT(a->fromClauseItem, b->fromClauseItem, "FCI are the same"); ASSERT_EQUALS_INT(INVALID_ATTR, b->fromClauseItem, "b has FCI=invalid"); ASSERT_EQUALS_INT(INVALID_ATTR, a->fromClauseItem, "a has FCI=invlaid"); ASSERT_EQUALS_STRINGP(a->name, b->name, "names are the same"); ASSERT_EQUALS_NODE(a,b,"both attribute references are same"); return PASS; }
static rc testOperator (void) { Operator *a; Constant *c; a = createOpExpr("f", LIST_MAKE(createConstInt(1), createConstInt(2))); c = (Constant *) getNthOfListP(a->args, 0); ASSERT_EQUALS_INT(1, INT_VALUE(c), "first arg is 1 const"); ASSERT_EQUALS_STRING("f", a->name, "op name is f"); return PASS; }
// ************************************************************ void testInsertAndFind (void) { RID insert[] = { {1,1}, {2,3}, {1,2}, {3,5}, {4,4}, {3,2}, }; int numInserts = 6; Value **keys; char *stringKeys[] = { "i1", "i11", "i13", "i17", "i23", "i52" }; testName = "test b-tree inserting and search"; int i, testint; BTreeHandle *tree = NULL; keys = createValues(stringKeys, numInserts); // init TEST_CHECK(initIndexManager(NULL)); printf("\n Init"); TEST_CHECK(createBtree("testidx", DT_INT, 2)); printf("\n Created"); TEST_CHECK(openBtree(&tree, "testidx")); // insert keys for(i = 0; i < numInserts; i++) TEST_CHECK(insertKey(tree, keys[i], insert[i])); // check index stats TEST_CHECK(getNumNodes(tree, &testint)); ASSERT_EQUALS_INT(testint,4, "number of nodes in btree"); TEST_CHECK(getNumEntries(tree, &testint)); ASSERT_EQUALS_INT(testint, numInserts, "number of entries in btree"); // search for keys for(i = 0; i < 1000; i++) { int pos = rand() % numInserts; RID rid; Value *key = keys[pos]; TEST_CHECK(findKey(tree, key, &rid)); ASSERT_EQUALS_RID(insert[pos], rid, "did we find the correct RID?"); } // cleanup TEST_CHECK(closeBtree(tree)); TEST_CHECK(deleteBtree("testidx")); TEST_CHECK(shutdownIndexManager()); freeValues(keys, numInserts); TEST_DONE(); }
// ************************************************************ void testIndexScan (void) { RID insert[] = { {1,1}, {2,3}, {1,2}, {3,5}, {4,4}, {3,2}, }; int numInserts = 6; Value **keys; char *stringKeys[] = { "i1", "i11", "i13", "i17", "i23", "i52" }; testName = "random insertion order and scan"; int i, testint, iter, rc; BTreeHandle *tree = NULL; BT_ScanHandle *sc = NULL; RID rid; keys = createValues(stringKeys, numInserts); // init TEST_CHECK(initIndexManager(NULL)); for(iter = 0; iter < 50; iter++) { int *permute; // create permutation permute = createPermutation(numInserts); // create B-tree TEST_CHECK(createBtree("testidx", DT_INT, 2)); TEST_CHECK(openBtree(&tree, "testidx")); // insert keys for(i = 0; i < numInserts; i++) TEST_CHECK(insertKey(tree, keys[permute[i]], insert[permute[i]])); // check index stats TEST_CHECK(getNumEntries(tree, &testint)); ASSERT_EQUALS_INT(testint, numInserts, "number of entries in btree"); // execute scan, we should see tuples in sort order openTreeScan(tree, &sc); i = 0; while((rc = nextEntry(sc, &rid)) == RC_OK) { RID expRid = insert[i++]; ASSERT_EQUALS_RID(expRid, rid, "did we find the correct RID?"); } ASSERT_EQUALS_INT(RC_IM_NO_MORE_ENTRIES, rc, "no error returned by scan"); ASSERT_EQUALS_INT(numInserts, i, "have seen all entries"); closeTreeScan(sc); // cleanup TEST_CHECK(closeBtree(tree)); TEST_CHECK(deleteBtree("testidx")); free(permute); } TEST_CHECK(shutdownIndexManager()); freeValues(keys, numInserts); TEST_DONE(); }
// test the LRU page replacement strategy void testLRU (void) { // expected results const char *poolContents[] = { // read first five pages and directly unpin them "[0 0],[-1 0],[-1 0],[-1 0],[-1 0]" , "[0 0],[1 0],[-1 0],[-1 0],[-1 0]", "[0 0],[1 0],[2 0],[-1 0],[-1 0]", "[0 0],[1 0],[2 0],[3 0],[-1 0]", "[0 0],[1 0],[2 0],[3 0],[4 0]", // use some of the page to create a fixed LRU order without changing pool content "[0 0],[1 0],[2 0],[3 0],[4 0]", "[0 0],[1 0],[2 0],[3 0],[4 0]", "[0 0],[1 0],[2 0],[3 0],[4 0]", "[0 0],[1 0],[2 0],[3 0],[4 0]", "[0 0],[1 0],[2 0],[3 0],[4 0]", // check that pages get evicted in LRU order "[0 0],[1 0],[2 0],[5 0],[4 0]", "[0 0],[1 0],[2 0],[5 0],[6 0]", "[7 0],[1 0],[2 0],[5 0],[6 0]", "[7 0],[1 0],[8 0],[5 0],[6 0]", "[7 0],[9 0],[8 0],[5 0],[6 0]" }; const int orderRequests[] = {3,4,0,2,1}; const int numLRUOrderChange = 5; int i; int snapshot = 0; BM_BufferPool *bm = MAKE_POOL(); BM_PageHandle *h = MAKE_PAGE_HANDLE(); testName = "Testing LRU page replacement"; CHECK(createPageFile("testbuffer.bin")); createDummyPages(bm, 100); CHECK(initBufferPool(bm, "testbuffer.bin", 5, RS_LRU, NULL)); // reading first five pages linearly with direct unpin and no modifications for(i = 0; i < 5; i++) { pinPage(bm, h, i); unpinPage(bm, h); ASSERT_EQUALS_POOL(poolContents[snapshot++], bm, "check pool content reading in pages"); } // read pages to change LRU order for(i = 0; i < numLRUOrderChange; i++) { pinPage(bm, h, orderRequests[i]); unpinPage(bm, h); ASSERT_EQUALS_POOL(poolContents[snapshot++], bm, "check pool content using pages"); } // replace pages and check that it happens in LRU order for(i = 0; i < 5; i++) { pinPage(bm, h, 5 + i); unpinPage(bm, h); ASSERT_EQUALS_POOL(poolContents[snapshot++], bm, "check pool content using pages"); } // check number of write IOs ASSERT_EQUALS_INT(0, getNumWriteIO(bm), "check number of write I/Os"); ASSERT_EQUALS_INT(10, getNumReadIO(bm), "check number of read I/Os"); CHECK(shutdownBufferPool(bm)); CHECK(destroyPageFile("testbuffer.bin")); free(bm); free(h); TEST_DONE(); }
void testFIFO () { // expected results const char *poolContents[] = { "[0 0],[-1 0],[-1 0]" , "[0 0],[1 0],[-1 0]", "[0 0],[1 0],[2 0]", "[3 0],[1 0],[2 0]", "[3 0],[4 0],[2 0]", "[3 0],[4 1],[2 0]", "[3 0],[4 1],[5x0]", "[6x0],[4 1],[5x0]", "[6x0],[4 1],[0x0]", "[6x0],[4 0],[0x0]", "[6 0],[4 0],[0 0]" }; const int requests[] = {0,1,2,3,4,4,5,6,0}; const int numLinRequests = 5; const int numChangeRequests = 3; int i; BM_BufferPool *bm = MAKE_POOL(); BM_PageHandle *h = MAKE_PAGE_HANDLE(); testName = "Testing FIFO page replacement"; CHECK(createPageFile("testbuffer.bin")); createDummyPages(bm, 100); CHECK(initBufferPool(bm, "testbuffer.bin", 3, RS_FIFO, NULL)); // reading some pages linearly with direct unpin and no modifications for(i = 0; i < numLinRequests; i++) { pinPage(bm, h, requests[i]); unpinPage(bm, h); ASSERT_EQUALS_POOL(poolContents[i], bm, "check pool content"); } // pin one page and test remainder i = numLinRequests; pinPage(bm, h, requests[i]); ASSERT_EQUALS_POOL(poolContents[i],bm,"pool content after pin page"); // read pages and mark them as dirty for(i = numLinRequests + 1; i < numLinRequests + numChangeRequests + 1; i++) { pinPage(bm, h, requests[i]); markDirty(bm, h); unpinPage(bm, h); ASSERT_EQUALS_POOL(poolContents[i], bm, "check pool content"); } // flush buffer pool to disk i = numLinRequests + numChangeRequests + 1; h->pageNum = 4; unpinPage(bm, h); ASSERT_EQUALS_POOL(poolContents[i],bm,"unpin last page"); i++; forceFlushPool(bm); ASSERT_EQUALS_POOL(poolContents[i],bm,"pool content after flush"); // check number of write IOs ASSERT_EQUALS_INT(3, getNumWriteIO(bm), "check number of write I/Os"); ASSERT_EQUALS_INT(8, getNumReadIO(bm), "check number of read I/Os"); CHECK(shutdownBufferPool(bm)); CHECK(destroyPageFile("testbuffer.bin")); free(bm); free(h); TEST_DONE(); }
// test the CLOCK page replacement strategy void testClock (void) { // expected results const char *poolContents[] = { // read first five pages and directly unpin them "[0 0],[-1 0],[-1 0]" , "[0 0],[1 0],[-1 0]" , "[2 0],[1 0],[-1 0]" , "[2 0],[1 0],[3 0]" , // pin the page 2 again "[2 0],[1 0],[3 0]" , // read other pages use pin_CLOCK "[2 0],[4 0],[3 0]" , "[5 0],[4 0],[3 0]" , "[6 0],[4 0],[3 0]", "[6 0],[7 0],[3 0]" }; const int orderRequests[] = {2}; const int numrfChange = 1; int i; int snapshot = 0; BM_BufferPool *bm = MAKE_POOL(); BM_PageHandle *h = MAKE_PAGE_HANDLE(); testName = "Testing CLOCK page replacement"; CHECK(createPageFile("testbuffer.bin")); createDummyPages(bm, 100); CHECK(initBufferPool(bm, "testbuffer.bin", 3, RS_CLOCK, NULL)); // reading first five pages linearly with direct unpin and no modifications for(i = 0; i <4; i++) { pinPage(bm, h, i); unpinPage(bm, h); ASSERT_EQUALS_POOL(poolContents[snapshot++], bm, "check pool content reading in pages"); } // read pages to rf of the frames for(i = 0; i < numrfChange; i++) { pinPage(bm, h, orderRequests[i]); unpinPage(bm, h); ASSERT_EQUALS_POOL(poolContents[snapshot++], bm, "check pool content using pages"); } // replace pages and check that it happens in LRU_K order for(i = 0; i < 4; i++) { pinPage(bm, h, 4 + i); unpinPage(bm, h); ASSERT_EQUALS_POOL(poolContents[snapshot++], bm, "check pool content using pages"); } // check number of write IOs ASSERT_EQUALS_INT(0, getNumWriteIO(bm), "check number of write I/Os"); ASSERT_EQUALS_INT(8, getNumReadIO(bm), "check number of read I/Os"); CHECK(shutdownBufferPool(bm)); CHECK(destroyPageFile("testbuffer.bin")); free(bm); free(h); TEST_DONE(); }
//Clock[START] void testClock() { // expected results const char *poolContents[] = { "[0 0],[-1 0],[-1 0]", "[0 0],[4 0],[-1 0]", "[0 0],[4 0],[1 0]", "[0 0],[4 0],[1 0]", "[2 0],[4 0],[1 0]", "[2 0],[4 0],[1 0]", "[2 0],[4 0],[3 0]", "[2 0],[4 0],[3 0]", "[2 0],[4 0],[3 0]", "[2 0],[4 0],[3 0]", "[2 0],[4 0],[0 0]", "[2 0],[4 0],[0 0]", "[1 0],[4 0],[0 0]", "[1 0],[4 0],[0 0]", "[1 0],[4 0],[2 0]", "[1 0],[4 0],[2 0]", "[3 0],[4 0],[2 0]", "[3 0],[4 0],[2 0]", "[3 0],[4 0],[2 0]", }; const int requests[] = {0,4,1,4,2,4,3,4,2,4,0,4,1,4,2,4,3,4}; int i; BM_BufferPool *bm = MAKE_POOL(); BM_PageHandle *h = MAKE_PAGE_HANDLE(); testName = "Testing CLOCK page replacement"; CHECK(createPageFile("testbuffer.bin")); createDummyPages(bm, 100); CHECK(initBufferPool(bm, "testbuffer.bin", 3, RS_CLOCK, NULL)); // reading some pages linearly with direct unpin and no modifications for(i = 0; i < 18; i++) { pinPage(bm, h, requests[i]); unpinPage(bm, h); ASSERT_EQUALS_POOL(poolContents[i], bm, "check pool content"); } forceFlushPool(bm); ASSERT_EQUALS_POOL(poolContents[i],bm,"pool content after flush"); // check number of write IOs //0 writes because no dirty pages were present ASSERT_EQUALS_INT(0, getNumWriteIO(bm), "check number of write I/Os"); ASSERT_EQUALS_INT(9, getNumReadIO(bm), "check number of read I/Os"); CHECK(shutdownBufferPool(bm)); CHECK(destroyPageFile("testbuffer.bin")); free(bm); free(h); TEST_DONE(); }
void testLFU() { // expected results const char *poolContents[] = { //Pin and Unpin 3 pages "[0 0],[-1 0],[-1 0]" , "[0 0],[1 0],[-1 0]", "[0 0],[1 0],[2 0]", //Pin the 0th page thrice,1st page twice "[0 3],[1 2],[2 0]", //Now pin a new page say 4. 4 should replace page 2 as page 2 has been Least Freq Used. "[0 3],[1 2],[4 1]", //Pin the 4th page thrice "[0 3],[1 2],[4 4]", //Now pin a new page 5. 5 should replace page 1 as page 1 has been Least Freq Used. "[0 3],[5 1],[4 4]", //Unpin page 0 thrice, page 5 once and page 4 four times. "[0 0],[5 0],[4 0]", }; const int requests[] = {0,1,2,3,4,5,6}; const int numLinRequests = 3; int i; BM_BufferPool *bm = MAKE_POOL(); BM_PageHandle *h = MAKE_PAGE_HANDLE(); testName = "Testing LFU page replacement"; CHECK(createPageFile("testbuffer.bin")); createDummyPages(bm, 100); CHECK(initBufferPool(bm, "testbuffer.bin", 3, RS_LFU, NULL)); // reading some pages linearly with direct unpin and no modifications for(i = 0; i < numLinRequests; i++) { pinPage(bm, h, requests[i]); unpinPage(bm, h); ASSERT_EQUALS_POOL(poolContents[i], bm, "check pool content"); } pinPage(bm, h, 0); pinPage(bm, h, 0); pinPage(bm, h, 0); pinPage(bm, h, 1); pinPage(bm, h, 1); ASSERT_EQUALS_POOL(poolContents[i++],bm,"pool content after pin page"); pinPage(bm, h, 4); ASSERT_EQUALS_POOL(poolContents[i++],bm,"pool content after pin page"); pinPage(bm,h,4); pinPage(bm,h,4); pinPage(bm,h,4); ASSERT_EQUALS_POOL(poolContents[i++],bm,"pool content after pin page"); pinPage(bm,h,5); ASSERT_EQUALS_POOL(poolContents[i++],bm,"pool content after pin page"); h->data = "Page-0"; h->pageNum = 0; unpinPage(bm,h); unpinPage(bm,h); unpinPage(bm,h); h->data = "Page-5"; h->pageNum = 5; unpinPage(bm,h); h->data = "Page-4"; h->pageNum = 4; unpinPage(bm,h); unpinPage(bm,h); unpinPage(bm,h); unpinPage(bm,h); forceFlushPool(bm); ASSERT_EQUALS_POOL(poolContents[i],bm,"pool content after flush"); // check number of write IOs //0 writes because no dirty pages were present ASSERT_EQUALS_INT(0, getNumWriteIO(bm), "check number of write I/Os"); ASSERT_EQUALS_INT(5, getNumReadIO(bm), "check number of read I/Os"); CHECK(shutdownBufferPool(bm)); CHECK(destroyPageFile("testbuffer.bin")); free(bm); free(h); TEST_DONE(); }