public void TestListeners()
        {
            INamedCache namedCache = CacheFactory.GetCache(CacheName);

            Hashtable ht = new Hashtable();

            ht.Add(GetKeyObject("Key1"), 435);
            ht.Add(GetKeyObject("Key2"), 253);
            ht.Add(GetKeyObject("Key3"), 3);
            ht.Add(GetKeyObject("Key4"), 200);
            ht.Add(GetKeyObject("Key5"), 333);
            namedCache.InsertAll(ht);

            IFilter greaterThan300          = new GreaterFilter(IdentityExtractor.Instance, 300);
            IFilter listenerFilter          = new CacheEventFilter(new GreaterFilter(IdentityExtractor.Instance, 350));
            ContinuousQueryCache queryCache = new ContinuousQueryCache(namedCache, greaterThan300);
            Listener             listener   = new SyncListener();

            // listener
            queryCache.AddCacheListener(listener);

            listener.CacheEvent = null;
            queryCache.Insert(GetKeyObject("Key7"), 400);
            Assert.IsNotNull(listener.CacheEvent);
            Assert.AreEqual(CacheEventType.Inserted, listener.CacheEvent.EventType);

            listener.CacheEvent = null;
            queryCache.Insert(GetKeyObject("Key7"), 350);
            Assert.IsNotNull(listener.CacheEvent);
            Assert.AreEqual(CacheEventType.Updated, listener.CacheEvent.EventType);

            listener.CacheEvent = null;
            queryCache.Remove(GetKeyObject("Key5"));
            Assert.IsNotNull(listener.CacheEvent);
            Assert.AreEqual(CacheEventType.Deleted, listener.CacheEvent.EventType);

            queryCache.RemoveCacheListener(listener);

            // listener, key, lite
            namedCache.Clear();
            namedCache.InsertAll(ht);
            queryCache.AddCacheListener(listener, GetKeyObject("Key5"), false);

            listener.CacheEvent = null;
            queryCache.Insert(GetKeyObject("Key6"), 400);
            Assert.IsNull(listener.CacheEvent);

            queryCache.Insert(GetKeyObject("Key5"), 400);
            Assert.IsNotNull(listener.CacheEvent);
            Assert.AreEqual(CacheEventType.Updated, listener.CacheEvent.EventType);

            listener.CacheEvent = null;
            queryCache.Remove(GetKeyObject("Key1"));
            Assert.IsNull(listener.CacheEvent);

            queryCache.Remove(GetKeyObject("Key5"));
            Assert.IsNotNull(listener.CacheEvent);
            Assert.AreEqual(CacheEventType.Deleted, listener.CacheEvent.EventType);

            queryCache.RemoveCacheListener(listener, GetKeyObject("Key5"));

            // listener, filter, lite
            namedCache.Clear();
            namedCache.InsertAll(ht);
            queryCache.AddCacheListener(listener, listenerFilter, false);

            listener.CacheEvent = null;
            queryCache.Insert(GetKeyObject("Key6"), 320);
            Assert.IsNull(listener.CacheEvent);

            queryCache.Insert(GetKeyObject("Key5"), 350);
            Assert.IsNull(listener.CacheEvent);

            queryCache.Insert(GetKeyObject("Key6"), 400);
            Assert.IsNotNull(listener.CacheEvent);
            Assert.AreEqual(CacheEventType.Updated, listener.CacheEvent.EventType);

            listener.CacheEvent = null;
            queryCache.Insert(GetKeyObject("Key7"), 340);
            Assert.IsNull(listener.CacheEvent);

            queryCache.Remove(GetKeyObject("Key7"));
            Assert.IsNull(listener.CacheEvent);

            queryCache.Remove(GetKeyObject("Key6"));
            Assert.IsNotNull(listener.CacheEvent);
            Assert.AreEqual(CacheEventType.Deleted, listener.CacheEvent.EventType);

            queryCache.RemoveCacheListener(listener, listenerFilter);

            // non-sync listener, filter, heavy
            // COH-2529: Filter-based cache events are reevaluated on the client unncessarily
            listener       = new Listener();
            listenerFilter = new CacheEventFilter(new EqualsFilter("getZip", "02144"));
            namedCache.Clear();
            namedCache.AddCacheListener(listener, listenerFilter, false);

            listener.CacheEvent = null;
            namedCache[GetKeyObject("Jason")] = new Address("3 TBR #8", "Somerville", "MA", "02144");
            listener.waitForEvent(5000);
            Assert.IsNotNull(listener.CacheEvent);
            Assert.IsNotNull(listener.CacheEvent.NewValue);
            Assert.AreEqual(CacheEventType.Inserted, listener.CacheEvent.EventType);

            listener.CacheEvent = null;
            listener.waitForEvent(5000);
            namedCache[GetKeyObject("Oracle")] = new Address("8 NEEP", "Burlington", "MA", "01803");
            Assert.IsNull(listener.CacheEvent);

            namedCache.RemoveCacheListener(listener, listenerFilter);

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