http://git-wip-us.apache.org/repos/asf/geode-native/blob/6cbd424f/clicache/integration-test/ThinClientHARegionTestsN.cs
----------------------------------------------------------------------
diff --git a/clicache/integration-test/ThinClientHARegionTestsN.cs 
b/clicache/integration-test/ThinClientHARegionTestsN.cs
new file mode 100644
index 0000000..5a00367
--- /dev/null
+++ b/clicache/integration-test/ThinClientHARegionTestsN.cs
@@ -0,0 +1,991 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Threading;
+
+namespace Apache.Geode.Client.UnitTests
+{
+  using NUnit.Framework;
+  using Apache.Geode.DUnitFramework;
+  using Apache.Geode.Client.Tests;
+  using Apache.Geode.Client;
+
+  using Region = Apache.Geode.Client.IRegion<Object, Object>;
+
+  [TestFixture]
+  [Category("group4")]
+  [Category("unicast_only")]
+  [Category("generics")]
+  public class ThinClientHARegionTests : ThinClientRegionSteps
+  {
+    #region Private members
+
+    private UnitProcess m_client1, m_client2, m_client3;
+    private string[] m_regexes = { "Key.*1", "Key.*2", "Key.*3", "Key.*4" };
+
+    private static string QueryRegionName = "Portfolios";
+
+    #endregion
+
+    protected override string ExtraPropertiesFile
+    {
+      get
+      {
+        return "geode.properties.mixed";
+      }
+    }
+
+    protected override ClientBase[] GetClients()
+    {
+      m_client1 = new UnitProcess();
+      m_client2 = new UnitProcess();
+      m_client3 = new UnitProcess();
+      return new ClientBase[] { m_client1, m_client2, m_client3 };
+    }
+
+    [TearDown]
+    public override void EndTest()
+    {
+      try
+      {
+        m_client1.Call(CacheHelper.Close);
+        m_client2.Call(CacheHelper.Close);
+        m_client3.Call(CacheHelper.Close);
+        CacheHelper.ClearEndpoints();
+      }
+      finally
+      {
+        CacheHelper.StopJavaServers();
+      }
+      base.EndTest();
+    }
+
+    #region Various steps for HA tests
+
+    public void InitClient_Pool(string locators, int redundancyLevel)
+    {
+      CacheHelper.CreatePool<object, object>("__TESTPOOL1_", locators, null, 
redundancyLevel, true);
+    }
+
+    public void InitClientForEventId_Pool(string locators, bool notification,
+      int redundancyLevel, int ackInterval, int dupCheckLife)
+    {
+      CacheHelper.Init();
+      CacheHelper.CreatePool<object, object>("__TESTPOOL1_", locators, null,
+        redundancyLevel, notification, ackInterval, dupCheckLife);
+    }
+
+    public void InitClientXml(string cacheXml)
+    {
+      CacheHelper.InitConfig(cacheXml);
+    }
+
+    public void InitClientXml(string cacheXml, int serverport1, int 
serverport2)
+    {
+      CacheHelper.HOST_PORT_1 = serverport1;
+      CacheHelper.HOST_PORT_2 = serverport2;
+      CacheHelper.InitConfig(cacheXml);
+    }
+
+    public void CreateEntriesForEventId(int sleep)
+    {
+      IRegion<object, object> region1 = CacheHelper.GetVerifyRegion<object, 
object>(m_regionNames[0]);
+      IRegion<object, object> region2 = CacheHelper.GetVerifyRegion<object, 
object>(m_regionNames[1]);
+
+      for (int value = 1; value <= 100; value++)
+      {
+        region1[m_keys[0]] = value;
+        Thread.Sleep(sleep);
+        region1[m_keys[1]] = value;
+        Thread.Sleep(sleep);
+        region1[m_keys[2]] = value;
+        Thread.Sleep(sleep);
+        region1[m_keys[3]] = value;
+        Thread.Sleep(sleep);
+        region2[m_keys[0]] = value;
+        Thread.Sleep(sleep);
+        region2[m_keys[1]] = value;
+        Thread.Sleep(sleep);
+        region2[m_keys[2]] = value;
+        Thread.Sleep(sleep);
+        region2[m_keys[3]] = value;
+        Thread.Sleep(sleep);
+      }
+    }
+
+    public void CheckClientForEventId()
+    {
+      IRegion<object, object> region1 = CacheHelper.GetVerifyRegion<object, 
object>(m_regionNames[0]);
+      IRegion<object, object> region2 = CacheHelper.GetVerifyRegion<object, 
object>(m_regionNames[1]);
+
+      DupListener<object, object> checker1 = region1.Attributes.CacheListener 
as DupListener<object, object>;
+      DupListener<object, object> checker2 = region2.Attributes.CacheListener 
as DupListener<object, object>;
+
+      Util.Log("Validating checker1 cachelistener");
+      checker1.validate();
+      Util.Log("Validating checker2 cachelistener");
+      checker2.validate();
+    }
+
+    public void InitDupListeners()
+    {
+      IRegion<object, object> region1 = CacheHelper.GetVerifyRegion<object, 
object>(m_regionNames[0]);
+      IRegion<object, object> region2 = CacheHelper.GetVerifyRegion<object, 
object>(m_regionNames[1]);
+
+      region1.AttributesMutator.SetCacheListener(DupListener<object, 
object>.Create());
+      region2.AttributesMutator.SetCacheListener(DupListener<object, 
object>.Create());
+
+      Thread.Sleep(5000);
+
+      region1.GetSubscriptionService().RegisterAllKeys();
+      region2.GetSubscriptionService().RegisterAllKeys();
+    }
+
+    public void CreateHATCRegions(string[] regionNames, bool useList,
+      string locators, bool clientNotification, bool create)
+    {
+      if (create)
+      {
+        CacheHelper.CreateTCRegion_Pool<object, object>(regionNames[0], true, 
true,
+          null, locators, "__TESTPOOL1_", clientNotification);
+        CacheHelper.CreateTCRegion_Pool<object, object>(regionNames[1], false, 
true,
+          null, locators, "__TESTPOOL1_", clientNotification);
+      }
+      m_regionNames = regionNames;
+    }
+
+    /*
+    public void CreateCPPRegion(string regionName)
+    {
+      CacheHelper.CreateTCRegion(regionName, true, true,
+        null, "none", false);
+    }
+     * */
+
+    public void CreateMixedEntry(string regionName, string key, string val)
+    {
+      CreateEntry(regionName, key, val);
+    }
+
+    public void DoNetsearchMixed(string regionName, string key, string val, 
bool checkNoKey)
+    {
+      DoNetsearch(regionName, key, val, checkNoKey);
+    }
+
+    public void UpdateEntryMixed(string regionName, string key, string val, 
bool checkVal)
+    {
+      UpdateEntry(regionName, key, val, checkVal);
+    }
+
+    public void LocalDestroyEntry(string regionName, string key)
+    {
+      Util.Log("Locally Destroying entry -- key: {0}  in region {1}",
+        key, regionName);
+
+      // Destroy entry, verify entry is destroyed
+      Region region = CacheHelper.GetVerifyRegion<object, object>(regionName);
+      Assert.IsTrue(region.ContainsKey(key), "Key should have been found in 
region.");
+      region.GetLocalView().Remove(key);
+      VerifyDestroyed(regionName, key);
+    }
+
+    public void Create2Vals(bool even)
+    {
+      if (even)
+      {
+        CreateEntry(m_regionNames[0], m_keys[0], m_vals[0]);
+        CreateEntry(m_regionNames[1], m_keys[2], m_vals[2]);
+      }
+      else
+      {
+        CreateEntry(m_regionNames[0], m_keys[1], m_vals[1]);
+        CreateEntry(m_regionNames[1], m_keys[3], m_vals[3]);
+      }
+    }
+
+    public void CreateVals()
+    {
+      Create2Vals(true);
+      Create2Vals(false);
+    }
+
+    public void VerifyValCreations(bool even)
+    {
+      if (even)
+      {
+        VerifyCreated(m_regionNames[0], m_keys[0]);
+        VerifyCreated(m_regionNames[1], m_keys[2]);
+      }
+      else
+      {
+        VerifyCreated(m_regionNames[0], m_keys[1]);
+        VerifyCreated(m_regionNames[1], m_keys[3]);
+      }
+    }
+
+    public void VerifyTallies()
+    {
+      IRegion<object, object> region1 = CacheHelper.GetVerifyRegion<object, 
object>(m_regionNames[0]);
+      IRegion<object, object> region2 = CacheHelper.GetVerifyRegion<object, 
object>(m_regionNames[1]);
+
+      TallyLoader<object, object> loader1 = (TallyLoader<object, 
object>)region1.Attributes.CacheLoader;
+      TallyListener<object, object> listener1 = (TallyListener<object, 
object>) region1.Attributes.CacheListener;
+      TallyWriter<object, object> writer1 = (TallyWriter<object, 
object>)region1.Attributes.CacheWriter;
+      TallyResolver<object, object> resolver1 = (TallyResolver<object, 
object>) region1.Attributes.PartitionResolver;
+
+      TallyLoader<object, object> loader2 = (TallyLoader<object, 
object>)region2.Attributes.CacheLoader;
+      TallyListener<object, object> listener2 = (TallyListener<object, 
object>)region2.Attributes.CacheListener;
+      TallyWriter<object, object> writer2 = (TallyWriter<object, 
object>)region2.Attributes.CacheWriter;
+      TallyResolver<object, object> resolver2 = (TallyResolver<object, 
object>)region2.Attributes.PartitionResolver;
+
+      loader1.ShowTallies();
+      writer1.ShowTallies();
+      listener1.ShowTallies();
+      resolver1.ShowTallies();
+
+      loader2.ShowTallies();
+      writer2.ShowTallies();
+      listener2.ShowTallies();
+      resolver2.ShowTallies();
+
+      // We don't assert for partition resolver because client metadata 
service may
+      // not have fetched PR single hop info to trigger the resolver.
+
+      Assert.AreEqual(1, loader1.ExpectLoads(1));
+      //Assert.AreEqual(1, resolver1.ExpectLoads(1));
+      Assert.AreEqual(1, writer1.ExpectCreates(1));
+      Assert.AreEqual(0, writer1.ExpectUpdates(0));
+      Assert.AreEqual(2, listener1.ExpectCreates(2));
+      Assert.AreEqual(1, listener1.ExpectUpdates(1));
+
+      Assert.AreEqual(1, loader2.ExpectLoads(1));
+      //Assert.AreEqual(1, resolver2.ExpectLoads(1));
+      Assert.AreEqual(1, writer2.ExpectCreates(1));
+      Assert.AreEqual(0, writer2.ExpectUpdates(0));
+      Assert.AreEqual(2, listener2.ExpectCreates(2));
+      Assert.AreEqual(1, listener2.ExpectUpdates(1));
+    }
+
+    public void UpdateVals()
+    {
+      UpdateEntry(m_regionNames[0], m_keys[0], m_vals[0], true);
+      UpdateEntry(m_regionNames[0], m_keys[1], m_vals[1], true);
+      UpdateEntry(m_regionNames[1], m_keys[2], m_vals[2], true);
+      UpdateEntry(m_regionNames[1], m_keys[3], m_vals[3], true);
+    }
+
+    public void Update2NVals(bool even, bool checkVal)
+    {
+      if (even)
+      {
+        UpdateEntry(m_regionNames[0], m_keys[0], m_nvals[0], checkVal);
+        UpdateEntry(m_regionNames[1], m_keys[2], m_nvals[2], checkVal);
+      }
+      else
+      {
+        UpdateEntry(m_regionNames[0], m_keys[1], m_nvals[1], checkVal);
+        UpdateEntry(m_regionNames[1], m_keys[3], m_nvals[3], checkVal);
+      }
+    }
+
+    public void UpdateNVals(bool checkVal)
+    {
+      Update2NVals(true, checkVal);
+      Update2NVals(false, checkVal);
+    }
+
+    public void Verify2Vals(bool even)
+    {
+      if (even)
+      {
+        VerifyEntry(m_regionNames[0], m_keys[0], m_vals[0]);
+        VerifyEntry(m_regionNames[1], m_keys[2], m_vals[2]);
+      }
+      else
+      {
+        VerifyEntry(m_regionNames[0], m_keys[1], m_vals[1]);
+        VerifyEntry(m_regionNames[1], m_keys[3], m_vals[3]);
+      }
+    }
+
+    public void VerifyVals()
+    {
+      Verify2Vals(true);
+      Verify2Vals(false);
+    }
+
+    public void Verify2NVals(bool even)
+    {
+      if (even)
+      {
+        VerifyEntry(m_regionNames[0], m_keys[0], m_nvals[0]);
+        VerifyEntry(m_regionNames[1], m_keys[2], m_nvals[2]);
+      }
+      else
+      {
+        VerifyEntry(m_regionNames[0], m_keys[1], m_nvals[1]);
+        VerifyEntry(m_regionNames[1], m_keys[3], m_nvals[3]);
+      }
+    }
+
+    public void DoNetsearch2Vals(bool even)
+    {
+      if (even)
+      {
+        DoNetsearch(m_regionNames[0], m_keys[0], m_vals[0], true);
+        DoNetsearch(m_regionNames[1], m_keys[2], m_vals[2], true);
+      }
+      else
+      {
+        DoNetsearch(m_regionNames[0], m_keys[1], m_vals[1], true);
+        DoNetsearch(m_regionNames[1], m_keys[3], m_vals[3], true);
+      }
+    }
+
+    public void DoCacheLoad2Vals(bool even)
+    {
+      if (even)
+      {
+        DoCacheLoad(m_regionNames[0], m_keys[0], m_vals[0], true);
+        DoCacheLoad(m_regionNames[1], m_keys[2], m_vals[2], true);
+      }
+      else
+      {
+        DoCacheLoad(m_regionNames[0], m_keys[1], m_vals[1], true);
+        DoCacheLoad(m_regionNames[1], m_keys[3], m_vals[3], true);
+      }
+    }
+
+    public void DoNetsearchVals()
+    {
+      DoNetsearch2Vals(true);
+      DoNetsearch2Vals(false);
+    }
+
+    public void VerifyNVals()
+    {
+      Verify2NVals(true);
+      Verify2NVals(false);
+    }
+
+    public void VerifyNValsVals()
+    {
+      VerifyEntry(m_regionNames[0], m_keys[0], m_nvals[0], true);
+      VerifyEntry(m_regionNames[0], m_keys[1], m_vals[1], true);
+      VerifyEntry(m_regionNames[1], m_keys[2], m_nvals[2], true);
+      VerifyEntry(m_regionNames[1], m_keys[3], m_vals[3], true);
+    }
+
+    public void VerifyNValVals()
+    {
+      VerifyEntry(m_regionNames[0], m_keys[0], m_nvals[0], true);
+      VerifyEntry(m_regionNames[0], m_keys[1], m_vals[1], true);
+      VerifyEntry(m_regionNames[1], m_keys[2], m_vals[2], true);
+      VerifyEntry(m_regionNames[1], m_keys[3], m_vals[3], true);
+    }
+
+    public void VerifyValsNVals()
+    {
+      VerifyEntry(m_regionNames[0], m_keys[0], m_vals[0], true);
+      VerifyEntry(m_regionNames[0], m_keys[1], m_nvals[1], true);
+      VerifyEntry(m_regionNames[1], m_keys[2], m_vals[2], true);
+      VerifyEntry(m_regionNames[1], m_keys[3], m_nvals[3], true);
+    }
+
+    public void VerifyMixedNVals()
+    {
+      VerifyEntry(m_regionNames[0], m_keys[0], m_nvals[0], true);
+      VerifyEntry(m_regionNames[0], m_keys[1], m_vals[1], true);
+      VerifyEntry(m_regionNames[1], m_keys[2], m_vals[2], true);
+      VerifyEntry(m_regionNames[1], m_keys[3], m_nvals[3], true);
+    }
+
+    public void RegisterKeysException(string key0, string key1)
+    {
+      Region region0 = CacheHelper.GetVerifyRegion<object, 
object>(m_regionNames[0]);
+      Region region1 = CacheHelper.GetVerifyRegion<object, 
object>(m_regionNames[1]);
+      if (key0 != null)
+      {
+          region0.GetSubscriptionService().RegisterKeys(new string[] {key0 });
+      }
+      if (key1 != null)
+      {
+          region1.GetSubscriptionService().RegisterKeys(new string[] {key1 });
+      }
+    }
+
+    public void RegisterRegexesException(string regex0, string regex1)
+    {
+      if (regex0 != null)
+      {
+        Region region0 = CacheHelper.GetVerifyRegion<object, 
object>(m_regionNames[0]);
+          region0.GetSubscriptionService().RegisterRegex(regex0);
+      }
+      if (regex1 != null)
+      {
+        Region region1 = CacheHelper.GetVerifyRegion<object, 
object>(m_regionNames[1]);
+          region1.GetSubscriptionService().RegisterRegex(regex1);
+      }
+    }
+
+    public void DistOpsCommonSteps(bool clientNotification)
+    {
+      DistOpsCommonSteps(clientNotification, true);
+    }
+
+    public void DistOpsCommonSteps(bool clientNotification, bool createRegions)
+    {
+      m_client1.Call(CreateHATCRegions, RegionNames, false,
+        (string)null, clientNotification, createRegions);
+      m_client1.Call(Create2Vals, true);
+      Util.Log("StepOne complete.");
+
+      m_client2.Call(CreateHATCRegions, RegionNames, false,
+       CacheHelper.Locators, !clientNotification, createRegions);
+      m_client2.Call(Create2Vals, false);
+      Util.Log("StepTwo complete.");
+
+      m_client1.Call(DoNetsearch2Vals, false);
+      m_client1.Call(RegisterKeys, m_keys[1], m_keys[3]);
+      Util.Log("StepThree complete.");
+
+      m_client2.Call(CheckServerKeys);
+      m_client2.Call(DoNetsearch2Vals, true);
+      m_client2.Call(RegisterKeys, m_keys[0], m_keys[2]);
+      Util.Log("StepFour complete.");
+
+      m_client1.Call(Update2NVals, true, true);
+      Util.Log("StepFive complete.");
+
+      m_client2.Call(Verify2NVals, true);
+      m_client2.Call(Update2NVals, false, true);
+      Util.Log("StepSix complete.");
+
+      m_client1.Call(Verify2NVals, false);
+      Util.Log("StepSeven complete.");
+    }
+
+    public void FailoverCommonSteps(int redundancyLevel, bool useRegexes)
+    {
+      CacheHelper.SetupJavaServers(true,
+        "cacheserver_notify_subscription.xml",
+        "cacheserver_notify_subscription2.xml",
+        "cacheserver_notify_subscription3.xml");
+
+      CacheHelper.StartJavaLocator(1, "GFELOC");
+      Util.Log("Locator started");
+
+      CacheHelper.StartJavaServerWithLocators(1, "GFECS1", 1);
+      Util.Log("Cacheserver 1 started.");
+
+      m_client1.Call(InitClient_Pool, CacheHelper.Locators, redundancyLevel);
+      m_client1.Call(CreateHATCRegions, RegionNames, false,
+        (string)null, useRegexes, true);
+      Util.Log("StepOne complete.");
+
+      m_client2.Call(InitClient_Pool, CacheHelper.Locators, redundancyLevel);
+      m_client2.Call(CreateHATCRegions, RegionNames, false,
+        (string)null, !useRegexes, true);
+      Util.Log("StepTwo complete.");
+
+      CacheHelper.StartJavaServerWithLocators(2, "GFECS2", 1);
+      Util.Log("Cacheserver 2 started.");
+
+      if (redundancyLevel > 1)
+      {
+        if (useRegexes)
+        {
+          m_client2.Call(RegisterRegexesException, m_regexes[0], m_regexes[2]);
+        }
+        else
+        {
+          m_client2.Call(RegisterKeysException, m_keys[0], m_keys[2]);
+        }
+      }
+      else
+      {
+        if (useRegexes)
+        {
+          m_client2.Call(RegisterRegexes, m_regexes[0], m_regexes[2]);
+        }
+        else
+        {
+          m_client2.Call(RegisterKeys, m_keys[0], m_keys[2]);
+        }
+      }
+      Util.Log("RegisterKeys done.");
+
+      m_client1.Call(CreateVals);
+      Util.Log("StepThree complete.");
+
+      m_client2.Call(VerifyValCreations, true);
+      m_client2.Call(Verify2Vals, true);
+      m_client2.Call(DoNetsearch2Vals, false);
+      Util.Log("StepFour complete.");
+
+      CacheHelper.StopJavaServer(1);
+      Util.Log("Cacheserver 1 stopped.");
+      //For Failover to complete.
+      Thread.Sleep(5000);
+
+      m_client1.Call(CheckServerKeys);
+      m_client1.Call(UpdateNVals, true);
+      Thread.Sleep(1000);
+      Util.Log("StepFive complete.");
+
+      m_client2.Call(VerifyNValsVals);
+      Util.Log("StepSix complete.");
+
+      CacheHelper.StartJavaServerWithLocators(1, "GFECS1", 1);
+      Util.Log("Cacheserver 1 started.");
+
+      CacheHelper.StopJavaServer(2);
+      Util.Log("Cacheserver 2 stopped.");
+
+      //For Failover to complete.
+      Thread.Sleep(5000);
+
+      CacheHelper.StartJavaServerWithLocators(3, "GFECS3", 1);
+      Util.Log("Cacheserver 3 started.");
+
+      m_client1.Call(UpdateVals);
+      Thread.Sleep(1000);
+      Util.Log("StepSeven complete.");
+
+      m_client2.Call(VerifyVals);
+      if (useRegexes)
+      {
+        m_client2.Call(UnregisterRegexes, (string)null, m_regexes[2]);
+      }
+      else
+      {
+        m_client2.Call(UnregisterKeys, (string)null, m_keys[2]);
+      }
+      Util.Log("StepEight complete.");
+
+      CacheHelper.StartJavaServerWithLocators(2, "GFECS2", 1);
+      Util.Log("Cacheserver 2 started.");
+
+      CacheHelper.StopJavaServer(3);
+      Util.Log("Cacheserver 3 stopped.");
+
+      m_client1.Call(UpdateNVals, true);
+      Thread.Sleep(1000);
+      Util.Log("StepNine complete.");
+
+      m_client2.Call(VerifyNValVals);
+      Util.Log("StepTen complete.");
+
+      CacheHelper.StopJavaServer(1);
+      Util.Log("Cacheserver 1 stopped.");
+
+      //For Failover to complete.
+      Thread.Sleep(5000);
+
+      m_client1.Call(UpdateVals);
+      Thread.Sleep(1000);
+      Util.Log("StepEleven complete.");
+
+      m_client2.Call(VerifyVals);
+      Util.Log("StepTwelve complete.");
+
+      m_client1.Call(Close);
+      m_client2.Call(Close);
+
+      CacheHelper.StopJavaServer(2);
+      Util.Log("Cacheserver 2 stopped.");
+
+      CacheHelper.StopJavaLocator(1);
+      Util.Log("Locator stopped");
+
+      CacheHelper.ClearEndpoints();
+      CacheHelper.ClearLocators();
+    }
+
+    public void KillServer()
+    {
+      CacheHelper.StopJavaServer(1);
+      Util.Log("Cacheserver 1 stopped.");
+    }
+
+    public delegate void KillServerDelegate();
+
+    public void StepOneFailover()
+    {
+      // This is here so that Client1 registers information of the cacheserver
+      // that has been already started
+      CacheHelper.SetupJavaServers(true,
+        "cacheserver_remoteoqlN.xml",
+        "cacheserver_remoteoql2N.xml");
+      CacheHelper.StartJavaLocator(1, "GFELOC");
+      Util.Log("Locator started");
+      //CacheHelper.StartJavaServer(1, "GFECS1");
+      CacheHelper.StartJavaServerWithLocators(1, "GFECS1", 1);
+      Util.Log("Cacheserver 1 started.");
+
+      try
+      {
+        Serializable.RegisterTypeGeneric(Portfolio.CreateDeserializable, 
CacheHelper.DCache);
+        Serializable.RegisterTypeGeneric(Position.CreateDeserializable, 
CacheHelper.DCache);
+      }
+      catch (IllegalStateException)
+      {
+        // ignored since we run multiple iterations for pool and non pool 
configs
+      }
+
+      InitClient_Pool(CacheHelper.Locators, 1);
+      CacheHelper.CreateTCRegion_Pool<object, object>(QueryRegionName, true, 
true,
+          null, null, "__TESTPOOL1_", true);
+
+      Region region = CacheHelper.GetVerifyRegion<object, 
object>(QueryRegionName);
+      Portfolio port1 = new Portfolio(1, 100);
+      Portfolio port2 = new Portfolio(2, 200);
+      Portfolio port3 = new Portfolio(3, 300);
+      Portfolio port4 = new Portfolio(4, 400);
+
+      region["1"] = port1;
+      region["2"] = port2;
+      region["3"] = port3;
+      region["4"] = port4;
+    }
+
+    public void StepTwoFailover()
+    {
+      CacheHelper.StartJavaServerWithLocators(2, "GFECS2", 1);
+      Util.Log("Cacheserver 2 started.");
+
+      IAsyncResult killRes = null;
+      KillServerDelegate ksd = new KillServerDelegate(KillServer);
+
+      QueryService<object, object> qs = null;
+      qs = 
CacheHelper.DCache.GetPoolManager().Find("__TESTPOOL1_").GetQueryService<object,
 object>();
+
+      for (int i = 0; i < 10000; i++)
+      {
+        Query<object> qry = qs.NewQuery("select distinct * from /" + 
QueryRegionName);
+
+        ISelectResults<object> results = qry.Execute();
+
+        if (i == 10)
+        {
+          Util.Log("Starting the kill server thread.");
+          killRes = ksd.BeginInvoke(null, null);
+        }
+
+        Int32 resultSize = results.Size;
+
+        if (i % 100 == 0)
+        {
+          Util.Log("Iteration upto {0} done, result size is {1}", i, 
resultSize);
+        }
+
+        Assert.AreEqual(4, resultSize, "Result size is not 4!");
+      }
+
+      killRes.AsyncWaitHandle.WaitOne();
+      ksd.EndInvoke(killRes);
+    }
+
+    #endregion
+
+    void runDistOps()
+    {
+      CacheHelper.SetupJavaServers(true, "cacheserver_notify_subscription.xml",
+        "cacheserver_notify_subscription2.xml");
+
+      CacheHelper.StartJavaLocator(1, "GFELOC");
+
+      CacheHelper.StartJavaServerWithLocators(1, "GFECS1", 1);
+      Util.Log("Cacheserver 1 started.");
+
+      CacheHelper.StartJavaServerWithLocators(2, "GFECS2", 1);
+      Util.Log("Cacheserver 2 started.");
+
+      m_client1.Call(InitClient_Pool, CacheHelper.Locators, 1);
+      m_client2.Call(InitClient_Pool, CacheHelper.Locators, 1);
+      m_client1.Call(CreateNonExistentRegion, CacheHelper.Locators);
+
+      DistOpsCommonSteps(true);
+
+      m_client1.Call(Close);
+      m_client2.Call(Close);
+
+      CacheHelper.StopJavaServer(1);
+      Util.Log("Cacheserver 1 stopped.");
+
+      CacheHelper.StopJavaServer(2);
+      Util.Log("Cacheserver 2 stopped.");
+
+      CacheHelper.StopJavaLocator(1);
+      Util.Log("Locator 1 stopped.");
+    }
+
+    void runDistOpsXml()
+    {
+ 
+      CacheHelper.SetupJavaServers(true, "cacheserver_notify_subscription.xml",
+        "cacheserver_notify_subscription2.xml");
+
+      CacheHelper.StartJavaLocator(1, "GFELOC");
+
+      CacheHelper.StartJavaServerWithLocators(1, "GFECS1", 1);
+      Util.Log("Cacheserver 1 started.");
+
+      CacheHelper.StartJavaServerWithLocators(2, "GFECS2", 1);
+      Util.Log("Cacheserver 2 started.");
+
+      m_client1.Call(InitClientXml, "client_pool.xml", 
CacheHelper.HOST_PORT_1, CacheHelper.HOST_PORT_2);
+      m_client2.Call(InitClientXml, "client_pool.xml", 
CacheHelper.HOST_PORT_1, CacheHelper.HOST_PORT_2);
+
+      DistOpsCommonSteps(false);
+
+      m_client1.Call(Close);
+      m_client2.Call(Close);
+
+      CacheHelper.StopJavaServer(1);
+      Util.Log("Cacheserver 1 stopped.");
+
+      CacheHelper.StopJavaServer(2);
+      Util.Log("Cacheserver 2 stopped.");
+
+      CacheHelper.StopJavaLocator(1);
+    }
+
+    void runGenericsXmlPlugins()
+    {
+      Util.Log("runGenericsXmlPlugins: pool with endpoints in client XML.");
+
+      CacheHelper.SetupJavaServers(false, "cacheserver1_partitioned.xml",
+        "cacheserver2_partitioned.xml");
+
+      CacheHelper.StartJavaServer(1, "GFECS1");
+      Util.Log("Cacheserver 1 started.");
+
+      CacheHelper.StartJavaServer(2, "GFECS2");
+      Util.Log("Cacheserver 2 started.");
+
+      m_client1.Call(InitClientXml, "client_pool.xml", 
CacheHelper.HOST_PORT_1, CacheHelper.HOST_PORT_2);
+      m_client2.Call(InitClientXml, "client_generics_plugins.xml", 
CacheHelper.HOST_PORT_1, CacheHelper.HOST_PORT_2);
+
+      m_client1.Call(CreateHATCRegions, RegionNames, false,
+        (string)null, false, false);
+      m_client2.Call(CreateHATCRegions, RegionNames, false,
+        (string)null, false, false);
+      Util.Log("StepOne complete.");
+
+      m_client2.Call(RegisterKeys, m_keys[0], m_keys[2]);
+
+      m_client1.Call(Create2Vals, true);     
+      
+      m_client2.Call(DoCacheLoad2Vals, false);
+
+      m_client1.Call(Update2NVals, true, true);
+
+      m_client2.Call(Create2Vals, false);
+
+      m_client2.Call(VerifyTallies);
+
+      m_client1.Call(Close);
+      m_client2.Call(Close);
+
+      CacheHelper.StopJavaServer(1);
+      Util.Log("Cacheserver 1 stopped.");
+
+      CacheHelper.StopJavaServer(2);
+      Util.Log("Cacheserver 2 stopped.");
+    }
+
+    void runQueryFailover()
+    {
+      try
+      {
+        m_client1.Call(StepOneFailover);
+        Util.Log("StepOneFailover complete.");
+
+        m_client1.Call(StepTwoFailover);
+        Util.Log("StepTwoFailover complete.");
+
+        m_client1.Call(Close);
+        Util.Log("Client closed");
+      }
+      finally
+      {
+        m_client1.Call(CacheHelper.StopJavaServers);
+        m_client1.Call(CacheHelper.StopJavaLocator, 1);
+        Util.Log("Locator stopped");
+      }
+    }
+
+    void runPeriodicAck()
+    {
+      CacheHelper.SetupJavaServers(true,
+        "cacheserver_notify_subscription.xml",
+        "cacheserver_notify_subscription2.xml");
+
+      CacheHelper.StartJavaLocator(1, "GFELOC");
+      Util.Log("Locator started");
+
+      CacheHelper.StartJavaServerWithLocators(1, "GFECS1", 1);
+      Util.Log("Cacheserver 1 started.");
+
+      CacheHelper.StartJavaServerWithLocators(2, "GFECS2", 1);
+      Util.Log("Cacheserver 2 started.");
+
+      m_client1.Call(InitClientForEventId_Pool, CacheHelper.Locators, false, 
1, 10, 30);
+
+      m_client1.Call(CreateHATCRegions, RegionNames, false,
+        (string)null, false, true);
+      Util.Log("StepOne complete.");
+
+      m_client2.Call(InitClientForEventId_Pool, CacheHelper.Locators, true, 1, 
10, 30);
+      m_client2.Call(CreateHATCRegions, RegionNames, false,
+        (string)null, true, true);
+      m_client2.Call(InitDupListeners);
+      Util.Log("StepTwo complete.");
+
+      m_client1.Call(CreateEntriesForEventId, 50);
+      Util.Log("CreateEntries complete.");
+
+      Thread.Sleep(30000);
+
+      m_client2.Call(CheckClientForEventId);
+      Util.Log("CheckClient complete.");
+
+      m_client1.Call(Close);
+      m_client2.Call(Close);
+
+      CacheHelper.StopJavaServer(1);
+      Util.Log("Cacheserver 1 stopped.");
+
+      CacheHelper.StopJavaServer(2);
+      Util.Log("Cacheserver 2 stopped.");
+
+      CacheHelper.StopJavaLocator(1);
+      Util.Log("Locator stopped");
+    }
+
+    void runEventIDMap()
+    {
+      CacheHelper.SetupJavaServers(true,
+        "cacheserver_notify_subscription.xml",
+        "cacheserver_notify_subscription2.xml");
+
+      CacheHelper.StartJavaLocator(1, "GFELOC");
+      Util.Log("Locator started");
+
+      CacheHelper.StartJavaServerWithLocators(1, "GFECS1", 1);
+      Util.Log("Cacheserver 1 started.");
+
+      m_client1.Call(InitClientForEventId_Pool, CacheHelper.Locators, false, 
1, 3600, 3600);
+      m_client1.Call(CreateHATCRegions, RegionNames, false,
+       (string)null, false, true);
+      Util.Log("StepOne complete.");
+
+      m_client2.Call(InitClientForEventId_Pool, CacheHelper.Locators, true, 1, 
3600, 3600);
+      m_client2.Call(CreateHATCRegions, RegionNames, false,
+        (string)null, true, true);
+      m_client2.Call(InitDupListeners);
+      Util.Log("StepTwo complete.");
+
+      CacheHelper.StartJavaServerWithLocators(2, "GFECS2", 1);
+      Util.Log("Cacheserver 2 started.");
+
+      m_client1.Call(CreateEntriesForEventId, 10);
+      Util.Log("CreateEntries complete.");
+
+      CacheHelper.StopJavaServer(1);
+      Util.Log("Cacheserver 1 stopped.");
+
+      Thread.Sleep(30000);
+
+      m_client2.Call(CheckClientForEventId);
+      Util.Log("CheckClient complete.");
+
+      m_client1.Call(Close);
+      m_client2.Call(Close);
+
+      CacheHelper.StopJavaServer(2);
+      Util.Log("Cacheserver 2 stopped.");
+
+      CacheHelper.StopJavaLocator(1);
+      Util.Log("Locator stopped");
+    }
+
+    [Test]
+    public void DistOps()
+    {
+      runDistOps();
+    }
+
+    [Test]
+    public void DistOpsXml()
+    {
+      runDistOpsXml();
+    }
+
+    [Test]
+    public void GenericsXmlPlugins()
+    {
+      runGenericsXmlPlugins();
+    }
+
+    [Test]
+    public void FailoverR1()
+    {
+      FailoverCommonSteps(1, false);
+    }
+
+    [Test]
+    public void FailoverR3()
+    {
+      FailoverCommonSteps(3, false);
+    }
+
+    [Test]
+    public void FailoverRegexR1()
+    {
+      FailoverCommonSteps(1, true);
+    }
+
+    [Test]
+    public void FailoverRegexR3()
+    {
+      FailoverCommonSteps(3, true);
+    }
+
+    [Test]
+    public void QueryFailover()
+    {
+      runQueryFailover();
+    }
+
+    [Test]
+    public void PeriodicAck()
+    {
+      runPeriodicAck();
+    }
+
+    [Test]
+    public void EventIDMap()
+    {
+      runEventIDMap();
+    }
+
+  }
+}

http://git-wip-us.apache.org/repos/asf/geode-native/blob/6cbd424f/clicache/integration-test/ThinClientListenerWriterN.cs
----------------------------------------------------------------------
diff --git a/clicache/integration-test/ThinClientListenerWriterN.cs 
b/clicache/integration-test/ThinClientListenerWriterN.cs
new file mode 100644
index 0000000..2a7ccfc
--- /dev/null
+++ b/clicache/integration-test/ThinClientListenerWriterN.cs
@@ -0,0 +1,287 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+using System;
+using System.Threading;
+
+namespace Apache.Geode.Client.UnitTests
+{
+  using NUnit.Framework;
+  using Apache.Geode.DUnitFramework;
+  using Apache.Geode.Client;
+  using Apache.Geode.Client.UnitTests;
+  using Region = Apache.Geode.Client.IRegion<Object, Object>;
+
+  [TestFixture]
+  [Category("group1")]
+  [Category("unicast_only")]
+  [Category("generics")]
+  public class ThinClientListenerWriter : ThinClientRegionSteps
+  {
+    private TallyWriter<object, object> m_writer;
+    private TallyListener<object, object> m_listener;
+    RegionOperation o_region;
+
+    private UnitProcess m_client1, m_client2, m_client3;
+
+    protected override ClientBase[] GetClients()
+    {
+      m_client1 = new UnitProcess();
+      m_client2 = new UnitProcess();
+      m_client3 = new UnitProcess();
+      return new ClientBase[] { m_client1, m_client2, m_client3 };
+    }
+
+    public void CreateRegion(string locators,
+      bool caching, bool listener, bool writer)
+    {
+      if (listener)
+      {
+        m_listener = new TallyListener<object, object>();
+      }
+      else
+      {
+        m_listener = null;
+      }
+      Region region = null;
+      region = CacheHelper.CreateTCRegion_Pool<object, object>(RegionName, 
true, caching,
+        m_listener, locators, "__TESTPOOL1_", true);
+
+      if (writer)
+      {
+        m_writer = new TallyWriter<object, object>();
+        AttributesMutator<object, object> at = region.AttributesMutator;
+        at.SetCacheWriter(m_writer);
+      }
+
+    }
+
+    public void ValidateEvents()
+    {
+      Thread.Sleep(5000);
+      m_listener.ShowTallies();
+      m_writer.ShowTallies();
+      Assert.AreEqual(0, m_listener.Creates, "Should be 0 creates");
+      Assert.AreEqual(0, m_listener.Updates, "Should be 0 updates");
+      Assert.AreEqual(20, m_listener.Invalidates, "Should be 20 invalidates");
+      Assert.AreEqual(5, m_listener.Destroys, "Should be 5 destroys");
+      Assert.AreEqual(false, m_writer.IsWriterInvoked, "Writer Should not be 
invoked");
+    }
+
+    public void ValidateGetEvents(int creates, int updates)
+    {
+      Thread.Sleep(1000);
+      m_listener.ShowTallies();
+      Assert.AreEqual(creates, m_listener.Creates, "Incorrect creates");
+      Assert.AreEqual(updates, m_listener.Updates, "Incorrect updates");
+    }
+
+    public void ValidateListenerWriterWithNBSTrue()
+    {
+      Thread.Sleep(5000);
+      m_listener.ShowTallies();
+
+      Assert.AreEqual(10, m_listener.Creates, "Should be 10 creates");
+      Assert.AreEqual(10, m_listener.Updates, "Should be 10 updates");
+      Assert.AreEqual(0, m_listener.Invalidates, "Should be 0 invalidates");
+      Assert.AreEqual(5, m_listener.Destroys, "Should be 5 destroys");
+      Assert.AreEqual(false, m_writer.IsWriterInvoked, "Writer should not be 
invoked");
+    }
+
+    public void RegisterAllKeysRN()
+    {
+      Region region = CacheHelper.GetVerifyRegion<object, object>(RegionName);
+      region.GetSubscriptionService().RegisterAllKeys(false, null, false, 
false);
+    }
+
+    public void CallOp()
+    {
+      o_region = new RegionOperation(RegionName);
+      o_region.PutOp(5, null);
+      Thread.Sleep(1000); // let the events reach at other end.
+      o_region.PutOp(5, null);
+      Thread.Sleep(1000);
+      o_region.InvalidateOp(5, null);
+      Thread.Sleep(1000);
+      o_region.DestroyOp(5, null);
+      Thread.Sleep(1000);
+    }
+
+    public void PutOp(string key, string value)
+    {
+      Util.Log("PutOp started");
+      o_region = new RegionOperation(RegionName);
+      Region r = o_region.Region;
+      r[key] = value;
+      Thread.Sleep(1000); // let the events reach at other end.
+      Util.Log("PutOp finished");
+    }
+
+    public void InvalidateOp(string key)
+    {
+      Util.Log("InvalidateOp started");
+      o_region = new RegionOperation(RegionName);
+      Region r = o_region.Region;
+      r.GetLocalView().Invalidate(key);
+      Thread.Sleep(1000); // let the events reach at other end.
+      Util.Log("InvalidateOp finished");
+    }
+
+    public void GetOp(string key)
+    {
+      Util.Log("GetOp started");
+      o_region = new RegionOperation(RegionName);
+      Region r = o_region.Region;
+      Object val  = r[key];
+      Thread.Sleep(1000); // let the events reach at other end.
+      Util.Log("GetOp finished");
+    }
+
+    public void registerPdxType8()
+    {
+      Serializable.RegisterPdxType(PdxTests.PdxTypes8.CreateDeserializable);
+    }
+    void runThinClientListenerWriterTest()
+    {
+      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.");
+
+      m_client1.Call(CacheHelper.InitClient);
+      Util.Log("Creating region in client1, no-ack, no-cache,  no-listener and 
no-writer");
+      m_client1.Call(CreateRegion, CacheHelper.Locators,
+        false, false, false);
+
+      m_client2.Call(CacheHelper.InitClient);
+      Util.Log("Creating region in client2 , no-ack, no-cache, with listener 
and writer");
+      m_client2.Call(CreateRegion, CacheHelper.Locators,
+        false, true, true);
+
+      m_client1.Call(registerPdxType8);
+      m_client2.Call(registerPdxType8);
+
+      m_client2.Call(RegisterAllKeys, new string[] { RegionName });
+
+      m_client1.Call(CallOp);
+
+      m_client2.Call(ValidateListenerWriterWithNBSTrue);
+
+      m_client1.Call(CacheHelper.CloseCache);
+
+      m_client2.Call(CacheHelper.CloseCache);
+
+      CacheHelper.StopJavaServer(1);
+
+      CacheHelper.SetupJavaServers(true, "cacheserver.xml");
+      CacheHelper.StartJavaServerWithLocators(1, "GFECS1", 1);
+      Util.Log("Cacheserver 1 started.");
+
+      Util.Log("Creating region in client1, no-ack, no-cache,  no-listener and 
no-writer");
+      m_client1.Call(CreateRegion, CacheHelper.Locators,
+        false, false, false);
+
+      Util.Log("Creating region in client2 , no-ack, no-cache, with listener 
and writer");
+      m_client2.Call(CreateRegion, CacheHelper.Locators,
+        false, true, true);
+
+      m_client3.Call(CacheHelper.InitClient);
+      Util.Log("Creating region in client2 , no-ack, no-cache, with listener 
and writer");
+      m_client3.Call(CreateRegion, CacheHelper.Locators,
+        false, true, true);
+
+      m_client1.Call(registerPdxType8);
+      m_client2.Call(registerPdxType8);
+
+      m_client2.Call(RegisterAllKeysRN);
+
+      m_client3.Call(RegisterAllKeysRN);
+
+      m_client1.Call(CallOp);
+
+      m_client2.Call(ValidateEvents);
+
+      m_client3.Call(ValidateEvents);
+
+      m_client1.Call(CacheHelper.Close);
+      m_client2.Call(CacheHelper.Close);
+      m_client3.Call(CacheHelper.Close);
+
+      CacheHelper.StopJavaServer(1);
+
+      /*  Bug #381   */
+      CacheHelper.SetupJavaServers(true, "cacheserver.xml");
+      CacheHelper.StartJavaServerWithLocators(1, "GFECS1", 1);
+      Util.Log("Cacheserver 1 started.");
+
+      Util.Log("Creating region in client1, no-ack, no-cache,  no-listener and 
no-writer");
+      m_client1.Call(CreateRegion,CacheHelper.Locators,
+        false, false, false);
+
+      Util.Log("Creating region in client2 , with listener and writer");
+      m_client2.Call(CreateRegion, CacheHelper.Locators,
+        true, true, true);
+
+      m_client3.Call(CacheHelper.InitClient);
+      Util.Log("Creating region in client3 , with listener and writer");
+      m_client3.Call(CreateRegion, CacheHelper.Locators,
+        true, true, true);
+
+      m_client2.Call(RegisterAllKeysRN);
+      m_client1.Call(PutOp, "Key-1", "Value-1");
+      m_client2.Call(GetOp, "Key-1");
+      m_client2.Call(ValidateGetEvents, 0, 1);
+      Util.Log("ValidateGetEvents 1 done. ");
+
+      m_client3.Call(RegisterAllKeysRN);
+      m_client3.Call(GetOp, "Key-1");
+      m_client3.Call(ValidateGetEvents, 1, 0);
+      Util.Log("ValidateGetEvents 2 done. ");
+
+      m_client2.Call(PutOp, "Key-2", "Value-2");
+      m_client2.Call(InvalidateOp, "Key-2");
+      m_client2.Call(GetOp, "Key-2");
+      m_client2.Call(ValidateGetEvents, 1, 2);
+      Util.Log("ValidateGetEvents 3 done. ");
+
+      m_client1.Call(CacheHelper.Close);
+      m_client2.Call(CacheHelper.Close);
+      m_client3.Call(CacheHelper.Close);
+
+      CacheHelper.StopJavaServer(1);
+
+      CacheHelper.StopJavaLocator(1);
+      Util.Log("Locator stopped");
+
+      CacheHelper.ClearLocators();
+      CacheHelper.ClearEndpoints();
+    }
+
+    [TearDown]
+    public override void EndTest()
+    {
+      base.EndTest();
+    }
+
+    [Test]
+    public void ThinClientListenerWriterTest()
+    {
+      runThinClientListenerWriterTest();
+    }
+  }
+}

Reply via email to