main.cpp

#include <iostream>
#include <stdlib.h>
#include <cstring>
#include <memory>
#include "include/page.h"
#include "buffer.h"
#include "include/file_iterator.h"
#include "include/page_iterator.h"
#include "exceptions/file_not_found_exception.h"
#include "exceptions/invalid_page_exception.h"
#include "exceptions/page_not_pinned_exception.h"
#include "exceptions/page_pinned_exception.h"
#include "exceptions/buffer_exceeded_exception.h"

#define PRINT_ERROR(str) \
{ \
  std::cerr << "On Line No:" << __LINE__ << "\n"; \
  std::cerr << str << "\n"; \
  exit(1); \
}

using namespace wiscdb;

const PageId num = 100;
PageId pid[num], pageno1, pageno2, pageno3, i;
RecordId rid[num], rid2, rid3;
Page *page, *page2, *page3;
char tmpbuf[100];
BufferManager* bufMgr;
File *file1ptr, *file2ptr, *file3ptr, *file4ptr, *file5ptr;

void usePageFile();

void test1();
void test2();
void test3();
void test4();
void test5();
void test6();
void testBufferManager();

int main() 
{
  //usePageFile();
    //This function tests buffer manager, comment this line if you don't wish to test buffer manager
  testBufferManager();
}

void usePageFile(){
//Following code shows how to use File and Page classes

  const std::string& filename = "test.db";
  // Clean up from any previous runs that crashed.
  try
  {
    File::remove(filename);
  }
  catch(FileNotFoundException)
  {
  }

  // Create a new database file.
  File new_file = File::create(filename);
    
  // Allocate some pages and put data on them.
  PageId third_page_number;
  for (int i = 0; i < 5; ++i) {
    Page new_page = new_file.allocatePage();
    if (i == 3) {
      // Keep track of the identifier for the third page so we can read it
      // later.
      third_page_number = new_page.page_number();
    }
    new_page.insertRecord("hello!");
    // Write the page back to the file (with the new data).
    new_file.writePage(new_page);
  }

  // Iterate through all pages in the file.
  for (FileIterator iter = new_file.begin(); iter != new_file.end(); ++iter) {
    // Iterate through all records on the page.
    for (PageIterator page_iter = (*iter).begin(); page_iter != (*iter).end();
           ++page_iter) {
      std::cout << "Found record: " << *page_iter
                << " on page " << (*iter).page_number() << "\n";
    }
  }

  // Retrieve the third page and add another record to it.
  Page third_page = new_file.readPage(third_page_number);
  const RecordId& rid = third_page.insertRecord("world!");
  new_file.writePage(third_page);

  // Retrieve the record we just added to the third page.
  std::cout << "Third page has a new record: "
            << third_page.getRecord(rid) << "\n\n";
  new_file.close();
  // new_file goes out of scope here, so file is automatically closed.
  // Delete the file since we're done with it.
  File::remove(filename);
}

void testBufferManager()
{
  // create buffer manager
  bufMgr = new BufferManager(num);

  // create dummy files
  const std::string& filename1 = "test.1";
  const std::string& filename2 = "test.2";
  const std::string& filename3 = "test.3";
  const std::string& filename4 = "test.4";
  const std::string& filename5 = "test.5";

  try
  {
    File::remove(filename1);
    File::remove(filename2);
    File::remove(filename3);
    File::remove(filename4);
    File::remove(filename5);
  }
  catch(FileNotFoundException e)
  {
  }

  File file1 = File::create(filename1);
  File file2 = File::create(filename2);
  File file3 = File::create(filename3);
  File file4 = File::create(filename4);
  File file5 = File::create(filename5);

  file1ptr = &file1;
  file2ptr = &file2;
  file3ptr = &file3;
  file4ptr = &file4;
  file5ptr = &file5;

  //Test buffer manager
  //Comment tests which you do not wish to run now. Tests are dependent on their preceding tests. So, they have to be run in the following order. 
  //Commenting  a particular test requires commenting all tests that follow it else those tests would fail.
  test1();
  test2();
  test3();
  test4();
  test5();
  test6();

  //Close files before deleting them  
        file1.close();
  file2.close();
  file3.close();
  file4.close();
  file5.close();

  //Delete files
  File::remove(filename1);
  File::remove(filename2);
  File::remove(filename3);
  File::remove(filename4);
  File::remove(filename5);

  delete bufMgr;

  std::cout << "\n" << "Passed all tests." << "\n";
}

void test1()
{
  //Allocating pages in a file...
  for (i = 0; i < num; i++)
  {
    bufMgr->allocatePage(file1ptr, pid[i], page);
    sprintf((char*)tmpbuf, "test.1 Page %d %7.1f", pid[i], (float)pid[i]);
    rid[i] = page->insertRecord(tmpbuf);
    bufMgr->unPinPage(file1ptr, pid[i], true);
  }

  //Reading pages back...
  for (i = 0; i < num; i++)
  {
    bufMgr->readPage(file1ptr, pid[i], page);
    sprintf((char*)&tmpbuf, "test.1 Page %d %7.1f", pid[i], (float)pid[i]);
    if(strncmp(page->getRecord(rid[i]).c_str(), tmpbuf, strlen(tmpbuf)) != 0)
    {
      PRINT_ERROR("ERROR :: CONTENTS DID NOT MATCH");
    }
    bufMgr->unPinPage(file1ptr, pid[i], false);
  }
  std::cout<< "Test 1 passed" << "\n";
}

void test2()
{
  //Writing and reading back multiple files
  //The page number and the value should match

  for (i = 0; i < num/3; i++) 
  {
    bufMgr->allocatePage(file2ptr, pageno2, page2);
    sprintf((char*)tmpbuf, "test.2 Page %d %7.1f", pageno2, (float)pageno2);
    rid2 = page2->insertRecord(tmpbuf);

    int index = random() % num;
    pageno1 = pid[index];
    bufMgr->readPage(file1ptr, pageno1, page);
    sprintf((char*)tmpbuf, "test.1 Page %d %7.1f", pageno1, (float)pageno1);
    if(strncmp(page->getRecord(rid[index]).c_str(), tmpbuf, strlen(tmpbuf)) != 0)
    {
      PRINT_ERROR("ERROR :: CONTENTS DID NOT MATCH");
    }

    bufMgr->allocatePage(file3ptr, pageno3, page3);
    sprintf((char*)tmpbuf, "test.3 Page %d %7.1f", pageno3, (float)pageno3);
    rid3 = page3->insertRecord(tmpbuf);

    bufMgr->readPage(file2ptr, pageno2, page2);
    sprintf((char*)&tmpbuf, "test.2 Page %d %7.1f", pageno2, (float)pageno2);
    if(strncmp(page2->getRecord(rid2).c_str(), tmpbuf, strlen(tmpbuf)) != 0)
    {
      PRINT_ERROR("ERROR :: CONTENTS DID NOT MATCH");
    }

    bufMgr->readPage(file3ptr, pageno3, page3);
    sprintf((char*)&tmpbuf, "test.3 Page %d %7.1f", pageno3, (float)pageno3);
    if(strncmp(page3->getRecord(rid3).c_str(), tmpbuf, strlen(tmpbuf)) != 0)
    {
      PRINT_ERROR("ERROR :: CONTENTS DID NOT MATCH");
    }

    bufMgr->unPinPage(file1ptr, pageno1, false);
  }

  for (i = 0; i < num/3; i++) {
    bufMgr->unPinPage(file2ptr, i+1, true);
    bufMgr->unPinPage(file2ptr, i+1, true);
    bufMgr->unPinPage(file3ptr, i+1, true);
    bufMgr->unPinPage(file3ptr, i+1, true);
  }

  std::cout << "Test 2 passed" << "\n";
}

void test3()
{
  try
  {
    bufMgr->readPage(file4ptr, 1, page);
    PRINT_ERROR("ERROR :: File4 should not exist. Exception should have been thrown before execution reaches this point.");
  }
  catch(InvalidPageException e)
  {
  }

  std::cout << "Test 3 passed" << "\n";
}

void test4()
{
  bufMgr->allocatePage(file4ptr, i, page);
  bufMgr->unPinPage(file4ptr, i, true);
  try
  {
    bufMgr->unPinPage(file4ptr, i, false);
    PRINT_ERROR("ERROR :: Page is already unpinned. Exception should have been thrown before execution reaches this point.");
  }
  catch(PageNotPinnedException e)
  {
  }

  std::cout << "Test 4 passed" << "\n";
}

void test5()
{
  for (i = 0; i < num; i++) {
    bufMgr->allocatePage(file5ptr, pid[i], page);
    sprintf((char*)tmpbuf, "test.5 Page %d %7.1f", pid[i], (float)pid[i]);
    rid[i] = page->insertRecord(tmpbuf);
  }

  PageId tmp;
  try
  {
    bufMgr->allocatePage(file5ptr, tmp, page);
    PRINT_ERROR("ERROR :: No more frames left for allocation. Exception should have been thrown before execution reaches this point.");
  }
  catch(BufferExceededException e)
  {
  }

  std::cout << "Test 5 passed" << "\n";

  for (i = 1; i <= num; i++)
    bufMgr->unPinPage(file5ptr, i, true);
}

void test6()
{
  //flushing file with pages still pinned. Should generate an error
  for (i = 1; i <= num; i++) {
    bufMgr->readPage(file1ptr, i, page);
  }

  try
  {
    bufMgr->flushFile(file1ptr);
    PRINT_ERROR("ERROR :: Pages pinned for file being flushed. Exception should have been thrown before execution reaches this point.");
  }
  catch(PagePinnedException e)
  {
  }

  std::cout << "Test 6 passed" << "\n";

  for (i = 1; i <= num; i++) 
    bufMgr->unPinPage(file1ptr, i, true);

  bufMgr->flushFile(file1ptr);
}