public void SP_TestDeleteRecord()
{
TestData[] addList =
{
new TestData {
data = "Record0", recordIdx = 0
}
};
TestData[] deleteTestList =
{
new TestData {
recordIdx = -1, exception = "InvalidRecordException"
},
new TestData {
recordIdx = 2, exception = "InvalidRecordException"
},
new TestData {
recordIdx = 0, exception = ""
},
new TestData {
recordIdx = 0, exception = "InvalidRecordException"
},
};
StoragePage page = new StoragePage();
AddRecords(page, addList);
DeleteRecords(page, deleteTestList);
}
/// <summary>
/// Reads a list of items from persistent storage. The list is written as a chain of pages,
/// where the current page stores a pointer to the page storing the next range of items.
/// The items can be any "serializable" C# type.
/// </summary>
/// <param name="stream">data file to read from</param>
/// <param name="pageIdx">index of the page storing the head of the list</param>
/// <param name="list">list of items read</param>
/// <param name="pages">list of physical pages we read from</param>
public void ReadList(FileStreamWrapper stream, int pageIdx, out List <T> list, out List <int> pages)
{
// read pages one by one
while (ListHdr.EOLPageIndex != pageIdx)
{
// read the page data
StoragePage page = new StoragePage();
int readPage = page.ReadPageData(stream, pageIdx);
if (readPage != pageIdx)
{
throw new InvalidListException();
}
// read the header
ListHdr header = (ListHdr)page.ReadRecord(ListHdr.HeaderRecordIdx);
if (null == header)
{
throw new InvalidListException();
}
// process the page
this.ReadCurrentPage(page, header.PageEntriesCount);
// update the page index
this.pageList.Add(pageIdx);
pageIdx = header.NextPageIndex;
}
// set the output variables
list = this.itemList;
pages = this.pageList;
}
private void ReadCurrentPage(StoragePage page, int itemCount)
{
for (int idx = 0; idx < (itemCount + 1); idx++)
{
if (ListHdr.HeaderRecordIdx == idx)
{
// skip over the header record
continue;
}
T item = (T)page.ReadRecord(idx);
this.itemList.Add(item);
}
}
private void WriteRecords(StoragePage page, TestData[] data)
{
foreach (TestData test in data)
{
try
{
page.WriteRecord(test.recordIdx, test.data);
}
catch (Exception e)
{
Assert.AreEqual(test.exception, e.GetType().Name,
"Unexpected exception. Test Data = [{0}]", test.ToString());
}
}
}
private void ReadRecords(StoragePage page, TestData[] data)
{
foreach (TestData test in data)
{
try
{
string result = (string)page.ReadRecord(test.recordIdx);
Assert.AreEqual(test.data, result,
"Read record did not match. Test Data = [{0}]", test.ToString());
}
catch (Exception e)
{
Assert.AreEqual(test.exception, e.GetType().Name,
"Unexpected exception. Test Data = [{0}]", test.ToString());
}
}
}
private void AddRecords(StoragePage page, TestData[] data)
{
foreach (TestData test in data)
{
try
{
int result = page.AddRecord(test.data);
Assert.AreEqual(test.recordIdx, result,
string.Format("Return value did not match. Test Data=[{0}]", test.ToString()));
}
catch (Exception e)
{
Assert.AreEqual(test.exception, e.GetType().Name,
"Unexpected exception. Test Data = [{0}]", test.ToString());
}
}
}
public void SP_TestReadWritePage()
{
string dataFile = "SP_TestData1.tpdb";
if (File.Exists(dataFile))
{
File.Delete(dataFile);
}
TestData[] pageData =
{
new TestData {
data = "Record_0", recordIdx = 0
},
new TestData {
data = "Record_1", recordIdx = 1
},
new TestData {
data = "Record_2", recordIdx = 2
}
};
int pageIndex = int.MinValue;
// write the page
using (FileStreamWrapper dataFileStream = FileStreamWrapper.CreateObject(dataFile))
{
// populate the page with some data
StoragePage page = new StoragePage();
AddRecords(page, pageData);
// write the file to disk
pageIndex = page.WritePageData(dataFileStream, -1);
}
// read the page
using (FileStreamWrapper dataFileStream = FileStreamWrapper.CreateObject(dataFile))
{
// read page from file
StoragePage page = new StoragePage();
page.ReadPageData(dataFileStream, pageIndex);
// validate the page data
ReadRecords(page, pageData);
}
}
public void SP_TestReadWriteRecord()
{
TestData[] addList =
{
new TestData {
data = "Record0", recordIdx = 0
},
new TestData {
data = "Record1", recordIdx = 1
},
};
TestData[] readAddList = addList;
TestData[] readWriteTestList =
{
new TestData {
data = "Record-1", recordIdx = -1, exception = "InvalidRecordException"
},
new TestData {
data = "RecordMax", recordIdx = int.MaxValue, exception = "InvalidRecordException"
},
new TestData {
data = "RecordLen", recordIdx = addList.Length, exception = "InvalidRecordException"
},
new TestData {
data = "Record0_2", recordIdx = addList[0].recordIdx
},
new TestData {
data = "Record1_2", recordIdx = addList[1].recordIdx
},
};
TestData[] readWriteList = readWriteTestList;
StoragePage page = new StoragePage();
// setup the page by adding some records and
// verify by reading the records back
AddRecords(page, addList);
ReadRecords(page, readAddList);
// execute writes
WriteRecords(page, readWriteTestList);
ReadRecords(page, readWriteList);
}
public void SP_TestAddRecord()
{
TestData[] testList =
{
new TestData {
data = "test data 1", recordIdx = 0
},
new TestData {
data = "test data 2", recordIdx = 1
},
};
StoragePage page = new StoragePage();
AddRecords(page, testList);
// test adding a record when page is full
string masterRecord = "1234567890";
int maxCount =
(StoragePage_Accessor.PageSize - sizeof(int))
/ (sizeof(int) + StoragePage_Accessor.Serialize(masterRecord).Length);
List <TestData> noSpacetestList = new List <TestData>();
for (int idx = 0; idx < maxCount; idx++)
{
TestData record = new TestData
{
data = masterRecord,
recordIdx = idx,
};
noSpacetestList.Add(record);
}
noSpacetestList.Add(new TestData
{
data = masterRecord,
exception = "InsuffcientSpaceException",
});
StoragePage page2 = new StoragePage();
AddRecords(page2, noSpacetestList.ToArray());
}
private void CreateNewPage(int count, StoragePageManager freeSpaceMgr)
{
// create a new header object
ListHdr header = new ListHdr()
{
NextPageIndex = ListHdr.EOLPageIndex,
TotalEntriesCount = count,
PageEntriesCount = 0,
PageWriteIndex = freeSpaceMgr.GetFreePage()
};
this.pageHeaderList.Push(header);
// create the page - and write a placeholder record for the header
StoragePage page = new StoragePage();
page.AddRecord(header);
this.pageList.Push(page);
}
private int WriteTopPage(FileStreamWrapper stream, int lastPageAddress)
{
// update the header
ListHdr header = this.pageHeaderList.Pop();
header.NextPageIndex = lastPageAddress;
// update the page
StoragePage page = this.pageList.Pop();
page.WriteRecord(ListHdr.HeaderRecordIdx, header);
// get the page to write to
int pageIdx = header.PageWriteIndex;
// write the page
pageIdx = page.WritePageData(stream, pageIdx);
this.pageIdxList.Insert(0, pageIdx);
return(pageIdx);
}
