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