You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@geode.apache.org by jb...@apache.org on 2017/08/11 23:52:58 UTC
[42/52] [partial] geode-native git commit: GEODE-3165: Reogranized
sources relative to the root for better CMake IDE integration.
http://git-wip-us.apache.org/repos/asf/geode-native/blob/6cbd424f/clicache/integration-test/TallyListener.cs
----------------------------------------------------------------------
diff --git a/clicache/integration-test/TallyListener.cs b/clicache/integration-test/TallyListener.cs
new file mode 100644
index 0000000..62a6df0
--- /dev/null
+++ b/clicache/integration-test/TallyListener.cs
@@ -0,0 +1,300 @@
+/*
+ * 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 Apache.Geode.DUnitFramework;
+
+ class TallyListener : Apache.Geode.Client.CacheListenerAdapter<Object, Object>
+ {
+ #region Private members
+
+ private int m_creates = 0;
+ private int m_updates = 0;
+ private int m_invalidates = 0;
+ private int m_destroys = 0;
+ private int m_clears = 0;
+ private Apache.Geode.Client.ICacheableKey m_lastKey = null;
+ private Apache.Geode.Client.IGeodeSerializable m_lastValue = null;
+ private Apache.Geode.Client.IGeodeSerializable m_callbackArg = null;
+ private bool m_ignoreTimeout = false;
+ private bool m_quiet = false;
+ private bool isListenerInvoke = false;
+ private bool isCallbackCalled = false;
+
+ #endregion
+
+ #region Public accessors
+
+ public int Creates
+ {
+ get
+ {
+ return m_creates;
+ }
+ }
+
+ public int Clears
+ {
+ get
+ {
+ return m_clears;
+ }
+ }
+
+ public int Updates
+ {
+ get
+ {
+ return m_updates;
+ }
+ }
+
+ public int Invalidates
+ {
+ get
+ {
+ return m_invalidates;
+ }
+ }
+
+ public int Destroys
+ {
+ get
+ {
+ return m_destroys;
+ }
+ }
+
+ public Apache.Geode.Client.IGeodeSerializable LastKey
+ {
+ get
+ {
+ return m_lastKey;
+ }
+ }
+
+ public bool IsListenerInvoked
+ {
+ get
+ {
+ return isListenerInvoke;
+ }
+ }
+
+ public bool IsCallBackArgCalled
+ {
+ get
+ {
+ return isCallbackCalled;
+ }
+ }
+
+ public Apache.Geode.Client.IGeodeSerializable LastValue
+ {
+ get
+ {
+ return m_lastValue;
+ }
+ }
+
+ public bool IgnoreTimeout
+ {
+ set
+ {
+ m_ignoreTimeout = value;
+ }
+ }
+
+ public bool Quiet
+ {
+ set
+ {
+ m_quiet = value;
+ }
+ }
+
+ public void SetCallBackArg(Apache.Geode.Client.IGeodeSerializable callbackArg)
+ {
+ m_callbackArg = callbackArg;
+ }
+
+
+ #endregion
+
+ public void CheckcallbackArg(Apache.Geode.Client.EntryEvent<Object, Object> ev)
+ {
+ if (!isListenerInvoke)
+ isListenerInvoke = true;
+ if (m_callbackArg != null)
+ {
+ Apache.Geode.Client.IGeodeSerializable callbkArg = (Apache.Geode.Client.IGeodeSerializable)ev.CallbackArgument;
+ if (m_callbackArg.Equals(callbkArg))
+ isCallbackCalled = true;
+ }
+ }
+
+
+ public void ResetListenerInvokation()
+ {
+ isListenerInvoke = false;
+ isCallbackCalled = false;
+ }
+ public int ExpectCreates(int expected)
+ {
+ int tries = 0;
+ while ((m_creates < expected) && (tries < 200))
+ {
+ Thread.Sleep(100);
+ tries++;
+ }
+ return m_creates;
+ }
+
+ public int ExpectUpdates(int expected)
+ {
+ int tries = 0;
+ while ((m_updates < expected) && (tries < 200))
+ {
+ Thread.Sleep(100);
+ tries++;
+ }
+ return m_updates;
+ }
+
+ public int ExpectedInvalidates(int expected)
+ {
+ int tries = 0;
+ while ((m_invalidates < expected) && (tries < 200))
+ {
+ Thread.Sleep(100);
+ tries++;
+ }
+ return m_invalidates;
+ }
+
+ public int ExpectedDestroys(int expected)
+ {
+ int tries = 0;
+ while ((m_destroys < expected) && (tries < 200))
+ {
+ Thread.Sleep(100);
+ tries++;
+ }
+ return m_destroys;
+ }
+
+ public void ShowTallies()
+ {
+ Util.Log("TallyListener state: (updates = {0}, creates = {1}, invalidates = {2}, destroys = {3})",
+ Updates,Creates, Invalidates, Destroys);
+ }
+
+ #region Logging functions that check for m_quiet
+
+ private void WriteLog(string message)
+ {
+ if (!m_quiet)
+ {
+ Util.Log(message);
+ }
+ }
+
+ private void WriteLog(string format, params object[] args)
+ {
+ if (!m_quiet)
+ {
+ Util.Log(format, args);
+ }
+ }
+
+ public static TallyListener Create()
+ {
+ return new TallyListener();
+ }
+
+ #endregion
+
+ #region ICacheListener Members
+
+ public override void AfterCreate(Apache.Geode.Client.EntryEvent<Object, Object> ev)
+ {
+ m_creates++;
+ m_lastKey = (Apache.Geode.Client.ICacheableKey)ev.Key;
+ m_lastValue = (Apache.Geode.Client.IGeodeSerializable)ev.NewValue;
+ CheckcallbackArg(ev);
+
+ string keyString = m_lastKey.ToString();
+ WriteLog("TallyListener create - key = \"{0}\", value = \"{1}\"",
+ keyString, m_lastValue.ToString());
+
+ if ((!m_ignoreTimeout) && (keyString.IndexOf("timeout") >= 0))
+ {
+ WriteLog("TallyListener: Sleeping 10 seconds to force a timeout.");
+ Thread.Sleep(10000); // this should give the client cause to timeout...
+ WriteLog("TallyListener: done sleeping..");
+ }
+ }
+
+ public override void AfterUpdate(Apache.Geode.Client.EntryEvent<Object, Object> ev)
+ {
+ m_updates++;
+ m_lastKey = (Apache.Geode.Client.ICacheableKey)ev.Key;
+ m_lastValue = (Apache.Geode.Client.IGeodeSerializable)ev.NewValue;
+ CheckcallbackArg(ev);
+
+ string keyString = m_lastKey.ToString();
+ WriteLog("TallyListener update - key = \"{0}\", value = \"{1}\"",
+ keyString, m_lastValue.ToString());
+
+ if ((!m_ignoreTimeout) && (keyString.IndexOf("timeout") >= 0))
+ {
+ WriteLog("TallyListener: Sleeping 10 seconds to force a timeout.");
+ Thread.Sleep(10000); // this should give the client cause to timeout...
+ WriteLog("TallyListener: done sleeping..");
+ }
+ }
+ public override void AfterDestroy(Apache.Geode.Client.EntryEvent<Object, Object> ev)
+ {
+ m_destroys++;
+ CheckcallbackArg(ev);
+ }
+ public override void AfterInvalidate(Apache.Geode.Client.EntryEvent<Object, Object> ev)
+ {
+ m_invalidates++;
+ CheckcallbackArg(ev);
+ }
+
+ public override void AfterRegionDestroy(Apache.Geode.Client.RegionEvent<Object, Object> ev) { }
+
+ public override void AfterRegionClear(Apache.Geode.Client.RegionEvent<Object, Object> ev)
+ {
+ m_clears++;
+ }
+
+ public override void AfterRegionInvalidate(Apache.Geode.Client.RegionEvent<Object, Object> ev) { }
+
+ public override void AfterRegionLive(Apache.Geode.Client.RegionEvent<Object, Object> ev) { }
+
+ public override void Close(Apache.Geode.Client.IRegion<Object, Object> region) { }
+
+ #endregion
+ }
+}
http://git-wip-us.apache.org/repos/asf/geode-native/blob/6cbd424f/clicache/integration-test/TallyListenerN.cs
----------------------------------------------------------------------
diff --git a/clicache/integration-test/TallyListenerN.cs b/clicache/integration-test/TallyListenerN.cs
new file mode 100644
index 0000000..3bad24e
--- /dev/null
+++ b/clicache/integration-test/TallyListenerN.cs
@@ -0,0 +1,333 @@
+/*
+ * 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 Apache.Geode.DUnitFramework;
+ using Apache.Geode.Client;
+ //using Region = Apache.Geode.Client.IRegion<Object, Object>;
+
+ class TallyListener<TKey, TVal> : CacheListenerAdapter<TKey, TVal>
+ {
+ #region Private members
+
+ private int m_creates = 0;
+ private int m_updates = 0;
+ private int m_invalidates = 0;
+ private int m_destroys = 0;
+ private int m_clears = 0;
+ private TKey m_lastKey = default(TKey);
+ private TVal m_lastValue = default(TVal);
+ private object m_callbackArg = null;
+ private bool m_ignoreTimeout = false;
+ private bool m_quiet = false;
+ private bool isListenerInvoke = false;
+ private bool isCallbackCalled = false;
+
+ #endregion
+
+ #region Public accessors
+
+ public int Creates
+ {
+ get
+ {
+ return m_creates;
+ }
+ }
+
+ public int Clears
+ {
+ get
+ {
+ return m_clears;
+ }
+ }
+
+ public int Updates
+ {
+ get
+ {
+ return m_updates;
+ }
+ }
+
+ public int Invalidates
+ {
+ get
+ {
+ return m_invalidates;
+ }
+ }
+
+ public int Destroys
+ {
+ get
+ {
+ return m_destroys;
+ }
+ }
+
+ public TKey LastKey
+ {
+ get
+ {
+ return m_lastKey;
+ }
+ }
+
+ public bool IsListenerInvoked
+ {
+ get
+ {
+ return isListenerInvoke;
+ }
+ }
+
+ public bool IsCallBackArgCalled
+ {
+ get
+ {
+ return isCallbackCalled;
+ }
+ }
+
+ public TVal LastValue
+ {
+ get
+ {
+ return m_lastValue;
+ }
+ }
+
+ public bool IgnoreTimeout
+ {
+ set
+ {
+ m_ignoreTimeout = value;
+ }
+ }
+
+ public bool Quiet
+ {
+ set
+ {
+ m_quiet = value;
+ }
+ }
+
+ public void SetCallBackArg(object callbackArg)
+ {
+ m_callbackArg = callbackArg;
+ }
+
+
+ #endregion
+
+ public void CheckcallbackArg<TKey1, TVal1>(EntryEvent<TKey1, TVal1> ev)
+ {
+ Util.Log("TallyListenerN: Checking callback arg for EntryEvent " +
+ "key:{0} oldval: {1} newval:{2} cbArg:{3} for region:{4} and remoteOrigin:{5}",
+ ev.Key, ev.NewValue, ev.OldValue, ev.CallbackArgument, ev.Region.Name, ev.RemoteOrigin);
+
+ if (!isListenerInvoke)
+ isListenerInvoke = true;
+ /*
+ if (m_callbackArg != null)
+ {
+ IGeodeSerializable callbkArg1 = ev.CallbackArgument as IGeodeSerializable;
+ IGeodeSerializable callbkArg2 = m_callbackArg as IGeodeSerializable;
+ if (callbkArg2 != null && callbkArg2.Equals(callbkArg1))
+ {
+ isCallbackCalled = true;
+ }
+ string callbkArg3 = ev.CallbackArgument as string;
+ string callbkArg4 = m_callbackArg as string;
+ if (callbkArg3 != null && callbkArg3.Equals(callbkArg4))
+ {
+ isCallbackCalled = true;
+ }
+ }
+ */
+ if (m_callbackArg != null && m_callbackArg.Equals(ev.CallbackArgument))
+ {
+ isCallbackCalled = true;
+ }
+ }
+
+
+ public void ResetListenerInvokation()
+ {
+ isListenerInvoke = false;
+ isCallbackCalled = false;
+ }
+ public int ExpectCreates(int expected)
+ {
+ int tries = 0;
+ while ((m_creates < expected) && (tries < 200))
+ {
+ Thread.Sleep(100);
+ tries++;
+ }
+ return m_creates;
+ }
+
+ public int ExpectUpdates(int expected)
+ {
+ int tries = 0;
+ while ((m_updates < expected) && (tries < 200))
+ {
+ Thread.Sleep(100);
+ tries++;
+ }
+ return m_updates;
+ }
+
+ public int ExpectedInvalidates(int expected)
+ {
+ int tries = 0;
+ while ((m_invalidates < expected) && (tries < 200))
+ {
+ Thread.Sleep(100);
+ tries++;
+ }
+ return m_invalidates;
+ }
+
+ public int ExpectedDestroys(int expected)
+ {
+ int tries = 0;
+ while ((m_destroys < expected) && (tries < 200))
+ {
+ Thread.Sleep(100);
+ tries++;
+ }
+ return m_destroys;
+ }
+
+ public void ShowTallies()
+ {
+ Util.Log("TallyListener state: (updates = {0}, creates = {1}, invalidates = {2}, destroys = {3})",
+ Updates,Creates, Invalidates, Destroys);
+ }
+
+ #region Logging functions that check for m_quiet
+
+ private void WriteLog(string message)
+ {
+ if (!m_quiet)
+ {
+ Util.Log(message);
+ }
+ }
+
+ private void WriteLog(string format, params object[] args)
+ {
+ if (!m_quiet)
+ {
+ Util.Log(format, args);
+ }
+ }
+
+ public static TallyListener<TKey, TVal> Create()
+ {
+ return new TallyListener<TKey, TVal>();
+ }
+
+ #endregion
+
+ #region ICacheListener Members
+
+ public override void AfterCreate(EntryEvent<TKey, TVal> ev)
+ {
+ m_creates++;
+ m_lastKey = (TKey)ev.Key;
+ m_lastValue = ev.NewValue;
+ CheckcallbackArg(ev);
+
+ string keyString = m_lastKey.ToString();
+ if (m_lastValue != null)
+ WriteLog("TallyListener create - key = \"{0}\", value = \"{1}\"",
+ keyString, m_lastValue.ToString());
+ else
+ WriteLog("TallyListener create - key = \"{0}\", value = \"null\"",
+ keyString);
+
+ if ((!m_ignoreTimeout) && (keyString.IndexOf("timeout") >= 0))
+ {
+ WriteLog("TallyListener: Sleeping 10 seconds to force a timeout.");
+ Thread.Sleep(10000); // this should give the client cause to timeout...
+ WriteLog("TallyListener: done sleeping..");
+ }
+ }
+
+ public override void AfterUpdate(EntryEvent<TKey, TVal> ev)
+ {
+ m_updates++;
+ m_lastKey = (TKey)ev.Key;
+ m_lastValue = ev.NewValue;
+ CheckcallbackArg(ev);
+
+ string keyString = m_lastKey.ToString();
+ if (m_lastValue != null)
+ WriteLog("TallyListener update - key = \"{0}\", value = \"{1}\"",
+ keyString, m_lastValue.ToString());
+ else
+ WriteLog("TallyListener update - key = \"{0}\", value = \"null\"",
+ keyString);
+
+ if ((!m_ignoreTimeout) && (keyString.IndexOf("timeout") >= 0))
+ {
+ WriteLog("TallyListener: Sleeping 10 seconds to force a timeout.");
+ Thread.Sleep(10000); // this should give the client cause to timeout...
+ WriteLog("TallyListener: done sleeping..");
+ }
+ }
+ public override void AfterDestroy(EntryEvent<TKey, TVal> ev)
+ {
+ WriteLog("TallyListener destroy - key = \"{0}\"",
+ ((TKey)ev.Key).ToString());
+ m_destroys++;
+ CheckcallbackArg(ev);
+ }
+ public override void AfterInvalidate(EntryEvent<TKey, TVal> ev)
+ {
+ WriteLog("TallyListener invalidate - key = \"{0}\"",
+ ((TKey)ev.Key).ToString());
+ m_invalidates++;
+ CheckcallbackArg(ev);
+ }
+
+ public override void AfterRegionDestroy(RegionEvent<TKey, TVal> ev) { }
+
+ public override void AfterRegionClear(RegionEvent<TKey, TVal> ev)
+ {
+ m_clears++;
+ }
+
+ public override void AfterRegionInvalidate(RegionEvent<TKey, TVal> ev) { }
+
+ public override void AfterRegionLive(RegionEvent<TKey, TVal> ev) { }
+
+ public override void Close(IRegion<TKey, TVal> region) { }
+
+ #endregion
+ }
+}
http://git-wip-us.apache.org/repos/asf/geode-native/blob/6cbd424f/clicache/integration-test/TallyLoaderN.cs
----------------------------------------------------------------------
diff --git a/clicache/integration-test/TallyLoaderN.cs b/clicache/integration-test/TallyLoaderN.cs
new file mode 100644
index 0000000..64db895
--- /dev/null
+++ b/clicache/integration-test/TallyLoaderN.cs
@@ -0,0 +1,104 @@
+/*
+ * 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 Apache.Geode.DUnitFramework;
+
+ using Apache.Geode.Client;
+ using Apache.Geode.Client;
+
+ class TallyLoader<TKey, TVal> : ICacheLoader<TKey, TVal>
+ {
+ #region Private members
+
+ private int m_loads = 0;
+
+ #endregion
+
+ #region Public accessors
+
+ public int Loads
+ {
+ get
+ {
+ return m_loads;
+ }
+ }
+
+ #endregion
+
+ public int ExpectLoads(int expected)
+ {
+ int tries = 0;
+ while ((m_loads < expected) && (tries < 200))
+ {
+ Thread.Sleep(100);
+ tries++;
+ }
+ return m_loads;
+ }
+
+ public void Reset()
+ {
+ m_loads = 0;
+ }
+
+ public void ShowTallies()
+ {
+ Util.Log("TallyLoader state: (loads = {0})", Loads);
+ }
+
+ public static TallyLoader<TKey, TVal> Create()
+ {
+ return new TallyLoader<TKey, TVal>();
+ }
+
+ public virtual int GetLoadCount()
+ {
+ return m_loads;
+ }
+
+ #region ICacheLoader<TKey, TVal> Members
+
+ public virtual TVal Load(IRegion<TKey, TVal> region, TKey key, object helper)
+ {
+ m_loads++;
+ Util.Log("TallyLoader Load: (m_loads = {0}) TYPEOF key={1} val={2} for region {3}",
+ m_loads, typeof(TKey), typeof(TVal), region.Name);
+ if (typeof(TVal) == typeof(string))
+ {
+ return (TVal) (object) m_loads.ToString();
+ }
+ if (typeof(TVal) == typeof(int))
+ {
+ return (TVal)(object) m_loads;
+ }
+ return default(TVal);
+ }
+
+ public virtual void Close(IRegion<TKey, TVal> region)
+ {
+ Util.Log("TallyLoader<TKey, TVal>::Close");
+ }
+
+ #endregion
+ }
+}
http://git-wip-us.apache.org/repos/asf/geode-native/blob/6cbd424f/clicache/integration-test/TallyResolverN.cs
----------------------------------------------------------------------
diff --git a/clicache/integration-test/TallyResolverN.cs b/clicache/integration-test/TallyResolverN.cs
new file mode 100755
index 0000000..a37c3a0
--- /dev/null
+++ b/clicache/integration-test/TallyResolverN.cs
@@ -0,0 +1,97 @@
+/*
+ * 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 Apache.Geode.DUnitFramework;
+
+ using Apache.Geode.Client;
+ using Apache.Geode.Client;
+
+ class TallyResolver<TKey, TVal> : IPartitionResolver<TKey, TVal>
+ {
+ #region Private members
+
+ private int m_loads = 0;
+
+ #endregion
+
+ #region Public accessors
+
+ public int Loads
+ {
+ get
+ {
+ return m_loads;
+ }
+ }
+
+ #endregion
+
+ public int ExpectLoads(int expected)
+ {
+ int tries = 0;
+ while ((m_loads < expected) && (tries < 200))
+ {
+ Thread.Sleep(100);
+ tries++;
+ }
+ return m_loads;
+ }
+
+ public void Reset()
+ {
+ m_loads = 0;
+ }
+
+ public void ShowTallies()
+ {
+ Util.Log("TallyResolver state: (loads = {0})", Loads);
+ }
+
+ public static TallyResolver<TKey, TVal> Create()
+ {
+ return new TallyResolver<TKey, TVal>();
+ }
+
+ public virtual int GetLoadCount()
+ {
+ return m_loads;
+ }
+
+ #region IPartitionResolver<TKey, TVal> Members
+
+ public virtual Object GetRoutingObject(EntryEvent<TKey, TVal> ev)
+ {
+ m_loads++;
+ Util.Log("TallyResolver Load: (m_loads = {0}) TYPEOF key={1} val={2} for region {3}",
+ m_loads, typeof(TKey), typeof(TVal), ev.Region.Name);
+ return ev.Key;
+ }
+
+ public virtual string GetName()
+ {
+ Util.Log("TallyResolver<TKey, TVal>::GetName");
+ return "TallyResolver";
+ }
+
+ #endregion
+ }
+}
http://git-wip-us.apache.org/repos/asf/geode-native/blob/6cbd424f/clicache/integration-test/TallyWriter.cs
----------------------------------------------------------------------
diff --git a/clicache/integration-test/TallyWriter.cs b/clicache/integration-test/TallyWriter.cs
new file mode 100644
index 0000000..8ef6db0
--- /dev/null
+++ b/clicache/integration-test/TallyWriter.cs
@@ -0,0 +1,222 @@
+/*
+ * 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 Apache.Geode.DUnitFramework;
+
+ class TallyWriter : Apache.Geode.Client.CacheWriterAdapter<Object, Object>
+ {
+ #region Private members
+
+ private int m_creates = 0;
+ private int m_updates = 0;
+ private int m_invalidates = 0;
+ private int m_destroys = 0;
+ private Apache.Geode.Client.IGeodeSerializable m_callbackArg = null;
+ private int m_clears = 0;
+ private Apache.Geode.Client.IGeodeSerializable m_lastKey = null;
+ private Apache.Geode.Client.IGeodeSerializable m_lastValue = null;
+ private bool isWriterFailed = false;
+ private bool isWriterInvoke = false;
+ private bool isCallbackCalled = false;
+
+ #endregion
+
+ #region Public accessors
+
+ public int Creates
+ {
+ get
+ {
+ return m_creates;
+ }
+ }
+ public int Clears
+ {
+ get
+ {
+ return m_clears;
+ }
+ }
+
+ public int Updates
+ {
+ get
+ {
+ return m_updates;
+ }
+ }
+
+ public int Invalidates
+ {
+ get
+ {
+ return m_invalidates;
+ }
+ }
+
+ public int Destroys
+ {
+ get
+ {
+ return m_destroys;
+ }
+ }
+
+
+ public Apache.Geode.Client.IGeodeSerializable LastKey
+ {
+ get
+ {
+ return m_lastKey;
+ }
+ }
+
+ public Apache.Geode.Client.IGeodeSerializable CallbackArgument
+ {
+ get
+ {
+ return m_callbackArg;
+ }
+ }
+
+
+ public Apache.Geode.Client.IGeodeSerializable LastValue
+ {
+ get
+ {
+ return m_lastValue;
+ }
+ }
+
+ public void SetWriterFailed( )
+ {
+ isWriterFailed = true;
+ }
+
+ public void SetCallBackArg( Apache.Geode.Client.IGeodeSerializable callbackArg )
+ {
+ m_callbackArg = callbackArg;
+ }
+
+ public void ResetWriterInvokation()
+ {
+ isWriterInvoke = false;
+ isCallbackCalled = false;
+ }
+
+ public bool IsWriterInvoked
+ {
+ get
+ {
+ return isWriterInvoke;
+ }
+ }
+ public bool IsCallBackArgCalled
+ {
+ get
+ {
+ return isCallbackCalled;
+ }
+ }
+ #endregion
+
+ public int ExpectCreates(int expected)
+ {
+ int tries = 0;
+ while ((m_creates < expected) && (tries < 200))
+ {
+ Thread.Sleep(100);
+ tries++;
+ }
+ return m_creates;
+ }
+
+ public int ExpectUpdates(int expected)
+ {
+ int tries = 0;
+ while ((m_updates < expected) && (tries < 200))
+ {
+ Thread.Sleep(100);
+ tries++;
+ }
+ return m_updates;
+ }
+
+ public void ShowTallies()
+ {
+ Util.Log("TallyWriter state: (updates = {0}, creates = {1}, invalidates = {2}, destroys = {3})",
+ Updates, Creates, Invalidates, Destroys);
+ }
+
+ public void CheckcallbackArg(Apache.Geode.Client.EntryEvent<Object, Object> ev)
+ {
+
+ if(!isWriterInvoke)
+ isWriterInvoke = true;
+ if (m_callbackArg != null)
+ {
+ Apache.Geode.Client.IGeodeSerializable callbkArg = (Apache.Geode.Client.IGeodeSerializable)ev.CallbackArgument;
+ if (m_callbackArg.Equals(callbkArg))
+ isCallbackCalled = true;
+ }
+ }
+
+ public static TallyWriter Create()
+ {
+ return new TallyWriter();
+ }
+
+ #region ICacheWriter Members
+
+ public override bool BeforeCreate(Apache.Geode.Client.EntryEvent<Object, Object> ev)
+ {
+ m_creates++;
+ Util.Log("TallyWriter::BeforeCreate");
+ CheckcallbackArg(ev);
+ return !isWriterFailed;
+ }
+
+ public override bool BeforeDestroy(Apache.Geode.Client.EntryEvent<Object, Object> ev)
+ {
+ m_destroys++;
+ Util.Log("TallyWriter::BeforeDestroy");
+ CheckcallbackArg(ev);
+ return !isWriterFailed;
+ }
+
+ public override bool BeforeRegionClear(Apache.Geode.Client.RegionEvent<Object, Object> ev)
+ {
+ m_clears++;
+ Util.Log("TallyWriter::BeforeRegionClear");
+ return true;
+ }
+
+ public override bool BeforeUpdate(Apache.Geode.Client.EntryEvent<Object, Object> ev)
+ {
+ m_updates++;
+ Util.Log("TallyWriter::BeforeUpdate");
+ CheckcallbackArg(ev);
+ return !isWriterFailed;
+ }
+ #endregion
+ }
+}
http://git-wip-us.apache.org/repos/asf/geode-native/blob/6cbd424f/clicache/integration-test/TallyWriterN.cs
----------------------------------------------------------------------
diff --git a/clicache/integration-test/TallyWriterN.cs b/clicache/integration-test/TallyWriterN.cs
new file mode 100644
index 0000000..1f3aaa2
--- /dev/null
+++ b/clicache/integration-test/TallyWriterN.cs
@@ -0,0 +1,240 @@
+/*
+ * 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 Apache.Geode.DUnitFramework;
+ using Apache.Geode.Client;
+ class TallyWriter<TKey, TVal> : CacheWriterAdapter<TKey, TVal>
+ {
+ #region Private members
+
+ private int m_creates = 0;
+ private int m_updates = 0;
+ private int m_invalidates = 0;
+ private int m_destroys = 0;
+ private Object m_callbackArg = null;
+ private int m_clears = 0;
+ private Object m_lastKey = null;
+ private Object m_lastValue = null;
+ private bool isWriterFailed = false;
+ private bool isWriterInvoke = false;
+ private bool isCallbackCalled = false;
+
+ #endregion
+
+ #region Public accessors
+
+ public int Creates
+ {
+ get
+ {
+ return m_creates;
+ }
+ }
+ public int Clears
+ {
+ get
+ {
+ return m_clears;
+ }
+ }
+
+ public int Updates
+ {
+ get
+ {
+ return m_updates;
+ }
+ }
+
+ public int Invalidates
+ {
+ get
+ {
+ return m_invalidates;
+ }
+ }
+
+ public int Destroys
+ {
+ get
+ {
+ return m_destroys;
+ }
+ }
+
+
+ public Object LastKey
+ {
+ get
+ {
+ return m_lastKey;
+ }
+ }
+
+ public Object CallbackArgument
+ {
+ get
+ {
+ return m_callbackArg;
+ }
+ }
+
+
+ public Object LastValue
+ {
+ get
+ {
+ return m_lastValue;
+ }
+ }
+
+ public void SetWriterFailed( )
+ {
+ isWriterFailed = true;
+ }
+
+ public void SetCallBackArg( object callbackArg )
+ {
+ m_callbackArg = callbackArg;
+ }
+
+ public void ResetWriterInvokation()
+ {
+ isWriterInvoke = false;
+ isCallbackCalled = false;
+ }
+
+ public bool IsWriterInvoked
+ {
+ get
+ {
+ return isWriterInvoke;
+ }
+ }
+ public bool IsCallBackArgCalled
+ {
+ get
+ {
+ return isCallbackCalled;
+ }
+ }
+ #endregion
+
+ public int ExpectCreates(int expected)
+ {
+ int tries = 0;
+ while ((m_creates < expected) && (tries < 200))
+ {
+ Thread.Sleep(100);
+ tries++;
+ }
+ return m_creates;
+ }
+
+ public int ExpectUpdates(int expected)
+ {
+ int tries = 0;
+ while ((m_updates < expected) && (tries < 200))
+ {
+ Thread.Sleep(100);
+ tries++;
+ }
+ return m_updates;
+ }
+
+ public void ShowTallies()
+ {
+ Util.Log("TallyWriter state: (updates = {0}, creates = {1}, invalidates = {2}, destroys = {3})",
+ Updates, Creates, Invalidates, Destroys);
+ }
+
+ public void CheckcallbackArg<TKey1, TVal1>(EntryEvent<TKey1, TVal1> ev)
+ {
+ Util.Log("TallyWriterN: Checking callback arg for EntryEvent " +
+ "key:{0} oldval: {1} newval:{2} cbArg:{3} for region:{4} and remoteOrigin:{5}",
+ ev.Key, ev.NewValue, ev.OldValue, ev.CallbackArgument, ev.Region.Name, ev.RemoteOrigin);
+
+ if(!isWriterInvoke)
+ isWriterInvoke = true;
+ /*
+ if (m_callbackArg != null)
+ {
+ IGeodeSerializable callbkArg1 = ev.CallbackArgument as IGeodeSerializable;
+ IGeodeSerializable callbkArg2 = m_callbackArg as IGeodeSerializable;
+ if (callbkArg1 != null && callbkArg1.Equals(callbkArg2))
+ {
+ isCallbackCalled = true;
+ }
+ string callbkArg3 = ev.CallbackArgument as string;
+ string callbkArg4 = m_callbackArg as string;
+ if (callbkArg3 != null && callbkArg3.Equals(callbkArg4))
+ {
+ isCallbackCalled = true;
+ }
+ }
+ * */
+ if (m_callbackArg != null && m_callbackArg.Equals(ev.CallbackArgument))
+ {
+ isCallbackCalled = true;
+ }
+ }
+
+ public static TallyWriter<TKey, TVal> Create()
+ {
+ return new TallyWriter<TKey, TVal>();
+ }
+
+ #region ICacheWriter Members
+
+ public override bool BeforeCreate(EntryEvent<TKey, TVal> ev)
+ {
+ m_creates++;
+ Util.Log("TallyWriter::BeforeCreate");
+ CheckcallbackArg(ev);
+ return !isWriterFailed;
+ }
+
+ public override bool BeforeDestroy(EntryEvent<TKey, TVal> ev)
+ {
+ m_destroys++;
+ Util.Log("TallyWriter::BeforeDestroy");
+ CheckcallbackArg(ev);
+ return !isWriterFailed;
+ }
+
+ public override bool BeforeRegionClear(RegionEvent<TKey, TVal> ev)
+ {
+ m_clears++;
+ Util.Log("TallyWriter::BeforeRegionClear");
+ return true;
+ }
+
+ public override bool BeforeUpdate(EntryEvent<TKey, TVal> ev)
+ {
+ m_updates++;
+ Util.Log("TallyWriter::BeforeUpdate");
+ CheckcallbackArg(ev);
+ return !isWriterFailed;
+ }
+ #endregion
+ }
+}
http://git-wip-us.apache.org/repos/asf/geode-native/blob/6cbd424f/clicache/integration-test/ThinClientAppDomainFunctionExecutionTests.cs
----------------------------------------------------------------------
diff --git a/clicache/integration-test/ThinClientAppDomainFunctionExecutionTests.cs b/clicache/integration-test/ThinClientAppDomainFunctionExecutionTests.cs
new file mode 100644
index 0000000..0d9129c
--- /dev/null
+++ b/clicache/integration-test/ThinClientAppDomainFunctionExecutionTests.cs
@@ -0,0 +1,282 @@
+//=========================================================================
+// 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.Collections;
+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>;
+
+ public class MyAppDomainResultCollector<TResult> : IResultCollector<TResult>
+ {
+ #region Private members
+ private bool m_resultReady = false;
+ ICollection<TResult> m_results = null;
+ private int m_addResultCount = 0;
+ private int m_getResultCount = 0;
+ private int m_endResultCount = 0;
+ #endregion
+ public int GetAddResultCount()
+ {
+ return m_addResultCount;
+ }
+ public int GetGetResultCount()
+ {
+ return m_getResultCount;
+ }
+ public int GetEndResultCount()
+ {
+ return m_endResultCount;
+ }
+ public MyAppDomainResultCollector()
+ {
+ m_results = new List<TResult>();
+ }
+ public void AddResult(TResult result)
+ {
+ Util.Log("MyAppDomainResultCollector " + result + " : " + result.GetType());
+ m_addResultCount++;
+ m_results.Add(result);
+ }
+ public ICollection<TResult> GetResult()
+ {
+ return GetResult(50);
+ }
+
+ public ICollection<TResult> GetResult(UInt32 timeout)
+ {
+ m_getResultCount++;
+ if (m_resultReady == true)
+ {
+ return m_results;
+ }
+ else
+ {
+ for (int i = 0; i < timeout; i++)
+ {
+ Thread.Sleep(1000);
+ if (m_resultReady == true)
+ {
+ return m_results;
+ }
+
+ }
+ throw new FunctionExecutionException(
+ "Result is not ready, endResults callback is called before invoking getResult() method");
+
+ }
+ }
+ public void EndResults()
+ {
+ m_endResultCount++;
+ m_resultReady = true;
+ }
+ public void ClearResults(/*bool unused*/)
+ {
+ m_results.Clear();
+ m_addResultCount = 0;
+ m_getResultCount = 0;
+ m_endResultCount = 0;
+ }
+ }
+
+
+ [TestFixture]
+ [Category("group3")]
+ [Category("unicast_only")]
+ [Category("generics")]
+ public class ThinClientAppDomainFunctionExecutionTests : ThinClientRegionSteps
+ {
+ #region Private members
+
+ private static string[] FunctionExecutionRegionNames = { "partition_region", "partition_region1" };
+ private static string poolName = "__TEST_POOL1__";
+ private static string serverGroup = "ServerGroup1";
+ private static string QERegionName = "partition_region";
+ private static string OnServerHAExceptionFunction = "OnServerHAExceptionFunction";
+ private static string OnServerHAShutdownFunction = "OnServerHAShutdownFunction";
+
+ #endregion
+
+ protected override ClientBase[] GetClients()
+ {
+ return new ClientBase[] { };
+ }
+
+ [TestFixtureSetUp]
+ public override void InitTests()
+ {
+ Util.Log("InitTests: AppDomain: " + AppDomain.CurrentDomain.Id);
+ Properties<string, string> config = new Properties<string, string>();
+ config.Insert("appdomain-enabled", "true");
+ CacheHelper.InitConfig(config);
+ }
+
+ [TearDown]
+ public override void EndTest()
+ {
+ Util.Log("EndTest: AppDomain: " + AppDomain.CurrentDomain.Id);
+ try
+ {
+ CacheHelper.ClearEndpoints();
+ CacheHelper.ClearLocators();
+ }
+ finally
+ {
+ CacheHelper.StopJavaServers();
+ CacheHelper.StopJavaLocators();
+ }
+ base.EndTest();
+ }
+
+ public void createRegionAndAttachPool(string regionName, string poolName)
+ {
+ CacheHelper.CreateTCRegion_Pool<object, object>(regionName, true, true, null, null, poolName, false, serverGroup);
+ }
+ public void createPool(string name, string locators, string serverGroup,
+ int redundancy, bool subscription, bool prSingleHop, bool threadLocal = false)
+ {
+ CacheHelper.CreatePool<object, object>(name, locators, serverGroup, redundancy, subscription, prSingleHop, threadLocal);
+ }
+
+ public void OnServerHAStepOne()
+ {
+
+ Region region = CacheHelper.GetVerifyRegion<object, object>(QERegionName);
+ for (int i = 0; i < 34; i++)
+ {
+ region["KEY--" + i] = "VALUE--" + i;
+ }
+
+ object[] routingObj = new object[17];
+
+ ArrayList args1 = new ArrayList();
+
+ int j = 0;
+ for (int i = 0; i < 34; i++)
+ {
+ if (i % 2 == 0) continue;
+ routingObj[j] = "KEY--" + i;
+ j++;
+ }
+ Util.Log("routingObj count= {0}.", routingObj.Length);
+
+ for (int i = 0; i < routingObj.Length; i++)
+ {
+ Console.WriteLine("routingObj[{0}]={1}.", i, (string)routingObj[i]);
+ args1.Add(routingObj[i]);
+ }
+
+ Boolean getResult = true;
+ //test data independant function execution with result onServer
+ Pool/*<TKey, TValue>*/ pool = CacheHelper.DCache.GetPoolManager().Find(poolName);
+
+ Apache.Geode.Client.Execution<object> exc = FunctionService<object>.OnServer(pool);
+ Assert.IsTrue(exc != null, "onServer Returned NULL");
+
+ IResultCollector<object> rc = exc.WithArgs<ArrayList>(args1).Execute(OnServerHAExceptionFunction, 15);
+
+ ICollection<object> executeFunctionResult = rc.GetResult();
+
+ List<object> resultList = new List<object>();
+
+ Console.WriteLine("executeFunctionResult.Length = {0}", executeFunctionResult.Count);
+
+ foreach (List<object> item in executeFunctionResult)
+ {
+ foreach (object item2 in item)
+ {
+ resultList.Add(item2);
+ }
+ }
+
+ Util.Log("on region: result count= {0}.", resultList.Count);
+ Assert.IsTrue(resultList.Count == 17, "result count check failed");
+ for (int i = 0; i < resultList.Count; i++)
+ {
+ Util.Log("on region:get:result[{0}]={1}.", i, (string)resultList[i]);
+ Assert.IsTrue(((string)resultList[i]) != null, "onServer Returned NULL");
+ }
+
+ rc = exc.WithArgs<ArrayList>(args1).Execute(OnServerHAShutdownFunction, 15);
+
+ ICollection<object> executeFunctionResult1 = rc.GetResult();
+
+ List<object> resultList1 = new List<object>();
+
+ foreach (List<object> item in executeFunctionResult1)
+ {
+ foreach (object item2 in item)
+ {
+ resultList1.Add(item2);
+ }
+ }
+
+ Util.Log("on region: result count= {0}.", resultList1.Count);
+
+ Console.WriteLine("resultList1.Count = {0}", resultList1.Count);
+
+ Assert.IsTrue(resultList1.Count == 17, "result count check failed");
+ for (int i = 0; i < resultList1.Count; i++)
+ {
+ Util.Log("on region:get:result[{0}]={1}.", i, (string)resultList1[i]);
+ Assert.IsTrue(((string)resultList1[i]) != null, "onServer Returned NULL");
+ }
+
+ // Bring down the region
+ //region.LocalDestroyRegion();
+ }
+
+ [Test]
+ public void OnServerHAExecuteFunction()
+ {
+ Util.Log("OnServerHAExecuteFunction: AppDomain: " + AppDomain.CurrentDomain.Id);
+ CacheHelper.SetupJavaServers(true, "func_cacheserver1_pool.xml",
+ "func_cacheserver2_pool.xml", "func_cacheserver3_pool.xml");
+ CacheHelper.StartJavaLocator(1, "GFELOC");
+ Util.Log("Locator 1 started.");
+ CacheHelper.StartJavaServerWithLocators(1, "GFECS1", 1);
+ Util.Log("Cacheserver 1 started.");
+ CacheHelper.StartJavaServerWithLocators(2, "GFECS2", 1);
+ Util.Log("Cacheserver 2 started.");
+ CacheHelper.StartJavaServerWithLocators(3, "GFECS3", 1);
+ Util.Log("Cacheserver 3 started.");
+
+ createPool(poolName, CacheHelper.Locators, serverGroup, 1, true, true, /*threadLocal*/true);
+ createRegionAndAttachPool(QERegionName, poolName);
+ Util.Log("Client 1 (pool locator) regions created");
+
+ OnServerHAStepOne();
+
+ Close();
+ Util.Log("Client 1 closed");
+
+ CacheHelper.StopJavaServer(1);
+ Util.Log("Cacheserver 1 stopped.");
+
+ CacheHelper.StopJavaServer(2);
+ Util.Log("Cacheserver 2 stopped.");
+
+ CacheHelper.StopJavaServer(3);
+ Util.Log("Cacheserver 3 stopped.");
+
+ CacheHelper.StopJavaLocator(1);
+ Util.Log("Locator 1 stopped.");
+
+ CacheHelper.ClearEndpoints();
+ CacheHelper.ClearLocators();
+ }
+ }
+}
http://git-wip-us.apache.org/repos/asf/geode-native/blob/6cbd424f/clicache/integration-test/ThinClientAppDomainQueryTests.cs
----------------------------------------------------------------------
diff --git a/clicache/integration-test/ThinClientAppDomainQueryTests.cs b/clicache/integration-test/ThinClientAppDomainQueryTests.cs
new file mode 100644
index 0000000..90aabf7
--- /dev/null
+++ b/clicache/integration-test/ThinClientAppDomainQueryTests.cs
@@ -0,0 +1,280 @@
+/*
+ * 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;
+
+namespace Apache.Geode.Client.UnitTests
+{
+ using Apache.Geode.Client;
+ using Apache.Geode.Client.Tests;
+ using Apache.Geode.DUnitFramework;
+ using NUnit.Framework;
+ using QueryCategory = Apache.Geode.Client.Tests.QueryCategory;
+ using QueryStatics = Apache.Geode.Client.Tests.QueryStatics;
+ using QueryStrings = Apache.Geode.Client.Tests.QueryStrings;
+
+ [TestFixture]
+ [Category("group1")]
+ [Category("unicast_only")]
+ [Category("generics")]
+ internal class ThinClientAppDomainQueryTests : 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 endpoint1;
+ private static string endpoint2;
+
+ #endregion Private members
+
+ protected override ClientBase[] GetClients()
+ {
+ return new ClientBase[] { };
+ }
+
+ [TestFixtureSetUp]
+ public override void InitTests()
+ {
+ Properties<string, string> config = new Properties<string, string>();
+ config.Insert("appdomain-enabled", "true");
+ CacheHelper.InitConfig(config);
+ }
+
+
+ [TearDown]
+ public override void EndTest()
+ {
+ CacheHelper.StopJavaServers();
+ base.EndTest();
+ }
+
+ #region Functions invoked by the tests
+
+ public void InitClient()
+ {
+ Serializable.RegisterTypeGeneric(Portfolio.CreateDeserializable, CacheHelper.DCache);
+ Serializable.RegisterTypeGeneric(Position.CreateDeserializable, CacheHelper.DCache);
+ Serializable.RegisterPdxType(Apache.Geode.Client.Tests.PortfolioPdx.CreateDeserializable);
+ Serializable.RegisterPdxType(Apache.Geode.Client.Tests.PositionPdx.CreateDeserializable);
+ }
+
+ public void CreateCache(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]);
+ Apache.Geode.Client.RegionAttributes<object, object> regattrs = region.Attributes;
+ region.CreateSubRegion(QueryRegionNames[1], regattrs);
+ }
+
+ public void PopulateRegions()
+ {
+ IRegion<object, object> region0 = CacheHelper.GetRegion<object, object>(QueryRegionNames[0]);
+ IRegion<object, object> subRegion0 = (IRegion<object, object>)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(CacheHelper.DCache);
+ Util.Log("SetSize {0}, NumSets {1}.", qh.PortfolioSetSize,
+ qh.PortfolioNumSets);
+
+ qh.PopulatePortfolioPdxData(region0, qh.PortfolioSetSize,
+ qh.PortfolioNumSets);
+ qh.PopulatePositionPdxData(subRegion0, qh.PortfolioSetSize,
+ qh.PortfolioNumSets);
+ qh.PopulatePositionPdxData(region1, qh.PortfolioSetSize,
+ qh.PortfolioNumSets);
+ qh.PopulatePortfolioPdxData(region2, qh.PortfolioSetSize,
+ qh.PortfolioNumSets);
+ qh.PopulatePortfolioPdxData(region3, qh.PortfolioSetSize,
+ qh.PortfolioNumSets);
+ }
+
+ public void VerifyQueries()
+ {
+ bool ErrorOccurred = false;
+
+ QueryHelper<object, object> qh = QueryHelper<object, object>.GetHelper(CacheHelper.DCache);
+
+ QueryService<object, object> qs = CacheHelper.DCache.GetPoolManager().Find("__TESTPOOL1_").GetQueryService<object, object>();
+
+ int qryIdx = 0;
+
+ foreach (QueryStrings qrystr in QueryStatics.ResultSetQueries)
+ {
+ if (qrystr.Category == QueryCategory.Unsupported)
+ {
+ Util.Log("Skipping query index {0} because it is unsupported.", qryIdx);
+ qryIdx++;
+ continue;
+ }
+
+ if (qryIdx == 2 || qryIdx == 3 || qryIdx == 4)
+ {
+ Util.Log("Skipping query index {0} for Pdx because it is function type.", qryIdx);
+ qryIdx++;
+ continue;
+ }
+
+ Util.Log("Evaluating query index {0}. Query string {1}", qryIdx, qrystr.Query);
+
+ Query<object> query = qs.NewQuery(qrystr.Query);
+
+ ISelectResults<object> results = query.Execute();
+
+ int expectedRowCount = qh.IsExpectedRowsConstantRS(qryIdx) ?
+ QueryStatics.ResultSetRowCounts[qryIdx] : QueryStatics.ResultSetRowCounts[qryIdx] * qh.PortfolioNumSets;
+
+ if (!qh.VerifyRS(results, expectedRowCount))
+ {
+ ErrorOccurred = true;
+ Util.Log("Query verify failed for query index {0}.", qryIdx);
+ qryIdx++;
+ continue;
+ }
+
+ ResultSet<object> rs = results as ResultSet<object>;
+
+ foreach (object item in rs)
+ {
+ PortfolioPdx port = item as PortfolioPdx;
+ if (port == null)
+ {
+ PositionPdx pos = item as PositionPdx;
+ if (pos == null)
+ {
+ string cs = item.ToString();
+ if (cs == 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.getSharesOutstanding);
+ }
+ }
+ else
+ {
+ Util.Log("Query got Portfolio object with ID {0}, pkid {1}.", port.ID, port.Pkid);
+ }
+ }
+
+ qryIdx++;
+ }
+
+ Assert.IsFalse(ErrorOccurred, "One or more query validation errors occurred.");
+ }
+
+ public void VerifyUnsupporteQueries()
+ {
+ bool ErrorOccurred = false;
+
+ QueryHelper<object, object> qh = QueryHelper<object, object>.GetHelper(CacheHelper.DCache);
+
+ QueryService<object, object> qs = CacheHelper.DCache.GetPoolManager().Find("__TESTPOOL1_").GetQueryService<object, object>();
+
+ int qryIdx = 0;
+
+ foreach (QueryStrings qrystr in QueryStatics.ResultSetQueries)
+ {
+ if (qrystr.Category != QueryCategory.Unsupported)
+ {
+ qryIdx++;
+ continue;
+ }
+
+ Util.Log("Evaluating unsupported query index {0}.", qryIdx);
+
+ Query<object> query = qs.NewQuery(qrystr.Query);
+
+ try
+ {
+ ISelectResults<object> results = query.Execute();
+
+ Util.Log("Query exception did not occur for index {0}.", qryIdx);
+ ErrorOccurred = true;
+ qryIdx++;
+ }
+ catch (GeodeException)
+ {
+ // ok, exception expected, do nothing.
+ qryIdx++;
+ }
+ catch (Exception)
+ {
+ Util.Log("Query unexpected exception occurred for index {0}.", qryIdx);
+ ErrorOccurred = true;
+ qryIdx++;
+ }
+ }
+
+ Assert.IsFalse(ErrorOccurred, "Query expected exceptions did not occur.");
+ }
+
+ #endregion Functions invoked by the tests
+
+ [Test]
+ public void RemoteQueryRS()
+ {
+ Util.Log("DoRemoteQueryRS: AppDomain: " + AppDomain.CurrentDomain.Id);
+ CacheHelper.SetupJavaServers(true, "remotequeryN.xml");
+ CacheHelper.StartJavaLocator(1, "GFELOC");
+ Util.Log("Locator started");
+ CacheHelper.StartJavaServerWithLocators(1, "GFECS1", 1);
+ Util.Log("Cacheserver 1 started.");
+
+ CreateCache(CacheHelper.Locators);
+ Util.Log("CreateCache complete.");
+
+ PopulateRegions();
+ Util.Log("PopulateRegions complete.");
+
+ VerifyQueries();
+ Util.Log("VerifyQueries complete.");
+
+ VerifyUnsupporteQueries();
+ Util.Log("VerifyUnsupporteQueries complete.");
+
+ Close();
+
+ CacheHelper.StopJavaServer(1);
+ Util.Log("Cacheserver 1 stopped.");
+
+ CacheHelper.StopJavaLocator(1);
+ Util.Log("Locator stopped");
+ }
+ }
+}
http://git-wip-us.apache.org/repos/asf/geode-native/blob/6cbd424f/clicache/integration-test/ThinClientCSTXN.cs
----------------------------------------------------------------------
diff --git a/clicache/integration-test/ThinClientCSTXN.cs b/clicache/integration-test/ThinClientCSTXN.cs
new file mode 100644
index 0000000..211a52c
--- /dev/null
+++ b/clicache/integration-test/ThinClientCSTXN.cs
@@ -0,0 +1,827 @@
+/*
+ * 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;
+using System.Collections.Generic;
+
+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>;
+ using Apache.Geode.Client.Tests;
+ #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");
+ }
+ }
+}