io.permazen.kv.test

Class KVDatabaseTest

java.lang.Object

io.permazen.test.TestSupport

io.permazen.kv.test.KVTestSupport

io.permazen.kv.test.KVDatabaseTest

public abstract class KVDatabaseTest
extends KVTestSupport

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
class	KVDatabaseTest.Committer
class	KVDatabaseTest.RandomTask
class	KVDatabaseTest.Reader
class	KVDatabaseTest.Writer

Field Summary

Fields

Modifier and Type	Field and Description
protected ExecutorService	executor
protected ExecutorService[]	threads

Fields inherited from class io.permazen.kv.test.KVTestSupport

numTransactionAttempts, numTransactionRetries

Fields inherited from class io.permazen.test.TestSupport

log, random, validator

Constructor Summary

Constructors

Constructor and Description
KVDatabaseTest()

Method Summary

Modifier and Type	Method and Description
protected boolean	allowBothTransactionsToFail()
protected boolean	allowsWriteSkewAnomaly()
protected KVDatabase[][]	getDBs()
protected abstract KVDatabase	getKVDatabase()
protected int	getNonconflictingTransactionCount()
protected int	getParallelTransactionLoopCount()
protected int	getParallelTransactionTaskCount()
protected int	getRandomTaskMaxIterations()
protected int	getSequentialTransactionLoopCount()
void	setupExecutorAndDatabases()
protected boolean	supportsMultipleWriteTransactions()
protected boolean	supportsReadOnlyAfterDataAccess()
void	teardownExecutorAndDatabases()
void	testApplyMutations(KVDatabase store) Test KVStore.apply().
protected void	testConflictingTransactions(KVDatabase store, String name, io.permazen.kv.test.KVDatabaseTest.Conflictor conflictor, KVPair expected1, KVPair expected2)
void	testKeyWatch(KVDatabase store)
void	testMultipleThreadsTransaction(KVDatabase store) This test has multiple threads banging away on a single transaction to verify that the transaction is thread safe.
void	testNonconflictingTransactions(KVDatabase store)
void	testParallelTransactions(KVDatabase store) This test runs transactions in parallel and verifies there is no "leakage" between them.
void	testParallelTransactions(KVDatabase[] stores)
void	testReadOnly(KVDatabase store)
void	testReadWriteConflict(KVDatabase store)
void	testSequentialTransactions(KVDatabase store) This test runs transactions sequentially and verifies that each transaction sees the changes that were committed in the previous transaction.
void	testSimpleStuff(KVDatabase store)
void	testSortOrder(KVDatabase store)
void	testWriteSkewAnomaly(KVDatabase store)
protected boolean	transactionsAreThreadSafe()

Methods inherited from class io.permazen.kv.test.KVTestSupport

createKVTransaction, doCreateTransaction, getNumTries, kv, mapRetryExceptionMessage, s, setupTransactionAttemptCounters, showKV, showKV, stringView, stringView, teardownTransactionAttemptCounters, toXmlString, toXmlString, tryNtimes, tryNtimesWithResult, updateRetryStats

Methods inherited from class io.permazen.test.TestSupport

assertEquals, assertEquals, b, ba, buildList, buildMap, buildSet, buildSortedMap, buildSortedSet, checkMap, checkSet, checkValid, createTempDirectory, deleteDirectoryHierarchy, diff, getRandom, randomBytes, randomBytes, readResource, readResource, readResource, s, seedRandom, setUpValidator, show

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

executor

protected ExecutorService executor

threads

protected ExecutorService[] threads

Constructor Detail

KVDatabaseTest

public KVDatabaseTest()

Method Detail

setupExecutorAndDatabases

@BeforeClass(dependsOnGroups="configure")
public void setupExecutorAndDatabases()
                                                                         throws Exception

Throws:

Exception

teardownExecutorAndDatabases

@AfterClass
public void teardownExecutorAndDatabases()
                                              throws Exception

Throws:

Exception

getDBs

@DataProvider(name="kvdbs")
protected KVDatabase[][] getDBs()

getKVDatabase

protected abstract KVDatabase getKVDatabase()

getNonconflictingTransactionCount

protected int getNonconflictingTransactionCount()

getParallelTransactionLoopCount

protected int getParallelTransactionLoopCount()

getParallelTransactionTaskCount

protected int getParallelTransactionTaskCount()

getSequentialTransactionLoopCount

protected int getSequentialTransactionLoopCount()

getRandomTaskMaxIterations

protected int getRandomTaskMaxIterations()

allowsWriteSkewAnomaly

protected boolean allowsWriteSkewAnomaly()

supportsReadOnlyAfterDataAccess

protected boolean supportsReadOnlyAfterDataAccess()

allowBothTransactionsToFail

protected boolean allowBothTransactionsToFail()

transactionsAreThreadSafe

protected boolean transactionsAreThreadSafe()

supportsMultipleWriteTransactions

protected boolean supportsMultipleWriteTransactions()

testSimpleStuff

public void testSimpleStuff(KVDatabase store)
                     throws Exception

Throws:

Exception

testReadOnly

public void testReadOnly(KVDatabase store)
                  throws Exception

Throws:

Exception

testSortOrder

public void testSortOrder(KVDatabase store)
                   throws Exception

Throws:

Exception

testKeyWatch

public void testKeyWatch(KVDatabase store)
                  throws Exception

Throws:

Exception

testReadWriteConflict

public void testReadWriteConflict(KVDatabase store)
                           throws Exception

Throws:

Exception

testWriteSkewAnomaly

public void testWriteSkewAnomaly(KVDatabase store)
                          throws Exception

Throws:

Exception

testConflictingTransactions

protected void testConflictingTransactions(KVDatabase store,
                                           String name,
                                           io.permazen.kv.test.KVDatabaseTest.Conflictor conflictor,
                                           KVPair expected1,
                                           KVPair expected2)
                                    throws Exception

Throws:

Exception

testNonconflictingTransactions

public void testNonconflictingTransactions(KVDatabase store)
                                    throws Exception

Throws:

Exception

testParallelTransactions

public void testParallelTransactions(KVDatabase store)
                              throws Exception

This test runs transactions in parallel and verifies there is no "leakage" between them. Database must be configured for linearizable isolation.

Parameters:

store - underlying store

Throws:

Exception - if an error occurs

testParallelTransactions

public void testParallelTransactions(KVDatabase[] stores)
                              throws Exception

Throws:

Exception

testSequentialTransactions

public void testSequentialTransactions(KVDatabase store)
                                throws Exception

This test runs transactions sequentially and verifies that each transaction sees the changes that were committed in the previous transaction.

Parameters:

store - underlying store

Throws:

Exception - if an error occurs

testMultipleThreadsTransaction

public void testMultipleThreadsTransaction(KVDatabase store)
                                    throws Exception

This test has multiple threads banging away on a single transaction to verify that the transaction is thread safe.

Parameters:

store - underlying store

Throws:

Exception - if an error occurs

testApplyMutations

public void testApplyMutations(KVDatabase store)
                        throws Exception

Test KVStore.apply().

Parameters:

store - database

Throws:

Exception - if an error occurs