WANTestBase (GemFire XD Java API Documentation)

java.lang.Object
- junit.framework.Assert
- - junit.framework.TestCase
  - - dunit.DistributedTestCase
    - - com.gemstone.gemfire.internal.cache.wan.WANTestBase

All Implemented Interfaces:

Serializable, junit.framework.Test

Direct Known Subclasses:

AsyncEventListenerDUnitTest, AsyncEventQueueStatsDUnitTest, CommonParallelAsyncEventQueueDUnitTest, CommonParallelGatewaySenderDUnitTest, ConcurrentAsyncEventQueueDUnitTest, ConcurrentParallelGatewaySenderDUnitTest, ConcurrentParallelGatewaySenderOperation_1_DUnitTest, ConcurrentParallelGatewaySenderOperation_2_DUnitTest, ConcurrentSerialGatewaySenderOperationsDUnitTest, ConcurrentWANPropogation_1_DUnitTest, ConcurrentWANPropogation_2_DUnitTest, NewWanAuthenticationDUnitTest, NewWANConcurrencyCheckForDestroyDUnitTest, ParallelGatewaySenderOperationsDUnitTest, ParallelGatewaySenderQueueOverflowDUnitTest, ParallelWANConflationDUnitTest, ParallelWANPersistenceEnabledGatewaySenderDUnitTest, ParallelWANPropagationLoopBackDUnitTest, ParallelWANPropogationClientServerDUnitTest, ParallelWANPropogationConcurrentOpsDUnitTest, ParallelWANPropogationDUnitTest, ParallelWANStatsDUnitTest, PDXNewWanDUnitTest, ReplicatedRegion_ParallelWANPersistenceDUnitTest, ReplicatedRegion_ParallelWANPropogationDUnitTest, SenderWithTransportFilterDUnitTest, SerialGatewaySenderEventListenerDUnitTest, SerialGatewaySenderOperationsDUnitTest, SerialGatewaySenderQueueDUnitTest, SerialWANPersistenceEnabledGatewaySenderDUnitTest, SerialWANPropagationLoopBackDUnitTest, SerialWANPropogation_PartitionedRegionDUnitTest, SerialWANPropogationDUnitTest, SerialWANPropogationsFeatureDUnitTest, SerialWANStatsDUnitTest, ShutdownAllPersistentGatewaySenderDUnitTest, WanAutoDiscoveryDUnitTest, WANLocatorServerDUnitTest, WanValidationsDUnitTest
```
public class WANTestBase
extends DistributedTestCase
```
See Also:

Serialized Form

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`WANTestBase.MyGatewayEventFilter`
`static class`	`WANTestBase.MyLocatorCallback`
`static class`	`WANTestBase.PDXGatewayEventFilter`
`protected static class`	`WANTestBase.PutTask`

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

Field Summary

Fields
Modifier and Type	Field and Description
`protected static com.gemstone.gemfire.cache.Cache`	`cache`
`protected static com.gemstone.gemfire.internal.cache.PartitionedRegion`	`customerRegion`
`protected static String`	`customerRegionName`
`protected static boolean`	`destroyFlag`
`protected static com.gemstone.gemfire.cache.wan.GatewayEventFilter`	`eventFilter`
`protected static com.gemstone.gemfire.cache.asyncqueue.AsyncEventListener`	`eventListener1`
`protected static com.gemstone.gemfire.cache.asyncqueue.AsyncEventListener`	`eventListener2`
`protected static List<QueueListener>`	`gatewayListeners`
`protected static QueueListener`	`listener1`
`protected static QueueListener`	`listener2`
`protected static com.gemstone.gemfire.internal.cache.PartitionedRegion`	`orderRegion`
`protected static String`	`orderRegionName`
`protected static com.gemstone.gemfire.cache.Region`	`region`
`protected static com.gemstone.gemfire.internal.cache.PartitionedRegion`	`shipmentRegion`
`protected static String`	`shipmentRegionName`
`protected static VM`	`vm0`
`protected static VM`	`vm1`
`protected static VM`	`vm2`
`protected static VM`	`vm3`
`protected static VM`	`vm4`
`protected static VM`	`vm5`
`protected static VM`	`vm6`
`protected static VM`	`vm7`

Fields inherited from class dunit.DistributedTestCase
logPerTest, reconnect, system, testName

Constructor Summary

Constructors
Constructor and Description

WANTestBase(String name)

Constructors
Constructor and Description
`WANTestBase(String name)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`static void`	`addCacheListenerAndCloseCache(String regionName)`
`static void`	`addCacheListenerAndDestroyRegion(String regionName)`
`static void`	`addListenerAndKillPrimary()`
`static void`	`addListenerOnBucketRegion(String regionName, int numBuckets)`
`static void`	`addListenerOnGateway(String gatewayHubId)`
`static void`	`addListenerOnQueueBucketRegion(String senderId, int numBuckets)`
`static void`	`addListenerOnRegion(String regionName)`
`static void`	`addQueueListener(String senderId, boolean isParallel)`
`static void`	`addSecondQueueListener(String senderId, boolean isParallel)`
`static void`	`bringBackLocatorOnOldPort(int dsId, int remoteLocPort, int oldPort)`
`static void`	`checkAllSiteMetaData(Map<Integer,List<Integer>> dsVsPorts)`
`static Long`	`checkAllSiteMetaDataFor3Sites(Map<Integer,Set<String>> dsVsPort)`
`static void`	`checkAsyncEventQueueBatchStats(String asyncQueueId, int batches)`
`static void`	`checkAsyncEventQueueConflatedStats(String asyncEventQueueId, int eventsConflated)`
`static void`	`checkAsyncEventQueueSize(String asyncQueueId, int numQueueEntries)`
`static void`	`checkAsyncEventQueueStats_Failover(String asyncEventQueueId, int eventsReceived)`
`static void`	`checkAsyncEventQueueStats(String queueId, int queueSize, int eventsReceived, int eventsQueued, int eventsDistributed)`
`static void`	`checkAsyncEventQueueUnprocessedStats(String asyncQueueId, int events)`
`static void`	`checkBatchStats(String senderId, boolean batchesDistributed, boolean bathcesRedistributed)`
`static void`	`checkBatchStats(String senderId, int batches)`
`static HashMap`	`checkBR(String regionName, int numBuckets)`
`static void`	`checkConflatedStats(String senderId, int eventsConflated)`
`static void`	`CheckContent(String regionName, int regionSize)`
`static void`	`checkEventFilteredStats(String senderId, int eventsFiltered)`
`static void`	`checkExcepitonStats(int exceptionsOccured)`
`static void`	`checkGatewayReceiverStats(int processBatches, int eventsReceived, int creates)`
`static void`	`checkGatewayReceiverStatsHA(int processBatches, int eventsReceived, int creates)`
`static HashMap`	`checkGateways(String gatewayHubId)`
`static void`	`checkLocatorsinSender(String senderId, InetSocketAddress locatorToWaitFor)`
`static void`	`checkMinimumGatewayReceiverStats(int processBatches, int eventsReceived)`
`static HashMap`	`checkPR(String regionName)`
`static void`	`checkPRQLocalSize(String senderId, int numQueueEntries)` To be used only for ParallelGatewaySender.
`static HashMap`	`checkQueue_BR(String senderId, int numBuckets)`
`static HashMap`	`checkQueue_PR(String senderId)`
`static HashMap`	`checkQueue()`
`static HashMap`	`checkQueue2()`
`static void`	`checkQueueOnSecondary(Map primaryUpdatesMap)`
`static void`	`checkQueueSize(String senderId, int numQueueEntries)`
`static void`	`checkQueueStats(String senderId, int queueSize, int eventsReceived, int eventsQueued, int eventsDistributed)`
`static void`	`checkStats_Failover(String senderId, int eventsReceived)`
`static void`	`checkUnProcessedStats(String senderId, int events)`
`static void`	`closeCache()`
`static void`	`createAsyncEventQueue(String asyncChannelId, boolean isParallel, Integer maxMemory, Integer batchSize, boolean isConflation, boolean isPersistent, String diskStoreName, boolean isDiskSynchronous)`
`static void`	`createAsyncEventQueueWithCustomListener(String asyncChannelId, boolean isParallel, Integer maxMemory, Integer batchSize, boolean isConflation, boolean isPersistent, String diskStoreName, boolean isDiskSynchronous)`
`static String`	`createAsyncEventQueueWithDiskStore(String asyncChannelId, boolean isParallel, Integer maxMemory, Integer batchSize, boolean isPersistent, String diskStoreName)`
`static void`	`createAsyncEventQueueWithListener2(String asyncChannelId, boolean isParallel, Integer maxMemory, Integer batchSize, boolean isPersistent, String diskStoreName)`
`static void`	`createCache_PDX(Integer locPort)`
`protected static void`	`createCache(boolean management, Integer locPort)`
`static void`	`createCache(Integer locPort)`
`static void`	`createCache(Integer locPort1, Integer locPort2)`
`static Integer`	`createCacheServer()` Method that creates a bridge server
`static void`	`createCacheWithoutLocator(Integer mCastPort)`
`static void`	`createClientWithLocator(int port0, String host, String regionName)`
`static void`	`createColocatedPartitionedRegion(String regionName, String senderIds, Integer redundantCopies, Integer totalNumBuckets, String colocatedWith, Boolean offHeap)`
`static void`	`createColocatedPartitionedRegions(String regionName, String senderIds, Integer redundantCopies, Integer totalNumBuckets, Boolean offHeap)`
`static void`	`createColocatedPartitionedRegions2(String regionName, String senderIds, Integer redundantCopies, Integer totalNumBuckets, Boolean offHeap)`
`static void`	`createColocatedPartitionedRegionWithAsyncEventQueue(String regionName, String asyncEventQueueId, Integer totalNumBuckets, String colocatedWith, Boolean offHeap)`
`static void`	`createConcurrentAsyncEventQueue(String asyncChannelId, boolean isParallel, Integer maxMemory, Integer batchSize, boolean isConflation, boolean isPersistent, String diskStoreName, boolean isDiskSynchronous, int dispatcherThreads, com.gemstone.gemfire.cache.util.Gateway.OrderPolicy policy)`
`static void`	`createConcurrentSender(String dsName, int remoteDsId, boolean isParallel, Integer maxMemory, Integer batchSize, boolean isConflation, boolean isPersistent, com.gemstone.gemfire.cache.wan.GatewayEventFilter filter, boolean isManulaStart, int concurrencyLevel, com.gemstone.gemfire.cache.util.Gateway.OrderPolicy policy)`
`static void`	`createCustomerOrderShipmentPartitionedRegion(String regionName, String senderIds, Integer redundantCopies, Integer totalNumBuckets, Boolean offHeap)`
`static int`	`createEndPoint(String dsName)`
`static Integer`	`createFirstLocatorWithDSId(int dsId)`
`static Integer`	`createFirstPeerLocator(int dsId)`
`static Integer`	`createFirstRemoteLocator(int dsId, int remoteLocPort)`
`static Integer`	`createFirstRemotePeerLocator(int dsId, int remoteLocPort)`
`static void`	`createGatewayHub(String id, Map<String,Integer> gateways)` Just creates the GatewayHub on the node.
`static void`	`createGatewayHub(String localDsName, String remoteDsName, Integer port)`
`static void`	`createLocator(int dsId, int port, Set<String> localLocatorsList, Set<String> remoteLocatorsList)`
`static void`	`createManagementCache(Integer locPort)`
`static void`	`createNormalRegion(String regionName, String senderIds)`
`static void`	`createPartitionedRegion_WithGatewayEnabled(String regionName, Integer redundantCopies, Integer totalNumBuckets, Boolean offHeap)`
`static void`	`createPartitionedRegion(String regionName, String senderIds, Integer redundantCopies, Integer totalNumBuckets, Boolean offHeap)`
`static void`	`createPartitionedRegionAccessorWithAsyncEventQueue(String regionName, String asyncEventQueueId)`
`static void`	`createPartitionedRegionAsAccessor(String regionName, String senderIds, Integer redundantCopies, Integer totalNumBuckets)`
`static void`	`createPartitionedRegionWithAsyncEventQueue(String regionName, String asyncEventQueueId, Boolean offHeap)`
`static void`	`createPartitionedRegionWithSerialParallelSenderIds(String regionName, String serialSenderIds, String parallelSenderIds, String colocatedWith, Boolean offHeap)`
`static void`	`createPersistentPartitionedRegion(String regionName, String senderIds, Integer redundantCopies, Integer totalNumBuckets, Boolean offHeap)`
`static void`	`createPersistentPartitionedRegionWithAsyncEventQueue(String regionName, String asyncEventQueueId, Boolean offHeap)`
`static void`	`createPersistentReplicatedRegion(String regionName, String senderIds, Boolean offHeap)`
`static void`	`createPersistentReplicatedRegionWithAsyncEventQueue(String regionName, String asyncQueueIds, Boolean offHeap)`
`static void`	`createPRWithRedundantCopyWithAsyncEventQueue(String regionName, String asyncEventQueueId, Boolean offHeap)` Create PartitionedRegion with 1 redundant copy
`static int`	`createReceiver_PDX(int locPort)`
`static int`	`createReceiver(int locPort)`
`static void`	`createReceiver2(int locPort)`
`static int`	`createReceiverAfterCache(int locPort)`
`static void`	`createReceiverAndServer(int locPort)`
`static int`	`createReceiverInSecuredCache(int locPort)`
`static void`	`createReplicatedRegion_WithGatewayEnabled(String regionName, String senderIds, Boolean offHeap)`
`static void`	`createReplicatedRegion(String regionName, String senderIds, Boolean offHeap)`
`static void`	`createReplicatedRegion(String regionName, String senderIds, com.gemstone.gemfire.cache.Scope scope, com.gemstone.gemfire.cache.DataPolicy policy, Boolean offHeap)`
`static void`	`createReplicatedRegionWithAsyncEventQueue(String regionName, String asyncQueueIds, Boolean offHeap)`
`static void`	`createReplicatedRegionWithSenderAndAsyncEventQueue(String regionName, String senderIds, String asyncChannelId, Boolean offHeap)`
`static Integer`	`createSecondLocator(int dsId, int locatorPort)`
`static Integer`	`createSecondPeerLocator(int dsId, int locatorPort)`
`static Integer`	`createSecondRemoteLocator(int dsId, int localPort, int remoteLocPort)`
`static Integer`	`createSecondRemotePeerLocator(int dsId, int localPort, int remoteLocPort)`
`static void`	`createSecuredCache(Properties authProps, Object javaProps, Integer locPort)`
`static void`	`createSender(String dsName, int remoteDsId, boolean isParallel, Integer maxMemory, Integer batchSize, boolean isConflation, boolean isPersistent, com.gemstone.gemfire.cache.wan.GatewayEventFilter filter, boolean isManulaStart)`
`static void`	`createSenderForValidations(String dsName, int remoteDsId, boolean isParallel, Integer alertThreshold, boolean isConflation, boolean isPersistent, List<com.gemstone.gemfire.cache.wan.GatewayEventFilter> eventfilters, List<com.gemstone.gemfire.cache.wan.GatewayTransportFilter> tranportFilters, boolean isManulaStart, boolean isDiskSync)`
`static String`	`createSenderWithDiskStore(String dsName, int remoteDsId, boolean isParallel, Integer maxMemory, Integer batchSize, boolean isConflation, boolean isPersistent, com.gemstone.gemfire.cache.wan.GatewayEventFilter filter, String dsStore, boolean isManualStart)`
`static void`	`createSenderWithListener(String dsName, int remoteDsName, boolean isParallel, Integer maxMemory, Integer batchSize, boolean isConflation, boolean isPersistent, com.gemstone.gemfire.cache.wan.GatewayEventFilter filter, boolean attachTwoListeners, boolean isManulaStart)`
`static void`	`createSenderWithoutDiskStore(String dsName, int remoteDsId, boolean isParallel, Integer maxMemory, Integer batchSize, boolean isConflation, boolean isPersistent, com.gemstone.gemfire.cache.wan.GatewayEventFilter filter, boolean isManulaStart)`
`static int`	`createServer(int locPort)`
`static void`	`destroyRegion(String regionName)`
`static void`	`destroyRegionAfterMinRegionSize(String regionName, int min)`
`static void`	`destroySender(String senderId)`
`static void`	`doDestroys(String regionName, int keyNum)`
`static void`	`doHeavyPuts(String regionName, int numPuts)`
`static void`	`doMultiThreadedPuts(String regionName, int numPuts)`
`static void`	`doNextPuts(String regionName, int start, int numPuts)`
`static void`	`doPutAll(String regionName, int numPuts, int size)`
`static void`	`doPuts(String regionName, int numPuts)`
`static void`	`doPutsAfter300(String regionName, int numPuts)`
`static void`	`doPutsFrom(String regionName, int from, int numPuts)`
`static void`	`doPutsPDXSerializable(String regionName, int numPuts)`
`static void`	`doPutsWithKeyAsString(String regionName, int numPuts)`
`static void`	`doRandomUpdates(String regionName, int numUpdates)`
`static void`	`doRebalance()` Do a rebalance and verify balance was improved.
`static void`	`doTxPuts(String regionName, int numPuts)`
`static void`	`doUpdateOnSameKey(String regionName, int key, int numUpdates)`
`static void`	`doUpdates(String regionName, int numUpdates)`
`static Set<Integer>`	`getAllPrimaryBucketsOnTheNode(String regionName)`
`static int`	`getAsyncEventListenerMapSize(String asyncEventQueueId)`
`static int`	`getAsyncEventQueueSize(String asyncEventQueueId)`
`static Map`	`getCacheServers()` Returns a Map that contains the count for number of bridge server and number of Receivers.
`static Long`	`getNumberOfEntriesInVM(String senderId)`
`static Long`	`getNumberOfEntriesOverflownToDisk(String senderId)`
`static Boolean`	`getPrimaryStatus()`
`static Integer`	`getQueueContentSize(String senderId)`
`static String`	`getRegionFullPath(String regionName)`
`static Integer`	`getRegionSize(String regionName)`
`static List<Integer>`	`getSenderStats(String senderId, int expectedQueueSize)`
`static Map`	`getSenderToReceiverConnectionInfo(String senderId)`
`com.gemstone.gemfire.distributed.internal.InternalDistributedSystem`	`getSystem(Properties props)` Returns this VM's connection to the distributed system.
`boolean`	`isOffHeap()` Returns true if the test should create off-heap regions.
`static Boolean`	`killAsyncEventQueue(String asyncQueueId)`
`static void`	`killSender()`
`static Boolean`	`killSender(String senderId)`
`static void`	`localDestroyRegion(String regionName)`
`static void`	`pauseAsyncEventQueue(String asyncChannelId)`
`static void`	`pauseAsyncEventQueueAndWaitForDispatcherToPause(String asyncChannelId)`
`static void`	`pauseGateway(String localDsName)`
`static void`	`pauseSender(String senderId)`
`static void`	`pauseSenderAndWaitForDispatcherToPause(String senderId)`
`static void`	`pauseWaitCriteria(long millisec)`
`static void`	`printEventListenerMap()`
`static void`	`putcolocatedPartitionedRegion(int numPuts)`
`static Map`	`putCustomerPartitionedRegion(int numPuts)`
`static void`	`putGivenKeyValue(String regionName, Map keyValues)`
`static Map`	`putOrderPartitionedRegion(int numPuts)`
`static Map`	`putOrderPartitionedRegionUsingCustId(int numPuts)`
`static Map`	`putShipmentPartitionedRegion(int numPuts)`
`static Map`	`putShipmentPartitionedRegionUsingCustId(int numPuts)`
`static void`	`removeSenderFromTheRegion(String senderId, String regionName)`
`static void`	`resumeAsyncEventQueue(String asyncQueueId)`
`static void`	`resumeSender(String senderId)`
`static void`	`setRemoveFromQueueOnException(String senderId, boolean removeFromQueue)`
`void`	`setUp()` Sets up the test (noop).
`static void`	`shutdownLocator()`
`static void`	`startAsyncEventQueue(String senderId)`
`static void`	`startGatewayHub(String gatewayHubId)`
`static void`	`startSender(String senderId)`
`static void`	`stopSender(String senderId)`
`void`	`tearDown2()` Tears down the test.
`static void`	`unsetRemoveFromQueueOnException(String senderId)`
`static Map`	`updateCustomerPartitionedRegion(int numPuts)`
`static Map`	`updateOrderPartitionedRegion(int numPuts)`
`static Map`	`updateOrderPartitionedRegionUsingCustId(int numPuts)`
`static Map`	`updateShipmentPartitionedRegion(int numPuts)`
`static Map`	`updateShipmentPartitionedRegionUsingCustId(int numPuts)`
`static void`	`validateAsyncEventListener(String asyncQueueId, int expectedSize)`
`static void`	`validateAsyncEventQueueAttributes(String asyncChannelId, int maxQueueMemory, int batchSize, int batchTimeInterval, boolean isPersistent, String diskStoreName, boolean isDiskSynchronous, boolean batchConflationEnabled)` Validate whether all the attributes set on AsyncEventQueueFactory are set on the sender underneath the AsyncEventQueue.
`static void`	`validateConcurrentAsyncEventQueueAttributes(String asyncChannelId, int maxQueueMemory, int batchSize, int batchTimeInterval, boolean isPersistent, String diskStoreName, boolean isDiskSynchronous, boolean batchConflationEnabled, int dispatcherThreads, com.gemstone.gemfire.cache.util.Gateway.OrderPolicy policy)` Validate whether all the attributes set on AsyncEventQueueFactory are set on the sender underneath the AsyncEventQueue.
`static void`	`validateCustomAsyncEventListener(String asyncQueueId, int expectedSize)`
`static void`	`validateParallelSenderQueueAllBucketsDrained(String senderId)`
`static void`	`validateParallelSenderQueueBucketSize(String senderId, int bucketSize)`
`static void`	`validateQueueClosedForConcurrentSerialGatewaySender(String senderId)`
`static void`	`validateQueueContents(String senderId, int regionSize)`
`static void`	`validateQueueContentsForConcurrentSerialGatewaySender(String senderId, int regionSize)`
`static void`	`validateRegionContents(String regionName, Map keyValues)`
`static void`	`validateRegionContentsForPR(String regionName, int regionSize)`
`static void`	`validateRegionSize_PDX(String regionName, int regionSize)`
`static void`	`validateRegionSize(String regionName, int regionSize)`
`static void`	`validateRegionSizeRemainsSame(String regionName, int regionSizeLimit)` This method is specifically written for pause and stop operations.
`static int`	`verifyAndGetEventsDispatchedByConcurrentDispatchers(String senderId)`
`static void`	`verifyAsyncEventListenerForPossibleDuplicates(String asyncEventQueueId, Set<Integer> bucketIds, int batchSize)`
`static void`	`verifyPrimaryStatus(Boolean isPrimary)`
`static void`	`verifyQueueSize(String senderId, int size)`
`static void`	`verifyRegionQueueNotEmpty(String senderId)`
`static void`	`verifyRegionQueueNotEmptyForConcurrentSender(String senderId)`
`static void`	`verifySenderDestroyed(String senderId, boolean isParallel)`
`static void`	`verifySenderPausedState(String senderId)` Test methods for sender operations
`static void`	`verifySenderResumedState(String senderId)`
`static void`	`verifySenderRunningState(String senderId)`
`static void`	`verifySenderStoppedState(String senderId)`
`static void`	`waitForAsyncEventQueueSize(String asyncQueueId, int numQueueEntries)` This method verifies the queue size of a ParallelGatewaySender.
`static void`	`waitForAsyncQueueToGetEmpty(String asyncQueueId)`
`static void`	`waitForSenderRunningState(String senderId)`
`static void`	`waitForSenderToBecomePrimary(String senderId)`

Methods inherited from class dunit.DistributedTestCase
addExpectedException, addExpectedException, addHydraProperties, attachDebugger, checkBBFlag, cleanupAllVms, clearBBFlag, crashDistributedSystem, crashDistributedSystem, createLogWriter, disconnectAllFromDS, disconnectFromDS, dumpAllStacks, dumpMyThreads, dumpStack, dumpStack, dumpStack, dumpStackTrace, fail, getAllDistributedSystemProperties, getDistributedSystemProperties, getDUnitLocatorAddress, getDUnitLocatorPort, getDUnitLocatorString, getDUnitLogLevel, getIPLiteral, getLogWriter, getLonerSystem, getMcastSystem, getMcastSystem, getRepeatTimeoutMs, getServerHostName, 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

cache

protected static com.gemstone.gemfire.cache.Cache cache

region

protected static com.gemstone.gemfire.cache.Region region

customerRegion

protected static com.gemstone.gemfire.internal.cache.PartitionedRegion customerRegion

orderRegion

protected static com.gemstone.gemfire.internal.cache.PartitionedRegion orderRegion

shipmentRegion

protected static com.gemstone.gemfire.internal.cache.PartitionedRegion shipmentRegion

customerRegionName

protected static final String customerRegionName

See Also:: Constant Field Values

orderRegionName

protected static final String orderRegionName

See Also:: Constant Field Values

shipmentRegionName

protected static final String shipmentRegionName

See Also:: Constant Field Values

vm0
```
protected static VM vm0
```

vm1
```
protected static VM vm1
```

vm2
```
protected static VM vm2
```

vm3
```
protected static VM vm3
```

vm4
```
protected static VM vm4
```

vm5
```
protected static VM vm5
```

vm6
```
protected static VM vm6
```

vm7
```
protected static VM vm7
```

listener1

protected static QueueListener listener1

listener2

protected static QueueListener listener2

gatewayListeners

protected static List<QueueListener> gatewayListeners

eventListener1

protected static com.gemstone.gemfire.cache.asyncqueue.AsyncEventListener eventListener1

eventListener2

protected static com.gemstone.gemfire.cache.asyncqueue.AsyncEventListener eventListener2

eventFilter

protected static com.gemstone.gemfire.cache.wan.GatewayEventFilter eventFilter

destroyFlag
```
protected static boolean destroyFlag
```

Constructor Detail
- WANTestBase
```
public WANTestBase(String 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

createLocator

public static void createLocator(int dsId,
                                 int port,
                                 Set<String> localLocatorsList,
                                 Set<String> remoteLocatorsList)

createFirstLocatorWithDSId

public static Integer createFirstLocatorWithDSId(int dsId)

createFirstPeerLocator

public static Integer createFirstPeerLocator(int dsId)

createSecondLocator

public static Integer createSecondLocator(int dsId,
                                          int locatorPort)

createSecondPeerLocator

public static Integer createSecondPeerLocator(int dsId,
                                              int locatorPort)

createFirstRemoteLocator

public static Integer createFirstRemoteLocator(int dsId,
                                               int remoteLocPort)

bringBackLocatorOnOldPort

public static void bringBackLocatorOnOldPort(int dsId,
                                             int remoteLocPort,
                                             int oldPort)

createFirstRemotePeerLocator

public static Integer createFirstRemotePeerLocator(int dsId,
                                                   int remoteLocPort)

createSecondRemoteLocator

public static Integer createSecondRemoteLocator(int dsId,
                                                int localPort,
                                                int remoteLocPort)

createSecondRemotePeerLocator

public static Integer createSecondRemotePeerLocator(int dsId,
                                                    int localPort,
                                                    int remoteLocPort)

createReplicatedRegion

public static void createReplicatedRegion(String regionName,
                                          String senderIds,
                                          Boolean offHeap)

createNormalRegion

public static void createNormalRegion(String regionName,
                                      String senderIds)

createPersistentReplicatedRegion

public static void createPersistentReplicatedRegion(String regionName,
                                                    String senderIds,
                                                    Boolean offHeap)

createReplicatedRegion_WithGatewayEnabled

public static void createReplicatedRegion_WithGatewayEnabled(String regionName,
                                                             String senderIds,
                                                             Boolean offHeap)

createReplicatedRegionWithAsyncEventQueue

public static void createReplicatedRegionWithAsyncEventQueue(String regionName,
                                                             String asyncQueueIds,
                                                             Boolean offHeap)

createPersistentReplicatedRegionWithAsyncEventQueue

public static void createPersistentReplicatedRegionWithAsyncEventQueue(String regionName,
                                                                       String asyncQueueIds,
                                                                       Boolean offHeap)

createReplicatedRegionWithSenderAndAsyncEventQueue

public static void createReplicatedRegionWithSenderAndAsyncEventQueue(String regionName,
                                                                      String senderIds,
                                                                      String asyncChannelId,
                                                                      Boolean offHeap)

createReplicatedRegion

public static void createReplicatedRegion(String regionName,
                                          String senderIds,
                                          com.gemstone.gemfire.cache.Scope scope,
                                          com.gemstone.gemfire.cache.DataPolicy policy,
                                          Boolean offHeap)

createAsyncEventQueue

public static void createAsyncEventQueue(String asyncChannelId,
                                         boolean isParallel,
                                         Integer maxMemory,
                                         Integer batchSize,
                                         boolean isConflation,
                                         boolean isPersistent,
                                         String diskStoreName,
                                         boolean isDiskSynchronous)

createAsyncEventQueueWithListener2

public static void createAsyncEventQueueWithListener2(String asyncChannelId,
                                                      boolean isParallel,
                                                      Integer maxMemory,
                                                      Integer batchSize,
                                                      boolean isPersistent,
                                                      String diskStoreName)

createAsyncEventQueueWithCustomListener

public static void createAsyncEventQueueWithCustomListener(String asyncChannelId,
                                                           boolean isParallel,
                                                           Integer maxMemory,
                                                           Integer batchSize,
                                                           boolean isConflation,
                                                           boolean isPersistent,
                                                           String diskStoreName,
                                                           boolean isDiskSynchronous)

createConcurrentAsyncEventQueue

public static void createConcurrentAsyncEventQueue(String asyncChannelId,
                                                   boolean isParallel,
                                                   Integer maxMemory,
                                                   Integer batchSize,
                                                   boolean isConflation,
                                                   boolean isPersistent,
                                                   String diskStoreName,
                                                   boolean isDiskSynchronous,
                                                   int dispatcherThreads,
                                                   com.gemstone.gemfire.cache.util.Gateway.OrderPolicy policy)

createAsyncEventQueueWithDiskStore

public static String createAsyncEventQueueWithDiskStore(String asyncChannelId,
                                                        boolean isParallel,
                                                        Integer maxMemory,
                                                        Integer batchSize,
                                                        boolean isPersistent,
                                                        String diskStoreName)

pauseAsyncEventQueue

public static void pauseAsyncEventQueue(String asyncChannelId)

pauseAsyncEventQueueAndWaitForDispatcherToPause

public static void pauseAsyncEventQueueAndWaitForDispatcherToPause(String asyncChannelId)

resumeAsyncEventQueue

public static void resumeAsyncEventQueue(String asyncQueueId)

checkAsyncEventQueueSize

public static void checkAsyncEventQueueSize(String asyncQueueId,
                                            int numQueueEntries)

waitForAsyncEventQueueSize
```
public static void waitForAsyncEventQueueSize(String asyncQueueId,
                                              int numQueueEntries)
                                       throws Exception
```
This method verifies the queue size of a ParallelGatewaySender. For ParallelGatewaySender conflation happens in a separate thread, hence test code needs to wait for some time for expected result

Parameters:

asyncQueueId - Async Queue ID

numQueueEntries - expected number of Queue entries

Throws:

Exception

createPartitionedRegion

public static void createPartitionedRegion(String regionName,
                                           String senderIds,
                                           Integer redundantCopies,
                                           Integer totalNumBuckets,
                                           Boolean offHeap)

createColocatedPartitionedRegion

public static void createColocatedPartitionedRegion(String regionName,
                                                    String senderIds,
                                                    Integer redundantCopies,
                                                    Integer totalNumBuckets,
                                                    String colocatedWith,
                                                    Boolean offHeap)

createPartitionedRegionWithAsyncEventQueue

public static void createPartitionedRegionWithAsyncEventQueue(String regionName,
                                                              String asyncEventQueueId,
                                                              Boolean offHeap)

createColocatedPartitionedRegionWithAsyncEventQueue

public static void createColocatedPartitionedRegionWithAsyncEventQueue(String regionName,
                                                                       String asyncEventQueueId,
                                                                       Integer totalNumBuckets,
                                                                       String colocatedWith,
                                                                       Boolean offHeap)

createPersistentPartitionedRegionWithAsyncEventQueue

public static void createPersistentPartitionedRegionWithAsyncEventQueue(String regionName,
                                                                        String asyncEventQueueId,
                                                                        Boolean offHeap)

createPRWithRedundantCopyWithAsyncEventQueue

public static void createPRWithRedundantCopyWithAsyncEventQueue(String regionName,
                                                                String asyncEventQueueId,
                                                                Boolean offHeap)

Create PartitionedRegion with 1 redundant copy

createPartitionedRegionAccessorWithAsyncEventQueue

public static void createPartitionedRegionAccessorWithAsyncEventQueue(String regionName,
                                                                      String asyncEventQueueId)

createPartitionedRegion_WithGatewayEnabled

public static void createPartitionedRegion_WithGatewayEnabled(String regionName,
                                                              Integer redundantCopies,
                                                              Integer totalNumBuckets,
                                                              Boolean offHeap)

createPartitionedRegionAsAccessor

public static void createPartitionedRegionAsAccessor(String regionName,
                                                     String senderIds,
                                                     Integer redundantCopies,
                                                     Integer totalNumBuckets)

createPartitionedRegionWithSerialParallelSenderIds

public static void createPartitionedRegionWithSerialParallelSenderIds(String regionName,
                                                                      String serialSenderIds,
                                                                      String parallelSenderIds,
                                                                      String colocatedWith,
                                                                      Boolean offHeap)

createPersistentPartitionedRegion

public static void createPersistentPartitionedRegion(String regionName,
                                                     String senderIds,
                                                     Integer redundantCopies,
                                                     Integer totalNumBuckets,
                                                     Boolean offHeap)

createCustomerOrderShipmentPartitionedRegion

public static void createCustomerOrderShipmentPartitionedRegion(String regionName,
                                                                String senderIds,
                                                                Integer redundantCopies,
                                                                Integer totalNumBuckets,
                                                                Boolean offHeap)

createColocatedPartitionedRegions

public static void createColocatedPartitionedRegions(String regionName,
                                                     String senderIds,
                                                     Integer redundantCopies,
                                                     Integer totalNumBuckets,
                                                     Boolean offHeap)

createColocatedPartitionedRegions2

public static void createColocatedPartitionedRegions2(String regionName,
                                                      String senderIds,
                                                      Integer redundantCopies,
                                                      Integer totalNumBuckets,
                                                      Boolean offHeap)

createCache

public static void createCache(Integer locPort)

createManagementCache

public static void createManagementCache(Integer locPort)

createCache

protected static void createCache(boolean management,
                                  Integer locPort)

createSecuredCache

public static void createSecuredCache(Properties authProps,
                                      Object javaProps,
                                      Integer locPort)

createCache_PDX

public static void createCache_PDX(Integer locPort)

createCache

public static void createCache(Integer locPort1,
                               Integer locPort2)

createCacheWithoutLocator

public static void createCacheWithoutLocator(Integer mCastPort)

createCacheServer
```
public static Integer createCacheServer()
```
Method that creates a bridge server

Returns:

Integer Port on which the server is started.

getCacheServers
```
public static Map getCacheServers()
```
Returns a Map that contains the count for number of bridge server and number of Receivers.

Returns:

Map

startSender

public static void startSender(String senderId)

startAsyncEventQueue

public static void startAsyncEventQueue(String senderId)

getSenderToReceiverConnectionInfo

public static Map getSenderToReceiverConnectionInfo(String senderId)

startGatewayHub

public static void startGatewayHub(String gatewayHubId)

getSenderStats

public static List<Integer> getSenderStats(String senderId,
                                           int expectedQueueSize)

checkQueueStats

public static void checkQueueStats(String senderId,
                                   int queueSize,
                                   int eventsReceived,
                                   int eventsQueued,
                                   int eventsDistributed)

checkAsyncEventQueueStats

public static void checkAsyncEventQueueStats(String queueId,
                                             int queueSize,
                                             int eventsReceived,
                                             int eventsQueued,
                                             int eventsDistributed)

checkGatewayReceiverStats

public static void checkGatewayReceiverStats(int processBatches,
                                             int eventsReceived,
                                             int creates)

checkMinimumGatewayReceiverStats

public static void checkMinimumGatewayReceiverStats(int processBatches,
                                                    int eventsReceived)

checkExcepitonStats

public static void checkExcepitonStats(int exceptionsOccured)

checkGatewayReceiverStatsHA

public static void checkGatewayReceiverStatsHA(int processBatches,
                                               int eventsReceived,
                                               int creates)

checkEventFilteredStats

public static void checkEventFilteredStats(String senderId,
                                           int eventsFiltered)

checkConflatedStats

public static void checkConflatedStats(String senderId,
                                       int eventsConflated)

checkAsyncEventQueueConflatedStats

public static void checkAsyncEventQueueConflatedStats(String asyncEventQueueId,
                                                      int eventsConflated)

checkStats_Failover

public static void checkStats_Failover(String senderId,
                                       int eventsReceived)

checkAsyncEventQueueStats_Failover

public static void checkAsyncEventQueueStats_Failover(String asyncEventQueueId,
                                                      int eventsReceived)

checkBatchStats

public static void checkBatchStats(String senderId,
                                   int batches)

checkAsyncEventQueueBatchStats

public static void checkAsyncEventQueueBatchStats(String asyncQueueId,
                                                  int batches)

checkBatchStats

public static void checkBatchStats(String senderId,
                                   boolean batchesDistributed,
                                   boolean bathcesRedistributed)

checkUnProcessedStats

public static void checkUnProcessedStats(String senderId,
                                         int events)

checkAsyncEventQueueUnprocessedStats

public static void checkAsyncEventQueueUnprocessedStats(String asyncQueueId,
                                                        int events)

setRemoveFromQueueOnException

public static void setRemoveFromQueueOnException(String senderId,
                                                 boolean removeFromQueue)

unsetRemoveFromQueueOnException

public static void unsetRemoveFromQueueOnException(String senderId)

waitForSenderRunningState

public static void waitForSenderRunningState(String senderId)

waitForSenderToBecomePrimary

public static void waitForSenderToBecomePrimary(String senderId)

checkQueue
```
public static HashMap checkQueue()
```

checkQueueOnSecondary

public static void checkQueueOnSecondary(Map primaryUpdatesMap)

checkQueue2
```
public static HashMap checkQueue2()
```

checkPR

public static HashMap checkPR(String regionName)

checkBR

public static HashMap checkBR(String regionName,
                              int numBuckets)

checkQueue_PR

public static HashMap checkQueue_PR(String senderId)

checkQueue_BR

public static HashMap checkQueue_BR(String senderId,
                                    int numBuckets)

checkGateways

public static HashMap checkGateways(String gatewayHubId)

addListenerOnBucketRegion

public static void addListenerOnBucketRegion(String regionName,
                                             int numBuckets)

addListenerOnQueueBucketRegion

public static void addListenerOnQueueBucketRegion(String senderId,
                                                  int numBuckets)

addListenerOnGateway

public static void addListenerOnGateway(String gatewayHubId)

addQueueListener

public static void addQueueListener(String senderId,
                                    boolean isParallel)

addSecondQueueListener

public static void addSecondQueueListener(String senderId,
                                          boolean isParallel)

addListenerOnRegion

public static void addListenerOnRegion(String regionName)

pauseSender

public static void pauseSender(String senderId)

pauseSenderAndWaitForDispatcherToPause

public static void pauseSenderAndWaitForDispatcherToPause(String senderId)

resumeSender

public static void resumeSender(String senderId)

stopSender

public static void stopSender(String senderId)

createSender

public static void createSender(String dsName,
                                int remoteDsId,
                                boolean isParallel,
                                Integer maxMemory,
                                Integer batchSize,
                                boolean isConflation,
                                boolean isPersistent,
                                com.gemstone.gemfire.cache.wan.GatewayEventFilter filter,
                                boolean isManulaStart)

createSenderWithoutDiskStore

public static void createSenderWithoutDiskStore(String dsName,
                                                int remoteDsId,
                                                boolean isParallel,
                                                Integer maxMemory,
                                                Integer batchSize,
                                                boolean isConflation,
                                                boolean isPersistent,
                                                com.gemstone.gemfire.cache.wan.GatewayEventFilter filter,
                                                boolean isManulaStart)

createConcurrentSender

public static void createConcurrentSender(String dsName,
                                          int remoteDsId,
                                          boolean isParallel,
                                          Integer maxMemory,
                                          Integer batchSize,
                                          boolean isConflation,
                                          boolean isPersistent,
                                          com.gemstone.gemfire.cache.wan.GatewayEventFilter filter,
                                          boolean isManulaStart,
                                          int concurrencyLevel,
                                          com.gemstone.gemfire.cache.util.Gateway.OrderPolicy policy)

createSenderForValidations

public static void createSenderForValidations(String dsName,
                                              int remoteDsId,
                                              boolean isParallel,
                                              Integer alertThreshold,
                                              boolean isConflation,
                                              boolean isPersistent,
                                              List<com.gemstone.gemfire.cache.wan.GatewayEventFilter> eventfilters,
                                              List<com.gemstone.gemfire.cache.wan.GatewayTransportFilter> tranportFilters,
                                              boolean isManulaStart,
                                              boolean isDiskSync)

createSenderWithDiskStore

public static String createSenderWithDiskStore(String dsName,
                                               int remoteDsId,
                                               boolean isParallel,
                                               Integer maxMemory,
                                               Integer batchSize,
                                               boolean isConflation,
                                               boolean isPersistent,
                                               com.gemstone.gemfire.cache.wan.GatewayEventFilter filter,
                                               String dsStore,
                                               boolean isManualStart)

createSenderWithListener

public static void createSenderWithListener(String dsName,
                                            int remoteDsName,
                                            boolean isParallel,
                                            Integer maxMemory,
                                            Integer batchSize,
                                            boolean isConflation,
                                            boolean isPersistent,
                                            com.gemstone.gemfire.cache.wan.GatewayEventFilter filter,
                                            boolean attachTwoListeners,
                                            boolean isManulaStart)

createGatewayHub

public static void createGatewayHub(String localDsName,
                                    String remoteDsName,
                                    Integer port)

createGatewayHub
```
public static void createGatewayHub(String id,
                                    Map<String,Integer> gateways)
```
Just creates the GatewayHub on the node. Doesn't start it. Needs to be started separately.

Parameters:

id - Id of the GatewayHub

gateways - Configuration of gateways in this GatewayHub

pauseGateway

public static void pauseGateway(String localDsName)

pauseWaitCriteria

public static void pauseWaitCriteria(long millisec)

createReceiver

public static int createReceiver(int locPort)

createReceiverAfterCache

public static int createReceiverAfterCache(int locPort)

createReceiverAndServer

public static void createReceiverAndServer(int locPort)

createReceiverInSecuredCache

public static int createReceiverInSecuredCache(int locPort)

createServer

public static int createServer(int locPort)

createClientWithLocator

public static void createClientWithLocator(int port0,
                                           String host,
                                           String regionName)

createReceiver_PDX

public static int createReceiver_PDX(int locPort)

createReceiver2

public static void createReceiver2(int locPort)

createEndPoint

public static int createEndPoint(String dsName)

doRebalance
```
public static void doRebalance()
```
Do a rebalance and verify balance was improved. If evictionPercentage > 0 (the default) then we have heapLRU and this can cause simulate and rebalance results to differ if eviction kicks in between. (See BUG 44899).

doPuts

public static void doPuts(String regionName,
                          int numPuts)

doPutsAfter300

public static void doPutsAfter300(String regionName,
                                  int numPuts)

doPutsFrom

public static void doPutsFrom(String regionName,
                              int from,
                              int numPuts)

doDestroys

public static void doDestroys(String regionName,
                              int keyNum)

doPutAll

public static void doPutAll(String regionName,
                            int numPuts,
                            int size)

doPutsWithKeyAsString

public static void doPutsWithKeyAsString(String regionName,
                                         int numPuts)

putGivenKeyValue

public static void putGivenKeyValue(String regionName,
                                    Map keyValues)

destroyRegion

public static void destroyRegion(String regionName)

destroyRegionAfterMinRegionSize

public static void destroyRegionAfterMinRegionSize(String regionName,
                                                   int min)

localDestroyRegion

public static void localDestroyRegion(String regionName)

putCustomerPartitionedRegion

public static Map putCustomerPartitionedRegion(int numPuts)

updateCustomerPartitionedRegion

public static Map updateCustomerPartitionedRegion(int numPuts)

putOrderPartitionedRegion

public static Map putOrderPartitionedRegion(int numPuts)

putOrderPartitionedRegionUsingCustId

public static Map putOrderPartitionedRegionUsingCustId(int numPuts)

updateOrderPartitionedRegion

public static Map updateOrderPartitionedRegion(int numPuts)

updateOrderPartitionedRegionUsingCustId

public static Map updateOrderPartitionedRegionUsingCustId(int numPuts)

putShipmentPartitionedRegion

public static Map putShipmentPartitionedRegion(int numPuts)

putcolocatedPartitionedRegion

public static void putcolocatedPartitionedRegion(int numPuts)

putShipmentPartitionedRegionUsingCustId

public static Map putShipmentPartitionedRegionUsingCustId(int numPuts)

doPutsPDXSerializable

public static void doPutsPDXSerializable(String regionName,
                                         int numPuts)

doTxPuts

public static void doTxPuts(String regionName,
                            int numPuts)

updateShipmentPartitionedRegion

public static Map updateShipmentPartitionedRegion(int numPuts)

updateShipmentPartitionedRegionUsingCustId

public static Map updateShipmentPartitionedRegionUsingCustId(int numPuts)

doNextPuts

public static void doNextPuts(String regionName,
                              int start,
                              int numPuts)

checkQueueSize

public static void checkQueueSize(String senderId,
                                  int numQueueEntries)

checkPRQLocalSize
```
public static void checkPRQLocalSize(String senderId,
                                     int numQueueEntries)
```
To be used only for ParallelGatewaySender.

Parameters:

senderId - Id of the ParallelGatewaySender

numQueueEntries - Expected number of ParallelGatewaySenderQueue entries

doUpdates

public static void doUpdates(String regionName,
                             int numUpdates)

doUpdateOnSameKey

public static void doUpdateOnSameKey(String regionName,
                                     int key,
                                     int numUpdates)

doRandomUpdates

public static void doRandomUpdates(String regionName,
                                   int numUpdates)

doMultiThreadedPuts

public static void doMultiThreadedPuts(String regionName,
                                       int numPuts)

verifyAsyncEventListenerForPossibleDuplicates

public static void verifyAsyncEventListenerForPossibleDuplicates(String asyncEventQueueId,
                                                                 Set<Integer> bucketIds,
                                                                 int batchSize)

validateRegionSize

public static void validateRegionSize(String regionName,
                                      int regionSize)

validateAsyncEventQueueAttributes

public static void validateAsyncEventQueueAttributes(String asyncChannelId,
                                                     int maxQueueMemory,
                                                     int batchSize,
                                                     int batchTimeInterval,
                                                     boolean isPersistent,
                                                     String diskStoreName,
                                                     boolean isDiskSynchronous,
                                                     boolean batchConflationEnabled)

Validate whether all the attributes set on AsyncEventQueueFactory are set on the sender underneath the AsyncEventQueue.

validateConcurrentAsyncEventQueueAttributes

public static void validateConcurrentAsyncEventQueueAttributes(String asyncChannelId,
                                                               int maxQueueMemory,
                                                               int batchSize,
                                                               int batchTimeInterval,
                                                               boolean isPersistent,
                                                               String diskStoreName,
                                                               boolean isDiskSynchronous,
                                                               boolean batchConflationEnabled,
                                                               int dispatcherThreads,
                                                               com.gemstone.gemfire.cache.util.Gateway.OrderPolicy policy)

Validate whether all the attributes set on AsyncEventQueueFactory are set on the sender underneath the AsyncEventQueue.

validateAsyncEventListener

public static void validateAsyncEventListener(String asyncQueueId,
                                              int expectedSize)

validateCustomAsyncEventListener

public static void validateCustomAsyncEventListener(String asyncQueueId,
                                                    int expectedSize)

waitForAsyncQueueToGetEmpty

public static void waitForAsyncQueueToGetEmpty(String asyncQueueId)

getAsyncEventListenerMapSize

public static int getAsyncEventListenerMapSize(String asyncEventQueueId)

getAsyncEventQueueSize

public static int getAsyncEventQueueSize(String asyncEventQueueId)

validateRegionSize_PDX

public static void validateRegionSize_PDX(String regionName,
                                          int regionSize)

validateRegionSizeRemainsSame
```
public static void validateRegionSizeRemainsSame(String regionName,
                                                 int regionSizeLimit)
```
This method is specifically written for pause and stop operations. This method validates that the region size remains same for at least minimum number of verification attempts and also it remains below a specified limit value. This validation will suffice for testing of pause/stop operations.

Parameters:

regionName -

regionSizeLimit -

getRegionFullPath

public static String getRegionFullPath(String regionName)

getRegionSize

public static Integer getRegionSize(String regionName)

validateRegionContents

public static void validateRegionContents(String regionName,
                                          Map keyValues)

CheckContent

public static void CheckContent(String regionName,
                                int regionSize)

validateRegionContentsForPR

public static void validateRegionContentsForPR(String regionName,
                                               int regionSize)

verifyPrimaryStatus

public static void verifyPrimaryStatus(Boolean isPrimary)

getPrimaryStatus

public static Boolean getPrimaryStatus()

getAllPrimaryBucketsOnTheNode

public static Set<Integer> getAllPrimaryBucketsOnTheNode(String regionName)

doHeavyPuts

public static void doHeavyPuts(String regionName,
                               int numPuts)

addListenerAndKillPrimary

public static void addListenerAndKillPrimary()

addCacheListenerAndDestroyRegion

public static void addCacheListenerAndDestroyRegion(String regionName)

addCacheListenerAndCloseCache

public static void addCacheListenerAndCloseCache(String regionName)

killSender

public static Boolean killSender(String senderId)

killAsyncEventQueue

public static Boolean killAsyncEventQueue(String asyncQueueId)

killSender
```
public static void killSender()
```

checkAllSiteMetaData

public static void checkAllSiteMetaData(Map<Integer,List<Integer>> dsVsPorts)

checkAllSiteMetaDataFor3Sites

public static Long checkAllSiteMetaDataFor3Sites(Map<Integer,Set<String>> dsVsPort)

checkLocatorsinSender

public static void checkLocatorsinSender(String senderId,
                                         InetSocketAddress locatorToWaitFor)
                                  throws InterruptedException

Throws:: InterruptedException

validateQueueContents

public static void validateQueueContents(String senderId,
                                         int regionSize)

validateQueueClosedForConcurrentSerialGatewaySender

public static void validateQueueClosedForConcurrentSerialGatewaySender(String senderId)

validateQueueContentsForConcurrentSerialGatewaySender

public static void validateQueueContentsForConcurrentSerialGatewaySender(String senderId,
                                                                         int regionSize)

getQueueContentSize

public static Integer getQueueContentSize(String senderId)

validateParallelSenderQueueBucketSize

public static void validateParallelSenderQueueBucketSize(String senderId,
                                                         int bucketSize)

validateParallelSenderQueueAllBucketsDrained

public static void validateParallelSenderQueueAllBucketsDrained(String senderId)

verifyAndGetEventsDispatchedByConcurrentDispatchers

public static int verifyAndGetEventsDispatchedByConcurrentDispatchers(String senderId)

getNumberOfEntriesOverflownToDisk

public static Long getNumberOfEntriesOverflownToDisk(String senderId)

getNumberOfEntriesInVM

public static Long getNumberOfEntriesInVM(String senderId)

verifyQueueSize

public static void verifyQueueSize(String senderId,
                                   int size)

verifyRegionQueueNotEmpty

public static void verifyRegionQueueNotEmpty(String senderId)

verifyRegionQueueNotEmptyForConcurrentSender

public static void verifyRegionQueueNotEmptyForConcurrentSender(String senderId)

verifySenderPausedState
```
public static void verifySenderPausedState(String senderId)
```
Test methods for sender operations

Parameters:

senderId -

verifySenderResumedState

public static void verifySenderResumedState(String senderId)

verifySenderStoppedState

public static void verifySenderStoppedState(String senderId)

verifySenderRunningState

public static void verifySenderRunningState(String senderId)

removeSenderFromTheRegion

public static void removeSenderFromTheRegion(String senderId,
                                             String regionName)

destroySender

public static void destroySender(String senderId)

verifySenderDestroyed

public static void verifySenderDestroyed(String senderId,
                                         boolean isParallel)

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 DistributedTestCase

Throws:

Exception

closeCache
```
public static void closeCache()
```

shutdownLocator
```
public static void shutdownLocator()
```

printEventListenerMap

public static void printEventListenerMap()

getSystem
```
public com.gemstone.gemfire.distributed.internal.InternalDistributedSystem getSystem(Properties props)
```
Description copied from class: DistributedTestCase

Returns this VM's connection to the distributed system. If necessary, the connection will be lazily created using the given Properties. Note that this method uses hydra's configuration to determine the location of log files, etc.

Overrides:

getSystem in class DistributedTestCase

See Also:

DistributedConnectionMgr.connect(java.lang.String)

isOffHeap
```
public boolean isOffHeap()
```
Returns true if the test should create off-heap regions. OffHeap tests should over-ride this method and return false.

Class WANTestBase

Nested Class Summary

Nested classes/interfaces inherited from class dunit.DistributedTestCase

Field Summary

Fields inherited from class dunit.DistributedTestCase

Constructor Summary

Method Summary

Methods inherited from class dunit.DistributedTestCase

Methods inherited from class junit.framework.TestCase

Methods inherited from class java.lang.Object

Field Detail

cache

region

customerRegion

orderRegion

shipmentRegion

customerRegionName

orderRegionName

shipmentRegionName

vm0

vm1

vm2

vm3

vm4

vm5

vm6

vm7

listener1

listener2

gatewayListeners

eventListener1

eventListener2

eventFilter

destroyFlag

Constructor Detail

WANTestBase

Method Detail

setUp

createLocator

createFirstLocatorWithDSId

createFirstPeerLocator

createSecondLocator

createSecondPeerLocator

createFirstRemoteLocator

bringBackLocatorOnOldPort

createFirstRemotePeerLocator

createSecondRemoteLocator

createSecondRemotePeerLocator

createReplicatedRegion

createNormalRegion

createPersistentReplicatedRegion

createReplicatedRegion_WithGatewayEnabled

createReplicatedRegionWithAsyncEventQueue

createPersistentReplicatedRegionWithAsyncEventQueue

createReplicatedRegionWithSenderAndAsyncEventQueue

createReplicatedRegion

createAsyncEventQueue

createAsyncEventQueueWithListener2

createAsyncEventQueueWithCustomListener

createConcurrentAsyncEventQueue

createAsyncEventQueueWithDiskStore

pauseAsyncEventQueue

pauseAsyncEventQueueAndWaitForDispatcherToPause

resumeAsyncEventQueue

checkAsyncEventQueueSize

waitForAsyncEventQueueSize

createPartitionedRegion

createColocatedPartitionedRegion

createPartitionedRegionWithAsyncEventQueue

createColocatedPartitionedRegionWithAsyncEventQueue

createPersistentPartitionedRegionWithAsyncEventQueue

createPRWithRedundantCopyWithAsyncEventQueue

createPartitionedRegionAccessorWithAsyncEventQueue

createPartitionedRegion_WithGatewayEnabled

createPartitionedRegionAsAccessor

createPartitionedRegionWithSerialParallelSenderIds

createPersistentPartitionedRegion

createCustomerOrderShipmentPartitionedRegion

createColocatedPartitionedRegions

createColocatedPartitionedRegions2