@Test
  public void testOneHopKnownIssues() {
    VM vm0 = VM.getVM(0);
    VM vm1 = VM.getVM(1);
    VM vm2 = VM.getVM(2);

    assertThat(vm0).isNotNull();
    assertThat(vm1).isNotNull();
    assertThat(vm2).isNotNull();
    // create an empty region in vm0 and replicated regions in VM 1 and 3,
    // then perform concurrent ops
    // on the same key while creating the region in VM2. Afterward make
    // sure that all three regions are consistent

    final String name = getUniqueName() + "-CC";

    assertThat(vm0.invoke("Create Region", () -> {
      try {
        final RegionFactory f = getCache().createRegionFactory(
            getRegionAttributes(RegionShortcut.REPLICATE_PROXY.toString()));

        CCRegion = (LocalRegion) f.create(name);
        assertThat(CCRegion).isNotNull();
      } catch (CacheException ex) {
        fail("While creating region", ex);
      }
      return true;
    })).isTrue(); // empty

    assertThat(vm1.invoke("Create Region", () -> {
      try {
        final RegionFactory f = getCache()
            .createRegionFactory(getRegionAttributes(RegionShortcut.REPLICATE.toString()));
        f.setDataPolicy(DataPolicy.NORMAL);

        CCRegion = (LocalRegion) f.create(name);
        assertThat(CCRegion).isNotNull();
      } catch (CacheException ex) {
        fail("While creating region", ex);
      }
      return true;
    })).isTrue(); // normal

    assertThat(vm2.invoke("Create Region", () -> {
      try {
        final RegionFactory f = getCache().createRegionFactory(getRegionAttributes());
        CCRegion = (LocalRegion) f.create(name);
        assertThat(CCRegion).isNotNull();
      } catch (CacheException ex) {
        fail("While creating region", ex);
      }
      return true;
    })).isTrue(); // replicate

    // case 1: entry already invalid on vm2 (replicate) is invalidated by vm0 (empty)
    final String invalidationKey = "invalidationKey";
    SerializableRunnable test =
        new SerializableRunnable() {
          @Override
          public void run() {
            CCRegion.put(invalidationKey, "initialValue");

            long invalidationCount = CCRegion.getCachePerfStats().getInvalidates();
            CCRegion.invalidate(invalidationKey);
            CCRegion.invalidate(invalidationKey);
            assertThat(invalidationCount + 1)
                .isEqualTo(CCRegion.getCachePerfStats().getInvalidates());

            // also test destroy() while we're at it. It should throw an exception
            long destroyCount = CCRegion.getCachePerfStats().getDestroys();
            CCRegion.destroy(invalidationKey);
            try {
              CCRegion.destroy(invalidationKey);
              fail("expected an EntryNotFoundException");
            } catch (EntryNotFoundException e) {
              // expected
            }
            assertThat(destroyCount + 1).isEqualTo(CCRegion.getCachePerfStats().getDestroys());
          }
        };
    vm0.invoke("case 1: second invalidation not applied or distributed", test);

    // now do the same with the datapolicy=normal region
    vm1.invoke("case 2: second invalidation not applied or distributed", test);
  }
This tests the concurrency versioning system to ensure that event conflation happens correctly
and that the statistic is being updated properly
geode-core/src/distributedTest/java/org/apache/geode/cache30/DistributedNoAckRegionCCEDUnitTest.java