public virtual void TestPutTransient()
{
Assert.AreEqual(0, map.Size());
map.PutTransient("key1", "value1", 100, TimeUnit.Milliseconds);
Assert.AreEqual("value1", map.Get("key1"));
TestSupport.AssertTrueEventually(() => { Assert.AreNotEqual("value1", map.Get("key1")); });
}
public void TestPut_ttl()
{
ReplicatedMap.Put(1, "value1", 5, TimeUnit.Seconds);
var value = ReplicatedMap.Get(1);
Assert.AreEqual(value, "value1");
TestSupport.AssertTrueEventually(() => { Assert.Null(ReplicatedMap.Get(1)); });
}
public virtual void TestPutTtl()
{
var ttl = 100;
map.Put("key1", "value1", ttl, TimeUnit.Milliseconds);
Assert.IsNotNull(map.Get("key1"));
TestSupport.AssertTrueEventually(() => { Assert.IsNull(map.Get("key1")); });
}
public virtual void TestSet()
{
map.Set("key1", "value1");
Assert.AreEqual("value1", map.Get("key1"));
map.Set("key1", "value2");
Assert.AreEqual("value2", map.Get("key1"));
map.Set("key1", "value3", 100, TimeUnit.Milliseconds);
Assert.AreEqual("value3", map.Get("key1"));
TestSupport.AssertTrueEventually(() => Assert.IsNull(map.Get("key1")));
}
public virtual void TestPutTransient()
{
Assert.AreEqual(0, map.Size());
var ttl = 100;
map.PutTransient("key1", "value1", 100, TimeUnit.MILLISECONDS);
Assert.AreEqual("value1", map.Get("key1"));
TestSupport.AssertTrueEventually(() =>
{
Assert.AreNotEqual("value1", map.Get("key1"));
});
}
public void TestPutIfAbsentTTL_whenExpire()
{
object key = "Key";
object value = "Value";
var ttl = 100;
var result = map.PutIfAbsent(key, value, ttl, TimeUnit.MILLISECONDS);
TestSupport.AssertTrueEventually(() => {
Assert.AreEqual(null, result);
Assert.AreEqual(null, map.Get(key));
});
}
public virtual void TestAsyncPutWithTtl()
{
var latch = new CountdownEvent(1);
map.AddEntryListener(new ExpiredListener(latch), true);
var f1 = map.PutAsync("key", "value1", 3, TimeUnit.Seconds);
Assert.IsNull(f1.Result);
Assert.AreEqual("value1", map.Get("key"));
Assert.IsTrue(latch.Wait(TimeSpan.FromSeconds(15)));
TestSupport.AssertTrueEventually(() => { Assert.IsNull(map.Get("key")); });
}
public void TestPartitionsUpdatedAfterNewNode()
{
var proxy = (HazelcastClientProxy)_client;
var partitionService = proxy.GetClient().GetClientPartitionService();
var partitionCount = partitionService.GetPartitionCount();
Assert.AreEqual(271, partitionCount);
var owners = GetPartitionOwners(partitionCount, partitionService);
Assert.AreEqual(1, owners.Count);
var member = StartMemberAndWait(_client, _remoteController, _cluster, 2);
try
{
TestSupport.AssertTrueEventually(() =>
{
try
{
owners = GetPartitionOwners(partitionCount, partitionService);
}
catch (TargetNotMemberException)
{
Assert.Fail("Partition table is stale.");
}
Assert.AreEqual(2, owners.Count);
});
}
finally
{
StopMemberAndWait(_client, _remoteController, _cluster, member);
TestSupport.AssertTrueEventually(() =>
{
try
{
owners = GetPartitionOwners(partitionCount, partitionService);
}
catch (TargetNotMemberException)
{
Assert.Fail("Partition table is stale.");
}
Assert.AreEqual(1, owners.Count);
}, 60);
}
}
public void TestPutWithTTL()
{
var context = Client.NewTransactionContext();
context.BeginTransaction();
var txnMap = context.GetMap <object, object>(_name);
var ttlMillis = 100;
Assert.IsNull(txnMap.Put("key1", "value1", ttlMillis, TimeUnit.Milliseconds));
Assert.AreEqual("value1", txnMap.Get("key1"));
context.CommitTransaction();
Assert.AreEqual("value1", _map.Get("key1"));
TestSupport.AssertTrueEventually(() => Assert.IsNull(_map.Get("key1")));
}
public void TestStatisticsContent()
{
TestSupport.AssertTrueEventually(() =>
{
var stat = GetClientStatsFromServer();
Assert.NotNull(stat);
Assert.True(stat.Contains("clientName=" + Client.GetName()));
Assert.True(stat.Contains("lastStatisticsCollectionTime="));
Assert.True(stat.Contains("enterprise=false"));
Assert.True(stat.Contains("clientType=CSHARP"));
Assert.True(stat.Contains("clientVersion=" + VersionUtil.GetDllVersion()));
var ownerConnectionAddress = ClientInternal.GetClientClusterService().GetOwnerConnectionAddress();
var ownerConnection = ClientInternal.GetConnectionManager().GetConnection(ownerConnectionAddress);
Assert.True(stat.Contains("clusterConnectionTimestamp=" + ownerConnection.ConnectionStartTime));
Assert.True(stat.Contains("clientAddress=" + ownerConnection.GetLocalSocketAddress()));
});
}
protected Member StartMemberAndWait(IHazelcastInstance client, IRemoteController remoteController, Cluster cluster,
int expectedSize)
{
var resetEvent = new ManualResetEventSlim();
var regId = client.Cluster.AddMembershipListener(new MembershipListener {
OnMemberAdded = @event => resetEvent.Set()
});
var member = StartMember(remoteController, cluster);
Assert.IsTrue(resetEvent.Wait(120 * 1000), "The member did not get added in 120 seconds");
Assert.IsTrue(client.Cluster.RemoveMembershipListener(regId));
// make sure partitions are updated
TestSupport.AssertTrueEventually(() => { Assert.AreEqual(expectedSize, GetUniquePartitionOwnerCount(client)); }, 60,
"The partition list did not contain " + expectedSize + " partitions.");
return(member);
}
public void TestNearCacheStatisticsContent()
{
var map = Client.GetMap <string, string>("nearCachedMap1");
map.Put("key", "value");
map.Get("key");
map.Get("key");
map.Get("other-key");
TestSupport.AssertTrueEventually(() =>
{
var stat = GetClientStatsFromServer();
Assert.NotNull(stat);
Assert.True(stat.Contains("nc.nearCachedMap1.hits=1"));
Assert.True(stat.Contains("nc.nearCachedMap1.misses=2"));
Assert.True(stat.Contains("nc.nearCachedMap1.ownedEntryCount=1"));
});
}
protected int AddNodeAndWait()
{
var resetEvent = new ManualResetEventSlim();
var regId = Client.GetCluster().AddMembershipListener(new MembershipListener
{
OnMemberAdded = @event => resetEvent.Set()
});
var id = Cluster.AddNode();
Assert.IsTrue(resetEvent.Wait(120 * 1000), "The member did not get added in 120 seconds");
Assert.IsTrue(Client.GetCluster().RemoveMembershipListener(regId));
// make sure partitions are updated
TestSupport.AssertTrueEventually(() => { Assert.AreEqual(Cluster.Size, GetUniquePartitionOwnerCount()); },
60, "The partition list did not contain " + Cluster.Size + " partitions.");
return(id);
}
public virtual void TestAsyncPutWithTtl()
{
var latch = new CountdownEvent(1);
map.AddEntryListener(new EntryAdapter <object, object>(
delegate { },
delegate { },
delegate { },
delegate { latch.Signal(); }
), true);
var f1 = map.PutAsync("key", "value1", 1, TimeUnit.Seconds);
Assert.IsNull(f1.Result);
Assert.AreEqual("value1", map.Get("key"));
Assert.IsTrue(latch.Wait(TimeSpan.FromSeconds(10)));
TestSupport.AssertTrueEventually(() => { Assert.IsNull(map.Get("key")); });
}
public void TestRetryAsyncRequest()
{
int count = 100;
var nodeId = AddNodeAndWait();
var map = Client.GetMap <int, string>(TestSupport.RandomString());
for (var i = 0; i < count; i++)
{
map.PutAsync(i, TestSupport.RandomString());
}
Cluster.RemoveNode(nodeId);
TestSupport.AssertTrueEventually(() =>
{
var keys = map.KeySet();
for (var i = 0; i < count; i++)
{
Assert.IsTrue(keys.Contains(i), "Key " + i + " was not found");
}
Assert.AreEqual(count, map.Size());
}, timeoutSeconds: 60);
}
public void TestNearCacheGetAsync()
{
_map.Put("key", "value");
var val = _map.GetAsync("key");
var result = val.Result;
Assert.AreEqual("value", result);
var clientNearCache = GetNearCache(_map);
TestSupport.AssertTrueEventually(() => { Assert.AreEqual(1, clientNearCache.Cache.Count); });
val = _map.GetAsync("key");
result = val.Result;
Assert.AreEqual("value", result);
var cacheRecord = clientNearCache.Cache.Values.ToArray()[0];
Assert.AreEqual(1, cacheRecord.Hit.Get());
}
public void TestSchedule_completed()
{
var executed = false;
var continued = false;
_clientExecutionService.Schedule(() =>
{
executed = true;
}, 2, TimeUnit.Seconds)
.ContinueWith(t =>
{
if (!t.IsCanceled)
{
continued = true;
}
}
);
TestSupport.AssertTrueEventually(() =>
{
Assert.True(executed);
Assert.True(continued);
});
}
public void TestListenerEventOrder()
{
const int maxSize = 10000;
var map2 = Client.GetMap <int, int>(TestSupport.RandomString());
map2.Put(1, 0);
var eventDataReceived = new Queue <int>();
var listener = new EntryAdapter <int, int>(
e => { },
e => { },
e =>
{
var value = e.GetValue();
eventDataReceived.Enqueue(value);
},
e => { });
map2.AddEntryListener(listener, true);
for (var i = 1; i < maxSize; i++)
{
map2.Put(1, i);
}
TestSupport.AssertTrueEventually(() => Assert.AreEqual(maxSize - 1, eventDataReceived.Count));
var oldEventData = -1;
foreach (var eventData in eventDataReceived)
{
Assert.Less(oldEventData, eventData);
oldEventData = eventData;
}
}
public void TestRetryRequestsWhenInstanceIsShutdown()
{
var nodeId = AddNodeAndWait();
var map = Client.GetMap <int, string>(TestSupport.RandomString());
for (int i = 0; i < Count; i++)
{
map.Put(i, TestSupport.RandomString());
if (i == Count / 2)
{
Cluster.RemoveNode(nodeId);
}
}
TestSupport.AssertTrueEventually(() =>
{
var keys = map.KeySet();
for (int i = 0; i < Count; i++)
{
Assert.IsTrue(keys.Contains(i), "Key " + i + " was not found");
}
Assert.AreEqual(Count, map.Size());
}, timeoutSeconds: 60);
}
private void TestInvalidate(Action <IMap <string, string>, string> invalidatingAction)
{
var map = Client.GetMap <string, string>("nearCacheMapInvalidate-" + TestSupport.RandomString());
try
{
map.Put("key", "value");
var val = map.Get("key");
Assert.AreEqual("value", val);
var clientNearCache = GetNearCache(map);
Assert.AreEqual(1, clientNearCache.Cache.Count);
var client = CreateClient();
try
{
invalidatingAction(client.GetMap <string, string>(map.GetName()), "key");
}
finally
{
client.Shutdown();
}
TestSupport.AssertTrueEventually(() =>
{
Assert.IsFalse(clientNearCache.Cache.ContainsKey(ToKeyData("key")),
"key should have been invalidated");
});
}
finally
{
map.Destroy();
}
}
public void TestScheduleWithCancellation_cancelled()
{
var executed = false;
var continued = false;
_clientExecutionService.ScheduleWithCancellation(() =>
{
executed = true;
}, 2, TimeUnit.Seconds, cts.Token)
.ContinueWith(t =>
{
if (!t.IsCanceled)
{
continued = true;
}
}
);
cts.Cancel();
TestSupport.AssertTrueEventually(() =>
{
Assert.False(executed);
Assert.False(continued);
});
}
public void TestListenerReconnect()
{
var member = StartMember(_remoteController, _cluster);
var client = CreateClient();
var name = TestSupport.RandomString();
var map = client.GetMap <string, string>(name);
var eventCount = 0;
var count = 2;
var regId = map.AddEntryListener(new EntryAdapter <string, string>
{
Added = e => { Interlocked.Increment(ref eventCount); }
}, true);
// try to start and stop the instance several times
for (var i = 0; i < count; i++)
{
var clientDisconnected = TestSupport.WaitForClientState(client,
LifecycleEvent.LifecycleState.ClientDisconnected);
_remoteController.shutdownMember(_cluster.Id, member.Uuid);
TestSupport.AssertCompletedEventually(clientDisconnected, taskName: "clientDisconnected");
Interlocked.Exchange(ref eventCount, 0);
var clientConnected = TestSupport.WaitForClientState(client,
LifecycleEvent.LifecycleState.ClientConnected);
member = _remoteController.startMember(_cluster.Id);
TestSupport.AssertCompletedEventually(clientConnected, taskName: "clientConnected");
TestSupport.AssertTrueEventually(() =>
{
map.Put(Guid.NewGuid().ToString(), Guid.NewGuid().ToString());
return(eventCount > 0);
});
}
Assert.IsTrue(map.RemoveEntryListener(regId));
map.Destroy();
}
public void TestNearCacheTtlEviction()
{
var map = Client.GetMap <int, int>("nearCacheTtl-" + TestSupport.RandomString());
var keys = Enumerable.Range(0, 10).ToList();
foreach (var k in keys)
{
map.Put(k, k);
}
map.GetAll(keys);
var cache = GetNearCache(map);
Assert.AreEqual(keys.Count, cache.Cache.Count);
TestSupport.AssertTrueEventually(() =>
{
map.Get(100); //force ttl check
foreach (var k in keys)
{
var keyData = ((HazelcastClientProxy)Client).GetClient().GetSerializationService().ToData(k);
Assert.IsFalse(cache.Cache.ContainsKey(keyData), "key " + k + " should have expired.");
}
});
}
private void AssertCounterValueEventually(long expectedValue, IPNCounter counter)
{
TestSupport.AssertTrueEventually(() => { Assert.AreEqual(expectedValue, counter.Get()); });
}
