private void testPutAll(Config config) throws TimeoutException {
TestHazelcastInstanceFactory nodeFactory = createHazelcastInstanceFactory(2);
HazelcastInstance instance1 = nodeFactory.newHazelcastInstance(config);
HazelcastInstance instance2 = nodeFactory.newHazelcastInstance(config);
final ReplicatedMap<String, String> map1 = instance1.getReplicatedMap("default");
final ReplicatedMap<String, String> map2 = instance2.getReplicatedMap("default");
final Map<String, String> mapTest = new HashMap<String, String>();
for (int i = 0; i < 100; i++) {
mapTest.put("foo-" + i, "bar");
}
WatchedOperationExecutor executor = new WatchedOperationExecutor();
executor.execute(
new Runnable() {
@Override
public void run() {
map1.putAll(mapTest);
}
},
60,
EntryEventType.ADDED,
map1,
map2);
for (Entry<String, String> entry : map2.entrySet()) {
assertStartsWith("foo-", entry.getKey());
assertEquals("bar", entry.getValue());
}
for (Entry<String, String> entry : map1.entrySet()) {
assertStartsWith("foo-", entry.getKey());
assertEquals("bar", entry.getValue());
}
}
private void testSize(Config config) throws Exception {
TestHazelcastInstanceFactory nodeFactory = createHazelcastInstanceFactory(2);
HazelcastInstance instance1 = nodeFactory.newHazelcastInstance(config);
HazelcastInstance instance2 = nodeFactory.newHazelcastInstance(config);
final ReplicatedMap<Integer, Integer> map1 = instance1.getReplicatedMap("default");
final ReplicatedMap<Integer, Integer> map2 = instance2.getReplicatedMap("default");
final AbstractMap.SimpleEntry<Integer, Integer>[] testValues = buildTestValues();
WatchedOperationExecutor executor = new WatchedOperationExecutor();
executor.execute(
new Runnable() {
@Override
public void run() {
int half = testValues.length / 2;
for (int i = 0; i < testValues.length; i++) {
final ReplicatedMap<Integer, Integer> map = i < half ? map1 : map2;
final AbstractMap.SimpleEntry<Integer, Integer> entry = testValues[i];
map.put(entry.getKey(), entry.getValue());
}
}
},
60,
EntryEventType.ADDED,
100,
1,
map1,
map2);
assertMatchSuccessfulOperationQuota(1, map1.size(), map2.size());
}
private void testAddEntryListener(Config config) throws TimeoutException {
TestHazelcastInstanceFactory nodeFactory = createHazelcastInstanceFactory(2);
HazelcastInstance instance1 = nodeFactory.newHazelcastInstance(config);
HazelcastInstance instance2 = nodeFactory.newHazelcastInstance(config);
final ReplicatedMap<String, String> map1 = instance1.getReplicatedMap("default");
final ReplicatedMap<String, String> map2 = instance2.getReplicatedMap("default");
SimpleEntryListener listener = new SimpleEntryListener(1, 0);
map2.addEntryListener(listener, "foo-18");
final int operations = 100;
WatchedOperationExecutor executor = new WatchedOperationExecutor();
executor.execute(
new Runnable() {
@Override
public void run() {
for (int i = 0; i < operations; i++) {
map1.put("foo-" + i, "bar");
}
}
},
60,
EntryEventType.ADDED,
operations,
1,
map1,
map2);
assertOpenEventually(listener.addLatch);
}
private void execute(
final Runnable runnable,
final EntryEventType type,
final int operations,
final double minExpectation,
ReplicatedMap... maps)
throws TimeoutException {
final WatchedOperationExecutor executor = new WatchedOperationExecutor();
executor.execute(runnable, 60, type, operations, minExpectation, maps);
}
private void testClear(Config config) throws Exception {
TestHazelcastInstanceFactory nodeFactory = createHazelcastInstanceFactory(2);
HazelcastInstance instance1 = nodeFactory.newHazelcastInstance(config);
HazelcastInstance instance2 = nodeFactory.newHazelcastInstance(config);
final ReplicatedMap<String, String> map1 = instance1.getReplicatedMap("default");
final ReplicatedMap<String, String> map2 = instance2.getReplicatedMap("default");
final int operations = 100;
WatchedOperationExecutor executor = new WatchedOperationExecutor();
executor.execute(
new Runnable() {
@Override
public void run() {
for (int i = 0; i < operations; i++) {
map1.put("foo-" + i, "bar");
}
}
},
60,
EntryEventType.ADDED,
operations,
1,
map1,
map2);
for (Entry<String, String> entry : map2.entrySet()) {
assertStartsWith("foo-", entry.getKey());
assertEquals("bar", entry.getValue());
}
for (Entry<String, String> entry : map1.entrySet()) {
assertStartsWith("foo-", entry.getKey());
assertEquals("bar", entry.getValue());
}
final AtomicBoolean happened = new AtomicBoolean(false);
for (int i = 0; i < 10; i++) {
map1.clear();
Thread.sleep(1000);
try {
assertEquals(0, map1.size());
assertEquals(0, map2.size());
happened.set(true);
} catch (AssertionError ignore) {
// ignore and retry
}
if (happened.get()) {
break;
}
}
}
private void testEntrySet(Config config) throws Exception {
TestHazelcastInstanceFactory nodeFactory = createHazelcastInstanceFactory(2);
HazelcastInstance instance1 = nodeFactory.newHazelcastInstance(config);
HazelcastInstance instance2 = nodeFactory.newHazelcastInstance(config);
final ReplicatedMap<Integer, Integer> map1 = instance1.getReplicatedMap("default");
final ReplicatedMap<Integer, Integer> map2 = instance2.getReplicatedMap("default");
final AbstractMap.SimpleEntry<Integer, Integer>[] testValues = buildTestValues();
WatchedOperationExecutor executor = new WatchedOperationExecutor();
executor.execute(
new Runnable() {
@Override
public void run() {
int half = testValues.length / 2;
for (int i = 0; i < testValues.length; i++) {
final ReplicatedMap<Integer, Integer> map = i < half ? map1 : map2;
final AbstractMap.SimpleEntry<Integer, Integer> entry = testValues[i];
map.put(entry.getKey(), entry.getValue());
}
}
},
60,
EntryEventType.ADDED,
100,
1,
map1,
map2);
List<Entry<Integer, Integer>> entrySet1 = copyToList(map1.entrySet());
List<Entry<Integer, Integer>> entrySet2 = copyToList(map2.entrySet());
int map2Contains = 0;
for (Entry<Integer, Integer> entry : entrySet2) {
System.out.println("Entry: " + entry);
Integer value = findValue(entry.getKey(), testValues);
if (value.equals(entry.getValue())) {
map2Contains++;
}
}
int map1Contains = 0;
for (Entry<Integer, Integer> entry : entrySet1) {
Integer value = findValue(entry.getKey(), testValues);
if (value.equals(entry.getValue())) {
map1Contains++;
}
}
assertMatchSuccessfulOperationQuota(1, testValues.length, map1Contains, map2Contains);
}
private void testKeySet(Config config) throws Exception {
TestHazelcastInstanceFactory nodeFactory = createHazelcastInstanceFactory(2);
HazelcastInstance instance1 = nodeFactory.newHazelcastInstance(config);
HazelcastInstance instance2 = nodeFactory.newHazelcastInstance(config);
final ReplicatedMap<Integer, Integer> map1 = instance1.getReplicatedMap("default");
final ReplicatedMap<Integer, Integer> map2 = instance2.getReplicatedMap("default");
final AbstractMap.SimpleEntry<Integer, Integer>[] testValues = buildTestValues();
final List<Integer> keySetTestValues = new ArrayList<Integer>(testValues.length);
WatchedOperationExecutor executor = new WatchedOperationExecutor();
executor.execute(
new Runnable() {
@Override
public void run() {
int half = testValues.length / 2;
for (int i = 0; i < testValues.length; i++) {
final ReplicatedMap<Integer, Integer> map = i < half ? map1 : map2;
final AbstractMap.SimpleEntry<Integer, Integer> entry = testValues[i];
map.put(entry.getKey(), entry.getValue());
keySetTestValues.add(entry.getKey());
}
}
},
60,
EntryEventType.ADDED,
100,
1,
map1,
map2);
List<Integer> keySet1 = copyToList(map1.keySet());
List<Integer> keySet2 = copyToList(map2.keySet());
int map1Contains = 0;
int map2Contains = 0;
for (Integer value : keySetTestValues) {
if (keySet2.contains(value)) {
map2Contains++;
}
if (keySet1.contains(value)) {
map1Contains++;
}
}
assertMatchSuccessfulOperationQuota(1, testValues.length, map1Contains, map2Contains);
}
private void testContainsKey(Config config) throws Exception {
TestHazelcastInstanceFactory nodeFactory = createHazelcastInstanceFactory(2);
HazelcastInstance instance1 = nodeFactory.newHazelcastInstance(config);
HazelcastInstance instance2 = nodeFactory.newHazelcastInstance(config);
final ReplicatedMap<String, String> map1 = instance1.getReplicatedMap("default");
final ReplicatedMap<String, String> map2 = instance2.getReplicatedMap("default");
final int operations = 100;
WatchedOperationExecutor executor = new WatchedOperationExecutor();
executor.execute(
new Runnable() {
@Override
public void run() {
for (int i = 0; i < operations; i++) {
map1.put("foo-" + i, "bar");
}
}
},
60,
EntryEventType.ADDED,
operations,
1,
map1,
map2);
int map2Contains = 0;
for (int i = 0; i < operations; i++) {
if (map2.containsKey("foo-" + i)) {
map2Contains++;
}
}
int map1Contains = 0;
for (int i = 0; i < operations; i++) {
if (map1.containsKey("foo-" + i)) {
map1Contains++;
}
}
assertMatchSuccessfulOperationQuota(1, operations, map1Contains, map2Contains);
}
private void testRemove(Config config) throws Exception {
TestHazelcastInstanceFactory nodeFactory = createHazelcastInstanceFactory(2);
HazelcastInstance instance1 = nodeFactory.newHazelcastInstance(config);
HazelcastInstance instance2 = nodeFactory.newHazelcastInstance(config);
final ReplicatedMap<String, String> map1 = instance1.getReplicatedMap("default");
final ReplicatedMap<String, String> map2 = instance2.getReplicatedMap("default");
final int operations = 100;
WatchedOperationExecutor executor = new WatchedOperationExecutor();
executor.execute(
new Runnable() {
@Override
public void run() {
for (int i = 0; i < operations; i++) {
map1.put("foo-" + i, "bar");
}
}
},
60,
EntryEventType.ADDED,
operations,
1,
map1,
map2);
for (Entry<String, String> entry : map2.entrySet()) {
assertStartsWith("foo-", entry.getKey());
assertEquals("bar", entry.getValue());
}
for (Entry<String, String> entry : map1.entrySet()) {
assertStartsWith("foo-", entry.getKey());
assertEquals("bar", entry.getValue());
}
executor.execute(
new Runnable() {
@Override
public void run() {
for (int i = 0; i < operations; i++) {
map2.remove("foo-" + i);
}
}
},
60,
EntryEventType.REMOVED,
operations,
1,
map1,
map2);
int map2Updated = 0;
for (int i = 0; i < operations; i++) {
Object value = map2.get("foo-" + i);
if (value == null) {
map2Updated++;
}
}
int map1Updated = 0;
for (int i = 0; i < operations; i++) {
Object value = map1.get("foo-" + i);
if (value == null) {
map1Updated++;
}
}
assertMatchSuccessfulOperationQuota(1, operations, map1Updated, map2Updated);
}
private void testUpdateTtl(Config config) throws Exception {
TestHazelcastInstanceFactory nodeFactory = createHazelcastInstanceFactory(2);
HazelcastInstance instance1 = nodeFactory.newHazelcastInstance(config);
HazelcastInstance instance2 = nodeFactory.newHazelcastInstance(config);
final ReplicatedMap<String, String> map1 = instance1.getReplicatedMap("default");
final ReplicatedMap<String, String> map2 = instance2.getReplicatedMap("default");
final int operations = 100;
WatchedOperationExecutor executor = new WatchedOperationExecutor();
executor.execute(
new Runnable() {
@Override
public void run() {
for (int i = 0; i < operations; i++) {
map1.put("foo-" + i, "bar");
}
}
},
60,
EntryEventType.ADDED,
operations,
1,
map1,
map2);
for (Entry<String, String> entry : map2.entrySet()) {
assertStartsWith("foo-", entry.getKey());
assertEquals("bar", entry.getValue());
}
for (Entry<String, String> entry : map1.entrySet()) {
assertStartsWith("foo-", entry.getKey());
assertEquals("bar", entry.getValue());
}
executor.execute(
new Runnable() {
@Override
public void run() {
for (int i = 0; i < operations; i++) {
map2.put("foo-" + i, "bar", 10, TimeUnit.MINUTES);
}
}
},
60,
EntryEventType.UPDATED,
operations,
1,
map1,
map2);
int map2Updated = 0;
for (Entry<String, String> entry : map2.entrySet()) {
ReplicatedRecord record = getReplicatedRecord(map2, entry.getKey());
if (record.getTtlMillis() > 0) {
map2Updated++;
}
}
int map1Updated = 0;
for (Entry<String, String> entry : map1.entrySet()) {
ReplicatedRecord record = getReplicatedRecord(map1, entry.getKey());
if (record.getTtlMillis() > 0) {
map1Updated++;
}
}
assertMatchSuccessfulOperationQuota(1, operations, map1Updated, map2Updated);
}
private void testAddTtl(Config config) throws Exception {
TestHazelcastInstanceFactory nodeFactory = createHazelcastInstanceFactory(2);
HazelcastInstance instance1 = nodeFactory.newHazelcastInstance(config);
HazelcastInstance instance2 = nodeFactory.newHazelcastInstance(config);
final ReplicatedMap<String, String> map1 = instance1.getReplicatedMap("default");
final ReplicatedMap<String, String> map2 = instance2.getReplicatedMap("default");
final int operations = 100;
WatchedOperationExecutor executor = new WatchedOperationExecutor();
executor.execute(
new Runnable() {
@Override
public void run() {
for (int i = 0; i < operations; i++) {
map1.put("foo-" + i, "bar", 10, TimeUnit.MINUTES);
}
}
},
60,
EntryEventType.ADDED,
operations,
1,
map1,
map2);
// Give a bit of time to process last batch of updates
TimeUnit.SECONDS.sleep(2);
Set<Entry<String, String>> map2entries = map2.entrySet();
for (Entry<String, String> entry : map2entries) {
assertStartsWith("foo-", entry.getKey());
assertEquals("bar", entry.getValue());
ReplicatedRecord<String, String> record = getReplicatedRecord(map2, entry.getKey());
assertNotEquals(0, record.getTtlMillis());
// Kill the record by setting timeout
record.setValue(record.getValue(), 1);
}
Set<Entry<String, String>> map1entries = map1.entrySet();
for (Entry<String, String> entry : map1entries) {
assertStartsWith("foo-", entry.getKey());
assertEquals("bar", entry.getValue());
ReplicatedRecord<String, String> record = getReplicatedRecord(map1, entry.getKey());
assertNotEquals(0, record.getTtlMillis());
// Kill the record by setting timeout
record.setValue(record.getValue(), 1);
}
TimeUnit.SECONDS.sleep(1);
int map2Updated = 0;
for (Entry<String, String> entry : map2entries) {
if (map2.get(entry.getKey()) == null) {
map2Updated++;
}
}
int map1Updated = 0;
for (Entry<String, String> entry : map1entries) {
if (map1.get(entry.getKey()) == null) {
map1Updated++;
}
}
assertMatchSuccessfulOperationQuota(1, operations, map1Updated, map2Updated);
}
