@BeforeClass
public void beforeClass() throws IOException {
System.out.println("Start LocalPaginatedClusterTest");
buildDirectory = System.getProperty("buildDirectory");
if (buildDirectory == null || buildDirectory.isEmpty())
buildDirectory = ".";
buildDirectory += "/localPaginatedClusterTest";
OLocalPaginatedStorage storage = mock(OLocalPaginatedStorage.class);
OStorageConfiguration storageConfiguration = mock(OStorageConfiguration.class);
storageConfiguration.clusters = new ArrayList<OStorageClusterConfiguration>();
storageConfiguration.fileTemplate = new OStorageSegmentConfiguration();
when(storageConfiguration.getDirectory()).thenReturn(buildDirectory);
diskCache = new OReadWriteDiskCache(400L * 1024 * 1024 * 1024, 2648L * 1024 * 1024,
OGlobalConfiguration.DISK_CACHE_PAGE_SIZE.getValueAsInteger() * 1024, 1000000, 100, storage, null, false, false);
OStorageVariableParser variableParser = new OStorageVariableParser(buildDirectory);
when(storage.getDiskCache()).thenReturn(diskCache);
when(storage.getVariableParser()).thenReturn(variableParser);
when(storage.getConfiguration()).thenReturn(storageConfiguration);
when(storage.getMode()).thenReturn("rw");
when(storage.getStoragePath()).thenReturn(buildDirectory);
when(storageConfiguration.getDirectory()).thenReturn(buildDirectory);
paginatedCluster.configure(storage, 5, "paginatedClusterTest", buildDirectory, -1);
paginatedCluster.create(-1);
}
public void testGetPhysicalPosition() throws IOException {
final int records = 10000;
long seed = System.currentTimeMillis();
MersenneTwisterFast mersenneTwisterFast = new MersenneTwisterFast(seed);
System.out.println("testGetPhysicalPosition seed : " + seed);
Set<OPhysicalPosition> positions = new HashSet<OPhysicalPosition>();
ORecordVersion recordVersion = OVersionFactory.instance().createVersion();
recordVersion.increment();
recordVersion.increment();
for (int i = 0; i < records; i++) {
int recordSize = mersenneTwisterFast.nextInt(2 * OClusterPage.MAX_RECORD_SIZE) + 1;
byte[] record = new byte[recordSize];
mersenneTwisterFast.nextBytes(record);
recordVersion.increment();
final OPhysicalPosition physicalPosition = paginatedCluster.createRecord(record, recordVersion, (byte) i);
positions.add(physicalPosition);
}
Set<OPhysicalPosition> removedPositions = new HashSet<OPhysicalPosition>();
for (OPhysicalPosition position : positions) {
OPhysicalPosition physicalPosition = new OPhysicalPosition();
physicalPosition.clusterPosition = position.clusterPosition;
physicalPosition = paginatedCluster.getPhysicalPosition(physicalPosition);
Assert.assertEquals(physicalPosition.clusterPosition, position.clusterPosition);
Assert.assertEquals(physicalPosition.recordType, position.recordType);
Assert.assertEquals(physicalPosition.recordSize, position.recordSize);
Assert.assertEquals(physicalPosition.dataSegmentPos, position.dataSegmentPos);
Assert.assertEquals(physicalPosition.dataSegmentId, position.dataSegmentId);
if (mersenneTwisterFast.nextBoolean()) {
paginatedCluster.deleteRecord(position.clusterPosition);
removedPositions.add(position);
}
}
for (OPhysicalPosition position : positions) {
OPhysicalPosition physicalPosition = new OPhysicalPosition();
physicalPosition.clusterPosition = position.clusterPosition;
physicalPosition = paginatedCluster.getPhysicalPosition(physicalPosition);
if (removedPositions.contains(position))
Assert.assertNull(physicalPosition);
else {
Assert.assertEquals(physicalPosition.clusterPosition, position.clusterPosition);
Assert.assertEquals(physicalPosition.recordType, position.recordType);
Assert.assertEquals(physicalPosition.recordSize, position.recordSize);
Assert.assertEquals(physicalPosition.dataSegmentPos, position.dataSegmentPos);
Assert.assertEquals(physicalPosition.dataSegmentId, position.dataSegmentId);
}
}
}
public void testUpdateOneBigRecord() throws IOException {
byte[] bigRecord = new byte[2 * 65536 + 100];
MersenneTwisterFast mersenneTwisterFast = new MersenneTwisterFast();
mersenneTwisterFast.nextBytes(bigRecord);
ORecordVersion recordVersion = OVersionFactory.instance().createVersion();
recordVersion.increment();
recordVersion.increment();
OPhysicalPosition physicalPosition = paginatedCluster.createRecord(bigRecord, recordVersion, (byte) 1);
Assert.assertEquals(physicalPosition.clusterPosition, OClusterPositionFactory.INSTANCE.valueOf(0));
recordVersion.increment();
bigRecord = new byte[2 * 65536 + 20];
mersenneTwisterFast.nextBytes(bigRecord);
paginatedCluster.updateRecord(physicalPosition.clusterPosition, bigRecord, recordVersion, (byte) 2);
ORawBuffer rawBuffer = paginatedCluster.readRecord(physicalPosition.clusterPosition);
Assert.assertNotNull(rawBuffer);
Assert.assertEquals(rawBuffer.version, recordVersion);
Assert.assertEquals(rawBuffer.buffer, bigRecord);
Assert.assertEquals(rawBuffer.recordType, 2);
}
public void testCompressionSnappy() throws Exception {
paginatedCluster.set(OCluster.ATTRIBUTES.COMPRESSION, OSnappyCompression.NAME);
paginatedCluster.set(OCluster.ATTRIBUTES.RECORD_GROW_FACTOR, 1);
byte[] record = new byte[100];
Random random = new Random();
random.nextBytes(record);
OPhysicalPosition physicalPosition = paginatedCluster
.createRecord(record, OVersionFactory.instance().createVersion(), (byte) 1);
record = OSnappyCompression.INSTANCE.compress(record);
OCacheEntry cacheEntry = diskCache.load(1, 1, false);
OCachePointer pagePointer = cacheEntry.getCachePointer();
int recordIndex = (int) (physicalPosition.clusterPosition.longValue() & 0xFFFF);
OClusterPage page = new OClusterPage(pagePointer.getDataPointer(), false, ODurablePage.TrackMode.NONE);
byte[] storedEntity = page.getRecordBinaryValue(recordIndex, 0, page.getRecordSize(recordIndex));
byte[] storedRecord = new byte[record.length];
System.arraycopy(storedEntity, OIntegerSerializer.INT_SIZE + OByteSerializer.BYTE_SIZE, storedRecord, 0, storedRecord.length);
Assert.assertEquals(storedRecord, record);
diskCache.release(cacheEntry);
}
public void testRecordGrowFactor() throws Exception {
paginatedCluster.set(OCluster.ATTRIBUTES.COMPRESSION, ONothingCompression.NAME);
paginatedCluster.set(OCluster.ATTRIBUTES.RECORD_GROW_FACTOR, 1.5);
byte[] record = new byte[100];
Random random = new Random();
random.nextBytes(record);
OPhysicalPosition physicalPosition = paginatedCluster
.createRecord(record, OVersionFactory.instance().createVersion(), (byte) 1);
OCacheEntry cacheEntry = diskCache.load(1, 1, false);
OCachePointer pagePointer = cacheEntry.getCachePointer();
OClusterPage page = new OClusterPage(pagePointer.getDataPointer(), false, ODurablePage.TrackMode.NONE);
int recordIndex = (int) (physicalPosition.clusterPosition.longValue() & 0xFFFF);
Assert.assertEquals(page.getRecordSize(recordIndex), ((int) (record.length * 1.5)) + RECORD_SYSTEM_INFORMATION);
diskCache.release(cacheEntry);
paginatedCluster.set(OCluster.ATTRIBUTES.RECORD_GROW_FACTOR, 2);
physicalPosition = paginatedCluster.createRecord(record, OVersionFactory.instance().createVersion(), (byte) 1);
recordIndex = (int) (physicalPosition.clusterPosition.longValue() & 0xFFFF);
cacheEntry = diskCache.load(1, 1, false);
pagePointer = cacheEntry.getCachePointer();
page = new OClusterPage(pagePointer.getDataPointer(), false, ODurablePage.TrackMode.NONE);
Assert.assertEquals(page.getRecordSize(recordIndex), record.length * 2 + RECORD_SYSTEM_INFORMATION);
diskCache.release(cacheEntry);
}
public void testAddManyRecords() throws IOException {
final int records = 10000;
long seed = System.currentTimeMillis();
MersenneTwisterFast mersenneTwisterFast = new MersenneTwisterFast(seed);
System.out.println("testAddManyRecords seed : " + seed);
Map<OClusterPosition, byte[]> positionRecordMap = new HashMap<OClusterPosition, byte[]>();
ORecordVersion recordVersion = OVersionFactory.instance().createVersion();
recordVersion.increment();
recordVersion.increment();
for (int i = 0; i < records; i++) {
int recordSize = mersenneTwisterFast.nextInt(2 * OClusterPage.MAX_RECORD_SIZE) + 1;
byte[] smallRecord = new byte[recordSize];
mersenneTwisterFast.nextBytes(smallRecord);
final OPhysicalPosition physicalPosition = paginatedCluster.createRecord(smallRecord, recordVersion, (byte) 2);
positionRecordMap.put(physicalPosition.clusterPosition, smallRecord);
}
for (Map.Entry<OClusterPosition, byte[]> entry : positionRecordMap.entrySet()) {
ORawBuffer rawBuffer = paginatedCluster.readRecord(entry.getKey());
Assert.assertNotNull(rawBuffer);
Assert.assertEquals(rawBuffer.version, recordVersion);
Assert.assertEquals(rawBuffer.buffer, entry.getValue());
Assert.assertEquals(rawBuffer.recordType, 2);
}
}
public void testUpdateManySmallRecords() throws IOException {
final int records = 10000;
long seed = System.currentTimeMillis();
MersenneTwisterFast mersenneTwisterFast = new MersenneTwisterFast(seed);
System.out.println("testUpdateManySmallRecords seed : " + seed);
Map<OClusterPosition, byte[]> positionRecordMap = new HashMap<OClusterPosition, byte[]>();
Set<OClusterPosition> updatedPositions = new HashSet<OClusterPosition>();
ORecordVersion recordVersion = OVersionFactory.instance().createVersion();
recordVersion.increment();
recordVersion.increment();
for (int i = 0; i < records; i++) {
int recordSize = mersenneTwisterFast.nextInt(OClusterPage.MAX_RECORD_SIZE - 1) + 1;
byte[] smallRecord = new byte[recordSize];
mersenneTwisterFast.nextBytes(smallRecord);
final OPhysicalPosition physicalPosition = paginatedCluster.createRecord(smallRecord, recordVersion, (byte) 2);
positionRecordMap.put(physicalPosition.clusterPosition, smallRecord);
}
ORecordVersion newRecordVersion = OVersionFactory.instance().createVersion();
newRecordVersion.copyFrom(recordVersion);
newRecordVersion.increment();
for (OClusterPosition clusterPosition : positionRecordMap.keySet()) {
if (mersenneTwisterFast.nextBoolean()) {
int recordSize = mersenneTwisterFast.nextInt(OClusterPage.MAX_RECORD_SIZE - 1) + 1;
byte[] smallRecord = new byte[recordSize];
mersenneTwisterFast.nextBytes(smallRecord);
paginatedCluster.updateRecord(clusterPosition, smallRecord, newRecordVersion, (byte) 3);
positionRecordMap.put(clusterPosition, smallRecord);
updatedPositions.add(clusterPosition);
}
}
for (Map.Entry<OClusterPosition, byte[]> entry : positionRecordMap.entrySet()) {
ORawBuffer rawBuffer = paginatedCluster.readRecord(entry.getKey());
Assert.assertNotNull(rawBuffer);
Assert.assertEquals(rawBuffer.buffer, entry.getValue());
if (updatedPositions.contains(entry.getKey())) {
Assert.assertEquals(rawBuffer.version, newRecordVersion);
Assert.assertEquals(rawBuffer.recordType, 3);
} else {
Assert.assertEquals(rawBuffer.version, recordVersion);
Assert.assertEquals(rawBuffer.recordType, 2);
}
}
}
private void assertFileRestoreFromWAL() throws IOException {
paginatedCluster.close();
writeAheadLog.close();
readCache.clear();
restoreClusterFromWAL();
testCluster.close();
assertClusterContentIsTheSame(testCluster.getName(), paginatedCluster.getName());
testCluster.open();
paginatedCluster.open();
}
public void testAddOneSmallRecord() throws IOException {
byte[] smallRecord = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
ORecordVersion recordVersion = OVersionFactory.instance().createVersion();
recordVersion.increment();
recordVersion.increment();
OPhysicalPosition physicalPosition = paginatedCluster.createRecord(smallRecord, recordVersion, (byte) 1);
Assert.assertEquals(physicalPosition.clusterPosition, OClusterPositionFactory.INSTANCE.valueOf(0));
ORawBuffer rawBuffer = paginatedCluster.readRecord(physicalPosition.clusterPosition);
Assert.assertNotNull(rawBuffer);
Assert.assertEquals(rawBuffer.version, recordVersion);
Assert.assertEquals(rawBuffer.buffer, smallRecord);
Assert.assertEquals(rawBuffer.recordType, 1);
}
public void testDeleteRecordAndAddNewOnItsPlace() throws IOException {
byte[] smallRecord = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
ORecordVersion recordVersion = OVersionFactory.instance().createVersion();
recordVersion.increment();
recordVersion.increment();
OPhysicalPosition physicalPosition = paginatedCluster.createRecord(smallRecord, recordVersion, (byte) 1);
Assert.assertEquals(physicalPosition.clusterPosition, OClusterPositionFactory.INSTANCE.valueOf(0));
paginatedCluster.deleteRecord(physicalPosition.clusterPosition);
physicalPosition = paginatedCluster.createRecord(smallRecord, recordVersion, (byte) 1);
Assert.assertEquals(physicalPosition.clusterPosition, OClusterPositionFactory.INSTANCE.valueOf(1));
recordVersion.increment();
Assert.assertEquals(physicalPosition.recordVersion, recordVersion);
}
public void testRemoveHalfRecords() throws IOException {
final int records = 10000;
long seed = System.currentTimeMillis();
MersenneTwisterFast mersenneTwisterFast = new MersenneTwisterFast(seed);
System.out.println("testRemoveHalfRecords seed : " + seed);
Map<OClusterPosition, byte[]> positionRecordMap = new HashMap<OClusterPosition, byte[]>();
ORecordVersion recordVersion = OVersionFactory.instance().createVersion();
recordVersion.increment();
recordVersion.increment();
for (int i = 0; i < records; i++) {
int recordSize = mersenneTwisterFast.nextInt(3 * OClusterPage.MAX_RECORD_SIZE) + 1;
byte[] bigRecord = new byte[recordSize];
mersenneTwisterFast.nextBytes(bigRecord);
final OPhysicalPosition physicalPosition = paginatedCluster.createRecord(bigRecord, recordVersion, (byte) 2);
positionRecordMap.put(physicalPosition.clusterPosition, bigRecord);
}
int deletedRecords = 0;
Assert.assertEquals(records, paginatedCluster.getEntries());
Set<OClusterPosition> deletedPositions = new HashSet<OClusterPosition>();
Iterator<OClusterPosition> positionIterator = positionRecordMap.keySet().iterator();
while (positionIterator.hasNext()) {
OClusterPosition clusterPosition = positionIterator.next();
if (mersenneTwisterFast.nextBoolean()) {
deletedPositions.add(clusterPosition);
Assert.assertTrue(paginatedCluster.deleteRecord(clusterPosition));
deletedRecords++;
Assert.assertEquals(records - deletedRecords, paginatedCluster.getEntries());
positionIterator.remove();
}
}
Assert.assertEquals(paginatedCluster.getEntries(), records - deletedRecords);
for (OClusterPosition deletedPosition : deletedPositions) {
Assert.assertNull(paginatedCluster.readRecord(deletedPosition));
Assert.assertFalse(paginatedCluster.deleteRecord(deletedPosition));
}
for (Map.Entry<OClusterPosition, byte[]> entry : positionRecordMap.entrySet()) {
ORawBuffer rawBuffer = paginatedCluster.readRecord(entry.getKey());
Assert.assertNotNull(rawBuffer);
Assert.assertEquals(rawBuffer.version, recordVersion);
Assert.assertEquals(rawBuffer.buffer, entry.getValue());
Assert.assertEquals(rawBuffer.recordType, 2);
}
}
@AfterClass
public void afterClass() throws IOException {
paginatedCluster.delete();
diskCache.delete();
File file = new File(buildDirectory);
Assert.assertTrue(file.delete());
System.out.println("End LocalPaginatedClusterTest");
}
public void testBackwardIteration() throws IOException {
final int records = 10000;
long seed = System.currentTimeMillis();
MersenneTwisterFast mersenneTwisterFast = new MersenneTwisterFast(1381162033616L);
System.out.println("testBackwardIteration seed : " + seed);
NavigableMap<OClusterPosition, byte[]> positionRecordMap = new TreeMap<OClusterPosition, byte[]>();
ORecordVersion recordVersion = OVersionFactory.instance().createVersion();
recordVersion.increment();
recordVersion.increment();
for (int i = 0; i < records; i++) {
int recordSize = mersenneTwisterFast.nextInt(2 * OClusterPage.MAX_RECORD_SIZE) + 1;
byte[] record = new byte[recordSize];
mersenneTwisterFast.nextBytes(record);
final OPhysicalPosition physicalPosition = paginatedCluster.createRecord(record, recordVersion, (byte) 2);
positionRecordMap.put(physicalPosition.clusterPosition, record);
}
Iterator<OClusterPosition> positionIterator = positionRecordMap.keySet().iterator();
while (positionIterator.hasNext()) {
OClusterPosition clusterPosition = positionIterator.next();
if (mersenneTwisterFast.nextBoolean()) {
Assert.assertTrue(paginatedCluster.deleteRecord(clusterPosition));
positionIterator.remove();
}
}
OPhysicalPosition physicalPosition = new OPhysicalPosition();
physicalPosition.clusterPosition = OClusterPositionFactory.INSTANCE.valueOf(Long.MAX_VALUE);
OPhysicalPosition[] positions = paginatedCluster.floorPositions(physicalPosition);
Assert.assertTrue(positions.length > 0);
positionIterator = positionRecordMap.descendingKeySet().iterator();
int counter = 0;
while (positionIterator.hasNext()) {
Assert.assertTrue(positions.length > 0);
OClusterPosition testedPosition = positionIterator.next();
Assert.assertEquals(positions[positions.length - 1].clusterPosition, testedPosition);
OPhysicalPosition positionToFind = positions[positions.length - 1];
positions = paginatedCluster.lowerPositions(positionToFind);
counter++;
}
Assert.assertEquals(paginatedCluster.getEntries(), counter);
Assert.assertEquals(paginatedCluster.getFirstPosition(), positionRecordMap.firstKey());
Assert.assertEquals(paginatedCluster.getLastPosition(), positionRecordMap.lastKey());
}
public void testRemoveHalfRecordsAndAddAnotherHalfAgain() throws IOException {
final int records = 10000;
long seed = System.currentTimeMillis();
MersenneTwisterFast mersenneTwisterFast = new MersenneTwisterFast(seed);
System.out.println("testRemoveHalfRecordsAndAddAnotherHalfAgain seed : " + seed);
Map<OClusterPosition, byte[]> positionRecordMap = new HashMap<OClusterPosition, byte[]>();
ORecordVersion recordVersion = OVersionFactory.instance().createVersion();
recordVersion.increment();
recordVersion.increment();
for (int i = 0; i < records; i++) {
int recordSize = mersenneTwisterFast.nextInt(3 * OClusterPage.MAX_RECORD_SIZE) + 1;
byte[] bigRecord = new byte[recordSize];
mersenneTwisterFast.nextBytes(bigRecord);
final OPhysicalPosition physicalPosition = paginatedCluster.createRecord(bigRecord, recordVersion, (byte) 2);
positionRecordMap.put(physicalPosition.clusterPosition, bigRecord);
}
int deletedRecords = 0;
Assert.assertEquals(records, paginatedCluster.getEntries());
Iterator<OClusterPosition> positionIterator = positionRecordMap.keySet().iterator();
while (positionIterator.hasNext()) {
OClusterPosition clusterPosition = positionIterator.next();
if (mersenneTwisterFast.nextBoolean()) {
Assert.assertTrue(paginatedCluster.deleteRecord(clusterPosition));
deletedRecords++;
Assert.assertEquals(paginatedCluster.getEntries(), records - deletedRecords);
positionIterator.remove();
}
}
Assert.assertEquals(paginatedCluster.getEntries(), records - deletedRecords);
for (int i = 0; i < records / 2; i++) {
int recordSize = mersenneTwisterFast.nextInt(3 * OClusterPage.MAX_RECORD_SIZE) + 1;
byte[] bigRecord = new byte[recordSize];
mersenneTwisterFast.nextBytes(bigRecord);
final OPhysicalPosition physicalPosition = paginatedCluster.createRecord(bigRecord, recordVersion, (byte) 2);
positionRecordMap.put(physicalPosition.clusterPosition, bigRecord);
}
Assert.assertEquals(paginatedCluster.getEntries(), (long) (1.5 * records - deletedRecords));
}
@AfterMethod
public void afterMethod() throws IOException {
Assert.assertNull(atomicOperationsManager.getCurrentOperation());
writeAheadLog.delete();
readCache.deleteStorage(writeCache);
testCluster.delete();
testReadCache.deleteStorage(testWriteCache);
File file = new File(storageDir);
Assert.assertTrue(file.delete());
file = new File(testStorageDir);
Assert.assertTrue(file.delete());
file = new File(buildDirectory);
Assert.assertTrue(file.delete());
}
public void testRecordOverflowGrowFactor() throws Exception {
paginatedCluster.set(OCluster.ATTRIBUTES.COMPRESSION, ONothingCompression.NAME);
paginatedCluster.set(OCluster.ATTRIBUTES.RECORD_GROW_FACTOR, 1.5);
paginatedCluster.set(OCluster.ATTRIBUTES.RECORD_OVERFLOW_GROW_FACTOR, 2.5);
byte[] record = new byte[100];
Random random = new Random();
random.nextBytes(record);
ORecordVersion version = OVersionFactory.instance().createVersion();
OPhysicalPosition physicalPosition = paginatedCluster.createRecord(record, version, (byte) 1);
record = new byte[150];
random.nextBytes(record);
paginatedCluster.updateRecord(physicalPosition.clusterPosition, record, version, (byte) 1);
OCacheEntry cacheEntry = diskCache.load(1, 1, false);
int recordIndex = (int) (physicalPosition.clusterPosition.longValue() & 0xFFFF);
OCachePointer pagePointer = cacheEntry.getCachePointer();
OClusterPage page = new OClusterPage(pagePointer.getDataPointer(), false, ODurablePage.TrackMode.NONE);
Assert.assertEquals(page.getRecordSize(recordIndex), record.length + RECORD_SYSTEM_INFORMATION);
diskCache.release(cacheEntry);
record = new byte[200];
random.nextBytes(record);
paginatedCluster.updateRecord(physicalPosition.clusterPosition, record, version, (byte) 1);
cacheEntry = diskCache.load(1, 1, false);
pagePointer = cacheEntry.getCachePointer();
page = new OClusterPage(pagePointer.getDataPointer(), false, ODurablePage.TrackMode.NONE);
int fullContentSize = 500 + OIntegerSerializer.INT_SIZE + OByteSerializer.BYTE_SIZE; // type + real size
Assert.assertEquals(page.getRecordSize(recordIndex), 150 + RECORD_SYSTEM_INFORMATION);
fullContentSize -= 150 + RECORD_SYSTEM_INFORMATION - OByteSerializer.BYTE_SIZE - OLongSerializer.LONG_SIZE;
Assert.assertEquals(page.getRecordSize(recordIndex + 1), fullContentSize
+ (OByteSerializer.BYTE_SIZE + OLongSerializer.LONG_SIZE));
diskCache.release(cacheEntry);
}
private void createTestPaginatedCluster() throws IOException {
testStorage = mock(OLocalPaginatedStorage.class);
OStorageConfiguration storageConfiguration = mock(OStorageConfiguration.class);
storageConfiguration.clusters = new ArrayList<OStorageClusterConfiguration>();
storageConfiguration.fileTemplate = new OStorageSegmentConfiguration();
storageConfiguration.binaryFormatVersion = Integer.MAX_VALUE;
when(storageConfiguration.getContextConfiguration()).thenReturn(new OContextConfiguration());
testStorageDir = buildDirectory + "/localPaginatedClusterWithWALTestTwo";
when(testStorage.getStoragePath()).thenReturn(testStorageDir);
when(testStorage.getComponentsFactory())
.thenReturn(new OCurrentStorageComponentsFactory(storageConfiguration));
when(testStorage.getName()).thenReturn("localPaginatedClusterWithWALTestTwo");
when(testStorage.getVariableParser()).thenReturn(new OStorageVariableParser(testStorageDir));
File buildDir = new File(buildDirectory);
if (!buildDir.exists()) buildDir.mkdirs();
File storageDirTwoFile = new File(testStorageDir);
if (!storageDirTwoFile.exists()) storageDirTwoFile.mkdirs();
testWriteCache =
new OWOWCache(
false,
OGlobalConfiguration.DISK_CACHE_PAGE_SIZE.getValueAsInteger() * 1024,
1000000,
writeAheadLog,
100,
1648L * 1024 * 1024,
1648L * 1024 * 1024 + 400L * 1024 * 1024 * 1024,
testStorage,
false,
1);
testReadCache =
new O2QCache(
400L * 1024 * 1024 * 1024,
OGlobalConfiguration.DISK_CACHE_PAGE_SIZE.getValueAsInteger() * 1024,
false,
20);
OStorageVariableParser variableParser = new OStorageVariableParser(testStorageDir);
final OAtomicOperationsManager testAtomicOperationsManager =
new OAtomicOperationsManager(testStorage);
when(testStorage.getReadCache()).thenReturn(testReadCache);
when(testStorage.getWriteCache()).thenReturn(testWriteCache);
when(testStorage.getWALInstance()).thenReturn(null);
when(testStorage.getStorageTransaction()).thenReturn(null);
when(testStorage.getAtomicOperationsManager()).thenReturn(testAtomicOperationsManager);
when(testStorage.getVariableParser()).thenReturn(variableParser);
when(testStorage.getConfiguration()).thenReturn(storageConfiguration);
when(testStorage.getMode()).thenReturn("rw");
when(storageConfiguration.getDirectory()).thenReturn(testStorageDir);
testCluster = new OPaginatedCluster("testPaginatedClusterWithWALTest", testStorage);
testCluster.configure(testStorage, 6, "testPaginatedClusterWithWALTest", buildDirectory, -1);
testCluster.create(-1);
}
@BeforeMethod
public void beforeMethod() throws IOException {
paginatedCluster.truncate();
}
