| /* |
| * 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.IO; |
| using System.Threading; |
| using System.Collections.Generic; |
| using System.Diagnostics; |
| |
| #pragma warning disable 618 |
| |
| namespace Apache.Geode.Client.UnitTests |
| { |
| using NUnit.Framework; |
| using Apache.Geode.DUnitFramework; |
| using Apache.Geode.Client; |
| |
| [TestFixture] |
| [Category("group4")] |
| [Category("unicast_only")] |
| [Category("generics")] |
| |
| public class OverflowTests : UnitTests |
| { |
| |
| protected override ClientBase[] GetClients() |
| { |
| return null; |
| } |
| |
| [TestFixtureSetUp] |
| public override void InitTests() |
| { |
| base.InitTests(); |
| } |
| |
| [TestFixtureTearDown] |
| public override void EndTests() |
| { |
| try |
| { |
| CacheHelper.Close(); |
| } |
| finally |
| { |
| base.EndTests(); |
| } |
| } |
| |
| [SetUp] |
| public void StartTest() |
| { |
| CacheHelper.Init(); |
| } |
| |
| [TearDown] |
| public override void EndTest() |
| { |
| CacheHelper.Close(); |
| base.EndTest(); |
| } |
| |
| #region Private functions used by the tests |
| |
| private IRegion<object, object> CreateOverflowRegion(string regionName, string libraryName, string factoryFunctionName) |
| { |
| |
| RegionFactory rf = CacheHelper.DCache.CreateRegionFactory(RegionShortcut.LOCAL); |
| rf.SetCachingEnabled(true); |
| rf.SetLruEntriesLimit(20); |
| rf.SetInitialCapacity(1000); |
| rf.SetDiskPolicy(DiskPolicyType.Overflows); |
| |
| Properties<string, string> sqliteProperties = new Properties<string, string>(); |
| sqliteProperties.Insert("PageSize", "65536"); |
| sqliteProperties.Insert("MaxFileSize", "512000000"); |
| String sqlite_dir = "SqLiteDir" + Process.GetCurrentProcess().Id.ToString(); |
| sqliteProperties.Insert("PersistenceDirectory", sqlite_dir); |
| |
| rf.SetPersistenceManager(libraryName, factoryFunctionName, sqliteProperties); |
| |
| CacheHelper.Init(); |
| IRegion<object, object> region = CacheHelper.GetRegion<object, object>(regionName); |
| if ((region != null) && !region.IsDestroyed) |
| { |
| region.GetLocalView().DestroyRegion(); |
| Assert.IsTrue(region.IsDestroyed, "IRegion<object, object> {0} was not destroyed.", regionName); |
| } |
| region = rf.Create<object, object>(regionName); |
| Assert.IsNotNull(region, "IRegion<object, object> was not created."); |
| |
| return region; |
| |
| } |
| |
| // Testing for attibute validation. |
| private void ValidateAttributes(IRegion<object, object> region) |
| { |
| Apache.Geode.Client.RegionAttributes<object, object> regAttr = region.Attributes; |
| int initialCapacity = regAttr.InitialCapacity; |
| Assert.AreEqual(1000, initialCapacity, "Expected initial capacity to be 1000"); |
| Assert.AreEqual(DiskPolicyType.Overflows, regAttr.DiskPolicy, |
| "Expected Action to be overflow to disk"); |
| } |
| |
| |
| private string GetSqLiteFileName(string sqliteDir, string regionName) |
| { |
| return Path.Combine(Directory.GetCurrentDirectory(), sqliteDir, regionName, regionName + ".db"); |
| } |
| |
| private IRegion<object, object> CreateSubRegion(IRegion<object, object> region, string subRegionName, string libraryName, string factoryFunctionName) |
| { |
| var regionAttributesFactory = new RegionAttributesFactory<object, object>(region.Attributes); |
| Properties<string, string> sqliteProperties = new Properties<string, string>(); |
| sqliteProperties.Insert("PageSize", "65536"); |
| sqliteProperties.Insert("MaxPageCount", "512000000"); |
| String sqlite_dir = "SqLiteDir" + Process.GetCurrentProcess().Id.ToString(); |
| sqliteProperties.Insert("PersistenceDirectory", sqlite_dir); |
| regionAttributesFactory.SetPersistenceManager(libraryName, factoryFunctionName, sqliteProperties); |
| IRegion<object, object> subRegion = region.CreateSubRegion(subRegionName, |
| regionAttributesFactory.Create()); |
| Assert.IsNotNull(subRegion, "Expected region to be non null"); |
| Assert.IsTrue(File.Exists(GetSqLiteFileName(sqlite_dir, subRegionName)), "Persistence file is not present"); |
| DoNput(subRegion, 50); |
| DoNget(subRegion, 50); |
| return subRegion; |
| } |
| |
| private void DoNput(IRegion<object, object> region, int num) |
| { |
| //CacheableString cVal = new CacheableString(new string('A', 1024)); |
| string cVal = new string('A', 1024); |
| for (int i = 0; i < num; i++) |
| { |
| Util.Log("Putting key = key-{0}", i); |
| region["key-" + i.ToString()] = cVal; |
| } |
| } |
| |
| private void DoNget(IRegion<object, object> region, int num) |
| { |
| string cVal; |
| string expectVal = new string('A', 1024); |
| for (int i = 0; i < num; i++) |
| { |
| cVal = region["key-" + i.ToString()] as string; |
| Util.Log("Getting key = key-{0}", i); |
| Assert.IsNotNull(cVal, "Key[key-{0}] not found.", i); |
| Assert.AreEqual(expectVal, cVal, "Did not find the expected value."); |
| } |
| } |
| |
| private bool IsOverflowed(/*ISerializable*/ object cVal) |
| { |
| //Util.Log("IsOverflowed:: value is: {0}; type is: {1}", cVal.ToString(), cVal.GetType()); |
| return cVal.ToString() == "CacheableToken::OVERFLOWED"; |
| } |
| |
| private void CheckOverflowToken(IRegion<object, object> region, int num, int lruLimit) |
| { |
| //ISerializable cVal; |
| //ICacheableKey[] cKeys = region.GetKeys(); |
| |
| object cVal; |
| ICollection<object> cKeys = region.GetLocalView().Keys; |
| Assert.AreEqual(num, cKeys.Count, "Number of keys does not match."); |
| int count = 0; |
| foreach (object cKey in cKeys) |
| { |
| RegionEntry<object, object> entry = region.GetEntry(cKey); |
| cVal = entry.Value; |
| if (IsOverflowed(cVal)) |
| { |
| count++; |
| } |
| } |
| Assert.AreEqual(0, count, "Number of overflowed entries should be zero"); |
| } |
| |
| private void CheckNumOfEntries(IRegion<object, object> region, int lruLimit) |
| { |
| //ICollection<object> cVals = region.GetLocalView().Values; |
| ICollection<object> cVals = region.Values; |
| Assert.AreEqual(lruLimit, cVals.Count, "Number of values does not match."); |
| } |
| |
| private void TestGetOp(IRegion<object, object> region, int num) |
| { |
| DoNput(region, num); |
| |
| ICollection<object> cKeys = region.GetLocalView().Keys; |
| object cVal; |
| |
| Assert.AreEqual(num, cKeys.Count, "Number of keys does not match."); |
| foreach (object cKey in cKeys) |
| { |
| RegionEntry<object, object> entry = region.GetEntry(cKey); |
| cVal = entry.Value; |
| if (IsOverflowed(cVal)) |
| { |
| cVal = region[cKey]; |
| Assert.IsFalse(IsOverflowed(cVal), "Overflow token even after a Region.Get"); |
| } |
| } |
| } |
| |
| private void TestEntryDestroy(IRegion<object, object> region) |
| { |
| //ICollection<object> cKeys = region.Keys; |
| ICollection<object> cKeys = region.GetLocalView().Keys; |
| string[] arrKeys = new string[cKeys.Count]; |
| cKeys.CopyTo(arrKeys, 0); |
| |
| for (int i = 50; i < 60; i++) |
| { |
| try |
| { |
| region.GetLocalView().Remove(arrKeys[i]); |
| } |
| catch (Exception ex) |
| { |
| Util.Log("Entry missing for {0}. Exception: {1}", arrKeys[i], ex.ToString()); |
| } |
| } |
| cKeys = region.GetLocalView().Keys; |
| |
| Assert.AreEqual(90, cKeys.Count, "Number of keys is not correct."); |
| } |
| |
| #endregion |
| |
| [Test] |
| public void OverflowPutGet() |
| { |
| IRegion<object, object> region = CreateOverflowRegion("OverFlowRegion", "SqLiteImpl", "createSqLiteInstance"); |
| ValidateAttributes(region); |
| |
| //Console.WriteLine("TEST-2"); |
| // put some values into the cache. |
| DoNput(region, 100); |
| //Console.WriteLine("TEST-2.1 All PUts Donee"); |
| |
| CheckNumOfEntries(region, 100); |
| |
| //Console.WriteLine("TEST-3"); |
| // check whether value get evicted and token gets set as overflow |
| CheckOverflowToken(region, 100, 20); |
| // do some gets... printing what we find in the cache. |
| DoNget(region, 100); |
| TestEntryDestroy(region); |
| TestGetOp(region, 100); |
| |
| //Console.WriteLine("TEST-4"); |
| // test to verify same region repeatedly to ensure that the persistece |
| // files are created and destroyed correctly |
| |
| IRegion<object, object> subRegion; |
| String sqlite_dir = "SqLiteDir" + Process.GetCurrentProcess().Id.ToString(); |
| for (int i = 0; i < 1; i++) |
| { |
| subRegion = CreateSubRegion(region, "SubRegion", "SqLiteImpl", "createSqLiteInstance"); |
| subRegion.DestroyRegion(); |
| Assert.IsTrue(subRegion.IsDestroyed, "Expected region to be destroyed"); |
| Assert.IsFalse(File.Exists(GetSqLiteFileName(sqlite_dir, "SubRegion")), "Persistence file present after region destroy"); |
| } |
| //Console.WriteLine("TEST-5"); |
| } |
| |
| [Test] |
| public void OverflowPutGetManaged() |
| { |
| IRegion<object, object> region = CreateOverflowRegion("OverFlowRegion", "Apache.Geode.Plugins.SqLite", |
| "Apache.Geode.Plugins.SqLite.SqLiteImpl<System.Object,System.Object>.Create"); |
| ValidateAttributes(region); |
| |
| //Console.WriteLine("TEST-2"); |
| // put some values into the cache. |
| DoNput(region, 100); |
| //Console.WriteLine("TEST-2.1 All PUts Donee"); |
| |
| CheckNumOfEntries(region, 100); |
| |
| //Console.WriteLine("TEST-3"); |
| // check whether value get evicted and token gets set as overflow |
| CheckOverflowToken(region, 100, 20); |
| // do some gets... printing what we find in the cache. |
| DoNget(region, 100); |
| TestEntryDestroy(region); |
| TestGetOp(region, 100); |
| |
| //Console.WriteLine("TEST-4"); |
| // test to verify same region repeatedly to ensure that the persistece |
| // files are created and destroyed correctly |
| |
| IRegion<object, object> subRegion; |
| String sqlite_dir = "SqLiteDir" + Process.GetCurrentProcess().Id.ToString(); |
| for (int i = 0; i < 10; i++) |
| { |
| subRegion = CreateSubRegion(region, "SubRegion", "Apache.Geode.Plugins.SqLite", |
| "Apache.Geode.Plugins.SqLite.SqLiteImpl<System.Object,System.Object>.Create"); |
| subRegion.DestroyRegion(); |
| Assert.IsTrue(subRegion.IsDestroyed, "Expected region to be destroyed"); |
| Assert.IsFalse(File.Exists(GetSqLiteFileName(sqlite_dir, "SubRegion")), "Persistence file present after region destroy"); |
| } |
| //Console.WriteLine("TEST-5"); |
| } |
| |
| [Test] |
| public void OverflowPutGetManagedMT() |
| { |
| IRegion<object, object> region = CreateOverflowRegion("OverFlowRegion", "Apache.Geode.Plugins.SqLite", |
| "Apache.Geode.Plugins.SqLite.SqLiteImpl<System.Object,System.Object>.Create"); |
| ValidateAttributes(region); |
| |
| List<Thread> threadsList = new List<Thread>(); |
| for (int i = 0; i < 10; i++) |
| { |
| Thread t = new Thread(delegate() |
| { |
| // put some values into the cache. |
| DoNput(region, 100); |
| CheckNumOfEntries(region, 100); |
| |
| // check whether value get evicted and token gets set as overflow |
| CheckOverflowToken(region, 100, 20); |
| // do some gets... printing what we find in the cache. |
| DoNget(region, 100); |
| TestEntryDestroy(region); |
| TestGetOp(region, 100); |
| }); |
| threadsList.Add(t); |
| t.Start(); |
| } |
| |
| for (int i = 0; i < 10; i++) |
| { |
| threadsList[i].Join(); |
| } |
| region.DestroyRegion(); |
| //Console.WriteLine("TEST-5"); |
| } |
| |
| [Test] |
| public void OverflowPutGetManagedSetInstance() |
| { |
| RegionFactory rf = CacheHelper.DCache.CreateRegionFactory(RegionShortcut.LOCAL); |
| rf.SetCachingEnabled(true); |
| rf.SetLruEntriesLimit(20); |
| rf.SetInitialCapacity(1000); |
| rf.SetDiskPolicy(DiskPolicyType.Overflows); |
| |
| Properties<string, string> sqliteProperties = new Properties<string, string>(); |
| sqliteProperties.Insert("PageSize", "65536"); |
| sqliteProperties.Insert("MaxFileSize", "512000000"); |
| String sqlite_dir = "SqLiteDir" + Process.GetCurrentProcess().Id.ToString(); |
| sqliteProperties.Insert("PersistenceDirectory", sqlite_dir); |
| |
| //rf.SetPersistenceManager(new Apache.Geode.Plugins.SQLite.SqLiteImpl<object, object>(), sqliteProperties); |
| rf.SetPersistenceManager("SqLiteImpl", "createSqLiteInstance", sqliteProperties); |
| |
| CacheHelper.Init(); |
| IRegion<object, object> region = CacheHelper.GetRegion<object, object>("OverFlowRegion"); |
| if ((region != null) && !region.IsDestroyed) |
| { |
| region.GetLocalView().DestroyRegion(); |
| Assert.IsTrue(region.IsDestroyed, "IRegion<object, object> OverFlowRegion was not destroyed."); |
| } |
| region = rf.Create<object, object>("OverFlowRegion"); |
| Assert.IsNotNull(region, "IRegion<object, object> was not created."); |
| ValidateAttributes(region); |
| |
| //Console.WriteLine("TEST-2"); |
| // put some values into the cache. |
| DoNput(region, 100); |
| //Console.WriteLine("TEST-2.1 All PUts Donee"); |
| |
| CheckNumOfEntries(region, 100); |
| |
| //Console.WriteLine("TEST-3"); |
| // check whether value get evicted and token gets set as overflow |
| CheckOverflowToken(region, 100, 20); |
| // do some gets... printing what we find in the cache. |
| DoNget(region, 100); |
| TestEntryDestroy(region); |
| TestGetOp(region, 100); |
| |
| //Console.WriteLine("TEST-4"); |
| // test to verify same region repeatedly to ensure that the persistece |
| // files are created and destroyed correctly |
| |
| IRegion<object, object> subRegion; |
| for (int i = 0; i < 1; i++) |
| { |
| subRegion = CreateSubRegion(region, "SubRegion", "Apache.Geode.Plugins.SqLite", "SqLiteImpl<object,object>.Create()"); |
| subRegion.DestroyRegion(); |
| Assert.IsTrue(subRegion.IsDestroyed, "Expected region to be destroyed"); |
| Assert.IsFalse(File.Exists(GetSqLiteFileName(sqlite_dir, "SubRegion")), "Persistence file present after region destroy"); |
| } |
| //Console.WriteLine("TEST-5"); |
| } |
| |
| |
| [Test] |
| public void XmlCacheCreationWithOverflow() |
| { |
| Cache cache = null; |
| IRegion<object, object> region1; |
| IRegion<object, object> region2; |
| IRegion<object, object> region3; |
| IRegion<object, object>[] rootRegions; |
| //Region<object, object>[] subRegions; |
| ICollection<IRegion<object, object>> subRegions; |
| /*string host_name = "XML_CACHE_CREATION_TEST";*/ |
| const UInt32 totalSubRegionsRoot1 = 2; |
| const UInt32 totalRootRegions = 3; |
| |
| try |
| { |
| CacheHelper.CloseCache(); |
| Util.Log("Creating cache with the configurations provided in valid_overflowAttr.xml"); |
| string cachePath = CacheHelper.TestDir + Path.DirectorySeparatorChar + "valid_overflowAttr.xml"; |
| cache = new CacheFactory().Set("cache-xml-file", cachePath).Create(); |
| Util.Log("Successfully created the cache."); |
| rootRegions = cache.RootRegions<object, object>(); |
| Assert.IsNotNull(rootRegions); |
| Assert.AreEqual(totalRootRegions, rootRegions.Length); |
| |
| Util.Log("Root regions in Cache: "); |
| foreach (IRegion<object, object> rg in rootRegions) |
| { |
| Util.Log('\t' + rg.Name); |
| } |
| |
| region1 = rootRegions[0]; |
| //subRegions = region1.SubRegions(true); |
| subRegions = region1.SubRegions(true); |
| Assert.IsNotNull(subRegions); |
| Assert.AreEqual(subRegions.Count, totalSubRegionsRoot1); |
| |
| Util.Log("SubRegions for the root region: "); |
| foreach (IRegion<object, object> rg in subRegions) |
| { |
| Util.Log('\t' + rg.Name); |
| } |
| |
| Util.Log("Testing if the nesting of regions is correct..."); |
| region2 = rootRegions[1]; |
| subRegions = region2.SubRegions(true); |
| string childName; |
| string parentName; |
| foreach (IRegion<object, object> rg in subRegions) |
| { |
| childName = rg.Name; |
| IRegion<object, object> parent = rg.ParentRegion; |
| parentName = parent.Name; |
| if (childName == "SubSubRegion221") |
| { |
| Assert.AreEqual("SubRegion22", parentName); |
| } |
| } |
| |
| region3 = rootRegions[2]; |
| //subRegions = region1.SubRegions(true); |
| subRegions = region3.SubRegions(true); |
| Assert.IsNotNull(subRegions); |
| Assert.AreEqual(subRegions.Count, totalSubRegionsRoot1); |
| |
| Util.Log("SubRegions for the root region: "); |
| foreach (IRegion<object, object> rg in subRegions) |
| { |
| Util.Log('\t' + rg.Name); |
| } |
| |
| Apache.Geode.Client.RegionAttributes<object, object> attrs = region1.Attributes; |
| //Util.Log("Attributes of root region Root1 are: "); |
| |
| bool cachingEnabled = attrs.CachingEnabled; |
| Assert.IsTrue(cachingEnabled); |
| |
| uint lruEL = attrs.LruEntriesLimit; |
| Assert.AreEqual(35, lruEL); |
| |
| int concurrency = attrs.ConcurrencyLevel; |
| Assert.AreEqual(10, concurrency); |
| |
| int initialCapacity = attrs.InitialCapacity; |
| Assert.AreEqual(25, initialCapacity); |
| |
| var regionIdleTO = attrs.RegionIdleTimeout; |
| Assert.AreEqual(20, regionIdleTO); |
| |
| ExpirationAction action1 = attrs.RegionIdleTimeoutAction; |
| Assert.AreEqual(ExpirationAction.Destroy, action1); |
| |
| DiskPolicyType type = attrs.DiskPolicy; |
| Assert.AreEqual(DiskPolicyType.Overflows, type); |
| string persistenceDir, maxPageCount, pageSize; |
| |
| string lib = attrs.PersistenceLibrary; |
| string libFun = attrs.PersistenceFactory; |
| Util.Log(" persistence library1 = " + lib); |
| Util.Log(" persistence function1 = " + libFun); |
| Properties<string, string> pconfig = attrs.PersistenceProperties; |
| Assert.IsNotNull(pconfig, "Persistence properties should not be null for root1."); |
| persistenceDir = (string)pconfig.Find("PersistenceDirectory"); |
| maxPageCount = (string)pconfig.Find("MaxPageCount"); |
| pageSize = (string)pconfig.Find("PageSize"); |
| Assert.IsNotNull(persistenceDir, "Persistence directory should not be null."); |
| Assert.AreNotEqual(0, persistenceDir.Length, "Persistence directory should not be empty."); |
| Assert.IsNotNull(maxPageCount, "Persistence MaxPageCount should not be null."); |
| Assert.AreNotEqual(0, maxPageCount.Length, "Persistence MaxPageCount should not be empty."); |
| Assert.IsNotNull(pageSize, "Persistence PageSize should not be null."); |
| Assert.AreNotEqual(0, pageSize.Length, "Persistence PageSize should not be empty."); |
| Util.Log("****Attributes of Root1 are correctly set****"); |
| |
| Apache.Geode.Client.RegionAttributes<object, object> attrs2 = region2.Attributes; |
| string lib2 = attrs2.PersistenceLibrary; |
| string libFun2 = attrs2.PersistenceFactory; |
| Util.Log(" persistence library2 = " + lib2); |
| Util.Log(" persistence function2 = " + libFun2); |
| Properties<string, string> pconfig2 = attrs2.PersistenceProperties; |
| Assert.IsNotNull(pconfig2, "Persistence properties should not be null for root2."); |
| persistenceDir = (string)pconfig2.Find("PersistenceDirectory"); |
| maxPageCount = (string)pconfig2.Find("MaxPageCount"); |
| maxPageCount = (string)pconfig2.Find("PageSize"); |
| Assert.IsNotNull(persistenceDir, "Persistence directory should not be null."); |
| Assert.AreNotEqual(0, persistenceDir.Length, "Persistence directory should not be empty."); |
| Assert.IsNotNull(maxPageCount, "Persistence MaxPageCount should not be null."); |
| Assert.AreNotEqual(0, maxPageCount.Length, "Persistence MaxPageCount should not be empty."); |
| Assert.IsNotNull(pageSize, "Persistence PageSize should not be null."); |
| Assert.AreNotEqual(0, pageSize.Length, "Persistence PageSize should not be empty."); |
| |
| Util.Log("****Attributes of Root2 are correctly set****"); |
| |
| Apache.Geode.Client.RegionAttributes<object, object> attrs3 = region3.Attributes; |
| //Util.Log("Attributes of root region Root1 are: "); |
| |
| Assert.IsTrue(attrs3.CachingEnabled); |
| Assert.AreEqual(35, attrs3.LruEntriesLimit); |
| Assert.AreEqual(10, attrs3.ConcurrencyLevel); |
| Assert.AreEqual(25, attrs3.InitialCapacity); |
| Assert.AreEqual(20, attrs3.RegionIdleTimeout); |
| Assert.AreEqual(ExpirationAction.Destroy, attrs3.RegionIdleTimeoutAction); |
| Assert.AreEqual(DiskPolicyType.Overflows, attrs3.DiskPolicy); |
| |
| Util.Log(" persistence library1 = " + attrs3.PersistenceLibrary); |
| Util.Log(" persistence function1 = " + attrs3.PersistenceFactory); |
| Properties<string, string> pconfig3 = attrs.PersistenceProperties; |
| Assert.IsNotNull(pconfig3, "Persistence properties should not be null for root1."); |
| Assert.IsNotNull(pconfig3.Find("PersistenceDirectory"), "Persistence directory should not be null."); |
| Assert.AreNotEqual(0, pconfig3.Find("PersistenceDirectory").Length, "Persistence directory should not be empty."); |
| Assert.IsNotNull(pconfig3.Find("MaxPageCount"), "Persistence MaxPageCount should not be null."); |
| Assert.AreNotEqual(0, pconfig3.Find("MaxPageCount").Length, "Persistence MaxPageCount should not be empty."); |
| Assert.IsNotNull(pconfig3.Find("PageSize"), "Persistence PageSize should not be null."); |
| Assert.AreNotEqual(0, pconfig3.Find("PageSize"), "Persistence PageSize should not be empty."); |
| Util.Log("****Attributes of Root1 are correctly set****"); |
| |
| region1.DestroyRegion(null); |
| region2.DestroyRegion(null); |
| region3.DestroyRegion(null); |
| |
| if (!cache.IsClosed) |
| { |
| cache.Close(); |
| } |
| |
| ////////////////////////////testing of cache.xml completed/////////////////// |
| |
| |
| Util.Log("Create cache with the configurations provided in the invalid_overflowAttr1.xml."); |
| |
| Util.Log("Non existent XML; exception should be thrown"); |
| |
| try |
| { |
| cachePath = CacheHelper.TestDir + Path.DirectorySeparatorChar + "non-existent.xml"; |
| cache = new CacheFactory().Set("cache-xml-file", cachePath).Create(); |
| Assert.Fail("Creation of cache with non-existent.xml should fail!"); |
| } |
| catch (CacheXmlException ex) |
| { |
| Util.Log("Expected exception with non-existent.xml: {0}", ex); |
| } |
| |
| Util.Log("This is a well-formed xml....attributes not provided for persistence manager. exception should be thrown"); |
| |
| try |
| { |
| cachePath = CacheHelper.TestDir + Path.DirectorySeparatorChar + "invalid_overflowAttr1.xml"; |
| cache = new CacheFactory().Set("cache-xml-file", cachePath).Create(); |
| Assert.Fail("Creation of cache with invalid_overflowAttr1.xml should fail!"); |
| } |
| catch (IllegalStateException ex) |
| { |
| Util.Log("Expected exception with invalid_overflowAttr1.xml: {0}", ex); |
| } |
| |
| ///////////////testing of invalid_overflowAttr1.xml completed/////////////////// |
| |
| Util.Log("Create cache with the configurations provided in the invalid_overflowAttr2.xml."); |
| Util.Log("This is a well-formed xml....attribute values is not provided for persistence library name......should throw an exception"); |
| |
| try |
| { |
| cachePath = CacheHelper.TestDir + Path.DirectorySeparatorChar + "invalid_overflowAttr2.xml"; |
| cache = new CacheFactory().Set("cache-xml-file", cachePath).Create(); |
| Assert.Fail("Creation of cache with invalid_overflowAttr2.xml should fail!"); |
| } |
| catch (CacheXmlException ex) |
| { |
| Util.Log("Expected exception with invalid_overflowAttr2.xml: {0}", ex); |
| } |
| |
| ///////////////testing of invalid_overflowAttr2.xml completed/////////////////// |
| |
| Util.Log("Create cache with the configurations provided in the invalid_overflowAttr3.xml."); |
| Util.Log("This is a well-formed xml....but region-attributes for persistence invalid......should throw an exception"); |
| |
| try |
| { |
| cachePath = CacheHelper.TestDir + Path.DirectorySeparatorChar + "invalid_overflowAttr3.xml"; |
| cache = new CacheFactory().Set("cache-xml-file", cachePath).Create(); |
| Assert.Fail("Creation of cache with invalid_overflowAttr3.xml should fail!"); |
| } |
| catch (CacheXmlException ex) |
| { |
| Util.Log("Expected exception with invalid_overflowAttr3.xml: {0}", ex); |
| } |
| |
| ///////////////testing of invalid_overflowAttr3.xml completed/////////////////// |
| } |
| catch (Exception ex) |
| { |
| Assert.Fail("Caught exception: {0}", ex); |
| } |
| finally |
| { |
| if (cache != null && !cache.IsClosed) |
| { |
| cache.Close(); |
| } |
| } |
| } |
| } |
| } |