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(); }