This is an automated email from the ASF dual-hosted git repository.
klund pushed a commit to branch develop
in repository https://gitbox.apache.org/repos/asf/geode.git
The following commit(s) were added to refs/heads/develop by this push:
new 64e5682 GEODE-8252: Rename DistributedCounters (#5564)
64e5682 is described below
commit 64e56826297584c321ac833969fed3a472b6ddd5
Author: Kirk Lund <[email protected]>
AuthorDate: Wed Sep 30 17:32:07 2020 -0700
GEODE-8252: Rename DistributedCounters (#5564)
Rename SharedCountersRule as DistributedCounters.
---
.../ReplicateCacheListenerDistributedTest.java | 28 ++++----
...ava => DistributedCountersDistributedTest.java} | 78 +++++++++++-----------
...dCountersRule.java => DistributedCounters.java} | 44 ++++++------
3 files changed, 75 insertions(+), 75 deletions(-)
diff --git
a/geode-core/src/distributedTest/java/org/apache/geode/cache/ReplicateCacheListenerDistributedTest.java
b/geode-core/src/distributedTest/java/org/apache/geode/cache/ReplicateCacheListenerDistributedTest.java
index e25dd2b..3eedcef 100644
---
a/geode-core/src/distributedTest/java/org/apache/geode/cache/ReplicateCacheListenerDistributedTest.java
+++
b/geode-core/src/distributedTest/java/org/apache/geode/cache/ReplicateCacheListenerDistributedTest.java
@@ -31,9 +31,9 @@ import org.junit.Test;
import org.apache.geode.cache.util.CacheListenerAdapter;
import org.apache.geode.test.dunit.rules.CacheRule;
+import org.apache.geode.test.dunit.rules.DistributedCounters;
import org.apache.geode.test.dunit.rules.DistributedErrorCollector;
import org.apache.geode.test.dunit.rules.DistributedRule;
-import org.apache.geode.test.dunit.rules.SharedCountersRule;
import org.apache.geode.test.junit.rules.serializable.SerializableTestName;
/**
@@ -69,7 +69,7 @@ public class ReplicateCacheListenerDistributedTest implements
Serializable {
public SerializableTestName testName = new SerializableTestName();
@Rule
- public SharedCountersRule sharedCountersRule = new SharedCountersRule();
+ public DistributedCounters distributedCounters = new DistributedCounters();
@Rule
public DistributedErrorCollector errorCollector = new
DistributedErrorCollector();
@@ -78,10 +78,10 @@ public class ReplicateCacheListenerDistributedTest
implements Serializable {
public void setUp() {
regionName = getClass().getSimpleName();
- sharedCountersRule.initialize(CREATES);
- sharedCountersRule.initialize(DESTROYS);
- sharedCountersRule.initialize(INVALIDATES);
- sharedCountersRule.initialize(UPDATES);
+ distributedCounters.initialize(CREATES);
+ distributedCounters.initialize(DESTROYS);
+ distributedCounters.initialize(INVALIDATES);
+ distributedCounters.initialize(UPDATES);
}
@Test
@@ -96,7 +96,7 @@ public class ReplicateCacheListenerDistributedTest implements
Serializable {
region.put(KEY, ENTRY_VALUE, cacheRule.getSystem().getDistributedMember());
-
assertThat(sharedCountersRule.getTotal(CREATES)).isEqualTo(expectedCreates());
+
assertThat(distributedCounters.getTotal(CREATES)).isEqualTo(expectedCreates());
}
@Test
@@ -112,7 +112,7 @@ public class ReplicateCacheListenerDistributedTest
implements Serializable {
region.put(KEY, ENTRY_VALUE, cacheRule.getSystem().getDistributedMember());
region.put(KEY, UPDATED_ENTRY_VALUE,
cacheRule.getSystem().getDistributedMember());
-
assertThat(sharedCountersRule.getTotal(UPDATES)).isEqualTo(expectedUpdates());
+
assertThat(distributedCounters.getTotal(UPDATES)).isEqualTo(expectedUpdates());
}
@Test
@@ -128,7 +128,7 @@ public class ReplicateCacheListenerDistributedTest
implements Serializable {
region.put(KEY, 0, cacheRule.getSystem().getDistributedMember());
region.invalidate(KEY);
-
assertThat(sharedCountersRule.getTotal(INVALIDATES)).isEqualTo(expectedInvalidates());
+
assertThat(distributedCounters.getTotal(INVALIDATES)).isEqualTo(expectedInvalidates());
assertThat(region.get(KEY)).isNull();
}
@@ -145,7 +145,7 @@ public class ReplicateCacheListenerDistributedTest
implements Serializable {
region.put(KEY, 0, cacheRule.getSystem().getDistributedMember());
region.destroy(KEY);
-
assertThat(sharedCountersRule.getTotal(DESTROYS)).isEqualTo(expectedDestroys());
+
assertThat(distributedCounters.getTotal(DESTROYS)).isEqualTo(expectedDestroys());
}
protected Region<String, Integer> createRegion(final String name,
@@ -210,7 +210,7 @@ public class ReplicateCacheListenerDistributedTest
implements Serializable {
@Override
public void afterCreate(final EntryEvent<String, Integer> event) {
- sharedCountersRule.increment(CREATES);
+ distributedCounters.increment(CREATES);
errorCollector.checkThat(event.getDistributedMember(),
equalTo(event.getCallbackArgument()));
errorCollector.checkThat(event.getOperation(),
equalTo(Operation.CREATE));
@@ -237,7 +237,7 @@ public class ReplicateCacheListenerDistributedTest
implements Serializable {
@Override
public void afterUpdate(final EntryEvent<String, Integer> event) {
- sharedCountersRule.increment(UPDATES);
+ distributedCounters.increment(UPDATES);
errorCollector.checkThat(event.getDistributedMember(),
equalTo(event.getCallbackArgument()));
errorCollector.checkThat(event.getOperation(),
equalTo(Operation.UPDATE));
@@ -264,7 +264,7 @@ public class ReplicateCacheListenerDistributedTest
implements Serializable {
@Override
public void afterInvalidate(final EntryEvent<String, Integer> event) {
- sharedCountersRule.increment(INVALIDATES);
+ distributedCounters.increment(INVALIDATES);
if (event.isOriginRemote()) {
errorCollector.checkThat(event.getDistributedMember(),
@@ -288,7 +288,7 @@ public class ReplicateCacheListenerDistributedTest
implements Serializable {
@Override
public void afterDestroy(final EntryEvent<String, Integer> event) {
- sharedCountersRule.increment(DESTROYS);
+ distributedCounters.increment(DESTROYS);
if (event.isOriginRemote()) {
errorCollector.checkThat(event.getDistributedMember(),
diff --git
a/geode-dunit/src/distributedTest/java/org/apache/geode/test/dunit/rules/tests/SharedCountersRuleDistributedTest.java
b/geode-dunit/src/distributedTest/java/org/apache/geode/test/dunit/rules/tests/DistributedCountersDistributedTest.java
similarity index 72%
rename from
geode-dunit/src/distributedTest/java/org/apache/geode/test/dunit/rules/tests/SharedCountersRuleDistributedTest.java
rename to
geode-dunit/src/distributedTest/java/org/apache/geode/test/dunit/rules/tests/DistributedCountersDistributedTest.java
index c6191d4..3367a8b 100644
---
a/geode-dunit/src/distributedTest/java/org/apache/geode/test/dunit/rules/tests/SharedCountersRuleDistributedTest.java
+++
b/geode-dunit/src/distributedTest/java/org/apache/geode/test/dunit/rules/tests/DistributedCountersDistributedTest.java
@@ -37,14 +37,14 @@ import org.junit.Rule;
import org.junit.Test;
import org.apache.geode.test.dunit.VM;
+import org.apache.geode.test.dunit.rules.DistributedCounters;
import org.apache.geode.test.dunit.rules.DistributedRule;
-import org.apache.geode.test.dunit.rules.SharedCountersRule;
/**
- * Distributed tests for {@link SharedCountersRule}.
+ * Distributed tests for {@link DistributedCounters}.
*/
@SuppressWarnings("serial")
-public class SharedCountersRuleDistributedTest implements Serializable {
+public class DistributedCountersDistributedTest implements Serializable {
private static final long TIMEOUT_MILLIS = getTimeout().toMillis();
private static final String ID = "ID";
@@ -57,79 +57,79 @@ public class SharedCountersRuleDistributedTest implements
Serializable {
public DistributedRule distributedRule = new DistributedRule();
@Rule
- public SharedCountersRule sharedCountersRule = new SharedCountersRule();
+ public DistributedCounters distributedCounters = new DistributedCounters();
@Test
public void
incrementingCounter_beforeInitializingIt_throwsNullPointerException() {
- assertThatThrownBy(() -> sharedCountersRule.increment(ID))
+ assertThatThrownBy(() -> distributedCounters.increment(ID))
.isInstanceOf(NullPointerException.class);
}
@Test
public void referencingCounter_beforeInitializingIt_returnsNull() {
- assertThat(sharedCountersRule.reference(ID)).isNull();
+ assertThat(distributedCounters.reference(ID)).isNull();
}
@Test
public void gettingCounter_afterInitializingIt_returnsZero() {
-
assertThat(sharedCountersRule.initialize(ID).reference(ID).get()).isEqualTo(0);
+
assertThat(distributedCounters.initialize(ID).reference(ID).get()).isEqualTo(0);
}
@Test
public void initializingCounterMoreThanOnce_initializesItJustOnce() {
-
assertThat(sharedCountersRule.initialize(ID).initialize(ID).reference(ID).get()).isEqualTo(0);
+
assertThat(distributedCounters.initialize(ID).initialize(ID).reference(ID).get()).isEqualTo(0);
}
@Test
public void gettingCounter_afterIncrementingIt_returnsOne() {
-
assertThat(sharedCountersRule.initialize(ID).increment(ID).reference(ID).get()).isEqualTo(1);
+
assertThat(distributedCounters.initialize(ID).increment(ID).reference(ID).get()).isEqualTo(1);
}
@Test
public void gettingCounter_afterIncrementingWithDeltaTwo_returnsTwo() {
- assertThat(sharedCountersRule.initialize(ID).increment(ID,
2).reference(ID).get())
+ assertThat(distributedCounters.initialize(ID).increment(ID,
2).reference(ID).get())
.isEqualTo(2);
}
@Test
public void gettingCounter_afterIncrementingTwice_returnsTwo() {
assertThat(
-
sharedCountersRule.initialize(ID).increment(ID).increment(ID).reference(ID).get())
+
distributedCounters.initialize(ID).increment(ID).increment(ID).reference(ID).get())
.isEqualTo(2);
}
@Test
public void getTotal_afterIncrementingOnce_returnsOne() {
- sharedCountersRule.initialize(ID).increment(ID);
+ distributedCounters.initialize(ID).increment(ID);
- int total = sharedCountersRule.getTotal(ID);
+ int total = distributedCounters.getTotal(ID);
assertThat(total).isEqualTo(1);
}
@Test
public void getTotal_afterIncrementingInEveryVm_returnsSameValueAsVmCount() {
- sharedCountersRule.initialize(ID);
+ distributedCounters.initialize(ID);
for (VM vm : getAllVMs()) {
vm.invoke(() -> {
- sharedCountersRule.increment(ID);
+ distributedCounters.increment(ID);
});
}
- int total = sharedCountersRule.getTotal(ID);
+ int total = distributedCounters.getTotal(ID);
assertThat(total).isEqualTo(getVMCount());
}
@Test
public void
getTotal_afterIncrementingInEveryVmAndController_returnsSameValueAsVmCountPlusOne()
{
- sharedCountersRule.initialize(ID).increment(ID);
+ distributedCounters.initialize(ID).increment(ID);
for (VM vm : getAllVMs()) {
vm.invoke(() -> {
- sharedCountersRule.increment(ID);
+ distributedCounters.increment(ID);
});
}
- assertThat(sharedCountersRule.getTotal(ID)).isEqualTo(getVMCount() + 1);
+ assertThat(distributedCounters.getTotal(ID)).isEqualTo(getVMCount() + 1);
}
@Test
@@ -157,57 +157,57 @@ public class SharedCountersRuleDistributedTest implements
Serializable {
int controllerPlusDUnitVMCount = dunitVMCount + 1;
int expectedIncrements = controllerPlusDUnitVMCount * numThreads;
- assertThat(sharedCountersRule.getTotal(ID)).isEqualTo(expectedIncrements);
+ assertThat(distributedCounters.getTotal(ID)).isEqualTo(expectedIncrements);
}
@Test
public void newVmInitializesExistingCounterToZero() {
- sharedCountersRule.initialize(ID);
+ distributedCounters.initialize(ID);
VM newVM = getVM(getVMCount());
- assertThat(newVM.invoke(() ->
sharedCountersRule.getLocal(ID))).isEqualTo(0);
+ assertThat(newVM.invoke(() ->
distributedCounters.getLocal(ID))).isEqualTo(0);
}
@Test
public void whenNewVmIncrementsCounter_totalIncludesThatValue() {
- sharedCountersRule.initialize(ID);
+ distributedCounters.initialize(ID);
VM newVM = getVM(getVMCount());
- newVM.invoke(() -> sharedCountersRule.increment(ID));
+ newVM.invoke(() -> distributedCounters.increment(ID));
- assertThat(sharedCountersRule.getTotal(ID)).isEqualTo(1);
+ assertThat(distributedCounters.getTotal(ID)).isEqualTo(1);
}
@Test
public void
whenBouncedVmIncrementsCounterBeforeBounce_totalIncludesThatValue() {
- sharedCountersRule.initialize(ID);
+ distributedCounters.initialize(ID);
- getVM(0).invoke(() -> sharedCountersRule.increment(ID));
+ getVM(0).invoke(() -> distributedCounters.increment(ID));
getVM(0).bounce();
- assertThat(sharedCountersRule.getTotal(ID)).isEqualTo(1);
+ assertThat(distributedCounters.getTotal(ID)).isEqualTo(1);
}
@Test
public void
whenBouncedVmIncrementsCounterAfterBounce_totalIncludesThatValue() {
- sharedCountersRule.initialize(ID);
+ distributedCounters.initialize(ID);
getVM(0).bounce();
- getVM(0).invoke(() -> sharedCountersRule.increment(ID));
+ getVM(0).invoke(() -> distributedCounters.increment(ID));
- assertThat(sharedCountersRule.getTotal(ID)).isEqualTo(1);
+ assertThat(distributedCounters.getTotal(ID)).isEqualTo(1);
}
@Test
public void
whenBouncedVmIncrementsCounterBeforeAndAfterBounce_totalIncludesThatValue() {
- sharedCountersRule.initialize(ID);
+ distributedCounters.initialize(ID);
- getVM(0).invoke(() -> sharedCountersRule.increment(ID));
+ getVM(0).invoke(() -> distributedCounters.increment(ID));
getVM(0).bounce();
- getVM(0).invoke(() -> sharedCountersRule.increment(ID));
+ getVM(0).invoke(() -> distributedCounters.increment(ID));
- assertThat(sharedCountersRule.getTotal(ID)).isEqualTo(2);
+ assertThat(distributedCounters.getTotal(ID)).isEqualTo(2);
}
@Test
@@ -216,7 +216,7 @@ public class SharedCountersRuleDistributedTest implements
Serializable {
}
private void givenSharedCounterFor(final Serializable id) {
- sharedCountersRule.initialize(id);
+ distributedCounters.initialize(id);
}
private void givenExecutorInEveryVM(final int numThreads) {
@@ -234,7 +234,7 @@ public class SharedCountersRuleDistributedTest implements
Serializable {
private void submitIncrementTasks(final int numThreads, final Serializable
id) {
for (int i = 0; i < numThreads; i++) {
futures.add(supplyAsync(() -> {
- sharedCountersRule.increment(id);
+ distributedCounters.increment(id);
return true;
}, executor));
}
@@ -251,13 +251,13 @@ public class SharedCountersRuleDistributedTest implements
Serializable {
public static class CreatedByBuilderWithId implements Serializable {
@Rule
- public SharedCountersRule countersRule = new
SharedCountersRule.Builder().withId(ID).build();
+ public DistributedCounters distCounters = new
DistributedCounters.Builder().withId(ID).build();
@Test
public void initializesCounterInEveryVm() {
for (VM vm : VM.toArray(getAllVMs(), getController())) {
vm.invoke(() -> {
- assertThat(countersRule.getLocal(ID)).isEqualTo(0);
+ assertThat(distCounters.getLocal(ID)).isEqualTo(0);
});
}
}
diff --git
a/geode-dunit/src/main/java/org/apache/geode/test/dunit/rules/SharedCountersRule.java
b/geode-dunit/src/main/java/org/apache/geode/test/dunit/rules/DistributedCounters.java
similarity index 79%
rename from
geode-dunit/src/main/java/org/apache/geode/test/dunit/rules/SharedCountersRule.java
rename to
geode-dunit/src/main/java/org/apache/geode/test/dunit/rules/DistributedCounters.java
index 7f25e40..88efb75 100644
---
a/geode-dunit/src/main/java/org/apache/geode/test/dunit/rules/SharedCountersRule.java
+++
b/geode-dunit/src/main/java/org/apache/geode/test/dunit/rules/DistributedCounters.java
@@ -30,50 +30,50 @@ import org.apache.geode.test.dunit.VM;
* JUnit Rule that provides SharedCounters in DistributedTest VMs.
*
* <p>
- * {@code SharedCountersRule} can be used in DistributedTests as a {@code
Rule}:
+ * {@code DistributedCounters} can be used in DistributedTests as a {@code
Rule}:
*
* <pre>
* {@literal @}Rule
* public DistributedRule distributedRule = new DistributedRule();
*
* {@literal @}Rule
- * public SharedCountersRule sharedCountersRule = new SharedCountersRule();
+ * public DistributedCounters distributedCounters = new DistributedCounters();
*
* {@literal @}Before
* public void setUp() {
- * sharedCountersRule.initialize("counter");
+ * distributedCounters.initialize("counter");
* }
*
* {@literal @}Test
* public void incrementCounterInEveryVm() {
- * sharedCountersRule.initialize("counter");
+ * distributedCounters.initialize("counter");
* for (VM vm : getAllVMs()) {
* vm.invoke(() -> {
- * sharedCountersRule.increment("counter");
+ * distributedCounters.increment("counter");
* });
* }
- *
assertThat(sharedCountersRule.getTotal("counter")).isEqualTo(getVMCount());
+ *
assertThat(distributedCounters.getTotal("counter")).isEqualTo(getVMCount());
* }
* </pre>
*
* <p>
- * {@link SharedCountersRule.Builder} can also be used to construct an
instance with more options:
+ * {@link DistributedCounters.Builder} can also be used to construct an
instance with more options:
*
* <pre>
* {@literal @}Rule
* public DistributedRule distributedRule = new DistributedRule();
*
* {@literal @}Rule
- * public SharedCountersRule sharedCountersRule =
SharedCountersRule.builder().withId("counter").build();
+ * public DistributedCounters distributedCounters =
DistributedCounters.builder().withId("counter").build();
*
* {@literal @}Test
* public void incrementCounterInEveryVm() {
* for (VM vm : getAllVMs()) {
* vm.invoke(() -> {
- * sharedCountersRule.increment("counter");
+ * distributedCounters.increment("counter");
* });
* }
- *
assertThat(sharedCountersRule.getTotal("counter")).isEqualTo(getVMCount());
+ *
assertThat(distributedCounters.getTotal("counter")).isEqualTo(getVMCount());
* }
* </pre>
*
@@ -82,7 +82,7 @@ import org.apache.geode.test.dunit.VM;
* {@code org.apache.geode.cache.ReplicateCacheListenerDistributedTest} in the
tests of geode-core.
*/
@SuppressWarnings("serial")
-public class SharedCountersRule extends AbstractDistributedRule {
+public class DistributedCounters extends AbstractDistributedRule {
private static volatile Map<Serializable, AtomicInteger> counters;
@@ -94,11 +94,11 @@ public class SharedCountersRule extends
AbstractDistributedRule {
return new Builder();
}
- public SharedCountersRule() {
+ public DistributedCounters() {
this(new Builder());
}
- private SharedCountersRule(final Builder builder) {
+ private DistributedCounters(final Builder builder) {
idsToInitInBefore.addAll(builder.ids);
}
@@ -156,7 +156,7 @@ public class SharedCountersRule extends
AbstractDistributedRule {
* Initialize an {@code AtomicInteger} with value of zero identified by
{@code id} in every
* {@code VM}.
*/
- public SharedCountersRule initialize(final Serializable id) {
+ public DistributedCounters initialize(final Serializable id) {
invoker().invokeInEveryVMAndController(() -> counters.putIfAbsent(id, new
AtomicInteger()));
return this;
}
@@ -171,7 +171,7 @@ public class SharedCountersRule extends
AbstractDistributedRule {
/**
* Increments the {@code AtomicInteger} identified by the specified {@code
id}.
*/
- public SharedCountersRule increment(final Serializable id) {
+ public DistributedCounters increment(final Serializable id) {
counters.get(id).incrementAndGet();
return this;
}
@@ -180,7 +180,7 @@ public class SharedCountersRule extends
AbstractDistributedRule {
* Increments the {@code AtomicInteger} by the specified {@code delta} which
may be a positive or
* negative integer.
*/
- public SharedCountersRule increment(final Serializable id, final int delta) {
+ public DistributedCounters increment(final Serializable id, final int delta)
{
counters.get(id).addAndGet(delta);
return this;
}
@@ -188,7 +188,7 @@ public class SharedCountersRule extends
AbstractDistributedRule {
/**
* Increments the {@code AtomicInteger} identified by the specified {@code
id}.
*/
- public SharedCountersRule decrement(final Serializable id) {
+ public DistributedCounters decrement(final Serializable id) {
counters.get(id).decrementAndGet();
return this;
}
@@ -196,7 +196,7 @@ public class SharedCountersRule extends
AbstractDistributedRule {
/**
* Decrements the {@code AtomicInteger} by the specified {@code delta}.
*/
- public SharedCountersRule decrement(final Serializable id, final int delta) {
+ public DistributedCounters decrement(final Serializable id, final int delta)
{
counters.get(id).addAndGet(-delta);
return this;
}
@@ -220,7 +220,7 @@ public class SharedCountersRule extends
AbstractDistributedRule {
}
/**
- * Builds an instance of SharedCountersRule
+ * Builds an instance of DistributedCounters
*/
public static class Builder {
@@ -231,15 +231,15 @@ public class SharedCountersRule extends
AbstractDistributedRule {
}
/**
- * Initialize specified id when {@code SharedCountersRule} is built.
+ * Initialize specified id when {@code DistributedCounters} is built.
*/
public Builder withId(final Serializable id) {
ids.add(id);
return this;
}
- public SharedCountersRule build() {
- return new SharedCountersRule(this);
+ public DistributedCounters build() {
+ return new DistributedCounters(this);
}
}
}
