| /* |
| * 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.Collections; |
| using PdxTests; |
| using System.Reflection; |
| |
| namespace Apache.Geode.Client.UnitTests |
| { |
| using NUnit.Framework; |
| using DUnitFramework; |
| using Client; |
| using Region = IRegion<object, object>; |
| |
| [TestFixture] |
| [Category("group4")] |
| [Category("unicast_only")] |
| [Category("generics")] |
| internal class ThinClientPdxTests1 : ThinClientRegionSteps |
| { |
| #region Private members |
| |
| private UnitProcess m_client1, m_client2; |
| |
| #endregion |
| |
| protected override ClientBase[] GetClients() |
| { |
| m_client1 = new UnitProcess(); |
| m_client2 = new UnitProcess(); |
| return new ClientBase[] {m_client1, m_client2}; |
| } |
| |
| [TestFixtureTearDown] |
| public override void EndTests() |
| { |
| CacheHelper.StopJavaServers(); |
| base.EndTests(); |
| } |
| |
| [TearDown] |
| public override void EndTest() |
| { |
| try |
| { |
| m_client1.Call(DestroyRegions); |
| m_client2.Call(DestroyRegions); |
| CacheHelper.ClearEndpoints(); |
| CacheHelper.ClearLocators(); |
| } |
| finally |
| { |
| CacheHelper.StopJavaServers(); |
| CacheHelper.StopJavaLocators(); |
| } |
| |
| base.EndTest(); |
| } |
| |
| private void cleanup() |
| { |
| { |
| CacheHelper.SetExtraPropertiesFile(null); |
| if (m_clients != null) |
| { |
| foreach (var client in m_clients) |
| { |
| try |
| { |
| client.Call(CacheHelper.Close); |
| } |
| catch (System.Runtime.Remoting.RemotingException) |
| { |
| } |
| catch (System.Net.Sockets.SocketException) |
| { |
| } |
| } |
| } |
| |
| CacheHelper.Close(); |
| } |
| } |
| |
| private void PutAndVerifyPdxInGet() |
| { |
| CacheHelper.DCache.TypeRegistry.RegisterPdxType(PdxType.CreateDeserializable); |
| |
| var region0 = CacheHelper.GetVerifyRegion<object, object>(m_regionNames[0]); |
| |
| region0[1] = new PdxType(); |
| |
| var pRet = (PdxType) region0[1]; |
| checkPdxInstanceToStringAtServer(region0); |
| |
| Assert.AreEqual(CacheHelper.DCache.GetPdxReadSerialized(), false, |
| "Pdx read serialized property should be false."); |
| } |
| |
| private void VerifyGetOnly() |
| { |
| CacheHelper.DCache.TypeRegistry.RegisterPdxType(PdxType.CreateDeserializable); |
| |
| var region0 = CacheHelper.GetVerifyRegion<object, object>(m_regionNames[0]); |
| |
| var pRet = (PdxType) region0[1]; |
| checkPdxInstanceToStringAtServer(region0); |
| } |
| |
| private void PutAndVerifyVariousPdxTypes() |
| { |
| var typeRegistry = CacheHelper.DCache.TypeRegistry; |
| typeRegistry.RegisterPdxType(PdxTypes1.CreateDeserializable); |
| typeRegistry.RegisterPdxType(PdxTypes2.CreateDeserializable); |
| typeRegistry.RegisterPdxType(PdxTypes3.CreateDeserializable); |
| typeRegistry.RegisterPdxType(PdxTypes4.CreateDeserializable); |
| typeRegistry.RegisterPdxType(PdxTypes5.CreateDeserializable); |
| typeRegistry.RegisterPdxType(PdxTypes6.CreateDeserializable); |
| typeRegistry.RegisterPdxType(PdxTypes7.CreateDeserializable); |
| typeRegistry.RegisterPdxType(PdxTypes8.CreateDeserializable); |
| typeRegistry.RegisterPdxType(PdxTypes9.CreateDeserializable); |
| typeRegistry.RegisterPdxType(PortfolioPdx.CreateDeserializable); |
| typeRegistry.RegisterPdxType(PositionPdx.CreateDeserializable); |
| typeRegistry.RegisterPdxType(AllPdxTypes.Create); |
| |
| |
| var region0 = CacheHelper.GetVerifyRegion<object, object>(m_regionNames[0]); |
| |
| { |
| var p1 = new PdxTypes1(); |
| region0[11] = p1; |
| var pRet = (PdxTypes1) region0[11]; |
| Assert.AreEqual(p1, pRet); |
| checkPdxInstanceToStringAtServer(region0); |
| } |
| |
| { |
| var p2 = new PdxTypes2(); |
| region0[12] = p2; |
| var pRet2 = (PdxTypes2) region0[12]; |
| Assert.AreEqual(p2, pRet2); |
| checkPdxInstanceToStringAtServer(region0); |
| } |
| |
| { |
| var p3 = new PdxTypes3(); |
| region0[13] = p3; |
| var pRet3 = (PdxTypes3) region0[13]; |
| Assert.AreEqual(p3, pRet3); |
| checkPdxInstanceToStringAtServer(region0); |
| } |
| |
| { |
| var p4 = new PdxTypes4(); |
| region0[14] = p4; |
| var pRet4 = (PdxTypes4) region0[14]; |
| Assert.AreEqual(p4, pRet4); |
| checkPdxInstanceToStringAtServer(region0); |
| } |
| |
| { |
| var p5 = new PdxTypes5(); |
| region0[15] = p5; |
| var pRet5 = (PdxTypes5) region0[15]; |
| Assert.AreEqual(p5, pRet5); |
| checkPdxInstanceToStringAtServer(region0); |
| } |
| |
| { |
| var p6 = new PdxTypes6(); |
| region0[16] = p6; |
| var pRet6 = (PdxTypes6) region0[16]; |
| Assert.AreEqual(p6, pRet6); |
| checkPdxInstanceToStringAtServer(region0); |
| } |
| |
| { |
| var p7 = new PdxTypes7(); |
| region0[17] = p7; |
| var pRet7 = (PdxTypes7) region0[17]; |
| Assert.AreEqual(p7, pRet7); |
| checkPdxInstanceToStringAtServer(region0); |
| } |
| |
| { |
| var p8 = new PdxTypes8(); |
| region0[18] = p8; |
| var pRet8 = (PdxTypes8) region0[18]; |
| Assert.AreEqual(p8, pRet8); |
| checkPdxInstanceToStringAtServer(region0); |
| } |
| { |
| var p9 = new PdxTypes9(); |
| region0[19] = p9; |
| var pRet9 = (PdxTypes9) region0[19]; |
| Assert.AreEqual(p9, pRet9); |
| checkPdxInstanceToStringAtServer(region0); |
| } |
| |
| { |
| var pf = new PortfolioPdx(1001, 10); |
| region0[20] = pf; |
| var retpf = (PortfolioPdx) region0[20]; |
| checkPdxInstanceToStringAtServer(region0); |
| //Assert.AreEqual(p9, pRet9); |
| } |
| |
| { |
| var pf = new PortfolioPdx(1001, 10, new string[] {"one", "two", "three"}); |
| region0[21] = pf; |
| var retpf = (PortfolioPdx) region0[21]; |
| checkPdxInstanceToStringAtServer(region0); |
| //Assert.AreEqual(p9, pRet9); |
| } |
| { |
| var p10 = new PdxTypes10(); |
| region0[22] = p10; |
| var pRet10 = (PdxTypes10) region0[22]; |
| Assert.AreEqual(p10, pRet10); |
| checkPdxInstanceToStringAtServer(region0); |
| } |
| { |
| var apt = new AllPdxTypes(true); |
| region0[23] = apt; |
| var aptRet = (AllPdxTypes) region0[23]; |
| Assert.AreEqual(apt, aptRet); |
| checkPdxInstanceToStringAtServer(region0); |
| } |
| } |
| |
| private void VerifyVariousPdxGets() |
| { |
| var typeRegistry = CacheHelper.DCache.TypeRegistry; |
| typeRegistry.RegisterPdxType(PdxTypes1.CreateDeserializable); |
| typeRegistry.RegisterPdxType(PdxTypes2.CreateDeserializable); |
| typeRegistry.RegisterPdxType(PdxTypes3.CreateDeserializable); |
| typeRegistry.RegisterPdxType(PdxTypes4.CreateDeserializable); |
| typeRegistry.RegisterPdxType(PdxTypes5.CreateDeserializable); |
| typeRegistry.RegisterPdxType(PdxTypes6.CreateDeserializable); |
| typeRegistry.RegisterPdxType(PdxTypes7.CreateDeserializable); |
| typeRegistry.RegisterPdxType(PdxTypes8.CreateDeserializable); |
| typeRegistry.RegisterPdxType(PdxTypes9.CreateDeserializable); |
| typeRegistry.RegisterPdxType(PortfolioPdx.CreateDeserializable); |
| typeRegistry.RegisterPdxType(PositionPdx.CreateDeserializable); |
| typeRegistry.RegisterPdxType(AllPdxTypes.Create); |
| |
| var region0 = CacheHelper.GetVerifyRegion<object, object>(m_regionNames[0]); |
| |
| { |
| var p1 = new PdxTypes1(); |
| var pRet = (PdxTypes1) region0[11]; |
| Assert.AreEqual(p1, pRet); |
| checkPdxInstanceToStringAtServer(region0); |
| } |
| |
| { |
| var p2 = new PdxTypes2(); |
| var pRet2 = (PdxTypes2) region0[12]; |
| Assert.AreEqual(p2, pRet2); |
| checkPdxInstanceToStringAtServer(region0); |
| } |
| |
| { |
| var p3 = new PdxTypes3(); |
| var pRet3 = (PdxTypes3) region0[13]; |
| Assert.AreEqual(p3, pRet3); |
| checkPdxInstanceToStringAtServer(region0); |
| } |
| |
| { |
| var p4 = new PdxTypes4(); |
| var pRet4 = (PdxTypes4) region0[14]; |
| Assert.AreEqual(p4, pRet4); |
| checkPdxInstanceToStringAtServer(region0); |
| } |
| |
| { |
| var p5 = new PdxTypes5(); |
| var pRet5 = (PdxTypes5) region0[15]; |
| Assert.AreEqual(p5, pRet5); |
| checkPdxInstanceToStringAtServer(region0); |
| } |
| |
| { |
| var p6 = new PdxTypes6(); |
| var pRet6 = (PdxTypes6) region0[16]; |
| Assert.AreEqual(p6, pRet6); |
| checkPdxInstanceToStringAtServer(region0); |
| } |
| |
| { |
| var p7 = new PdxTypes7(); |
| var pRet7 = (PdxTypes7) region0[17]; |
| Assert.AreEqual(p7, pRet7); |
| checkPdxInstanceToStringAtServer(region0); |
| } |
| |
| { |
| var p8 = new PdxTypes8(); |
| var pRet8 = (PdxTypes8) region0[18]; |
| Assert.AreEqual(p8, pRet8); |
| checkPdxInstanceToStringAtServer(region0); |
| } |
| { |
| var p9 = new PdxTypes9(); |
| var pRet9 = (PdxTypes9) region0[19]; |
| Assert.AreEqual(p9, pRet9); |
| checkPdxInstanceToStringAtServer(region0); |
| } |
| { |
| var retpf = (PortfolioPdx) region0[20]; |
| checkPdxInstanceToStringAtServer(region0); |
| } |
| { |
| var retpf = (PortfolioPdx) region0[21]; |
| checkPdxInstanceToStringAtServer(region0); |
| } |
| { |
| var p10 = new PdxTypes10(); |
| var pRet10 = (PdxTypes10) region0[22]; |
| Assert.AreEqual(p10, pRet10); |
| checkPdxInstanceToStringAtServer(region0); |
| } |
| { |
| var apt = new AllPdxTypes(true); |
| var aptRet = (AllPdxTypes) region0[23]; |
| Assert.AreEqual(apt, aptRet); |
| checkPdxInstanceToStringAtServer(region0); |
| } |
| } |
| |
| private void checkPdxInstanceToStringAtServer(Region region) |
| { |
| var retVal = (bool) region["success"]; |
| Assert.IsTrue(retVal); |
| } |
| |
| private void runPdxDistOps() |
| { |
| CacheHelper.SetupJavaServers(true, "cacheserverPdx.xml"); |
| CacheHelper.StartJavaLocator(1, "GFELOC"); |
| Util.Log("Locator 1 started."); |
| CacheHelper.StartJavaServerWithLocators(1, "GFECS1", 1); |
| Util.Log("Cacheserver 1 started."); |
| |
| m_client1.Call(CreateTCRegions_Pool, RegionNames, |
| CacheHelper.Locators, "__TESTPOOL1_", false, false, false /*local caching false*/); |
| Util.Log("StepOne (pool locators) complete."); |
| |
| m_client2.Call(CreateTCRegions_Pool, RegionNames, |
| CacheHelper.Locators, "__TESTPOOL1_", false, false, false /*local caching false*/); |
| Util.Log("StepTwo (pool locators) complete."); |
| |
| m_client1.Call(PutAndVerifyPdxInGet); |
| Util.Log("StepThree complete."); |
| |
| m_client2.Call(VerifyGetOnly); |
| Util.Log("StepFour complete."); |
| |
| m_client1.Call(PutAndVerifyVariousPdxTypes); |
| Util.Log("StepFive complete."); |
| |
| m_client2.Call(VerifyVariousPdxGets); |
| Util.Log("StepSeven complete."); |
| |
| m_client1.Call(Close); |
| Util.Log("Client 1 closed"); |
| m_client2.Call(Close); |
| //Util.Log("Client 2 closed"); |
| |
| CacheHelper.StopJavaServer(1); |
| Util.Log("Cacheserver 1 stopped."); |
| |
| CacheHelper.StopJavaLocator(1); |
| Util.Log("Locator 1 stopped."); |
| |
| CacheHelper.ClearEndpoints(); |
| CacheHelper.ClearLocators(); |
| } |
| |
| private void VerifyDataOutputAdvance() |
| { |
| CacheHelper.DCache.TypeRegistry.RegisterPdxType(MyClass.Create); |
| CacheHelper.DCache.TypeRegistry.RegisterPdxType(MyClasses.Create); |
| |
| var region0 = CacheHelper.GetVerifyRegion<object, object>(m_regionNames[0]); |
| |
| var mcs = new MyClasses("1", 1000); |
| |
| region0[1] = mcs; |
| |
| var ret = region0[1]; |
| |
| Assert.AreEqual(mcs, ret); |
| } |
| |
| private void runPdxDistOps2() |
| { |
| CacheHelper.SetupJavaServers(true, "cacheserverPdxSerializer.xml"); |
| CacheHelper.StartJavaLocator(1, "GFELOC"); |
| Util.Log("Locator 1 started."); |
| CacheHelper.StartJavaServerWithLocators(1, "GFECS1", 1); |
| Util.Log("Cacheserver 1 started."); |
| |
| m_client1.Call(CreateTCRegions_Pool, RegionNames, |
| CacheHelper.Locators, "__TESTPOOL1_", false, false, false /*local caching false*/); |
| Util.Log("StepOne (pool locators) complete."); |
| |
| m_client2.Call(CreateTCRegions_Pool, RegionNames, |
| CacheHelper.Locators, "__TESTPOOL1_", false, false, false /*local caching false*/); |
| Util.Log("StepTwo (pool locators) complete."); |
| |
| |
| m_client1.Call(VerifyDataOutputAdvance); |
| Util.Log("StepThree complete."); |
| |
| |
| m_client1.Call(Close); |
| Util.Log("Client 1 closed"); |
| m_client2.Call(Close); |
| //Util.Log("Client 2 closed"); |
| |
| CacheHelper.StopJavaServer(1); |
| Util.Log("Cacheserver 1 stopped."); |
| |
| CacheHelper.StopJavaLocator(1); |
| Util.Log("Locator 1 stopped."); |
| |
| CacheHelper.ClearEndpoints(); |
| CacheHelper.ClearLocators(); |
| } |
| |
| private void PutAndVerifyNestedPdxInGet() |
| { |
| CacheHelper.DCache.TypeRegistry.RegisterPdxType(NestedPdx.CreateDeserializable); |
| CacheHelper.DCache.TypeRegistry.RegisterPdxType(PdxTypes1.CreateDeserializable); |
| CacheHelper.DCache.TypeRegistry.RegisterPdxType(PdxTypes2.CreateDeserializable); |
| CacheHelper.DCache.TypeRegistry.RegisterPdxType(PdxTypes3.CreateDeserializable); |
| CacheHelper.DCache.TypeRegistry.RegisterPdxType(PdxTypes4.CreateDeserializable); |
| CacheHelper.DCache.TypeRegistry.RegisterPdxType(PdxTypes5.CreateDeserializable); |
| CacheHelper.DCache.TypeRegistry.RegisterPdxType(PdxTypes6.CreateDeserializable); |
| CacheHelper.DCache.TypeRegistry.RegisterPdxType(PdxTypes7.CreateDeserializable); |
| CacheHelper.DCache.TypeRegistry.RegisterPdxType(PdxTypes8.CreateDeserializable); |
| |
| var region0 = CacheHelper.GetVerifyRegion<object, object>(m_regionNames[0]); |
| var np = new NestedPdx(); |
| region0[1] = np; |
| |
| var pRet = (NestedPdx) region0[1]; |
| |
| Assert.AreEqual(np, pRet); |
| } |
| |
| private void VerifyNestedGetOnly() |
| { |
| CacheHelper.DCache.TypeRegistry.RegisterPdxType(NestedPdx.CreateDeserializable); |
| CacheHelper.DCache.TypeRegistry.RegisterPdxType(PdxTypes1.CreateDeserializable); |
| CacheHelper.DCache.TypeRegistry.RegisterPdxType(PdxTypes2.CreateDeserializable); |
| CacheHelper.DCache.TypeRegistry.RegisterPdxType(PdxTypes3.CreateDeserializable); |
| CacheHelper.DCache.TypeRegistry.RegisterPdxType(PdxTypes4.CreateDeserializable); |
| CacheHelper.DCache.TypeRegistry.RegisterPdxType(PdxTypes5.CreateDeserializable); |
| CacheHelper.DCache.TypeRegistry.RegisterPdxType(PdxTypes6.CreateDeserializable); |
| CacheHelper.DCache.TypeRegistry.RegisterPdxType(PdxTypes7.CreateDeserializable); |
| CacheHelper.DCache.TypeRegistry.RegisterPdxType(PdxTypes8.CreateDeserializable); |
| |
| |
| var region0 = CacheHelper.GetVerifyRegion<object, object>(m_regionNames[0]); |
| |
| var orig = new NestedPdx(); |
| var pRet = (NestedPdx) region0[1]; |
| |
| Assert.AreEqual(orig, pRet); |
| } |
| |
| private void runNestedPdxOps() |
| { |
| CacheHelper.SetupJavaServers(true, "cacheserver.xml"); |
| CacheHelper.StartJavaLocator(1, "GFELOC"); |
| Util.Log("Locator 1 started."); |
| CacheHelper.StartJavaServerWithLocators(1, "GFECS1", 1); |
| Util.Log("Cacheserver 1 started."); |
| |
| m_client1.Call(CreateTCRegions_Pool, RegionNames, |
| CacheHelper.Locators, "__TESTPOOL1_", false, false, false /*local caching false*/); |
| Util.Log("StepOne (pool locators) complete."); |
| |
| m_client2.Call(CreateTCRegions_Pool, RegionNames, |
| CacheHelper.Locators, "__TESTPOOL1_", false, false, false /*local caching false*/); |
| Util.Log("StepTwo (pool locators) complete."); |
| |
| |
| m_client1.Call(PutAndVerifyNestedPdxInGet); |
| Util.Log("StepThree complete."); |
| |
| m_client2.Call(VerifyNestedGetOnly); |
| Util.Log("StepFour complete."); |
| |
| m_client1.Call(Close); |
| Util.Log("Client 1 closed"); |
| m_client2.Call(Close); |
| //Util.Log("Client 2 closed"); |
| |
| CacheHelper.StopJavaServer(1); |
| Util.Log("Cacheserver 1 stopped."); |
| |
| CacheHelper.StopJavaLocator(1); |
| Util.Log("Locator 1 stopped."); |
| |
| CacheHelper.ClearEndpoints(); |
| CacheHelper.ClearLocators(); |
| } |
| |
| private void PutAndVerifyPdxInIGFSInGet() |
| { |
| try |
| { |
| CacheHelper.DCache.TypeRegistry.RegisterType(PdxInsideIGeodeSerializable.CreateDeserializable, 5005); |
| CacheHelper.DCache.TypeRegistry.RegisterPdxType(NestedPdx.CreateDeserializable); |
| CacheHelper.DCache.TypeRegistry.RegisterPdxType(PdxTypes1.CreateDeserializable); |
| CacheHelper.DCache.TypeRegistry.RegisterPdxType(PdxTypes2.CreateDeserializable); |
| CacheHelper.DCache.TypeRegistry.RegisterPdxType(PdxTypes3.CreateDeserializable); |
| CacheHelper.DCache.TypeRegistry.RegisterPdxType(PdxTypes4.CreateDeserializable); |
| CacheHelper.DCache.TypeRegistry.RegisterPdxType(PdxTypes5.CreateDeserializable); |
| CacheHelper.DCache.TypeRegistry.RegisterPdxType(PdxTypes6.CreateDeserializable); |
| CacheHelper.DCache.TypeRegistry.RegisterPdxType(PdxTypes7.CreateDeserializable); |
| CacheHelper.DCache.TypeRegistry.RegisterPdxType(PdxTypes8.CreateDeserializable); |
| } |
| catch (Exception) |
| { |
| } |
| |
| var region0 = CacheHelper.GetVerifyRegion<object, object>(m_regionNames[0]); |
| var np = new PdxInsideIGeodeSerializable(); |
| region0[1] = np; |
| |
| var pRet = (PdxInsideIGeodeSerializable) region0[1]; |
| |
| Assert.AreEqual(np, pRet); |
| } |
| |
| private void VerifyPdxInIGFSGetOnly() |
| { |
| try |
| { |
| CacheHelper.DCache.TypeRegistry.RegisterType(PdxInsideIGeodeSerializable.CreateDeserializable, 5005); |
| CacheHelper.DCache.TypeRegistry.RegisterPdxType(NestedPdx.CreateDeserializable); |
| CacheHelper.DCache.TypeRegistry.RegisterPdxType(PdxTypes1.CreateDeserializable); |
| CacheHelper.DCache.TypeRegistry.RegisterPdxType(PdxTypes2.CreateDeserializable); |
| CacheHelper.DCache.TypeRegistry.RegisterPdxType(PdxTypes3.CreateDeserializable); |
| CacheHelper.DCache.TypeRegistry.RegisterPdxType(PdxTypes4.CreateDeserializable); |
| CacheHelper.DCache.TypeRegistry.RegisterPdxType(PdxTypes5.CreateDeserializable); |
| CacheHelper.DCache.TypeRegistry.RegisterPdxType(PdxTypes6.CreateDeserializable); |
| CacheHelper.DCache.TypeRegistry.RegisterPdxType(PdxTypes7.CreateDeserializable); |
| CacheHelper.DCache.TypeRegistry.RegisterPdxType(PdxTypes8.CreateDeserializable); |
| } |
| catch (Exception) |
| { |
| } |
| |
| |
| var region0 = CacheHelper.GetVerifyRegion<object, object>(m_regionNames[0]); |
| |
| var orig = new PdxInsideIGeodeSerializable(); |
| var pRet = (PdxInsideIGeodeSerializable) region0[1]; |
| |
| Assert.AreEqual(orig, pRet); |
| } |
| |
| private void runPdxInIGFSOps() |
| { |
| CacheHelper.SetupJavaServers(true, "cacheserver.xml"); |
| CacheHelper.StartJavaLocator(1, "GFELOC"); |
| Util.Log("Locator 1 started."); |
| CacheHelper.StartJavaServerWithLocators(1, "GFECS1", 1); |
| Util.Log("Cacheserver 1 started."); |
| |
| m_client1.Call(CreateTCRegions_Pool, RegionNames, |
| CacheHelper.Locators, "__TESTPOOL1_", false, false, false /*local caching false*/); |
| Util.Log("StepOne (pool locators) complete."); |
| |
| m_client2.Call(CreateTCRegions_Pool, RegionNames, |
| CacheHelper.Locators, "__TESTPOOL1_", false, false, false /*local caching false*/); |
| Util.Log("StepTwo (pool locators) complete."); |
| |
| m_client1.Call(PutAndVerifyPdxInIGFSInGet); |
| Util.Log("StepThree complete."); |
| |
| m_client2.Call(VerifyPdxInIGFSGetOnly); |
| Util.Log("StepFour complete."); |
| |
| m_client1.Call(Close); |
| Util.Log("Client 1 closed"); |
| m_client2.Call(Close); |
| //Util.Log("Client 2 closed"); |
| |
| CacheHelper.StopJavaServer(1); |
| Util.Log("Cacheserver 1 stopped."); |
| |
| CacheHelper.StopJavaLocator(1); |
| Util.Log("Locator 1 stopped."); |
| |
| CacheHelper.ClearEndpoints(); |
| CacheHelper.ClearLocators(); |
| } |
| |
| private void JavaPutGet_LinedListType() |
| { |
| var region0 = CacheHelper.GetVerifyRegion<object, object>(m_regionNames[0]); |
| |
| //Do some put to invike attached listener, |
| region0[1] = 123; |
| |
| //Get |
| var value = (int) region0[1]; |
| //Util.Log("JavaPutGet_LinedListType value received = " + value); |
| |
| //verify that listener methods have been called. |
| Assert.IsTrue((bool) region0["success"]); |
| |
| //LinkedList validation |
| var myList1 = new LinkedList<object>(); |
| myList1.AddFirst("Manan"); |
| myList1.AddLast("Nishka"); |
| |
| //get the JSON document (as PdxInstance) that has been put from java in attached cacheListener code. |
| var ret = (IPdxInstance) region0["jsondoc1"]; |
| var linkedList = (LinkedList<object>) ret.GetField("kids"); |
| |
| //verify sizes |
| Assert.AreEqual((linkedList.Count == myList1.Count), true, " LinkedList size should be equal."); |
| |
| var e1 = linkedList.GetEnumerator(); |
| var e2 = myList1.GetEnumerator(); |
| |
| //verify content of LinkedList |
| while (e1.MoveNext() && e2.MoveNext()) |
| { |
| //Util.Log("JavaPutGet_LinedListType Kids = " + e1.Current); |
| PdxType.GenericValCompare(e1.Current, e2.Current); |
| } |
| |
| Util.Log("successfully completed JavaPutGet_LinedListType"); |
| } |
| |
| private void JavaPutGet() |
| { |
| try |
| { |
| CacheHelper.DCache.TypeRegistry.RegisterPdxType(PdxType.CreateDeserializable); |
| } |
| catch (Exception) |
| { |
| } |
| |
| var region0 = CacheHelper.GetVerifyRegion<object, object>(m_regionNames[0]); |
| var np = new PdxType(); |
| region0[1] = np; |
| |
| var pRet = (PdxType) region0[1]; |
| |
| //Assert.AreEqual(np, pRet); |
| |
| Assert.IsTrue((bool) region0["success"]); |
| } |
| |
| private void JavaGet() |
| { |
| try |
| { |
| CacheHelper.DCache.TypeRegistry.RegisterPdxType(PdxType.CreateDeserializable); |
| } |
| catch (Exception) |
| { |
| } |
| |
| var region0 = CacheHelper.GetVerifyRegion<object, object>(m_regionNames[0]); |
| |
| var np = new PdxType(); |
| |
| var pRet = (PdxType) region0[1]; |
| |
| var putFromjava = (PdxType) region0["putFromjava"]; |
| } |
| |
| private void runJavaInterOpsWithLinkedListType() |
| { |
| CacheHelper.SetupJavaServers(true, "cacheserverForPdx.xml"); |
| CacheHelper.StartJavaLocator(1, "GFELOC"); |
| Util.Log("Locator 1 started."); |
| CacheHelper.StartJavaServerWithLocators(1, "GFECS1", 1); |
| Util.Log("Cacheserver 1 started."); |
| |
| m_client1.Call(CreateTCRegions_Pool_PDXWithLL, RegionNames, |
| CacheHelper.Locators, "__TESTPOOL1_", false, false, false /*local caching false*/); |
| Util.Log("Clinet-1 CreateTCRegions_Pool_PDXWithLL (pool with locator) completed."); |
| |
| m_client1.Call(JavaPutGet_LinedListType); |
| Util.Log("JavaPutGet_LinedListType complete."); |
| |
| |
| m_client1.Call(Close); |
| Util.Log("Client 1 closed"); |
| |
| CacheHelper.StopJavaServer(1); |
| Util.Log("Cacheserver 1 stopped."); |
| |
| CacheHelper.StopJavaLocator(1); |
| Util.Log("Locator 1 stopped."); |
| |
| CacheHelper.ClearEndpoints(); |
| CacheHelper.ClearLocators(); |
| } |
| |
| private void runJavaInteroperableOps() |
| { |
| CacheHelper.SetupJavaServers(true, "cacheserverForPdx.xml"); |
| CacheHelper.StartJavaLocator(1, "GFELOC"); |
| Util.Log("Locator 1 started."); |
| CacheHelper.StartJavaServerWithLocators(1, "GFECS1", 1); |
| Util.Log("Cacheserver 1 started."); |
| |
| m_client1.Call(CreateTCRegions_Pool, RegionNames, |
| CacheHelper.Locators, "__TESTPOOL1_", false, false, false /*local caching false*/); |
| Util.Log("StepOne (pool locators) complete."); |
| |
| m_client2.Call(CreateTCRegions_Pool, RegionNames, |
| CacheHelper.Locators, "__TESTPOOL1_", false, false, false /*local caching false*/); |
| Util.Log("StepTwo (pool locators) complete."); |
| |
| |
| m_client1.Call(JavaPutGet); |
| Util.Log("StepThree complete."); |
| |
| m_client2.Call(JavaGet); |
| Util.Log("StepFour complete."); |
| |
| m_client1.Call(Close); |
| Util.Log("Client 1 closed"); |
| m_client2.Call(Close); |
| //Util.Log("Client 2 closed"); |
| |
| CacheHelper.StopJavaServer(1); |
| Util.Log("Cacheserver 1 stopped."); |
| |
| CacheHelper.StopJavaLocator(1); |
| Util.Log("Locator 1 stopped."); |
| |
| CacheHelper.ClearEndpoints(); |
| CacheHelper.ClearLocators(); |
| } |
| |
| private void putallAndGetallPdx() |
| { |
| try |
| { |
| CacheHelper.DCache.TypeRegistry.RegisterType(PdxInsideIGeodeSerializable.CreateDeserializable, 5005); |
| CacheHelper.DCache.TypeRegistry.RegisterPdxType(NestedPdx.CreateDeserializable); |
| CacheHelper.DCache.TypeRegistry.RegisterPdxType(PdxTypes1.CreateDeserializable); |
| CacheHelper.DCache.TypeRegistry.RegisterPdxType(PdxTypes2.CreateDeserializable); |
| CacheHelper.DCache.TypeRegistry.RegisterPdxType(PdxTypes3.CreateDeserializable); |
| CacheHelper.DCache.TypeRegistry.RegisterPdxType(PdxTypes4.CreateDeserializable); |
| CacheHelper.DCache.TypeRegistry.RegisterPdxType(PdxTypes5.CreateDeserializable); |
| CacheHelper.DCache.TypeRegistry.RegisterPdxType(PdxTypes6.CreateDeserializable); |
| CacheHelper.DCache.TypeRegistry.RegisterPdxType(PdxTypes7.CreateDeserializable); |
| CacheHelper.DCache.TypeRegistry.RegisterPdxType(PdxTypes8.CreateDeserializable); |
| } |
| catch (Exception) |
| { |
| } |
| |
| var region0 = CacheHelper.GetVerifyRegion<object, object>(m_regionNames[0]); |
| IDictionary<object, object> all = new Dictionary<object, object>(); |
| |
| var p1 = new PdxTypes1(); |
| var p2 = new PdxTypes2(); |
| var p3 = new PdxTypes3(); |
| var p4 = new PdxTypes4(); |
| var p5 = new PdxTypes5(); |
| var p6 = new PdxTypes6(); |
| var p7 = new PdxTypes7(); |
| var p8 = new PdxTypes8(); |
| |
| all.Add(21, p1); |
| all.Add(22, p2); |
| all.Add(23, p3); |
| all.Add(24, p4); |
| all.Add(25, p5); |
| all.Add(26, p6); |
| all.Add(27, p7); |
| all.Add(28, p8); |
| region0.PutAll(all); |
| |
| |
| ICollection<object> keys = new List<object>(); |
| IDictionary<object, object> getall = new Dictionary<object, object>(); |
| |
| keys.Add(21); |
| keys.Add(22); |
| keys.Add(23); |
| keys.Add(24); |
| keys.Add(25); |
| keys.Add(26); |
| keys.Add(27); |
| keys.Add(28); |
| //keys.Add(p1); |
| //keys.Add(p2); |
| region0.GetAll(keys, getall, null); |
| foreach (var kv in all) |
| { |
| var key = kv.Key; |
| Util.Log("putall keys " + key.GetType() + " : " + key); |
| } |
| |
| //IEnumerator<KeyValuePair<object, object>> ie = getall.GetEnumerator(); |
| foreach (var kv in getall) |
| { |
| var key = kv.Key; |
| if (key != null) |
| Util.Log("got key " + key.GetType() + " : " + key); |
| else |
| Util.Log("got NULL key "); |
| var origVal = all[key]; |
| Assert.AreEqual(kv.Value, origVal); |
| } |
| } |
| |
| private void runPutAllGetAllOps() |
| { |
| CacheHelper.SetupJavaServers(true, "cacheserver.xml"); |
| CacheHelper.StartJavaLocator(1, "GFELOC"); |
| Util.Log("Locator 1 started."); |
| CacheHelper.StartJavaServerWithLocators(1, "GFECS1", 1); |
| Util.Log("Cacheserver 1 started."); |
| |
| m_client1.Call(CreateTCRegions_Pool, RegionNames, |
| CacheHelper.Locators, "__TESTPOOL1_", false, false, false /*local caching false*/); |
| Util.Log("StepOne (pool locators) complete."); |
| |
| m_client2.Call(CreateTCRegions_Pool, RegionNames, |
| CacheHelper.Locators, "__TESTPOOL1_", false, false, false /*local caching false*/); |
| Util.Log("StepTwo (pool locators) complete."); |
| |
| m_client1.Call(putallAndGetallPdx); |
| Util.Log("StepThree complete."); |
| |
| m_client2.Call(putallAndGetallPdx); |
| Util.Log("StepFour complete."); |
| |
| m_client1.Call(Close); |
| Util.Log("Client 1 closed"); |
| m_client2.Call(Close); |
| //Util.Log("Client 2 closed"); |
| |
| CacheHelper.StopJavaServer(1); |
| Util.Log("Cacheserver 1 stopped."); |
| |
| CacheHelper.StopJavaLocator(1); |
| Util.Log("Locator 1 stopped."); |
| |
| CacheHelper.ClearEndpoints(); |
| CacheHelper.ClearLocators(); |
| } |
| |
| #region Tests |
| |
| [Test] |
| public void DistOps() |
| { |
| runPdxDistOps(); |
| } |
| |
| [Test] |
| public void DistOps2() |
| { |
| runPdxDistOps2(); |
| } |
| |
| [Test] |
| public void NestedPdxOps() |
| { |
| runNestedPdxOps(); |
| } |
| |
| [Test] |
| public void PdxInIGFSOps() |
| { |
| runPdxInIGFSOps(); |
| } |
| |
| [Test] |
| public void JavaInteroperableOps() |
| { |
| runJavaInteroperableOps(); |
| } |
| |
| [Test] |
| public void JavaInterOpsWithLinkedListType() |
| { |
| runJavaInterOpsWithLinkedListType(); |
| } |
| |
| [Test] |
| public void PutAllGetAllOps() |
| { |
| runPutAllGetAllOps(); |
| } |
| |
| #endregion |
| } |
| |
| #region IpDxSerializer stuff |
| |
| public class SerializePdx : IPdxSerializable |
| { |
| [PdxIdentityField] public int i1; |
| public int i2; |
| public string s1; |
| public string s2; |
| |
| /*public static SerializePdx1 CreateDeserializable() |
| { |
| return new SerializePdx1(false); |
| }*/ |
| |
| //public SerializePdx() |
| //{ |
| //} |
| |
| public static SerializePdx Create() |
| { |
| return new SerializePdx(false); |
| } |
| |
| public SerializePdx(bool init) |
| { |
| if (init) |
| { |
| i1 = 1; |
| i2 = 2; |
| s1 = "s1"; |
| s2 = "s2"; |
| } |
| } |
| |
| public override bool Equals(object obj) |
| { |
| if (obj == null) |
| return false; |
| if (obj == this) |
| return true; |
| |
| var other = obj as SerializePdx; |
| |
| if (obj == null) |
| return false; |
| |
| if (i1 == other.i1 |
| && i2 == other.i2 |
| && s1 == other.s1 |
| && s2 == other.s2) |
| return true; |
| |
| return false; |
| } |
| |
| public override int GetHashCode() |
| { |
| return base.GetHashCode(); |
| } |
| |
| #region IPdxSerializable Members |
| |
| public void FromData(IPdxReader reader) |
| { |
| i1 = reader.ReadInt("i1"); |
| i2 = reader.ReadInt("i2"); |
| s1 = reader.ReadString("s1"); |
| s2 = reader.ReadString("s2"); |
| } |
| |
| public void ToData(IPdxWriter writer) |
| { |
| writer.WriteInt("i1", i1); |
| writer.MarkIdentityField("i1"); |
| writer.WriteInt("i2", i2); |
| writer.WriteString("s1", s1); |
| writer.MarkIdentityField("s1"); |
| writer.WriteString("s2", s2); |
| } |
| |
| #endregion |
| } |
| |
| public class SerializePdx1 |
| { |
| [PdxIdentityField] public int i1; |
| public int i2; |
| public string s1; |
| public string s2; |
| |
| /*public static SerializePdx1 CreateDeserializable() |
| { |
| return new SerializePdx1(false); |
| }*/ |
| |
| public SerializePdx1() |
| { |
| } |
| |
| public SerializePdx1(bool init) |
| { |
| if (init) |
| { |
| i1 = 1; |
| i2 = 2; |
| s1 = "s1"; |
| s2 = "s2"; |
| } |
| } |
| |
| public override bool Equals(object obj) |
| { |
| if (obj == null) |
| return false; |
| if (obj == this) |
| return true; |
| |
| var other = obj as SerializePdx1; |
| |
| if (other == null) |
| return false; |
| |
| if (i1 == other.i1 |
| && i2 == other.i2 |
| && s1 == other.s1 |
| && s2 == other.s2) |
| return true; |
| |
| return false; |
| } |
| |
| public override int GetHashCode() |
| { |
| return base.GetHashCode(); |
| } |
| } |
| |
| public class SerializePdx2 |
| { |
| public string s0; |
| [PdxIdentityField] public int i1; |
| public int i2; |
| public string s1; |
| public string s2; |
| |
| public SerializePdx2() |
| { |
| } |
| |
| public override string ToString() |
| { |
| return i1 + i2 + s1 + s2; |
| } |
| |
| public SerializePdx2(bool init) |
| { |
| if (init) |
| { |
| s0 = "s9999999999999999999999999999999999"; |
| i1 = 1; |
| i2 = 2; |
| s1 = "s1"; |
| s2 = "s2"; |
| } |
| } |
| |
| public override bool Equals(object obj) |
| { |
| if (obj == null) |
| return false; |
| if (obj == this) |
| return true; |
| |
| var other = obj as SerializePdx2; |
| |
| if (other == null) |
| return false; |
| |
| if (s0 == other.s0 |
| && i1 == other.i1 |
| && i2 == other.i2 |
| && s1 == other.s1 |
| && s2 == other.s2) |
| return true; |
| |
| return false; |
| } |
| |
| public override int GetHashCode() |
| { |
| return base.GetHashCode(); |
| } |
| } |
| |
| public class BaseClass |
| { |
| //private readonly int _b1 = 1000; |
| [NonSerialized] |
| //private int _nonserialized = 1001; |
| //private static int _static = 1002; |
| private const int _const = 1003; |
| |
| private int _baseclassmember; |
| |
| public BaseClass() |
| { |
| } |
| |
| public BaseClass(bool init) |
| { |
| if (init) |
| { |
| _baseclassmember = 101; |
| } |
| } |
| |
| public override bool Equals(object obj) |
| { |
| if (obj == null) |
| return false; |
| var bc = obj as BaseClass; |
| if (bc == null) |
| return false; |
| |
| if (bc == this) |
| return true; |
| |
| if (bc._baseclassmember == _baseclassmember) |
| { |
| return true; |
| } |
| |
| return false; |
| } |
| |
| public override int GetHashCode() |
| { |
| return base.GetHashCode(); |
| } |
| |
| public void ToData(IPdxWriter w) |
| { |
| w.WriteInt("_baseclassmember", _baseclassmember); |
| } |
| |
| public void FromData(IPdxReader r) |
| { |
| _baseclassmember = r.ReadInt("_baseclassmember"); |
| } |
| } |
| |
| public class Address |
| { |
| private static Guid oddGuid = new Guid("924243B5-9C2A-41d7-86B1-E0B905C7EED3"); |
| private static Guid evenGuid = new Guid("47AA8F17-FF6B-4a7d-B398-D83790977574"); |
| private string _street; |
| private string _aptName; |
| private int _flatNumber; |
| private Guid _guid; |
| |
| public Address() |
| { |
| } |
| |
| public Address(int id) |
| { |
| _flatNumber = id; |
| _aptName = id.ToString(); |
| _street = id.ToString() + "_street"; |
| if (id % 2 == 0) |
| _guid = evenGuid; |
| else |
| _guid = oddGuid; |
| } |
| |
| public override string ToString() |
| { |
| return _flatNumber + " " + _aptName + " " + _street + " " + _guid.ToString(); |
| } |
| |
| public override bool Equals(object obj) |
| { |
| if (obj == null) |
| return false; |
| var other = obj as Address; |
| |
| if (other == null) |
| return false; |
| |
| if (_street == other._street && |
| _aptName == other._aptName && |
| _flatNumber == other._flatNumber && |
| _guid.Equals(other._guid)) |
| return true; |
| |
| return false; |
| } |
| |
| public override int GetHashCode() |
| { |
| return base.GetHashCode(); |
| } |
| |
| public void ToData(IPdxWriter w) |
| { |
| w.WriteString("_street", _street); |
| w.WriteString("_aptName", _aptName); |
| w.WriteInt("_flatNumber", _flatNumber); |
| w.WriteString("_guid", _guid.ToString()); |
| } |
| |
| public void FromData(IPdxReader r) |
| { |
| _street = r.ReadString("_street"); |
| _aptName = r.ReadString("_aptName"); |
| _flatNumber = r.ReadInt("_flatNumber"); |
| var s = r.ReadString("_guid"); |
| _guid = new Guid(s); |
| } |
| } |
| |
| public class SerializePdx3 : BaseClass |
| { |
| private string s0; |
| [PdxIdentityField] private int i1; |
| public int i2; |
| public string s1; |
| public string s2; |
| private SerializePdx2 nestedObject; |
| private ArrayList _addressList; |
| private Address _address; |
| |
| private Hashtable _hashTable; |
| |
| //private int arrayCountS3= 10; |
| private List<object> _addressListObj; |
| //private Address[] _arrayOfAddress; |
| |
| public SerializePdx3() |
| : base() |
| { |
| } |
| |
| public SerializePdx3(bool init, int nAddress) |
| : base(init) |
| { |
| if (init) |
| { |
| s0 = "s9999999999999999999999999999999999"; |
| i1 = 1; |
| i2 = 2; |
| s1 = "s1"; |
| s2 = "s2"; |
| nestedObject = new SerializePdx2(true); |
| |
| _addressList = new ArrayList(); |
| _hashTable = new Hashtable(); |
| _addressListObj = new List<object>(); |
| |
| for (var i = 0; i < 10; i++) |
| { |
| _addressList.Add(new Address(i)); |
| _hashTable.Add(i, new SerializePdx2(true)); |
| _addressListObj.Add(new Address(i)); |
| } |
| |
| _address = new Address(nAddress); |
| |
| //_arrayOfAddress = new Address[3]; |
| |
| //for (int i = 0; i < 3; i++) |
| //{ |
| // _arrayOfAddress[i] = new Address(i); |
| //} |
| } |
| } |
| |
| public override bool Equals(object obj) |
| { |
| if (obj == null) |
| return false; |
| if (obj == this) |
| return true; |
| |
| var other = obj as SerializePdx3; |
| |
| if (other == null) |
| return false; |
| |
| if (s0 == other.s0 |
| && i1 == other.i1 |
| && i2 == other.i2 |
| && s1 == other.s1 |
| && s2 == other.s2) |
| { |
| var ret = nestedObject.Equals(other.nestedObject); |
| if (ret) |
| { |
| if (_addressList.Count == 10 && |
| _addressList.Count == other._addressList.Count //&& |
| //_arrayOfAddress.Length == other._arrayOfAddress.Length && |
| //_arrayOfAddress[0].Equals(other._arrayOfAddress[0]) |
| ) |
| { |
| for (var i = 0; i < _addressList.Count; i++) |
| { |
| ret = _addressList[i].Equals(other._addressList[i]); |
| if (!ret) |
| return false; |
| } |
| |
| if (_hashTable.Count != other._hashTable.Count) |
| return false; |
| foreach (DictionaryEntry de in _hashTable) |
| { |
| var otherHe = other._hashTable[de.Key]; |
| ret = de.Value.Equals(otherHe); |
| if (!ret) |
| return false; |
| } |
| |
| if (!_address.Equals(other._address)) |
| return false; |
| return base.Equals(other); |
| } |
| } |
| } |
| |
| return false; |
| } |
| |
| public override int GetHashCode() |
| { |
| return base.GetHashCode(); |
| } |
| |
| public new void ToData(IPdxWriter w) |
| { |
| base.ToData(w); |
| w.WriteString("s0", s0); |
| w.WriteInt("i1", i1); |
| w.WriteInt("i2", i2); |
| w.WriteString("s1", s1); |
| w.WriteString("s2", s2); |
| w.WriteObject("nestedObject", nestedObject); |
| w.WriteObject("_addressList", _addressList); |
| w.WriteObject("_address", _address); |
| w.WriteObject("_hashTable", _hashTable); |
| } |
| |
| public new void FromData(IPdxReader r) |
| { |
| base.FromData(r); |
| s0 = r.ReadString("s0"); |
| i1 = r.ReadInt("i1"); |
| i2 = r.ReadInt("i2"); |
| s1 = r.ReadString("s1"); |
| s2 = r.ReadString("s2"); |
| nestedObject = (SerializePdx2) r.ReadObject("nestedObject"); |
| _addressList = (ArrayList) r.ReadObject("_addressList"); |
| _address = (Address) r.ReadObject("_address"); |
| _hashTable = (Hashtable) r.ReadObject("_hashTable"); |
| } |
| } |
| |
| public class SerializePdx4 : BaseClass |
| { |
| private string s0; |
| [PdxIdentityField] private int i1; |
| public int i2; |
| public string s1; |
| public string s2; |
| private SerializePdx2 nestedObject; |
| private ArrayList _addressList; |
| |
| private Address[] _addressArray; |
| |
| //private int arrayCount = 10; |
| public SerializePdx4() |
| : base() |
| { |
| } |
| |
| public override string ToString() |
| { |
| return i1 + ":" + i2 + ":" + s1 + ":" + s2 + nestedObject.ToString() + " add: " + _addressList[0].ToString(); |
| } |
| |
| public SerializePdx4(bool init) |
| : base(init) |
| { |
| if (init) |
| { |
| s0 = "s9999999999999999999999999999999999"; |
| i1 = 1; |
| i2 = 2; |
| s1 = "s1"; |
| s2 = "s2"; |
| nestedObject = new SerializePdx2(true); |
| |
| _addressList = new ArrayList(); |
| _addressArray = new Address[10]; |
| |
| for (var i = 0; i < 10; i++) |
| { |
| _addressList.Add(new Address(i)); |
| _addressArray[i] = new Address(i); |
| } |
| } |
| } |
| |
| public override bool Equals(object obj) |
| { |
| if (obj == null) |
| return false; |
| if (obj == this) |
| return true; |
| |
| var other = obj as SerializePdx4; |
| |
| if (other == null) |
| return false; |
| |
| if (s0 == other.s0 |
| && i1 == other.i1 |
| && i2 == other.i2 |
| && s1 == other.s1 |
| && s2 == other.s2) |
| { |
| var ret = nestedObject.Equals(other.nestedObject); |
| if (ret) |
| { |
| if (_addressList.Count == other._addressList.Count && |
| _addressList[0].Equals(other._addressList[0])) |
| { |
| for (var i = 0; i < _addressList.Count; i++) |
| { |
| ret = _addressList[i].Equals(other._addressList[i]); |
| if (!ret) |
| return false; |
| } |
| |
| for (var i = 0; i < _addressArray.Length; i++) |
| { |
| ret = _addressArray[i].Equals(other._addressArray[i]); |
| if (!ret) |
| return false; |
| } |
| |
| return base.Equals(other); |
| } |
| } |
| } |
| |
| return false; |
| } |
| |
| public override int GetHashCode() |
| { |
| return base.GetHashCode(); |
| } |
| } |
| |
| public class PdxFieldTest |
| { |
| private string _notInclude = "default_value"; |
| private int _nameChange; |
| private int _identityField; |
| |
| public PdxFieldTest() |
| { |
| } |
| |
| public string NotInclude |
| { |
| set { _notInclude = "default_value"; } |
| } |
| |
| public PdxFieldTest(bool init) |
| { |
| if (init) |
| { |
| _notInclude = "valuechange"; |
| _nameChange = 11213; |
| _identityField = 1038193; |
| } |
| } |
| |
| public override bool Equals(object obj) |
| { |
| if (obj == null) |
| return false; |
| |
| var other = obj as PdxFieldTest; |
| |
| if (other == null) |
| return false; |
| |
| if (_notInclude == other._notInclude |
| && _nameChange == other._nameChange |
| && _identityField == other._identityField) |
| return true; |
| |
| |
| return false; |
| } |
| |
| public override int GetHashCode() |
| { |
| return base.GetHashCode(); |
| } |
| } |
| |
| public class PdxSerializer : IPdxSerializer |
| { |
| #region IPdxSerializer Members |
| |
| public object FromData(string className, IPdxReader reader) |
| { |
| var o = Activator.CreateInstance(Type.GetType(className)); |
| var obj = o as SerializePdx1; |
| |
| if (obj != null) |
| { |
| obj.i1 = reader.ReadInt("i1"); |
| obj.i2 = reader.ReadInt("i2"); |
| obj.s1 = reader.ReadString("s1"); |
| obj.s2 = reader.ReadString("s2"); |
| return o; |
| } |
| else |
| { |
| var obj2 = o as SerializePdx2; |
| if (obj2 != null) |
| { |
| obj2.s0 = reader.ReadString("s0"); |
| obj2.i1 = reader.ReadInt("i1"); |
| obj2.i2 = reader.ReadInt("i2"); |
| obj2.s1 = reader.ReadString("s1"); |
| obj2.s2 = reader.ReadString("s2"); |
| return o; |
| } |
| else |
| { |
| var sp3 = o as SerializePdx3; |
| |
| if (sp3 != null) |
| { |
| sp3.FromData(reader); |
| return o; |
| } |
| else |
| { |
| var ad = o as Address; |
| if (ad != null) |
| { |
| ad.FromData(reader); |
| return o; |
| } |
| } |
| |
| return null; |
| } |
| } |
| } |
| |
| public bool ToData(object o, IPdxWriter writer) |
| { |
| var obj = o as SerializePdx1; |
| |
| if (obj != null) |
| { |
| writer.WriteInt("i1", obj.i1); |
| writer.WriteInt("i2", obj.i2); |
| writer.WriteString("s1", obj.s1); |
| writer.WriteString("s2", obj.s2); |
| return true; |
| } |
| else |
| { |
| var obj2 = o as SerializePdx2; |
| if (obj2 != null) |
| { |
| writer.WriteString("s0", obj2.s0); |
| writer.WriteInt("i1", obj2.i1); |
| writer.WriteInt("i2", obj2.i2); |
| writer.WriteString("s1", obj2.s1); |
| writer.WriteString("s2", obj2.s2); |
| return true; |
| } |
| else |
| { |
| var sp3 = o as SerializePdx3; |
| |
| if (sp3 != null) |
| { |
| sp3.ToData(writer); |
| return true; |
| } |
| else |
| { |
| var ad = o as Address; |
| if (ad != null) |
| { |
| ad.ToData(writer); |
| return true; |
| } |
| } |
| } |
| |
| return false; |
| } |
| } |
| |
| #endregion |
| } |
| |
| public class SerializePdxNoRegister : IPdxSerializable |
| { |
| public int i1; |
| public int i2; |
| public string s1; |
| public string s2; |
| |
| /*public static SerializePdx1 CreateDeserializable() |
| { |
| return new SerializePdx1(false); |
| }*/ |
| |
| public SerializePdxNoRegister() |
| { |
| } |
| |
| public SerializePdxNoRegister(bool init) |
| { |
| if (init) |
| { |
| i1 = 1; |
| i2 = 2; |
| s1 = "s1"; |
| s2 = "s2"; |
| } |
| } |
| |
| public override bool Equals(object obj) |
| { |
| if (obj == null) |
| return false; |
| if (obj == this) |
| return true; |
| |
| var other = obj as SerializePdxNoRegister; |
| |
| if (other == null) |
| return false; |
| |
| if (i1 == other.i1 |
| && i2 == other.i2 |
| && s1 == other.s1 |
| && s2 == other.s2) |
| return true; |
| |
| return false; |
| } |
| |
| public override int GetHashCode() |
| { |
| return base.GetHashCode(); |
| } |
| |
| #region IPdxSerializable Members |
| |
| public void FromData(IPdxReader reader) |
| { |
| i1 = reader.ReadInt("i1"); |
| i2 = reader.ReadInt("i2"); |
| s1 = reader.ReadString("s1"); |
| s2 = reader.ReadString("s2"); |
| } |
| |
| public void ToData(IPdxWriter writer) |
| { |
| writer.WriteInt("i1", i1); |
| writer.WriteInt("i2", i2); |
| writer.WriteString("s1", s1); |
| writer.WriteString("s2", s2); |
| } |
| |
| #endregion |
| } |
| |
| #endregion |
| |
| #region Extension of ReflectionBasedAutoSerializer |
| |
| public class AutoSerializerEx : ReflectionBasedAutoSerializer |
| { |
| public override bool IsIdentityField(FieldInfo fi, Type type) |
| { |
| if (fi.Name == "_identityField") |
| return true; |
| return base.IsIdentityField(fi, type); |
| } |
| |
| public override string GetFieldName(FieldInfo fi, Type type) |
| { |
| if (fi.Name == "_nameChange") |
| return fi.Name + "NewName"; |
| |
| return fi.Name; |
| } |
| |
| public override bool IsFieldIncluded(FieldInfo fi, Type type) |
| { |
| if (fi.Name == "_notInclude") |
| return false; |
| return base.IsFieldIncluded(fi, type); |
| } |
| |
| public override FieldType GetFieldType(FieldInfo fi, Type type) |
| { |
| if (fi.FieldType.Equals(Type.GetType("System.Guid"))) |
| return FieldType.STRING; |
| return base.GetFieldType(fi, type); |
| } |
| |
| public override object WriteTransform(FieldInfo fi, Type type, object originalValue) |
| { |
| if (fi.FieldType.Equals(Type.GetType("System.Guid"))) |
| { |
| //writer.WriteField(fi.Name, fi.GetValue(o).ToString(), Type.GetType("System.String")); |
| return originalValue.ToString(); |
| } |
| else |
| return base.WriteTransform(fi, type, originalValue); |
| } |
| |
| public override object ReadTransform(FieldInfo fi, Type type, object serializeValue) |
| { |
| if (fi.FieldType.Equals(Type.GetType("System.Guid"))) |
| { |
| var g = new Guid((string) serializeValue); |
| |
| //fi.SetValue(o, g); |
| return g; |
| } |
| else |
| return base.ReadTransform(fi, type, serializeValue); |
| } |
| |
| /*public override void SerializeField(object o, FieldInfo fi, IPdxWriter writer) |
| { |
| if (fi.FieldType.Equals(Type.GetType("System.Guid"))) |
| { |
| writer.WriteField(fi.Name, fi.GetValue(o).ToString(), Type.GetType("System.String")); |
| } |
| else |
| base.SerializeField(o, fi, writer); |
| }*/ |
| |
| /* public override object DeserializeField(object o, FieldInfo fi, IPdxReader reader) |
| { |
| if (fi.FieldType.Equals(Type.GetType("System.Guid"))) |
| { |
| string gStr = (string)reader.ReadField(fi.Name, Type.GetType("System.String")); |
| Guid g = new Guid(gStr); |
| |
| //fi.SetValue(o, g); |
| return g; |
| } |
| else |
| return base.DeserializeField(o, fi, reader); |
| }*/ |
| } |
| |
| #endregion |
| |
| #region Classes for per test and Dataoutput.Advance method |
| |
| internal class MyClasses : IPdxSerializable |
| { |
| [PdxIdentityField] public string Key; |
| public List<object> Children; |
| |
| public MyClasses() |
| { |
| } |
| |
| public MyClasses(string key, int nClasses) |
| { |
| Key = key; |
| Children = new List<object>(nClasses); |
| for (var i = 0; i < nClasses; i++) |
| { |
| var my = new MyClass(i); |
| Children.Add(my); |
| } |
| } |
| |
| public static IPdxSerializable Create() |
| { |
| return new MyClasses(); |
| } |
| |
| public override bool Equals(object obj) |
| { |
| if (obj == null) |
| return false; |
| |
| var other = obj as MyClasses; |
| if (other == null) |
| return false; |
| |
| if (Children.Count == other.Children.Count) |
| return true; |
| return false; |
| } |
| |
| public override int GetHashCode() |
| { |
| return base.GetHashCode(); |
| } |
| |
| #region IPdxSerializable Members |
| |
| public void FromData(IPdxReader reader) |
| { |
| Key = reader.ReadString("Key"); |
| Children = (List<object>) (reader.ReadObject("Children")); |
| } |
| |
| public void ToData(IPdxWriter writer) |
| { |
| writer.WriteString("Key", Key); |
| writer.WriteObject("Children", Children); |
| } |
| |
| #endregion |
| } |
| |
| internal class MyClass : IPdxSerializable |
| { |
| [PdxIdentityField] public string Key; |
| public int SecKey; |
| public double ShareQuantity; |
| public double Cost; |
| public double Price; |
| public int SettleSecKey; |
| public double SettleFxRate; |
| public double ValueBasis; |
| public double OpenDate; |
| public double Strategy; |
| |
| public MyClass() |
| { |
| } |
| |
| public MyClass(int key) |
| { |
| Key = key.ToString(); |
| SecKey = key; |
| ShareQuantity = key * 9278; |
| Cost = ShareQuantity * 100; |
| Price = Cost * 10; |
| SettleSecKey = SecKey + 100000; |
| SettleFxRate = Price * 1.5; |
| ValueBasis = 1.5; |
| OpenDate = 100000; |
| Strategy = 3.6; |
| } |
| |
| public static IPdxSerializable Create() |
| { |
| return new MyClass(); |
| } |
| |
| #region IPdxSerializable Members |
| |
| public void FromData(IPdxReader reader) |
| { |
| Key = reader.ReadString("Key"); |
| SecKey = reader.ReadInt("SecKey"); |
| ShareQuantity = reader.ReadDouble("ShareQuantity"); |
| Cost = reader.ReadDouble("Cost"); |
| Price = reader.ReadDouble("Price"); |
| SettleSecKey = reader.ReadInt("SettleSecKey"); |
| SettleFxRate = reader.ReadDouble("SettleFxRate"); |
| ValueBasis = reader.ReadDouble("ValueBasis"); |
| OpenDate = reader.ReadDouble("OpenDate"); |
| Strategy = reader.ReadDouble("Strategy"); |
| } |
| |
| public void ToData(IPdxWriter writer) |
| { |
| writer.WriteString("Key", Key); |
| writer.WriteInt("SecKey", SecKey); |
| writer.WriteDouble("ShareQuantity", ShareQuantity); |
| writer.WriteDouble("Cost", Cost); |
| writer.WriteDouble("Price", Price); |
| writer.WriteInt("SettleSecKey", SettleSecKey); |
| writer.WriteDouble("SettleFxRate", SettleFxRate); |
| writer.WriteDouble("ValueBasis", ValueBasis); |
| writer.WriteDouble("OpenDate", OpenDate); |
| writer.WriteDouble("Strategy", Strategy); |
| } |
| |
| #endregion |
| } |
| |
| #endregion |
| |
| #region PdxTypeMapper |
| |
| public class PdxTypeMapper : IPdxTypeMapper |
| { |
| public string ToPdxTypeName(string localTypeName) |
| { |
| return "my" + localTypeName; |
| } |
| |
| public string FromPdxTypeName(string pdxTypeName) |
| { |
| return pdxTypeName.Substring(2); //need to extract "my" |
| } |
| } |
| |
| #endregion |
| |
| #region Pdx nested class |
| |
| public enum Gender |
| { |
| male, |
| female, |
| other |
| }; |
| |
| public class ChildPdx : IPdxSerializable |
| { |
| public int _childId; |
| public Gender _gender; |
| public string _childName; |
| |
| public ChildPdx() |
| { |
| } |
| |
| public ChildPdx(int id) |
| { |
| _childId = id; |
| _childName = "name" + id.ToString(); |
| if (id % 2 == 0) |
| _gender = Gender.female; |
| else |
| _gender = Gender.male; |
| } |
| |
| public override string ToString() |
| { |
| return _childId + ":" + _childName + ":" + _gender; |
| } |
| |
| public override bool Equals(object obj) |
| { |
| if (obj == null) |
| return false; |
| var other = obj as ChildPdx; |
| if (other == null) |
| return false; |
| if (_childName == other._childName |
| && _gender == other._gender |
| && _childId == other._childId) |
| return true; |
| return false; |
| } |
| |
| public override int GetHashCode() |
| { |
| return base.GetHashCode(); |
| } |
| |
| #region IPdxSerializable Members |
| |
| public void FromData(IPdxReader reader) |
| { |
| _childId = reader.ReadInt("_childId"); |
| _gender = (Gender) reader.ReadObject("_gender"); |
| _childName = reader.ReadString("_childName"); |
| } |
| |
| public void ToData(IPdxWriter writer) |
| { |
| writer.WriteInt("_childId", _childId); |
| writer.MarkIdentityField("_childId"); |
| writer.WriteObject("_gender", _gender); |
| writer.WriteString("_childName", _childName); |
| } |
| |
| #endregion |
| } |
| |
| public class ParentPdx : IPdxSerializable |
| { |
| public int _parentId; |
| public Gender _gender; |
| public string _parentName; |
| public ChildPdx _childPdx; |
| |
| public ParentPdx() |
| { |
| } |
| |
| public ParentPdx(int id) |
| { |
| _parentId = id; |
| _parentName = "name" + id.ToString(); |
| if (id % 2 == 0) |
| _gender = Gender.female; |
| else |
| _gender = Gender.male; |
| _childPdx = new ChildPdx(id * 1393); |
| } |
| |
| public override string ToString() |
| { |
| return _parentId + ":" + _gender + ":" + _parentName + ":" + _childPdx; |
| } |
| |
| public override bool Equals(object obj) |
| { |
| if (obj == null) |
| return false; |
| var other = obj as ParentPdx; |
| if (other == null) |
| return false; |
| if (_parentId == other._parentId |
| && _gender == other._gender |
| && _parentName == other._parentName |
| && _childPdx.Equals(other._childPdx)) |
| return true; |
| return false; |
| } |
| |
| public override int GetHashCode() |
| { |
| return base.GetHashCode(); |
| } |
| |
| #region IPdxSerializable Members |
| |
| public void FromData(IPdxReader reader) |
| { |
| _parentId = reader.ReadInt("_parentId"); |
| _gender = (Gender) reader.ReadObject("_gender"); |
| _parentName = reader.ReadString("_parentName"); |
| _childPdx = (ChildPdx) reader.ReadObject("_childPdx"); |
| } |
| |
| public void ToData(IPdxWriter writer) |
| { |
| writer.WriteInt("_parentId", _parentId); |
| writer.MarkIdentityField("_parentId"); |
| writer.WriteObject("_gender", _gender); |
| writer.WriteString("_parentName", _parentName); |
| writer.WriteObject("_childPdx", _childPdx); |
| writer.MarkIdentityField("_childPdx"); |
| } |
| |
| #endregion |
| } |
| |
| public class ChildPdxAS |
| { |
| [PdxIdentityField] private int _childId; |
| private Gender _gender; |
| private string _childName; |
| |
| public ChildPdxAS() |
| { |
| } |
| |
| public ChildPdxAS(int id) |
| { |
| _childId = id; |
| _childName = "name" + id.ToString(); |
| if (id % 2 == 0) |
| _gender = Gender.female; |
| else |
| _gender = Gender.male; |
| } |
| |
| public override string ToString() |
| { |
| return _childId + ":" + _childName + ":" + _gender; |
| } |
| |
| public override bool Equals(object obj) |
| { |
| if (obj == null) |
| return false; |
| var other = obj as ChildPdxAS; |
| if (other == null) |
| return false; |
| if (_childName == other._childName |
| && _gender == other._gender |
| && _childId == other._childId) |
| return true; |
| return false; |
| } |
| |
| public override int GetHashCode() |
| { |
| return base.GetHashCode(); |
| } |
| } |
| |
| public class Heaptest : IPdxSerializable |
| { |
| private int _id; |
| private byte[] _data; |
| |
| public Heaptest() |
| { |
| } |
| |
| public Heaptest(int id) |
| { |
| _id = id; |
| _data = new byte[id]; |
| } |
| |
| |
| #region IPdxSerializable Members |
| |
| public void FromData(IPdxReader reader) |
| { |
| _id = reader.ReadInt("_id"); |
| _data = reader.ReadByteArray("_data"); |
| } |
| |
| public void ToData(IPdxWriter writer) |
| { |
| writer.WriteInt("_id", _id); |
| writer.WriteByteArray("_data", _data); |
| } |
| |
| #endregion |
| } |
| |
| public enum enumQuerytest |
| { |
| id1, |
| id2, |
| id3 |
| }; |
| |
| public class PdxEnumTestClass : IPdxSerializable |
| { |
| private int _id; |
| private enumQuerytest _enumid; |
| |
| public int ID |
| { |
| get { return _id; } |
| } |
| |
| public PdxEnumTestClass(int id) |
| { |
| _id = id; |
| switch (id) |
| { |
| case 0: |
| _enumid = enumQuerytest.id1; |
| break; |
| case 1: |
| _enumid = enumQuerytest.id2; |
| break; |
| case 2: |
| _enumid = enumQuerytest.id3; |
| break; |
| default: |
| _enumid = enumQuerytest.id1; |
| break; |
| } |
| } |
| |
| public PdxEnumTestClass() |
| { |
| } |
| |
| #region IPdxSerializable Members |
| |
| public void FromData(IPdxReader reader) |
| { |
| _id = reader.ReadInt("_id"); |
| _enumid = (enumQuerytest) reader.ReadObject("_enumid"); |
| } |
| |
| public void ToData(IPdxWriter writer) |
| { |
| writer.WriteInt("_id", _id); |
| writer.WriteObject("_enumid", _enumid); |
| } |
| |
| #endregion |
| } |
| |
| #endregion |
| } |
| |
| namespace javaobject |
| { |
| using Apache.Geode.Client; |
| |
| #region Pdx Delta class |
| |
| public class PdxDelta : IPdxSerializable, IDelta, ICloneable |
| { |
| public static int GotDelta = 0; |
| private int _delta = 0; |
| private int _id; |
| |
| public PdxDelta() |
| { |
| } |
| |
| public PdxDelta(int id) |
| { |
| _id = id; |
| } |
| |
| #region IPdxSerializable Members |
| |
| public void FromData(IPdxReader reader) |
| { |
| _id = reader.ReadInt("_id"); |
| _delta = reader.ReadInt("_delta"); |
| } |
| |
| public void ToData(IPdxWriter writer) |
| { |
| writer.WriteInt("_id", _id); |
| writer.WriteInt("_delta", _delta); |
| } |
| |
| #endregion |
| |
| public int Delta |
| { |
| get { return _delta; } |
| } |
| |
| #region IDelta Members |
| |
| public void FromDelta(DataInput input) |
| { |
| Console.WriteLine(" in fromdelta " + GotDelta); |
| _delta = input.ReadInt32(); |
| GotDelta++; |
| } |
| |
| public bool HasDelta() |
| { |
| Console.WriteLine(" in hasdelta " + _delta); |
| if (_delta > 0) |
| { |
| _delta++; |
| return true; |
| } |
| else |
| { |
| _delta++; |
| return false; |
| } |
| } |
| |
| public void ToDelta(DataOutput output) |
| { |
| Console.WriteLine(" in todelta " + GotDelta); |
| output.WriteInt32(_delta); |
| GotDelta++; |
| } |
| |
| #endregion |
| |
| #region ICloneable Members |
| |
| public object Clone() |
| { |
| var pd = new PdxDelta(); |
| pd._id = _id; |
| pd._delta = _delta; |
| return pd; |
| } |
| |
| #endregion |
| } |
| |
| #endregion |
| } |
