public void TestPreloadRequest()
{
IEntryProcessor processor = PreloadRequest.Instance;
IEntryProcessor processor1 = PreloadRequest.Instance;
Assert.AreEqual(processor, processor1);
Assert.AreEqual(processor.GetHashCode(), processor1.GetHashCode());
Assert.AreEqual(processor.ToString(), processor1.ToString());
INamedCache cache = CacheFactory.GetCache(CacheName);
cache.Clear();
Temperature bgd = new Temperature(25, 'c', 12);
Temperature nyc = new Temperature(99, 'f', 12);
cache.Insert("BGD", bgd);
cache.Insert("NYC", nyc);
object o = cache.Invoke("BGD", processor);
Assert.IsNull(o);
CacheFactory.Shutdown();
}
public void TestClearAndCount()
{
IConfigurableCacheFactory ccf = CacheFactory.ConfigurableCacheFactory;
IXmlDocument config = XmlHelper.LoadXml("assembly://Coherence.Tests/Tangosol.Resources/s4hc-local-cache-config.xml");
ccf.Config = config;
INamedCache cache = CacheFactory.GetCache("local-default");
cache.Clear();
Assert.AreEqual(0, cache.Count);
cache.Insert("key1", "value1");
Assert.AreEqual(1, cache.Count);
cache.Insert("key2", "value2");
Assert.AreEqual(2, cache.Count);
cache.Insert("key3", "value3");
cache.Insert("key4", "value4");
Assert.AreEqual(4, cache.Count);
cache.Clear();
Assert.AreEqual(0, cache.Count);
CacheFactory.Shutdown();
}
public void CompositeCacheGetAllWithSameKeys()
{
INamedCache safecache = CacheFactory.GetCache(CacheName);
// ListenAll
CompositeCache ccache = new CompositeCache(new LocalNamedCache(),
safecache,
CompositeCacheStrategyType.ListenAll);
ccache.Clear();
Hashtable ht = new Hashtable();
ht.Add(1, "Aleks");
ht.Add(2, "Ana");
ht.Add(3, "Goran");
ht.Add(4, "Ivan");
ccache.InsertAll(ht);
int[] keys1 = { 1, 1, 1, 2, 3, 10, 10 };
IDictionary result = ccache.GetAll(keys1);
Assert.AreEqual(3, result.Count);
safecache.Insert(5, "Milos");
int[] keys2 = { 1, 1, 1, 2, 3, 5, 10, 10 };
result = ccache.GetAll(keys2);
Assert.AreEqual(4, result.Count);
ccache.Release();
// ListenNone
ccache = new CompositeCache(new LocalNamedCache(),
safecache,
CompositeCacheStrategyType.ListenNone);
ccache.Clear();
ccache.InsertAll(ht);
result = ccache.GetAll(keys1);
Assert.AreEqual(3, result.Count);
safecache.Insert(5, "Milos");
result = ccache.GetAll(keys2);
Assert.AreEqual(4, result.Count);
ccache.Release();
// ListenPresent
ccache = new CompositeCache(new LocalNamedCache(),
safecache,
CompositeCacheStrategyType.ListenPresent);
ccache.Clear();
ccache.InsertAll(ht);
result = ccache.GetAll(keys1);
Assert.AreEqual(3, result.Count);
safecache.Insert(5, "Milos");
result = ccache.GetAll(keys2);
Assert.AreEqual(4, result.Count);
safecache.Remove(1);
result = ccache.GetAll(keys2);
Assert.AreEqual(3, result.Count);
}
public void TestDoubleMaxAggregator()
{
DoubleMax agg1 = new DoubleMax(IdentityExtractor.Instance);
Assert.IsNotNull(agg1);
Assert.AreSame(IdentityExtractor.Instance, agg1.Extractor);
DoubleMax agg2 = new DoubleMax("dummy");
Assert.IsNotNull(agg2);
Assert.IsInstanceOf(typeof(ReflectionExtractor), agg2.Extractor);
DoubleMax agg3 = new DoubleMax("another.dummy");
Assert.IsNotNull(agg3);
Assert.IsInstanceOf(typeof(ChainedExtractor), agg3.Extractor);
ArrayList al = new ArrayList();
al.Add(new TestInvocableCacheEntry("Ivan", 173.6));
al.Add(new TestInvocableCacheEntry("Milica", 173.22));
al.Add(new TestInvocableCacheEntry("Goran", 185.1));
al.Add(new TestInvocableCacheEntry("Ana", 164.08));
Assert.AreEqual(185.1, agg1.Aggregate(al));
// aggragation on remote cache
INamedCache cache = CacheFactory.GetCache(CacheName);
cache.Clear();
Hashtable ht = new Hashtable();
ht.Add("key1", 100);
ht.Add("key2", 80.5);
ht.Add("key3", 19.5);
ht.Add("key4", 2);
ht.Add("key5", 1011);
cache.InsertAll(ht);
IEntryAggregator aggregator = new DoubleMax(IdentityExtractor.Instance);
object result = cache.Aggregate(cache.Keys, aggregator);
Assert.AreEqual(1011, result);
cache.Insert("key5", Int32.MaxValue);
result = cache.Aggregate(cache.Keys, aggregator);
Assert.AreEqual((double)Int32.MaxValue, result);
cache.Insert("key6", Int64.MaxValue);
result = cache.Aggregate(cache.Keys, aggregator);
Assert.AreEqual((double)Int64.MaxValue, result);
CacheFactory.Shutdown();
}
public void TestNumberIncrementor()
{
Temperature belgrade = new Temperature(25, 'c', 1);
int bgdBefore = belgrade.Value;
PropertyManipulator valueManipulator = new PropertyManipulator("Value");
IEntryProcessor processor = new NumberIncrementor(valueManipulator, 1, true);
IEntryProcessor processor1 = new NumberIncrementor(valueManipulator, 1, true);
Assert.AreEqual(processor, processor1);
Assert.AreEqual(processor.GetHashCode(), processor1.GetHashCode());
Assert.AreEqual(processor.ToString(), processor1.ToString());
LocalCache.Entry entry = new LocalCache.Entry(new LocalCache(), "belgrade", belgrade);
processor.Process(entry);
Assert.AreEqual(bgdBefore + 1, ((Temperature)entry.Value).Value);
processor.Process(entry);
Assert.AreEqual(bgdBefore + 2, ((Temperature)entry.Value).Value);
// testing on Remote cache
INamedCache cache = CacheFactory.GetCache(CacheName);
cache.Clear();
Temperature bgd = new Temperature(25, 'c', 12);
Temperature nyc = new Temperature(99, 'f', 12);
cache.Insert("BGD", bgd);
cache.Insert("NYC", nyc);
PropertyManipulator manipulator = new PropertyManipulator("Value");
processor = new NumberIncrementor(manipulator, 1, true);
object before = cache.Invoke("BGD", processor);
Assert.AreEqual(bgd.Value, before);
Temperature after = (Temperature)cache["BGD"];
Assert.AreEqual(((int)before) + 1, after.Value);
processor = new NumberIncrementor(manipulator, -19, false);
object newNYC = cache.Invoke("NYC", processor);
Assert.AreEqual(nyc.Value - 19, newNYC);
Score score = new Score(1, 1, 1, 1, 1, 1, 1, new RawInt128(new byte[] { 0 }), 1);
LocalCache.Entry scoreEntry = new LocalCache.Entry(new LocalCache(), "score", score);
valueManipulator = new PropertyManipulator("RawInt128Value");
processor = new NumberIncrementor(valueManipulator, 1, true);
processor.Process(scoreEntry);
CacheFactory.Shutdown();
}
public void TestNamedCacheMethods()
{
INamedCache cache = CacheFactory.GetCache(CacheName);
string key = "testNamedCacheInterfaceMethodsKey";
string value = "testNamedCacheInterfaceMethodsValue";
object[] keys = { GetKeyObject("key1"), GetKeyObject("key2"), GetKeyObject("key3") };
string[] values = { "value1", "value2", "value3" };
cache.Clear();
Assert.IsTrue(cache.Count == 0);
cache.Add(GetKeyObject(key), value);
Assert.AreEqual(cache.Count, 1);
Assert.AreEqual(cache[GetKeyObject(key)], value);
Assert.IsTrue(cache.Contains(GetKeyObject(key)));
object old = cache.Insert(keys[0], values[0]);
Assert.IsNull(old);
Assert.AreEqual(cache[keys[0]], values[0]);
IDictionary h = new Hashtable();
h.Add(keys[0], values[0]);
h.Add(keys[1], values[1]);
h.Add(keys[2], values[2]);
cache.InsertAll(h);
IList list = new ArrayList(keys);
IDictionary map = cache.GetAll(list);
Assert.AreEqual(map.Count, list.Count);
Assert.AreEqual(cache[keys[1]], map[keys[1]]);
cache.Remove(GetKeyObject(key));
Assert.IsNull(cache[GetKeyObject(key)]);
Binary bin = new Binary(new byte[] { 1, 2, 3 });
cache.Insert(GetKeyObject("key4"), bin);
object o = cache[GetKeyObject("key4")];
Assert.IsNotNull(o);
Assert.IsInstanceOf(typeof(Binary), o);
Assert.AreEqual(bin.Length, ((Binary)o).Length);
CacheFactory.ReleaseCache(cache);
CacheFactory.Shutdown();
}
public void TestExtractor()
{
Address addr = new Address("Champs-Elysees", "Paris", "France", "1616");
ExtractorProcessor extractorProcessor = new ExtractorProcessor(new ReflectionExtractor("Street"));
ExtractorProcessor extractorProcessor1 = new ExtractorProcessor(new ReflectionExtractor("Street"));
Assert.AreEqual(extractorProcessor, extractorProcessor1);
Assert.AreEqual(extractorProcessor.GetHashCode(), extractorProcessor1.GetHashCode());
Assert.AreEqual(extractorProcessor.ToString(), extractorProcessor1.ToString());
LocalCache.Entry entry = new LocalCache.Entry(new LocalCache(), "addr1", addr);
Object result = extractorProcessor.Process(entry);
Assert.AreEqual("Champs-Elysees", result);
extractorProcessor = new ExtractorProcessor(new KeyExtractor(IdentityExtractor.Instance));
result = extractorProcessor.Process(entry);
Assert.AreEqual("addr1", result);
// testing on Remote cache
INamedCache cache = CacheFactory.GetCache(CacheName);
cache.Clear();
ExtractorProcessor processor = new ExtractorProcessor(new ReflectionExtractor("getStreet"));
Address addr1 = new Address("XI krajiske divizije", "Belgrade", "Serbia", "11000");
Address addr2 = new Address("Pere Velimirovica", "Uzice", "Serbia", "11000");
Address addr3 = new Address("Rige od Fere", "Novi Sad", "Serbia", "11000");
cache.Insert("addr1", addr1);
cache.Insert("addr2", addr2);
cache.Insert("addr3", addr3);
Assert.IsTrue(cache.Count == 3);
result = cache.Invoke("addr1", processor);
Assert.IsNotNull(result);
Assert.AreEqual(addr1.Street, result as String);
processor = new ExtractorProcessor(new ReflectionExtractor("getCity"));
IDictionary dictResult = cache.InvokeAll(cache.Keys, processor);
Assert.AreEqual(addr1.City, dictResult["addr1"]);
Assert.AreEqual(addr2.City, dictResult["addr2"]);
Assert.AreEqual(addr3.City, dictResult["addr3"]);
CacheFactory.Shutdown();
}
public void TestFilters()
{
IConfigurableCacheFactory ccf = CacheFactory.ConfigurableCacheFactory;
IXmlDocument config = XmlHelper.LoadXml("assembly://Coherence.Tests/Tangosol.Resources/s4hc-local-cache-config.xml");
ccf.Config = config;
INamedCache cache = CacheFactory.GetCache("local-default");
cache.Clear();
cache.Insert("5", "5");
cache.Insert(1, "10");
cache.Insert("g", "15");
cache.Insert("b", "20");
cache.Insert("1", "105");
IFilter[] filters = new IFilter[] {
new EqualsFilter(IdentityExtractor.Instance, "20"),
new LikeFilter(IdentityExtractor.Instance, "1%", '\\', true)
};
AnyFilter anyFilter = new AnyFilter(filters);
ICollection results = cache.GetKeys(anyFilter);
Assert.AreEqual(4, results.Count);
Assert.IsTrue(CollectionUtils.Contains(results, 1));
Assert.IsTrue(CollectionUtils.Contains(results, "g"));
Assert.IsTrue(CollectionUtils.Contains(results, "b"));
Assert.IsTrue(CollectionUtils.Contains(results, "1"));
filters = new IFilter[] {
new EqualsFilter(IdentityExtractor.Instance, "20"),
new LikeFilter(IdentityExtractor.Instance, "5%", '\\', true)
};
anyFilter = new AnyFilter(filters);
ICacheEntry[] entries = cache.GetEntries(anyFilter);
Assert.AreEqual(2, entries.Length);
Assert.Contains("b", new object[] { entries[0].Key, entries[1].Key });
Assert.Contains("5", new object[] { entries[0].Key, entries[1].Key });
Assert.Contains("20", new object[] { entries[0].Value, entries[1].Value });
Assert.Contains("5", new object[] { entries[0].Value, entries[1].Value });
CacheFactory.Shutdown();
}
/*
* common method for tests of this suite
*/
private void runTest(IXmlDocument config, string cacheName, string serializerName)
{
IConfigurableCacheFactory ccf = CacheFactory.ConfigurableCacheFactory;
IXmlElement originalConfig = ccf.Config;
ccf.Config = config;
INamedCache cache = ccf.EnsureCache(cacheName);
cache.Clear();
// create a key, and value
String sKey = "hello";
String sValue = "grid";
// insert the pair into the cache
cache.Insert(sKey, sValue);
// read back the value, custom serializer should have converted
Assert.AreEqual(cache.Count, 1);
Assert.AreEqual(cache[sKey], serializerName);
ccf.DestroyCache(cache);
ccf.Config = originalConfig;
}
public void TestListenerEvents()
{
IConfigurableCacheFactory ccf = CacheFactory.ConfigurableCacheFactory;
IXmlDocument config =
XmlHelper.LoadXml("assembly://Coherence.Tests/Tangosol.Resources/s4hc-near-cache-config.xml");
ccf.Config = config;
INamedCache cache = CacheFactory.GetCache("dist-extend-direct");
cache.Clear();
ListenerWithWait listen = new ListenerWithWait();
cache.AddCacheListener(listen, "test", true);
cache.Insert("test", "c");
CacheEventArgs localEvent = listen.WaitForEvent(2000);
Assert.IsNotNull(localEvent);
String value = (String)cache["test"];
localEvent = listen.WaitForEvent(4000);
Assert.AreEqual("c", value);
Assert.IsNull(localEvent);
CacheFactory.Shutdown();
}
public virtual void TestNamedCacheProperties()
{
INamedCache cache = CacheFactory.GetCache(CacheName);
string key = "testNamedCachePropertiesKey";
string value = "testNamedCachePropertiesValue";
// INamedCache
Assert.IsTrue(cache.IsActive);
cache.Clear();
Assert.AreEqual(cache.Count, 0);
cache.Insert(GetKeyObject(key), value);
Assert.AreEqual(cache.Count, 1);
Assert.AreEqual(cache[GetKeyObject(key)], value);
// SafeNamedCache
SafeNamedCache safeCache = (SafeNamedCache)cache;
Assert.IsFalse(safeCache.IsReleased);
Assert.IsFalse(safeCache.IsFixedSize);
Assert.IsFalse(safeCache.IsReadOnly);
Assert.IsTrue(safeCache.IsSynchronized);
// RemoteNamedCache
RemoteNamedCache remoteCache = (RemoteNamedCache)safeCache.NamedCache;
Assert.IsTrue(remoteCache.Channel.IsOpen);
Assert.IsInstanceOf(typeof(NamedCacheProtocol), remoteCache.Protocol);
CacheFactory.ReleaseCache(cache);
CacheFactory.Shutdown();
}
public void TestPofUpdater()
{
INamedCache cache = CacheFactory.GetCache(CacheName);
cache.Clear();
PortablePerson original = new PortablePerson();
original.Name = "Aleksandar Seovic";
original.Address = new Address("street", "Belgrade", "SRB", "11000");
cache.Insert("p1", original);
PofUpdater updName = new PofUpdater(0);
PofUpdater updCity = new PofUpdater(new SimplePofPath(new int[] { 1, 1 }));
cache.Invoke("p1", new UpdaterProcessor(updName, "Novak Seovic"));
cache.Invoke("p1", new UpdaterProcessor(updCity, "Lutz"));
PortablePerson modified = (PortablePerson)cache["p1"];
Assert.AreEqual("Novak Seovic", modified.Name);
Assert.AreEqual("Lutz", modified.Address.City);
CacheFactory.Shutdown();
}
public override void TestNamedCacheProperties()
{
INamedCache cache = CacheFactory.GetCache(CacheName);
string key = "testNamedCachePropertiesKey";
string value = "testNamedCachePropertiesValue";
// INamedCache
Assert.IsTrue(cache.IsActive);
cache.Clear();
Assert.AreEqual(cache.Count, 0);
cache.Insert(GetKeyObject(key), value);
Assert.AreEqual(cache.Count, 1);
Assert.AreEqual(cache[GetKeyObject(key)], value);
// BundlingNamedCache
BundlingNamedCache bundleCache = (BundlingNamedCache)cache;
Assert.IsFalse(bundleCache.IsFixedSize);
Assert.IsFalse(bundleCache.IsReadOnly);
Assert.IsTrue(bundleCache.IsSynchronized);
// RemoteNamedCache
SafeNamedCache safeCache = (SafeNamedCache)bundleCache.NamedCache;
Assert.IsTrue(safeCache.IsActive);
CacheFactory.ReleaseCache(cache);
CacheFactory.Shutdown();
}
public void TestConfiguredTriggerListener()
{
IConfigurableCacheFactory ccf = CacheFactory.ConfigurableCacheFactory;
IXmlDocument config = XmlHelper.LoadXml("assembly://Coherence.Tests/Tangosol.Resources/s4hc-extend-maptrigger-cache-config.xml");
ccf.Config = config;
INamedCache cache = CacheFactory.GetCache(CACHE_NAME);
cache.Clear();
SimplePerson pIn = new SimplePerson("123-45-6789", "Eddie", "Van Halen", 1955,
"987-65-4321", new String[] { "456-78-9123" });
try
{
cache.Insert(1, pIn);
Object[] keys = cache.GetKeys(AlwaysFilter.Instance);
Assert.AreEqual(keys.Length, 1);
SimplePerson pOut = (SimplePerson)cache[1];
Assert.AreEqual(pIn.LastName.ToUpper(), pOut.LastName);
}
finally
{
CacheFactory.Shutdown();
}
}
public void TestUpdaterProcessor()
{
Temperature belgrade = new Temperature(25, 'c', 1);
IValueUpdater updater = new ReflectionUpdater("Value");
IEntryProcessor processor = new UpdaterProcessor(updater, 0);
IEntryProcessor processor1 = new UpdaterProcessor(updater, 0);
Assert.AreEqual(processor, processor1);
Assert.AreEqual(processor.GetHashCode(), processor1.GetHashCode());
Assert.AreEqual(processor.ToString(), processor1.ToString());
LocalCache.Entry entry = new LocalCache.Entry(new LocalCache(), "belgrade", belgrade);
processor.Process(entry);
Assert.AreEqual(0, ((Temperature)entry.Value).Value);
// testing on Remote cache
INamedCache cache = CacheFactory.GetCache(CacheName);
cache.Clear();
Temperature bgd = new Temperature(25, 'c', 12);
Temperature nyc = new Temperature(99, 'f', 12);
cache.Insert("BGD", bgd);
cache.Insert("NYC", nyc);
updater = new ReflectionUpdater("setValue");
processor = new UpdaterProcessor(updater, 0);
object newTemp = cache.Invoke("BGD", processor);
Temperature newBGD = (Temperature)cache["BGD"];
Assert.AreEqual(0, newBGD.Value);
updater = new ReflectionUpdater("setValue");
IValueUpdater compositeupdater = new CompositeUpdater(IdentityExtractor.Instance, updater);
processor = new UpdaterProcessor(compositeupdater, 5);
cache.Invoke("NYC", processor);
Temperature newNYC = (Temperature)cache["NYC"];
Assert.AreEqual(5, newNYC.Value);
CacheFactory.Shutdown();
}
public void TestNumberMultiplier()
{
Temperature belgrade = new Temperature(25, 'c', 1);
int bgdBefore = belgrade.Value;
PropertyManipulator valueManipulator = new PropertyManipulator("Value");
IEntryProcessor processor = new NumberMultiplier(valueManipulator, 2, true);
IEntryProcessor processor1 = new NumberMultiplier(valueManipulator, 2, true);
Assert.AreEqual(processor, processor1);
Assert.AreEqual(processor.GetHashCode(), processor1.GetHashCode());
Assert.AreEqual(processor.ToString(), processor1.ToString());
LocalCache.Entry entry = new LocalCache.Entry(new LocalCache(), "belgrade", belgrade);
processor.Process(entry);
Assert.AreEqual(bgdBefore * 2, ((Temperature)entry.Value).Value);
INamedCache cache = CacheFactory.GetCache(CacheName);
cache.Clear();
Temperature bgd = new Temperature(25, 'c', 12);
Temperature nyc = new Temperature(99, 'f', 12);
cache.Insert("BGD", bgd);
cache.Insert("NYC", nyc);
PropertyManipulator manipulator = new PropertyManipulator("Value");
processor = new NumberMultiplier(manipulator, 2, false);
object newTemp = cache.Invoke("BGD", processor);
Assert.AreEqual(bgd.Value * 2, newTemp);
Temperature newBGD = (Temperature)cache["BGD"];
Assert.AreEqual(bgd.Value * 2, newBGD.Value);
processor = new NumberMultiplier(manipulator, 0.5, false);
object newNYC = cache.Invoke("NYC", processor);
Assert.AreEqual(49, newNYC);
CacheFactory.Shutdown();
}
public void TestComparisonValueExtractor()
{
// testing on remote cache
INamedCache cache = CacheFactory.GetCache(CacheName);
cache.Clear();
Score score = new Score(1, 1, 126, 10000L, 1.24f, 1432.55, new decimal(11223344), new RawInt128(new byte[] { 1 }), 1);
cache.Insert("score1", score);
IValueExtractor exByte = new ReflectionExtractor("getByteValue");
IValueExtractor exShort = new ReflectionExtractor("getShortValue");
IValueExtractor exInt = new ReflectionExtractor("getIntValue");
IValueExtractor exLong = new ReflectionExtractor("getLongValue");
IValueExtractor exFloat = new ReflectionExtractor("getFloatValue");
IValueExtractor exDouble = new ReflectionExtractor("getDoubleValue");
IValueExtractor exDecimal = new ReflectionExtractor("getBigDecimalValue");
IValueExtractor exInt128 = new ReflectionExtractor("getBigIntegerValue");
//different ways to instantiate same extractor
ComparisonValueExtractor cve1 = new ComparisonValueExtractor(exByte, exShort);
ComparisonValueExtractor cve2 = new ComparisonValueExtractor(exInt, exLong);
ComparisonValueExtractor cve3 = new ComparisonValueExtractor(exFloat, exDouble);
ComparisonValueExtractor cve4 = new ComparisonValueExtractor(exDecimal, exDecimal);
ComparisonValueExtractor cve5 = new ComparisonValueExtractor(exInt128, exInt128);
IFilter filter = new EqualsFilter(cve1, score.ByteValue - score.ShortValue);
ICollection keys = cache.GetKeys(filter);
Assert.IsNotEmpty(keys);
Assert.IsTrue(keys.Count == 1);
filter = new EqualsFilter(cve2, score.IntValue - score.LongValue);
keys = cache.GetKeys(filter);
Assert.IsNotEmpty(keys);
Assert.IsTrue(keys.Count == 1);
filter = new EqualsFilter(cve3, score.FloatValue - score.DoubleValue);
keys = cache.GetKeys(filter);
Assert.IsNotEmpty(keys);
Assert.IsTrue(keys.Count == 1);
filter = new EqualsFilter(cve4, (decimal)0);
keys = cache.GetKeys(filter);
Assert.IsNotEmpty(keys);
Assert.IsTrue(keys.Count == 1);
filter = new EqualsFilter(cve5, NumberUtils.DecimalToRawInt128(score.RawInt128Value.ToDecimal() - score.RawInt128Value.ToDecimal()));
keys = cache.GetKeys(filter);
Assert.IsNotEmpty(keys);
Assert.IsTrue(keys.Count == 1);
CacheFactory.Shutdown();
}
public void TestDoubleAverageAggregator()
{
DoubleAverage agg1 = new DoubleAverage(IdentityExtractor.Instance);
Assert.IsNotNull(agg1);
Assert.AreSame(IdentityExtractor.Instance, agg1.Extractor);
DoubleAverage agg2 = new DoubleAverage("dummy");
Assert.IsNotNull(agg2);
Assert.IsInstanceOf(typeof(ReflectionExtractor), agg2.Extractor);
DoubleAverage agg3 = new DoubleAverage("another.dummy");
Assert.IsNotNull(agg3);
Assert.IsInstanceOf(typeof(ChainedExtractor), agg3.Extractor);
ArrayList al = new ArrayList();
al.Add(new TestInvocableCacheEntry("Ivan", 173.6));
al.Add(new TestInvocableCacheEntry("Milica", 173.22));
al.Add(new TestInvocableCacheEntry("Goran", 185.1));
al.Add(new TestInvocableCacheEntry("Ana", 164.08));
Assert.AreEqual((173.6 + 173.22 + 185.1 + 164.08) / 4, agg1.Aggregate(al));
// aggragation on remote cache
INamedCache cache = CacheFactory.GetCache(CacheName);
cache.Clear();
Hashtable ht = new Hashtable();
ht.Add("doubleAvgKey1", 100);
ht.Add("doubleAvgKey2", 80.5);
ht.Add("doubleAvgKey3", 19.5);
ht.Add("doubleAvgKey4", 2);
cache.InsertAll(ht);
IEntryAggregator aggregator = new DoubleAverage(IdentityExtractor.Instance);
object result = cache.Aggregate(cache.Keys, aggregator);
Assert.AreEqual(50.5, result);
cache.Insert("comparableKey5", null);
result = cache.Aggregate(cache.Keys, aggregator);
Assert.AreEqual(50.5, result);
IFilter filter = new AlwaysFilter();
result = cache.Aggregate(filter, aggregator);
Assert.AreEqual(50.5, result);
CacheFactory.Shutdown();
}
public void TestDecimalMinAggregator()
{
DecimalMin agg1 = new DecimalMin(IdentityExtractor.Instance);
Assert.IsNotNull(agg1);
Assert.AreSame(IdentityExtractor.Instance, agg1.Extractor);
DecimalMin agg2 = new DecimalMin("dummy");
Assert.IsNotNull(agg2);
Assert.IsInstanceOf(typeof(ReflectionExtractor), agg2.Extractor);
DecimalMin agg3 = new DecimalMin("another.dummy");
Assert.IsNotNull(agg3);
Assert.IsInstanceOf(typeof(ChainedExtractor), agg3.Extractor);
ArrayList al = new ArrayList();
al.Add(new TestInvocableCacheEntry("Ivan", -173.6M));
al.Add(new TestInvocableCacheEntry("Goran", 185.1M));
al.Add(new TestInvocableCacheEntry("Ana", 1643426876432.08M));
Assert.AreEqual(-173.6M, agg1.Aggregate(al));
// aggragation on remote cache
INamedCache cache = CacheFactory.GetCache(CacheName);
cache.Clear();
Hashtable ht = new Hashtable();
ht.Add("key1", 100M);
ht.Add("key2", 80.523423423423M);
ht.Add("key3", 4643321321426876432.08M);
ht.Add("key4", 1643426876432.08M);
ht.Add("key5", 1011M);
cache.InsertAll(ht);
IEntryAggregator aggregator = new DecimalMin(IdentityExtractor.Instance);
object result = cache.Aggregate(cache.Keys, aggregator);
Assert.AreEqual(80.523423423423M, result);
cache.Insert("key10", -10.23896128635231234M);
IFilter filter = new AlwaysFilter();
result = cache.Aggregate(filter, aggregator);
Assert.AreEqual(-10.23896128635231234M, result);
CacheFactory.Shutdown();
}
public void TestExtractor()
{
IConfigurableCacheFactory ccf = CacheFactory.ConfigurableCacheFactory;
IXmlDocument config = XmlHelper.LoadXml("assembly://Coherence.Tests/Tangosol.Resources/s4hc-local-cache-config.xml");
ccf.Config = config;
INamedCache cache = CacheFactory.GetCache("local-default");
cache.Clear();
ExtractorProcessor processor = new ExtractorProcessor(new ReflectionExtractor("Street"));
Address addr1 = new Address("XI krajiske divizije", "Belgrade", "Serbia", "11000");
Address addr2 = new Address("Pere Velimirovica", "Uzice", "Serbia", "11000");
Address addr3 = new Address("Rige od Fere", "Novi Sad", "Serbia", "11000");
cache.Insert("addr1", addr1);
cache.Insert("addr2", addr2);
cache.Insert("addr3", addr3);
Assert.IsTrue(cache.Count == 3);
Object result = cache.Invoke("addr1", processor);
Assert.IsNotNull(result);
Assert.AreEqual(addr1.Street, result as String);
processor = new ExtractorProcessor(new ReflectionExtractor("City"));
IDictionary dictResult = cache.InvokeAll(cache.Keys, processor);
Assert.AreEqual(addr1.City, dictResult["addr1"]);
Assert.AreEqual(addr2.City, dictResult["addr2"]);
Assert.AreEqual(addr3.City, dictResult["addr3"]);
CacheFactory.Shutdown();
}
public void TestPofExtractorWithFilter()
{
INamedCache cache = CacheFactory.GetCache(CacheName);
cache.Clear();
for (int i = 1901; i <= 2000; i++)
{
PortablePersonLite customer = new PortablePersonLite();
customer.Name = "Name" + i;
customer.DOB = new DateTime(i, 1, 1);
cache.Insert(i, customer);
}
DateTime criteria = new DateTime(1970, 1, 1);
IValueExtractor extractor = new PofExtractor(null, 2);
IFilter filter2 = new LessEqualsFilter(extractor, criteria);
Assert.AreEqual(cache.GetEntries(filter2).Length, 70,
"Expected: 70; Result was: " + cache.GetEntries(filter2).Length);
CacheFactory.Shutdown();
}
public void TestLimitFilter()
{
INamedCache cache = CacheFactory.GetCache(CacheName);
LimitFilter limitFilter = new LimitFilter(new AlwaysFilter(), 10);
IDictionary <Int32, String> mapReturn = new Dictionary <Int32, String>();
bool entryReturned = true;
int totalCount = 0,
uniqueCount = 0;
cache.Clear();
for (int i = 0; i < CACHE_SIZE; i++)
{
cache.Insert(i, "value" + i);
}
while (entryReturned)
{
entryReturned = false;
foreach (ICacheEntry entry in cache.GetEntries(limitFilter))
{
++totalCount;
entryReturned = true;
if (!mapReturn.ContainsKey((int)entry.Key))
{
mapReturn.Add((Int32)entry.Key,
(String)entry.Value);
++uniqueCount;
}
}
limitFilter.NextPage();
}
;
Assert.AreEqual(CACHE_SIZE, totalCount);
Assert.AreEqual(totalCount, uniqueCount);
}
public void TestListenerConfiguration()
{
IConfigurableCacheFactory ccf = CacheFactory.ConfigurableCacheFactory;
IXmlDocument config =
XmlHelper.LoadXml("assembly://Coherence.Tests/Tangosol.Resources/s4hc-near-cache-config.xml");
ccf.Config = config;
INamedCache cache = CacheFactory.GetCache("dist-extend-direct-listener");
cache.Clear();
SyncListenerStatic.Reset();
Assert.IsNull(SyncListenerStatic.CacheEvent);
cache.Insert("test", "yes");
Assert.AreEqual(SyncListenerStatic.CacheEvent.EventType, CacheEventType.Inserted);
cache["test"] = "d";
Assert.AreEqual(SyncListenerStatic.CacheEvent.EventType, CacheEventType.Updated);
cache.Remove("test");
Assert.AreEqual(SyncListenerStatic.CacheEvent.EventType, CacheEventType.Deleted);
CacheFactory.Shutdown();
}
public void TestAggregate()
{
IConfigurableCacheFactory ccf = CacheFactory.ConfigurableCacheFactory;
IXmlDocument config = XmlHelper.LoadXml("assembly://Coherence.Tests/Tangosol.Resources/s4hc-local-cache-config.xml");
ccf.Config = config;
INamedCache cache = CacheFactory.GetCache("local-default");
cache.Clear();
Hashtable ht = new Hashtable();
ht.Add("comparableMaxKey1", 100);
ht.Add("comparableMaxKey2", 80.5);
ht.Add("comparableMaxKey3", 19.5);
ht.Add("comparableMaxKey4", 2);
cache.InsertAll(ht);
IEntryAggregator aggregator = new DoubleAverage(IdentityExtractor.Instance);
object result = cache.Aggregate(cache.Keys, aggregator);
Assert.AreEqual(50.5, result);
cache.Insert("comparableKey5", null);
result = cache.Aggregate(cache.Keys, aggregator);
Assert.AreEqual(50.5, result);
IFilter alwaysFilter = new AlwaysFilter();
result = cache.Aggregate(alwaysFilter, aggregator);
Assert.AreEqual(50.5, result);
cache.Clear();
ht = new Hashtable();
ht.Add("comparableMaxKey1", 435);
ht.Add("comparableMaxKey2", 253);
ht.Add("comparableMaxKey3", 3);
ht.Add("comparableMaxKey4", null);
ht.Add("comparableMaxKey5", -3);
cache.InsertAll(ht);
aggregator = new ComparableMax(IdentityExtractor.Instance);
object max = cache.Aggregate(cache.Keys, aggregator);
Assert.AreEqual(max, 435);
max = cache.Aggregate(alwaysFilter, aggregator);
Assert.AreEqual(max, 435);
cache.Clear();
ht = new Hashtable();
ht.Add("comparableMaxKey1", 435);
ht.Add("comparableMaxKey2", 253);
ht.Add("comparableMaxKey3", 3);
ht.Add("comparableMaxKey4", 3);
ht.Add("comparableMaxKey5", 3);
ht.Add("comparableMaxKey6", null);
ht.Add("comparableMaxKey7", null);
cache.InsertAll(ht);
aggregator = new DistinctValues(IdentityExtractor.Instance);
result = cache.Aggregate(cache.Keys, aggregator);
Assert.AreEqual(3, ((ICollection)result).Count);
foreach (object o in ht.Values)
{
Assert.IsTrue(((IList)result).Contains(o) || o == null);
}
IFilter lessFilter = new LessFilter(IdentityExtractor.Instance, 100);
result = cache.Aggregate(lessFilter, aggregator);
Assert.AreEqual(1, ((ICollection)result).Count);
cache.Clear();
ht = new Hashtable();
ht.Add("key1", 100);
ht.Add("key2", 80.5);
ht.Add("key3", 19.5);
ht.Add("key4", 2);
cache.InsertAll(ht);
aggregator = new DoubleSum(IdentityExtractor.Instance);
result = cache.Aggregate(cache.Keys, aggregator);
Assert.AreEqual(202, result);
IFilter filter = new AlwaysFilter();
result = cache.Aggregate(filter, aggregator);
Assert.AreEqual(202, result);
cache.Clear();
ht = new Hashtable();
ht.Add("key1", 100);
ht.Add("key2", 80);
ht.Add("key3", 19);
ht.Add("key4", 2);
ht.Add("key5", null);
cache.InsertAll(ht);
aggregator = new LongSum(IdentityExtractor.Instance);
result = cache.Aggregate(cache.Keys, aggregator);
Assert.AreEqual(201, result);
IFilter greaterFilter = new GreaterFilter(IdentityExtractor.Instance, 1);
result = cache.Aggregate(greaterFilter, aggregator);
Assert.AreEqual(201, result);
CacheFactory.Shutdown();
}
public void TestListeners()
{
IConfigurableCacheFactory ccf = CacheFactory.ConfigurableCacheFactory;
IXmlDocument config = XmlHelper.LoadXml("assembly://Coherence.Tests/Tangosol.Resources/s4hc-local-cache-config.xml");
ccf.Config = config;
INamedCache cache = CacheFactory.GetCache("local-default");
cache.Clear();
SyncListener listen = new SyncListener();
cache.AddCacheListener(listen, "test", false);
Assert.IsNull(listen.CacheEvent);
cache.Insert("t", "a");
Assert.IsNull(listen.CacheEvent);
cache.Insert("tes", "b");
Assert.IsNull(listen.CacheEvent);
cache.Insert("test", "c");
Assert.IsNotNull(listen.CacheEvent);
Assert.AreEqual(listen.CacheEvent.EventType, CacheEventType.Inserted);
listen.CacheEvent = null;
Assert.IsNull(listen.CacheEvent);
cache["test"] = "d";
Assert.IsNotNull(listen.CacheEvent);
Assert.AreEqual(listen.CacheEvent.EventType, CacheEventType.Updated);
listen.CacheEvent = null;
Assert.IsNull(listen.CacheEvent);
cache.Remove("test");
Assert.IsNotNull(listen.CacheEvent);
Assert.AreEqual(listen.CacheEvent.EventType, CacheEventType.Deleted);
cache.RemoveCacheListener(listen, "test");
CacheEventFilter likeFilter = new CacheEventFilter(
new LikeFilter(IdentityExtractor.Instance, "%ic", '\\', false));
cache.AddCacheListener(listen, likeFilter, false);
listen.CacheEvent = null;
Assert.IsNull(listen.CacheEvent);
cache.Insert("key1", "Ratko");
Assert.IsNull(listen.CacheEvent);
cache.Insert("key2", "PerIc");
Assert.IsNull(listen.CacheEvent);
cache.Insert("key3", "RatkoviC");
Assert.IsNull(listen.CacheEvent);
cache.Insert("key4", "Perovic");
Assert.IsNotNull(listen.CacheEvent);
Assert.AreEqual(listen.CacheEvent.EventType, CacheEventType.Inserted);
cache.RemoveCacheListener(listen);
cache.Clear();
cache.AddCacheListener(listen);
listen.CacheEvent = null;
Assert.IsNull(listen.CacheEvent);
cache.Insert("key1", "Ratko");
Assert.IsNotNull(listen.CacheEvent);
Assert.AreEqual(listen.CacheEvent.EventType, CacheEventType.Inserted);
cache.Insert("key1", "Ratko NEW");
Assert.AreEqual(listen.CacheEvent.EventType, CacheEventType.Updated);
cache.Insert("key2", "Pera");
Assert.IsNotNull(listen.CacheEvent);
Assert.AreEqual(listen.CacheEvent.EventType, CacheEventType.Inserted);
cache.RemoveCacheListener(listen);
CacheFactory.Shutdown();
}
public void TestVersionPut()
{
Temperature temperature = new Temperature(35, 'f', 11);
Temperature temperatureNew = new Temperature(15, 'C', 10);
LocalCache.Entry entry = new LocalCache.Entry(new LocalCache(), "morning", temperature);
IEntryProcessor processorVersioned = new VersionedPut(temperatureNew, true, true);
IEntryProcessor processorVersioned1 = new VersionedPut(temperatureNew, true, true);
Assert.AreEqual(processorVersioned, processorVersioned1);
Assert.AreEqual(processorVersioned.GetHashCode(), processorVersioned1.GetHashCode());
Assert.AreEqual(processorVersioned.ToString(), processorVersioned1.ToString());
Temperature res = (Temperature)processorVersioned.Process(entry);
Assert.AreEqual(temperature, res);
temperatureNew = new Temperature(15, 'C', 11);
processorVersioned = new VersionedPut(temperatureNew, true, true);
processorVersioned.Process(entry);
Assert.AreEqual((entry.Value as Temperature).Grade, temperatureNew.Grade);
Assert.AreEqual((entry.Value as Temperature).Value, temperatureNew.Value);
// testing on Remote cache
INamedCache cache = CacheFactory.GetCache(CacheName);
cache.Clear();
Temperature t1 = new Temperature(3, 'c', 8);
Temperature t2 = new Temperature(24, 'c', 12);
Temperature t3 = new Temperature(15, 'c', 18);
Temperature t4 = new Temperature(0, 'c', 0);
cache.Insert("morning", t1);
cache.Insert("noon", t2);
cache.Insert("afternoon", t3);
cache.Insert("midnight", t4);
Temperature t = new Temperature(35, 'f', 11);
IEntryProcessor processor = new VersionedPut(t, true, true);
Temperature result = (Temperature)cache.Invoke("morning", processor);
Assert.AreNotEqual(t.Value, result.Value);
Assert.AreNotEqual(t.Grade, result.Grade);
Temperature after = (Temperature)cache["morning"];
Assert.AreNotEqual(t.Value, after.Value);
Assert.AreNotEqual(t.Version, after.Version);
Assert.AreNotEqual(t.Grade, after.Grade);
t = new Temperature(35, 'f', 8);
processor = new VersionedPut(t, true, true);
result = (Temperature)cache.Invoke("morning", processor);
Assert.IsNull(result);
after = (Temperature)cache["morning"];
Assert.AreEqual(t.Version + 1, after.Version);
Assert.AreEqual(t.Value, after.Value);
Assert.AreEqual(t.Grade, after.Grade);
t = new Temperature(38, 'f', 10);
processor = new VersionedPut(t, true, true);
result = (Temperature)cache.Invoke("sometime", processor);
after = (Temperature)cache["sometime"];
Assert.AreEqual(t.Value, after.Value);
Assert.AreEqual(t.Grade, after.Grade);
Assert.AreEqual(t.Version + 1, after.Version);
cache.Remove("sometime");
processor = new VersionedPut(t, false, true);
result = (Temperature)cache.Invoke("sometime", processor);
after = (Temperature)cache["sometime"];
Assert.IsNull(after);
CacheFactory.Shutdown();
}
public void TestComposite()
{
Address addr1 = new Address("XI krajiske divizije", "Belgrade", "Serbia", "11000");
Address addr2 = new Address("Pere Velimirovica", "Belgrade", "Serbia", "11000");
Address addr3 = new Address("Rige od Fere", "Belgrade", "Serbia", "11000");
Address addrNEW = new Address("NEW Pere", "NEW Belgrade", "Serbia", "11000");
IEntryProcessor putLikeXI = new ConditionalPut(new LikeFilter(new ReflectionExtractor("Street"), "XI%", '\\', true), addr2);
IEntryProcessor putLikeRig = new ConditionalPut(new LikeFilter(new ReflectionExtractor("Street"), "Rige%", '\\', true), addrNEW);
IEntryProcessor[] processors = new IEntryProcessor[] { putLikeXI, putLikeRig };
CompositeProcessor processor = new CompositeProcessor(processors);
CompositeProcessor processor1 = new CompositeProcessor(processors);
Assert.AreEqual(processor, processor1);
Assert.AreEqual(processor.GetHashCode(), processor1.GetHashCode());
Assert.AreEqual(processor.ToString(), processor1.ToString());
LocalCache.Entry entry = new LocalCache.Entry(new LocalCache(), "addr1", addr1);
processor.Process(entry);
Assert.AreEqual(addr2, entry.Value);
entry = new LocalCache.Entry(new LocalCache(), "addr2", addr2);
processor.Process(entry);
Assert.AreEqual(addr2, entry.Value);
entry = new LocalCache.Entry(new LocalCache(), "addr3", addr3);
processor.Process(entry);
Assert.AreEqual(addrNEW, entry.Value);
// testing on Remote cache
INamedCache cache = CacheFactory.GetCache(CacheName);
cache.Clear();
cache.Insert("addr1", addr1);
cache.Insert("addr2", addr2);
Assert.IsTrue(cache.Count == 2);
LikeFilter likeXI = new LikeFilter(new ReflectionExtractor("getStreet"), "XI%", '\\', true);
ExtractorProcessor extractStreet = new ExtractorProcessor(new ReflectionExtractor("getStreet"));
IEntryProcessor putAddr3 = new ConditionalPut(AlwaysFilter.Instance, addr3);
IEntryProcessor removeLikeXI = new ConditionalRemove(likeXI, false);
processors = new IEntryProcessor[] { extractStreet, removeLikeXI, putAddr3 };
processor = new CompositeProcessor(processors);
Object objResult = cache.Invoke("addr1", processor);
Assert.IsTrue(cache.Count == 2);
Assert.AreEqual(addr1.Street, (objResult as Object[])[0]);
Address res = cache["addr1"] as Address;
Assert.AreEqual(addr3.City, res.City);
Assert.AreEqual(addr3.State, res.State);
Assert.AreEqual(addr3.Street, res.Street);
Assert.AreEqual(addr3.ZIP, res.ZIP);
res = cache["addr2"] as Address;
Assert.AreEqual(addr2.City, res.City);
Assert.AreEqual(addr2.State, res.State);
Assert.AreEqual(addr2.Street, res.Street);
Assert.AreEqual(addr2.ZIP, res.ZIP);
IDictionary dictResult = cache.InvokeAll(new ArrayList(new object[] { "addr1", "addr2" }), processor);
Assert.IsTrue(cache.Count == 2);
Assert.AreEqual(addr3.Street, (cache["addr1"] as Address).Street);
Assert.AreEqual(addr3.Street, (cache["addr2"] as Address).Street);
Assert.AreEqual((dictResult["addr1"] as object[])[0], addr3.Street);
Assert.AreEqual((dictResult["addr2"] as object[])[0], addr2.Street);
CacheFactory.Shutdown();
}
public void TestComposite()
{
IConfigurableCacheFactory ccf = CacheFactory.ConfigurableCacheFactory;
IXmlDocument config = XmlHelper.LoadXml("assembly://Coherence.Tests/Tangosol.Resources/s4hc-local-cache-config.xml");
ccf.Config = config;
INamedCache cache = CacheFactory.GetCache("local-default");
cache.Clear();
Address addr1 = new Address("XI krajiske divizije", "Belgrade", "Serbia", "11000");
Address addr2 = new Address("Pere Velimirovica", "Belgrade", "Serbia", "11000");
Address addr3 = new Address("Rige od Fere", "Belgrade", "Serbia", "11000");
cache.Insert("addr1", addr1);
cache.Insert("addr2", addr2);
Assert.IsTrue(cache.Count == 2);
LikeFilter likeXI = new LikeFilter(new ReflectionExtractor("Street"), "XI%", '\\', true);
ExtractorProcessor extractStreet = new ExtractorProcessor(new ReflectionExtractor("Street"));
IEntryProcessor putAddr3 = new ConditionalPut(AlwaysFilter.Instance, addr3);
IEntryProcessor removeLikeXI = new ConditionalRemove(likeXI, false);
IEntryProcessor[] processors = new IEntryProcessor[] { extractStreet, removeLikeXI, putAddr3 };
CompositeProcessor processor = new CompositeProcessor(processors);
Object objResult = cache.Invoke("addr1", processor);
Assert.IsTrue(cache.Count == 2);
object[] objResultArr = objResult as object[];
Assert.IsNotNull(objResultArr);
Assert.AreEqual(addr1.Street, objResultArr[0]);
Address res = cache["addr1"] as Address;
Assert.IsNotNull(res);
Assert.AreEqual(addr3.City, res.City);
Assert.AreEqual(addr3.State, res.State);
Assert.AreEqual(addr3.Street, res.Street);
Assert.AreEqual(addr3.ZIP, res.ZIP);
res = cache["addr2"] as Address;
Assert.IsNotNull(res);
Assert.AreEqual(addr2.City, res.City);
Assert.AreEqual(addr2.State, res.State);
Assert.AreEqual(addr2.Street, res.Street);
Assert.AreEqual(addr2.ZIP, res.ZIP);
IDictionary dictResult = cache.InvokeAll(new ArrayList(new object[] { "addr1", "addr2" }), processor);
Assert.IsTrue(cache.Count == 2);
Address address = cache["addr1"] as Address;
Assert.IsNotNull(address);
Assert.AreEqual(addr3.Street, address.Street);
address = cache["addr2"] as Address;
Assert.IsNotNull(address);
Assert.AreEqual(addr3.Street, address.Street);
object[] objectArr = dictResult["addr1"] as object[];
Assert.IsNotNull(objectArr);
Assert.AreEqual(objectArr[0], addr3.Street);
objectArr = dictResult["addr2"] as object[];
Assert.IsNotNull(objectArr);
Assert.AreEqual(objectArr[0], addr2.Street);
CacheFactory.Shutdown();
}
public void TestVersionPutAll()
{
Hashtable ht = new Hashtable();
ht.Add("noon", new Temperature(100, 'f', 12));
ht.Add("midnight", new Temperature(25, 'f', 0));
IEntryProcessor processor = new VersionedPutAll(ht, true, false);
IEntryProcessor processor1 = new VersionedPutAll(ht, true, false);
Assert.AreEqual(processor.ToString(), processor1.ToString());
Temperature temperature = new Temperature(500, 'C', 1);
LocalCache.Entry entry = new LocalCache.Entry(new LocalCache(), "morning", temperature);
processor.Process(entry);
Temperature entryTemp = entry.Value as Temperature;
Assert.AreEqual(entryTemp.Grade, temperature.Grade);
Assert.AreEqual(entryTemp.Value, temperature.Value);
temperature = new Temperature(500, 'C', 12);
entry = new LocalCache.Entry(new LocalCache(), "noon", temperature);
processor.Process(entry);
entryTemp = entry.Value as Temperature;
Assert.AreEqual(entryTemp.Grade, 'F');
Assert.AreEqual(entryTemp.Value, 100);
// testing on Remote cache
INamedCache cache = CacheFactory.GetCache(CacheName);
cache.Clear();
Temperature t1 = new Temperature(3, 'c', 8);
Temperature t2 = new Temperature(24, 'c', 12);
Temperature t3 = new Temperature(15, 'c', 18);
Temperature t4 = new Temperature(0, 'c', 0);
cache.Insert("morning", t1);
cache.Insert("noon", t2);
cache.Insert("afternoon", t3);
cache.Insert("midnight", t4);
ht = new Hashtable();
ht.Add("noon", new Temperature(100, 'f', 12));
ht.Add("midnight", new Temperature(25, 'f', 0));
processor = new VersionedPutAll(ht, true, false);
cache.InvokeAll(cache.Keys, processor);
Temperature after = (Temperature)cache["midnight"];
Assert.AreEqual(25, after.Value);
Assert.AreEqual('F', after.Grade);
Assert.AreEqual(1, after.Version);
after = (Temperature)cache["noon"];
Assert.AreEqual(100, after.Value);
Assert.AreEqual('F', after.Grade);
Assert.AreEqual(13, after.Version);
CacheFactory.Shutdown();
}