@Test
  public void test003Bug36684() throws CacheException, InterruptedException {
    final String name = getName();

    // Create the cache servers with distributed, mirrored region
    Stream.of(vm0, vm1).forEach(vm -> {
      vm.invoke("Create Cache Server", () -> {
        CacheLoader<Object, Object> cl = new CacheLoader<Object, Object>() {
          @Override
          public Object load(LoaderHelper helper) {
            return helper.getKey();
          }

          @Override
          public void close() {

          }
        };
        RegionFactory<Object, Object> factory =
            getBridgeServerMirroredAckRegionAttributes(cl);
        createRegion(name, factory);
        startBridgeServer(0);

      });
      logger.info("before create server");
    });

    // Create cache server clients
    final int numberOfKeys = 1000;
    final String host0 = NetworkUtils.getServerHostName();
    final int vm0Port = vm0.invoke(ConnectionPoolDUnitTest::getCacheServerPort);
    final int vm1Port = vm1.invoke(ConnectionPoolDUnitTest::getCacheServerPort);
    SerializableRunnable createClient = new CacheSerializableRunnable() {
      @Override
      public void run2() throws CacheException {
        // reset all static listener variables in case this is being rerun in a subclass
        numberOfAfterInvalidates = 0;
        numberOfAfterCreates = 0;
        numberOfAfterUpdates = 0;
        // create the region
        getLonerSystem();
        RegionFactory<Object, Object> factory = getCache().createRegionFactory();
        factory.setScope(Scope.LOCAL);
        factory.setConcurrencyChecksEnabled(false); // test validation expects this behavior
        // create bridge writer
        configureConnectionPool(factory, host0, new int[] {vm0Port, vm1Port}, true, -1,
            -1, null);
        createRegion(name, factory);
      }
    };
    logger.info("before create client");
    vm2.invoke("Create Cache Server Client", createClient);
    vm3.invoke("Create Cache Server Client", createClient);

    // Initialize each client with entries (so that afterInvalidate is called)
    SerializableRunnable initializeClient = new CacheSerializableRunnable() {
      @Override
      public void run2() throws CacheException {
        // StringBuilder errors = new StringBuilder();
        numberOfAfterInvalidates = 0;
        numberOfAfterCreates = 0;
        numberOfAfterUpdates = 0;
        Region<Object, Object> region = getRootRegion().getSubregion(name);
        for (int i = 0; i < numberOfKeys; i++) {
          String expected = "key-" + i;
          String actual = (String) region.get("key-" + i);
          assertThat(expected).isEqualTo(actual);
        }
      }
    };

    logger.info("before initialize client");
    AsyncInvocation<Void> inv2 = vm2.invokeAsync("Initialize Client", initializeClient);
    AsyncInvocation<Void> inv3 = vm3.invokeAsync("Initialize Client", initializeClient);

    inv2.await();
    inv3.await();
  }
Tests for bug 36684 by having two cache servers with cacheloaders that should always return a
value and one client connected to each server reading values. If the bug exists, the clients
will get null sometimes.
geode-core/src/distributedTest/java/org/apache/geode/cache/ConnectionPoolDUnitTest.java