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();
}
