KeyColumnValueStoreTest (JanusGraph-Backend-testutils: Collection of Backend tests 1.0.1-20240516-140043.dcd55d6 API)

java.lang.Object
- org.janusgraph.diskstorage.AbstractKCVSTest
- - org.janusgraph.diskstorage.KeyColumnValueStoreTest

All Implemented Interfaces:: JanusGraphBaseStoreFeaturesTest

public abstract class KeyColumnValueStoreTest
extends AbstractKCVSTest
implements JanusGraphBaseStoreFeaturesTest

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

protected class KeyColumnValueStoreTest.ConcurrentRandomSliceReader

Nested Classes
Modifier and Type	Class and Description
`protected class`	`KeyColumnValueStoreTest.ConcurrentRandomSliceReader`

Field Summary

Fields
Modifier and Type Field and Description

KeyColumnValueStoreManager manager

KeyColumnValueStore store

protected String storeName

static int TRIALS

StoreTransaction tx
- Fields inherited from class org.janusgraph.diskstorage.AbstractKCVSTest
  times

Fields
Modifier and Type	Field and Description
`KeyColumnValueStoreManager`	`manager`
`KeyColumnValueStore`	`store`
`protected String`	`storeName`
`static int`	`TRIALS`
`StoreTransaction`	`tx`

Constructor Summary

Constructors
Constructor and Description

KeyColumnValueStoreTest()

Constructors
Constructor and Description
`KeyColumnValueStoreTest()`

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`checkKeys(Set<Integer> removed)`
`protected void`	`checkRandomSlices(String[][] values, Set<KeyColumn> deleted)`
`void`	`checkSlice(String[][] values, Set<KeyColumn> removed, int key, int start, int end, int limit)`
`void`	`checkValueExistence(String[][] values)`
`void`	`checkValueExistence(String[][] values, Set<KeyColumn> removed)`
`void`	`checkValues(String[][] values)`
`void`	`checkValues(String[][] values, Set<KeyColumn> removed)`
`void`	`clopen()`
`void`	`close()`
`void`	`compareStores()`
`void`	`containsKeyColumnReturnsFalseOnNonexistentInput()`
`void`	`containsKeyColumnReturnsTrueOnExtantInput()`
`void`	`containsKeyReturnsFalseOnNonexistentKey()`
`void`	`containsKeyReturnsTrueOnExtantKey()`
`void`	`createDatabase()`
`void`	`deleteColumnsTest1()`
`void`	`deleteColumnsTest2()`
`void`	`deleteKeys()`
`Set<Integer>`	`deleteKeys(int every)`
`void`	`deleteNonExistingKeys()`
`Set<KeyColumn>`	`deleteValues(int every)`
`protected void`	`examineGetKeysResults(KeyIterator keyIterator, long startKey, long endKey)`
`String[][]`	`generateValues()`
`void`	`getNonExistentKeyReturnsNull()`
`void`	`getSliceRespectsAllBoundsInclusionArguments()`
`void`	`getSliceRespectsColumnLimit()`
`StoreFeatures`	`getStoreFeatures()`
`void`	`insertingGettingAndDeletingSimpleDataWorks()`
`void`	`intervalTest1()`
`void`	`intervalTest2()`
`void`	`loadLowerTriangularValues(int dimension, int offset)` Load a bunch of key-column-values in a way that vaguely resembles a lower triangular matrix.
`void`	`loadValues(String[][] values)`
`void`	`loadValues(String[][] values, int shiftEveryNthRow, int shiftSliceLength)`
`void`	`newTx()`
`void`	`open()`
`abstract KeyColumnValueStoreManager`	`openStorageManager()`
`protected KeyColumnValueStoreManager`	`openStorageManagerForClearStorageTest()`
`protected void`	`populateDBWith100Keys()`
`protected void`	`populateDBWith100Keys(KeyColumnValueStore store)`
`void`	`scanTest()` Loads a block of data where keys are longs on [idOffset, idOffset + numKeys) and the columns are longs on [idOffset, idOffset + numColumns).
`void`	`scanTestWithSimpleJob()`
`void`	`setUp()`
`StoreTransaction`	`startTx()`
`void`	`storeAndRetrieve()`
`void`	`storeAndRetrievePerformance()`
`void`	`storeAndRetrieveWithClosing()`
`StoreFeatures`	`storeFeatures()`
`void`	`tearDown()`
`void`	`testClearStorage()`
`void`	`testConcurrentGetSlice()`
`void`	`testConcurrentGetSliceAndMutate()`
`protected void`	`testConcurrentStoreOps(boolean deletionEnabled)`
`void`	`testGetKeysColumnSlicesOnLowerTriangular()` Test `getKeys` with columns slice values chosen to trigger potential fencepost bugs.
`void`	`testGetKeysColumnSlicesSimple()` Check that `getKeys` methods respect column slice bounds.
`void`	`testGetKeysWithKeyRange(org.junit.jupiter.api.TestInfo testInfo)`
`void`	`testGetKeysWithSliceQuery(org.junit.jupiter.api.TestInfo testInfo)`
`void`	`testGetSlices()`
`void`	`testOrderedGetKeysRespectsKeyLimit(org.junit.jupiter.api.TestInfo testInfo)` Verify that `KeyColumnValueStore.getKeys(KeyRangeQuery, StoreTransaction)` treats the lower key bound as inclusive and the upper key bound as exclusive.
`void`	`testStoreTTL()`
`void`	`testTtl()`

Methods inherited from class org.janusgraph.diskstorage.AbstractKCVSTest
getConsistentTxConfig, getTxConfig

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

Field Detail

TRIALS
```
public static final int TRIALS
```
See Also:

Constant Field Values

storeName
```
protected final String storeName
```
See Also:

Constant Field Values

manager

public KeyColumnValueStoreManager manager

tx
```
public StoreTransaction tx
```

store
```
public KeyColumnValueStore store
```

Constructor Detail
- KeyColumnValueStoreTest
```
public KeyColumnValueStoreTest()
```

Method Detail

setUp

@BeforeEach
public void setUp()
                       throws Exception

Throws:: Exception

openStorageManager

public abstract KeyColumnValueStoreManager openStorageManager()
                                                       throws BackendException

Throws:: BackendException

open

public void open()
          throws BackendException

Throws:: BackendException

getStoreFeatures
```
public StoreFeatures getStoreFeatures()
```
Specified by:

getStoreFeatures in interface JanusGraphBaseStoreFeaturesTest

startTx

public StoreTransaction startTx()
                         throws BackendException

Throws:: BackendException

storeFeatures
```
public StoreFeatures storeFeatures()
```

clopen

public void clopen()
            throws BackendException

Throws:: BackendException

tearDown

@AfterEach
public void tearDown()
                         throws Exception

Throws:: Exception

close

public void close()
           throws BackendException

Throws:: BackendException

newTx

public void newTx()
           throws BackendException

Throws:: BackendException

createDatabase
```
@Test
public void createDatabase()
```

generateValues
```
public String[][] generateValues()
```

loadValues

public void loadValues(String[][] values)
                throws BackendException

Throws:: BackendException

loadValues

public void loadValues(String[][] values,
                       int shiftEveryNthRow,
                       int shiftSliceLength)
                throws BackendException

Throws:: BackendException

loadLowerTriangularValues
```
public void loadLowerTriangularValues(int dimension,
                                      int offset)
                               throws BackendException
```
Load a bunch of key-column-values in a way that vaguely resembles a lower triangular matrix.
Iterate over key values k in the half-open long interval [offset, offset + dimension -1). For each k, iterate over the column values c in the half-open integer interval [offset, k].
For each key-column coordinate specified by a (k, c pair in the iteration, write a value one byte long with all bits set (unsigned -1 or signed 255).

Parameters:

dimension - size of loaded data (must be positive)

offset - offset (must be positive)

Throws:

BackendException - unexpected failure

deleteValues

public Set<KeyColumn> deleteValues(int every)
                            throws BackendException

Throws:: BackendException

deleteKeys

public Set<Integer> deleteKeys(int every)
                        throws BackendException

Throws:: BackendException

checkKeys

public void checkKeys(Set<Integer> removed)
               throws BackendException

Throws:: BackendException

checkValueExistence

public void checkValueExistence(String[][] values)
                         throws BackendException

Throws:: BackendException

checkValueExistence

public void checkValueExistence(String[][] values,
                                Set<KeyColumn> removed)
                         throws BackendException

Throws:: BackendException

checkValues

public void checkValues(String[][] values)
                 throws BackendException

Throws:: BackendException

checkValues

public void checkValues(String[][] values,
                        Set<KeyColumn> removed)
                 throws BackendException

Throws:: BackendException

storeAndRetrieve

@Test
public void storeAndRetrieve()
                            throws BackendException

Throws:: BackendException

compareStores

public void compareStores()
                   throws BackendException

Throws:: BackendException

storeAndRetrievePerformance

@Test
public void storeAndRetrievePerformance()
                                       throws BackendException

Throws:: BackendException

storeAndRetrieveWithClosing

@Test
public void storeAndRetrieveWithClosing()
                                       throws BackendException

Throws:: BackendException

deleteColumnsTest1

@Test
public void deleteColumnsTest1()
                              throws BackendException

Throws:: BackendException

deleteColumnsTest2

@Test
public void deleteColumnsTest2()
                              throws BackendException

Throws:: BackendException

deleteKeys

@Test
public void deleteKeys()
                      throws BackendException

Throws:: BackendException

deleteNonExistingKeys

@Test
public void deleteNonExistingKeys()

scanTest
```
@Test
public void scanTest()
                    throws BackendException
```
Loads a block of data where keys are longs on [idOffset, idOffset + numKeys) and the columns are longs on [idOffset, idOffset + numColumns). idOffset is KeyValueStoreUtil.idOffset. Note that identical columns appear on every key. The loaded values are randomly generated strings converted to bytes.
Calls the store's supported getKeys method depending on whether it supports ordered or unordered scan. This logic is delegated to KCVSUtil.getKeys(KeyColumnValueStore, StoreFeatures, int, int, StoreTransaction) . That method uses all-zero and all-one buffers for the key and column limits and retrieves every key.
This method does nothing and returns immediately if the store supports no scans.

Throws:

BackendException

testOrderedGetKeysRespectsKeyLimit
```
@Test
public void testOrderedGetKeysRespectsKeyLimit(org.junit.jupiter.api.TestInfo testInfo)
                                              throws BackendException
```
Verify that KeyColumnValueStore.getKeys(KeyRangeQuery, StoreTransaction) treats the lower key bound as inclusive and the upper key bound as exclusive. Verify that keys less than the start and greater than or equal to the end containing matching columns are not returned.

Throws:

BackendException

testGetKeysColumnSlicesSimple
```
@Test
public void testGetKeysColumnSlicesSimple()
                                         throws BackendException
```
Check that getKeys methods respect column slice bounds. Uses nearly the same data as testOrderedGetKeysRespectsKeyLimit(TestInfo), except that all columns on every 10th row exceed the getKeys slice limit.
For each row in this test, either all columns match the slice bounds or all columns fall outside the slice bounds. For this reason, it could be described as a "coarse-grained" or "simple" test of getKeys's column bounds checking.

Throws:

BackendException

testGetKeysColumnSlicesOnLowerTriangular
```
@Test
public void testGetKeysColumnSlicesOnLowerTriangular()
                                                    throws BackendException,
                                                           IOException
```
Test getKeys with columns slice values chosen to trigger potential fencepost bugs.
Description of data generated for and queried by this test:
Generate a sequence of keys as unsigned integers, starting at zero. Each row has as many columns as the key value. The columns are generated in the same way as the keys. This results in a sort of "lower triangular" data space, with no values above the diagonal.

Throws:

BackendException - shouldn't happen

IOException - shouldn't happen

checkSlice

public void checkSlice(String[][] values,
                       Set<KeyColumn> removed,
                       int key,
                       int start,
                       int end,
                       int limit)
                throws BackendException

Throws:: BackendException

intervalTest1

@Test
public void intervalTest1()
                         throws BackendException

Throws:: BackendException

intervalTest2

@Test
public void intervalTest2()
                         throws BackendException

Throws:: BackendException

checkRandomSlices

protected void checkRandomSlices(String[][] values,
                                 Set<KeyColumn> deleted)
                          throws BackendException

Throws:: BackendException

testConcurrentGetSlice

@Test
public void testConcurrentGetSlice()
                                  throws ExecutionException,
                                         InterruptedException,
                                         BackendException

Throws:: ExecutionException; InterruptedException; BackendException

testConcurrentGetSliceAndMutate

@Test
public void testConcurrentGetSliceAndMutate()
                                           throws BackendException,
                                                  ExecutionException,
                                                  InterruptedException

Throws:: BackendException; ExecutionException; InterruptedException

testConcurrentStoreOps

protected void testConcurrentStoreOps(boolean deletionEnabled)
                               throws BackendException,
                                      ExecutionException,
                                      InterruptedException

Throws:: BackendException; ExecutionException; InterruptedException

getNonExistentKeyReturnsNull

@Test
public void getNonExistentKeyReturnsNull()
                                        throws Exception

Throws:: Exception

insertingGettingAndDeletingSimpleDataWorks

@Test
public void insertingGettingAndDeletingSimpleDataWorks()
                                                      throws Exception

Throws:: Exception

getSliceRespectsColumnLimit

@Test
public void getSliceRespectsColumnLimit()
                                       throws Exception

Throws:: Exception

getSliceRespectsAllBoundsInclusionArguments

@Test
public void getSliceRespectsAllBoundsInclusionArguments()
                                                       throws Exception

Throws:: Exception

containsKeyReturnsTrueOnExtantKey

@Test
public void containsKeyReturnsTrueOnExtantKey()
                                             throws Exception

Throws:: Exception

containsKeyReturnsFalseOnNonexistentKey

@Test
public void containsKeyReturnsFalseOnNonexistentKey()
                                                   throws Exception

Throws:: Exception

containsKeyColumnReturnsFalseOnNonexistentInput

@Test
public void containsKeyColumnReturnsFalseOnNonexistentInput()
                                                           throws Exception

Throws:: Exception

containsKeyColumnReturnsTrueOnExtantInput

@Test
public void containsKeyColumnReturnsTrueOnExtantInput()
                                                     throws Exception

Throws:: Exception

testGetSlices

@Test
public void testGetSlices()
                         throws Exception

Throws:: Exception

testGetKeysWithSliceQuery

@Test
public void testGetKeysWithSliceQuery(org.junit.jupiter.api.TestInfo testInfo)
                                     throws Exception

Throws:: Exception

testGetKeysWithKeyRange

@Test
public void testGetKeysWithKeyRange(org.junit.jupiter.api.TestInfo testInfo)
                                   throws Exception

Throws:: Exception

testTtl

@Tag(value="BRITTLE_TESTS")
 @Test
public void testTtl()
                                                throws Exception

Throws:: Exception

testStoreTTL

@Test
public void testStoreTTL()
                        throws Exception

Throws:: Exception

populateDBWith100Keys

protected void populateDBWith100Keys()
                              throws Exception

Throws:: Exception

populateDBWith100Keys

protected void populateDBWith100Keys(KeyColumnValueStore store)
                              throws Exception

Throws:: Exception

examineGetKeysResults

protected void examineGetKeysResults(KeyIterator keyIterator,
                                     long startKey,
                                     long endKey)

scanTestWithSimpleJob

@Test
public void scanTestWithSimpleJob()
                                 throws Exception

Throws:: Exception

testClearStorage

@Test
public void testClearStorage()
                            throws Exception

Throws:: Exception

openStorageManagerForClearStorageTest

protected KeyColumnValueStoreManager openStorageManagerForClearStorageTest()
                                                                    throws Exception

Throws:: Exception

Class KeyColumnValueStoreTest

Nested Class Summary

Field Summary

Fields inherited from class org.janusgraph.diskstorage.AbstractKCVSTest

Constructor Summary

Method Summary

Methods inherited from class org.janusgraph.diskstorage.AbstractKCVSTest

Methods inherited from class java.lang.Object

Field Detail

TRIALS

storeName

manager

tx

store

Constructor Detail

KeyColumnValueStoreTest

Method Detail

setUp

openStorageManager

open

getStoreFeatures

startTx

storeFeatures

clopen

tearDown

close

newTx

createDatabase

generateValues

loadValues

loadValues

loadLowerTriangularValues

deleteValues

deleteKeys

checkKeys

checkValueExistence

checkValueExistence

checkValues

checkValues

storeAndRetrieve

compareStores

storeAndRetrievePerformance

storeAndRetrieveWithClosing

deleteColumnsTest1

deleteColumnsTest2

deleteKeys

deleteNonExistingKeys

scanTest

testOrderedGetKeysRespectsKeyLimit

testGetKeysColumnSlicesSimple

testGetKeysColumnSlicesOnLowerTriangular

checkSlice

intervalTest1

intervalTest2

checkRandomSlices

testConcurrentGetSlice

testConcurrentGetSliceAndMutate

testConcurrentStoreOps

getNonExistentKeyReturnsNull

insertingGettingAndDeletingSimpleDataWorks

getSliceRespectsColumnLimit

getSliceRespectsAllBoundsInclusionArguments

containsKeyReturnsTrueOnExtantKey

containsKeyReturnsFalseOnNonexistentKey

containsKeyColumnReturnsFalseOnNonexistentInput

containsKeyColumnReturnsTrueOnExtantInput

testGetSlices

testGetKeysWithSliceQuery

testGetKeysWithKeyRange

testTtl

testStoreTTL

populateDBWith100Keys

populateDBWith100Keys

examineGetKeysResults

scanTestWithSimpleJob

testClearStorage

openStorageManagerForClearStorageTest