public void TestBaseInvalidateObject() { try { pool = MakeEmptyPool(3); } catch (NotSupportedException) { return; // skip this test if unsupported } Object keya = MakeKey(0); Assert.AreEqual(0, pool.KeyedActiveCount(keya)); Assert.AreEqual(0, pool.KeyedIdleCount(keya)); Object obj0 = pool.BorrowObject(keya); Object obj1 = pool.BorrowObject(keya); Assert.AreEqual(2, pool.KeyedActiveCount(keya)); Assert.AreEqual(0, pool.KeyedIdleCount(keya)); pool.InvalidateObject(keya, obj0); Assert.AreEqual(1, pool.KeyedActiveCount(keya)); Assert.AreEqual(0, pool.KeyedIdleCount(keya)); pool.InvalidateObject(keya, obj1); Assert.AreEqual(0, pool.KeyedActiveCount(keya)); Assert.AreEqual(0, pool.KeyedIdleCount(keya)); }
public void TestBaseClear() { try { pool = MakeEmptyPool(3); } catch (NotSupportedException) { return; // skip this test if unsupported } Object keya = MakeKey(0); Assert.AreEqual(0, pool.KeyedActiveCount(keya)); Assert.AreEqual(0, pool.KeyedIdleCount(keya)); Object obj0 = pool.BorrowObject(keya); Object obj1 = pool.BorrowObject(keya); Assert.AreEqual(2, pool.KeyedActiveCount(keya)); Assert.AreEqual(0, pool.KeyedIdleCount(keya)); pool.ReturnObject(keya, obj1); pool.ReturnObject(keya, obj0); Assert.AreEqual(0, pool.KeyedActiveCount(keya)); Assert.AreEqual(2, pool.KeyedIdleCount(keya)); pool.Clear(keya); Assert.AreEqual(0, pool.KeyedActiveCount(keya)); Assert.AreEqual(0, pool.KeyedIdleCount(keya)); Object obj2 = pool.BorrowObject(keya); Assert.AreEqual(GetNthObject(keya, 2), obj2); }
public void TestBaseNumActiveNumIdle2() { try { pool = MakeEmptyPool(6); } catch (NotSupportedException) { return; // skip this test if unsupported } Object keya = MakeKey(0); Object keyb = MakeKey(1); Assert.AreEqual(0, pool.ActiveCount); Assert.AreEqual(0, pool.IdleCount); Assert.AreEqual(0, pool.KeyedActiveCount(keya)); Assert.AreEqual(0, pool.KeyedIdleCount(keya)); Assert.AreEqual(0, pool.KeyedActiveCount(keyb)); Assert.AreEqual(0, pool.KeyedIdleCount(keyb)); Object objA0 = pool.BorrowObject(keya); Object objB0 = pool.BorrowObject(keyb); Assert.AreEqual(2, pool.ActiveCount); Assert.AreEqual(0, pool.IdleCount); Assert.AreEqual(1, pool.KeyedActiveCount(keya)); Assert.AreEqual(0, pool.KeyedIdleCount(keya)); Assert.AreEqual(1, pool.KeyedActiveCount(keyb)); Assert.AreEqual(0, pool.KeyedIdleCount(keyb)); Object objA1 = pool.BorrowObject(keya); Object objB1 = pool.BorrowObject(keyb); Assert.AreEqual(4, pool.ActiveCount); Assert.AreEqual(0, pool.IdleCount); Assert.AreEqual(2, pool.KeyedActiveCount(keya)); Assert.AreEqual(0, pool.KeyedIdleCount(keya)); Assert.AreEqual(2, pool.KeyedActiveCount(keyb)); Assert.AreEqual(0, pool.KeyedIdleCount(keyb)); pool.ReturnObject(keya, objA0); pool.ReturnObject(keyb, objB0); Assert.AreEqual(2, pool.ActiveCount); Assert.AreEqual(2, pool.IdleCount); Assert.AreEqual(1, pool.KeyedActiveCount(keya)); Assert.AreEqual(1, pool.KeyedIdleCount(keya)); Assert.AreEqual(1, pool.KeyedActiveCount(keyb)); Assert.AreEqual(1, pool.KeyedIdleCount(keyb)); pool.ReturnObject(keya, objA1); pool.ReturnObject(keyb, objB1); Assert.AreEqual(0, pool.ActiveCount); Assert.AreEqual(4, pool.IdleCount); Assert.AreEqual(0, pool.KeyedActiveCount(keya)); Assert.AreEqual(2, pool.KeyedIdleCount(keya)); Assert.AreEqual(0, pool.KeyedActiveCount(keyb)); Assert.AreEqual(2, pool.KeyedIdleCount(keyb)); }
public void TestClosedPoolBehavior() { KeyedObjectPool <Object, Object> pool; try { pool = MakeEmptyPool(new InternalKeyedPoolableObjectFactory()); } catch (NotSupportedException) { return; // test not supported } Object o1 = pool.BorrowObject(KEY); Object o2 = pool.BorrowObject(KEY); pool.Close(); try { pool.AddObject(KEY); Assert.Fail("A Closed pool must throw an IllegalStateException when AddObject is called."); } catch (IllegalStateException) { // expected } try { pool.BorrowObject(KEY); Assert.Fail("A Closed pool must throw an IllegalStateException when BorrowObject is called."); } catch (IllegalStateException) { // expected } // The following should not throw exceptions just because the pool is Closed. Assert.AreEqual(0, pool.KeyedIdleCount(KEY), "A Closed pool shouldn't have any idle objects."); Assert.AreEqual(0, pool.IdleCount, "A Closed pool shouldn't have any idle objects."); int count = pool.ActiveCount; count = pool.KeyedActiveCount(KEY); count++; pool.ReturnObject(KEY, o1); Assert.AreEqual(0, pool.KeyedIdleCount(KEY), "ReturnObject should not add items back into the idle object pool for a Closed pool."); Assert.AreEqual(0, pool.IdleCount, "ReturnObject should not add items back into the idle object pool for a Closed pool."); pool.InvalidateObject(KEY, o2); pool.Clear(KEY); pool.Clear(); pool.Close(); }
public void TestBaseAddObject() { try { pool = MakeEmptyPool(3); } catch (NotSupportedException) { return; // skip this test if unsupported } Object key = MakeKey(0); try { Assert.AreEqual(0, pool.IdleCount); Assert.AreEqual(0, pool.ActiveCount); Assert.AreEqual(0, pool.KeyedIdleCount(key)); Assert.AreEqual(0, pool.KeyedActiveCount(key)); pool.AddObject(key); Assert.AreEqual(1, pool.IdleCount); Assert.AreEqual(0, pool.ActiveCount); Assert.AreEqual(1, pool.KeyedIdleCount(key)); Assert.AreEqual(0, pool.KeyedActiveCount(key)); Object obj = pool.BorrowObject(key); Assert.AreEqual(GetNthObject(key, 0), obj); Assert.AreEqual(0, pool.IdleCount); Assert.AreEqual(1, pool.ActiveCount); Assert.AreEqual(0, pool.KeyedIdleCount(key)); Assert.AreEqual(1, pool.KeyedActiveCount(key)); pool.ReturnObject(key, obj); Assert.AreEqual(1, pool.IdleCount); Assert.AreEqual(0, pool.ActiveCount); Assert.AreEqual(1, pool.KeyedIdleCount(key)); Assert.AreEqual(0, pool.KeyedActiveCount(key)); } catch (NotSupportedException) { return; // skip this test if one of those calls is unsupported } }
public void TestKPOFReturnObjectUsages() { FailingKeyedPoolableObjectFactory factory = new FailingKeyedPoolableObjectFactory(); KeyedObjectPool <Object, Object> pool; try { pool = MakeEmptyPool(factory); } catch (NotSupportedException) { return; // test not supported } List <MethodCall> expectedMethods = new ArrayList <MethodCall>(); Object obj; // Test correct behavior code paths obj = pool.BorrowObject(KEY); Clear(factory, expectedMethods); // returned object should be passivated pool.ReturnObject(KEY, obj); expectedMethods.Add(new MethodCall("passivateObject", KEY, obj)); Assert.AreEqual(expectedMethods, factory.MethodCalls); // Test exception handling of ReturnObject Reset(pool, factory, expectedMethods); // passivateObject should swallow exceptions and not add the object to the pool pool.AddObject(KEY); pool.AddObject(KEY); pool.AddObject(KEY); Assert.AreEqual(3, pool.KeyedIdleCount(KEY)); obj = pool.BorrowObject(KEY); obj = pool.BorrowObject(KEY); Assert.AreEqual(1, pool.KeyedIdleCount(KEY)); Assert.AreEqual(2, pool.KeyedActiveCount(KEY)); Clear(factory, expectedMethods); factory.SuspendObjectFail = true; pool.ReturnObject(KEY, obj); expectedMethods.Add(new MethodCall("passivateObject", KEY, obj)); TestObjectPool.RemoveDestroyObjectCall(factory.MethodCalls); // The exact timing of destroyObject is flexible here. Assert.AreEqual(expectedMethods, factory.MethodCalls); Assert.AreEqual(1, pool.KeyedIdleCount(KEY)); // Not added Assert.AreEqual(1, pool.KeyedActiveCount(KEY)); // But not active Reset(pool, factory, expectedMethods); obj = pool.BorrowObject(KEY); Clear(factory, expectedMethods); factory.SuspendObjectFail = true; factory.DestroyObjectFail = true; try { pool.ReturnObject(KEY, obj); if (!(pool is GenericKeyedObjectPool <Object, Object>)) { Assert.Fail("Expecting DestroyObject exception to be propagated"); } } catch (MethodAccessException) { // Expected } }