public void testKPOFAddObjectUsage() { FailingKeyedPoolableObjectFactory factory = new FailingKeyedPoolableObjectFactory(); KeyedObjectPool <Object, Object> pool; try { pool = MakeEmptyPool(factory); } catch (NotSupportedException) { return; // test not supported } List <MethodCall> expectedMethods = new ArrayList <MethodCall>(); // AddObject should make a new object, pasivate it and put it in the pool pool.AddObject(KEY); expectedMethods.Add(new MethodCall("makeObject", KEY).SetReturned(ZERO)); expectedMethods.Add(new MethodCall("passivateObject", KEY, ZERO)); Assert.AreEqual(expectedMethods, factory.MethodCalls); // Test exception handling of AddObject Reset(pool, factory, expectedMethods); // makeObject Exceptions should be propagated to client code from AddObject factory.CreateObjectFail = true; try { pool.AddObject(KEY); Assert.Fail("Expected AddObject to propagate makeObject exception."); } catch (MethodAccessException) { // expected } expectedMethods.Add(new MethodCall("makeObject", KEY)); Assert.AreEqual(expectedMethods, factory.MethodCalls); Clear(factory, expectedMethods); // passivateObject Exceptions should be propagated to client code from AddObject factory.CreateObjectFail = false; factory.SuspendObjectFail = true; try { pool.AddObject(KEY); Assert.Fail("Expected AddObject to propagate passivateObject exception."); } catch (MethodAccessException) { // expected } expectedMethods.Add(new MethodCall("makeObject", KEY).SetReturned(ONE)); expectedMethods.Add(new MethodCall("passivateObject", KEY, ONE)); Assert.AreEqual(expectedMethods, factory.MethodCalls); }
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 static void PreFill <K, V>(KeyedObjectPool <K, V> keyedPool, K key, int count) where V : class { if (keyedPool == null) { throw new ArgumentException("keyedPool must not be null."); } if (key == null) { throw new ArgumentException("key must not be null."); } for (int i = 0; i < count; i++) { keyedPool.AddObject(key); } }
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 } }
public void TestKPOFBorrowObjectUsages() { 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; if (pool is GenericKeyedObjectPool <Object, Object> ) { ((GenericKeyedObjectPool <Object, Object>)pool).TestOnBorrow = true; } // Test correct behavior code paths // existing idle object should be activated and validated pool.AddObject(KEY); Clear(factory, expectedMethods); obj = pool.BorrowObject(KEY); expectedMethods.Add(new MethodCall("activateObject", KEY, ZERO)); expectedMethods.Add(new MethodCall("validateObject", KEY, ZERO).SetReturned(true)); Assert.AreEqual(expectedMethods, factory.MethodCalls); pool.ReturnObject(KEY, obj); // Test exception handling of BorrowObject Reset(pool, factory, expectedMethods); // makeObject Exceptions should be propagated to client code from BorrowObject factory.CreateObjectFail = true; try { obj = pool.BorrowObject(KEY); Assert.Fail("Expected BorrowObject to propagate makeObject exception."); } catch (MethodAccessException) { // expected } expectedMethods.Add(new MethodCall("makeObject", KEY)); Assert.AreEqual(expectedMethods, factory.MethodCalls); // when activateObject fails in BorrowObject, a new object should be borrowed/created Reset(pool, factory, expectedMethods); pool.AddObject(KEY); Clear(factory, expectedMethods); factory.ActivateObjectFail = true; expectedMethods.Add(new MethodCall("activateObject", KEY, obj)); try { obj = pool.BorrowObject(KEY); Assert.Fail("Expecting NoSuchElementException"); } catch (NoSuchElementException) { //Activate should fail } // After idle object fails validation, new on is created and activation // fails again for the new one. expectedMethods.Add(new MethodCall("makeObject", KEY).SetReturned(ONE)); expectedMethods.Add(new MethodCall("activateObject", KEY, ONE)); TestObjectPool.RemoveDestroyObjectCall(factory.MethodCalls); // The exact timing of destroyObject is flexible here. Assert.AreEqual(expectedMethods, factory.MethodCalls); // when validateObject fails in BorrowObject, a new object should be borrowed/created Reset(pool, factory, expectedMethods); pool.AddObject(KEY); Clear(factory, expectedMethods); factory.ValidateObjectFail = true; // testOnBorrow is on, so this will throw when the newly created instance // fails validation try { obj = pool.BorrowObject(KEY); Assert.Fail("Expecting NoSuchElementException"); } catch (NoSuchElementException) { // expected } // Activate, then validate for idle instance expectedMethods.Add(new MethodCall("activateObject", KEY, ZERO)); expectedMethods.Add(new MethodCall("validateObject", KEY, ZERO)); // Make new instance, activate succeeds, validate fails expectedMethods.Add(new MethodCall("makeObject", KEY).SetReturned(ONE)); expectedMethods.Add(new MethodCall("activateObject", KEY, ONE)); expectedMethods.Add(new MethodCall("validateObject", KEY, ONE)); TestObjectPool.RemoveDestroyObjectCall(factory.MethodCalls); Assert.AreEqual(expectedMethods, factory.MethodCalls); }