GIIDeltaDUnitTest (GemFire XD Java API Documentation)

java.lang.Object
- junit.framework.Assert
- - junit.framework.TestCase
  - - dunit.DistributedTestCase
    - - com.gemstone.gemfire.cache30.CacheTestCase
      - com.gemstone.gemfire.internal.cache.GIIDeltaDUnitTest

All Implemented Interfaces:

Serializable, junit.framework.Test
```
public class GIIDeltaDUnitTest
extends CacheTestCase
```
See Also:

Serialized Form

Nested Class Summary
- Nested classes/interfaces inherited from class dunit.DistributedTestCase
  DistributedTestCase.ExpectedException, DistributedTestCase.WaitCriterion, DistributedTestCase.WaitCriterion2

Field Summary

Fields
Modifier and Type Field and Description

protected DistributedTestCase.ExpectedException expectedEx

protected static String REGION_NAME
- Fields inherited from class com.gemstone.gemfire.cache30.CacheTestCase
  cache
- Fields inherited from class dunit.DistributedTestCase
  logPerTest, reconnect, system, testName

Fields
Modifier and Type	Field and Description
`protected DistributedTestCase.ExpectedException`	`expectedEx`
`protected static String`	`REGION_NAME`

Constructor Summary

Constructors
Constructor and Description

GIIDeltaDUnitTest(String name)

Constructors
Constructor and Description
`GIIDeltaDUnitTest(String name)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`protected void`	`assignVMsToPandR(VM vm0, VM vm1)`
`protected void`	`changeForceFullGII(VM vm, boolean value, boolean checkOnly)`
`protected void`	`changeTombstoneTimout(VM vm, long value)`
`protected void`	`changeUnfinishedOperationLimit(VM vm, int value)`
`protected void`	`closeCache(VM vm)`
`protected void`	`createDistributedRegion(VM vm)`
`protected AsyncInvocation`	`createDistributedRegionAsync(VM vm)`
`protected void`	`destroyRegion(VM vm)`
`protected int`	`getDeltaGIICount(VM vm)`
`protected com.gemstone.gemfire.internal.cache.versions.RegionVersionVector`	`getDiskRVV(VM vm)`
`protected com.gemstone.gemfire.cache.RegionAttributes`	`getRegionAttributes()` Returns region attributes for a `GLOBAL` region
`protected com.gemstone.gemfire.internal.cache.versions.RegionVersionVector`	`getRVV(VM vm)`
`protected byte[]`	`getRVVByteArray(VM vm, String regionName)`
`protected void`	`prepareForEachTest()`
`protected void`	`removeSystemPropertiesInVM(VM vm, String prop)`
`static void`	`resetSlowGII()`
`static void`	`setRegionName(String testName)`
`void`	`setUp()` Sets up the test (noop).
`static void`	`slowGII(long[] versionsToBlock)`
`void`	`tearDown2()` Tears down the test.
`void`	`testClearAfterChunkEntries()` P and R are peers, each holds a DR.
`void`	`testClearAfterSavedRVV()` P and R are peers, each holds a DR.
`void`	`testDeltaGIIAfterClear()` P and R are peers, each holds a DR.
`void`	`testDeltaGIIWithDifferentRVVGC()` vm0 and vm1 are peers, each holds a DR.
`void`	`testDeltaGIIWithExceptionList()` vm0 and vm1 are peers, each holds a DR.
`void`	`testDeltaGIIWithOnlyUnfinishedOp_GCAtR()` This is to test a race condition for bug#47616 vm0 and vm1 are peers, each holds a DR.
`void`	`testDeltaGIIWithOnlyUnfinishedOp()` vm0 and vm1 are peers, each holds a DR.
`void`	`testDeltaGIIWithoutRVVGC()` vm0 and vm1 are peers, each holds a DR.
`void`	`testDeltaGIIWithSameRVV()` vm0 and vm1 are peers, each holds a DR.
`void`	`testExpiredTombstoneSkippedAtProviderOnly()` vm0 and vm1 are peers, each holds a DR.
`void`	`testFillSpecialException()` P1, P2, P3 R does GII but wait at BeforeSavedReceivedRVV, so R's RVV=P3R0 P4, P5 R goes on to save received RVV.
`void`	`testFillSpecialException2()` P1, P2, P3 R does GII but wait at BeforeSavedReceivedRVV, so R's RVV=P3R0 P4, P5 R goes on to save received RVV.
`void`	`testFullGIIAfterClear()` P and R are peers, each holds a DR.
`void`	`testFullGIINotDorminatedByProviderRVVGC()` vm0 and vm1 are peers, each holds a DR.
`void`	`testFullGIITriggeredByHigherRVVGC()` vm0 and vm1 are peers, each holds a DR.
`void`	`testFullGIITriggeredByTooManyUnfinishedOps()` vm0 and vm1 are peers, each holds a DR.
`void`	`testHooks()`
`void`	`testRecoverFromUntrustedRVV()` Test the case where a member has an untrusted RVV and still initializes from the local data.
`void`	`testRequesterHasHigherRVVGC()` vm0 and vm1 are peers, each holds a DR.
`void`	`testRestartWithOnlyGIIBegion()` P and R are peers, each holds a DR.
`void`	`testSavingRVVGC()` vm0(P), vm1(R), vm2(T) are peers, each holds a DR.
`void`	`testTombstoneGCInMiddleOfGII()` vm0 and vm1 are peers, each holds a DR.
`void`	`testUnfinishedOpsWithoutExceptionList()` Let R4, R5 unfinish, but R5 is the last operation from R.
`protected void`	`verifyDeltaSizeFromStats(VM vm, int expectedKeyNum, int expectedDeltaGIINum)`
`protected void`	`verifyTombstoneExist(VM vm, String key, boolean expectExist, boolean expectExpired)`
`void`	`waitForCallbackStarted(VM vm, com.gemstone.gemfire.internal.cache.InitialImageOperation.GIITestHookType callbacktype)`
`void`	`waitForToVerifyRVV(VM vm, com.gemstone.gemfire.internal.cache.persistence.DiskStoreID member, long expectedRegionVersion, long[] exceptionList, long expectedGCVersion)`
`void`	`waitToVerifyKey(VM vm, String key, String expect_value)`

Methods inherited from class com.gemstone.gemfire.cache30.CacheTestCase
addExceptionTag1, basicGetCache, beginCacheXml, cleanDiskDirs, closeAllCache, closeCache, createLonerCache, createMcastCache, createMcastCache, createRegion, createRegion, createRootRegion, createRootRegion, disconnectFromDS, finishCacheXml, finishCacheXml, getCache, getCache, getCache, getCache, getClientCache, getDiskDirs, getGemfireCache, getInternalRegionArguments, getRootRegion, getRootRegion, hasCache, remoteTearDown, removeExceptionTag1, sendSerialMessageToAll, sendUnorderedMessageToAll

Methods inherited from class dunit.DistributedTestCase
addExpectedException, addExpectedException, addHydraProperties, attachDebugger, checkBBFlag, cleanupAllVms, clearBBFlag, crashDistributedSystem, crashDistributedSystem, createLogWriter, disconnectAllFromDS, dumpAllStacks, dumpMyThreads, dumpStack, dumpStack, dumpStack, dumpStackTrace, fail, getAllDistributedSystemProperties, getDistributedSystemProperties, getDUnitLocatorAddress, getDUnitLocatorPort, getDUnitLocatorString, getDUnitLogLevel, getIPLiteral, getLogWriter, getLonerSystem, getMcastSystem, getMcastSystem, getRepeatTimeoutMs, getServerHostName, getSystem, getSystem, getTestClass, getTestName, getUniqueName, getVMCount, incBBFlag, invokeInEveryVM, invokeInEveryVM, invokeInEveryVM, invokeInEveryVM, invokeInEveryVMRepeatingIfNecessary, invokeInLocator, invokeRepeatingIfNecessary, isConnectedToDS, join, noteTiming, pause, pause, perVMSetUp, realTearDown, setDiskStoreForGateway, setSystem, setTestName, staticPause, tearDown, unregisterAllDataSerializersFromAllVms, unregisterDataSerializerInThisVM, unregisterInstantiatorsInThisVM, waitForBBFlag, waitForCriterion, waitMutex

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

- Field Detail
  - REGION_NAME
```
protected static String REGION_NAME
```
  - expectedEx
```
protected DistributedTestCase.ExpectedException expectedEx
```
- Constructor Detail
  - GIIDeltaDUnitTest
```
public GIIDeltaDUnitTest(String name)
```
    Parameters:
    
    name -
- Method Detail
  - setUp
```
public void setUp()
           throws Exception
```
    Description copied from class: DistributedTestCase
    
    Sets up the test (noop).
    
    Overrides:
    
    setUp in class DistributedTestCase
    
    Throws:
    
    Exception
  - setRegionName
```
public static void setRegionName(String testName)
```
  - tearDown2
```
public void tearDown2()
               throws Exception
```
    Description copied from class: DistributedTestCase
    
    Tears down the test. This method is called by the final DistributedTestCase.tearDown() method, and should be over ridden in its place.
    
    Overrides:
    
    tearDown2 in class CacheTestCase
    
    Throws:
    
    Exception
  - prepareForEachTest
```
protected void prepareForEachTest()
```
  - testDeltaGIIWithSameRVV
```
public void testDeltaGIIWithSameRVV()
                             throws Throwable
```
    vm0 and vm1 are peers, each holds a DR. Each does a few operations to make RVV=P7,R6, RVVGC=P4,R0 for both members. vm1 becomes offline then restarts. The deltaGII should only exchange RVV. No need to send data from vm0 to vm1.
    
    Throws:
    
    Throwable
  - testDeltaGIIWithExceptionList
```
public void testDeltaGIIWithExceptionList()
                                   throws Throwable
```
    vm0 and vm1 are peers, each holds a DR. create some exception list. Before GII, P's RVV is P7,R6(3-6), R's RVV is P6,R6, RVVGC are both P4,R0 vm1 becomes offline then restarts. https://wiki.gemstone.com/display/gfepersistence/DeltaGII+Spec+for+7.5 The deltaGII should send delta to R, revoke unfinished opeation R4,R5
    
    Throws:
    
    Throwable
  - testDeltaGIIWithOnlyUnfinishedOp
```
public void testDeltaGIIWithOnlyUnfinishedOp()
                                      throws Throwable
```
    vm0 and vm1 are peers, each holds a DR. create some exception list. Before GII, P's RVV is P6,R6(3-6), R's RVV is P6,R6, RVVGC are both P4,R0 vm1 becomes offline then restarts. The deltaGII should send delta which only contains unfinished opeation R4,R5
    
    Throws:
    
    Throwable
  - testDeltaGIIWithOnlyUnfinishedOp_GCAtR
```
public void testDeltaGIIWithOnlyUnfinishedOp_GCAtR()
                                            throws Throwable
```
    This is to test a race condition for bug#47616 vm0 and vm1 are peers, each holds a DR. create some exception list. Before GII, P's RVV is P6,R6(3-6), R's RVV is P6,R6, RVVGC are both P4,R0 vm1 becomes offline then restarts. The deltaGII should send delta which only contains unfinished opeation R4,R5
    
    Throws:
    
    Throwable
  - testDeltaGIIWithDifferentRVVGC
```
public void testDeltaGIIWithDifferentRVVGC()
                                    throws Throwable
```
    vm0 and vm1 are peers, each holds a DR. create some exception list. Then shutdown R. Do tombstone GC at P only. Before GII, P's RVV is P7,R6(3-6), RVVGC is P4,R0; R's RVV is P6,R6, RVVGC are both P0,R0 vm1 becomes offline then restarts. https://wiki.gemstone.com/display/gfepersistence/DeltaGII+Spec+for+7.5 The deltaGII should send delta to R, revoke unfinished opeation R4,R5
    
    Throws:
    
    Throwable
  - testFullGIITriggeredByHigherRVVGC
```
public void testFullGIITriggeredByHigherRVVGC()
                                       throws Throwable
```
    vm0 and vm1 are peers, each holds a DR. Let provider to have higher RVVGC than requester's RVV It should trigger fullGII This test also verify tombstoneGC happened in middle of GII, but BEFORE GII thread got GIILock. i.e. before GII, P's RVVGC=P0,R0, upon received RequestImageMessage, it becomes P4,R0 it should cause the fullGII.
    
    Throws:
    
    Throwable
  - testSavingRVVGC
```
public void testSavingRVVGC()
                     throws Throwable
```
    vm0(P), vm1(R), vm2(T) are peers, each holds a DR. shutdown vm1(R), vm2(T) Let provider to have higher RVVGC than requester's RVV when vm1 and vm2 are offline Restart R, It should trigger fullGII If R did not save the rvvgc, restarted R will have a way smaller rvvgc (maybe the same as T's) Let T requests GII from R, it wll become deltaGII, which is wrong.
    
    Throws:
    
    Throwable
  - testDeltaGIIWithoutRVVGC
```
public void testDeltaGIIWithoutRVVGC()
                              throws Throwable
```
    vm0 and vm1 are peers, each holds a DR. create some exception list. Not to do any tombstone GC Before GII, P's RVV is P7,R6(3-6), R's RVV is P6,R6, RVVGC are both P0,R0 vm1 becomes offline then restarts. https://wiki.gemstone.com/display/gfepersistence/DeltaGII+Spec+for+7.5 The deltaGII should send delta to R, revoke unfinished opeation R4,R5
    
    Throws:
    
    Throwable
  - testFullGIINotDorminatedByProviderRVVGC
```
public void testFullGIINotDorminatedByProviderRVVGC()
                                             throws Throwable
```
    vm0 and vm1 are peers, each holds a DR. unifinished P8: destroy(key1), finished P9: put(key3). Shutdown R, then GC tombstones at P. P's RVV=P9,R6(3-6), RVVGC=P8,R0, R's RVV=P9(7-9),R6, RVV It should trigger fullGII
    
    Throws:
    
    Throwable
  - testUnfinishedOpsWithoutExceptionList
```
public void testUnfinishedOpsWithoutExceptionList()
                                           throws Throwable
```
    Let R4, R5 unfinish, but R5 is the last operation from R. So P's RVV is still P:x,R3, without exception list. But actually R4, R5 are unfinished ops by all means.
    
    Throws:
    
    Throwable
  - testFillSpecialException
```
public void testFillSpecialException()
                              throws Throwable
```
    P1, P2, P3 R does GII but wait at BeforeSavedReceivedRVV, so R's RVV=P3R0 P4, P5 R goes on to save received RVV. R's new RVV=P5(3-6)R0 When image (which contains P4, P5) arrives, it should fill the special exception
    
    Throws:
    
    Throwable
  - testFillSpecialException2
```
public void testFillSpecialException2()
                               throws Throwable
```
    P1, P2, P3 R does GII but wait at BeforeSavedReceivedRVV, so R's RVV=P3R0 P4, P5 R goes on to save received RVV. R's new RVV=P5(3-6)R0 When image (which contains P4, P5) arrives, it should fill the special exception This test will let the 2 operations happen before RIM, so the rvv will match between R and P and no gii will happen. In this way, the chunk will not contain the missing entries.
    
    Throws:
    
    Throwable
  - testHooks
```
public void testHooks()
               throws Throwable
```
    Throws:
    
    Throwable
  - testTombstoneGCInMiddleOfGII
```
public void testTombstoneGCInMiddleOfGII()
                                  throws Throwable
```
    vm0 and vm1 are peers, each holds a DR. create some exception list. Then shutdown R. Before GII, P's RVV is P7,R6(3-6), RVVGC is P0,R0; R's RVV is P3,R6, RVVGC is P0,R0 vm1 becomes offline then restarts. Use testHook to pause the GII, then do tombstone GC at P only. The deltaGII should send correct tombstonedelta to R, revoke unfinished opeation R4,R5 There's member T doing GII from P at the same time. In this test, GII thread will get the GIILock before tombstone GC, so tombstone GC should wait for all GIIs to finish
    
    Throws:
    
    Throwable
  - testExpiredTombstoneSkippedAtProviderOnly
```
public void testExpiredTombstoneSkippedAtProviderOnly()
                                               throws Throwable
```
    vm0 and vm1 are peers, each holds a DR. Let P and R have the same RVV and RVVGC: P7,R6, RVVGC is P0,R0. vm1 becomes offline then restarts. Use testHook to pause the GII, then do tombstone GC triggered by expireBatch (not by forceGC) at R only. The tombstone GC will be executed at R, but igored at P. The deltaGII should send nothing to R since the RVVs are the same. So after GII, P and R will have different tombstone number. But P's tombstones should be expired.
    
    Throws:
    
    Throwable
  - testRequesterHasHigherRVVGC
```
public void testRequesterHasHigherRVVGC()
                                 throws Throwable
```
    vm0 and vm1 are peers, each holds a DR. Each does a few operations to make RVV=P7,R6, RVVGC=P4,R0 for both members. vm1 becomes offline then restarts. The deltaGII should only exchange RVV. No need to send data from vm0 to vm1.
    
    Throws:
    
    Throwable
  - testDeltaGIIAfterClear
```
public void testDeltaGIIAfterClear()
                            throws Throwable
```
    P and R are peers, each holds a DR. Each does a few operations to make RVV=P7,R6, RVVGC=P0,R0 for both members. P8 is clear() operation. After that, R offline. Run P9 is a put. Restart R. R will do deltaGII to get P9 as delta
    
    Throws:
    
    Throwable
  - testClearAfterChunkEntries
```
public void testClearAfterChunkEntries()
                                throws Throwable
```
    P and R are peers, each holds a DR. Each does a few operations to make RVV=P6,R6, RVVGC=P0,R0 for both members. R off line, then run P7. Restart R. It will trigger deltaGII to chunk entry P7(key1). After that, do clear(). Make sure R should not contain key1 after GII.
    
    Throws:
    
    Throwable
  - testClearAfterSavedRVV
```
public void testClearAfterSavedRVV()
                            throws Throwable
```
    P and R are peers, each holds a DR. Each does a few operations to make RVV=P6,R6, RVVGC=P0,R0 for both members. R off line, then run P7. Restart R. When P's RVV arrives, do clear(). It should trigger fullGII. Make sure R should not contain key1 after GII.
    
    Throws:
    
    Throwable
  - testFullGIIAfterClear
```
public void testFullGIIAfterClear()
                           throws Throwable
```
    P and R are peers, each holds a DR. Each does a few operations to make RVV=P7,R6, RVVGC=P0,R0 for both members. R offline, then P8 is clear() operation. Run P9 is a put. Restart R. R will do fullGII since R missed a clear
    
    Throws:
    
    Throwable
  - testFullGIITriggeredByTooManyUnfinishedOps
```
public void testFullGIITriggeredByTooManyUnfinishedOps()
                                                throws Throwable
```
    vm0 and vm1 are peers, each holds a DR. create some exception list. Before GII, P's RVV is P7,R6(3-6), R's RVV is P6,R6, RVVGC are both P4,R0 By changing MAX_UNFINISHED_OPERATIONS to be 1, 2. It should be fullGII then deltaGII.
    
    Throws:
    
    Throwable
  - testRestartWithOnlyGIIBegion
```
public void testRestartWithOnlyGIIBegion()
                                  throws Throwable
```
    P and R are peers, each holds a DR. Each does a few operations to make RVV=P6,R6, RVVGC=P0,R0 for both members. R off line, then run P7. Restart R. When P's RVV arrives, restart R. It should trigger fullGII.
    
    Throws:
    
    Throwable
  - testRecoverFromUntrustedRVV
```
public void testRecoverFromUntrustedRVV()
                                 throws Throwable
```
    Test the case where a member has an untrusted RVV and still initializes from the local data. See bug 48066
    
    Throws:
    
    Throwable
  - getRegionAttributes
```
protected com.gemstone.gemfire.cache.RegionAttributes getRegionAttributes()
```
    Returns region attributes for a GLOBAL region
  - createDistributedRegion
```
protected void createDistributedRegion(VM vm)
```
  - createDistributedRegionAsync
```
protected AsyncInvocation createDistributedRegionAsync(VM vm)
```
  - closeCache
```
protected void closeCache(VM vm)
```
  - destroyRegion
```
protected void destroyRegion(VM vm)
```
  - changeUnfinishedOperationLimit
```
protected void changeUnfinishedOperationLimit(VM vm,
                                              int value)
```
  - changeTombstoneTimout
```
protected void changeTombstoneTimout(VM vm,
                                     long value)
```
  - changeForceFullGII
```
protected void changeForceFullGII(VM vm,
                                  boolean value,
                                  boolean checkOnly)
```
  - removeSystemPropertiesInVM
```
protected void removeSystemPropertiesInVM(VM vm,
                                          String prop)
```
  - verifyDeltaSizeFromStats
```
protected void verifyDeltaSizeFromStats(VM vm,
                                        int expectedKeyNum,
                                        int expectedDeltaGIINum)
```
  - assignVMsToPandR
```
protected void assignVMsToPandR(VM vm0,
                                VM vm1)
```
  - waitForToVerifyRVV
```
public void waitForToVerifyRVV(VM vm,
                               com.gemstone.gemfire.internal.cache.persistence.DiskStoreID member,
                               long expectedRegionVersion,
                               long[] exceptionList,
                               long expectedGCVersion)
```
  - waitForCallbackStarted
```
public void waitForCallbackStarted(VM vm,
                                   com.gemstone.gemfire.internal.cache.InitialImageOperation.GIITestHookType callbacktype)
```
  - waitToVerifyKey
```
public void waitToVerifyKey(VM vm,
                            String key,
                            String expect_value)
```
  - getRVVByteArray
```
protected byte[] getRVVByteArray(VM vm,
                                 String regionName)
                          throws IOException,
                                 ClassNotFoundException
```
    Throws:
    
    IOException
    
    ClassNotFoundException
  - getRVV
```
protected com.gemstone.gemfire.internal.cache.versions.RegionVersionVector getRVV(VM vm)
                                                                           throws IOException,
                                                                                  ClassNotFoundException
```
    Throws:
    
    IOException
    
    ClassNotFoundException
  - getDiskRVV
```
protected com.gemstone.gemfire.internal.cache.versions.RegionVersionVector getDiskRVV(VM vm)
                                                                               throws IOException,
                                                                                      ClassNotFoundException
```
    Throws:
    
    IOException
    
    ClassNotFoundException
  - verifyTombstoneExist
```
protected void verifyTombstoneExist(VM vm,
                                    String key,
                                    boolean expectExist,
                                    boolean expectExpired)
```
  - getDeltaGIICount
```
protected int getDeltaGIICount(VM vm)
```
  - slowGII
```
public static void slowGII(long[] versionsToBlock)
```
  - resetSlowGII
```
public static void resetSlowGII()
```

Class GIIDeltaDUnitTest

Nested Class Summary

Nested classes/interfaces inherited from class dunit.DistributedTestCase

Field Summary

Fields inherited from class com.gemstone.gemfire.cache30.CacheTestCase

Fields inherited from class dunit.DistributedTestCase

Constructor Summary

Method Summary

Methods inherited from class com.gemstone.gemfire.cache30.CacheTestCase

Methods inherited from class dunit.DistributedTestCase

Methods inherited from class junit.framework.TestCase

Methods inherited from class java.lang.Object

Field Detail

REGION_NAME

expectedEx

Constructor Detail

GIIDeltaDUnitTest

Method Detail

setUp

setRegionName

tearDown2

prepareForEachTest

testDeltaGIIWithSameRVV

testDeltaGIIWithExceptionList

testDeltaGIIWithOnlyUnfinishedOp

testDeltaGIIWithOnlyUnfinishedOp_GCAtR

testDeltaGIIWithDifferentRVVGC

testFullGIITriggeredByHigherRVVGC

testSavingRVVGC

testDeltaGIIWithoutRVVGC

testFullGIINotDorminatedByProviderRVVGC

testUnfinishedOpsWithoutExceptionList

testFillSpecialException

testFillSpecialException2

testHooks

testTombstoneGCInMiddleOfGII

testExpiredTombstoneSkippedAtProviderOnly

testRequesterHasHigherRVVGC

testDeltaGIIAfterClear

testClearAfterChunkEntries

testClearAfterSavedRVV

testFullGIIAfterClear

testFullGIITriggeredByTooManyUnfinishedOps

testRestartWithOnlyGIIBegion

testRecoverFromUntrustedRVV

getRegionAttributes

createDistributedRegion

createDistributedRegionAsync

closeCache

destroyRegion

changeUnfinishedOperationLimit

changeTombstoneTimout

changeForceFullGII

removeSystemPropertiesInVM

verifyDeltaSizeFromStats

assignVMsToPandR

waitForToVerifyRVV

waitForCallbackStarted

waitToVerifyKey

getRVVByteArray

getRVV

getDiskRVV

verifyTombstoneExist

getDeltaGIICount

slowGII

resetSlowGII