org.apache.geode.internal.cache.wan.WANTestBase.java Source code

Java tutorial

Introduction

Here is the source code for org.apache.geode.internal.cache.wan.WANTestBase.java

Source

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more contributor license
 * agreements. See the NOTICE file distributed with this work for additional information regarding
 * copyright ownership. The ASF licenses this file to You under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance with the License. You may obtain a
 * copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software distributed under the License
 * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
 * or implied. See the License for the specific language governing permissions and limitations under
 * the License.
 */
package org.apache.geode.internal.cache.wan;

import static org.apache.geode.distributed.ConfigurationProperties.CONSERVE_SOCKETS;
import static org.apache.geode.distributed.ConfigurationProperties.DISTRIBUTED_SYSTEM_ID;
import static org.apache.geode.distributed.ConfigurationProperties.GATEWAY_SSL_CIPHERS;
import static org.apache.geode.distributed.ConfigurationProperties.GATEWAY_SSL_ENABLED;
import static org.apache.geode.distributed.ConfigurationProperties.GATEWAY_SSL_KEYSTORE;
import static org.apache.geode.distributed.ConfigurationProperties.GATEWAY_SSL_KEYSTORE_PASSWORD;
import static org.apache.geode.distributed.ConfigurationProperties.GATEWAY_SSL_KEYSTORE_TYPE;
import static org.apache.geode.distributed.ConfigurationProperties.GATEWAY_SSL_PROTOCOLS;
import static org.apache.geode.distributed.ConfigurationProperties.GATEWAY_SSL_REQUIRE_AUTHENTICATION;
import static org.apache.geode.distributed.ConfigurationProperties.GATEWAY_SSL_TRUSTSTORE;
import static org.apache.geode.distributed.ConfigurationProperties.GATEWAY_SSL_TRUSTSTORE_PASSWORD;
import static org.apache.geode.distributed.ConfigurationProperties.JMX_MANAGER;
import static org.apache.geode.distributed.ConfigurationProperties.JMX_MANAGER_HTTP_PORT;
import static org.apache.geode.distributed.ConfigurationProperties.JMX_MANAGER_PORT;
import static org.apache.geode.distributed.ConfigurationProperties.JMX_MANAGER_START;
import static org.apache.geode.distributed.ConfigurationProperties.LOCATORS;
import static org.apache.geode.distributed.ConfigurationProperties.LOG_LEVEL;
import static org.apache.geode.distributed.ConfigurationProperties.MCAST_PORT;
import static org.apache.geode.distributed.ConfigurationProperties.OFF_HEAP_MEMORY_SIZE;
import static org.apache.geode.distributed.ConfigurationProperties.REMOTE_LOCATORS;
import static org.apache.geode.distributed.ConfigurationProperties.START_LOCATOR;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;

import org.apache.commons.io.FileUtils;
import org.apache.geode.cache.AttributesFactory;
import org.apache.geode.cache.AttributesMutator;
import org.apache.geode.cache.Cache;
import org.apache.geode.cache.CacheClosedException;
import org.apache.geode.cache.CacheFactory;
import org.apache.geode.cache.CacheListener;
import org.apache.geode.cache.CacheTransactionManager;
import org.apache.geode.cache.DataPolicy;
import org.apache.geode.cache.DiskStore;
import org.apache.geode.cache.DiskStoreFactory;
import org.apache.geode.cache.EntryEvent;
import org.apache.geode.cache.PartitionAttributesFactory;
import org.apache.geode.cache.Region;
import org.apache.geode.cache.RegionAttributes;
import org.apache.geode.cache.RegionDestroyedException;
import org.apache.geode.cache.RegionFactory;
import org.apache.geode.cache.Scope;
import org.apache.geode.cache.asyncqueue.AsyncEventListener;
import org.apache.geode.cache.asyncqueue.AsyncEventQueue;
import org.apache.geode.cache.asyncqueue.AsyncEventQueueFactory;
import org.apache.geode.cache.asyncqueue.internal.AsyncEventQueueImpl;
import org.apache.geode.cache.client.Pool;
import org.apache.geode.cache.client.PoolManager;
import org.apache.geode.cache.client.internal.LocatorDiscoveryCallbackAdapter;
import org.apache.geode.cache.client.internal.PoolImpl;
import org.apache.geode.cache.client.internal.locator.wan.LocatorMembershipListener;
import org.apache.geode.cache.persistence.PartitionOfflineException;
import org.apache.geode.cache.server.CacheServer;
import org.apache.geode.cache.util.CacheListenerAdapter;
import org.apache.geode.cache.wan.GatewayEventFilter;
import org.apache.geode.cache.wan.GatewayQueueEvent;
import org.apache.geode.cache.wan.GatewayReceiver;
import org.apache.geode.cache.wan.GatewayReceiverFactory;
import org.apache.geode.cache.wan.GatewaySender;
import org.apache.geode.cache.wan.GatewaySender.OrderPolicy;
import org.apache.geode.cache.wan.GatewaySenderFactory;
import org.apache.geode.cache.wan.GatewayTransportFilter;
import org.apache.geode.cache30.CacheTestCase;
import org.apache.geode.distributed.Locator;
import org.apache.geode.distributed.internal.InternalDistributedSystem;
import org.apache.geode.distributed.internal.InternalLocator;
import org.apache.geode.distributed.internal.ServerLocation;
import org.apache.geode.internal.AvailablePort;
import org.apache.geode.internal.AvailablePortHelper;
import org.apache.geode.internal.admin.remote.DistributionLocatorId;
import org.apache.geode.internal.cache.BucketRegion;
import org.apache.geode.internal.cache.CacheConfig;
import org.apache.geode.internal.cache.CacheServerImpl;
import org.apache.geode.internal.cache.CustomerIDPartitionResolver;
import org.apache.geode.internal.cache.ForceReattemptException;
import org.apache.geode.internal.cache.GemFireCacheImpl;
import org.apache.geode.internal.cache.LocalRegion;
import org.apache.geode.internal.cache.PartitionedRegion;
import org.apache.geode.internal.cache.RegionQueue;
import org.apache.geode.internal.cache.execute.data.CustId;
import org.apache.geode.internal.cache.execute.data.Customer;
import org.apache.geode.internal.cache.execute.data.Order;
import org.apache.geode.internal.cache.execute.data.OrderId;
import org.apache.geode.internal.cache.execute.data.Shipment;
import org.apache.geode.internal.cache.execute.data.ShipmentId;
import org.apache.geode.internal.cache.partitioned.PRLocallyDestroyedException;
import org.apache.geode.internal.cache.tier.sockets.CacheServerStats;
import org.apache.geode.internal.cache.tier.sockets.CacheServerTestUtil;
import org.apache.geode.internal.cache.wan.parallel.ConcurrentParallelGatewaySenderEventProcessor;
import org.apache.geode.internal.cache.wan.parallel.ConcurrentParallelGatewaySenderQueue;
import org.apache.geode.internal.cache.wan.parallel.ParallelGatewaySenderEventProcessor;
import org.apache.geode.internal.cache.wan.parallel.ParallelGatewaySenderQueue;
import org.apache.geode.internal.cache.wan.serial.ConcurrentSerialGatewaySenderEventProcessor;
import org.apache.geode.internal.cache.wan.serial.SerialGatewaySenderQueue;
import org.apache.geode.pdx.SimpleClass;
import org.apache.geode.pdx.SimpleClass1;
import org.apache.geode.test.dunit.Assert;
import org.apache.geode.test.dunit.AsyncInvocation;
import org.apache.geode.test.dunit.Host;
import org.apache.geode.test.dunit.IgnoredException;
import org.apache.geode.test.dunit.Invoke;
import org.apache.geode.test.dunit.LogWriterUtils;
import org.apache.geode.test.dunit.VM;
import org.apache.geode.test.dunit.Wait;
import org.apache.geode.test.dunit.WaitCriterion;
import org.apache.geode.test.dunit.internal.JUnit4DistributedTestCase;
import org.apache.geode.test.junit.categories.DistributedTest;
import org.apache.geode.util.test.TestUtil;
import org.awaitility.Awaitility;
import org.junit.experimental.categories.Category;

import java.io.File;
import java.io.IOException;
import java.io.Serializable;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
import java.util.StringTokenizer;
import java.util.concurrent.Callable;
import java.util.concurrent.ConcurrentSkipListSet;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.stream.Collectors;

@Category(DistributedTest.class)
public class WANTestBase extends JUnit4DistributedTestCase {

    protected static Cache cache;
    protected static Region region;

    protected static PartitionedRegion customerRegion;
    protected static PartitionedRegion orderRegion;
    protected static PartitionedRegion shipmentRegion;

    protected static final String customerRegionName = "CUSTOMER";
    protected static final String orderRegionName = "ORDER";
    protected static final String shipmentRegionName = "SHIPMENT";

    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;

    protected static QueueListener listener1;
    protected static QueueListener listener2;

    protected static AsyncEventListener eventListener1;
    protected static AsyncEventListener eventListener2;

    private static final long MAX_WAIT = 10000;

    protected static GatewayEventFilter eventFilter;

    protected static List<Integer> dispatcherThreads = new ArrayList<Integer>(Arrays.asList(1, 3, 5));
    // this will be set for each test method run with one of the values from above list
    protected static int numDispatcherThreadsForTheRun = 1;

    public WANTestBase() {
        super();
    }

    /**
     * @deprecated Use the no arg constructor, or better yet, don't construct this class
     */
    @Deprecated
    public WANTestBase(final String ignored) {
    }

    @Override
    public final void preSetUp() throws Exception {
        final Host host = Host.getHost(0);
        vm0 = host.getVM(0);
        vm1 = host.getVM(1);
        vm2 = host.getVM(2);
        vm3 = host.getVM(3);
        vm4 = host.getVM(4);
        vm5 = host.getVM(5);
        vm6 = host.getVM(6);
        vm7 = host.getVM(7);
        // Need to set the test name after the VMs are created
    }

    @Override
    public final void postSetUp() throws Exception {
        // this is done to vary the number of dispatchers for sender
        // during every test method run
        shuffleNumDispatcherThreads();
        Invoke.invokeInEveryVM(() -> setNumDispatcherThreadsForTheRun(dispatcherThreads.get(0)));
        IgnoredException.addIgnoredException("Connection refused");
        IgnoredException.addIgnoredException("Software caused connection abort");
        IgnoredException.addIgnoredException("Connection reset");
        postSetUpWANTestBase();
    }

    protected void postSetUpWANTestBase() throws Exception {
    }

    public static void shuffleNumDispatcherThreads() {
        Collections.shuffle(dispatcherThreads);
    }

    public static void setNumDispatcherThreadsForTheRun(int numThreads) {
        numDispatcherThreadsForTheRun = numThreads;
    }

    public static void stopOldLocator() {
        if (Locator.hasLocator()) {
            Locator.getLocator().stop();
        }
    }

    public static void createLocator(int dsId, int port, Set<String> localLocatorsList,
            Set<String> remoteLocatorsList) {
        WANTestBase test = new WANTestBase();
        Properties props = test.getDistributedSystemProperties();
        props.setProperty(MCAST_PORT, "0");
        props.setProperty(DISTRIBUTED_SYSTEM_ID, "" + dsId);
        StringBuffer localLocatorBuffer = new StringBuffer(localLocatorsList.toString());
        localLocatorBuffer.deleteCharAt(0);
        localLocatorBuffer.deleteCharAt(localLocatorBuffer.lastIndexOf("]"));
        String localLocator = localLocatorBuffer.toString();
        localLocator = localLocator.replace(" ", "");

        props.setProperty(LOCATORS, localLocator);
        props.setProperty(START_LOCATOR,
                "localhost[" + port + "],server=true,peer=true,hostname-for-clients=localhost");
        StringBuffer remoteLocatorBuffer = new StringBuffer(remoteLocatorsList.toString());
        remoteLocatorBuffer.deleteCharAt(0);
        remoteLocatorBuffer.deleteCharAt(remoteLocatorBuffer.lastIndexOf("]"));
        String remoteLocator = remoteLocatorBuffer.toString();
        remoteLocator = remoteLocator.replace(" ", "");
        props.setProperty(REMOTE_LOCATORS, remoteLocator);
        test.getSystem(props);
    }

    public static Integer createFirstLocatorWithDSId(int dsId) {
        stopOldLocator();
        WANTestBase test = new WANTestBase();
        int port = AvailablePortHelper.getRandomAvailablePortForDUnitSite();
        Properties props = test.getDistributedSystemProperties();
        props.setProperty(MCAST_PORT, "0");
        props.setProperty(DISTRIBUTED_SYSTEM_ID, "" + dsId);
        props.setProperty(LOCATORS, "localhost[" + port + "]");
        props.setProperty(START_LOCATOR,
                "localhost[" + port + "],server=true,peer=true,hostname-for-clients=localhost");
        test.getSystem(props);
        return port;
    }

    public static Integer createFirstPeerLocator(int dsId) {
        stopOldLocator();
        WANTestBase test = new WANTestBase();
        int port = AvailablePortHelper.getRandomAvailablePortForDUnitSite();
        Properties props = test.getDistributedSystemProperties();
        props.setProperty(MCAST_PORT, "0");
        props.setProperty(DISTRIBUTED_SYSTEM_ID, "" + dsId);
        props.setProperty(LOCATORS, "localhost[" + port + "]");
        props.setProperty(START_LOCATOR,
                "localhost[" + port + "],server=false,peer=true,hostname-for-clients=localhost");
        test.getSystem(props);
        return port;
    }

    public static Integer createSecondLocator(int dsId, int locatorPort) {
        stopOldLocator();
        WANTestBase test = new WANTestBase();
        int port = AvailablePortHelper.getRandomAvailablePortForDUnitSite();
        Properties props = test.getDistributedSystemProperties();
        props.setProperty(MCAST_PORT, "0");
        props.setProperty(DISTRIBUTED_SYSTEM_ID, "" + dsId);
        props.setProperty(LOCATORS, "localhost[" + locatorPort + "]");
        props.setProperty(START_LOCATOR,
                "localhost[" + port + "],server=true,peer=true,hostname-for-clients=localhost");
        test.getSystem(props);
        return port;
    }

    public static Integer createSecondPeerLocator(int dsId, int locatorPort) {
        stopOldLocator();
        WANTestBase test = new WANTestBase();
        int port = AvailablePortHelper.getRandomAvailablePortForDUnitSite();
        Properties props = test.getDistributedSystemProperties();
        props.setProperty(MCAST_PORT, "0");
        props.setProperty(DISTRIBUTED_SYSTEM_ID, "" + dsId);
        props.setProperty(LOCATORS, "localhost[" + locatorPort + "]");
        props.setProperty(START_LOCATOR,
                "localhost[" + port + "],server=false,peer=true,hostname-for-clients=localhost");
        test.getSystem(props);
        return port;
    }

    public static Integer createFirstRemoteLocator(int dsId, int remoteLocPort) {
        stopOldLocator();
        WANTestBase test = new WANTestBase();
        int port = AvailablePortHelper.getRandomAvailablePortForDUnitSite();
        Properties props = test.getDistributedSystemProperties();
        props.setProperty(MCAST_PORT, "0");
        props.setProperty(DISTRIBUTED_SYSTEM_ID, "" + dsId);
        props.setProperty(LOCATORS, "localhost[" + port + "]");
        props.setProperty(START_LOCATOR,
                "localhost[" + port + "],server=true,peer=true,hostname-for-clients=localhost");
        props.setProperty(REMOTE_LOCATORS, "localhost[" + remoteLocPort + "]");
        test.getSystem(props);
        return port;
    }

    public static void bringBackLocatorOnOldPort(int dsId, int remoteLocPort, int oldPort) {
        WANTestBase test = new WANTestBase();
        Properties props = test.getDistributedSystemProperties();
        props.put(LOG_LEVEL, "fine");
        props.setProperty(MCAST_PORT, "0");
        props.setProperty(DISTRIBUTED_SYSTEM_ID, "" + dsId);
        props.setProperty(LOCATORS, "localhost[" + oldPort + "]");
        props.setProperty(START_LOCATOR,
                "localhost[" + oldPort + "],server=true,peer=true,hostname-for-clients=localhost");
        props.setProperty(REMOTE_LOCATORS, "localhost[" + remoteLocPort + "]");
        test.getSystem(props);
    }

    public static Integer createFirstRemotePeerLocator(int dsId, int remoteLocPort) {
        stopOldLocator();
        WANTestBase test = new WANTestBase();
        int port = AvailablePortHelper.getRandomAvailablePortForDUnitSite();
        Properties props = test.getDistributedSystemProperties();
        props.setProperty(MCAST_PORT, "0");
        props.setProperty(DISTRIBUTED_SYSTEM_ID, "" + dsId);
        props.setProperty(LOCATORS, "localhost[" + port + "]");
        props.setProperty(START_LOCATOR,
                "localhost[" + port + "],server=false,peer=true,hostname-for-clients=localhost");
        props.setProperty(REMOTE_LOCATORS, "localhost[" + remoteLocPort + "]");
        test.getSystem(props);
        return port;
    }

    public static Integer createSecondRemoteLocator(int dsId, int localPort, int remoteLocPort) {
        stopOldLocator();
        WANTestBase test = new WANTestBase();
        int port = AvailablePortHelper.getRandomAvailablePortForDUnitSite();
        Properties props = test.getDistributedSystemProperties();
        props.setProperty(MCAST_PORT, "0");
        props.setProperty(DISTRIBUTED_SYSTEM_ID, "" + dsId);
        props.setProperty(LOCATORS, "localhost[" + localPort + "]");
        props.setProperty(START_LOCATOR,
                "localhost[" + port + "],server=true,peer=true,hostname-for-clients=localhost");
        props.setProperty(REMOTE_LOCATORS, "localhost[" + remoteLocPort + "]");
        test.getSystem(props);
        return port;
    }

    public static Integer createSecondRemoteLocatorWithAPI(int dsId, int localPort, int remoteLocPort,
            String hostnameForClients) throws IOException {
        stopOldLocator();
        WANTestBase test = new WANTestBase();
        int port = AvailablePortHelper.getRandomAvailablePortForDUnitSite();
        Properties props = test.getDistributedSystemProperties();
        props.setProperty(MCAST_PORT, "0");
        props.setProperty(DISTRIBUTED_SYSTEM_ID, "" + dsId);
        props.setProperty(LOCATORS, "localhost[" + localPort + "]");
        props.setProperty(REMOTE_LOCATORS, "localhost[" + remoteLocPort + "]");
        Locator locator = Locator.startLocatorAndDS(0, null, InetAddress.getByName("localhost"), props, true, true,
                hostnameForClients);
        return locator.getPort();
    }

    public static Integer createSecondRemotePeerLocator(int dsId, int localPort, int remoteLocPort) {
        stopOldLocator();
        WANTestBase test = new WANTestBase();
        int port = AvailablePortHelper.getRandomAvailablePortForDUnitSite();
        Properties props = test.getDistributedSystemProperties();
        props.setProperty(MCAST_PORT, "0");
        props.setProperty(DISTRIBUTED_SYSTEM_ID, "" + dsId);
        props.setProperty(LOCATORS, "localhost[" + localPort + "]");
        props.setProperty(START_LOCATOR,
                "localhost[" + port + "],server=false,peer=true,hostname-for-clients=localhost");
        props.setProperty(REMOTE_LOCATORS, "localhost[" + remoteLocPort + "]");
        test.getSystem(props);
        return port;
    }

    public static int createReceiverInSecuredCache() {
        GatewayReceiverFactory fact = WANTestBase.cache.createGatewayReceiverFactory();
        int port = AvailablePortHelper.getRandomAvailablePortForDUnitSite();
        fact.setStartPort(port);
        fact.setEndPort(port);
        fact.setManualStart(true);
        GatewayReceiver receiver = fact.create();
        try {
            receiver.start();
        } catch (IOException e) {
            e.printStackTrace();
            org.apache.geode.test.dunit.Assert.fail("Failed to start GatewayReceiver on port " + port, e);
        }
        return port;
    }

    public static void createReplicatedRegion(String regionName, String senderIds, Boolean offHeap) {
        IgnoredException exp = IgnoredException.addIgnoredException(ForceReattemptException.class.getName());
        IgnoredException exp1 = IgnoredException.addIgnoredException(InterruptedException.class.getName());
        IgnoredException exp2 = IgnoredException.addIgnoredException(GatewaySenderException.class.getName());
        try {
            AttributesFactory fact = new AttributesFactory();
            if (senderIds != null) {
                StringTokenizer tokenizer = new StringTokenizer(senderIds, ",");
                while (tokenizer.hasMoreTokens()) {
                    String senderId = tokenizer.nextToken();
                    fact.addGatewaySenderId(senderId);
                }
            }
            fact.setDataPolicy(DataPolicy.REPLICATE);
            fact.setScope(Scope.DISTRIBUTED_ACK);
            fact.setOffHeap(offHeap);
            Region r = cache.createRegionFactory(fact.create()).create(regionName);
            assertNotNull(r);
        } finally {
            exp.remove();
            exp1.remove();
            exp2.remove();
        }
    }

    public static void createNormalRegion(String regionName, String senderIds) {
        AttributesFactory fact = new AttributesFactory();
        if (senderIds != null) {
            StringTokenizer tokenizer = new StringTokenizer(senderIds, ",");
            while (tokenizer.hasMoreTokens()) {
                String senderId = tokenizer.nextToken();
                fact.addGatewaySenderId(senderId);
            }
        }
        fact.setDataPolicy(DataPolicy.NORMAL);
        fact.setScope(Scope.DISTRIBUTED_ACK);
        Region r = cache.createRegionFactory(fact.create()).create(regionName);
        assertNotNull(r);
    }

    public static void createPersistentReplicatedRegion(String regionName, String senderIds, Boolean offHeap) {
        AttributesFactory fact = new AttributesFactory();
        if (senderIds != null) {
            StringTokenizer tokenizer = new StringTokenizer(senderIds, ",");
            while (tokenizer.hasMoreTokens()) {
                String senderId = tokenizer.nextToken();
                fact.addGatewaySenderId(senderId);
            }
        }
        fact.setDataPolicy(DataPolicy.PERSISTENT_REPLICATE);
        fact.setOffHeap(offHeap);
        Region r = cache.createRegionFactory(fact.create()).create(regionName);
        assertNotNull(r);
    }

    public static void createReplicatedRegionWithAsyncEventQueue(String regionName, String asyncQueueIds,
            Boolean offHeap) {
        IgnoredException exp1 = IgnoredException.addIgnoredException(ForceReattemptException.class.getName());
        try {
            AttributesFactory fact = new AttributesFactory();
            if (asyncQueueIds != null) {
                StringTokenizer tokenizer = new StringTokenizer(asyncQueueIds, ",");
                while (tokenizer.hasMoreTokens()) {
                    String asyncQueueId = tokenizer.nextToken();
                    fact.addAsyncEventQueueId(asyncQueueId);
                }
            }
            fact.setDataPolicy(DataPolicy.REPLICATE);
            fact.setOffHeap(offHeap);
            RegionFactory regionFactory = cache.createRegionFactory(fact.create());
            Region r = regionFactory.create(regionName);
            assertNotNull(r);
        } finally {
            exp1.remove();
        }
    }

    public static void createReplicatedRegionWithSenderAndAsyncEventQueue(String regionName, String senderIds,
            String asyncChannelId, Boolean offHeap) {
        IgnoredException exp = IgnoredException.addIgnoredException(ForceReattemptException.class.getName());
        try {
            AttributesFactory fact = new AttributesFactory();
            if (senderIds != null) {
                StringTokenizer tokenizer = new StringTokenizer(senderIds, ",");
                while (tokenizer.hasMoreTokens()) {
                    String senderId = tokenizer.nextToken();
                    fact.addGatewaySenderId(senderId);
                }
            }
            fact.setDataPolicy(DataPolicy.REPLICATE);
            fact.setScope(Scope.DISTRIBUTED_ACK);
            fact.setOffHeap(offHeap);
            RegionFactory regionFactory = cache.createRegionFactory(fact.create());
            regionFactory.addAsyncEventQueueId(asyncChannelId);
            Region r = regionFactory.create(regionName);
            assertNotNull(r);
        } finally {
            exp.remove();
        }
    }

    public static void createReplicatedRegion(String regionName, String senderIds, Scope scope, DataPolicy policy,
            Boolean offHeap) {
        AttributesFactory fact = new AttributesFactory();
        if (senderIds != null) {
            StringTokenizer tokenizer = new StringTokenizer(senderIds, ",");
            while (tokenizer.hasMoreTokens()) {
                String senderId = tokenizer.nextToken();
                fact.addGatewaySenderId(senderId);
            }
        }
        fact.setDataPolicy(policy);
        fact.setScope(scope);
        fact.setOffHeap(offHeap);
        Region r = cache.createRegionFactory(fact.create()).create(regionName);
        assertNotNull(r);
    }

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

        if (diskStoreName != null) {
            File directory = new File(
                    asyncChannelId + "_disk_" + System.currentTimeMillis() + "_" + VM.getCurrentVMNum());
            directory.mkdir();
            File[] dirs1 = new File[] { directory };
            DiskStoreFactory dsf = cache.createDiskStoreFactory();
            dsf.setDiskDirs(dirs1);
            dsf.create(diskStoreName);
        }

        AsyncEventListener asyncEventListener = new MyAsyncEventListener();

        AsyncEventQueueFactory factory = cache.createAsyncEventQueueFactory();
        factory.setBatchSize(batchSize);
        factory.setPersistent(isPersistent);
        factory.setDiskStoreName(diskStoreName);
        factory.setDiskSynchronous(isDiskSynchronous);
        factory.setBatchConflationEnabled(isConflation);
        factory.setMaximumQueueMemory(maxMemory);
        factory.setParallel(isParallel);
        // set dispatcher threads
        factory.setDispatcherThreads(numDispatcherThreadsForTheRun);
        factory.create(asyncChannelId, asyncEventListener);
    }

    public static void createPartitionedRegion(String regionName, String senderIds, Integer redundantCopies,
            Integer totalNumBuckets, Boolean offHeap) {
        IgnoredException exp = IgnoredException.addIgnoredException(ForceReattemptException.class.getName());
        IgnoredException exp1 = IgnoredException.addIgnoredException(PartitionOfflineException.class.getName());
        try {
            AttributesFactory fact = new AttributesFactory();
            if (senderIds != null) {
                StringTokenizer tokenizer = new StringTokenizer(senderIds, ",");
                while (tokenizer.hasMoreTokens()) {
                    String senderId = tokenizer.nextToken();
                    fact.addGatewaySenderId(senderId);
                }
            }
            PartitionAttributesFactory pfact = new PartitionAttributesFactory();
            pfact.setTotalNumBuckets(totalNumBuckets);
            pfact.setRedundantCopies(redundantCopies);
            pfact.setRecoveryDelay(0);
            fact.setPartitionAttributes(pfact.create());
            fact.setOffHeap(offHeap);
            Region r = cache.createRegionFactory(fact.create()).create(regionName);
            assertNotNull(r);
        } finally {
            exp.remove();
            exp1.remove();
        }
    }

    // TODO:OFFHEAP: add offheap flavor
    public static void createPartitionedRegionWithPersistence(String regionName, String senderIds,
            Integer redundantCopies, Integer totalNumBuckets) {
        IgnoredException exp = IgnoredException.addIgnoredException(ForceReattemptException.class.getName());
        IgnoredException exp1 = IgnoredException.addIgnoredException(PartitionOfflineException.class.getName());
        try {
            AttributesFactory fact = new AttributesFactory();
            if (senderIds != null) {
                StringTokenizer tokenizer = new StringTokenizer(senderIds, ",");
                while (tokenizer.hasMoreTokens()) {
                    String senderId = tokenizer.nextToken();
                    fact.addGatewaySenderId(senderId);
                }
            }
            PartitionAttributesFactory pfact = new PartitionAttributesFactory();
            pfact.setTotalNumBuckets(totalNumBuckets);
            pfact.setRedundantCopies(redundantCopies);
            pfact.setRecoveryDelay(0);
            fact.setPartitionAttributes(pfact.create());
            fact.setDataPolicy(DataPolicy.PERSISTENT_PARTITION);
            Region r = cache.createRegionFactory(fact.create()).create(regionName);
            assertNotNull(r);
        } finally {
            exp.remove();
            exp1.remove();
        }
    }

    public static void createColocatedPartitionedRegion(String regionName, String senderIds,
            Integer redundantCopies, Integer totalNumBuckets, String colocatedWith) {
        IgnoredException exp = IgnoredException.addIgnoredException(ForceReattemptException.class.getName());
        IgnoredException exp1 = IgnoredException.addIgnoredException(PartitionOfflineException.class.getName());
        try {
            AttributesFactory fact = new AttributesFactory();
            if (senderIds != null) {
                StringTokenizer tokenizer = new StringTokenizer(senderIds, ",");
                while (tokenizer.hasMoreTokens()) {
                    String senderId = tokenizer.nextToken();
                    fact.addGatewaySenderId(senderId);
                }
            }
            PartitionAttributesFactory pfact = new PartitionAttributesFactory();
            pfact.setTotalNumBuckets(totalNumBuckets);
            pfact.setRedundantCopies(redundantCopies);
            pfact.setRecoveryDelay(0);
            pfact.setColocatedWith(colocatedWith);
            fact.setPartitionAttributes(pfact.create());
            Region r = cache.createRegionFactory(fact.create()).create(regionName);
            assertNotNull(r);
        } finally {
            exp.remove();
            exp1.remove();
        }
    }

    public static void addSenderThroughAttributesMutator(String regionName, String senderIds) {
        final Region r = cache.getRegion(Region.SEPARATOR + regionName);
        assertNotNull(r);
        AttributesMutator mutator = r.getAttributesMutator();
        mutator.addGatewaySenderId(senderIds);
    }

    public static void addAsyncEventQueueThroughAttributesMutator(String regionName, String queueId) {
        final Region r = cache.getRegion(Region.SEPARATOR + regionName);
        assertNotNull(r);
        AttributesMutator mutator = r.getAttributesMutator();
        mutator.addAsyncEventQueueId(queueId);
    }

    public static void createPartitionedRegionAsAccessor(String regionName, String senderIds,
            Integer redundantCopies, Integer totalNumBuckets) {
        AttributesFactory fact = new AttributesFactory();
        if (senderIds != null) {
            StringTokenizer tokenizer = new StringTokenizer(senderIds, ",");
            while (tokenizer.hasMoreTokens()) {
                String senderId = tokenizer.nextToken();
                fact.addGatewaySenderId(senderId);
            }
        }
        PartitionAttributesFactory pfact = new PartitionAttributesFactory();
        pfact.setTotalNumBuckets(totalNumBuckets);
        pfact.setRedundantCopies(redundantCopies);
        pfact.setLocalMaxMemory(0);
        fact.setPartitionAttributes(pfact.create());
        Region r = cache.createRegionFactory(fact.create()).create(regionName);
        assertNotNull(r);
    }

    public static void createPartitionedRegionWithSerialParallelSenderIds(String regionName, String serialSenderIds,
            String parallelSenderIds, String colocatedWith, Boolean offHeap) {
        AttributesFactory fact = new AttributesFactory();
        if (serialSenderIds != null) {
            StringTokenizer tokenizer = new StringTokenizer(serialSenderIds, ",");
            while (tokenizer.hasMoreTokens()) {
                String senderId = tokenizer.nextToken();
                fact.addGatewaySenderId(senderId);
            }
        }
        if (parallelSenderIds != null) {
            StringTokenizer tokenizer = new StringTokenizer(parallelSenderIds, ",");
            while (tokenizer.hasMoreTokens()) {
                String senderId = tokenizer.nextToken();
                fact.addGatewaySenderId(senderId);
            }
        }
        PartitionAttributesFactory pfact = new PartitionAttributesFactory();
        pfact.setColocatedWith(colocatedWith);
        fact.setPartitionAttributes(pfact.create());
        fact.setOffHeap(offHeap);
        Region r = cache.createRegionFactory(fact.create()).create(regionName);
        assertNotNull(r);
    }

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

        IgnoredException exp = IgnoredException.addIgnoredException(ForceReattemptException.class.getName());
        IgnoredException exp1 = IgnoredException.addIgnoredException(PartitionOfflineException.class.getName());
        try {

            AttributesFactory fact = new AttributesFactory();
            if (senderIds != null) {
                StringTokenizer tokenizer = new StringTokenizer(senderIds, ",");
                while (tokenizer.hasMoreTokens()) {
                    String senderId = tokenizer.nextToken();
                    fact.addGatewaySenderId(senderId);
                }
            }
            PartitionAttributesFactory pfact = new PartitionAttributesFactory();
            pfact.setTotalNumBuckets(totalNumBuckets);
            pfact.setRedundantCopies(redundantCopies);
            fact.setPartitionAttributes(pfact.create());
            fact.setDataPolicy(DataPolicy.PERSISTENT_PARTITION);
            fact.setOffHeap(offHeap);
            Region r = cache.createRegionFactory(fact.create()).create(regionName);
            assertNotNull(r);
        } finally {
            exp.remove();
            exp1.remove();
        }
    }

    public static void createCustomerOrderShipmentPartitionedRegion(String senderIds, Integer redundantCopies,
            Integer totalNumBuckets, Boolean offHeap) {
        IgnoredException exp = IgnoredException.addIgnoredException(ForceReattemptException.class.getName());
        try {
            AttributesFactory fact = new AttributesFactory();
            if (senderIds != null) {
                StringTokenizer tokenizer = new StringTokenizer(senderIds, ",");
                while (tokenizer.hasMoreTokens()) {
                    String senderId = tokenizer.nextToken();
                    fact.addGatewaySenderId(senderId);
                }
            }

            PartitionAttributesFactory paf = new PartitionAttributesFactory();
            paf.setRedundantCopies(redundantCopies).setTotalNumBuckets(totalNumBuckets)
                    .setPartitionResolver(new CustomerIDPartitionResolver("CustomerIDPartitionResolver"));
            fact.setPartitionAttributes(paf.create());
            fact.setOffHeap(offHeap);
            customerRegion = (PartitionedRegion) cache.createRegionFactory(fact.create())
                    .create(customerRegionName);
            assertNotNull(customerRegion);
            LogWriterUtils.getLogWriter()
                    .info("Partitioned Region CUSTOMER created Successfully :" + customerRegion.toString());

            paf = new PartitionAttributesFactory();
            paf.setRedundantCopies(redundantCopies).setTotalNumBuckets(totalNumBuckets)
                    .setColocatedWith(customerRegionName)
                    .setPartitionResolver(new CustomerIDPartitionResolver("CustomerIDPartitionResolver"));
            fact = new AttributesFactory();
            if (senderIds != null) {
                StringTokenizer tokenizer = new StringTokenizer(senderIds, ",");
                while (tokenizer.hasMoreTokens()) {
                    String senderId = tokenizer.nextToken();
                    fact.addGatewaySenderId(senderId);
                }
            }
            fact.setPartitionAttributes(paf.create());
            fact.setOffHeap(offHeap);
            orderRegion = (PartitionedRegion) cache.createRegionFactory(fact.create()).create(orderRegionName);
            assertNotNull(orderRegion);
            LogWriterUtils.getLogWriter()
                    .info("Partitioned Region ORDER created Successfully :" + orderRegion.toString());

            paf = new PartitionAttributesFactory();
            paf.setRedundantCopies(redundantCopies).setTotalNumBuckets(totalNumBuckets)
                    .setColocatedWith(orderRegionName)
                    .setPartitionResolver(new CustomerIDPartitionResolver("CustomerIDPartitionResolver"));
            fact = new AttributesFactory();
            if (senderIds != null) {
                StringTokenizer tokenizer = new StringTokenizer(senderIds, ",");
                while (tokenizer.hasMoreTokens()) {
                    String senderId = tokenizer.nextToken();
                    fact.addGatewaySenderId(senderId);
                }
            }
            fact.setPartitionAttributes(paf.create());
            fact.setOffHeap(offHeap);
            shipmentRegion = (PartitionedRegion) cache.createRegionFactory(fact.create())
                    .create(shipmentRegionName);
            assertNotNull(shipmentRegion);
            LogWriterUtils.getLogWriter()
                    .info("Partitioned Region SHIPMENT created Successfully :" + shipmentRegion.toString());
        } finally {
            exp.remove();
        }
    }

    public static void createColocatedPartitionedRegions(String regionName, String senderIds,
            Integer redundantCopies, Integer totalNumBuckets, Boolean offHeap) {
        AttributesFactory fact = new AttributesFactory();
        if (senderIds != null) {
            StringTokenizer tokenizer = new StringTokenizer(senderIds, ",");
            while (tokenizer.hasMoreTokens()) {
                String senderId = tokenizer.nextToken();
                fact.addGatewaySenderId(senderId);
            }
        }
        PartitionAttributesFactory pfact = new PartitionAttributesFactory();
        pfact.setTotalNumBuckets(totalNumBuckets);
        pfact.setRedundantCopies(redundantCopies);
        fact.setPartitionAttributes(pfact.create());
        fact.setOffHeap(offHeap);
        Region r = cache.createRegionFactory(fact.create()).create(regionName);
        assertNotNull(r);

        pfact.setColocatedWith(r.getName());
        fact.setPartitionAttributes(pfact.create());
        fact.setOffHeap(offHeap);
        Region r1 = cache.createRegionFactory(fact.create()).create(regionName + "_child1");
        assertNotNull(r1);

        Region r2 = cache.createRegionFactory(fact.create()).create(regionName + "_child2");
        assertNotNull(r2);
    }

    public static void createColocatedPartitionedRegions2(String regionName, String senderIds,
            Integer redundantCopies, Integer totalNumBuckets, Boolean offHeap) {
        AttributesFactory fact = new AttributesFactory();
        if (senderIds != null) {
            StringTokenizer tokenizer = new StringTokenizer(senderIds, ",");
            while (tokenizer.hasMoreTokens()) {
                String senderId = tokenizer.nextToken();
                fact.addGatewaySenderId(senderId);
            }
        }
        PartitionAttributesFactory pfact = new PartitionAttributesFactory();
        pfact.setTotalNumBuckets(totalNumBuckets);
        pfact.setRedundantCopies(redundantCopies);
        fact.setPartitionAttributes(pfact.create());
        fact.setOffHeap(offHeap);
        Region r = cache.createRegionFactory(fact.create()).create(regionName);
        assertNotNull(r);

        fact = new AttributesFactory();
        pfact.setColocatedWith(r.getName());
        fact.setPartitionAttributes(pfact.create());
        fact.setOffHeap(offHeap);
        Region r1 = cache.createRegionFactory(fact.create()).create(regionName + "_child1");
        assertNotNull(r1);

        Region r2 = cache.createRegionFactory(fact.create()).create(regionName + "_child2");
        assertNotNull(r2);
    }

    public static void createCacheInVMs(Integer locatorPort, VM... vms) {
        for (VM vm : vms) {
            vm.invoke(() -> createCache(locatorPort));
        }
    }

    public static void addListenerToSleepAfterCreateEvent(int milliSeconds, final String regionName) {
        cache.getRegion(regionName).getAttributesMutator()
                .addCacheListener(new CacheListenerAdapter<Object, Object>() {
                    @Override
                    public void afterCreate(final EntryEvent<Object, Object> event) {
                        try {
                            Thread.sleep(milliSeconds);
                        } catch (InterruptedException e) {
                            Thread.currentThread().interrupt();
                        }
                    }
                });
    }

    private static CacheListener myListener;

    public static void longPauseAfterNumEvents(int numEvents, int milliSeconds) {
        myListener = new CacheListenerAdapter<Object, Object>() {
            @Override
            public void afterCreate(final EntryEvent<Object, Object> event) {
                try {
                    if (event.getRegion().size() >= numEvents) {
                        Thread.sleep(milliSeconds);
                    }
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        };
        cache.getRegion(getTestMethodName() + "_RR_1").getAttributesMutator().addCacheListener(myListener);
    }

    public static void removeCacheListener() {
        cache.getRegion(getTestMethodName() + "_RR_1").getAttributesMutator().removeCacheListener(myListener);

    }

    public static void createCache(Integer locPort) {
        createCache(false, locPort);
    }

    public static void createManagementCache(Integer locPort) {
        createCache(true, locPort);
    }

    public static void createCacheConserveSockets(Boolean conserveSockets, Integer locPort) {
        WANTestBase test = new WANTestBase();
        Properties props = test.getDistributedSystemProperties();
        props.setProperty(MCAST_PORT, "0");
        props.setProperty(LOCATORS, "localhost[" + locPort + "]");
        props.setProperty(CONSERVE_SOCKETS, conserveSockets.toString());
        InternalDistributedSystem ds = test.getSystem(props);
        cache = CacheFactory.create(ds);
    }

    protected static void createCache(boolean management, Integer locPort) {
        WANTestBase test = new WANTestBase();
        Properties props = test.getDistributedSystemProperties();
        if (management) {
            props.setProperty(JMX_MANAGER, "true");
            props.setProperty(JMX_MANAGER_START, "false");
            props.setProperty(JMX_MANAGER_PORT, "0");
            props.setProperty(JMX_MANAGER_HTTP_PORT, "0");
        }
        props.setProperty(MCAST_PORT, "0");
        props.setProperty(LOCATORS, "localhost[" + locPort + "]");
        InternalDistributedSystem ds = test.getSystem(props);
        cache = CacheFactory.create(ds);
    }

    protected static void createCacheWithSSL(Integer locPort) {
        WANTestBase test = new WANTestBase();

        boolean gatewaySslenabled = true;
        String gatewaySslprotocols = "any";
        String gatewaySslciphers = "any";
        boolean gatewaySslRequireAuth = true;

        Properties gemFireProps = test.getDistributedSystemProperties();
        gemFireProps.put(LOG_LEVEL, LogWriterUtils.getDUnitLogLevel());
        gemFireProps.put(GATEWAY_SSL_ENABLED, String.valueOf(gatewaySslenabled));
        gemFireProps.put(GATEWAY_SSL_PROTOCOLS, gatewaySslprotocols);
        gemFireProps.put(GATEWAY_SSL_CIPHERS, gatewaySslciphers);
        gemFireProps.put(GATEWAY_SSL_REQUIRE_AUTHENTICATION, String.valueOf(gatewaySslRequireAuth));

        gemFireProps.put(GATEWAY_SSL_KEYSTORE_TYPE, "jks");
        gemFireProps.put(GATEWAY_SSL_KEYSTORE, TestUtil.getResourcePath(WANTestBase.class,
                "/org/apache/geode/cache/client/internal/client.keystore"));
        gemFireProps.put(GATEWAY_SSL_KEYSTORE_PASSWORD, "password");
        gemFireProps.put(GATEWAY_SSL_TRUSTSTORE, TestUtil.getResourcePath(WANTestBase.class,
                "/org/apache/geode/cache/client/internal/client.truststore"));
        gemFireProps.put(GATEWAY_SSL_TRUSTSTORE_PASSWORD, "password");

        gemFireProps.setProperty(MCAST_PORT, "0");
        gemFireProps.setProperty(LOCATORS, "localhost[" + locPort + "]");

        LogWriterUtils.getLogWriter().info("Starting cache ds with following properties \n" + gemFireProps);

        InternalDistributedSystem ds = test.getSystem(gemFireProps);
        cache = CacheFactory.create(ds);
    }

    public static void createCache_PDX(Integer locPort) {
        WANTestBase test = new WANTestBase();
        Properties props = test.getDistributedSystemProperties();
        props.setProperty(MCAST_PORT, "0");
        props.setProperty(LOCATORS, "localhost[" + locPort + "]");
        InternalDistributedSystem ds = test.getSystem(props);
        CacheConfig cacheConfig = new CacheConfig();
        cacheConfig.setPdxPersistent(true);
        cacheConfig.setPdxDiskStore("PDX_TEST");
        cache = GemFireCacheImpl.create(ds, false, cacheConfig);

        File pdxDir = new File(CacheTestCase.getDiskDir(), "pdx");
        DiskStoreFactory dsf = cache.createDiskStoreFactory();
        File[] dirs1 = new File[] { pdxDir };
        dsf.setDiskDirs(dirs1).setMaxOplogSize(1).create("PDX_TEST");
    }

    public static void createCache(Integer locPort1, Integer locPort2) {
        WANTestBase test = new WANTestBase();
        Properties props = test.getDistributedSystemProperties();
        props.setProperty(MCAST_PORT, "0");
        props.setProperty(LOCATORS, "localhost[" + locPort1 + "],localhost[" + locPort2 + "]");
        InternalDistributedSystem ds = test.getSystem(props);
        cache = CacheFactory.create(ds);
    }

    public static void createCacheWithoutLocator(Integer mCastPort) {
        WANTestBase test = new WANTestBase();
        Properties props = test.getDistributedSystemProperties();
        props.setProperty(MCAST_PORT, "" + mCastPort);
        InternalDistributedSystem ds = test.getSystem(props);
        cache = CacheFactory.create(ds);
    }

    /**
     * Method that creates a bridge server
     *
     * @return Integer Port on which the server is started.
     */
    public static Integer createCacheServer() {
        CacheServer server1 = cache.addCacheServer();
        assertNotNull(server1);
        server1.setPort(0);
        try {
            server1.start();
        } catch (IOException e) {
            org.apache.geode.test.dunit.Assert.fail("Failed to start the Server", e);
        }
        assertTrue(server1.isRunning());

        return new Integer(server1.getPort());
    }

    /**
     * Returns a Map that contains the count for number of bridge server and number of Receivers.
     *
     * @return Map
     */
    public static Map getCacheServers() {
        List cacheServers = cache.getCacheServers();

        Map cacheServersMap = new HashMap();
        Iterator itr = cacheServers.iterator();
        int bridgeServerCounter = 0;
        int receiverServerCounter = 0;
        while (itr.hasNext()) {
            CacheServerImpl cacheServer = (CacheServerImpl) itr.next();
            if (cacheServer.getAcceptor().isGatewayReceiver()) {
                receiverServerCounter++;
            } else {
                bridgeServerCounter++;
            }
        }
        cacheServersMap.put("BridgeServer", bridgeServerCounter);
        cacheServersMap.put("ReceiverServer", receiverServerCounter);
        return cacheServersMap;
    }

    public static void startSenderInVMs(String senderId, VM... vms) {
        for (VM vm : vms) {
            vm.invoke(() -> startSender(senderId));
        }
    }

    public static void startSenderInVMsAsync(String senderId, VM... vms) {
        List<AsyncInvocation> tasks = new LinkedList<>();
        for (VM vm : vms) {
            tasks.add(vm.invokeAsync(() -> startSender(senderId)));
        }
        for (AsyncInvocation invocation : tasks) {
            try {
                invocation.join(30000); // TODO: these might be AsyncInvocation orphans
            } catch (InterruptedException e) {
                fail("Starting senders was interrupted");
            }
        }
    }

    public static void startSender(String senderId) {
        final IgnoredException exln = IgnoredException.addIgnoredException("Could not connect");

        IgnoredException exp = IgnoredException.addIgnoredException(ForceReattemptException.class.getName());
        IgnoredException exp1 = IgnoredException.addIgnoredException(InterruptedException.class.getName());
        try {
            Set<GatewaySender> senders = cache.getGatewaySenders();
            GatewaySender sender = null;
            for (GatewaySender s : senders) {
                if (s.getId().equals(senderId)) {
                    sender = s;
                    break;
                }
            }
            sender.start();
        } finally {
            exp.remove();
            exp1.remove();
            exln.remove();
        }

    }

    public static void enableConflation(String senderId) {
        Set<GatewaySender> senders = cache.getGatewaySenders();
        AbstractGatewaySender sender = null;
        for (GatewaySender s : senders) {
            if (s.getId().equals(senderId)) {
                sender = (AbstractGatewaySender) s;
                break;
            }
        }
        sender.test_setBatchConflationEnabled(true);
    }

    public static Map getSenderToReceiverConnectionInfo(String senderId) {
        Set<GatewaySender> senders = cache.getGatewaySenders();
        GatewaySender sender = null;
        for (GatewaySender s : senders) {
            if (s.getId().equals(senderId)) {
                sender = s;
                break;
            }
        }
        Map connectionInfo = null;
        if (!sender.isParallel() && ((AbstractGatewaySender) sender).isPrimary()) {
            connectionInfo = new HashMap();
            GatewaySenderEventDispatcher dispatcher = ((AbstractGatewaySender) sender).getEventProcessor()
                    .getDispatcher();
            if (dispatcher instanceof GatewaySenderEventRemoteDispatcher) {
                ServerLocation serverLocation = ((GatewaySenderEventRemoteDispatcher) dispatcher)
                        .getConnection(false).getServer();
                connectionInfo.put("serverHost", serverLocation.getHostName());
                connectionInfo.put("serverPort", serverLocation.getPort());

            }
        }
        return connectionInfo;
    }

    public static List<Integer> getSenderStats(String senderId, final int expectedQueueSize) {
        Set<GatewaySender> senders = cache.getGatewaySenders();
        AbstractGatewaySender sender = null;
        for (GatewaySender s : senders) {
            if (s.getId().equals(senderId)) {
                sender = (AbstractGatewaySender) s;
                break;
            }
        }
        final GatewaySenderStats statistics = sender.getStatistics();
        if (expectedQueueSize != -1) {
            final RegionQueue regionQueue;
            regionQueue = sender.getQueues().toArray(new RegionQueue[1])[0];
            Awaitility.await().atMost(120, TimeUnit.SECONDS).until(() -> assertEquals(
                    "Expected queue entries: " + expectedQueueSize + " but actual entries: " + regionQueue.size(),
                    expectedQueueSize, regionQueue.size()));
        }
        ArrayList<Integer> stats = new ArrayList<Integer>();
        stats.add(statistics.getEventQueueSize());
        stats.add(statistics.getEventsReceived());
        stats.add(statistics.getEventsQueued());
        stats.add(statistics.getEventsDistributed());
        stats.add(statistics.getBatchesDistributed());
        stats.add(statistics.getBatchesRedistributed());
        stats.add(statistics.getEventsFiltered());
        stats.add(statistics.getEventsNotQueuedConflated());
        stats.add(statistics.getEventsConflatedFromBatches());
        return stats;
    }

    public static void checkQueueStats(String senderId, final int queueSize, final int eventsReceived,
            final int eventsQueued, final int eventsDistributed) {
        Set<GatewaySender> senders = cache.getGatewaySenders();
        GatewaySender sender = null;
        for (GatewaySender s : senders) {
            if (s.getId().equals(senderId)) {
                sender = s;
                break;
            }
        }

        final GatewaySenderStats statistics = ((AbstractGatewaySender) sender).getStatistics();
        assertEquals(queueSize, statistics.getEventQueueSize());
        assertEquals(eventsReceived, statistics.getEventsReceived());
        assertEquals(eventsQueued, statistics.getEventsQueued());
        assert (statistics.getEventsDistributed() >= eventsDistributed);
    }

    public static void checkGatewayReceiverStats(int processBatches, int eventsReceived, int creates) {
        Set<GatewayReceiver> gatewayReceivers = cache.getGatewayReceivers();
        GatewayReceiver receiver = gatewayReceivers.iterator().next();
        CacheServerStats stats = ((CacheServerImpl) receiver.getServer()).getAcceptor().getStats();

        assertTrue(stats instanceof GatewayReceiverStats);
        GatewayReceiverStats gatewayReceiverStats = (GatewayReceiverStats) stats;
        assertTrue(gatewayReceiverStats.getProcessBatchRequests() >= processBatches);
        assertEquals(eventsReceived, gatewayReceiverStats.getEventsReceived());
        assertEquals(creates, gatewayReceiverStats.getCreateRequest());
    }

    public static void checkMinimumGatewayReceiverStats(int processBatches, int eventsReceived) {
        Set<GatewayReceiver> gatewayReceivers = cache.getGatewayReceivers();
        GatewayReceiver receiver = gatewayReceivers.iterator().next();
        CacheServerStats stats = ((CacheServerImpl) receiver.getServer()).getAcceptor().getStats();

        assertTrue(stats instanceof GatewayReceiverStats);
        GatewayReceiverStats gatewayReceiverStats = (GatewayReceiverStats) stats;
        assertTrue(gatewayReceiverStats.getProcessBatchRequests() >= processBatches);
        assertTrue(gatewayReceiverStats.getEventsReceived() >= eventsReceived);
    }

    public static void checkExceptionStats(int exceptionsOccurred) {
        Set<GatewayReceiver> gatewayReceivers = cache.getGatewayReceivers();
        GatewayReceiver receiver = gatewayReceivers.iterator().next();
        CacheServerStats stats = ((CacheServerImpl) receiver.getServer()).getAcceptor().getStats();

        assertTrue(stats instanceof GatewayReceiverStats);
        GatewayReceiverStats gatewayReceiverStats = (GatewayReceiverStats) stats;
        if (exceptionsOccurred == 0) {
            assertEquals(exceptionsOccurred, gatewayReceiverStats.getExceptionsOccurred());
        } else {
            assertTrue(gatewayReceiverStats.getExceptionsOccurred() >= exceptionsOccurred);
        }
    }

    public static void checkGatewayReceiverStatsHA(int processBatches, int eventsReceived, int creates) {
        Set<GatewayReceiver> gatewayReceivers = cache.getGatewayReceivers();
        GatewayReceiver receiver = gatewayReceivers.iterator().next();
        CacheServerStats stats = ((CacheServerImpl) receiver.getServer()).getAcceptor().getStats();

        assertTrue(stats instanceof GatewayReceiverStats);
        GatewayReceiverStats gatewayReceiverStats = (GatewayReceiverStats) stats;
        assertTrue(gatewayReceiverStats.getProcessBatchRequests() >= processBatches);
        assertTrue(gatewayReceiverStats.getEventsReceived() >= eventsReceived);
        assertTrue(gatewayReceiverStats.getCreateRequest() >= creates);
    }

    public static void checkEventFilteredStats(String senderId, final int eventsFiltered) {
        Set<GatewaySender> senders = cache.getGatewaySenders();
        GatewaySender sender = null;
        for (GatewaySender s : senders) {
            if (s.getId().equals(senderId)) {
                sender = s;
                break;
            }
        }
        final GatewaySenderStats statistics = ((AbstractGatewaySender) sender).getStatistics();
        assertEquals(eventsFiltered, statistics.getEventsFiltered());
    }

    public static void checkConflatedStats(String senderId, final int eventsConflated) {
        Set<GatewaySender> senders = cache.getGatewaySenders();
        GatewaySender sender = null;
        for (GatewaySender s : senders) {
            if (s.getId().equals(senderId)) {
                sender = s;
                break;
            }
        }
        final GatewaySenderStats statistics = ((AbstractGatewaySender) sender).getStatistics();
        assertEquals(eventsConflated, statistics.getEventsNotQueuedConflated());
    }

    public static void checkStats_Failover(String senderId, final int eventsReceived) {
        Set<GatewaySender> senders = cache.getGatewaySenders();
        GatewaySender sender = null;
        for (GatewaySender s : senders) {
            if (s.getId().equals(senderId)) {
                sender = s;
                break;
            }
        }
        final GatewaySenderStats statistics = ((AbstractGatewaySender) sender).getStatistics();

        assertEquals(eventsReceived, statistics.getEventsReceived());
        assertEquals(eventsReceived, (statistics.getEventsQueued() + statistics.getUnprocessedTokensAddedByPrimary()
                + statistics.getUnprocessedEventsRemovedByPrimary()));
    }

    public static void checkBatchStats(String senderId, final int batches) {
        Set<GatewaySender> senders = cache.getGatewaySenders();
        GatewaySender sender = null;
        for (GatewaySender s : senders) {
            if (s.getId().equals(senderId)) {
                sender = s;
                break;
            }
        }
        final GatewaySenderStats statistics = ((AbstractGatewaySender) sender).getStatistics();
        assert (statistics.getBatchesDistributed() >= batches);
        assertEquals(0, statistics.getBatchesRedistributed());
    }

    public static void checkBatchStats(String senderId, final boolean batchesDistributed,
            final boolean batchesRedistributed) {
        Set<GatewaySender> senders = cache.getGatewaySenders();
        GatewaySender sender = null;
        for (GatewaySender s : senders) {
            if (s.getId().equals(senderId)) {
                sender = s;
                break;
            }
        }
        final GatewaySenderStats statistics = ((AbstractGatewaySender) sender).getStatistics();
        assertEquals(batchesDistributed, (statistics.getBatchesDistributed() > 0));
        assertEquals(batchesRedistributed, (statistics.getBatchesRedistributed() > 0));
    }

    public static void checkUnProcessedStats(String senderId, int events) {
        Set<GatewaySender> senders = cache.getGatewaySenders();
        GatewaySender sender = null;
        for (GatewaySender s : senders) {
            if (s.getId().equals(senderId)) {
                sender = s;
                break;
            }
        }
        final GatewaySenderStats statistics = ((AbstractGatewaySender) sender).getStatistics();
        assertEquals(events, (statistics.getUnprocessedEventsAddedBySecondary()
                + statistics.getUnprocessedTokensRemovedBySecondary()));
        assertEquals(events, (statistics.getUnprocessedEventsRemovedByPrimary()
                + statistics.getUnprocessedTokensAddedByPrimary()));
    }

    public static void waitForSenderRunningState(String senderId) {
        final IgnoredException exln = IgnoredException.addIgnoredException("Could not connect");
        try {
            Set<GatewaySender> senders = cache.getGatewaySenders();
            final GatewaySender sender = getGatewaySenderById(senders, senderId);
            Awaitility.await().atMost(300, TimeUnit.SECONDS)
                    .until(() -> assertEquals("Expected sender isRunning state to " + "be true but is false", true,
                            (sender != null && sender.isRunning())));
        } finally {
            exln.remove();
        }
    }

    public static void waitForSenderToBecomePrimary(String senderId) {
        Set<GatewaySender> senders = ((GemFireCacheImpl) cache).getAllGatewaySenders();
        final GatewaySender sender = getGatewaySenderById(senders, senderId);
        Awaitility.await().atMost(10, TimeUnit.SECONDS)
                .until(() -> assertEquals("Expected sender primary state to " + "be true but is false", true,
                        (sender != null && ((AbstractGatewaySender) sender).isPrimary())));
    }

    private static GatewaySender getGatewaySenderById(Set<GatewaySender> senders, String senderId) {
        for (GatewaySender s : senders) {
            if (s.getId().equals(senderId)) {
                return s;
            }
        }
        // if none of the senders matches with the supplied senderid, return null
        return null;
    }

    public static HashMap checkQueue() {
        HashMap listenerAttrs = new HashMap();
        listenerAttrs.put("Create", listener1.createList);
        listenerAttrs.put("Update", listener1.updateList);
        listenerAttrs.put("Destroy", listener1.destroyList);
        return listenerAttrs;
    }

    public static void checkQueueOnSecondary(final Map primaryUpdatesMap) {
        final HashMap secondaryUpdatesMap = new HashMap();
        secondaryUpdatesMap.put("Create", listener1.createList);
        secondaryUpdatesMap.put("Update", listener1.updateList);
        secondaryUpdatesMap.put("Destroy", listener1.destroyList);

        Awaitility.await().atMost(10, TimeUnit.SECONDS).until(() -> {
            secondaryUpdatesMap.put("Create", listener1.createList);
            secondaryUpdatesMap.put("Update", listener1.updateList);
            secondaryUpdatesMap.put("Destroy", listener1.destroyList);
            assertEquals("Expected secondary map to be " + primaryUpdatesMap + " but it is " + secondaryUpdatesMap,
                    true, secondaryUpdatesMap.equals(primaryUpdatesMap));
        });
    }

    public static HashMap checkQueue2() {
        HashMap listenerAttrs = new HashMap();
        listenerAttrs.put("Create", listener2.createList);
        listenerAttrs.put("Update", listener2.updateList);
        listenerAttrs.put("Destroy", listener2.destroyList);
        return listenerAttrs;
    }

    public static HashMap checkPR(String regionName) {
        PartitionedRegion region = (PartitionedRegion) cache.getRegion(regionName);
        QueueListener listener = (QueueListener) region.getCacheListener();

        HashMap listenerAttrs = new HashMap();
        listenerAttrs.put("Create", listener.createList);
        listenerAttrs.put("Update", listener.updateList);
        listenerAttrs.put("Destroy", listener.destroyList);
        return listenerAttrs;
    }

    public static HashMap checkBR(String regionName, int numBuckets) {
        PartitionedRegion region = (PartitionedRegion) cache.getRegion(regionName);
        HashMap listenerAttrs = new HashMap();
        for (int i = 0; i < numBuckets; i++) {
            BucketRegion br = region.getBucketRegion(i);
            QueueListener listener = (QueueListener) br.getCacheListener();
            listenerAttrs.put("Create" + i, listener.createList);
            listenerAttrs.put("Update" + i, listener.updateList);
            listenerAttrs.put("Destroy" + i, listener.destroyList);
        }
        return listenerAttrs;
    }

    public static HashMap checkQueue_BR(String senderId, int numBuckets) {
        Set<GatewaySender> senders = cache.getGatewaySenders();
        GatewaySender sender = null;
        for (GatewaySender s : senders) {
            if (s.getId().equals(senderId)) {
                sender = s;
                break;
            }
        }
        RegionQueue parallelQueue = ((AbstractGatewaySender) sender).getQueues().toArray(new RegionQueue[1])[0];

        PartitionedRegion region = (PartitionedRegion) parallelQueue.getRegion();
        HashMap listenerAttrs = new HashMap();
        for (int i = 0; i < numBuckets; i++) {
            BucketRegion br = region.getBucketRegion(i);
            if (br != null) {
                QueueListener listener = (QueueListener) br.getCacheListener();
                if (listener != null) {
                    listenerAttrs.put("Create" + i, listener.createList);
                    listenerAttrs.put("Update" + i, listener.updateList);
                    listenerAttrs.put("Destroy" + i, listener.destroyList);
                }
            }
        }
        return listenerAttrs;
    }

    public static void addListenerOnBucketRegion(String regionName, int numBuckets) {
        WANTestBase test = new WANTestBase();
        test.addCacheListenerOnBucketRegion(regionName, numBuckets);
    }

    private void addCacheListenerOnBucketRegion(String regionName, int numBuckets) {
        PartitionedRegion region = (PartitionedRegion) cache.getRegion(regionName);
        for (int i = 0; i < numBuckets; i++) {
            BucketRegion br = region.getBucketRegion(i);
            AttributesMutator mutator = br.getAttributesMutator();
            listener1 = new QueueListener();
            mutator.addCacheListener(listener1);
        }
    }

    public static void addListenerOnQueueBucketRegion(String senderId, int numBuckets) {
        WANTestBase test = new WANTestBase();
        test.addCacheListenerOnQueueBucketRegion(senderId, numBuckets);
    }

    private void addCacheListenerOnQueueBucketRegion(String senderId, int numBuckets) {
        Set<GatewaySender> senders = cache.getGatewaySenders();
        GatewaySender sender = null;
        for (GatewaySender s : senders) {
            if (s.getId().equals(senderId)) {
                sender = s;
                break;
            }
        }
        RegionQueue parallelQueue = ((AbstractGatewaySender) sender).getQueues().toArray(new RegionQueue[1])[0];

        PartitionedRegion region = (PartitionedRegion) parallelQueue.getRegion();
        for (int i = 0; i < numBuckets; i++) {
            BucketRegion br = region.getBucketRegion(i);
            if (br != null) {
                AttributesMutator mutator = br.getAttributesMutator();
                CacheListener listener = new QueueListener();
                mutator.addCacheListener(listener);
            }
        }

    }

    public static void addQueueListener(String senderId, boolean isParallel) {
        WANTestBase test = new WANTestBase();
        test.addCacheQueueListener(senderId, isParallel);
    }

    public static void addSecondQueueListener(String senderId, boolean isParallel) {
        WANTestBase test = new WANTestBase();
        test.addSecondCacheQueueListener(senderId, isParallel);
    }

    public static void addListenerOnRegion(String regionName) {
        WANTestBase test = new WANTestBase();
        test.addCacheListenerOnRegion(regionName);
    }

    private void addCacheListenerOnRegion(String regionName) {
        Region region = cache.getRegion(regionName);
        AttributesMutator mutator = region.getAttributesMutator();
        listener1 = new QueueListener();
        mutator.addCacheListener(listener1);
    }

    private void addCacheQueueListener(String senderId, boolean isParallel) {
        Set<GatewaySender> senders = cache.getGatewaySenders();
        GatewaySender sender = null;
        for (GatewaySender s : senders) {
            if (s.getId().equals(senderId)) {
                sender = s;
                break;
            }
        }
        listener1 = new QueueListener();
        if (!isParallel) {
            Set<RegionQueue> queues = ((AbstractGatewaySender) sender).getQueues();
            for (RegionQueue q : queues) {
                q.addCacheListener(listener1);
            }
        } else {
            RegionQueue parallelQueue = ((AbstractGatewaySender) sender).getQueues().toArray(new RegionQueue[1])[0];
            parallelQueue.addCacheListener(listener1);
        }
    }

    private void addSecondCacheQueueListener(String senderId, boolean isParallel) {
        Set<GatewaySender> senders = cache.getGatewaySenders();
        GatewaySender sender = null;
        for (GatewaySender s : senders) {
            if (s.getId().equals(senderId)) {
                sender = s;
                break;
            }
        }
        listener2 = new QueueListener();
        if (!isParallel) {
            Set<RegionQueue> queues = ((AbstractGatewaySender) sender).getQueues();
            for (RegionQueue q : queues) {
                q.addCacheListener(listener2);
            }
        } else {
            RegionQueue parallelQueue = ((AbstractGatewaySender) sender).getQueues().toArray(new RegionQueue[1])[0];
            parallelQueue.addCacheListener(listener2);
        }
    }

    public static void pauseSender(String senderId) {
        final IgnoredException exln = IgnoredException.addIgnoredException("Could not connect");
        IgnoredException exp = IgnoredException.addIgnoredException(ForceReattemptException.class.getName());
        try {
            Set<GatewaySender> senders = cache.getGatewaySenders();
            GatewaySender sender = null;
            for (GatewaySender s : senders) {
                if (s.getId().equals(senderId)) {
                    sender = s;
                    break;
                }
            }
            sender.pause();
            ((AbstractGatewaySender) sender).getEventProcessor().waitForDispatcherToPause();

        } finally {
            exp.remove();
            exln.remove();
        }
    }

    public static void resumeSender(String senderId) {
        final IgnoredException exln = IgnoredException.addIgnoredException("Could not connect");
        IgnoredException exp = IgnoredException.addIgnoredException(ForceReattemptException.class.getName());
        try {
            Set<GatewaySender> senders = cache.getGatewaySenders();
            GatewaySender sender = null;
            for (GatewaySender s : senders) {
                if (s.getId().equals(senderId)) {
                    sender = s;
                    break;
                }
            }
            sender.resume();
        } finally {
            exp.remove();
            exln.remove();
        }
    }

    public static void stopSender(String senderId) {
        final IgnoredException exln = IgnoredException.addIgnoredException("Could not connect");
        IgnoredException exp = IgnoredException.addIgnoredException(ForceReattemptException.class.getName());
        try {
            Set<GatewaySender> senders = cache.getGatewaySenders();
            GatewaySender sender = null;
            for (GatewaySender s : senders) {
                if (s.getId().equals(senderId)) {
                    sender = s;
                    break;
                }
            }
            AbstractGatewaySenderEventProcessor eventProcessor = null;
            if (sender instanceof AbstractGatewaySender) {
                eventProcessor = ((AbstractGatewaySender) sender).getEventProcessor();
            }
            sender.stop();

            Set<RegionQueue> queues = null;
            if (eventProcessor instanceof ConcurrentSerialGatewaySenderEventProcessor) {
                queues = ((ConcurrentSerialGatewaySenderEventProcessor) eventProcessor).getQueues();
                for (RegionQueue queue : queues) {
                    if (queue instanceof SerialGatewaySenderQueue) {
                        assertFalse(((SerialGatewaySenderQueue) queue).isRemovalThreadAlive());
                    }
                }
            }
        } finally {
            exp.remove();
            exln.remove();
        }
    }

    public static void stopReceivers() {
        Set<GatewayReceiver> receivers = cache.getGatewayReceivers();
        for (GatewayReceiver receiver : receivers) {
            receiver.stop();
        }
    }

    public static void startReceivers() {
        Set<GatewayReceiver> receivers = cache.getGatewayReceivers();
        for (GatewayReceiver receiver : receivers) {
            try {
                receiver.start();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }

    public static GatewaySenderFactory configureGateway(DiskStoreFactory dsf, File[] dirs1, String dsName,
            boolean isParallel, Integer maxMemory, Integer batchSize, boolean isConflation, boolean isPersistent,
            GatewayEventFilter filter, boolean isManualStart, int numDispatchers, OrderPolicy policy) {

        InternalGatewaySenderFactory gateway = (InternalGatewaySenderFactory) cache.createGatewaySenderFactory();
        gateway.setParallel(isParallel);
        gateway.setMaximumQueueMemory(maxMemory);
        gateway.setBatchSize(batchSize);
        gateway.setBatchConflationEnabled(isConflation);
        gateway.setManualStart(isManualStart);
        gateway.setDispatcherThreads(numDispatchers);
        gateway.setOrderPolicy(policy);
        gateway.setLocatorDiscoveryCallback(new MyLocatorCallback());
        if (filter != null) {
            eventFilter = filter;
            gateway.addGatewayEventFilter(filter);
        }
        if (isPersistent) {
            gateway.setPersistenceEnabled(true);
            gateway.setDiskStoreName(dsf.setDiskDirs(dirs1).create(dsName).getName());
        } else {
            DiskStore store = dsf.setDiskDirs(dirs1).create(dsName);
            gateway.setDiskStoreName(store.getName());
        }
        return gateway;
    }

    public static void createSender(String dsName, int remoteDsId, boolean isParallel, Integer maxMemory,
            Integer batchSize, boolean isConflation, boolean isPersistent, GatewayEventFilter filter,
            boolean isManualStart) {
        final IgnoredException exln = IgnoredException.addIgnoredException("Could not connect");
        try {
            File persistentDirectory = new File(
                    dsName + "_disk_" + System.currentTimeMillis() + "_" + VM.getCurrentVMNum());
            persistentDirectory.mkdir();
            DiskStoreFactory dsf = cache.createDiskStoreFactory();
            File[] dirs1 = new File[] { persistentDirectory };
            GatewaySenderFactory gateway = configureGateway(dsf, dirs1, dsName, isParallel, maxMemory, batchSize,
                    isConflation, isPersistent, filter, isManualStart, numDispatcherThreadsForTheRun,
                    GatewaySender.DEFAULT_ORDER_POLICY);
            gateway.create(dsName, remoteDsId);

        } finally {
            exln.remove();
        }
    }

    public static void createSenderWithMultipleDispatchers(String dsName, int remoteDsId, boolean isParallel,
            Integer maxMemory, Integer batchSize, boolean isConflation, boolean isPersistent,
            GatewayEventFilter filter, boolean isManualStart, int numDispatchers, OrderPolicy orderPolicy) {
        final IgnoredException exln = IgnoredException.addIgnoredException("Could not connect");
        try {
            File persistentDirectory = new File(
                    dsName + "_disk_" + System.currentTimeMillis() + "_" + VM.getCurrentVMNum());
            persistentDirectory.mkdir();
            DiskStoreFactory dsf = cache.createDiskStoreFactory();
            File[] dirs1 = new File[] { persistentDirectory };
            GatewaySenderFactory gateway = configureGateway(dsf, dirs1, dsName, isParallel, maxMemory, batchSize,
                    isConflation, isPersistent, filter, isManualStart, numDispatchers, orderPolicy);
            gateway.create(dsName, remoteDsId);

        } finally {
            exln.remove();
        }
    }

    public static void createSenderWithoutDiskStore(String dsName, int remoteDsId, Integer maxMemory,
            Integer batchSize, boolean isConflation, boolean isManualStart) {

        GatewaySenderFactory gateway = cache.createGatewaySenderFactory();
        gateway.setParallel(true);
        gateway.setMaximumQueueMemory(maxMemory);
        gateway.setBatchSize(batchSize);
        gateway.setManualStart(isManualStart);
        // set dispatcher threads
        gateway.setDispatcherThreads(numDispatcherThreadsForTheRun);
        gateway.setBatchConflationEnabled(isConflation);
        gateway.create(dsName, remoteDsId);
    }

    public static void createConcurrentSender(String dsName, int remoteDsId, boolean isParallel, Integer maxMemory,
            Integer batchSize, boolean isConflation, boolean isPersistent, GatewayEventFilter filter,
            boolean isManualStart, int concurrencyLevel, OrderPolicy policy) {

        File persistentDirectory = new File(
                dsName + "_disk_" + System.currentTimeMillis() + "_" + VM.getCurrentVMNum());
        persistentDirectory.mkdir();
        DiskStoreFactory dsf = cache.createDiskStoreFactory();
        File[] dirs1 = new File[] { persistentDirectory };
        GatewaySenderFactory gateway = configureGateway(dsf, dirs1, dsName, isParallel, maxMemory, batchSize,
                isConflation, isPersistent, filter, isManualStart, concurrencyLevel, policy);
        gateway.create(dsName, remoteDsId);
    }

    public static void createSenderForValidations(String dsName, int remoteDsId, boolean isParallel,
            Integer alertThreshold, boolean isConflation, boolean isPersistent,
            List<GatewayEventFilter> eventFilters, List<GatewayTransportFilter> transportFilters,
            boolean isManualStart, boolean isDiskSync) {
        IgnoredException exp1 = IgnoredException.addIgnoredException(RegionDestroyedException.class.getName());
        try {
            File persistentDirectory = new File(
                    dsName + "_disk_" + System.currentTimeMillis() + "_" + VM.getCurrentVMNum());
            persistentDirectory.mkdir();
            DiskStoreFactory dsf = cache.createDiskStoreFactory();
            File[] dirs1 = new File[] { persistentDirectory };

            if (isParallel) {
                GatewaySenderFactory gateway = cache.createGatewaySenderFactory();
                gateway.setParallel(true);
                gateway.setAlertThreshold(alertThreshold);
                ((InternalGatewaySenderFactory) gateway).setLocatorDiscoveryCallback(new MyLocatorCallback());
                if (eventFilters != null) {
                    for (GatewayEventFilter filter : eventFilters) {
                        gateway.addGatewayEventFilter(filter);
                    }
                }
                if (transportFilters != null) {
                    for (GatewayTransportFilter filter : transportFilters) {
                        gateway.addGatewayTransportFilter(filter);
                    }
                }
                if (isPersistent) {
                    gateway.setPersistenceEnabled(true);
                    gateway.setDiskStoreName(dsf.setDiskDirs(dirs1).create(dsName + "_Parallel").getName());
                } else {
                    DiskStore store = dsf.setDiskDirs(dirs1).create(dsName + "_Parallel");
                    gateway.setDiskStoreName(store.getName());
                }
                gateway.setDiskSynchronous(isDiskSync);
                gateway.setBatchConflationEnabled(isConflation);
                gateway.setManualStart(isManualStart);
                // set dispatcher threads
                gateway.setDispatcherThreads(numDispatcherThreadsForTheRun);
                gateway.create(dsName, remoteDsId);

            } else {
                GatewaySenderFactory gateway = cache.createGatewaySenderFactory();
                gateway.setAlertThreshold(alertThreshold);
                gateway.setManualStart(isManualStart);
                // set dispatcher threads
                gateway.setDispatcherThreads(numDispatcherThreadsForTheRun);
                ((InternalGatewaySenderFactory) gateway).setLocatorDiscoveryCallback(new MyLocatorCallback());
                if (eventFilters != null) {
                    for (GatewayEventFilter filter : eventFilters) {
                        gateway.addGatewayEventFilter(filter);
                    }
                }
                if (transportFilters != null) {
                    for (GatewayTransportFilter filter : transportFilters) {
                        gateway.addGatewayTransportFilter(filter);
                    }
                }
                gateway.setBatchConflationEnabled(isConflation);
                if (isPersistent) {
                    gateway.setPersistenceEnabled(true);
                    gateway.setDiskStoreName(dsf.setDiskDirs(dirs1).create(dsName + "_Serial").getName());
                } else {
                    DiskStore store = dsf.setDiskDirs(dirs1).create(dsName + "_Serial");
                    gateway.setDiskStoreName(store.getName());
                }
                gateway.setDiskSynchronous(isDiskSync);
                gateway.create(dsName, remoteDsId);
            }
        } finally {
            exp1.remove();
        }
    }

    public static String createSenderWithDiskStore(String dsName, int remoteDsId, boolean isParallel,
            Integer maxMemory, Integer batchSize, boolean isConflation, boolean isPersistent,
            GatewayEventFilter filter, String dsStore, boolean isManualStart) {
        File persistentDirectory = null;
        if (dsStore == null) {
            persistentDirectory = new File(
                    dsName + "_disk_" + System.currentTimeMillis() + "_" + VM.getCurrentVMNum());
        } else {
            persistentDirectory = new File(dsStore);
        }
        LogWriterUtils.getLogWriter().info("The ds is : " + persistentDirectory.getName());

        persistentDirectory.mkdir();
        DiskStoreFactory dsf = cache.createDiskStoreFactory();
        File[] dirs1 = new File[] { persistentDirectory };

        if (isParallel) {
            GatewaySenderFactory gateway = cache.createGatewaySenderFactory();
            gateway.setParallel(true);
            gateway.setMaximumQueueMemory(maxMemory);
            gateway.setBatchSize(batchSize);
            gateway.setManualStart(isManualStart);
            // set dispatcher threads
            gateway.setDispatcherThreads(numDispatcherThreadsForTheRun);
            ((InternalGatewaySenderFactory) gateway).setLocatorDiscoveryCallback(new MyLocatorCallback());
            if (filter != null) {
                gateway.addGatewayEventFilter(filter);
            }
            if (isPersistent) {
                gateway.setPersistenceEnabled(true);
                String dsname = dsf.setDiskDirs(dirs1).create(dsName).getName();
                gateway.setDiskStoreName(dsname);
                LogWriterUtils.getLogWriter().info("The DiskStoreName is : " + dsname);
            } else {
                DiskStore store = dsf.setDiskDirs(dirs1).create(dsName);
                gateway.setDiskStoreName(store.getName());
                LogWriterUtils.getLogWriter().info("The ds is : " + store.getName());
            }
            gateway.setBatchConflationEnabled(isConflation);
            gateway.create(dsName, remoteDsId);

        } else {
            GatewaySenderFactory gateway = cache.createGatewaySenderFactory();
            gateway.setMaximumQueueMemory(maxMemory);
            gateway.setBatchSize(batchSize);
            gateway.setManualStart(isManualStart);
            // set dispatcher threads
            gateway.setDispatcherThreads(numDispatcherThreadsForTheRun);
            ((InternalGatewaySenderFactory) gateway).setLocatorDiscoveryCallback(new MyLocatorCallback());
            if (filter != null) {
                gateway.addGatewayEventFilter(filter);
            }
            gateway.setBatchConflationEnabled(isConflation);
            if (isPersistent) {
                gateway.setPersistenceEnabled(true);
                gateway.setDiskStoreName(dsf.setDiskDirs(dirs1).create(dsName).getName());
            } else {
                DiskStore store = dsf.setDiskDirs(dirs1).create(dsName);

                gateway.setDiskStoreName(store.getName());
            }
            gateway.create(dsName, remoteDsId);
        }
        return persistentDirectory.getName();
    }

    public static void createSenderWithListener(String dsName, int remoteDsName, boolean isParallel,
            Integer maxMemory, Integer batchSize, boolean isConflation, boolean isPersistent,
            GatewayEventFilter filter, boolean attachTwoListeners, boolean isManualStart) {
        File persistentDirectory = new File(
                dsName + "_disk_" + System.currentTimeMillis() + "_" + VM.getCurrentVMNum());
        persistentDirectory.mkdir();
        DiskStoreFactory dsf = cache.createDiskStoreFactory();
        File[] dirs1 = new File[] { persistentDirectory };

        if (isParallel) {
            GatewaySenderFactory gateway = cache.createGatewaySenderFactory();
            gateway.setParallel(true);
            gateway.setMaximumQueueMemory(maxMemory);
            gateway.setBatchSize(batchSize);
            gateway.setManualStart(isManualStart);
            // set dispatcher threads
            gateway.setDispatcherThreads(numDispatcherThreadsForTheRun);
            ((InternalGatewaySenderFactory) gateway).setLocatorDiscoveryCallback(new MyLocatorCallback());
            if (filter != null) {
                gateway.addGatewayEventFilter(filter);
            }
            if (isPersistent) {
                gateway.setPersistenceEnabled(true);
                gateway.setDiskStoreName(dsf.setDiskDirs(dirs1).create(dsName).getName());
            } else {
                DiskStore store = dsf.setDiskDirs(dirs1).create(dsName);
                gateway.setDiskStoreName(store.getName());
            }
            gateway.setBatchConflationEnabled(isConflation);
            gateway.create(dsName, remoteDsName);

        } else {
            GatewaySenderFactory gateway = cache.createGatewaySenderFactory();
            gateway.setMaximumQueueMemory(maxMemory);
            gateway.setBatchSize(batchSize);
            gateway.setManualStart(isManualStart);
            // set dispatcher threads
            gateway.setDispatcherThreads(numDispatcherThreadsForTheRun);
            ((InternalGatewaySenderFactory) gateway).setLocatorDiscoveryCallback(new MyLocatorCallback());
            if (filter != null) {
                gateway.addGatewayEventFilter(filter);
            }
            gateway.setBatchConflationEnabled(isConflation);
            if (isPersistent) {
                gateway.setPersistenceEnabled(true);
                gateway.setDiskStoreName(dsf.setDiskDirs(dirs1).create(dsName).getName());
            } else {
                DiskStore store = dsf.setDiskDirs(dirs1).create(dsName);
                gateway.setDiskStoreName(store.getName());
            }

            eventListener1 = new MyGatewaySenderEventListener();
            ((InternalGatewaySenderFactory) gateway).addAsyncEventListener(eventListener1);
            if (attachTwoListeners) {
                eventListener2 = new MyGatewaySenderEventListener2();
                ((InternalGatewaySenderFactory) gateway).addAsyncEventListener(eventListener2);
            }
            ((InternalGatewaySenderFactory) gateway).create(dsName);
        }
    }

    public static void createReceiverInVMs(VM... vms) {
        for (VM vm : vms) {
            vm.invoke(() -> createReceiver());
        }
    }

    public static int createReceiver() {
        GatewayReceiverFactory fact = cache.createGatewayReceiverFactory();
        int port = AvailablePortHelper.getRandomAvailablePortForDUnitSite();
        fact.setStartPort(port);
        fact.setEndPort(port);
        fact.setManualStart(true);
        GatewayReceiver receiver = fact.create();
        try {
            receiver.start();
        } catch (IOException e) {
            e.printStackTrace();
            Assert.fail("Test " + getTestMethodName() + " failed to start GatewayReceiver on port " + port, e);
        }
        return port;
    }

    public static void createReceiverWithBindAddress(int locPort) {
        WANTestBase test = new WANTestBase();
        Properties props = test.getDistributedSystemProperties();
        props.setProperty(MCAST_PORT, "0");
        props.setProperty(LOG_LEVEL, LogWriterUtils.getDUnitLogLevel());
        props.setProperty(LOCATORS, "localhost[" + locPort + "]");

        InternalDistributedSystem ds = test.getSystem(props);
        cache = CacheFactory.create(ds);
        GatewayReceiverFactory fact = cache.createGatewayReceiverFactory();
        int port = AvailablePortHelper.getRandomAvailablePortForDUnitSite();
        fact.setStartPort(port);
        fact.setEndPort(port);
        fact.setManualStart(true);
        fact.setBindAddress("200.112.204.10");
        GatewayReceiver receiver = fact.create();
        try {
            receiver.start();
            fail("Expected GatewayReceiver Exception");
        } catch (GatewayReceiverException gRE) {
            LogWriterUtils.getLogWriter().fine("Got the GatewayReceiverException", gRE);
            assertTrue(gRE.getMessage().contains("Failed to create server socket on"));
        } catch (IOException e) {
            e.printStackTrace();
            fail("Test " + test.getName() + " failed to start GatewayReceiver on port " + port);
        }
    }

    public static int createReceiverWithSSL(int locPort) {
        WANTestBase test = new WANTestBase();

        Properties gemFireProps = test.getDistributedSystemProperties();

        gemFireProps.put(LOG_LEVEL, LogWriterUtils.getDUnitLogLevel());
        gemFireProps.put(GATEWAY_SSL_ENABLED, "true");
        gemFireProps.put(GATEWAY_SSL_PROTOCOLS, "any");
        gemFireProps.put(GATEWAY_SSL_CIPHERS, "any");
        gemFireProps.put(GATEWAY_SSL_REQUIRE_AUTHENTICATION, "true");

        gemFireProps.put(GATEWAY_SSL_KEYSTORE_TYPE, "jks");
        gemFireProps.put(GATEWAY_SSL_KEYSTORE, TestUtil.getResourcePath(WANTestBase.class,
                "/org/apache/geode/cache/client/internal/cacheserver.keystore"));
        gemFireProps.put(GATEWAY_SSL_KEYSTORE_PASSWORD, "password");
        gemFireProps.put(GATEWAY_SSL_TRUSTSTORE, TestUtil.getResourcePath(WANTestBase.class,
                "/org/apache/geode/cache/client/internal/cacheserver.truststore"));
        gemFireProps.put(GATEWAY_SSL_TRUSTSTORE_PASSWORD, "password");

        gemFireProps.setProperty(MCAST_PORT, "0");
        gemFireProps.setProperty(LOCATORS, "localhost[" + locPort + "]");

        LogWriterUtils.getLogWriter().info("Starting cache ds with following properties \n" + gemFireProps);

        InternalDistributedSystem ds = test.getSystem(gemFireProps);
        cache = CacheFactory.create(ds);
        GatewayReceiverFactory fact = cache.createGatewayReceiverFactory();
        int port = AvailablePortHelper.getRandomAvailablePortForDUnitSite();
        fact.setStartPort(port);
        fact.setEndPort(port);
        fact.setManualStart(true);
        GatewayReceiver receiver = fact.create();
        try {
            receiver.start();
        } catch (IOException e) {
            e.printStackTrace();
            fail("Test " + test.getName() + " failed to start GatewayReceiver on port " + port);
        }
        return port;
    }

    public static void createReceiverAndServer(int locPort) {
        WANTestBase test = new WANTestBase();
        Properties props = test.getDistributedSystemProperties();
        props.setProperty(MCAST_PORT, "0");
        props.setProperty(LOCATORS, "localhost[" + locPort + "]");

        InternalDistributedSystem ds = test.getSystem(props);
        cache = CacheFactory.create(ds);
        GatewayReceiverFactory fact = cache.createGatewayReceiverFactory();
        int receiverPort = AvailablePortHelper.getRandomAvailablePortForDUnitSite();
        fact.setStartPort(receiverPort);
        fact.setEndPort(receiverPort);
        fact.setManualStart(true);
        GatewayReceiver receiver = fact.create();
        try {
            receiver.start();
        } catch (IOException e) {
            e.printStackTrace();
            fail("Test " + test.getName() + " failed to start GatewayReceiver on port " + receiverPort);
        }
        CacheServer server = cache.addCacheServer();
        int serverPort = AvailablePort.getRandomAvailablePort(AvailablePort.SOCKET);
        server.setPort(serverPort);
        server.setHostnameForClients("localhost");
        try {
            server.start();
        } catch (IOException e) {
            org.apache.geode.test.dunit.Assert.fail("Failed to start server ", e);
        }
    }

    public static int createServer(int locPort) {
        WANTestBase test = new WANTestBase();
        Properties props = test.getDistributedSystemProperties();
        props.setProperty(MCAST_PORT, "0");
        props.setProperty(LOCATORS, "localhost[" + locPort + "]");
        InternalDistributedSystem ds = test.getSystem(props);
        cache = CacheFactory.create(ds);

        CacheServer server = cache.addCacheServer();
        int port = AvailablePort.getRandomAvailablePort(AvailablePort.SOCKET);
        server.setPort(port);
        server.setHostnameForClients("localhost");
        try {
            server.start();
        } catch (IOException e) {
            org.apache.geode.test.dunit.Assert.fail("Failed to start server ", e);
        }
        return port;
    }

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

        AttributesFactory factory = new AttributesFactory();
        factory.setPoolName("pool");
        factory.setDataPolicy(DataPolicy.NORMAL);
        RegionAttributes attrs = factory.create();
        region = cache.createRegion(regionName, attrs);
        region.registerInterest("ALL_KEYS");
        assertNotNull(region);
        LogWriterUtils.getLogWriter()
                .info("Distributed Region " + regionName + " created Successfully :" + region.toString());
    }

    public static void createClientWithLocator(final int port0, final String host) {
        WANTestBase test = new WANTestBase();
        Properties props = test.getDistributedSystemProperties();
        props.setProperty(MCAST_PORT, "0");
        props.setProperty(LOCATORS, "");

        InternalDistributedSystem ds = test.getSystem(props);
        cache = CacheFactory.create(ds);

        assertNotNull(cache);
        CacheServerTestUtil.disableShufflingOfEndpoints();
        Pool p;
        try {
            p = PoolManager.createFactory().addLocator(host, port0).setPingInterval(250)
                    .setSubscriptionEnabled(true).setSubscriptionRedundancy(-1).setReadTimeout(20000)
                    .setSocketBufferSize(1000).setMinConnections(6).setMaxConnections(10).setRetryAttempts(3)
                    .create("pool");
        } finally {
            CacheServerTestUtil.enableShufflingOfEndpoints();
        }
    }

    public static int createReceiver_PDX(int locPort) {
        WANTestBase test = new WANTestBase();
        Properties props = test.getDistributedSystemProperties();
        props.setProperty(MCAST_PORT, "0");
        props.setProperty(LOCATORS, "localhost[" + locPort + "]");
        InternalDistributedSystem ds = test.getSystem(props);
        CacheConfig cacheConfig = new CacheConfig();
        File pdxDir = new File(CacheTestCase.getDiskDir(), "pdx");
        cacheConfig.setPdxPersistent(true);
        cacheConfig.setPdxDiskStore("pdxStore");
        cache = GemFireCacheImpl.create(ds, false, cacheConfig);
        cache.createDiskStoreFactory().setDiskDirs(new File[] { pdxDir }).setMaxOplogSize(1).create("pdxStore");
        GatewayReceiverFactory fact = cache.createGatewayReceiverFactory();
        int port = AvailablePortHelper.getRandomAvailablePortForDUnitSite();
        fact.setStartPort(port);
        fact.setEndPort(port);
        fact.setManualStart(true);
        GatewayReceiver receiver = fact.create();
        try {
            receiver.start();
        } catch (IOException e) {
            e.printStackTrace();
            fail("Test " + test.getName() + " failed to start GatewayReceiver on port " + port);
        }
        return port;
    }

    public static void doDistTXPuts(String regionName, int numPuts) {
        CacheTransactionManager txMgr = cache.getCacheTransactionManager();
        txMgr.setDistributed(true);

        IgnoredException exp1 = IgnoredException.addIgnoredException(InterruptedException.class.getName());
        IgnoredException exp2 = IgnoredException.addIgnoredException(GatewaySenderException.class.getName());
        try {
            Region r = cache.getRegion(Region.SEPARATOR + regionName);
            assertNotNull(r);
            for (long i = 1; i <= numPuts; i++) {
                txMgr.begin();
                r.put(i, i);
                txMgr.commit();
            }
        } finally {
            exp1.remove();
            exp2.remove();
        }
    }

    public static void doPuts(String regionName, int numPuts, Object value) {
        IgnoredException exp1 = IgnoredException.addIgnoredException(InterruptedException.class.getName());
        IgnoredException exp2 = IgnoredException.addIgnoredException(GatewaySenderException.class.getName());
        try {
            Region r = cache.getRegion(Region.SEPARATOR + regionName);
            assertNotNull(r);
            for (long i = 0; i < numPuts; i++) {
                r.put(i, value);
            }
        } finally {
            exp1.remove();
            exp2.remove();
        }
    }

    public static void doPuts(String regionName, int numPuts) {
        IgnoredException exp1 = IgnoredException.addIgnoredException(InterruptedException.class.getName());
        IgnoredException exp2 = IgnoredException.addIgnoredException(GatewaySenderException.class.getName());
        try {
            Region r = cache.getRegion(Region.SEPARATOR + regionName);
            assertNotNull(r);
            for (long i = 0; i < numPuts; i++) {
                r.put(i, i);
            }
        } finally {
            exp1.remove();
            exp2.remove();
        }
    }

    public static void doPutsAfter300(String regionName, int numPuts) {
        Region r = cache.getRegion(Region.SEPARATOR + regionName);
        assertNotNull(r);
        for (long i = 300; i < numPuts; i++) {
            r.put(i, i);
        }
    }

    public static void doPutsFrom(String regionName, int from, int numPuts) {
        Region r = cache.getRegion(Region.SEPARATOR + regionName);
        assertNotNull(r);
        for (long i = from; i < numPuts; i++) {
            r.put(i, i);
        }
    }

    public static void doDestroys(String regionName, int keyNum) {
        Region r = cache.getRegion(Region.SEPARATOR + regionName);
        assertNotNull(r);
        for (long i = 0; i < keyNum; i++) {
            r.destroy(i);
        }
    }

    public static void doPutAll(String regionName, int numPuts, int size) {
        Region r = cache.getRegion(Region.SEPARATOR + regionName);
        assertNotNull(r);
        for (long i = 0; i < numPuts; i++) {
            Map putAllMap = new HashMap();
            for (long j = 0; j < size; j++) {
                putAllMap.put((size * i) + j, i);
            }
            r.putAll(putAllMap, "putAllCallback");
            putAllMap.clear();
        }
    }

    public static void doPutsWithKeyAsString(String regionName, int numPuts) {
        Region r = cache.getRegion(Region.SEPARATOR + regionName);
        assertNotNull(r);
        for (long i = 0; i < numPuts; i++) {
            r.put("Object_" + i, i);
        }
    }

    public static void putGivenKeyValue(String regionName, Map keyValues) {
        Region r = cache.getRegion(Region.SEPARATOR + regionName);
        assertNotNull(r);
        for (Object key : keyValues.keySet()) {
            r.put(key, keyValues.get(key));
        }
    }

    public static void destroyRegion(String regionName) {
        destroyRegion(regionName, -1);
    }

    public static void destroyRegion(String regionName, final int min) {
        final Region r = cache.getRegion(Region.SEPARATOR + regionName);
        assertNotNull(r);
        Awaitility.await().atMost(30, TimeUnit.SECONDS).until(() -> r.size() > min);
        r.destroyRegion();
    }

    public static void localDestroyRegion(String regionName) {
        IgnoredException exp = IgnoredException.addIgnoredException(PRLocallyDestroyedException.class.getName());
        try {
            Region r = cache.getRegion(Region.SEPARATOR + regionName);
            assertNotNull(r);
            r.localDestroyRegion();
        } finally {
            exp.remove();
        }
    }

    public static Map putCustomerPartitionedRegion(int numPuts) {
        String valueSuffix = "";
        return putCustomerPartitionedRegion(numPuts, valueSuffix);
    }

    public static Map updateCustomerPartitionedRegion(int numPuts) {
        String valueSuffix = "_update";
        return putCustomerPartitionedRegion(numPuts, valueSuffix);
    }

    protected static Map putCustomerPartitionedRegion(int numPuts, String valueSuffix) {
        assertNotNull(cache);
        assertNotNull(customerRegion);
        Map custKeyValues = new HashMap();
        for (int i = 1; i <= numPuts; i++) {
            CustId custid = new CustId(i);
            Customer customer = new Customer("name" + i, "Address" + i + valueSuffix);
            try {
                customerRegion.put(custid, customer);
                assertTrue(customerRegion.containsKey(custid));
                assertEquals(customer, customerRegion.get(custid));
                custKeyValues.put(custid, customer);
            } catch (Exception e) {
                org.apache.geode.test.dunit.Assert.fail(
                        "putCustomerPartitionedRegion : failed while doing put operation in CustomerPartitionedRegion ",
                        e);
            }
            LogWriterUtils.getLogWriter().info("Customer :- { " + custid + " : " + customer + " }");
        }
        return custKeyValues;
    }

    public static Map putOrderPartitionedRegion(int numPuts) {
        assertNotNull(cache);
        assertNotNull(orderRegion);
        Map orderKeyValues = new HashMap();
        for (int i = 1; i <= numPuts; i++) {
            CustId custid = new CustId(i);
            int oid = i + 1;
            OrderId orderId = new OrderId(oid, custid);
            Order order = new Order("ORDER" + oid);
            try {
                orderRegion.put(orderId, order);
                orderKeyValues.put(orderId, order);
                assertTrue(orderRegion.containsKey(orderId));
                assertEquals(order, orderRegion.get(orderId));

            } catch (Exception e) {
                org.apache.geode.test.dunit.Assert.fail(
                        "putOrderPartitionedRegion : failed while doing put operation in OrderPartitionedRegion ",
                        e);
            }
            LogWriterUtils.getLogWriter().info("Order :- { " + orderId + " : " + order + " }");
        }
        return orderKeyValues;
    }

    public static Map putOrderPartitionedRegionUsingCustId(int numPuts) {
        assertNotNull(cache);
        assertNotNull(orderRegion);
        Map orderKeyValues = new HashMap();
        for (int i = 1; i <= numPuts; i++) {
            CustId custid = new CustId(i);
            Order order = new Order("ORDER" + i);
            try {
                orderRegion.put(custid, order);
                orderKeyValues.put(custid, order);
                assertTrue(orderRegion.containsKey(custid));
                assertEquals(order, orderRegion.get(custid));

            } catch (Exception e) {
                org.apache.geode.test.dunit.Assert.fail(
                        "putOrderPartitionedRegionUsingCustId : failed while doing put operation in OrderPartitionedRegion ",
                        e);
            }
            LogWriterUtils.getLogWriter().info("Order :- { " + custid + " : " + order + " }");
        }
        return orderKeyValues;
    }

    public static Map updateOrderPartitionedRegion(int numPuts) {
        assertNotNull(cache);
        assertNotNull(orderRegion);
        Map orderKeyValues = new HashMap();
        for (int i = 1; i <= numPuts; i++) {
            CustId custid = new CustId(i);
            int oid = i + 1;
            OrderId orderId = new OrderId(oid, custid);
            Order order = new Order("ORDER" + oid + "_update");
            try {
                orderRegion.put(orderId, order);
                orderKeyValues.put(orderId, order);
                assertTrue(orderRegion.containsKey(orderId));
                assertEquals(order, orderRegion.get(orderId));

            } catch (Exception e) {
                org.apache.geode.test.dunit.Assert.fail(
                        "updateOrderPartitionedRegion : failed while doing put operation in OrderPartitionedRegion ",
                        e);
            }
            LogWriterUtils.getLogWriter().info("Order :- { " + orderId + " : " + order + " }");
        }
        return orderKeyValues;
    }

    public static Map updateOrderPartitionedRegionUsingCustId(int numPuts) {
        assertNotNull(cache);
        assertNotNull(orderRegion);
        Map orderKeyValues = new HashMap();
        for (int i = 1; i <= numPuts; i++) {
            CustId custid = new CustId(i);
            Order order = new Order("ORDER" + i + "_update");
            try {
                orderRegion.put(custid, order);
                assertTrue(orderRegion.containsKey(custid));
                assertEquals(order, orderRegion.get(custid));
                orderKeyValues.put(custid, order);
            } catch (Exception e) {
                org.apache.geode.test.dunit.Assert.fail(
                        "updateOrderPartitionedRegionUsingCustId : failed while doing put operation in OrderPartitionedRegion ",
                        e);
            }
            LogWriterUtils.getLogWriter().info("Order :- { " + custid + " : " + order + " }");
        }
        return orderKeyValues;
    }

    public static Map putShipmentPartitionedRegion(int numPuts) {
        assertNotNull(cache);
        assertNotNull(shipmentRegion);
        Map shipmentKeyValue = new HashMap();
        for (int i = 1; i <= numPuts; i++) {
            CustId custid = new CustId(i);
            int oid = i + 1;
            OrderId orderId = new OrderId(oid, custid);
            int sid = oid + 1;
            ShipmentId shipmentId = new ShipmentId(sid, orderId);
            Shipment shipment = new Shipment("Shipment" + sid);
            try {
                shipmentRegion.put(shipmentId, shipment);
                assertTrue(shipmentRegion.containsKey(shipmentId));
                assertEquals(shipment, shipmentRegion.get(shipmentId));
                shipmentKeyValue.put(shipmentId, shipment);
            } catch (Exception e) {
                org.apache.geode.test.dunit.Assert.fail(
                        "putShipmentPartitionedRegion : failed while doing put operation in ShipmentPartitionedRegion ",
                        e);
            }
            LogWriterUtils.getLogWriter().info("Shipment :- { " + shipmentId + " : " + shipment + " }");
        }
        return shipmentKeyValue;
    }

    public static void putcolocatedPartitionedRegion(int numPuts) {
        assertNotNull(cache);
        assertNotNull(customerRegion);
        assertNotNull(orderRegion);
        assertNotNull(shipmentRegion);
        for (int i = 1; i <= numPuts; i++) {
            CustId custid = new CustId(i);
            Customer customer = new Customer("Customer" + custid, "Address" + custid);
            customerRegion.put(custid, customer);
            int oid = i + 1;
            OrderId orderId = new OrderId(oid, custid);
            Order order = new Order("Order" + orderId);
            orderRegion.put(orderId, order);
            int sid = oid + 1;
            ShipmentId shipmentId = new ShipmentId(sid, orderId);
            Shipment shipment = new Shipment("Shipment" + sid);
            shipmentRegion.put(shipmentId, shipment);
        }
    }

    public static Map putShipmentPartitionedRegionUsingCustId(int numPuts) {
        assertNotNull(cache);
        assertNotNull(shipmentRegion);
        Map shipmentKeyValue = new HashMap();
        for (int i = 1; i <= numPuts; i++) {
            CustId custid = new CustId(i);
            Shipment shipment = new Shipment("Shipment" + i);
            try {
                shipmentRegion.put(custid, shipment);
                assertTrue(shipmentRegion.containsKey(custid));
                assertEquals(shipment, shipmentRegion.get(custid));
                shipmentKeyValue.put(custid, shipment);
            } catch (Exception e) {
                org.apache.geode.test.dunit.Assert.fail(
                        "putShipmentPartitionedRegionUsingCustId : failed while doing put operation in ShipmentPartitionedRegion ",
                        e);
            }
            LogWriterUtils.getLogWriter().info("Shipment :- { " + custid + " : " + shipment + " }");
        }
        return shipmentKeyValue;
    }

    public static Map updateShipmentPartitionedRegion(int numPuts) {
        assertNotNull(cache);
        assertNotNull(shipmentRegion);
        Map shipmentKeyValue = new HashMap();
        for (int i = 1; i <= numPuts; i++) {
            CustId custid = new CustId(i);
            int oid = i + 1;
            OrderId orderId = new OrderId(oid, custid);
            int sid = oid + 1;
            ShipmentId shipmentId = new ShipmentId(sid, orderId);
            Shipment shipment = new Shipment("Shipment" + sid + "_update");
            try {
                shipmentRegion.put(shipmentId, shipment);
                assertTrue(shipmentRegion.containsKey(shipmentId));
                assertEquals(shipment, shipmentRegion.get(shipmentId));
                shipmentKeyValue.put(shipmentId, shipment);
            } catch (Exception e) {
                org.apache.geode.test.dunit.Assert.fail(
                        "updateShipmentPartitionedRegion : failed while doing put operation in ShipmentPartitionedRegion ",
                        e);
            }
            LogWriterUtils.getLogWriter().info("Shipment :- { " + shipmentId + " : " + shipment + " }");
        }
        return shipmentKeyValue;
    }

    public static Map updateShipmentPartitionedRegionUsingCustId(int numPuts) {
        assertNotNull(cache);
        assertNotNull(shipmentRegion);
        Map shipmentKeyValue = new HashMap();
        for (int i = 1; i <= numPuts; i++) {
            CustId custid = new CustId(i);
            Shipment shipment = new Shipment("Shipment" + i + "_update");
            try {
                shipmentRegion.put(custid, shipment);
                assertTrue(shipmentRegion.containsKey(custid));
                assertEquals(shipment, shipmentRegion.get(custid));
                shipmentKeyValue.put(custid, shipment);
            } catch (Exception e) {
                org.apache.geode.test.dunit.Assert.fail(
                        "updateShipmentPartitionedRegionUsingCustId : failed while doing put operation in ShipmentPartitionedRegion ",
                        e);
            }
            LogWriterUtils.getLogWriter().info("Shipment :- { " + custid + " : " + shipment + " }");
        }
        return shipmentKeyValue;
    }

    public static void doPutsPDXSerializable(String regionName, int numPuts) {
        Region r = cache.getRegion(Region.SEPARATOR + regionName);
        assertNotNull(r);
        for (int i = 0; i < numPuts; i++) {
            r.put("Key_" + i, new SimpleClass(i, (byte) i));
        }
    }

    public static void doPutsPDXSerializable2(String regionName, int numPuts) {
        Region r = cache.getRegion(Region.SEPARATOR + regionName);
        assertNotNull(r);
        for (int i = 0; i < numPuts; i++) {
            r.put("Key_" + i, new SimpleClass1(false, (short) i, "" + i, i, "" + i, "" + i, i, i));
        }
    }

    public static void doTxPuts(String regionName) {
        Region r = cache.getRegion(Region.SEPARATOR + regionName);
        assertNotNull(r);
        CacheTransactionManager mgr = cache.getCacheTransactionManager();

        mgr.begin();
        r.put(0, 0);
        r.put(100, 100);
        r.put(200, 200);
        mgr.commit();
    }

    public static void doNextPuts(String regionName, int start, int numPuts) {
        IgnoredException exp = IgnoredException.addIgnoredException(CacheClosedException.class.getName());
        try {
            Region r = cache.getRegion(Region.SEPARATOR + regionName);
            assertNotNull(r);
            for (long i = start; i < numPuts; i++) {
                r.put(i, i);
            }
        } finally {
            exp.remove();
        }
    }

    public static void checkQueueSize(String senderId, int numQueueEntries) {
        Awaitility.await().atMost(10, TimeUnit.SECONDS).until(() -> testQueueSize(senderId, numQueueEntries));
    }

    public static void testQueueSize(String senderId, int numQueueEntries) {
        GatewaySender sender = null;
        for (GatewaySender s : cache.getGatewaySenders()) {
            if (s.getId().equals(senderId)) {
                sender = s;
                break;
            }
        }
        if (sender.isParallel()) {
            int totalSize = 0;
            Set<RegionQueue> queues = ((AbstractGatewaySender) sender).getQueues();
            for (RegionQueue q : queues) {
                ConcurrentParallelGatewaySenderQueue prQ = (ConcurrentParallelGatewaySenderQueue) q;
                totalSize += prQ.size();
            }
            assertEquals(numQueueEntries, totalSize);
        } else {
            Set<RegionQueue> queues = ((AbstractGatewaySender) sender).getQueues();
            int size = 0;
            for (RegionQueue q : queues) {
                size += q.size();
            }
            assertEquals(numQueueEntries, size);
        }
    }

    /**
     * To be used only for ParallelGatewaySender.
     * 
     * @param senderId Id of the ParallelGatewaySender
     * @param numQueueEntries Expected number of ParallelGatewaySenderQueue entries
     */
    public static void checkPRQLocalSize(String senderId, final int numQueueEntries) {
        GatewaySender sender = null;
        for (GatewaySender s : cache.getGatewaySenders()) {
            if (s.getId().equals(senderId)) {
                sender = s;
                break;
            }
        }

        if (sender.isParallel()) {
            final Set<RegionQueue> queues = ((AbstractGatewaySender) sender).getQueues();
            Awaitility.await().atMost(120, TimeUnit.SECONDS).until(() -> {
                int size = 0;
                for (RegionQueue q : queues) {
                    ConcurrentParallelGatewaySenderQueue prQ = (ConcurrentParallelGatewaySenderQueue) q;
                    size += prQ.localSize();
                }
                assertEquals(" Expected local queue entries: " + numQueueEntries + " but actual entries: " + size,
                        numQueueEntries, size);
            });
        }
    }

    /**
     * To be used only for ParallelGatewaySender.
     * 
     * @param senderId Id of the ParallelGatewaySender
     */
    public static int getPRQLocalSize(String senderId) {
        GatewaySender sender = null;
        for (GatewaySender s : cache.getGatewaySenders()) {
            if (s.getId().equals(senderId)) {
                sender = s;
                break;
            }
        }
        if (sender.isParallel()) {
            int totalSize = 0;
            Set<RegionQueue> queues = ((AbstractGatewaySender) sender).getQueues();
            for (RegionQueue q : queues) {
                ConcurrentParallelGatewaySenderQueue prQ = (ConcurrentParallelGatewaySenderQueue) q;
                totalSize += prQ.localSize();
            }
            return totalSize;
        }
        return -1;
    }

    public static void doMultiThreadedPuts(String regionName, int numPuts) {
        final AtomicInteger ai = new AtomicInteger(-1);
        final ExecutorService execService = Executors.newFixedThreadPool(5, new ThreadFactory() {
            AtomicInteger threadNum = new AtomicInteger();

            public Thread newThread(final Runnable r) {
                Thread result = new Thread(r, "Client Put Thread-" + threadNum.incrementAndGet());
                result.setDaemon(true);
                return result;
            }
        });

        final Region r = cache.getRegion(Region.SEPARATOR + regionName);
        assertNotNull(r);

        List<Callable<Object>> tasks = new ArrayList<Callable<Object>>();
        for (long i = 0; i < 5; i++)
            tasks.add(new PutTask(r, ai, numPuts));

        try {
            List<Future<Object>> l = execService.invokeAll(tasks);
            for (Future<Object> f : l)
                f.get();
        } catch (InterruptedException e1) { // TODO: eats exception
            e1.printStackTrace();
        } catch (ExecutionException e) { // TODO: eats exceptions
            e.printStackTrace();
        }
        execService.shutdown();
    }

    public static void validateRegionSize(String regionName, final int regionSize) {
        validateRegionSize(regionName, regionSize, 30000);
    }

    public static void validateRegionSize(String regionName, final int regionSize, long waitTimeInMilliSec) {
        IgnoredException exp = IgnoredException.addIgnoredException(ForceReattemptException.class.getName());
        IgnoredException exp1 = IgnoredException.addIgnoredException(CacheClosedException.class.getName());
        try {
            final Region r = cache.getRegion(Region.SEPARATOR + regionName);
            assertNotNull(r);
            if (regionSize != r.keySet().size()) {
                Awaitility.await().atMost(waitTimeInMilliSec, TimeUnit.MILLISECONDS)
                        .pollInterval(500, TimeUnit.MILLISECONDS)
                        .until(() -> assertEquals(
                                "Expected region entries: " + regionSize + " but actual entries: "
                                        + r.keySet().size() + " present region keyset " + r.keySet(),
                                regionSize, r.keySet().size()));
            }
        } finally {
            exp.remove();
            exp1.remove();
        }
    }

    public static void validateAsyncEventListener(String asyncQueueId, final int expectedSize) {
        AsyncEventListener theListener = null;

        Set<AsyncEventQueue> asyncEventQueues = cache.getAsyncEventQueues();
        for (AsyncEventQueue asyncQueue : asyncEventQueues) {
            if (asyncQueueId.equals(asyncQueue.getId())) {
                theListener = asyncQueue.getAsyncEventListener();
            }
        }

        final Map eventsMap = ((MyAsyncEventListener) theListener).getEventsMap();
        assertNotNull(eventsMap);
        Awaitility.await().atMost(60, TimeUnit.SECONDS)
                .until(() -> assertEquals(
                        "Expected map entries: " + expectedSize + " but actual entries: " + eventsMap.size(),
                        expectedSize, eventsMap.size()));
    }

    public static void waitForAsyncQueueToGetEmpty(String asyncQueueId) {
        AsyncEventQueue theAsyncEventQueue = null;

        Set<AsyncEventQueue> asyncEventChannels = cache.getAsyncEventQueues();
        for (AsyncEventQueue asyncChannel : asyncEventChannels) {
            if (asyncQueueId.equals(asyncChannel.getId())) {
                theAsyncEventQueue = asyncChannel;
            }
        }

        final GatewaySender sender = ((AsyncEventQueueImpl) theAsyncEventQueue).getSender();

        if (sender.isParallel()) {
            final Set<RegionQueue> queues = ((AbstractGatewaySender) sender).getQueues();
            Awaitility.await().atMost(60, TimeUnit.SECONDS).until(() -> {
                int size = 0;
                for (RegionQueue q : queues) {
                    size += q.size();
                }
                assertEquals("Expected queue size to be : " + 0 + " but actual entries: " + size, 0, size);
            });
        } else {
            Awaitility.await().atMost(60, TimeUnit.SECONDS).until(() -> {
                Set<RegionQueue> queues = ((AbstractGatewaySender) sender).getQueues();
                int size = 0;
                for (RegionQueue q : queues) {
                    size += q.size();
                }
                assertEquals("Expected queue size to be : " + 0 + " but actual entries: " + size, 0, size);
            });
        }
    }

    public static int getAsyncEventListenerMapSize(String asyncEventQueueId) {
        AsyncEventListener theListener = null;

        Set<AsyncEventQueue> asyncEventQueues = cache.getAsyncEventQueues();
        for (AsyncEventQueue asyncQueue : asyncEventQueues) {
            if (asyncEventQueueId.equals(asyncQueue.getId())) {
                theListener = asyncQueue.getAsyncEventListener();
            }
        }

        final Map eventsMap = ((MyAsyncEventListener) theListener).getEventsMap();
        assertNotNull(eventsMap);
        LogWriterUtils.getLogWriter().info("The events map size is " + eventsMap.size());
        return eventsMap.size();
    }

    public static void validateRegionSize_PDX(String regionName, final int regionSize) {
        final Region r = cache.getRegion(Region.SEPARATOR + regionName);
        assertNotNull(r);
        Awaitility.await().atMost(200, TimeUnit.SECONDS)
                .until(() -> assertEquals("Expected region entries: " + regionSize + " but actual entries: "
                        + r.keySet().size() + " present region keyset " + r.keySet(), true,
                        (regionSize <= r.keySet().size())));
        for (int i = 0; i < regionSize; i++) {
            LogWriterUtils.getLogWriter().info("For Key : Key_" + i + " : Values : " + r.get("Key_" + i));
            assertEquals("keySet = " + r.keySet() + " values() = " + r.values(), new SimpleClass(i, (byte) i),
                    r.get("Key_" + i));
        }
    }

    public static void validateRegionSizeOnly_PDX(String regionName, final int regionSize) {
        final Region r = cache.getRegion(Region.SEPARATOR + regionName);
        assertNotNull(r);
        Awaitility.await().atMost(200, TimeUnit.SECONDS)
                .until(() -> assertEquals("Expected region entries: " + regionSize + " but actual entries: "
                        + r.keySet().size() + " present region keyset " + r.keySet(), true,
                        (regionSize <= r.keySet().size())));
    }

    public static void validateQueueSizeStat(String id, final int queueSize) {
        final AbstractGatewaySender sender = (AbstractGatewaySender) cache.getGatewaySender(id);
        Awaitility.await().atMost(30, TimeUnit.SECONDS)
                .until(() -> assertEquals(queueSize, sender.getEventQueueSize()));
        assertEquals(queueSize, sender.getEventQueueSize());
    }

    /**
     * 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.
     *
     * @param regionName
     * @param regionSizeLimit
     */
    public static void validateRegionSizeRemainsSame(String regionName, final int regionSizeLimit) {
        final Region r = cache.getRegion(Region.SEPARATOR + regionName);
        assertNotNull(r);
        WaitCriterion wc = new WaitCriterion() {
            final int MIN_VERIFICATION_RUNS = 20;
            int sameRegionSizeCounter = 0;
            long previousSize = -1;

            public boolean done() {
                if (r.keySet().size() == previousSize) {
                    sameRegionSizeCounter++;
                    int s = r.keySet().size();
                    // if the sameRegionSizeCounter exceeds the minimum verification runs and regionSize is
                    // below specified limit, then return true
                    if (sameRegionSizeCounter >= MIN_VERIFICATION_RUNS && s <= regionSizeLimit) {
                        return true;
                    } else {
                        return false;
                    }

                } else { // current regionSize is not same as recorded previous regionSize
                    previousSize = r.keySet().size(); // update the previousSize variable with current region
                                                      // size
                    sameRegionSizeCounter = 0;// reset the sameRegionSizeCounter
                    return false;
                }
            }

            public String description() {
                return "Expected region size to remain same below a specified limit but actual region size does not remain same or exceeded the specified limit "
                        + sameRegionSizeCounter + " :regionSize " + previousSize;
            }
        };
        Wait.waitForCriterion(wc, 200000, 500, true);
    }

    public static String getRegionFullPath(String regionName) {
        final Region r = cache.getRegion(Region.SEPARATOR + regionName);
        assertNotNull(r);
        return r.getFullPath();
    }

    public static Integer getRegionSize(String regionName) {
        final Region r = cache.getRegion(Region.SEPARATOR + regionName);
        assertNotNull(r);
        return r.keySet().size();
    }

    public static void validateRegionContents(String regionName, final Map keyValues) {
        final Region r = cache.getRegion(Region.SEPARATOR + regionName);
        assertNotNull(r);
        Awaitility.await().atMost(120, TimeUnit.SECONDS).until(() -> {
            boolean matchFlag = true;
            for (Object key : keyValues.keySet()) {
                if (!r.get(key).equals(keyValues.get(key))) {
                    LogWriterUtils.getLogWriter().info("The values are for key " + "  " + key + " " + r.get(key)
                            + " in the map " + keyValues.get(key));
                    matchFlag = false;
                }
            }
            assertEquals("Expected region entries doesn't match", true, matchFlag);
        });
    }

    public static void doHeavyPuts(String regionName, int numPuts) {
        Region r = cache.getRegion(Region.SEPARATOR + regionName);
        assertNotNull(r);
        // GatewaySender.DEFAULT_BATCH_SIZE * OBJECT_SIZE should be more than MAXIMUM_QUEUE_MEMORY
        // to guarantee overflow
        for (long i = 0; i < numPuts; i++) {
            r.put(i, new byte[1024 * 1024]);
        }
    }

    public static void addCacheListenerAndDestroyRegion(String regionName) {
        final Region region = cache.getRegion(Region.SEPARATOR + regionName);
        assertNotNull(region);
        CacheListenerAdapter cl = new CacheListenerAdapter() {
            @Override
            public void afterCreate(EntryEvent event) {
                if ((Long) event.getKey() == 99) {
                    region.destroyRegion();
                }
            }
        };
        region.getAttributesMutator().addCacheListener(cl);
    }

    public static Boolean killSender(String senderId) {
        final IgnoredException exln = IgnoredException.addIgnoredException("Could not connect");
        IgnoredException exp = IgnoredException.addIgnoredException(CacheClosedException.class.getName());
        IgnoredException exp1 = IgnoredException.addIgnoredException(ForceReattemptException.class.getName());
        try {
            Set<GatewaySender> senders = cache.getGatewaySenders();
            AbstractGatewaySender sender = null;
            for (GatewaySender s : senders) {
                if (s.getId().equals(senderId)) {
                    sender = (AbstractGatewaySender) s;
                    break;
                }
            }
            if (sender.isPrimary()) {
                LogWriterUtils.getLogWriter().info("Gateway sender is killed by a test");
                cache.getDistributedSystem().disconnect();
                return Boolean.TRUE;
            }
            return Boolean.FALSE;
        } finally {
            exp.remove();
            exp1.remove();
            exln.remove();
        }
    }

    public static void killSender() {
        LogWriterUtils.getLogWriter().info("Gateway sender is going to be killed by a test");
        cache.close();
        cache.getDistributedSystem().disconnect();
        LogWriterUtils.getLogWriter().info("Gateway sender is killed by a test");
    }

    public static void checkAllSiteMetaData(Map<Integer, Set<InetSocketAddress>> dsIdToLocatorAddresses) {
        List<Locator> locatorsConfigured = Locator.getLocators();
        Locator locator = locatorsConfigured.get(0);
        Awaitility.waitAtMost(60, TimeUnit.SECONDS).until(() -> {
            Map<Integer, Set<DistributionLocatorId>> allSiteMetaData = ((InternalLocator) locator)
                    .getlocatorMembershipListener().getAllLocatorsInfo();
            for (Map.Entry<Integer, Set<InetSocketAddress>> entry : dsIdToLocatorAddresses.entrySet()) {
                Set<DistributionLocatorId> foundLocatorIds = allSiteMetaData.get(entry.getKey());
                Set<InetSocketAddress> expectedLocators = entry.getValue();
                final Set<InetSocketAddress> foundLocators = foundLocatorIds.stream()
                        .map(distributionLocatorId -> new InetSocketAddress(
                                distributionLocatorId.getHostnameForClients(), distributionLocatorId.getPort()))
                        .collect(Collectors.toSet());
                assertEquals(expectedLocators, foundLocators);
            }
        });
    }

    public static Long checkAllSiteMetaDataFor3Sites(final Map<Integer, Set<String>> dsVsPort) {
        Awaitility.await().atMost(50, TimeUnit.SECONDS)
                .until(() -> assertEquals("System is not initialized", true, (getSystemStatic() != null)));
        List<Locator> locatorsConfigured = Locator.getLocators();
        Locator locator = locatorsConfigured.get(0);
        LocatorMembershipListener listener = ((InternalLocator) locator).getlocatorMembershipListener();
        if (listener == null) {
            fail("No locator membership listener available. WAN is likely not enabled. Is this test in the WAN project?");
        }
        final Map<Integer, Set<DistributionLocatorId>> allSiteMetaData = listener.getAllLocatorsInfo();
        System.out.println("allSiteMetaData : " + allSiteMetaData);

        Awaitility.await().atMost(300, TimeUnit.SECONDS).until(() -> {
            assertEquals(true, (dsVsPort.size() == allSiteMetaData.size()));
            boolean completeFlag = true;
            for (Map.Entry<Integer, Set<String>> entry : dsVsPort.entrySet()) {
                Set<DistributionLocatorId> locators = allSiteMetaData.get(entry.getKey());
                for (String locatorInMetaData : entry.getValue()) {
                    DistributionLocatorId locatorId = new DistributionLocatorId(locatorInMetaData);
                    if (!locators.contains(locatorId)) {
                        completeFlag = false;
                        break;
                    }
                }
                if (false == completeFlag) {
                    break;
                }
            }
            assertEquals("Expected site Metadata: " + dsVsPort + " but actual meta data: " + allSiteMetaData, true,
                    completeFlag);
        });
        return System.currentTimeMillis();
    }

    public static void putRemoteSiteLocators(int remoteDsId, Set<String> remoteLocators) {
        List<Locator> locatorsConfigured = Locator.getLocators();
        Locator locator = locatorsConfigured.get(0);
        if (remoteLocators != null) {
            // Add fake remote locators to the locators map
            ((InternalLocator) locator).getlocatorMembershipListener().getAllServerLocatorsInfo().put(remoteDsId,
                    remoteLocators);
        }
    }

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

        Set<GatewaySender> senders = cache.getGatewaySenders();
        GatewaySender sender = null;
        for (GatewaySender s : senders) {
            if (s.getId().equals(senderId)) {
                sender = s;
                break;
            }
        }

        MyLocatorCallback callback = (MyLocatorCallback) ((AbstractGatewaySender) sender)
                .getLocatorDiscoveryCallback();

        boolean discovered = callback.waitForDiscovery(locatorToWaitFor, MAX_WAIT);
        assertTrue("Waited " + MAX_WAIT + " for " + locatorToWaitFor + " to be discovered on client. List is now: "
                + callback.getDiscovered(), discovered);
    }

    public static void validateQueueContents(final String senderId, final int regionSize) {
        IgnoredException exp1 = IgnoredException.addIgnoredException(InterruptedException.class.getName());
        IgnoredException exp2 = IgnoredException.addIgnoredException(GatewaySenderException.class.getName());
        try {
            Set<GatewaySender> senders = cache.getGatewaySenders();
            GatewaySender sender = null;
            for (GatewaySender s : senders) {
                if (s.getId().equals(senderId)) {
                    sender = s;
                    break;
                }
            }

            if (!sender.isParallel()) {
                final Set<RegionQueue> queues = ((AbstractGatewaySender) sender).getQueues();
                Awaitility.await().atMost(120, TimeUnit.SECONDS).until(() -> {
                    int size = 0;
                    for (RegionQueue q : queues) {
                        size += q.size();
                    }
                    assertEquals("Expected queue entries: " + regionSize + " but actual entries: " + size,
                            regionSize, size);
                });
            } else if (sender.isParallel()) {
                final RegionQueue regionQueue;
                regionQueue = ((AbstractGatewaySender) sender).getQueues().toArray(new RegionQueue[1])[0];
                Awaitility.await().atMost(120, TimeUnit.SECONDS).until(() -> assertEquals(
                        "Expected queue entries: " + regionSize + " but actual entries: " + regionQueue.size(),
                        regionSize, regionQueue.size()));
            }
        } finally {
            exp1.remove();
            exp2.remove();
        }

    }

    // Ensure that the sender's queue(s) have been closed.
    public static void validateQueueClosedForConcurrentSerialGatewaySender(final String senderId) {
        Set<GatewaySender> senders = cache.getGatewaySenders();
        GatewaySender sender = null;
        for (GatewaySender s : senders) {
            if (s.getId().equals(senderId)) {
                sender = s;
                break;
            }
        }
        final Set<RegionQueue> regionQueue;
        if (sender instanceof AbstractGatewaySender) {
            regionQueue = ((AbstractGatewaySender) sender).getQueuesForConcurrentSerialGatewaySender();
        } else {
            regionQueue = null;
        }
        assertEquals(null, regionQueue);
    }

    public static void validateQueueContentsForConcurrentSerialGatewaySender(final String senderId,
            final int regionSize) {
        Set<GatewaySender> senders = cache.getGatewaySenders();
        GatewaySender sender = null;
        for (GatewaySender s : senders) {
            if (s.getId().equals(senderId)) {
                sender = s;
                break;
            }
        }
        final Set<RegionQueue> regionQueue;
        if (!sender.isParallel()) {
            regionQueue = ((AbstractGatewaySender) sender).getQueuesForConcurrentSerialGatewaySender();
        } else {
            regionQueue = null;
        }
        Awaitility.await().atMost(120, TimeUnit.SECONDS).until(() -> {
            int size = 0;
            for (RegionQueue q : regionQueue) {
                size += q.size();
            }
            assertEquals(true, regionSize == size);
        });
    }

    public static Integer getQueueContentSize(final String senderId) {
        return getQueueContentSize(senderId, false);
    }

    public static Integer getQueueContentSize(final String senderId, boolean includeSecondary) {
        Set<GatewaySender> senders = cache.getGatewaySenders();
        GatewaySender sender = null;
        for (GatewaySender s : senders) {
            if (s.getId().equals(senderId)) {
                sender = s;
                break;
            }
        }

        if (!sender.isParallel()) {
            if (includeSecondary) {
                fail("Not implemented yet");
            }
            final Set<RegionQueue> queues = ((AbstractGatewaySender) sender).getQueues();
            int size = 0;
            for (RegionQueue q : queues) {
                size += q.size();
            }
            return size;
        } else if (sender.isParallel()) {
            RegionQueue regionQueue = null;
            regionQueue = ((AbstractGatewaySender) sender).getQueues().toArray(new RegionQueue[1])[0];
            if (regionQueue instanceof ConcurrentParallelGatewaySenderQueue) {
                return ((ConcurrentParallelGatewaySenderQueue) regionQueue).localSize(includeSecondary);
            } else if (regionQueue instanceof ParallelGatewaySenderQueue) {
                return ((ParallelGatewaySenderQueue) regionQueue).localSize(includeSecondary);
            } else {
                if (includeSecondary) {
                    fail("Not Implemented yet");
                }
                regionQueue = ((AbstractGatewaySender) sender).getQueues().toArray(new RegionQueue[1])[0];
                return regionQueue.getRegion().size();
            }
        }
        fail("Not yet implemented?");
        return 0;
    }

    public static void validateParallelSenderQueueBucketSize(final String senderId, final int bucketSize) {
        Set<GatewaySender> senders = cache.getGatewaySenders();
        GatewaySender sender = null;
        for (GatewaySender s : senders) {
            if (s.getId().equals(senderId)) {
                sender = s;
                break;
            }
        }
        RegionQueue regionQueue = ((AbstractGatewaySender) sender).getQueues().toArray(new RegionQueue[1])[0];
        Set<BucketRegion> buckets = ((PartitionedRegion) regionQueue.getRegion()).getDataStore()
                .getAllLocalPrimaryBucketRegions();
        for (BucketRegion bucket : buckets) {
            assertEquals("Expected bucket entries for bucket " + bucket.getId() + " is different than actual.",
                    bucketSize, bucket.keySet().size());
        }
    }

    public static void validateParallelSenderQueueAllBucketsDrained(final String senderId) {
        IgnoredException exp = IgnoredException.addIgnoredException(RegionDestroyedException.class.getName());
        IgnoredException exp1 = IgnoredException.addIgnoredException(ForceReattemptException.class.getName());
        try {
            Set<GatewaySender> senders = cache.getGatewaySenders();
            GatewaySender sender = null;
            for (GatewaySender s : senders) {
                if (s.getId().equals(senderId)) {
                    sender = s;
                    break;
                }
            }
            RegionQueue regionQueue = ((AbstractGatewaySender) sender).getQueues().toArray(new RegionQueue[1])[0];
            Set<BucketRegion> buckets = ((PartitionedRegion) regionQueue.getRegion()).getDataStore()
                    .getAllLocalPrimaryBucketRegions();
            for (final BucketRegion bucket : buckets) {
                Awaitility.await().atMost(30, TimeUnit.SECONDS).until(() -> {
                    assertEquals(
                            "Expected bucket entries for bucket: " + bucket.getId() + " is: 0 but actual entries: "
                                    + bucket.keySet().size() + " This bucket isPrimary: "
                                    + bucket.getBucketAdvisor().isPrimary() + " KEYSET: " + bucket.keySet(),
                            0, bucket.keySet().size());
                });
            } // for loop ends
        } finally {
            exp.remove();
            exp1.remove();
        }

    }

    public static Integer validateAfterAck(final String senderId) {
        Set<GatewaySender> senders = cache.getGatewaySenders();
        GatewaySender sender = null;
        for (GatewaySender s : senders) {
            if (s.getId().equals(senderId)) {
                sender = s;
                break;
            }
        }

        final MyGatewayEventFilter_AfterAck filter = (MyGatewayEventFilter_AfterAck) sender.getGatewayEventFilters()
                .get(0);
        return filter.getAckList().size();
    }

    public static int verifyAndGetEventsDispatchedByConcurrentDispatchers(final String senderId) {
        Set<GatewaySender> senders = cache.getGatewaySenders();
        GatewaySender sender = null;
        for (GatewaySender s : senders) {
            if (s.getId().equals(senderId)) {
                sender = s;
                break;
            }
        }
        ConcurrentParallelGatewaySenderEventProcessor cProc = (ConcurrentParallelGatewaySenderEventProcessor) ((AbstractGatewaySender) sender)
                .getEventProcessor();
        if (cProc == null)
            return 0;

        int totalDispatched = 0;
        for (ParallelGatewaySenderEventProcessor lProc : cProc.getProcessors()) {
            totalDispatched += lProc.getNumEventsDispatched();
        }
        assertTrue(totalDispatched > 0);
        return totalDispatched;
    }

    public static Long getNumberOfEntriesOverflownToDisk(final String senderId) {
        Set<GatewaySender> senders = cache.getGatewaySenders();
        GatewaySender sender = null;
        for (GatewaySender s : senders) {
            if (s.getId().equals(senderId)) {
                sender = s;
                break;
            }
        }

        long numEntries = 0;
        if (sender.isParallel()) {
            RegionQueue regionQueue;
            regionQueue = ((AbstractGatewaySender) sender).getQueues().toArray(new RegionQueue[1])[0];
            numEntries = ((ConcurrentParallelGatewaySenderQueue) regionQueue).getNumEntriesOverflowOnDiskTestOnly();
        }
        return numEntries;
    }

    public static Long getNumberOfEntriesInVM(final String senderId) {
        Set<GatewaySender> senders = cache.getGatewaySenders();
        GatewaySender sender = null;
        for (GatewaySender s : senders) {
            if (s.getId().equals(senderId)) {
                sender = s;
                break;
            }
        }
        RegionQueue regionQueue;
        long numEntries = 0;
        if (sender.isParallel()) {
            regionQueue = ((AbstractGatewaySender) sender).getQueues().toArray(new RegionQueue[1])[0];
            numEntries = ((ConcurrentParallelGatewaySenderQueue) regionQueue).getNumEntriesInVMTestOnly();
        }
        return numEntries;
    }

    public static void verifyQueueSize(String senderId, int size) {
        Set<GatewaySender> senders = cache.getGatewaySenders();
        GatewaySender sender = null;
        for (GatewaySender s : senders) {
            if (s.getId().equals(senderId)) {
                sender = s;
                break;
            }
        }

        if (!sender.isParallel()) {
            final Set<RegionQueue> queues = ((AbstractGatewaySender) sender).getQueues();
            int queueSize = 0;
            for (RegionQueue q : queues) {
                queueSize += q.size();
            }

            assertEquals("verifyQueueSize failed for sender " + senderId, size, queueSize);
        } else if (sender.isParallel()) {
            RegionQueue regionQueue = ((AbstractGatewaySender) sender).getQueues().toArray(new RegionQueue[1])[0];
            assertEquals("verifyQueueSize failed for sender " + senderId, size, regionQueue.size());
        }
    }

    public static void verifyRegionQueueNotEmpty(String senderId) {
        Set<GatewaySender> senders = cache.getGatewaySenders();
        GatewaySender sender = null;
        for (GatewaySender s : senders) {
            if (s.getId().equals(senderId)) {
                sender = s;
                break;
            }
        }

        if (!sender.isParallel()) {
            final Set<RegionQueue> queues = ((AbstractGatewaySender) sender).getQueues();
            int queueSize = 0;
            for (RegionQueue q : queues) {
                queueSize += q.size();
            }
            assertTrue(queues.size() > 0);
            assertTrue(queueSize > 0);
        } else if (sender.isParallel()) {
            RegionQueue regionQueue = ((AbstractGatewaySender) sender).getQueues().toArray(new RegionQueue[1])[0];
            assertTrue(regionQueue.size() > 0);
        }
    }

    public static void waitForConcurrentSerialSenderQueueToDrain(String senderId) {
        Set<GatewaySender> senders = cache.getGatewaySenders();
        GatewaySender sender = senders.stream().filter(s -> s.getId().equals(senderId)).findFirst().get();

        Awaitility.await().atMost(1, TimeUnit.MINUTES).until(() -> {
            Set<RegionQueue> queues = ((AbstractGatewaySender) sender).getQueuesForConcurrentSerialGatewaySender();
            for (RegionQueue q : queues) {
                assertEquals(0, q.size());
            }
        });
    }

    /**
     * Test methods for sender operations
     * 
     * @param senderId
     */
    public static void verifySenderPausedState(String senderId) {
        Set<GatewaySender> senders = cache.getGatewaySenders();
        GatewaySender sender = null;
        for (GatewaySender s : senders) {
            if (s.getId().equals(senderId)) {
                sender = s;
                break;
            }
        }
        assertTrue(sender.isPaused());
    }

    public static void verifySenderResumedState(String senderId) {
        Set<GatewaySender> senders = cache.getGatewaySenders();
        GatewaySender sender = null;
        for (GatewaySender s : senders) {
            if (s.getId().equals(senderId)) {
                sender = s;
                break;
            }
        }
        assertFalse(sender.isPaused());
        assertTrue(sender.isRunning());
    }

    public static void verifySenderStoppedState(String senderId) {
        Set<GatewaySender> senders = cache.getGatewaySenders();
        GatewaySender sender = null;
        for (GatewaySender s : senders) {
            if (s.getId().equals(senderId)) {
                sender = s;
                break;
            }
        }
        assertFalse(sender.isRunning());
    }

    public static void verifySenderRunningState(String senderId) {
        Set<GatewaySender> senders = cache.getGatewaySenders();
        GatewaySender sender = null;
        for (GatewaySender s : senders) {
            if (s.getId().equals(senderId)) {
                sender = s;
                break;
            }
        }
        assertTrue(sender.isRunning());
    }

    public static void verifyPool(String senderId, boolean poolShouldExist, int expectedPoolLocatorsSize) {
        AbstractGatewaySender sender = (AbstractGatewaySender) cache.getGatewaySender(senderId);
        PoolImpl pool = sender.getProxy();
        if (poolShouldExist) {
            assertNotNull(pool);
            assertEquals(expectedPoolLocatorsSize, pool.getLocators().size());
        } else {
            assertNull(pool);
        }
    }

    public static void removeSenderFromTheRegion(String senderId, String regionName) {
        Region region = cache.getRegion(regionName);
        assertNotNull(region);
        region.getAttributesMutator().removeGatewaySenderId(senderId);
    }

    public static void destroySender(String senderId) {
        Set<GatewaySender> senders = cache.getGatewaySenders();
        GatewaySender sender = null;
        for (GatewaySender s : senders) {
            if (s.getId().equals(senderId)) {
                sender = s;
                break;
            }
        }
        sender.destroy();
    }

    public static void verifySenderDestroyed(String senderId, boolean isParallel) {
        Set<GatewaySender> senders = cache.getGatewaySenders();
        AbstractGatewaySender sender = null;
        for (GatewaySender s : senders) {
            if (s.getId().equals(senderId)) {
                sender = (AbstractGatewaySender) s;
                break;
            }
        }
        assertNull(sender);

        String queueRegionNameSuffix = null;
        if (isParallel) {
            queueRegionNameSuffix = ParallelGatewaySenderQueue.QSTRING;
        } else {
            queueRegionNameSuffix = "_SERIAL_GATEWAY_SENDER_QUEUE";
        }

        Set<LocalRegion> allRegions = ((GemFireCacheImpl) cache).getAllRegions();
        for (LocalRegion region : allRegions) {
            if (region.getName().indexOf(senderId + queueRegionNameSuffix) != -1) {
                fail("Region underlying the sender is not destroyed.");
            }
        }
    }

    public static void destroyAsyncEventQueue(String id) {
        AsyncEventQueueImpl aeq = (AsyncEventQueueImpl) cache.getAsyncEventQueue(id);
        assertNotNull(aeq);
        aeq.destroy();
    }

    protected static void verifyListenerEvents(final long expectedNumEvents) {
        Awaitility.await().atMost(60, TimeUnit.SECONDS).until(() -> listener1.getNumEvents() == expectedNumEvents);
    }

    protected Integer[] createLNAndNYLocators() {
        Integer lnPort = vm0.invoke(() -> createFirstLocatorWithDSId(1));
        Integer nyPort = vm1.invoke(() -> createFirstRemoteLocator(2, lnPort));
        return new Integer[] { lnPort, nyPort };
    }

    protected void validateRegionSizes(String regionName, int expectedRegionSize, VM... vms) {
        for (VM vm : vms) {
            vm.invoke(() -> validateRegionSize(regionName, expectedRegionSize));
        }
    }

    public static class MyLocatorCallback extends LocatorDiscoveryCallbackAdapter {

        private final Set discoveredLocators = new HashSet();

        private final Set removedLocators = new HashSet();

        public synchronized void locatorsDiscovered(List locators) {
            discoveredLocators.addAll(locators);
            notifyAll();
        }

        public synchronized void locatorsRemoved(List locators) {
            removedLocators.addAll(locators);
            notifyAll();
        }

        public boolean waitForDiscovery(InetSocketAddress locator, long time) throws InterruptedException {
            return waitFor(discoveredLocators, locator, time);
        }

        private synchronized boolean waitFor(Set set, InetSocketAddress locator, long time)
                throws InterruptedException {
            long remaining = time;
            long endTime = System.currentTimeMillis() + time;
            while (!set.contains(locator) && remaining >= 0) {
                wait(remaining);
                remaining = endTime - System.currentTimeMillis();
            }
            return set.contains(locator);
        }

        public synchronized Set getDiscovered() {
            return new HashSet(discoveredLocators);
        }

    }

    protected static class PutTask implements Callable {
        private final Region region;

        private final AtomicInteger key_value;

        private final int numPuts;

        public PutTask(Region region, AtomicInteger key_value, int numPuts) {
            this.region = region;
            this.key_value = key_value;
            this.numPuts = numPuts;
        }

        public Object call() throws Exception {
            while (true) {
                int key = key_value.incrementAndGet();
                if (key < numPuts) {
                    region.put(key, key);
                } else {
                    break;
                }
            }
            return null;
        }
    }

    public static class MyGatewayEventFilter implements GatewayEventFilter, Serializable {

        String Id = "MyGatewayEventFilter";

        boolean beforeEnqueueInvoked;
        boolean beforeTransmitInvoked;
        boolean afterAckInvoked;

        public MyGatewayEventFilter() {
        }

        public boolean beforeEnqueue(GatewayQueueEvent event) {
            this.beforeEnqueueInvoked = true;
            return !((Long) event.getKey() >= 500 && (Long) event.getKey() < 600);
        }

        public boolean beforeTransmit(GatewayQueueEvent event) {
            this.beforeTransmitInvoked = true;
            return !((Long) event.getKey() >= 600 && (Long) event.getKey() < 700);
        }

        public void close() {
            // TODO Auto-generated method stub

        }

        public String toString() {
            return Id;
        }

        public void afterAcknowledgement(GatewayQueueEvent event) {
            this.afterAckInvoked = true;
            // TODO Auto-generated method stub
        }

        public boolean equals(Object obj) {
            if (this == obj) {
                return true;
            }
            if (!(obj instanceof MyGatewayEventFilter))
                return false;
            MyGatewayEventFilter filter = (MyGatewayEventFilter) obj;
            return this.Id.equals(filter.Id);
        }
    }

    public static class MyGatewayEventFilter_AfterAck implements GatewayEventFilter, Serializable {

        String Id = "MyGatewayEventFilter_AfterAck";

        ConcurrentSkipListSet<Long> ackList = new ConcurrentSkipListSet<Long>();

        public MyGatewayEventFilter_AfterAck() {
        }

        public boolean beforeEnqueue(GatewayQueueEvent event) {
            return true;
        }

        public boolean beforeTransmit(GatewayQueueEvent event) {
            return true;
        }

        public void close() {
            // TODO Auto-generated method stub

        }

        public String toString() {
            return Id;
        }

        public void afterAcknowledgement(GatewayQueueEvent event) {
            ackList.add((Long) event.getKey());
        }

        public Set getAckList() {
            return ackList;
        }

        public boolean equals(Object obj) {
            if (this == obj) {
                return true;
            }
            if (!(obj instanceof MyGatewayEventFilter))
                return false;
            MyGatewayEventFilter filter = (MyGatewayEventFilter) obj;
            return this.Id.equals(filter.Id);
        }
    }

    public static class PDXGatewayEventFilter implements GatewayEventFilter, Serializable {

        String Id = "PDXGatewayEventFilter";

        public int beforeEnqueueInvoked;
        public int beforeTransmitInvoked;
        public int afterAckInvoked;

        public PDXGatewayEventFilter() {
        }

        public boolean beforeEnqueue(GatewayQueueEvent event) {
            System.out.println("Invoked enqueue for " + event);
            this.beforeEnqueueInvoked++;
            return true;
        }

        public boolean beforeTransmit(GatewayQueueEvent event) {
            System.out.println("Invoked transmit for " + event);
            this.beforeTransmitInvoked++;
            return true;
        }

        public void close() {
            // TODO Auto-generated method stub

        }

        public String toString() {
            return Id;
        }

        public void afterAcknowledgement(GatewayQueueEvent event) {
            System.out.println("Invoked afterAck for " + event);
            this.afterAckInvoked++;
            // TODO Auto-generated method stub
        }

        public boolean equals(Object obj) {
            if (this == obj) {
                return true;
            }
            if (!(obj instanceof MyGatewayEventFilter))
                return false;
            MyGatewayEventFilter filter = (MyGatewayEventFilter) obj;
            return this.Id.equals(filter.Id);
        }
    }

    @Override
    public final void preTearDown() throws Exception {
        cleanupVM();
        List<AsyncInvocation> invocations = new ArrayList<AsyncInvocation>();
        final Host host = Host.getHost(0);
        for (int i = 0; i < host.getVMCount(); i++) {
            invocations.add(host.getVM(i).invokeAsync(() -> WANTestBase.cleanupVM()));
        }
        for (AsyncInvocation invocation : invocations) {
            invocation.join();
            invocation.checkException();
        }
    }

    public static void cleanupVM() throws IOException {
        if (Locator.hasLocator()) {
            Locator.getLocator().stop();
        }
        closeCache();
        CacheTestCase.cleanDiskDirs();
    }

    public static void closeCache() {
        if (cache != null && !cache.isClosed()) {
            cache.close();
            cache.getDistributedSystem().disconnect();
            cache = null;
        } else {
            WANTestBase test = new WANTestBase();
            if (test.isConnectedToDS()) {
                test.getSystem().disconnect();
            }
        }
    }

    public static void deletePDXDir() throws IOException {
        File pdxDir = new File(CacheTestCase.getDiskDir(), "pdx");
        FileUtils.deleteDirectory(pdxDir);
    }

    public static void shutdownLocator() {
        WANTestBase test = new WANTestBase();
        test.getSystem().disconnect();
    }

    public static void printEventListenerMap() {
        ((MyGatewaySenderEventListener) eventListener1).printMap();
    }

    @Override
    public Properties getDistributedSystemProperties() {
        // For now all WANTestBase tests allocate off-heap memory even though
        // many of them never use it.
        // The problem is that WANTestBase has static methods that create instances
        // of WANTestBase (instead of instances of the subclass). So we can't override
        // this method so that only the off-heap subclasses allocate off heap memory.
        Properties props = new Properties();
        props.setProperty(OFF_HEAP_MEMORY_SIZE, "300m");
        return props;
    }

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