TestRWJournal.TestRawStore (Blazegraph Database Platform 2.1.5 API)

java.lang.Object
- junit.framework.Assert
- - junit.framework.TestCase
  - - junit.framework.TestCase2
    - - com.bigdata.io.TestCase3
      - com.bigdata.rawstore.AbstractRawStoreTestCase
        
        com.bigdata.journal.AbstractBufferStrategyTestCase
        
        com.bigdata.journal.AbstractRestartSafeTestCase
        
        com.bigdata.rwstore.TestRWJournal.TestRawStore

All Implemented Interfaces:

junit.framework.Test

Enclosing class:

TestRWJournal
```
public static class TestRWJournal.TestRawStore
extends AbstractRestartSafeTestCase
```
Test suite integration for AbstractRestartSafeTestCase.

Author:

Bryan Thompson

Nested Class Summary
- Nested classes/interfaces inherited from class junit.framework.TestCase2
  TestCase2.MyProperties, TestCase2.RandomType

Field Summary
- Fields inherited from class com.bigdata.rawstore.AbstractRawStoreTestCase
  r
- Fields inherited from class junit.framework.TestCase2
  _randomType, log

Constructor Summary

Constructors
Constructor and Description

TestRWJournal.TestRawStore()

TestRWJournal.TestRawStore(String name)

Constructors
Constructor and Description
`TestRWJournal.TestRawStore()`
`TestRWJournal.TestRawStore(String name)`

Method Summary

Methods
Modifier and Type	Method and Description
`int`	`doStressCommitIndex(long retention, int runs)`
`protected BufferMode`	`getBufferMode()`
`Properties`	`getProperties()` Reads in the configuration properties for the test from a variety of resources and returns a properties hierarchy.
`protected IRawStore`	`getSmallSlotStore()`
`protected IRawStore`	`getSmallSlotStore(int slotSize)`
`protected IRawStore`	`getSmallSlotStore(int slotSize, int nWasteAllocators, float maxWaste)`
`protected IRawStore`	`getStore()` Return a new store that will serve as the fixture for the test.
`protected Journal`	`getStore(long retentionMillis)`
`void`	`notest_stress_alloc_performance()` Test to determine that allocation performance does not degrade at scale.
`void`	`notest_stressReallocationWithReadAndReopen()`
`void`	`test_addressing()` Ensures the allocation of unique addresses by mapping allocated address with uniqueness assertion against physical address.
`void`	`test_addressingContiguous()` Ensures the allocation of unique addresses by mapping allocated address with uniqueness assertion against physical address.
`void`	`test_allocate_then_read()` Test allocate()+read() where the record was never written (the data are undefined unless written so there is nothing really to test here except for exceptions which might be through for this condition).
`void`	`test_allocationContexts()` From a RWStore, creates multiple AllocationContexts to isolate updates, re-allocate storage and protect against by concurrent Contexts.
`void`	`test_allocations()` Basic allocation test to ensure the FixedAllocators are operating efficiently.
`void`	`test_allocBlobBoundariesCommitFreeCommitWithHistory()`
`void`	`test_allocBlobCommitFreeCommitWithHistory()`
`void`	`test_allocCommitFree()` State1 Allocate - Commit - Free assert that allocation remains committed
`void`	`test_allocCommitFreeCommit()` State2 Allocate - Commit - Free - Commit assert that allocation is no longer committed
`void`	`test_allocCommitFreeCommitAllocSessionWriteCache()` State5 Allocate - Commit - Free - Commit Tracks writeCache state through allocation
`void`	`test_allocCommitFreeCommitSessionWriteCache()` State4 Allocate - Commit - Free - Commit ..but with session protection using a RawTx
`void`	`test_allocCommitFreeCommitWithHistory()` In order to see deferred recycling we need to make two commits (with modifications) after the retention period has expired.
`void`	`test_allocCommitFreeCommitWriteCache()` State3 Allocate - Commit - Free - Commit Tracks writeCache state through allocation
`void`	`test_allocCommitFreeCommitWriteCacheWithHistory()`
`void`	`test_allocCommitFreeWithHistory()`
`void`	`test_blob_allocs()` Test of blob allocation, does not check on read back, just the allocation
`void`	`test_blob_readBack()` Test of blob allocation and read-back, firstly from cache and then from disk.
`void`	`test_blob_realloc()` Test of blob allocation and read-back, firstly from cache and then from disk.
`void`	`test_blobDeferredFrees()` This test releases over a blobs worth of deferred frees
`void`	`test_commitState()` Verify that we correctly restore the RWStore commit state if `RWStore.commit()` is followed by `RWStore.reset()` rather than `RWStore.postCommit()`.
`void`	`test_commitStateError()` Test verifies that a failure to retain the commit state in `RWStore.commit()` will cause problems if the write set is discarded by `RWStore.reset()` such that subsequent write sets run into persistent addressing errors.
`void`	`test_commitStateIllegal()` Verify that a double-commit causes an illegal state exception.
`void`	`test_isolatedReset()` Tests semantics of a simple isolated reset Commit some data UnIsolated: Delete committed and allocate new data Isolated: Delete committed and allocate new data Reset Test that deletion and new allocation are void for unisolated actions but not isolated
`void`	`test_metaAlloc()`
`void`	`test_multiVoidCommit()`
`void`	`test_notSoSimpleIsolatedReset()` Tests semantics of a more complex isolated reset Primarily the same as the simple isolated but ensuring more unisolated interactions after isolation is established.
`void`	`test_pureAlloc()` The pureAlloc test is to test the allocation aspect of the memory management rather than worrying about writing the data
`void`	`test_reallocate()` Reallocates the same object several times, then commits and tests read back.
`void`	`test_reallocation()` Reallocation tests the freeing of allocated address and the re-use within a transaction.
`void`	`test_reallocationWithReadAndReopen()`
`void`	`test_reopenReset()` Tests semantics of a simple reset after reopen to emulate an HAJournal reopen As for simple reset but also re-open, then write and abort.
`void`	`test_sessionProtection()` Tests whether tasks are able to access and modify data safely by emulating transactions by calling activateTx and deactivateTx directly.
`void`	`test_simpleConcurrentReadersWithResets()` Concurrent readers should no longer be an issue now that reset() is not re-initializing from the root block.
`void`	`test_simpleReset()` Tests semantics of a simple reset Commit some data Delete committed and allocate new data Reset Test that deletion and new allocation are void
`void`	`test_smallSlotRecycling()` Tests the recycling of small slot alloctors and outputs statistics related to contiguous allocations indicative of reduced IOPS.
`void`	`test_smallSlotWasteRecylcing()` At scale the small slot handling can lead to large amounts of store waste, tending to the small slot allocation thresholds of 50%, dependent on use case.
`void`	`test_snapshotData()`
`void`	`test_stressAlloc()`
`void`	`test_stressBlobBlobHeaderBlobDataDeferredFrees()` Repeats the BlobBlobHeader of deferred frees, but also with blob data.
`void`	`test_stressBlobBlobHeaderDeferredFrees()` This test releases over a blobs worth of deferred frees where the blob requires a blob header.
`void`	`test_stressBlobDeferredFrees()` This is the test that was able to reproduce the recycler failure for BLZG-1236 when run with 10M deferred frees.
`void`	`test_stressBlobReadBack()`
`void`	`test_stressCommit()`
`void`	`test_stressCommitIndexNoRetention()`
`void`	`test_stressCommitIndexWithRetention()`
`void`	`test_stressReallocationWithRead()` Adjust tcount to increase stress levels
`void`	`test_stressSessionProtection()` To stress the session protection, we will allocate a batch of addresses, then free half with protection.
`void`	`test_write_flush_update()` Ttest write() + flush() + update() - for this case the data have been flushed from the write cache so the update will be a random write on the file rather than being buffered by the write cache.
`void`	`testAllocationContexts()`
`void`	`testAllocationReserves()` Not so much a test as a code coverage exercise.
`void`	`testResetHARootBlock()`
`void`	`testSimpleReplication()` Test low level RWStore add/removeAddress methods as used in HA WriteCache replication to ensure Allocation consistency
`void`	`testSimpleReset()`
`void`	`testSimpleUnisolatedAllocationContextRecycling()`
`void`	`testStressAllocationContextRecycling()` This tests whether AllocationContexts efficiently recycle transient allocations.
`void`	`testStressReplication()` Test low level RWStore add/removeAddress methods as used in HA WriteCache replication to ensure Allocation consistency
`void`	`testStressUnisolatedAllocationContextRecycling()` This tests whether AllocationContexts efficiently recycle transient allocations with an Unisolated AllocationContext.
`void`	`testUnisolatedAllocationContextRecycling()` Need to test the handling of aborted Unisolated connections and specifically the logic behind freed addresses.
`void`	`testVerifyCommitRecordIndex()` Can be tested by removing RWStore call to journal.removeCommitRecordEntries in freeDeferrals.

Methods inherited from class com.bigdata.journal.AbstractRestartSafeTestCase
reopenStore, test_abort, test_closeForWrites, test_restartSafe_multipleWrites, test_restartSafe_oneWrite, test_restartSafe_oneWriteNoCommit

Methods inherited from class com.bigdata.journal.AbstractBufferStrategyTestCase
test_overflow, test_writeNoExtend, test_writeWithExtend, writeRandomData

Methods inherited from class com.bigdata.rawstore.AbstractRawStoreTestCase
getRandomData, test_close, test_multipleWrites, test_read_correctRejection_0L, test_read_correctRejection_zeroLength, test_readImmutable, test_write_correctRejection_emptyRecord, test_write_correctRejection_null, test_writeImmutable, test_writeRead, test_writeReadRead, testBlobObjectStreams, testEmptyStream, testSimpleStringStream, testSimpleStringStreamFromStandardAllocation, testZipStreams

Methods inherited from class com.bigdata.io.TestCase3
assertCondition, assertCondition, assertEquals, assertEquals, getBytes, getPort, getRandomData, getRandomData, setUp, tearDown

Methods inherited from class junit.framework.TestCase2
assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEqualsWithinUlps, assertSameArray, assertSameArray, assertSameBigDecimal, assertSameBigDecimal, assertSameBigInteger, assertSameBigInteger, assertSameIterator, assertSameIterator, assertSameIteratorAnyOrder, assertSameIteratorAnyOrder, assertSameValue, assertSameValue, assertZeroUlps, assertZeroUlps, fail, getInnerCause, getNormalInt, getProjectBuildPath, getRandomObject, getRandomObject, getRandomOrder, getRandomString, getTestInputStream, getTestResource, getTestResource, getUlps, getUlps, isDEBUG, isDEBUG, isINFO, isINFO, isInnerCause, logProperties

Methods inherited from class junit.framework.TestCase
assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertFalse, assertFalse, assertNotNull, assertNotNull, assertNotSame, assertNotSame, assertNull, assertNull, assertSame, assertSame, assertTrue, assertTrue, countTestCases, createResult, fail, fail, failNotEquals, failNotSame, failSame, format, getName, run, run, runBare, runTest, setName, toString

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Constructor Detail
  - TestRWJournal.TestRawStore
```
public TestRWJournal.TestRawStore()
```
  - TestRWJournal.TestRawStore
```
public TestRWJournal.TestRawStore(String name)
```
- Method Detail
  - getBufferMode
```
protected BufferMode getBufferMode()
```
    Specified by:
    
    getBufferMode in class AbstractBufferStrategyTestCase
  - getProperties
```
public Properties getProperties()
```
    Description copied from class: TestCase2
    Reads in the configuration properties for the test from a variety of resources and returns a properties hierarchy. If a property name is not bound at the top-level of the returned Properties object, then the lower levels of the hierarchy are recursively searched.
    The hierarchy is constructed from the following properties files in the following order. The first property file in this list corresponds to the top of the property hierarchy. The last property file in this list corresponds to the bottom of the property hierarchy. The property resources are:
    1. The System properties specified using the -D argument on the command line.
    2. ${user.home}/build.properties. ${user.home} is the value of the Java system environment variable named "user.home" and corresponds to the user home directory. A warning is logged if this properties file does not exist. Note: The JUnit UI can wind up with a different value for this property than when you execute tests without the UI. It is an error if the properties file exists but can not be read.
    3. {class}.properties, where {class} is the class name reported by Java reflection, is loaded iff it is found.
    4. {class} is repeatedly truncated by dropping the last package name component to generate a package name. If a properties file named "test.properties" exists in that package then those properties are loaded.
    Overrides:
    
    getProperties in class AbstractBufferStrategyTestCase
    
    Returns:
    A Properties object that supplies bindings for property names according to the described hierarchy among property resources. The returned Properties is NOT cached. TODO This does not handle the recursive truncation of the class name to search for "test.properties" yet.
  - getStore
```
protected IRawStore getStore()
```
    Description copied from class: AbstractRawStoreTestCase
    
    Return a new store that will serve as the fixture for the test. A stable store must remove the pre-existing store. A transient store should open a new store every time.
    
    Overrides:
    
    getStore in class AbstractBufferStrategyTestCase
    
    Returns:
    The fixture for the test.
  - getSmallSlotStore
```
protected IRawStore getSmallSlotStore()
```
  - getSmallSlotStore
```
protected IRawStore getSmallSlotStore(int slotSize)
```
  - getSmallSlotStore
```
protected IRawStore getSmallSlotStore(int slotSize,
                          int nWasteAllocators,
                          float maxWaste)
```
  - getStore
```
protected Journal getStore(long retentionMillis)
```
  - test_allocate_then_read
```
public void test_allocate_then_read()
```
    Test allocate()+read() where the record was never written (the data are undefined unless written so there is nothing really to test here except for exceptions which might be through for this condition).
  - test_reallocate
```
public void test_reallocate()
```
    Reallocates the same object several times, then commits and tests read back. Has been amended to exercise different cache read paths.
  - test_addressing
```
public void test_addressing()
```
    Ensures the allocation of unique addresses by mapping allocated address with uniqueness assertion against physical address.
  - test_addressingContiguous
```
public void test_addressingContiguous()
```
    Ensures the allocation of unique addresses by mapping allocated address with uniqueness assertion against physical address.
  - test_smallSlotRecycling
```
public void test_smallSlotRecycling()
```
    Tests the recycling of small slot alloctors and outputs statistics related to contiguous allocations indicative of reduced IOPS.
  - test_smallSlotWasteRecylcing
```
public void test_smallSlotWasteRecylcing()
```
    At scale the small slot handling can lead to large amounts of store waste, tending to the small slot allocation thresholds of 50%, dependent on use case.
    To mitigate this problem, when more than some minimum number of allocators are in use the storage stats are used to check on overall usage. If the waste is above some specified amount, then an attempt is made to locate a "reasonable" candidate allocator to be used.
    To test below sets thresholds to quickly trigger this behaviour, with a low minimum number of allocators, and low "candidate" re-use threshold.
    
    See Also:
    (Small slot optimization to minimize waste).
  - test_allocations
```
public void test_allocations()
```
    Basic allocation test to ensure the FixedAllocators are operating efficiently. A 90 byte allocation is expected to fit in a 128byte block. If we only allocate this fixed block size, then we would expect the physical address to increase by 128 bytes for each allocation.
  - testAllocationReserves
```
public void testAllocationReserves()
```
    Not so much a test as a code coverage exercise. The output from showAllocReserve confirms the relative merits of optimizing for space vs density. The DirectFixedAllocators will allocate from DirectBuffers, where locality of reference is less important than efficient management of the memory, which is optimized by allocations in smaller amounts that match the demands at a finer granularity.
  - test_reallocation
```
public void test_reallocation()
                       throws IOException
```
    Reallocation tests the freeing of allocated address and the re-use within a transaction. The repeated runs with full reopening of the store check the initialization of the allocators on reload.
    
    Throws:
    
    IOException
  - test_reallocationWithReadAndReopen
```
public void test_reallocationWithReadAndReopen()
```
  - notest_stressReallocationWithReadAndReopen
```
public void notest_stressReallocationWithReadAndReopen()
```
  - testAllocationContexts
```
public void testAllocationContexts()
```
  - testStressAllocationContextRecycling
```
public void testStressAllocationContextRecycling()
```
    This tests whether AllocationContexts efficiently recycle transient allocations. To do this it will allocate and free 1 million 50 byte regions, in batches of 10K.
  - testStressUnisolatedAllocationContextRecycling
```
public void testStressUnisolatedAllocationContextRecycling()
```
    This tests whether AllocationContexts efficiently recycle transient allocations with an Unisolated AllocationContext. To do this it will allocate and free 1 million 50 byte regions, in batches of 10K.
  - testUnisolatedAllocationContextRecycling
```
public void testUnisolatedAllocationContextRecycling()
```
    Need to test the handling of aborted Unisolated connections and specifically the logic behind freed addresses.
    The process is to: Allocate a range of data (to establish a number of Allocators) Create an Isolated context and allocate a handful more Create an Unisolated context Free some committed addreses Abort the Unisolated context - calling abort on the Journal Commit the Isolated context Observe if any of the previously committed data is freed!
  - testSimpleUnisolatedAllocationContextRecycling
```
public void testSimpleUnisolatedAllocationContextRecycling()
```
  - test_stressReallocationWithRead
```
public void test_stressReallocationWithRead()
```
    Adjust tcount to increase stress levels
  - notest_stress_alloc_performance
```
public void notest_stress_alloc_performance()
```
    Test to determine that allocation performance does not degrade at scale. The idea is to first create 128K allocations, and measure recycling performance. Then to add an additional 128K allocations and re-measure recycling to observe if performance degrades. The test is "observational" and console output should be monitored. Should be disabled for CI.
  - test_blob_allocs
```
public void test_blob_allocs()
```
    Test of blob allocation, does not check on read back, just the allocation
  - test_blob_readBack
```
public void test_blob_readBack()
```
    Test of blob allocation and read-back, firstly from cache and then from disk.
    
    Throws:
    
    InterruptedException
  - test_stressBlobReadBack
```
public void test_stressBlobReadBack()
```
  - test_blob_realloc
```
public void test_blob_realloc()
                       throws InterruptedException
```
    Test of blob allocation and read-back, firstly from cache and then from disk.
    
    Throws:
    
    InterruptedException
  - test_write_flush_update
```
public void test_write_flush_update()
```
    Ttest write() + flush() + update() - for this case the data have been flushed from the write cache so the update will be a random write on the file rather than being buffered by the write cache.
  - test_metaAlloc
```
public void test_metaAlloc()
```
  - test_multiVoidCommit
```
public void test_multiVoidCommit()
```
  - test_allocationContexts
```
public void test_allocationContexts()
                             throws IOException
```
    From a RWStore, creates multiple AllocationContexts to isolate updates, re-allocate storage and protect against by concurrent Contexts. This is the core functionality required to support Transactions. If an allocation is made for an AllocationContext then this will result in a ContextAllocation object being created in the RWStore within which "shadow" allocations can be made. If such a shadow allocation is deleted, within the AllocationContext, then this can be removed immediately.
    
    Throws:
    
    IOException
  - test_stressCommitIndexWithRetention
```
public void test_stressCommitIndexWithRetention()
```
  - test_stressCommitIndexNoRetention
```
public void test_stressCommitIndexNoRetention()
```
  - test_stressCommit
```
public void test_stressCommit()
```
  - doStressCommitIndex
```
public int doStressCommitIndex(long retention,
                      int runs)
```
  - test_stressAlloc
```
public void test_stressAlloc()
```
  - test_snapshotData
```
public void test_snapshotData()
                       throws IOException
```
    Throws:
    
    IOException
  - test_sessionProtection
```
public void test_sessionProtection()
```
    Tests whether tasks are able to access and modify data safely by emulating transactions by calling activateTx and deactivateTx directly.
  - test_stressSessionProtection
```
public void test_stressSessionProtection()
```
    To stress the session protection, we will allocate a batch of addresses, then free half with protection. Then reallocate half again after releasing the session. This should result in all the original batch being allocated, exercising both session protection and write cache clearing
  - testSimpleReplication
```
public void testSimpleReplication()
                           throws IOException
```
    Test low level RWStore add/removeAddress methods as used in HA WriteCache replication to ensure Allocation consistency
    
    Throws:
    
    IOException
  - testStressReplication
```
public void testStressReplication()
                           throws IOException
```
    Test low level RWStore add/removeAddress methods as used in HA WriteCache replication to ensure Allocation consistency
    
    Throws:
    
    IOException
  - test_pureAlloc
```
public void test_pureAlloc()
```
    The pureAlloc test is to test the allocation aspect of the memory management rather than worrying about writing the data
  - test_allocCommitFree
```
public void test_allocCommitFree()
```
    State1 Allocate - Commit - Free assert that allocation remains committed
  - test_commitState
```
public void test_commitState()
```
    Verify that we correctly restore the RWStore commit state if RWStore.commit() is followed by RWStore.reset() rather than RWStore.postCommit().
    
    See Also:
    RWStore commit is not robust to internal failure.
  - test_commitStateError
```
public void test_commitStateError()
```
    Test verifies that a failure to retain the commit state in RWStore.commit() will cause problems if the write set is discarded by RWStore.reset() such that subsequent write sets run into persistent addressing errors.
    
    See Also:
    RWStore commit is not robust to internal failure.
  - test_commitStateIllegal
```
public void test_commitStateIllegal()
```
    Verify that a double-commit causes an illegal state exception. Further verify that an RWStore.reset() allwos us to then apply and commit new write sets.
    
    See Also:
    RWStore commit is not robust to internal failure.
  - test_allocCommitFreeWithHistory
```
public void test_allocCommitFreeWithHistory()
```
  - test_blobDeferredFrees
```
public void test_blobDeferredFrees()
```
    This test releases over a blobs worth of deferred frees
  - test_stressBlobDeferredFrees
```
public void test_stressBlobDeferredFrees()
```
    This is the test that was able to reproduce the recycler failure for BLZG-1236 when run with 10M deferred frees.
    
    See Also:
    (recycler error)
  - test_stressBlobBlobHeaderDeferredFrees
```
public void test_stressBlobBlobHeaderDeferredFrees()
```
    This test releases over a blobs worth of deferred frees where the blob requires a blob header. To test this we use a max fixed alloc of 192 bytes, so 24 8 bytes addresses can be stored in each "leaf" and 48 leaves can be addressed in a standard blob header. This should set the allocation threshold at 48 * 24 = 1152 deferred addresses Anything greater than that requires that the blob header itself is a blob and this is what we need to test.
  - test_stressBlobBlobHeaderBlobDataDeferredFrees
```
public void test_stressBlobBlobHeaderBlobDataDeferredFrees()
```
    Repeats the BlobBlobHeader of deferred frees, but also with blob data.
  - testVerifyCommitRecordIndex
```
public void testVerifyCommitRecordIndex()
```
    Can be tested by removing RWStore call to journal.removeCommitRecordEntries in freeDeferrals. final int commitPointsRemoved = journal.removeCommitRecordEntries(fromKey, toKey); replaced with final int commitPointsRemoved = commitPointsRecycled;
  - testResetHARootBlock
```
public void testResetHARootBlock()
```
  - testSimpleReset
```
public void testSimpleReset()
```
  - test_allocCommitFreeCommit
```
public void test_allocCommitFreeCommit()
```
    State2 Allocate - Commit - Free - Commit assert that allocation is no longer committed
  - test_allocCommitFreeCommitWithHistory
```
public void test_allocCommitFreeCommitWithHistory()
```
    In order to see deferred recycling we need to make two commits (with modifications) after the retention period has expired. To be able to check for the address release, we must ensure that the same address cannot be re-allocated, so a different size allocation is requested.
  - test_allocBlobCommitFreeCommitWithHistory
```
public void test_allocBlobCommitFreeCommitWithHistory()
```
  - test_allocBlobBoundariesCommitFreeCommitWithHistory
```
public void test_allocBlobBoundariesCommitFreeCommitWithHistory()
```
  - test_allocCommitFreeCommitWriteCache
```
public void test_allocCommitFreeCommitWriteCache()
```
    State3 Allocate - Commit - Free - Commit Tracks writeCache state through allocation
  - test_allocCommitFreeCommitWriteCacheWithHistory
```
public void test_allocCommitFreeCommitWriteCacheWithHistory()
```
  - test_allocCommitFreeCommitSessionWriteCache
```
public void test_allocCommitFreeCommitSessionWriteCache()
```
    State4 Allocate - Commit - Free - Commit ..but with session protection using a RawTx
  - test_allocCommitFreeCommitAllocSessionWriteCache
```
public void test_allocCommitFreeCommitAllocSessionWriteCache()
```
    State5 Allocate - Commit - Free - Commit Tracks writeCache state through allocation
  - test_simpleReset
```
public void test_simpleReset()
```
    Tests semantics of a simple reset Commit some data Delete committed and allocate new data Reset Test that deletion and new allocation are void
  - test_reopenReset
```
public void test_reopenReset()
                      throws IOException
```
    Tests semantics of a simple reset after reopen to emulate an HAJournal reopen As for simple reset but also re-open, then write and abort.
    
    Throws:
    
    IOException
  - test_isolatedReset
```
public void test_isolatedReset()
```
    Tests semantics of a simple isolated reset Commit some data UnIsolated: Delete committed and allocate new data Isolated: Delete committed and allocate new data Reset Test that deletion and new allocation are void for unisolated actions but not isolated
  - test_notSoSimpleIsolatedReset
```
public void test_notSoSimpleIsolatedReset()
```
    Tests semantics of a more complex isolated reset Primarily the same as the simple isolated but ensuring more unisolated interactions after isolation is established. Commit some data UnIsolated: Delete committed and allocate new data Isolated: Delete committed and allocate new data UnIsolated: Delete committed and allocate new data Reset Test that deletion and new allocation are void for unisolated actions but not isolated
  - test_simpleConcurrentReadersWithResets
```
public void test_simpleConcurrentReadersWithResets()
                                            throws InterruptedException
```
    Concurrent readers should no longer be an issue now that reset() is not re-initializing from the root block. This test should confirm that. Establishes some committed data and runs two readers concurrent with a single writer intermittently aborting
    
    Throws:
    
    InterruptedException

Class TestRWJournal.TestRawStore

Nested Class Summary

Nested classes/interfaces inherited from class junit.framework.TestCase2

Field Summary

Fields inherited from class com.bigdata.rawstore.AbstractRawStoreTestCase

Fields inherited from class junit.framework.TestCase2

Constructor Summary

Method Summary

Methods inherited from class com.bigdata.journal.AbstractRestartSafeTestCase

Methods inherited from class com.bigdata.journal.AbstractBufferStrategyTestCase

Methods inherited from class com.bigdata.rawstore.AbstractRawStoreTestCase

Methods inherited from class com.bigdata.io.TestCase3

Methods inherited from class junit.framework.TestCase2

Methods inherited from class junit.framework.TestCase

Methods inherited from class java.lang.Object

Constructor Detail

TestRWJournal.TestRawStore

TestRWJournal.TestRawStore

Method Detail

getBufferMode

getProperties

getStore

getSmallSlotStore

getSmallSlotStore

getSmallSlotStore

getStore

test_allocate_then_read

test_reallocate

test_addressing

test_addressingContiguous

test_smallSlotRecycling

test_smallSlotWasteRecylcing

test_allocations

testAllocationReserves

test_reallocation

test_reallocationWithReadAndReopen

notest_stressReallocationWithReadAndReopen

testAllocationContexts

testStressAllocationContextRecycling

testStressUnisolatedAllocationContextRecycling

testUnisolatedAllocationContextRecycling

testSimpleUnisolatedAllocationContextRecycling

test_stressReallocationWithRead

notest_stress_alloc_performance

test_blob_allocs

test_blob_readBack

test_stressBlobReadBack

test_blob_realloc

test_write_flush_update

test_metaAlloc

test_multiVoidCommit

test_allocationContexts

test_stressCommitIndexWithRetention

test_stressCommitIndexNoRetention

test_stressCommit

doStressCommitIndex

test_stressAlloc

test_snapshotData

test_sessionProtection

test_stressSessionProtection

testSimpleReplication

testStressReplication

test_pureAlloc

test_allocCommitFree

test_commitState

test_commitStateError

test_commitStateIllegal

test_allocCommitFreeWithHistory

test_blobDeferredFrees

test_stressBlobDeferredFrees

test_stressBlobBlobHeaderDeferredFrees

test_stressBlobBlobHeaderBlobDataDeferredFrees

testVerifyCommitRecordIndex

testResetHARootBlock

testSimpleReset

test_allocCommitFreeCommit

test_allocCommitFreeCommitWithHistory

test_allocBlobCommitFreeCommitWithHistory

test_allocBlobBoundariesCommitFreeCommitWithHistory

test_allocCommitFreeCommitWriteCache