geode-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From r..@apache.org
Subject [30/51] [partial] geode git commit: Software Grant Agreement (SGA) from Pivotal for Apache Geode
Date Fri, 13 Jan 2017 22:46:14 GMT
http://git-wip-us.apache.org/repos/asf/geode/blob/2d4a7ecd/src/clicache/integration-test/ThinClientCSTXN.cs
----------------------------------------------------------------------
diff --git a/src/clicache/integration-test/ThinClientCSTXN.cs b/src/clicache/integration-test/ThinClientCSTXN.cs
new file mode 100644
index 0000000..c6505bd
--- /dev/null
+++ b/src/clicache/integration-test/ThinClientCSTXN.cs
@@ -0,0 +1,817 @@
+//=========================================================================
+// Copyright (c) 2002-2014 Pivotal Software, Inc. All Rights Reserved.
+// This product is protected by U.S. and international copyright
+// and intellectual property laws. Pivotal products are covered by
+// more patents listed at http://www.pivotal.io/patents.
+//========================================================================
+
+using System;
+using System.Threading;
+using System.Collections.Generic;
+
+namespace GemStone.GemFire.Cache.UnitTests.NewAPI
+{
+  using NUnit.Framework;
+  using GemStone.GemFire.DUnitFramework;
+  using GemStone.GemFire.Cache.Generic;
+  using GemStone.GemFire.Cache.UnitTests.NewAPI;
+  using Region = GemStone.GemFire.Cache.Generic.IRegion<Object, Object>;
+  using GemStone.GemFire.Cache.Tests.NewAPI;
+  #region CSTX_COMMENTED - transaction listener and writer are disabled for now
+  /* 
+  class CSTXListener<TKey, TVal> : TransactionListenerAdapter<TKey, TVal>
+  {
+    public CSTXListener(string cacheName)
+    {
+      m_cacheName = cacheName; 
+    }
+    public override void AfterCommit(TransactionEvent<TKey, TVal> te)
+    {
+      if (te.Cache.Name != m_cacheName)
+        incorrectCacheName = true; 
+        
+      afterCommitEvents++;
+      afterCommitKeyEvents += te.Events.Length;
+    }
+
+    public override void AfterFailedCommit(TransactionEvent<TKey, TVal> te)
+    {
+      if (te.Cache.Name != m_cacheName)
+        incorrectCacheName = true;
+
+      afterFailedCommitEvents++;
+      afterFailedCommitKeyEvents += te.Events.Length;
+    }
+
+    public override void AfterRollback(TransactionEvent<TKey, TVal> te)
+    {
+      if (te.Cache.Name != m_cacheName)
+        incorrectCacheName = true;
+
+      afterRollbackEvents++;
+      afterRollbackKeyEvents += te.Events.Length;
+    }
+
+    public override void Close()
+    {
+      closeEvent++;
+    }
+    
+    public void ShowTallies()
+    {
+      Util.Log("CSTXListener state: (afterCommitEvents = {0}, afterRollbackEvents = {1}, afterFailedCommitEvents = {2}, afterCommitRegionEvents = {3}, afterRollbackRegionEvents = {4}, afterFailedCommitRegionEvents = {5}, closeEvent = {6})",
+        afterCommitEvents, afterRollbackEvents, afterFailedCommitEvents, afterCommitKeyEvents, afterRollbackKeyEvents, afterFailedCommitKeyEvents, closeEvent);
+    }
+    
+    public int AfterCommitEvents { get { return afterCommitEvents; } }
+    public int AfterRollbackEvents { get { return afterRollbackEvents; } }
+    public int AfterFailedCommitEvents { get { return afterFailedCommitEvents; } }
+    public int AfterCommitKeyEvents { get { return afterCommitKeyEvents; } }
+    public int AfterRollbackKeyEvents { get { return afterRollbackKeyEvents; } }
+    public int AfterFailedCommitKeyEvents { get { return afterFailedCommitKeyEvents; } }
+    public int CloseEvent { get { return closeEvent; } }
+    public bool IncorrectCacheName { get { return incorrectCacheName; } }
+    
+    private int afterCommitEvents = 0;
+
+    private int afterRollbackEvents = 0;
+    private int afterFailedCommitEvents = 0;
+    
+    private int afterCommitKeyEvents = 0;
+    private int afterRollbackKeyEvents = 0;
+    private int afterFailedCommitKeyEvents = 0;
+    private int closeEvent = 0;
+    
+    private string m_cacheName = null;
+
+    private bool incorrectCacheName = false;
+
+    
+  }
+  class CSTXWriter<TKey, TVal> : TransactionWriterAdapter<TKey, TVal>
+  {
+    public CSTXWriter(string cacheName, string instanceName)
+    {
+      m_instanceName = instanceName;
+      m_cacheName = cacheName; 
+    }
+    
+    public override void BeforeCommit(TransactionEvent<TKey, TVal> te)
+    {
+      if (te.Cache.Name != m_cacheName)
+        incorrectCacheName = true;
+
+      beforeCommitEvents++;
+      beforeCommitKeyEvents += te.Events.Length; 
+    }
+    public int BeforeCommitEvents { get { return beforeCommitEvents; } }
+    public int BeforeCommitKeyEvents { get { return beforeCommitKeyEvents; } }
+    public string InstanceName { get { return m_instanceName; } }
+    public bool IncorrectCacheName { get { return incorrectCacheName; } }
+    public void ShowTallies()
+    {
+      Util.Log("CSTXWriter state: (beforeCommitEvents = {0}, beforeCommitRegionEvents = {1}, instanceName = {2})",
+        beforeCommitEvents, beforeCommitKeyEvents, m_instanceName);
+    }
+    private int beforeCommitEvents = 0;
+    private int beforeCommitKeyEvents = 0;
+    private string m_cacheName = null;
+    private string m_instanceName;
+    
+    private bool incorrectCacheName = false;
+    
+  }
+  */
+  #endregion
+
+  [TestFixture]
+  [Category("group1")]
+  [Category("unicast_only")]
+  public class ThinClientCSTX : ThinClientRegionSteps
+  {
+    #region CSTX_COMMENTED - transaction listener and writer are disabled for now
+    /*private CSTXWriter<object, object> m_writer1;
+    private CSTXWriter<object, object> m_writer2;
+    private CSTXListener<object, object> m_listener1;
+    private CSTXListener<object, object> m_listener2;*/
+    #endregion
+
+    RegionOperation o_region1;
+    RegionOperation o_region2;
+    private TallyListener<object, object> m_listener;
+    private static string[] cstxRegions = new string[] { "cstx1", "cstx2", "cstx3" };
+    private UnitProcess m_client1;
+
+    protected override ClientBase[] GetClients()
+    {
+      m_client1 = new UnitProcess();
+      return new ClientBase[] { m_client1 };
+    }
+
+    public void CreateRegion(string regionName, string locators, bool listener)
+    {
+      if (listener)
+        m_listener = new TallyListener<object, object>();
+      else
+        m_listener = null;
+
+      Region region = null;
+      region = CacheHelper.CreateTCRegion_Pool<object, object>(regionName, false, false,
+        m_listener, locators, "__TESTPOOL1_", false);
+
+    }
+
+    #region CSTX_COMMENTED - transaction listener and writer are disabled for now
+    /*
+    public void ValidateCSTXListenerWriter()
+    {
+      Util.Log("tallies for listener 1");
+      m_listener1.ShowTallies();
+      Util.Log("tallies for writer 1");
+      m_writer1.ShowTallies();
+      Util.Log("tallies for listener 2");
+      m_listener2.ShowTallies();
+      Util.Log("tallies for writer 2");
+      m_writer2.ShowTallies();
+      
+       // listener 1
+      Assert.AreEqual(4, m_listener1.AfterCommitEvents, "Should be 4");
+      Assert.AreEqual(14, m_listener1.AfterCommitKeyEvents, "Should be 14");
+      Assert.AreEqual(0, m_listener1.AfterFailedCommitEvents, "Should be 0");
+      Assert.AreEqual(0, m_listener1.AfterFailedCommitKeyEvents, "Should be 0");
+      Assert.AreEqual(2, m_listener1.AfterRollbackEvents, "Should be 2");
+      Assert.AreEqual(6, m_listener1.AfterRollbackKeyEvents, "Should be 6");
+      Assert.AreEqual(1, m_listener1.CloseEvent, "Should be 1");
+      Assert.AreEqual(false, m_listener1.IncorrectCacheName, "Incorrect cache name in the events");
+      
+      // listener 2
+      Assert.AreEqual(2, m_listener2.AfterCommitEvents, "Should be 2");
+      Assert.AreEqual(6, m_listener2.AfterCommitKeyEvents, "Should be 6");
+      Assert.AreEqual(0, m_listener2.AfterFailedCommitEvents, "Should be 0");
+      Assert.AreEqual(0, m_listener2.AfterFailedCommitKeyEvents, "Should be 0");
+      Assert.AreEqual(2, m_listener2.AfterRollbackEvents, "Should be 2");
+      Assert.AreEqual(6, m_listener2.AfterRollbackKeyEvents, "Should be 6");
+      Assert.AreEqual(1, m_listener2.CloseEvent, "Should be 1");
+      Assert.AreEqual(false, m_listener2.IncorrectCacheName, "Incorrect cache name in the events");
+      
+      // writer 1 
+      Assert.AreEqual(3, m_writer1.BeforeCommitEvents, "Should be 3");
+      Assert.AreEqual(10, m_writer1.BeforeCommitKeyEvents, "Should be 10");
+      Assert.AreEqual(false, m_writer1.IncorrectCacheName, "Incorrect cache name in the events");
+      
+      // writer 2
+      Assert.AreEqual(1, m_writer2.BeforeCommitEvents, "Should be 1");
+      Assert.AreEqual(4, m_writer2.BeforeCommitKeyEvents, "Should be 4");
+      Assert.AreEqual(false, m_writer2.IncorrectCacheName, "Incorrect cache name in the events");
+    }
+    */
+    #endregion
+    public void ValidateListener()
+    {
+      o_region1 = new RegionOperation(cstxRegions[2]);
+      CacheHelper.CSTXManager.Begin();
+      o_region1.Region.Put("key3", "value1", null);
+      o_region1.Region.Put("key4", "value2", null);
+      o_region1.Region.Remove("key4");
+      CacheHelper.CSTXManager.Commit();
+      // server is conflating the events on the same key hence only 1 create
+      Assert.AreEqual(1, m_listener.Creates, "Should be 1 creates");
+      Assert.AreEqual(1, m_listener.Destroys, "Should be 1 destroys");
+
+      CacheHelper.CSTXManager.Begin();
+      o_region1.Region.Put("key1", "value1", null);
+      o_region1.Region.Put("key2", "value2", null);
+      o_region1.Region.Invalidate("key1");
+      o_region1.Region.Invalidate("key3");
+      CacheHelper.CSTXManager.Commit();
+
+      // server is conflating the events on the same key hence only 1 invalidate
+      Assert.AreEqual(3, m_listener.Creates, "Should be 3 creates");
+      Assert.AreEqual(1, m_listener.Invalidates, "Should be 1 invalidates");
+
+    }
+    public void SuspendResumeRollback()
+    {
+      o_region1 = new RegionOperation(cstxRegions[0]);
+      o_region2 = new RegionOperation(cstxRegions[1]);
+
+      CacheHelper.CSTXManager.Begin();
+      o_region1.PutOp(1, null);
+
+      o_region2.PutOp(1, null);
+
+
+      Assert.AreEqual(CacheHelper.CSTXManager.IsSuspended(CacheHelper.CSTXManager.TransactionId), false, "Transaction should not be suspended");
+      Assert.AreEqual(CacheHelper.CSTXManager.Exists(CacheHelper.CSTXManager.TransactionId), true, "Transaction should exist");
+      Assert.AreEqual(2, o_region1.Region.Keys.Count, "There should be two values in the region before commit");
+      Assert.AreEqual(2, o_region2.Region.Keys.Count, "There should be two values in the region before commit");
+
+      TransactionId tid = CacheHelper.CSTXManager.Suspend();
+
+      Assert.AreEqual(CacheHelper.CSTXManager.IsSuspended(tid), true, "Transaction should be suspended");
+      Assert.AreEqual(CacheHelper.CSTXManager.Exists(tid), true, "Transaction should exist");
+      Assert.AreEqual(0, o_region1.Region.Keys.Count, "There should be 0 values in the region after suspend");
+      Assert.AreEqual(0, o_region2.Region.Keys.Count, "There should be 0 values in the region after suspend");
+
+
+      CacheHelper.CSTXManager.Resume(tid);
+      Assert.AreEqual(CacheHelper.CSTXManager.IsSuspended(tid), false, "Transaction should not be suspended");
+      Assert.AreEqual(CacheHelper.CSTXManager.Exists(tid), true, "Transaction should exist");
+      Assert.AreEqual(2, o_region1.Region.Keys.Count, "There should be two values in the region before commit");
+      Assert.AreEqual(2, o_region2.Region.Keys.Count, "There should be two values in the region before commit");
+
+      o_region2.PutOp(2, null);
+
+      Assert.AreEqual(2, o_region1.Region.Keys.Count, "There should be four values in the region before commit");
+      Assert.AreEqual(4, o_region2.Region.Keys.Count, "There should be four values in the region before commit");
+
+      CacheHelper.CSTXManager.Rollback();
+      Assert.AreEqual(CacheHelper.CSTXManager.IsSuspended(tid), false, "Transaction should not be suspended");
+      Assert.AreEqual(CacheHelper.CSTXManager.Exists(tid), false, "Transaction should NOT exist");
+      Assert.AreEqual(CacheHelper.CSTXManager.TryResume(tid), false, "Transaction should not be resumed");
+      Assert.AreEqual(CacheHelper.CSTXManager.TryResume(tid, 3000), false, "Transaction should not be resumed");
+      Assert.AreEqual(0, o_region1.Region.Keys.Count, "There should be 0 values in the region after rollback");
+      Assert.AreEqual(0, o_region2.Region.Keys.Count, "There should be 0 values in the region after rollback");
+      bool resumeEx = false;
+      try
+      {
+        CacheHelper.CSTXManager.Resume(tid);
+      }
+      catch (IllegalStateException)
+      {
+        resumeEx = true;
+      }
+      Assert.AreEqual(resumeEx, true, "The transaction should not be resumed");
+
+    }
+
+    public void SuspendResumeInThread()
+    {
+      AutoResetEvent txEvent = new AutoResetEvent(false);
+      AutoResetEvent txIdUpdated = new AutoResetEvent(false);
+      SuspendTransactionThread susObj = new SuspendTransactionThread(false, txEvent, txIdUpdated);
+      Thread susThread = new Thread(new ThreadStart(susObj.ThreadStart));
+      susThread.Start();
+      txIdUpdated.WaitOne();
+
+      ResumeTransactionThread resObj = new ResumeTransactionThread(susObj.Tid, false, false, txEvent);
+      Thread resThread = new Thread(new ThreadStart(resObj.ThreadStart));
+      resThread.Start();
+
+      susThread.Join();
+      resThread.Join();
+      Assert.AreEqual(resObj.IsFailed, false, resObj.Error);
+
+      susObj = new SuspendTransactionThread(false, txEvent, txIdUpdated);
+      susThread = new Thread(new ThreadStart(susObj.ThreadStart));
+      susThread.Start();
+      txIdUpdated.WaitOne();
+
+      resObj = new ResumeTransactionThread(susObj.Tid, true, false, txEvent);
+      resThread = new Thread(new ThreadStart(resObj.ThreadStart));
+      resThread.Start();
+
+      susThread.Join();
+      resThread.Join();
+      Assert.AreEqual(resObj.IsFailed, false, resObj.Error);
+
+
+      susObj = new SuspendTransactionThread(true, txEvent, txIdUpdated);
+      susThread = new Thread(new ThreadStart(susObj.ThreadStart));
+      susThread.Start();
+      txIdUpdated.WaitOne();
+
+      resObj = new ResumeTransactionThread(susObj.Tid, false, true, txEvent);
+      resThread = new Thread(new ThreadStart(resObj.ThreadStart));
+      resThread.Start();
+
+      susThread.Join();
+      resThread.Join();
+      Assert.AreEqual(resObj.IsFailed, false, resObj.Error);
+
+
+      susObj = new SuspendTransactionThread(true, txEvent, txIdUpdated);
+      susThread = new Thread(new ThreadStart(susObj.ThreadStart));
+      susThread.Start();
+
+      txIdUpdated.WaitOne();
+      resObj = new ResumeTransactionThread(susObj.Tid, true, true, txEvent);
+      resThread = new Thread(new ThreadStart(resObj.ThreadStart));
+      resThread.Start();
+
+      susThread.Join();
+      resThread.Join();
+      Assert.AreEqual(resObj.IsFailed, false, resObj.Error);
+
+    }
+    public void SuspendResumeCommit()
+    {
+      o_region1 = new RegionOperation(cstxRegions[0]);
+      o_region2 = new RegionOperation(cstxRegions[1]);
+
+      CacheHelper.CSTXManager.Begin();
+      o_region1.PutOp(1, null);
+
+      o_region2.PutOp(1, null);
+
+
+      Assert.AreEqual(CacheHelper.CSTXManager.IsSuspended(CacheHelper.CSTXManager.TransactionId), false, "Transaction should not be suspended");
+      Assert.AreEqual(CacheHelper.CSTXManager.Exists(CacheHelper.CSTXManager.TransactionId), true, "Transaction should exist");
+      Assert.AreEqual(2, o_region1.Region.Keys.Count, "There should be two values in the region before commit");
+      Assert.AreEqual(2, o_region2.Region.Keys.Count, "There should be two values in the region before commit");
+
+      TransactionId tid = CacheHelper.CSTXManager.Suspend();
+
+      Assert.AreEqual(CacheHelper.CSTXManager.IsSuspended(tid), true, "Transaction should be suspended");
+      Assert.AreEqual(CacheHelper.CSTXManager.Exists(tid), true, "Transaction should exist");
+      Assert.AreEqual(0, o_region1.Region.Keys.Count, "There should be 0 values in the region after suspend");
+      Assert.AreEqual(0, o_region2.Region.Keys.Count, "There should be 0 values in the region after suspend");
+
+
+      CacheHelper.CSTXManager.Resume(tid);
+      Assert.AreEqual(CacheHelper.CSTXManager.TryResume(tid), false, "The transaction should not have been resumed again.");
+      Assert.AreEqual(CacheHelper.CSTXManager.IsSuspended(tid), false, "Transaction should not be suspended");
+      Assert.AreEqual(CacheHelper.CSTXManager.Exists(tid), true, "Transaction should exist");
+      Assert.AreEqual(2, o_region1.Region.Keys.Count, "There should be two values in the region before commit");
+      Assert.AreEqual(2, o_region2.Region.Keys.Count, "There should be two values in the region before commit");
+
+      o_region2.PutOp(2, null);
+
+      Assert.AreEqual(2, o_region1.Region.Keys.Count, "There should be four values in the region before commit");
+      Assert.AreEqual(4, o_region2.Region.Keys.Count, "There should be four values in the region before commit");
+
+      CacheHelper.CSTXManager.Commit();
+      Assert.AreEqual(CacheHelper.CSTXManager.IsSuspended(tid), false, "Transaction should not be suspended");
+      Assert.AreEqual(CacheHelper.CSTXManager.Exists(tid), false, "Transaction should NOT exist");
+      Assert.AreEqual(CacheHelper.CSTXManager.TryResume(tid), false, "Transaction should not be resumed");
+      Assert.AreEqual(CacheHelper.CSTXManager.TryResume(tid, 3000), false, "Transaction should not be resumed");
+      Assert.AreEqual(2, o_region1.Region.Keys.Count, "There should be four values in the region after commit");
+      Assert.AreEqual(4, o_region2.Region.Keys.Count, "There should be four values in the region after commit");
+      o_region1.DestroyOpWithPdxValue(1, null);
+      o_region2.DestroyOpWithPdxValue(2, null);
+      bool resumeEx = false;
+      try
+      {
+        CacheHelper.CSTXManager.Resume(tid);
+      }
+      catch (IllegalStateException)
+      {
+        resumeEx = true;
+      }
+      Assert.AreEqual(resumeEx, true, "The transaction should not be resumed");
+      Assert.AreEqual(CacheHelper.CSTXManager.Suspend(), null, "The transaction should not be suspended");
+    }
+
+    public void CallOp()
+    {
+      #region CSTX_COMMENTED - transaction listener and writer are disabled for now
+      /*
+      m_writer1 = new CSTXWriter<object, object>(CacheHelper.DCache.Name, "cstxWriter1");
+      m_writer2 = new CSTXWriter<object, object>(CacheHelper.DCache.Name, "cstxWriter2");
+      m_listener1 = new CSTXListener<object, object>(CacheHelper.DCache.Name);
+      m_listener2 = new CSTXListener<object, object>(CacheHelper.DCache.Name);
+      
+      CacheHelper.CSTXManager.AddListener<object, object>(m_listener1);
+      CacheHelper.CSTXManager.AddListener<object, object>(m_listener2);
+      CacheHelper.CSTXManager.SetWriter<object, object>(m_writer1);
+      
+      // test two listener one writer for commit on two regions
+      Util.Log(" test two listener one writer for commit on two regions");
+      */
+      #endregion
+
+      CacheHelper.CSTXManager.Begin();
+      o_region1 = new RegionOperation(cstxRegions[0]);
+      o_region1.PutOp(2, null);
+
+      o_region2 = new RegionOperation(cstxRegions[1]);
+      o_region2.PutOp(2, null);
+
+      CacheHelper.CSTXManager.Commit();
+      //two pdx put as well
+      Assert.AreEqual(2 + 2, o_region1.Region.Keys.Count, "Commit didn't put two values in the region");
+      Assert.AreEqual(2 + 2, o_region2.Region.Keys.Count, "Commit didn't put two values in the region");
+
+      #region CSTX_COMMENTED - transaction listener and writer are disabled for now
+      /*
+      Util.Log(" test two listener one writer for commit on two regions - complete");
+      //////////////////////////////////
+      
+      // region test two listener one writer for commit on one region
+      Util.Log(" region test two listener one writer for commit on one region");
+      CacheHelper.CSTXManager.Begin();
+      o_region1.PutOp(2, null);
+
+      CacheHelper.CSTXManager.Commit();
+      Util.Log(" region test two listener one writer for commit on one region - complete");
+      //////////////////////////////////
+      // test two listener one writer for rollback on two regions
+      Util.Log(" test two listener one writer for rollback on two regions");
+      */
+      #endregion
+
+      CacheHelper.CSTXManager.Begin();
+      o_region1.PutOp(2, null);
+
+      o_region2.PutOp(2, null);
+
+      CacheHelper.CSTXManager.Rollback();
+      //two pdx put as well
+      Assert.AreEqual(2 + 2, o_region1.Region.Keys.Count, "Region has incorrect number of objects");
+      Assert.AreEqual(2 + 2, o_region2.Region.Keys.Count, "Region has incorrect number of objects");
+      o_region1.DestroyOpWithPdxValue(2, null);
+      o_region2.DestroyOpWithPdxValue(2, null);
+
+      #region CSTX_COMMENTED - transaction listener and writer are disabled for now
+      /*
+      
+      Util.Log(" test two listener one writer for rollback on two regions - complete");
+      //////////////////////////////////
+      
+      // test two listener one writer for rollback on on region
+      Util.Log(" test two listener one writer for rollback on on region");
+      CacheHelper.CSTXManager.Begin();
+     
+      o_region2.PutOp(2, null);
+
+      CacheHelper.CSTXManager.Rollback();
+      Util.Log(" test two listener one writer for rollback on on region - complete");
+      //////////////////////////////////
+      
+      // test remove listener
+      Util.Log(" test remove listener");
+      CacheHelper.CSTXManager.RemoveListener<object, object>(m_listener2);
+      
+      CacheHelper.CSTXManager.Begin();
+      o_region1.PutOp(2, null);
+
+      o_region2.PutOp(2, null);
+
+      CacheHelper.CSTXManager.Commit();
+      Util.Log(" test remove listener - complete" );
+      //////////////////////////////////
+      
+      // test GetWriter
+      Util.Log("test GetWriter");
+      CSTXWriter<object, object> writer = (CSTXWriter<object, object>)CacheHelper.CSTXManager.GetWriter<object, object>();
+      Assert.AreEqual(writer.InstanceName, m_writer1.InstanceName, "GetWriter is not returning the object set by SetWriter");
+      Util.Log("test GetWriter - complete");
+      //////////////////////////////////
+      
+      // set a different writer 
+      Util.Log("set a different writer");
+      CacheHelper.CSTXManager.SetWriter<object, object>(m_writer2);
+      
+      CacheHelper.CSTXManager.Begin();
+      o_region1.PutOp(2, null);
+
+      o_region2.PutOp(2, null);
+
+      CacheHelper.CSTXManager.Commit();
+      Util.Log("set a different writer - complete");
+      //////////////////////////////////
+      */
+      #endregion
+    }
+
+    void runThinClientCSTXTest()
+    {
+      CacheHelper.SetupJavaServers(true, "client_server_transactions.xml");
+      CacheHelper.StartJavaLocator(1, "GFELOC");
+      Util.Log("Locator started");
+      CacheHelper.StartJavaServerWithLocators(1, "GFECS1", 1);
+
+      Util.Log("Cacheserver 1 started.");
+
+      m_client1.Call(CacheHelper.InitClient);
+      Util.Log("Creating two regions in client1");
+      m_client1.Call(CreateRegion, cstxRegions[0], CacheHelper.Locators, false);
+      m_client1.Call(CreateRegion, cstxRegions[1], CacheHelper.Locators, false);
+      m_client1.Call(CreateRegion, cstxRegions[2], CacheHelper.Locators, true);
+
+      m_client1.Call(CallOp);
+      m_client1.Call(SuspendResumeCommit);
+      m_client1.Call(SuspendResumeRollback);
+      m_client1.Call(SuspendResumeInThread);
+
+
+      m_client1.Call(ValidateListener);
+
+      #region CSTX_COMMENTED - transaction listener and writer are disabled for now
+      /*
+      m_client1.Call(ValidateCSTXListenerWriter);
+      */
+      #endregion
+
+      m_client1.Call(CacheHelper.Close);
+
+      CacheHelper.StopJavaServer(1);
+
+      CacheHelper.StopJavaLocator(1);
+      Util.Log("Locator stopped");
+
+      CacheHelper.ClearLocators();
+      CacheHelper.ClearEndpoints();
+    }
+
+    void runThinClientPersistentTXTest()
+    {
+      CacheHelper.SetupJavaServers(true, "client_server_persistent_transactions.xml");
+      CacheHelper.StartJavaLocator(1, "GFELOC");
+      Util.Log("Locator started");
+      CacheHelper.StartJavaServerWithLocators(1, "GFECS1", 1, "--J=-Dgemfire.ALLOW_PERSISTENT_TRANSACTIONS=true");
+
+      Util.Log("Cacheserver 1 started.");
+
+      m_client1.Call(CacheHelper.InitClient);
+      Util.Log("Creating two regions in client1");
+      m_client1.Call(CreateRegion, cstxRegions[0], CacheHelper.Locators, false);
+
+      m_client1.Call(initializePdxSerializer);
+      m_client1.Call(doPutGetWithPdxSerializer);
+
+      m_client1.Call(CacheHelper.Close);
+
+      CacheHelper.StopJavaServer(1);
+
+      CacheHelper.StopJavaLocator(1);
+      Util.Log("Locator stopped");
+
+      CacheHelper.ClearLocators();
+      CacheHelper.ClearEndpoints();
+    }
+
+    [TearDown]
+    public override void EndTest()
+    {
+      base.EndTest();
+    }
+
+    //Successful
+    [Test]
+    public void ThinClientCSTXTest()
+    {
+      runThinClientCSTXTest();
+    }
+
+    [Test]
+    public void ThinClientPersistentTXTest()
+    {
+      runThinClientPersistentTXTest();
+    }
+
+    public class SuspendTransactionThread
+    {
+      public SuspendTransactionThread(bool sleep, AutoResetEvent txevent, AutoResetEvent txIdUpdated)
+      {
+        m_sleep = sleep;
+        m_txevent = txevent;
+        m_txIdUpdated = txIdUpdated;
+      }
+      public void ThreadStart()
+      {
+        RegionOperation o_region1 = new RegionOperation(cstxRegions[0]);
+        RegionOperation o_region2 = new RegionOperation(cstxRegions[1]);
+        CacheHelper.CSTXManager.Begin();
+
+        o_region1.PutOp(1, null);
+        o_region2.PutOp(1, null);
+
+        m_tid = CacheHelper.CSTXManager.TransactionId;
+        m_txIdUpdated.Set();
+
+        if (m_sleep)
+        {
+          m_txevent.WaitOne();
+          Thread.Sleep(5000);
+        }
+
+        m_tid = CacheHelper.CSTXManager.Suspend();
+      }
+
+      public TransactionId Tid
+      {
+        get
+        {
+          return m_tid;
+        }
+      }
+
+      private TransactionId m_tid = null;
+      private bool m_sleep = false;
+      private AutoResetEvent m_txevent = null;
+      AutoResetEvent m_txIdUpdated = null;
+    }
+
+    public class ResumeTransactionThread
+    {
+      public ResumeTransactionThread(TransactionId tid, bool isCommit, bool tryResumeWithSleep, AutoResetEvent txevent)
+      {
+        m_tryResumeWithSleep = tryResumeWithSleep;
+        m_txevent = txevent;
+        m_tid = tid;
+        m_isCommit = isCommit;
+      }
+
+      public void ThreadStart()
+      {
+        RegionOperation o_region1 = new RegionOperation(cstxRegions[0]);
+        RegionOperation o_region2 = new RegionOperation(cstxRegions[1]);
+        if (m_tryResumeWithSleep)
+        {
+          if (AssertCheckFail(CacheHelper.CSTXManager.IsSuspended(m_tid) == false, "Transaction should not be suspended"))
+            return;
+        }
+        else
+        {
+          if (AssertCheckFail(CacheHelper.CSTXManager.IsSuspended(m_tid) == true, "Transaction should be suspended"))
+            return;
+        }
+        if (AssertCheckFail(CacheHelper.CSTXManager.Exists(m_tid) == true, "Transaction should exist"))
+          return;
+        if (AssertCheckFail(0 == o_region1.Region.Keys.Count, "There should be 0 values in the region after suspend"))
+          return;
+        if (AssertCheckFail(0 == o_region2.Region.Keys.Count, "There should be 0 values in the region after suspend"))
+          return;
+
+        if (m_tryResumeWithSleep)
+        {
+          m_txevent.Set();
+          CacheHelper.CSTXManager.TryResume(m_tid, 30000);
+        }
+        else
+          CacheHelper.CSTXManager.Resume(m_tid);
+
+        if (AssertCheckFail(CacheHelper.CSTXManager.IsSuspended(m_tid) == false, "Transaction should not be suspended"))
+          return;
+        if (AssertCheckFail(CacheHelper.CSTXManager.Exists(m_tid) == true, "Transaction should exist"))
+          return;
+        if (AssertCheckFail(o_region1.Region.Keys.Count == 2, "There should be two values in the region after suspend"))
+          return;
+        if (AssertCheckFail(o_region2.Region.Keys.Count == 2, "There should be two values in the region after suspend"))
+          return;
+
+        o_region2.PutOp(2, null);
+
+        if (m_isCommit)
+        {
+          CacheHelper.CSTXManager.Commit();
+          if (AssertCheckFail(CacheHelper.CSTXManager.IsSuspended(m_tid) == false, "Transaction should not be suspended"))
+            return;
+          if (AssertCheckFail(CacheHelper.CSTXManager.Exists(m_tid) == false, "Transaction should NOT exist"))
+            return;
+          if (AssertCheckFail(CacheHelper.CSTXManager.TryResume(m_tid) == false, "Transaction should not be resumed"))
+            return;
+          if (AssertCheckFail(CacheHelper.CSTXManager.TryResume(m_tid, 3000) == false, "Transaction should not be resumed"))
+            return;
+          if (AssertCheckFail(2 == o_region1.Region.Keys.Count, "There should be four values in the region after commit"))
+            return;
+          if (AssertCheckFail(4 == o_region2.Region.Keys.Count, "There should be four values in the region after commit"))
+            return;
+          o_region1.DestroyOpWithPdxValue(1, null);
+          o_region2.DestroyOpWithPdxValue(2, null);
+        }
+        else
+        {
+          CacheHelper.CSTXManager.Rollback();
+          if (AssertCheckFail(CacheHelper.CSTXManager.IsSuspended(m_tid) == false, "Transaction should not be suspended"))
+            return;
+          if (AssertCheckFail(CacheHelper.CSTXManager.Exists(m_tid) == false, "Transaction should NOT exist"))
+            return;
+          if (AssertCheckFail(CacheHelper.CSTXManager.TryResume(m_tid) == false, "Transaction should not be resumed"))
+            return;
+          if (AssertCheckFail(CacheHelper.CSTXManager.TryResume(m_tid, 3000) == false, "Transaction should not be resumed"))
+            return;
+          if (AssertCheckFail(0 == o_region1.Region.Keys.Count, "There should be 0 values in the region after rollback"))
+            return;
+          if (AssertCheckFail(0 == o_region2.Region.Keys.Count, "There should be 0 values in the region after rollback"))
+            return;
+        }
+
+      }
+
+      public bool AssertCheckFail(bool cond, String error)
+      {
+        if (!cond)
+        {
+          m_isFailed = true;
+          m_error = error;
+          return true;
+        }
+        return false;
+      }
+
+      public TransactionId Tid
+      {
+        get { return m_tid; }
+      }
+      public bool IsFailed
+      {
+        get { return m_isFailed; }
+      }
+      public String Error
+      {
+        get { return m_error; }
+      }
+
+      private TransactionId m_tid = null;
+      private bool m_tryResumeWithSleep = false;
+      private bool m_isFailed = false;
+      private String m_error;
+      private bool m_isCommit = false;
+      private AutoResetEvent m_txevent = null;
+
+    }
+    
+    public void initializePdxSerializer()
+    {
+      Serializable.RegisterPdxSerializer(new PdxSerializer());
+    }
+
+    public void doPutGetWithPdxSerializer()
+    {
+      CacheHelper.CSTXManager.Begin();
+      o_region1 = new RegionOperation(cstxRegions[0]);
+      for (int i = 0; i < 10; i++)
+      {
+        o_region1.Region[i] = i + 1;
+        object ret = o_region1.Region[i];
+        o_region1.Region[i + 10] = i + 10;
+        ret = o_region1.Region[i + 10];
+        o_region1.Region[i + 20] = i + 20;
+        ret = o_region1.Region[i + 20];
+      }
+      CacheHelper.CSTXManager.Commit();
+      Util.Log("Region keys count after commit for non-pdx keys = {0} ", o_region1.Region.Keys.Count);
+      Assert.AreEqual(30, o_region1.Region.Keys.Count, "Commit didn't put two values in the region");
+
+      CacheHelper.CSTXManager.Begin();
+      o_region1 = new RegionOperation(cstxRegions[0]);
+      for (int i = 100; i < 110; i++)
+      {
+        object put = new SerializePdx1(true);
+        o_region1.Region[i] = put;                
+        put = new SerializePdx2(true);
+        o_region1.Region[i + 10] = put;
+        put = new SerializePdx3(true, i % 2);
+        o_region1.Region[i + 20] = put;        
+      }
+      CacheHelper.CSTXManager.Commit();
+
+      for (int i = 100; i < 110; i++)
+      {
+        object put = new SerializePdx1(true);
+        object ret = o_region1.Region[i];
+        Assert.AreEqual(put, ret);
+        put = new SerializePdx2(true);
+        ret = o_region1.Region[i + 10];
+        Assert.AreEqual(put, ret);
+        put = new SerializePdx3(true, i % 2);
+        ret = o_region1.Region[i + 20];
+        Assert.AreEqual(put, ret);
+      }
+      Util.Log("Region keys count after pdx-keys commit = {0} ", o_region1.Region.Keys.Count);
+      Assert.AreEqual(60, o_region1.Region.Keys.Count, "Commit didn't put two values in the region");      
+    }
+  }
+}

http://git-wip-us.apache.org/repos/asf/geode/blob/2d4a7ecd/src/clicache/integration-test/ThinClientCallbackArgN.cs
----------------------------------------------------------------------
diff --git a/src/clicache/integration-test/ThinClientCallbackArgN.cs b/src/clicache/integration-test/ThinClientCallbackArgN.cs
new file mode 100644
index 0000000..fca3f0e
--- /dev/null
+++ b/src/clicache/integration-test/ThinClientCallbackArgN.cs
@@ -0,0 +1,709 @@
+using System;
+using System.Threading;
+
+namespace GemStone.GemFire.Cache.UnitTests.NewAPI
+{
+  using NUnit.Framework;
+  using GemStone.GemFire.DUnitFramework;
+  using GemStone.GemFire.Cache.Tests.NewAPI;
+
+  using GemStone.GemFire.Cache.Generic;
+
+  using GIRegion = GemStone.GemFire.Cache.Generic.IRegion<int, object>;
+  using System.Collections.Generic;
+
+  public class CallbackListener : CacheListenerAdapter<int, object>
+  {
+    int m_creates;
+    int m_updates;
+    int m_invalidates;
+    int m_destroys;
+    int m_regionInvalidate;
+    int m_regionDestroy;
+    int m_regionClear; 
+    object m_callbackArg;
+
+    #region Getters
+
+    public int Creates
+    {
+      get { return m_creates; }
+    }
+
+    public int Updates
+    {
+      get { return m_updates; }
+    }
+
+    public int Invalidates
+    {
+      get { return m_invalidates; }
+    }
+
+    public int Destroys
+    {
+      get { return m_destroys; }
+    }
+
+    public int RegionInvalidates
+    {
+      get { return m_regionInvalidate; }
+    }
+
+    public int RegionDestroys
+    {
+      get { return m_regionDestroy; }
+    }
+    public int RegionClear
+ 	{ 
+ 	  get { return m_regionClear; }
+ 	}
+    public object CallbackArg
+    {
+      get { return m_callbackArg; }
+    }
+    #endregion
+
+    public void SetCallbackArg(object callbackArg)
+    {
+      m_callbackArg = callbackArg;
+    }
+
+    private void check(object eventCallback, ref int updateCount)
+    {
+      Log.Fine("check..");
+      if (eventCallback != null)
+      {
+        string callbackArg = eventCallback as string;
+
+        if (callbackArg != null)
+        {
+          string cs = m_callbackArg as string;
+          if (cs != null)
+          {
+            if (callbackArg == cs)
+            {
+              Log.Fine("value matched");
+              updateCount++;
+            }
+            else
+              Log.Fine("value matched NOT");
+          }
+        }
+        else
+        {
+          Log.Fine("Callbackarg is not cacheable string");
+          Portfolio pfCallback = eventCallback as Portfolio;
+          if (pfCallback != null)
+          {
+            Portfolio pf = m_callbackArg as Portfolio;
+            if (pf != null)
+            {
+              if (pf.Pkid == pfCallback.Pkid && pfCallback.ArrayNull == null
+                    && pfCallback.ArrayZeroSize != null && pfCallback.ArrayZeroSize.Length == 0)
+              {
+                Log.Fine("value matched");
+                updateCount++;
+              }
+            }
+          }
+        }
+      }
+    }
+
+    private void checkCallbackArg(EntryEvent<int, object> entryEvent, ref int updateCount)
+    {
+      check(entryEvent.CallbackArgument, ref updateCount);
+    }
+
+    private void checkCallbackArg(RegionEvent<int, object> regionEvent, ref int updateCount)
+    {
+      check(regionEvent.CallbackArgument, ref updateCount);
+    }
+
+    #region CacheListener Members
+
+    public override void AfterCreate(EntryEvent<int, object> ev)
+    {
+      checkCallbackArg(ev, ref m_creates);
+    }
+
+    public override void AfterUpdate(EntryEvent<int, object> ev)
+    {
+      checkCallbackArg(ev, ref m_updates);
+    }
+
+    public override void AfterInvalidate(EntryEvent<int, object> ev)
+    {
+      checkCallbackArg(ev, ref m_invalidates);
+    }
+
+    public override void AfterDestroy(EntryEvent<int, object> ev)
+    {
+      checkCallbackArg(ev, ref m_destroys);
+    }
+
+    public override void AfterRegionInvalidate(RegionEvent<int, object> rev)
+    {
+      checkCallbackArg(rev, ref m_regionInvalidate);
+    }
+
+    public override void AfterRegionDestroy(RegionEvent<int, object> rev)
+    {
+      checkCallbackArg(rev, ref m_regionDestroy);
+    }
+    public override void AfterRegionClear(RegionEvent<int, object> rev)
+    {
+        checkCallbackArg(rev, ref m_regionClear);
+    }
+
+    #endregion
+  }
+
+  [TestFixture]
+  [Category("generics")]
+  public class ThinClientCallbackArg : ThinClientRegionSteps
+  {
+    private TallyWriter<int, object> m_writer;
+    private TallyListener<int, object> m_listener;
+    private CallbackListener m_callbackListener;
+    RegionOperation o_region;
+    private UnitProcess m_client1, m_client2;
+    int key0 = 12;
+    object m_callbackarg = "Gemstone's Callback";
+    
+    protected override ClientBase[] GetClients()
+    {
+      m_client1 = new UnitProcess();
+      m_client2 = new UnitProcess();
+      return new ClientBase[] { m_client1, m_client2 };
+    }
+
+    public void CreateRegion(string locators,
+      bool caching, bool listener, bool writer)
+    {
+      if (listener)
+      {
+        m_listener = new TallyListener<int, object>();
+
+      }
+      else
+      {
+        m_listener = null;
+      }
+      GIRegion region = null;
+      region = CacheHelper.CreateTCRegion_Pool<int, object>(RegionName, true, caching,
+        m_listener, locators, "__TESTPOOL1_", true);
+      if (listener)
+        m_listener.SetCallBackArg(key0);
+
+      if (writer)
+      {
+        m_writer = new TallyWriter<int, object>();
+
+      }
+      else
+      {
+        m_writer = null;
+      }
+      if (writer)
+      {
+        AttributesMutator<int, object> at = region.AttributesMutator;
+        at.SetCacheWriter(m_writer);
+        m_writer.SetCallBackArg(key0);
+      }
+    }
+
+    public void CreateRegion2(string locators,
+      bool caching, bool listener, bool writer)
+    {
+      CallbackListener callbackLis = null;
+      if (listener)
+      {
+        m_callbackListener = new CallbackListener();
+        m_callbackListener.SetCallbackArg(m_callbackarg);
+        callbackLis = m_callbackListener;
+      }
+      else
+      {
+        m_listener = null;
+      }
+      GIRegion region = null;
+      region = CacheHelper.CreateTCRegion_Pool<int, object>(RegionName, true, caching,
+        callbackLis, locators, "__TESTPOOL1_", true);
+    }
+
+    public void ValidateLocalListenerWriterData()
+    {
+      Thread.Sleep(2000);
+      Assert.AreEqual(true, m_writer.IsWriterInvoked, "Writer should be invoked");
+      Assert.AreEqual(true, m_listener.IsListenerInvoked, "Listener should be invoked");
+      Assert.AreEqual(true, m_writer.IsCallBackArgCalled, "Writer CallbackArg should be invoked");
+      Assert.AreEqual(true, m_listener.IsCallBackArgCalled, "Listener CallbackArg should be invoked");
+      m_listener.ShowTallies();
+      m_writer.ShowTallies();
+    }
+
+    public void ValidateEvents()
+    {
+      Assert.AreEqual(15, m_writer.Creates, "Should be 10 creates");
+      Assert.AreEqual(15, m_listener.Creates, "Should be 10 creates");
+      Assert.AreEqual(15, m_writer.Updates, "Should be 5 updates");
+      Assert.AreEqual(15, m_listener.Updates, "Should be 5 updates");
+      Assert.AreEqual(0, m_writer.Invalidates, "Should be 0 invalidates");
+      Assert.AreEqual(5, m_listener.Invalidates, "Should be 5 invalidates");
+      Assert.AreEqual(10, m_writer.Destroys, "Should be 10 destroys");  // 5 destroys + 5 removes
+      Assert.AreEqual(10, m_listener.Destroys, "Should be 10 destroys"); // 5 destroys + 5 removes
+    }
+
+    public void CallOp()
+    {
+      o_region = new RegionOperation(RegionName);
+      o_region.PutOp(5, key0);
+      Thread.Sleep(1000); // let the events reach at other end.
+      o_region.PutOp(5, key0);
+      Thread.Sleep(1000);
+      o_region.InvalidateOp(5, key0);
+      Thread.Sleep(1000);
+      o_region.DestroyOp(5, key0);
+      Thread.Sleep(1000); // let the events reach at other end.
+      o_region.PutOp(5, key0);
+      Thread.Sleep(1000);
+      o_region.RemoveOp(5, key0);
+      Thread.Sleep(1000);
+    }
+
+    void RegisterPdxType8()
+    {
+      Serializable.RegisterPdxType(PdxTests.PdxTypes8.CreateDeserializable);
+    }
+
+    void runCallbackArgTest()
+    {
+      CacheHelper.SetupJavaServers(true, "cacheserver_notify_subscription.xml");
+      CacheHelper.StartJavaLocator(1, "GFELOC");
+      Util.Log("Locator started");
+      CacheHelper.StartJavaServerWithLocators(1, "GFECS1", 1);
+      Util.Log("Cacheserver 1 started.");
+
+      Util.Log("Creating region in client1, no-ack, cache-enabled, with listener and writer");
+      m_client1.Call(CreateRegion, CacheHelper.Locators,
+        true, true, true);
+      m_client1.Call(RegisterAllKeys, new string[] { RegionName });
+
+      Util.Log("Creating region in client2 , no-ack, cache-enabled, with listener and writer");
+      m_client2.Call(CreateRegion, CacheHelper.Locators,
+        true, true, true);
+      m_client2.Call(RegisterAllKeys, new string[] { RegionName });
+
+      m_client2.Call(RegisterPdxType8);
+
+      m_client1.Call(CallOp);
+      
+
+      m_client1.Call(ValidateLocalListenerWriterData);
+      m_client1.Call(ValidateEvents);
+
+      m_client1.Call(CacheHelper.Close);
+      m_client2.Call(CacheHelper.Close);
+
+      CacheHelper.StopJavaServer(1);
+      Util.Log("Cacheserver 1 stopped.");
+
+      CacheHelper.StopJavaLocator(1);
+      Util.Log("Locator stopped");
+
+      CacheHelper.ClearLocators();
+      CacheHelper.ClearEndpoints();
+    }
+
+    private bool m_isSet = false;
+    public void SetCallbackArg()
+    {
+      if (!m_isSet)
+      {
+        m_isSet = true;
+        m_callbackarg = new Portfolio(1, 1);
+        //TODO:;split
+        Serializable.RegisterTypeGeneric(Portfolio.CreateDeserializable);
+        Serializable.RegisterTypeGeneric(Position.CreateDeserializable);
+      }
+    }
+
+    public void TestCreatesAndUpdates()
+    {
+      o_region = new RegionOperation(RegionName);
+      o_region.Region.Add("Key-1", "Val-1", m_callbackarg);
+      o_region.Region.Put("Key-1", "NewVal-1", m_callbackarg);
+      Thread.Sleep(10000);
+    }
+
+    public void TestInvalidates()
+    {
+      o_region = new RegionOperation(RegionName);
+      o_region.Region.GetLocalView().Add(1234, 1234, m_callbackarg);
+      o_region.Region.GetLocalView().Add(12345, 12345, m_callbackarg);
+      o_region.Region.GetLocalView().Add(12346, 12346, m_callbackarg);
+      o_region.Region.GetLocalView().Put(1234, "Val-1", m_callbackarg);
+      o_region.Region.GetLocalView().Invalidate(1234, m_callbackarg);
+      Assert.AreEqual(o_region.Region.GetLocalView().Remove(12345, 12345, m_callbackarg), true, "Result of remove should be true, as this value exists locally.");
+      Assert.AreEqual(o_region.Region.GetLocalView().ContainsKey(12345), false, "containsKey should be false");
+      Assert.AreEqual(o_region.Region.GetLocalView().Remove(12346, m_callbackarg), true, "Result of remove should be true, as this value exists locally.");
+      Assert.AreEqual(o_region.Region.GetLocalView().ContainsKey(12346), false, "containsKey should be false"); 
+      o_region.Region.Invalidate("Key-1", m_callbackarg);
+      o_region.Region.InvalidateRegion(m_callbackarg);
+    }
+
+    public void TestDestroy()
+    {
+      o_region = new RegionOperation(RegionName);
+      o_region.Region.Remove("Key-1", m_callbackarg);
+      //o_region.Region.DestroyRegion(m_callbackarg);
+    }
+
+    public void TestRemove()
+    {
+      o_region = new RegionOperation(RegionName);
+      o_region.Region.Remove("Key-1", "NewVal-1", m_callbackarg);
+      o_region.Region.DestroyRegion(m_callbackarg);
+    }
+
+    public void TestlocalClear()
+    {
+        o_region = new RegionOperation(RegionName);
+        o_region.Region.GetLocalView().Clear(m_callbackarg); 
+    }
+    public void TestValidate()
+    {
+      Thread.Sleep(10000);
+      Assert.AreEqual(5, m_callbackListener.Creates, "Should be 5 creates");
+      Assert.AreEqual(3, m_callbackListener.Updates, "Should be 3 update");
+      Assert.AreEqual(2, m_callbackListener.Invalidates, "Should be 2 invalidate");
+      Assert.AreEqual(4, m_callbackListener.Destroys, "Should be 4 destroy");
+      Assert.AreEqual(1, m_callbackListener.RegionInvalidates, "Should be 1 region invalidates");
+      Assert.AreEqual(1, m_callbackListener.RegionDestroys, "Should be 1 regiondestroy");
+      Assert.AreEqual(1, m_callbackListener.RegionClear, "Should be 1 RegionClear");
+    }
+
+    void runCallbackArgTest2(int callbackArgChange)
+    {
+      if (callbackArgChange == 1)
+      {
+        //change now custom type
+        m_callbackarg = new Portfolio(1, 1);
+        m_client1.Call(SetCallbackArg);
+        m_client2.Call(SetCallbackArg);
+      }
+
+      m_callbackListener = new CallbackListener();
+      m_callbackListener.SetCallbackArg(m_callbackarg);
+      CacheHelper.SetupJavaServers(true, "cacheserver_notify_subscription5N.xml");
+      CacheHelper.StartJavaLocator(1, "GFELOC");
+      Util.Log("Locator started");
+      CacheHelper.StartJavaServerWithLocators(1, "GFECS1", 1);
+      Util.Log("Cacheserver 1 started.");
+
+      Util.Log("Creating region in client1, no-ack, cache-enabled, with listener and writer");
+      m_client1.Call(CreateRegion2, CacheHelper.Locators,
+        true, true, false);
+      m_client1.Call(RegisterAllKeys, new string[] { RegionName });
+
+      Util.Log("Creating region in client2 , no-ack, cache-enabled, with listener and writer");
+      m_client2.Call(CreateRegion2, CacheHelper.Locators,
+        true, false, false);
+
+      m_client2.Call(TestCreatesAndUpdates);
+      m_client1.Call(TestInvalidates);
+      m_client2.Call(TestDestroy);
+      m_client2.Call(TestCreatesAndUpdates);
+      m_client1.Call(TestlocalClear); 
+      m_client2.Call(TestRemove);
+      m_client1.Call(TestValidate);
+
+      m_client1.Call(CacheHelper.Close);
+      m_client2.Call(CacheHelper.Close);
+
+      CacheHelper.StopJavaServer(1);
+      Util.Log("Cacheserver 1 stopped.");
+
+      CacheHelper.StopJavaLocator(1);
+      Util.Log("Locator stopped");
+
+      CacheHelper.ClearLocators();
+      CacheHelper.ClearEndpoints();
+    }
+
+    private bool isRegistered = false;
+    public void registerDefaultCacheableType()
+    {
+      if (!isRegistered)
+      {
+        Serializable.RegisterTypeGeneric(DefaultType.CreateDeserializable);
+        isRegistered = true;
+      }
+    }
+
+
+    public void CallOp2()
+    {
+      o_region = new RegionOperation(RegionName);
+      DefaultType dc = new DefaultType(true);
+      o_region.Region.Put("key-1", dc, null);
+      Thread.Sleep(1000); // let the events reach at other end.
+    }
+
+    public void ValidateData()
+    {
+      o_region = new RegionOperation(RegionName);
+      DefaultType dc = (DefaultType)o_region.Region.Get("key-1", null);
+
+      Assert.AreEqual(dc.CBool, true, "bool is not equal");
+      Assert.AreEqual(dc.CInt, 1000, "int is not equal");
+
+      int[] cia = dc.CIntArray;
+      Assert.IsNotNull(cia, "Int array is null");
+      Assert.AreEqual(3, cia.Length, "Int array are not three");
+
+      string[] csa = dc.CStringArray;
+      Assert.IsNotNull(csa, "String array is null");
+      Assert.AreEqual(2, csa.Length, "String array length is not two");
+
+      Assert.AreEqual(dc.CFileName, "gemstone.txt", "Cacheable filename is not equal");
+
+      /*
+      Assert.IsNotNull(dc.CHashSet, "hashset is null");
+      Assert.AreEqual(2, dc.CHashSet.Count, "hashset size is not two");
+       * */
+
+      Assert.IsNotNull(dc.CHashMap, "hashmap is null");
+      Assert.AreEqual(1, dc.CHashMap.Count, "hashmap size is not one");
+
+      //Assert.IsNotNull(dc.CDate, "Date is null");
+
+      Assert.IsNotNull(dc.CVector);
+      Assert.AreEqual(2, dc.CVector.Count, "Vector size is not two");
+
+      //Assert.IsNotNull(dc.CObject);
+      //Assert.AreEqual("key", ((CustomSerializableObject)dc.CObject).key, "Object key is not same");
+      //Assert.AreEqual("value", ((CustomSerializableObject)dc.CObject).value, "Object value is not same");
+    }
+
+    void runCallbackArgTest3()
+    {
+
+      CacheHelper.SetupJavaServers(true, "cacheserver_notify_subscription6.xml");
+      CacheHelper.StartJavaLocator(1, "GFELOC");
+      Util.Log("Locator started");
+      CacheHelper.StartJavaServerWithLocators(1, "GFECS1", 1);
+      Util.Log("Cacheserver 1 started.");
+
+      Util.Log("Creating region in client1, no-ack, cache-enabled, with listener and writer");
+      m_client1.Call(CreateRegion, CacheHelper.Locators,
+        true, false, false);
+      // m_client1.Call(RegisterAllKeys, new string[] { RegionName });
+
+      Util.Log("Creating region in client2 , no-ack, cache-enabled, with listener and writer");
+      m_client2.Call(CreateRegion, CacheHelper.Locators,
+        true, false, false);
+
+      m_client1.Call(registerDefaultCacheableType);
+      m_client2.Call(registerDefaultCacheableType);
+
+      m_client2.Call(RegisterAllKeys, new string[] { RegionName });
+
+      m_client1.Call(CallOp2);
+
+      m_client2.Call(ValidateData);
+
+      m_client1.Call(CacheHelper.Close);
+      m_client2.Call(CacheHelper.Close);
+
+      CacheHelper.StopJavaServer(1);
+      Util.Log("Cacheserver 1 stopped.");
+
+      CacheHelper.StopJavaLocator(1);
+      Util.Log("Locator stopped");
+
+      CacheHelper.ClearLocators();
+      CacheHelper.ClearEndpoints();
+    }
+
+    public void TestRemoveAll()
+    {
+      o_region = new RegionOperation(RegionName);
+      ICollection<object> keys = new LinkedList<object>(); 
+      for(int i =0; i< 10; i++)
+      {
+        o_region.Region["Key-"+i] = "Value-"+i;
+        keys.Add("Key-" + i);
+      }
+      o_region.Region.RemoveAll(keys, m_callbackarg);
+    }
+
+    public void TestPutAll()
+    {
+      o_region = new RegionOperation(RegionName);
+      Dictionary<Object, Object> entryMap = new Dictionary<Object, Object>();
+      for (Int32 item = 0; item < 10; item++)
+      {
+        int K = item;
+        string value = item.ToString();
+        entryMap.Add(K, value);
+      }
+      o_region.Region.PutAll(entryMap, 15, m_callbackarg);
+    }
+
+    public void TestGetAll()
+    {
+      o_region = new RegionOperation(RegionName);
+      List<Object> keys = new List<Object>();
+      for (int item = 0; item < 10; item++)
+      {
+        Object K = item;
+        keys.Add(K);
+      }
+      Dictionary<Object, Object> values = new Dictionary<Object, Object>();
+      o_region.Region.GetAll(keys.ToArray(), values, null, true, m_callbackarg);
+
+      Dictionary<Object, Object>.Enumerator enumerator = values.GetEnumerator();
+      while (enumerator.MoveNext())
+      {
+        Util.Log("Values after getAll with CallBack Key = {0} Value = {1} ", enumerator.Current.Key.ToString(), enumerator.Current.Value.ToString());
+      }
+    }
+
+    public void TestValidateRemoveAllCallback()
+    {
+      Thread.Sleep(10000);
+      Assert.AreEqual(10, m_callbackListener.Destroys, "Should be 10 destroy");
+    }
+
+    public void TestValidatePutAllCallback()
+    {
+      Thread.Sleep(10000);
+      Assert.AreEqual(10, m_callbackListener.Creates, "Should be 10 creates");      
+      Assert.AreEqual("Gemstone's Callback", m_callbackListener.CallbackArg, "CallBackArg for putAll should be same");
+    }
+
+    void runPutAllCallbackArgTest()
+    {
+      m_callbackListener = new CallbackListener();
+      m_callbackListener.SetCallbackArg(m_callbackarg);
+      
+      CacheHelper.SetupJavaServers(true, "cacheserver_notify_subscription5N.xml");
+      CacheHelper.StartJavaLocator(1, "GFELOC");
+      Util.Log("Locator started");
+      CacheHelper.StartJavaServerWithLocators(1, "GFECS1", 1);
+      Util.Log("Cacheserver 1 started.");
+
+      Util.Log("Creating region in client1, no-ack, cache-enabled, with listener and writer");
+      m_client1.Call(CreateRegion2, CacheHelper.Locators,
+        true, true, false);
+      m_client1.Call(RegisterAllKeys, new string[] { RegionName });
+      Util.Log("RegisterAllKeys completed..");
+
+      Util.Log("Creating region in client2 , no-ack, cache-enabled, with listener and writer");
+      m_client2.Call(CreateRegion2, CacheHelper.Locators,
+        true, false, false);
+      Util.Log("CreateRegion2 completed..");
+
+      m_client2.Call(TestPutAll);
+      Util.Log("TestPutAll completed..");
+      m_client1.Call(TestValidatePutAllCallback);
+      Util.Log("TestValidatePutAllCallback completed..");
+      m_client2.Call(TestGetAll);
+      Util.Log("TestGetAll completed..");
+
+      m_client1.Call(CacheHelper.Close);
+      m_client2.Call(CacheHelper.Close);
+
+      CacheHelper.StopJavaServer(1);
+      Util.Log("Cacheserver 1 stopped.");
+
+      CacheHelper.StopJavaLocator(1);
+      Util.Log("Locator stopped");
+
+      CacheHelper.ClearLocators();
+      CacheHelper.ClearEndpoints();
+    }
+
+    void runRemoveAllCallbackArgTest()
+    {
+
+      m_callbackListener = new CallbackListener();
+      m_callbackListener.SetCallbackArg(m_callbackarg);
+      CacheHelper.SetupJavaServers(true, "cacheserver_notify_subscription5N.xml");
+      CacheHelper.StartJavaLocator(1, "GFELOC");
+      Util.Log("Locator started");
+      CacheHelper.StartJavaServerWithLocators(1, "GFECS1", 1);
+      Util.Log("Cacheserver 1 started.");
+
+      Util.Log("Creating region in client1, no-ack, cache-enabled, with listener and writer");
+      m_client1.Call(CreateRegion2, CacheHelper.Locators,
+        true, true, false);
+      m_client1.Call(RegisterAllKeys, new string[] { RegionName });
+      Util.Log("RegisterAllKeys completed..");
+
+      Util.Log("Creating region in client2 , no-ack, cache-enabled, with listener and writer");
+      m_client2.Call(CreateRegion2,CacheHelper.Locators,
+        true, false, false);
+      Util.Log("CreateRegion2 completed..");
+
+      m_client2.Call(TestRemoveAll);
+      Util.Log("TestRemoveAll completed..");
+      m_client1.Call(TestValidateRemoveAllCallback);
+      Util.Log("TestValidateRemoveAllCallback completed..");
+
+      m_client1.Call(CacheHelper.Close);
+      m_client2.Call(CacheHelper.Close);
+
+      CacheHelper.StopJavaServer(1);
+      Util.Log("Cacheserver 1 stopped.");
+
+      CacheHelper.StopJavaLocator(1);
+      Util.Log("Locator stopped");
+
+      CacheHelper.ClearLocators();
+      CacheHelper.ClearEndpoints();
+    }
+
+    [TearDown]
+    public override void EndTest()
+    {
+      base.EndTest();
+    }
+
+    [Test]
+    public void ThinClientCallbackArgTest()
+    {
+      runCallbackArgTest();
+    }
+
+    [Test]
+    public void ThinClientCallbackArgTest2()
+    {
+      for (int i = 0; i < 2; i++)
+      {
+        runCallbackArgTest2(i);
+      }
+    }
+
+    [Test]
+    public void ThinClientCallbackArgTest3()
+    {
+      runCallbackArgTest3();
+    }
+
+    [Test]
+    public void RemoveAllCallbackArgTest()
+    {
+      runRemoveAllCallbackArgTest();
+    }
+
+    [Test]
+    public void PutAllCallbackArgTest()
+    {
+      runPutAllCallbackArgTest();
+    }
+  }
+}
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/geode/blob/2d4a7ecd/src/clicache/integration-test/ThinClientConflationTestsN.cs
----------------------------------------------------------------------
diff --git a/src/clicache/integration-test/ThinClientConflationTestsN.cs b/src/clicache/integration-test/ThinClientConflationTestsN.cs
new file mode 100644
index 0000000..bbe7e5a
--- /dev/null
+++ b/src/clicache/integration-test/ThinClientConflationTestsN.cs
@@ -0,0 +1,344 @@
+//=========================================================================
+// Copyright (c) 2002-2014 Pivotal Software, Inc. All Rights Reserved.
+// This product is protected by U.S. and international copyright
+// and intellectual property laws. Pivotal products are covered by
+// more patents listed at http://www.pivotal.io/patents.
+//========================================================================
+
+using System;
+using System.Collections.Generic;
+using System.Threading;
+
+namespace GemStone.GemFire.Cache.UnitTests.NewAPI
+{
+  using NUnit.Framework;
+  using GemStone.GemFire.DUnitFramework;
+  using GemStone.GemFire.Cache.Tests.NewAPI;
+  using GemStone.GemFire.Cache.Generic;
+
+  #region Listener
+  class ConflationListner<TKey, TValue> : ICacheListener<TKey, TValue>
+  {
+    #region Private members
+
+    private int m_events = 0;
+    private TValue m_value = default(TValue);
+    #endregion
+
+    public static ConflationListner<TKey, TValue> Create()
+    {
+      Util.Log(" ConflationListner Created");
+
+      return new ConflationListner<TKey, TValue>();
+    }
+
+    private void check(EntryEvent<TKey, TValue> ev)
+    {
+      m_events++;
+      TKey key = ev.Key;
+      TValue value = ev.NewValue;
+      m_value = value;
+      Util.Log("Region:{0}:: Key:{1}, Value:{2}", ev.Region.Name, key, value);
+
+    }
+
+    public void validate(bool conflation)
+    {
+      if (conflation)
+      {
+        string msg1 = string.Format("Conflation On: Expected 2 events but got {0}", m_events);
+        Assert.AreEqual(2, m_events, msg1);
+      }
+      else
+      {
+        string msg2 = string.Format("Conflation Off: Expected 5 events but got {0}", m_events);
+        Assert.AreEqual(5, m_events, msg2);
+      }
+
+      string msg3 = string.Format("Expected Value =5, Actual = {0}", m_value);
+      Assert.AreEqual(5, m_value, msg3);
+    }
+
+    #region ICacheListener Members
+
+    public virtual void AfterCreate(EntryEvent<TKey, TValue> ev)
+    {
+      check(ev);
+    }
+
+    public virtual void AfterUpdate(EntryEvent<TKey, TValue> ev)
+    {
+      check(ev);
+    }
+
+    public virtual void AfterDestroy(EntryEvent<TKey, TValue> ev) { }
+
+    public virtual void AfterInvalidate(EntryEvent<TKey, TValue> ev) { }
+
+    public virtual void AfterRegionDestroy(RegionEvent<TKey, TValue> ev) { }
+
+    public virtual void AfterRegionInvalidate(RegionEvent<TKey, TValue> ev) { }
+
+    public virtual void AfterRegionClear(RegionEvent<TKey, TValue> ev) { }
+
+    public virtual void AfterRegionLive(RegionEvent<TKey, TValue> ev)
+    {
+      Util.Log("DurableListener: Received AfterRegionLive event of region: {0}", ev.Region.Name);
+    }
+
+    public virtual void Close(IRegion<TKey, TValue> region) { }
+    public virtual void AfterRegionDisconnected(IRegion<TKey, TValue> region) { }
+
+    #endregion
+  }
+  #endregion
+
+  [TestFixture]
+  [Category("group1")]
+  [Category("unicast_only")]
+  [Category("generics")]
+  
+  public class ThinClientConflationTests : ThinClientRegionSteps
+  {
+    #region Private members
+
+    private UnitProcess m_client1, m_client2, m_feeder;
+    private string[] keys = { "Key-1", "Key-2", "Key-3", "Key-4", "Key-5" };
+
+    private static string[] DurableClientIds = { "DurableClientId1", "DurableClientId2" };
+
+    static string[] Regions = { "ConflatedRegion", "NonConflatedRegion" };
+
+    private static ConflationListner<object, object> m_listener1C1, m_listener2C1, m_listener1C2, m_listener2C2;
+
+    #endregion
+
+    protected override ClientBase[] GetClients()
+    {
+      m_client1 = new UnitProcess();
+      m_client2 = new UnitProcess();
+      m_feeder = new UnitProcess();
+      return new ClientBase[] { m_client1, m_client2, m_feeder };
+    }
+
+    [TearDown]
+    public override void EndTest()
+    {
+      try
+      {
+        m_client1.Call(CacheHelper.Close);
+        m_client2.Call(CacheHelper.Close);
+        m_feeder.Call(CacheHelper.Close);
+        CacheHelper.ClearEndpoints();
+      }
+      finally
+      {
+        CacheHelper.StopJavaServers();
+      }
+      base.EndTest();
+    }
+
+    #region Common Functions
+
+    public void InitFeeder(string locators, int redundancyLevel)
+    {
+      CacheHelper.CreatePool<object, object>("__TESTPOOL1_", locators, (string)null, redundancyLevel, false);
+      CacheHelper.CreateTCRegion_Pool<object, object>(Regions[0], false, false, null,
+        CacheHelper.Locators, "__TESTPOOL1_", false);
+      CacheHelper.CreateTCRegion_Pool<object, object>(Regions[1], false, false, null,
+        CacheHelper.Locators, "__TESTPOOL1_", false);
+    }
+
+    public void InitDurableClient(int client, string locators, string conflation)
+    {
+      // Create DurableListener for first time and use same afterward.
+      ConflationListner<object, object> checker1 = null;
+      ConflationListner<object, object> checker2 = null;
+      string durableId = ThinClientConflationTests.DurableClientIds[client - 1];
+      if (client == 1)
+      {
+        ThinClientConflationTests.m_listener1C1 = ConflationListner<object, object>.Create();
+        ThinClientConflationTests.m_listener2C1 = ConflationListner<object, object>.Create();
+        checker1 = ThinClientConflationTests.m_listener1C1;
+        checker2 = ThinClientConflationTests.m_listener2C1;
+      }
+      else // client == 2 
+      {
+        ThinClientConflationTests.m_listener1C2 = ConflationListner<object, object>.Create();
+        ThinClientConflationTests.m_listener2C2 = ConflationListner<object, object>.Create();
+        checker1 = ThinClientConflationTests.m_listener1C2;
+        checker2 = ThinClientConflationTests.m_listener2C2;
+      }
+      CacheHelper.InitConfigForConflation_Pool(locators, durableId, conflation);
+      CacheHelper.CreateTCRegion_Pool<object, object>(Regions[0], false, true, checker1,
+        CacheHelper.Locators, "__TESTPOOL1_", true);
+      CacheHelper.CreateTCRegion_Pool<object, object>(Regions[1], false, true, checker2,
+        CacheHelper.Locators, "__TESTPOOL1_", true);
+
+      //CacheHelper.DCache.ReadyForEvents();
+
+      IRegion<object, object> region1 = CacheHelper.GetVerifyRegion<object, object>(Regions[0]);
+      region1.GetSubscriptionService().RegisterAllKeys(true);
+      IRegion<object, object> region2 = CacheHelper.GetVerifyRegion<object, object>(Regions[1]);
+      region2.GetSubscriptionService().RegisterAllKeys(true);
+    }
+
+    public void ReadyForEvents()
+    {
+      CacheHelper.DCache.ReadyForEvents();
+    }
+
+    public void FeederUpdate(int keyIdx)
+    {
+      IRegion<object, object> region1 = CacheHelper.GetVerifyRegion<object, object>(Regions[0]);
+
+      
+      region1[keys[keyIdx]] = 1;
+      region1[keys[keyIdx]] = 2;
+      region1[keys[keyIdx]] = 3;
+      region1[keys[keyIdx]] = 4;
+      region1[keys[keyIdx]] = 5;
+
+      IRegion<object, object> region2 = CacheHelper.GetVerifyRegion<object, object>(Regions[1]);
+
+      region2[keys[keyIdx]] = 1;
+      region2[keys[keyIdx]] = 2;
+      region2[keys[keyIdx]] = 3;
+      region2[keys[keyIdx]] = 4;
+      region2[keys[keyIdx]] = 5;
+    }
+
+    public void ClientDown()
+    {
+      CacheHelper.Close();
+    }
+
+
+    public void KillServer()
+    {
+      CacheHelper.StopJavaServer(1);
+      Util.Log("Cacheserver 1 stopped.");
+    }
+
+    public delegate void KillServerDelegate();
+
+    #endregion
+
+
+    public void Validate(int client, int region, bool conflate)
+    {
+      ConflationListner<object, object> checker = null;
+      if (client == 1)
+      {
+        if (region == 1)
+          checker = ThinClientConflationTests.m_listener1C1;
+        else
+          checker = ThinClientConflationTests.m_listener2C1;
+      }
+      else // client == 2
+      {
+        if (region == 1)
+          checker = ThinClientConflationTests.m_listener1C2;
+        else
+          checker = ThinClientConflationTests.m_listener2C2;
+      }
+
+      if (checker != null)
+      {
+        checker.validate(conflate);
+      }
+      else
+      {
+        Assert.Fail("Checker is NULL!");
+      }
+    }
+
+    void runConflationBasic()
+    {
+      CacheHelper.SetupJavaServers(true, "cacheserver_conflation.xml");
+
+      CacheHelper.StartJavaLocator(1, "GFELOC");
+      Util.Log("Locator started");
+      CacheHelper.StartJavaServerWithLocators(1, "GFECS1", 1);
+      Util.Log("Cacheserver 1 started.");
+
+      m_feeder.Call(InitFeeder, CacheHelper.Locators, 0);
+      Util.Log("Feeder initialized.");
+
+      //Test "true" and "false" settings
+      m_client1.Call(InitDurableClient, 1, CacheHelper.Locators, "true");
+      m_client2.Call(InitDurableClient, 2, CacheHelper.Locators, "false");
+      Util.Log("Clients initialized for first time.");
+
+      m_feeder.Call(FeederUpdate, 0);
+      Util.Log("Feeder performed first update.");
+
+      Util.Log("Client1 sending readyForEvents().");
+      m_client1.Call(ReadyForEvents);
+      Thread.Sleep(5000);
+      Util.Log("Validating Client 1 Region 1.");
+      m_client1.Call(Validate, 1, 1, true);
+      Util.Log("Validating Client 1 Region 2.");
+      m_client1.Call(Validate, 1, 2, true);
+
+      Util.Log("Client2 sending readyForEvents().");
+      m_client2.Call(ReadyForEvents);
+      Thread.Sleep(5000);
+      Util.Log("Validating Client 2 Region 1.");
+      m_client2.Call(Validate, 2, 1, false);
+      Util.Log("Validating Client 2 Region 1.");
+      m_client2.Call(Validate, 2, 2, false);
+
+      //Close Clients.
+      m_client1.Call(ClientDown);
+      m_client2.Call(ClientDown);
+      Util.Log("First step complete, tested true/false options.");
+
+      //Test "server" and not set settings
+      m_client1.Call(InitDurableClient, 1, CacheHelper.Locators, "server");
+      m_client2.Call(InitDurableClient, 2, CacheHelper.Locators, "");
+      Util.Log("Clients initialized second times.");
+
+      m_feeder.Call(FeederUpdate, 1);
+      Util.Log("Feeder performed second update.");
+
+      Util.Log("Client1 sending readyForEvents().");
+      m_client1.Call(ReadyForEvents);
+      Thread.Sleep(5000);
+      Util.Log("Validating Client 1 Region 1.");
+      m_client1.Call(Validate, 1, 1, true);
+      Util.Log("Validating Client 1 Region 2.");
+      m_client1.Call(Validate, 1, 2, false);
+
+      Util.Log("Client2 sending readyForEvents().");
+      m_client2.Call(ReadyForEvents);
+      Thread.Sleep(5000);
+      Util.Log("Validating Client 2 Region 1.");
+      m_client2.Call(Validate, 2, 1, true);
+      Util.Log("Validating Client 2 Region 2.");
+      m_client2.Call(Validate, 2, 2, false);
+
+      //Close Clients.
+      m_client1.Call(ClientDown);
+      m_client2.Call(ClientDown);
+      m_feeder.Call(ClientDown);
+      Util.Log("Feeder and Clients closed.");
+
+      CacheHelper.StopJavaServer(1);
+      Util.Log("Cacheserver 1 stopped.");
+
+      CacheHelper.StopJavaLocator(1);
+      Util.Log("Locator stopped");
+
+      CacheHelper.ClearLocators();
+      CacheHelper.ClearEndpoints();
+    }
+
+    [Test]
+    public void ConflationBasic()
+    {
+      runConflationBasic();
+    }
+
+  }
+}

http://git-wip-us.apache.org/repos/asf/geode/blob/2d4a7ecd/src/clicache/integration-test/ThinClientCqIRTestsN.cs
----------------------------------------------------------------------
diff --git a/src/clicache/integration-test/ThinClientCqIRTestsN.cs b/src/clicache/integration-test/ThinClientCqIRTestsN.cs
new file mode 100644
index 0000000..0d1a783
--- /dev/null
+++ b/src/clicache/integration-test/ThinClientCqIRTestsN.cs
@@ -0,0 +1,240 @@
+//=========================================================================
+// Copyright (c) 2002-2014 Pivotal Software, Inc. All Rights Reserved.
+// This product is protected by U.S. and international copyright
+// and intellectual property laws. Pivotal products are covered by
+// more patents listed at http://www.pivotal.io/patents.
+//========================================================================
+
+using System;
+using System.Collections.Generic;
+using System.Threading;
+
+namespace GemStone.GemFire.Cache.UnitTests.NewAPI
+{
+  using NUnit.Framework;
+  using GemStone.GemFire.DUnitFramework;
+  using GemStone.GemFire.Cache.Tests.NewAPI;
+  using GemStone.GemFire.Cache.Generic;
+
+
+  [TestFixture]
+  [Category("group2")]
+  [Category("unicast_only")]
+  [Category("generics")]
+
+  public class ThinClientCqIRTests : ThinClientRegionSteps
+  {
+    #region Private members
+
+    private UnitProcess m_client1;
+    private UnitProcess m_client2;
+    private static string[] QueryRegionNames = { "Portfolios", "Positions", "Portfolios2",
+      "Portfolios3" };
+    private static string QERegionName = "Portfolios";
+    private static string CqName = "MyCq";
+
+    #endregion
+
+    protected override ClientBase[] GetClients()
+    {
+      m_client1 = new UnitProcess();
+      m_client2 = new UnitProcess();
+      return new ClientBase[] { m_client1, m_client2 };
+    }
+
+    [TestFixtureSetUp]
+    public override void InitTests()
+    {
+      base.InitTests();
+      m_client1.Call(InitClient);
+      m_client2.Call(InitClient);
+    }
+
+    [TearDown]
+    public override void EndTest()
+    {
+      CacheHelper.StopJavaServers();
+      base.EndTest();
+    }
+
+
+    public void InitClient()
+    {
+      CacheHelper.Init();
+      try
+      {
+        Serializable.RegisterTypeGeneric(Portfolio.CreateDeserializable);
+        Serializable.RegisterTypeGeneric(Position.CreateDeserializable);
+      }
+      catch (IllegalStateException)
+      {
+        // ignore since we run multiple iterations for pool and non pool configs
+      }
+    }
+    public void StepOne(string locators)
+    {
+      CacheHelper.CreateTCRegion_Pool<object, object>(QueryRegionNames[0], true, true,
+      null, locators, "__TESTPOOL1_", true);
+      CacheHelper.CreateTCRegion_Pool<object, object>(QueryRegionNames[1], true, true,
+        null, locators, "__TESTPOOL1_", true);
+      CacheHelper.CreateTCRegion_Pool<object, object>(QueryRegionNames[2], true, true,
+        null, locators, "__TESTPOOL1_", true);
+      CacheHelper.CreateTCRegion_Pool<object, object>(QueryRegionNames[3], true, true,
+        null, locators, "__TESTPOOL1_", true);
+
+      IRegion<object, object> region = CacheHelper.GetRegion<object, object>(QueryRegionNames[0]);
+      GemStone.GemFire.Cache.Generic.RegionAttributes<object, object> regattrs = region.Attributes;
+      region.CreateSubRegion(QueryRegionNames[1], regattrs);
+    }
+
+    public void StepTwo()
+    {
+      IRegion<object, object> region0 = CacheHelper.GetRegion<object, object>(QueryRegionNames[0]);
+      IRegion<object, object> subRegion0 = region0.GetSubRegion(QueryRegionNames[1]);
+      IRegion<object, object> region1 = CacheHelper.GetRegion<object, object>(QueryRegionNames[1]);
+      IRegion<object, object> region2 = CacheHelper.GetRegion<object, object>(QueryRegionNames[2]);
+      IRegion<object, object> region3 = CacheHelper.GetRegion<object, object>(QueryRegionNames[3]);
+
+      QueryHelper<object, object> qh = QueryHelper<object, object>.GetHelper();
+      Util.Log("SetSize {0}, NumSets {1}.", qh.PortfolioSetSize,
+        qh.PortfolioNumSets);
+
+      qh.PopulatePortfolioData(region0, qh.PortfolioSetSize,
+        qh.PortfolioNumSets);
+      qh.PopulatePositionData(subRegion0, qh.PortfolioSetSize,
+        qh.PortfolioNumSets);
+      qh.PopulatePositionData(region1, qh.PortfolioSetSize,
+        qh.PortfolioNumSets);
+      qh.PopulatePortfolioData(region2, qh.PortfolioSetSize,
+        qh.PortfolioNumSets);
+      qh.PopulatePortfolioData(region3, qh.PortfolioSetSize,
+        qh.PortfolioNumSets);
+    }
+
+    public void StepTwoQT()
+    {
+      IRegion<object, object> region0 = CacheHelper.GetRegion<object, object>(QueryRegionNames[0]);
+      IRegion<object, object> subRegion0 = region0.GetSubRegion(QueryRegionNames[1]);
+
+      QueryHelper<object, object> qh = QueryHelper<object, object>.GetHelper();
+
+      qh.PopulatePortfolioData(region0, 100, 20, 100);
+      qh.PopulatePositionData(subRegion0, 100, 20);
+    }
+
+    public void StepOneQE(string locators)
+    {
+      CacheHelper.CreateTCRegion_Pool<object, object>(QERegionName, true, true,
+        null, locators, "__TESTPOOL1_", true);
+
+      IRegion<object, object> region = CacheHelper.GetVerifyRegion<object, object>(QERegionName);
+      Portfolio p1 = new Portfolio(1, 100);
+      Portfolio p2 = new Portfolio(2, 100);
+      Portfolio p3 = new Portfolio(3, 100);
+      Portfolio p4 = new Portfolio(4, 100);
+
+      region["1"] = p1;
+      region["2"] = p2;
+      region["3"] = p3;
+      region["4"] = p4;
+
+      QueryService<object, object> qs = null;
+      qs = PoolManager/*<object, object>*/.Find("__TESTPOOL1_").GetQueryService<object, object>();
+      CqAttributesFactory<object, object> cqFac = new CqAttributesFactory<object, object>();
+      ICqListener<object, object> cqLstner = new MyCqListener<object, object>();
+      cqFac.AddCqListener(cqLstner);
+      CqAttributes<object, object> cqAttr = cqFac.Create();
+      CqQuery<object, object> qry = qs.NewCq(CqName, "select * from /" + QERegionName + "  p where p.ID!=2", cqAttr, false);
+      ICqResults<object> results = qry.ExecuteWithInitialResults();
+      Thread.Sleep(18000); // sleep 0.3min to allow server c query to complete
+      region["4"] = p1;
+      region["3"] = p2;
+      region["2"] = p3;
+      region["1"] = p4;
+      Thread.Sleep(18000); // sleep 0.3min to allow server c query to complete
+      Util.Log("Results size {0}.", results.Size);
+
+      SelectResultsIterator<object> iter = results.GetIterator();
+
+      while (iter.HasNext)
+      {
+        object item = iter.Next();
+        if (item != null)
+        {
+          Struct st = item as Struct;
+
+          string key = st["key"] as string;
+
+          Assert.IsNotNull(key, "key is null");
+
+          Portfolio port = st["value"] as Portfolio;
+
+          if (port == null)
+          {
+            Position pos = st["value"] as Position;
+            if (pos == null)
+            {
+              string cs = item as string;
+
+              if (cs == null)
+              {
+                Assert.Fail("value is null");
+                Util.Log("Query got other/unknown object.");
+              }
+              else
+              {
+                Util.Log("Query got string : {0}.", cs);
+              }
+            }
+            else
+            {
+              Util.Log("Query got Position object with secId {0}, shares {1}.", pos.SecId, pos.SharesOutstanding);
+            }
+          }
+          else
+          {
+            Util.Log("Query got Portfolio object with ID {0}, pkid {1}.", port.ID, port.Pkid);
+          }
+        }
+      }
+      qry = qs.GetCq(CqName);
+      qry.Stop();
+      qry.Close();
+      // Bring down the region
+      region.GetLocalView().DestroyRegion();
+    }
+
+    void runCqQueryIRTest()
+    {
+      CacheHelper.SetupJavaServers(true, "remotequeryN.xml");
+      CacheHelper.StartJavaLocator(1, "GFELOC");
+      Util.Log("Locator started");
+      CacheHelper.StartJavaServerWithLocators(1, "GFECS1", 1);
+      Util.Log("Cacheserver 1 started.");
+
+      m_client1.Call(StepOne, CacheHelper.Locators);
+      Util.Log("StepOne complete.");
+
+      m_client1.Call(StepTwo);
+      Util.Log("StepTwo complete.");
+
+      m_client1.Call(StepOneQE, CacheHelper.Locators);
+      Util.Log("StepOne complete.");
+
+      m_client1.Call(Close);
+
+      CacheHelper.StopJavaServer(1);
+      Util.Log("Cacheserver 1 stopped.");
+
+      CacheHelper.StopJavaLocator(1);
+      Util.Log("Locator stopped");
+    }
+
+    [Test]
+    public void CqQueryIRTest()
+    {
+      runCqQueryIRTest();
+    }
+
+  }
+}


Mime
View raw message