MultiVMRegionTestCase (GemFire XD Java API Documentation)

java.lang.Object
- junit.framework.Assert
- - junit.framework.TestCase
  - - dunit.DistributedTestCase
    - - com.gemstone.gemfire.cache30.CacheTestCase
      - com.gemstone.gemfire.cache30.RegionTestCase
        
        com.gemstone.gemfire.cache30.MultiVMRegionTestCase

All Implemented Interfaces:

Serializable, junit.framework.Test

Direct Known Subclasses:

DistributedAckRegionTest, DistributedNoAckRegionTest, GlobalRegionTest, PartitionedRegionDUnitTest, PreloadedRegionTestCase
```
public abstract class MultiVMRegionTestCase
extends RegionTestCase
```
Abstract superclass of Region tests that involve more than one VM.

See Also:

Serialized Form

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

class MultiVMRegionTestCase.MyTransactionListener
- Nested classes/interfaces inherited from class com.gemstone.gemfire.cache30.RegionTestCase
  RegionTestCase.TestExpiry
- Nested classes/interfaces inherited from class dunit.DistributedTestCase
  DistributedTestCase.ExpectedException, DistributedTestCase.WaitCriterion, DistributedTestCase.WaitCriterion2

Nested Classes
Modifier and Type	Class and Description
`class`	`MultiVMRegionTestCase.MyTransactionListener`

Field Summary

Fields
Modifier and Type Field and Description

static com.gemstone.gemfire.internal.cache.LocalRegion CCRegion
- Fields inherited from class com.gemstone.gemfire.cache30.RegionTestCase
  eventCount, preSnapshotRegion
- 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
`static com.gemstone.gemfire.internal.cache.LocalRegion`	`CCRegion`

Constructor Summary

Constructors
Constructor and Description

MultiVMRegionTestCase(String name)

Constructors
Constructor and Description
`MultiVMRegionTestCase(String name)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`_ttestOrderedUpdates()` Tests that distributed updates are delivered in order
`static void`	`assertCacheCallbackEvents(String regionName, com.gemstone.gemfire.cache.TransactionId txId, Object key, Object oldValue, Object newValue)`
`static void`	`assertNoClearTimeouts()`
`static void`	`clearCCRegion()`
`void`	`concurrentMapTest(String rName)` Do putIfAbsent(), replace(Object, Object), replace(Object, Object, Object), remove(Object, Object) operations
`protected void`	`createRegionWithAttribute(VM vm, String name, boolean syncDiskWrite)`
`void`	`DISABLED_TILL_NEW_TX_IMPL_COMPLETE_testTXNonblockingGetInitialImage()` Tests that distributed ack operations do not block while another cache is doing a getInitialImage.
`protected void`	`disconnect(VM vm)`
`static void`	`doOpsLoopNoFlush(int runTimeMs, boolean includeClear, boolean includePutAll)`
`static Map`	`getCCRegionContents()`
`static Map<String,com.gemstone.gemfire.internal.cache.versions.VersionTag>`	`getCCRegionVersions()` returns a map of keys->versiontags for the test region
`static byte[]`	`getCCRegionVersionVector()` Since version vectors aren't java.io.Serializable we use DataSerializer to return a serialized form of the vector
`static com.gemstone.gemfire.distributed.internal.membership.InternalDistributedMember`	`getMemberId()`
`protected com.gemstone.gemfire.cache.RegionAttributes`	`getRegionAttributes(String type)` return the region attributes for the given type of region.
`protected AsyncInvocation`	`performOps4ClearWithConcurrentEvents(VM vm, int opNum)`
`protected boolean`	`supportsNetLoad()` Indicate whether this region supports netload
`protected boolean`	`supportsReplication()` Indicate whether replication/GII supported
`protected boolean`	`supportsTransactions()` Indicate whether this region supports transactions
`void`	`tearDown2()` Tears down the test.
`void`	`testCacheLoaderModifyingArgument()` Tests that when a `CacheLoader` modifies the callback argument in place, the change is visible to the `CacheWriter` even if it is in another VM.
`void`	`testCacheLoaderWithNetLoad()`
`void`	`testCacheLoaderWithNetSearch()`
`void`	`testConcurrentOperations()` This is a for the ConcurrentMap operations.
`void`	`testDefinedEntryUpdated()` Two VMs create a region.
`void`	`testDeltaWithReplicate()` Tests that a Delta is applied correctly both locally and on a replicate region.
`void`	`testDistributedDestroy()` Tests that destroying an entry is propagated to all VMs that define that entry.
`void`	`testDistributedGet()` Tests that doing a distributed get results in a `netSearch`.
`void`	`testDistributedInvalidate()` Tests that invalidating an entry is propagated to all VMs that define that entry.
`void`	`testDistributedInvalidate4()` Tests that invalidating an entry in multiple VMs does not cause any problems.
`void`	`testDistributedPut()` Tests that an entry update is propagated to other caches that have that same entry defined.
`void`	`testDistributedPutNoUpdate()` Tests that doing a `put` on a distributed region in one VM does not effect a region in a different VM that does not have that key defined.
`void`	`testDistributedRegionDestroy()` Tests that destroying a region is propagated to all VMs that define that region.
`void`	`testDistributedRegionInvalidate()` Tests that invalidating a region is propagated to all VMs that define that entry.
`void`	`testDistributedUpdate()` Tests that doing a `put` in a distributed region one VM updates the value in another VM.
`void`	`testEntryTtlDestroyEvent()` Tests that an entry in a distributed region that expires with a distributed destroy causes an event in other VM with isExpiration flag set.
`void`	`testEntryTtlLocalDestroy()` Tests that an entry in a distributed region expires with a local destroy after a given time to live.
`void`	`testGetInitialImage()` Tests that a newly-created mirrored region contains all of the entries of another region.
`void`	`testLargeGetInitialImage()` Tests that a newly-created mirrored region contains all of the entries of another region, with a large quantity of data.
`void`	`testLocalAndRemoteCacheWriters()` Tests that, when given a choice, a local `CacheWriter` is invoked instead of a remote one.
`void`	`testLocalCacheLoader()` Tests that a local loader is preferred to a remote one
`void`	`testLocalDestroy()` Tests that a Region.localDestroy(java.lang.Object) does not effect other VMs that define that entry.
`void`	`testLocalRegionDestroy()` Tests that a `Region.localDestroyRegion()` is not propagated to other VMs that define that region.
`void`	`testMirroredDataFromNonMirrored()` Tests that a mirrored region gets data pushed to it from a non-mirrored region and the afterCreate event is invoked on a listener.
`void`	`testMirroredLocalLoad()` Tests that a local load occurs, even with mirroring
`void`	`testMirroredNetLoad()` Tests sure that a `netLoad` occurs, even with mirroring
`void`	`testNBRegionDestructionDuringGetInitialImage()`
`void`	`testNBRegionInvalidationDuringGetInitialImage()`
`void`	`testNetSearchObservesIdleTime()`
`void`	`testNetSearchObservesTtl()`
`void`	`testNoDataSerializer()` Tests what happens when one VM attempts to read an object for which it does not have a registered `DataSerializer`.
`void`	`testNoInstantiator()` Tests what happens when one VM attempts to read an object for which it does not have a registered `Instantiator`.
`void`	`testNoLoaderWithInvalidEntry()` Tests that a remote `CacheLoader` is not invoked if the remote region has an invalid entry (that is, a key, but no value).
`void`	`testNoMirroredDataToNonMirrored()` Tests that a mirrored region does not push data to a non-mirrored region.
`void`	`testNonblockingGetInitialImage()` Tests that distributed ack operations do not block while another cache is doing a getInitialImage.
`void`	`testNoRegionKeepAlive()` Tests that a region is not kept alive
`void`	`testNoRemoteCacheLoader()` Tests that `Region.get(java.lang.Object)` returns `null` when there is no remote loader.
`void`	`testRemoteCacheListener()` Tests that a `CacheListener` is invoked in a remote VM.
`void`	`testRemoteCacheListenerInSubregion()` Tests that a `CacheListener` is invoked in a remote VM.
`void`	`testRemoteCacheLoader()` Tests that a `CacheLoader` is invoked in a remote VM.
`void`	`testRemoteCacheLoaderArg()` Tests that the parameter passed to a remote `CacheLoader` is actually passed.
`void`	`testRemoteCacheLoaderException()` Tests that a remote `CacheLoader` that throws a `CacheLoaderException` results is propagated back to the caller.
`void`	`testRemoteCacheWriter()` Tests that a remote `CacheWriter` is invoked and that `CacheWriter` arguments and `CacheWriterException`s are propagated appropriately.
`void`	`testRemoteLoaderNetSearch()` Tests that invoking `netSearch` in a remote loader returns `null` instead of causing infinite recursion.
`void`	`testReplicate()` Tests that keys and values are pushed with `DataPolicy.REPLICATE`.
`void`	`testTXMultiRegion()`
`void`	`testTXRmtMirror()`
`void`	`testTXSimpleOps()` Tests that an entry update is propagated to other caches that have that same entry defined.
`void`	`testTXUpdateLoadNoConflict()` Tests that the push of a loaded value does not cause a conflict on the side receiving the update
`void`	`testUpdateResetsIdleTime()` Tests to makes sure that a distributed update resets the expiration timer.
`void`	`todo_testTXAlgebra()`
`void`	`versionTestClearOnNonReplicateWithConcurrentEvents()`
`void`	`versionTestClearWithConcurrentEvents()`
`void`	`versionTestClearWithConcurrentEventsAsync()`
`void`	`versionTestConcurrentEvents()` This tests the concurrency versioning system to ensure that event conflation happens correctly and that the statistic is being updated properly
`void`	`versionTestConcurrentEventsOnEmptyRegion()` This tests the concurrency versioning system to ensure that event conflation happens correctly and that the statistic is being updated properly
`void`	`versionTestConcurrentEventsOnNonReplicatedRegion()` This tests the concurrency versioning system to ensure that event conflation happens correctly and that the statistic is being updated properly
`void`	`versionTestGetAllWithVersions()`
`void`	`versionTestGIISendsTombstones()`
`void`	`versionTestRegionVersionVectors()`
`void`	`versionTestTombstones()`
`protected boolean`	`waitForAsyncProcessing(AsyncInvocation async, String expectedError)`
`protected void`	`z_versionTestClearWithConcurrentEvents(boolean syncDiskWrite)`

Methods inherited from class com.gemstone.gemfire.cache30.RegionTestCase
createRegion, createRootRegion, entryIsLocal, getRegionAttributes, pauseIfNecessary, pauseIfNecessary, remoteTestPostSnapshot, supportsLocalDestroyAndLocalInvalidate, supportsSubregions, testBadRegionAccess, testCloseRegion, testContainsKey, testCreateSubregions, testCustomEntryIdleReset, testCustomEntryIdleTimeout1, testCustomEntryIdleTimeout2, testCustomEntryIdleTimeout3, testCustomEntryTtl1, testCustomEntryTtl2, testCustomEntryTtl3, testCustomIdleOnce, testDestroyEntry, testDestroyRegion, testEntries, testEntriesRecursive, testEntryExpirationAfterMutate, testEntryFromLoadTtlInvalidate, testEntryIdleDestroy, testEntryIdleInvalidate, testEntryIdleReset, testEntryIdleTimeout3, testEntryIdleTtl, testEntryTtl3, testEntryTtlDestroy, testEntryTtlInvalidate, testEntryUserAttribute, testGetCache, testGetName, testGetParentRegion, testGetPathFromRoot, testInvalidateEntry, testInvalidateRegion, testKeys, testLocalDestroyEntry, testLocalDestroyRegion, testLocalInvalidateEntry, testLocalInvalidateRegion, testNulls, testPutNonExistentEntry, testRegionExpirationAfterMutate, testRegionIdleDestroy, testRegionIdleInvalidate, testRegionTtlDestroy, testRegionTtlInvalidate, testRegionUserAttribute, testRootSnapshot, testSnapshot, testSubregions, testSubregionsRecursive, testValues, waitForDestroy, waitForInvalidate, waitForRegionDestroy

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, setUp, 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
  - CCRegion
```
public static com.gemstone.gemfire.internal.cache.LocalRegion CCRegion
```
- Constructor Detail
  - MultiVMRegionTestCase
```
public MultiVMRegionTestCase(String name)
```
- Method Detail
  - 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 RegionTestCase
    
    Throws:
    
    Exception
  - testConcurrentOperations
```
public void testConcurrentOperations()
                              throws Exception
```
    This is a for the ConcurrentMap operations. 4 VMs are used to create the region and operations are performed on one of the nodes
    
    Throws:
    
    Exception
  - concurrentMapTest
```
public void concurrentMapTest(String rName)
```
    Do putIfAbsent(), replace(Object, Object), replace(Object, Object, Object), remove(Object, Object) operations
  - testDistributedUpdate
```
public void testDistributedUpdate()
```
    Tests that doing a put in a distributed region one VM updates the value in another VM.
  - _ttestOrderedUpdates
```
public void _ttestOrderedUpdates()
                          throws Throwable
```
    Tests that distributed updates are delivered in order
    Note that this test does not make sense for regions that are Scope.DISTRIBUTED_NO_ACK for which we do not guarantee the ordering of updates for a single producer/single consumer. DISABLED 4-16-04 - the current implementation assumes events are processed synchronously, which is no longer true.
    
    Throws:
    
    Throwable
  - testDistributedGet
```
public void testDistributedGet()
```
    Tests that doing a distributed get results in a netSearch.
  - testDistributedPutNoUpdate
```
public void testDistributedPutNoUpdate()
                                throws InterruptedException
```
    Tests that doing a put on a distributed region in one VM does not effect a region in a different VM that does not have that key defined.
    
    Throws:
    
    InterruptedException
  - testDefinedEntryUpdated
```
public void testDefinedEntryUpdated()
```
    Two VMs create a region. One populates a region entry. The other VM defines that entry. The first VM updates the entry. The second VM should see the updated value.
  - testDistributedDestroy
```
public void testDistributedDestroy()
                            throws InterruptedException
```
    Tests that destroying an entry is propagated to all VMs that define that entry.
    
    Throws:
    
    InterruptedException
  - testDistributedRegionDestroy
```
public void testDistributedRegionDestroy()
                                  throws InterruptedException
```
    Tests that destroying a region is propagated to all VMs that define that region.
    
    Throws:
    
    InterruptedException
  - testLocalDestroy
```
public void testLocalDestroy()
                      throws InterruptedException
```
    Tests that a Region.localDestroy(java.lang.Object) does not effect other VMs that define that entry.
    
    Throws:
    
    InterruptedException
  - testLocalRegionDestroy
```
public void testLocalRegionDestroy()
                            throws InterruptedException
```
    Tests that a Region.localDestroyRegion() is not propagated to other VMs that define that region.
    
    Throws:
    
    InterruptedException
  - testDistributedInvalidate
```
public void testDistributedInvalidate()
```
    Tests that invalidating an entry is propagated to all VMs that define that entry.
  - testDistributedInvalidate4
```
public void testDistributedInvalidate4()
                                throws InterruptedException
```
    Tests that invalidating an entry in multiple VMs does not cause any problems.
    
    Throws:
    
    InterruptedException
  - testDistributedRegionInvalidate
```
public void testDistributedRegionInvalidate()
                                     throws InterruptedException
```
    Tests that invalidating a region is propagated to all VMs that define that entry.
    
    Throws:
    
    InterruptedException
  - testRemoteCacheListener
```
public void testRemoteCacheListener()
                             throws InterruptedException
```
    Tests that a CacheListener is invoked in a remote VM.
    
    Throws:
    
    InterruptedException
  - testRemoteCacheListenerInSubregion
```
public void testRemoteCacheListenerInSubregion()
                                        throws InterruptedException
```
    Tests that a CacheListener is invoked in a remote VM.
    
    Throws:
    
    InterruptedException
  - supportsNetLoad
```
protected boolean supportsNetLoad()
```
    Indicate whether this region supports netload
    
    Returns:
    
    true if it supports netload
  - testRemoteCacheLoader
```
public void testRemoteCacheLoader()
                           throws InterruptedException
```
    Tests that a CacheLoader is invoked in a remote VM. This essentially tests netLoad.
    
    Throws:
    
    InterruptedException
  - testRemoteCacheLoaderArg
```
public void testRemoteCacheLoaderArg()
                              throws InterruptedException
```
    Tests that the parameter passed to a remote CacheLoader is actually passed.
    
    Throws:
    
    InterruptedException
  - testRemoteCacheLoaderException
```
public void testRemoteCacheLoaderException()
                                    throws InterruptedException
```
    Tests that a remote CacheLoader that throws a CacheLoaderException results is propagated back to the caller.
    
    Throws:
    
    InterruptedException
  - testCacheLoaderWithNetSearch
```
public void testCacheLoaderWithNetSearch()
                                  throws com.gemstone.gemfire.cache.CacheException
```
    Throws:
    
    com.gemstone.gemfire.cache.CacheException
  - testCacheLoaderWithNetLoad
```
public void testCacheLoaderWithNetLoad()
                                throws com.gemstone.gemfire.cache.CacheException
```
    Throws:
    
    com.gemstone.gemfire.cache.CacheException
  - testNoRemoteCacheLoader
```
public void testNoRemoteCacheLoader()
                             throws InterruptedException
```
    Tests that Region.get(java.lang.Object) returns null when there is no remote loader.
    
    Throws:
    
    InterruptedException
  - testNoLoaderWithInvalidEntry
```
public void testNoLoaderWithInvalidEntry()
```
    Tests that a remote CacheLoader is not invoked if the remote region has an invalid entry (that is, a key, but no value).
  - testRemoteCacheWriter
```
public void testRemoteCacheWriter()
                           throws InterruptedException
```
    Tests that a remote CacheWriter is invoked and that CacheWriter arguments and CacheWriterExceptions are propagated appropriately.
    
    Throws:
    
    InterruptedException
  - testLocalAndRemoteCacheWriters
```
public void testLocalAndRemoteCacheWriters()
                                    throws InterruptedException
```
    Tests that, when given a choice, a local CacheWriter is invoked instead of a remote one.
    
    Throws:
    
    InterruptedException
  - testCacheLoaderModifyingArgument
```
public void testCacheLoaderModifyingArgument()
                                      throws InterruptedException
```
    Tests that when a CacheLoader modifies the callback argument in place, the change is visible to the CacheWriter even if it is in another VM.
    
    Throws:
    
    InterruptedException
  - testRemoteLoaderNetSearch
```
public void testRemoteLoaderNetSearch()
                               throws com.gemstone.gemfire.cache.CacheException
```
    Tests that invoking netSearch in a remote loader returns null instead of causing infinite recursion.
    
    Throws:
    
    com.gemstone.gemfire.cache.CacheException
  - testLocalCacheLoader
```
public void testLocalCacheLoader()
```
    Tests that a local loader is preferred to a remote one
  - testDistributedPut
```
public void testDistributedPut()
                        throws Exception
```
    Tests that an entry update is propagated to other caches that have that same entry defined.
    
    Throws:
    
    Exception
  - supportsReplication
```
protected boolean supportsReplication()
```
    Indicate whether replication/GII supported
    
    Returns:
    
    true if replication is supported
  - testReplicate
```
public void testReplicate()
                   throws InterruptedException
```
    Tests that keys and values are pushed with DataPolicy.REPLICATE.
    
    Throws:
    
    InterruptedException
  - testDeltaWithReplicate
```
public void testDeltaWithReplicate()
                            throws InterruptedException
```
    Tests that a Delta is applied correctly both locally and on a replicate region.
    
    Throws:
    
    InterruptedException
  - testGetInitialImage
```
public void testGetInitialImage()
```
    Tests that a newly-created mirrored region contains all of the entries of another region.
  - testLargeGetInitialImage
```
public void testLargeGetInitialImage()
```
    Tests that a newly-created mirrored region contains all of the entries of another region, with a large quantity of data.
  - testMirroredDataFromNonMirrored
```
public void testMirroredDataFromNonMirrored()
                                     throws InterruptedException
```
    Tests that a mirrored region gets data pushed to it from a non-mirrored region and the afterCreate event is invoked on a listener.
    
    Throws:
    
    InterruptedException
  - testNoMirroredDataToNonMirrored
```
public void testNoMirroredDataToNonMirrored()
                                     throws InterruptedException
```
    Tests that a mirrored region does not push data to a non-mirrored region.
    
    Throws:
    
    InterruptedException
  - testMirroredLocalLoad
```
public void testMirroredLocalLoad()
```
    Tests that a local load occurs, even with mirroring
  - testMirroredNetLoad
```
public void testMirroredNetLoad()
```
    Tests sure that a netLoad occurs, even with mirroring
  - testNoRegionKeepAlive
```
public void testNoRegionKeepAlive()
                           throws InterruptedException
```
    Tests that a region is not kept alive
    
    Throws:
    
    InterruptedException
  - testNetSearchObservesTtl
```
public void testNetSearchObservesTtl()
                              throws InterruptedException
```
    Throws:
    
    InterruptedException
  - testNetSearchObservesIdleTime
```
public void testNetSearchObservesIdleTime()
                                   throws InterruptedException
```
    Throws:
    
    InterruptedException
  - testEntryTtlDestroyEvent
```
public void testEntryTtlDestroyEvent()
                              throws InterruptedException
```
    Tests that an entry in a distributed region that expires with a distributed destroy causes an event in other VM with isExpiration flag set.
    
    Throws:
    
    InterruptedException
  - testEntryTtlLocalDestroy
```
public void testEntryTtlLocalDestroy()
                              throws InterruptedException
```
    Tests that an entry in a distributed region expires with a local destroy after a given time to live.
    
    Throws:
    
    InterruptedException
  - testUpdateResetsIdleTime
```
public void testUpdateResetsIdleTime()
                              throws InterruptedException
```
    Tests to makes sure that a distributed update resets the expiration timer.
    
    Throws:
    
    InterruptedException
  - testNonblockingGetInitialImage
```
public void testNonblockingGetInitialImage()
                                    throws Throwable
```
    Tests that distributed ack operations do not block while another cache is doing a getInitialImage.
    
    Throws:
    
    Throwable
  - DISABLED_TILL_NEW_TX_IMPL_COMPLETE_testTXNonblockingGetInitialImage
```
public void DISABLED_TILL_NEW_TX_IMPL_COMPLETE_testTXNonblockingGetInitialImage()
                                                                         throws Throwable
```
    Tests that distributed ack operations do not block while another cache is doing a getInitialImage. [sumedh] Requires event subscription for TX events and GII support for TX.
    
    Throws:
    
    Throwable
  - testNBRegionInvalidationDuringGetInitialImage
```
public void testNBRegionInvalidationDuringGetInitialImage()
                                                   throws Throwable
```
    Throws:
    
    Throwable
  - testNBRegionDestructionDuringGetInitialImage
```
public void testNBRegionDestructionDuringGetInitialImage()
                                                  throws Throwable
```
    Throws:
    
    Throwable
  - testNoDataSerializer
```
public void testNoDataSerializer()
```
    Tests what happens when one VM attempts to read an object for which it does not have a registered DataSerializer.
    
    Since:
    
    3.5
  - testNoInstantiator
```
public void testNoInstantiator()
```
    Tests what happens when one VM attempts to read an object for which it does not have a registered Instantiator.
    
    Since:
    
    3.5
  - assertCacheCallbackEvents
```
public static void assertCacheCallbackEvents(String regionName,
                                             com.gemstone.gemfire.cache.TransactionId txId,
                                             Object key,
                                             Object oldValue,
                                             Object newValue)
```
  - testTXSimpleOps
```
public void testTXSimpleOps()
                     throws Exception
```
    Tests that an entry update is propagated to other caches that have that same entry defined.
    
    Throws:
    
    Exception
  - supportsTransactions
```
protected boolean supportsTransactions()
```
    Indicate whether this region supports transactions
    
    Returns:
    
    true if it supports transactions
  - testTXUpdateLoadNoConflict
```
public void testTXUpdateLoadNoConflict()
                                throws Exception
```
    Tests that the push of a loaded value does not cause a conflict on the side receiving the update
    
    Throws:
    
    Exception
  - testTXMultiRegion
```
public void testTXMultiRegion()
                       throws Exception
```
    Throws:
    
    Exception
  - testTXRmtMirror
```
public void testTXRmtMirror()
                     throws Exception
```
    Throws:
    
    Exception
  - todo_testTXAlgebra
```
public void todo_testTXAlgebra()
                        throws Exception
```
    Throws:
    
    Exception
  - getRegionAttributes
```
protected com.gemstone.gemfire.cache.RegionAttributes getRegionAttributes(String type)
```
    return the region attributes for the given type of region. See GemFireCache.getRegionAttributes(String). Subclasses are expected to reimplement this method. See DistributedAckRegionCCEDUnitTest.getRegionAttributes(String).
  - versionTestGIISendsTombstones
```
public void versionTestGIISendsTombstones()
                                   throws Exception
```
    Throws:
    
    Exception
  - disconnect
```
protected void disconnect(VM vm)
```
  - versionTestConcurrentEvents
```
public void versionTestConcurrentEvents()
                                 throws Exception
```
    This tests the concurrency versioning system to ensure that event conflation happens correctly and that the statistic is being updated properly
    
    Throws:
    
    Exception
  - performOps4ClearWithConcurrentEvents
```
protected AsyncInvocation performOps4ClearWithConcurrentEvents(VM vm,
                                                               int opNum)
```
  - createRegionWithAttribute
```
protected void createRegionWithAttribute(VM vm,
                                         String name,
                                         boolean syncDiskWrite)
```
  - versionTestClearWithConcurrentEvents
```
public void versionTestClearWithConcurrentEvents()
                                          throws Exception
```
    Throws:
    
    Exception
  - versionTestClearWithConcurrentEventsAsync
```
public void versionTestClearWithConcurrentEventsAsync()
                                               throws Exception
```
    Throws:
    
    Exception
  - z_versionTestClearWithConcurrentEvents
```
protected void z_versionTestClearWithConcurrentEvents(boolean syncDiskWrite)
                                               throws Exception
```
    Throws:
    
    Exception
  - versionTestClearOnNonReplicateWithConcurrentEvents
```
public void versionTestClearOnNonReplicateWithConcurrentEvents()
                                                        throws Exception
```
    Throws:
    
    Exception
  - versionTestTombstones
```
public void versionTestTombstones()
```
  - versionTestConcurrentEventsOnEmptyRegion
```
public void versionTestConcurrentEventsOnEmptyRegion()
```
    This tests the concurrency versioning system to ensure that event conflation happens correctly and that the statistic is being updated properly
  - doOpsLoopNoFlush
```
public static void doOpsLoopNoFlush(int runTimeMs,
                                    boolean includeClear,
                                    boolean includePutAll)
```
  - versionTestConcurrentEventsOnNonReplicatedRegion
```
public void versionTestConcurrentEventsOnNonReplicatedRegion()
```
    This tests the concurrency versioning system to ensure that event conflation happens correctly and that the statistic is being updated properly
  - versionTestGetAllWithVersions
```
public void versionTestGetAllWithVersions()
```
  - versionTestRegionVersionVectors
```
public void versionTestRegionVersionVectors()
                                     throws Exception
```
    Throws:
    
    Exception
  - waitForAsyncProcessing
```
protected boolean waitForAsyncProcessing(AsyncInvocation async,
                                         String expectedError)
```
  - assertNoClearTimeouts
```
public static void assertNoClearTimeouts()
```
  - clearCCRegion
```
public static void clearCCRegion()
```
  - getCCRegionContents
```
public static Map getCCRegionContents()
```
  - getCCRegionVersionVector
```
public static byte[] getCCRegionVersionVector()
                                       throws Exception
```
    Since version vectors aren't java.io.Serializable we use DataSerializer to return a serialized form of the vector
    
    Throws:
    
    Exception
  - getCCRegionVersions
```
public static Map<String,com.gemstone.gemfire.internal.cache.versions.VersionTag> getCCRegionVersions()
```
    returns a map of keys->versiontags for the test region
  - getMemberId
```
public static com.gemstone.gemfire.distributed.internal.membership.InternalDistributedMember getMemberId()
```

Class MultiVMRegionTestCase

Nested Class Summary

Nested classes/interfaces inherited from class com.gemstone.gemfire.cache30.RegionTestCase

Nested classes/interfaces inherited from class dunit.DistributedTestCase

Field Summary

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

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.RegionTestCase

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

CCRegion

Constructor Detail

MultiVMRegionTestCase

Method Detail

tearDown2

testConcurrentOperations

concurrentMapTest

testDistributedUpdate

_ttestOrderedUpdates

testDistributedGet

testDistributedPutNoUpdate

testDefinedEntryUpdated

testDistributedDestroy

testDistributedRegionDestroy

testLocalDestroy

testLocalRegionDestroy

testDistributedInvalidate

testDistributedInvalidate4

testDistributedRegionInvalidate

testRemoteCacheListener

testRemoteCacheListenerInSubregion

supportsNetLoad

testRemoteCacheLoader

testRemoteCacheLoaderArg

testRemoteCacheLoaderException

testCacheLoaderWithNetSearch

testCacheLoaderWithNetLoad

testNoRemoteCacheLoader

testNoLoaderWithInvalidEntry

testRemoteCacheWriter

testLocalAndRemoteCacheWriters

testCacheLoaderModifyingArgument

testRemoteLoaderNetSearch

testLocalCacheLoader

testDistributedPut

supportsReplication

testReplicate

testDeltaWithReplicate

testGetInitialImage

testLargeGetInitialImage

testMirroredDataFromNonMirrored

testNoMirroredDataToNonMirrored

testMirroredLocalLoad

testMirroredNetLoad

testNoRegionKeepAlive

testNetSearchObservesTtl

testNetSearchObservesIdleTime

testEntryTtlDestroyEvent

testEntryTtlLocalDestroy

testUpdateResetsIdleTime

testNonblockingGetInitialImage

DISABLED_TILL_NEW_TX_IMPL_COMPLETE_testTXNonblockingGetInitialImage

testNBRegionInvalidationDuringGetInitialImage

testNBRegionDestructionDuringGetInitialImage

testNoDataSerializer

testNoInstantiator

assertCacheCallbackEvents

testTXSimpleOps

supportsTransactions

testTXUpdateLoadNoConflict

testTXMultiRegion

testTXRmtMirror

todo_testTXAlgebra

getRegionAttributes