From 3a80de9806cbdd0461716e814f5e674e259d42b3 Mon Sep 17 00:00:00 2001 From: Jim Hahn Date: Thu, 29 Mar 2018 15:07:36 -0400 Subject: Add api-resource-locks feature Added ResourceLockFeatureAPI, to provide an interface for PolicyGuard to use to access other locking mechanisms. Move lock API to policy-core. Changed the interface and added Callback support. Added a class to invoke the API implementers. Changed to set a future instead of expecting the callback to implement the future interface. Also refactored, creating "lock" sub-package. Add junit tests. Increase junit coverage. IsLocked & isLockedBy should check all arguments. Make ImplFuture protected instead of public. Simplify locking - move callback support to an optional feature. Move Reference class to policy-utils. Return plain Future instead of LockRequestFuture. Change-Id: I65154d33833914b4332e02d1ef2512f4c5f09b16 Issue-ID: POLICY-577 Signed-off-by: Jim Hahn --- .../drools/core/lock/LockRequestFutureTest.java | 431 +++++++++++++++++ .../org/onap/policy/drools/core/lock/LockTest.java | 131 ++++++ .../lock/PolicyResourceLockFeatureAPITest.java | 76 +++ .../core/lock/PolicyResourceLockManagerTest.java | 509 +++++++++++++++++++++ .../drools/core/lock/SimpleLockManagerTest.java | 280 ++++++++++++ .../onap/policy/drools/core/lock/TestUtils.java | 59 +++ 6 files changed, 1486 insertions(+) create mode 100644 policy-core/src/test/java/org/onap/policy/drools/core/lock/LockRequestFutureTest.java create mode 100644 policy-core/src/test/java/org/onap/policy/drools/core/lock/LockTest.java create mode 100644 policy-core/src/test/java/org/onap/policy/drools/core/lock/PolicyResourceLockFeatureAPITest.java create mode 100644 policy-core/src/test/java/org/onap/policy/drools/core/lock/PolicyResourceLockManagerTest.java create mode 100644 policy-core/src/test/java/org/onap/policy/drools/core/lock/SimpleLockManagerTest.java create mode 100644 policy-core/src/test/java/org/onap/policy/drools/core/lock/TestUtils.java (limited to 'policy-core/src/test/java/org') diff --git a/policy-core/src/test/java/org/onap/policy/drools/core/lock/LockRequestFutureTest.java b/policy-core/src/test/java/org/onap/policy/drools/core/lock/LockRequestFutureTest.java new file mode 100644 index 00000000..883778eb --- /dev/null +++ b/policy-core/src/test/java/org/onap/policy/drools/core/lock/LockRequestFutureTest.java @@ -0,0 +1,431 @@ +/* + * ============LICENSE_START======================================================= + * ONAP + * ================================================================================ + * Copyright (C) 2018 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * Licensed 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. + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.drools.core.lock; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; +import static org.mockito.ArgumentMatchers.anyBoolean; +import static org.mockito.Mockito.doThrow; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.never; +import static org.mockito.Mockito.verify; +import static org.onap.policy.drools.core.lock.TestUtils.expectException; +import java.util.concurrent.CancellationException; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.TimeoutException; +import org.junit.Before; +import org.junit.Test; +import org.onap.policy.drools.core.lock.PolicyResourceLockFeatureAPI.Callback; + +public class LockRequestFutureTest { + + private static final int WAIT_SEC = 1; + private static final String RESOURCE = "my.resource"; + private static final String OWNER = "my.owner"; + private static final String EXPECTED_EXCEPTION = "expected exception"; + + private Callback callback; + private LockRequestFuture fut; + + @Before + public void setUp() { + callback = mock(Callback.class); + fut = new LockRequestFuture(RESOURCE, OWNER, callback); + } + + @Test + public void testLockRequestFutureStringStringBoolean_False() throws Exception { + fut = new LockRequestFuture(RESOURCE, OWNER, false); + + assertTrue(fut.isDone()); + assertEquals(RESOURCE, fut.getResourceId()); + assertEquals(OWNER, fut.getOwner()); + + assertFalse(fut.isLocked()); + assertFalse(fut.get(0, TimeUnit.SECONDS)); + } + + @Test + public void testLockRequestFutureStringStringBoolean_True() throws Exception { + fut = new LockRequestFuture(RESOURCE, OWNER, true); + + assertTrue(fut.isDone()); + assertEquals(RESOURCE, fut.getResourceId()); + assertEquals(OWNER, fut.getOwner()); + + assertTrue(fut.isLocked()); + assertTrue(fut.get(0, TimeUnit.SECONDS)); + } + + @Test + public void testLockRequestFutureStringStringBoolean_ArgEx() throws Exception { + + // null resource id + IllegalArgumentException ex = expectException(IllegalArgumentException.class, + xxx -> new LockRequestFuture(null, OWNER, true)); + assertEquals("null resourceId", ex.getMessage()); + + + // null owner + ex = expectException(IllegalArgumentException.class, xxx -> new LockRequestFuture(RESOURCE, null, true)); + assertEquals("null owner", ex.getMessage()); + } + + @Test + public void testLockRequestFutureStringStringCallback() throws Exception { + assertFalse(fut.isDone()); + assertEquals(RESOURCE, fut.getResourceId()); + assertEquals(OWNER, fut.getOwner()); + + fut.setLocked(true); + fut.invokeCallback(); + + // ensure it invoked the callback + verify(callback).set(true); + } + + @Test + public void testLockRequestFutureStringStringCallback_ArgEx() throws Exception { + + // null resource id + IllegalArgumentException ex = expectException(IllegalArgumentException.class, + xxx -> new LockRequestFuture(null, OWNER, callback)); + assertEquals("null resourceId", ex.getMessage()); + + + // null owner + ex = expectException(IllegalArgumentException.class, xxx -> new LockRequestFuture(RESOURCE, null, callback)); + assertEquals("null owner", ex.getMessage()); + + + // null callback is OK + new LockRequestFuture(RESOURCE, OWNER, null); + } + + @Test + public void testGetResourceId() { + assertEquals(RESOURCE, fut.getResourceId()); + } + + @Test + public void testGetOwner() { + assertEquals(OWNER, fut.getOwner()); + } + + @Test + public void testCancel() throws Exception { + // not cancelled yet + assertFalse(fut.isDone()); + + // cancel it + assertTrue(fut.cancel(false)); + assertTrue(fut.isDone()); + + // should not block now + expectException(CancellationException.class, xxx -> fut.get(0, TimeUnit.SECONDS)); + + } + + @Test + public void testCancel_AlreadyCancelled() throws Exception { + + fut.cancel(true); + + assertFalse(fut.cancel(true)); + assertTrue(fut.isDone()); + + expectException(CancellationException.class, xxx -> fut.get(0, TimeUnit.SECONDS)); + } + + @Test + public void testCancel_AlreadyAcquired() throws Exception { + + fut.setLocked(true); + + assertFalse(fut.cancel(true)); + assertTrue(fut.isDone()); + assertTrue(fut.get(0, TimeUnit.SECONDS)); + } + + @Test + public void testCancel_AlreadyDenied() throws Exception { + + fut.setLocked(false); + + assertFalse(fut.cancel(true)); + assertTrue(fut.isDone()); + assertFalse(fut.get(0, TimeUnit.SECONDS)); + } + + @Test + public void testSetLocked_True() throws Exception { + assertTrue(fut.setLocked(true)); + + assertTrue(fut.isDone()); + assertTrue(fut.get(0, TimeUnit.SECONDS)); + } + + @Test + public void testSetLocked_False() throws Exception { + assertTrue(fut.setLocked(false)); + + assertTrue(fut.isDone()); + assertFalse(fut.get(0, TimeUnit.SECONDS)); + } + + @Test + public void testSetLocked_AlreadyCancelled() { + + fut.cancel(true); + + assertFalse(fut.setLocked(true)); + assertFalse(fut.setLocked(false)); + + assertTrue(fut.isDone()); + expectException(CancellationException.class, xxx -> fut.get(0, TimeUnit.SECONDS)); + } + + @Test + public void testSetLocked_AlreadyAcquired() throws Exception { + fut.setLocked(true); + + assertTrue(fut.isDone()); + assertTrue(fut.get(0, TimeUnit.SECONDS)); + + assertFalse(fut.cancel(true)); + assertFalse(fut.setLocked(true)); + assertFalse(fut.setLocked(false)); + } + + @Test + public void testSetLocked_AlreadyDenied() throws Exception { + fut.setLocked(false); + + assertTrue(fut.isDone()); + assertFalse(fut.get(0, TimeUnit.SECONDS)); + + assertFalse(fut.cancel(true)); + assertFalse(fut.setLocked(true)); + assertFalse(fut.setLocked(false)); + } + + @Test + public void testIsCancelled() { + assertFalse(fut.isCancelled()); + + fut.cancel(false); + assertTrue(fut.isCancelled()); + } + + @Test + public void testIsCancelled_Acquired() { + fut.setLocked(true); + assertFalse(fut.isCancelled()); + } + + @Test + public void testIsCancelled_Denied() { + fut.setLocked(false); + assertFalse(fut.isCancelled()); + } + + @Test + public void testIsDone_Cancelled() { + fut.cancel(false); + assertTrue(fut.isDone()); + } + + @Test + public void testIsDone_Acquired() { + fut.setLocked(true); + assertTrue(fut.isDone()); + } + + @Test + public void testIsDone_Denied() { + fut.setLocked(false); + assertTrue(fut.isDone()); + } + + @Test + public void testIsDone_Waiting() { + assertFalse(fut.isDone()); + } + + @Test + public void testIsLocked_Cancelled() { + fut.cancel(false); + assertFalse(fut.isLocked()); + } + + @Test + public void testIsLocked_Acquired() { + fut.setLocked(true); + assertTrue(fut.isLocked()); + } + + @Test + public void testIsLocked_Denied() { + fut.setLocked(false); + assertFalse(fut.isLocked()); + } + + @Test + public void testIsLocked_Waiting() { + assertFalse(fut.isLocked()); + } + + @Test + public void testGet_Cancelled() throws Exception { + new Thread() { + @Override + public void run() { + fut.cancel(false); + } + }.start(); + + expectException(CancellationException.class, xxx -> fut.get()); + } + + @Test + public void testGet_Acquired() throws Exception { + new Thread() { + @Override + public void run() { + fut.setLocked(true); + } + }.start(); + + assertTrue(fut.get()); + } + + @Test + public void testGet_Denied() throws Exception { + new Thread() { + @Override + public void run() { + fut.setLocked(false); + } + }.start(); + + assertFalse(fut.get()); + } + + @Test + public void testGetLongTimeUnit() throws Exception { + expectException(TimeoutException.class, xxx -> fut.get(0, TimeUnit.SECONDS)); + + fut.setLocked(true); + assertTrue(fut.get(0, TimeUnit.SECONDS)); + } + + @Test + public void testGetLongTimeUnit_Timeout() throws Exception { + expectException(TimeoutException.class, xxx -> fut.get(0, TimeUnit.SECONDS)); + expectException(TimeoutException.class, xxx -> fut.get(2, TimeUnit.MILLISECONDS)); + } + + @Test + public void testGetLongTimeUnit_Cancelled() throws Exception { + new Thread() { + @Override + public void run() { + fut.cancel(false); + } + }.start(); + + expectException(CancellationException.class, xxx -> fut.get(WAIT_SEC, TimeUnit.SECONDS)); + } + + @Test + public void testGetLongTimeUnit_Acquired() throws Exception { + new Thread() { + @Override + public void run() { + fut.setLocked(true); + } + }.start(); + + assertTrue(fut.get(WAIT_SEC, TimeUnit.SECONDS)); + } + + @Test + public void testGetLongTimeUnit_Denied() throws Exception { + new Thread() { + @Override + public void run() { + fut.setLocked(false); + } + }.start(); + + assertFalse(fut.get(WAIT_SEC, TimeUnit.SECONDS)); + } + + @Test(expected = IllegalStateException.class) + public void testInvokeCallback() { + fut.setLocked(true); + fut.invokeCallback(); + + // re-invoke - should throw an exception + fut.invokeCallback(); + } + + @Test(expected = IllegalStateException.class) + public void testInvokeCallback_Cancelled() { + fut.cancel(false); + + // invoke after cancel - should throw an exception + fut.invokeCallback(); + } + + @Test + public void testInvokeCallback_Acquired() { + fut.setLocked(true); + fut.invokeCallback(); + + verify(callback).set(true); + verify(callback, never()).set(false); + } + + @Test + public void testInvokeCallback_Denied() { + fut.setLocked(false); + fut.invokeCallback(); + + verify(callback).set(false); + verify(callback, never()).set(true); + } + + @Test + public void testInvokeCallback_Ex() { + doThrow(new RuntimeException(EXPECTED_EXCEPTION)).when(callback).set(anyBoolean()); + + fut.setLocked(false); + fut.invokeCallback(); + } + + @Test + public void testMakeNullArgException() { + IllegalArgumentException ex = LockRequestFuture.makeNullArgException(EXPECTED_EXCEPTION); + assertEquals(EXPECTED_EXCEPTION, ex.getMessage()); + } +} diff --git a/policy-core/src/test/java/org/onap/policy/drools/core/lock/LockTest.java b/policy-core/src/test/java/org/onap/policy/drools/core/lock/LockTest.java new file mode 100644 index 00000000..bd11dcf9 --- /dev/null +++ b/policy-core/src/test/java/org/onap/policy/drools/core/lock/LockTest.java @@ -0,0 +1,131 @@ +/* + * ============LICENSE_START======================================================= + * ONAP + * ================================================================================ + * Copyright (C) 2018 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * Licensed 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. + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.drools.core.lock; + +import static org.junit.Assert.*; +import org.junit.Before; +import org.junit.Test; +import org.onap.policy.drools.core.lock.Lock.RemoveResult; +import org.onap.policy.drools.utils.Pair; + +public class LockTest { + + private static final String OWNER = "my.owner"; + private static final String OWNER2 = "another.owner"; + private static final String OWNER3 = "third.owner"; + + private static final Integer ITEM2 = 10; + private static final Integer ITEM3 = 20; + + private Lock lock; + private Pair newOwner; + + @Before + public void setUp() { + lock = new Lock<>(OWNER); + newOwner = new Pair<>(null, null); + } + + + @Test + public void testLock() { + assertEquals(OWNER, lock.getOwner()); + } + + @Test + public void testGetOwner() { + assertEquals(OWNER, lock.getOwner()); + } + + @Test + public void testAdd() { + assertTrue(lock.add(OWNER2, ITEM2)); + assertTrue(lock.add(OWNER3, ITEM3)); + + // attempt to re-add owner2 with the same item - should fail + assertFalse(lock.add(OWNER2, ITEM2)); + + // attempt to re-add owner2 with a different item - should fail + assertFalse(lock.add(OWNER2, ITEM3)); + } + + @Test(expected = IllegalArgumentException.class) + public void testAdd_ArgEx() { + lock.add(OWNER2, null); + } + + @Test + public void testAdd_AlreadyOwner() { + assertFalse(lock.add(OWNER, ITEM2)); + } + + @Test + public void testAdd_AlreadyInQueue() { + lock.add(OWNER2, ITEM2); + + assertFalse(lock.add(OWNER2, ITEM2)); + } + + @Test + public void testRemoveRequester_Owner_QueueEmpty() { + assertEquals(RemoveResult.UNLOCKED, lock.removeRequester(OWNER, newOwner)); + } + + @Test + public void testRemoveRequester_Owner_QueueHasOneItem() { + lock.add(OWNER2, ITEM2); + + assertEquals(RemoveResult.RELOCKED, lock.removeRequester(OWNER, newOwner)); + assertEquals(OWNER2, newOwner.first()); + assertEquals(ITEM2, newOwner.second()); + + assertEquals(RemoveResult.UNLOCKED, lock.removeRequester(OWNER2, newOwner)); + } + + @Test + public void testRemoveRequester_Owner_QueueHasMultipleItems() { + lock.add(OWNER2, ITEM2); + lock.add(OWNER3, ITEM3); + + assertEquals(RemoveResult.RELOCKED, lock.removeRequester(OWNER, newOwner)); + assertEquals(OWNER2, newOwner.first()); + assertEquals(ITEM2, newOwner.second()); + + assertEquals(RemoveResult.RELOCKED, lock.removeRequester(OWNER2, newOwner)); + assertEquals(OWNER3, newOwner.first()); + assertEquals(ITEM3, newOwner.second()); + + assertEquals(RemoveResult.UNLOCKED, lock.removeRequester(OWNER3, newOwner)); + } + + @Test + public void testRemoveRequester_InQueue() { + lock.add(OWNER2, ITEM2); + + assertEquals(RemoveResult.REMOVED, lock.removeRequester(OWNER2, newOwner)); + } + + @Test + public void testRemoveRequester_NeitherOwnerNorInQueue() { + assertEquals(RemoveResult.NOT_FOUND, lock.removeRequester(OWNER2, newOwner)); + } + +} diff --git a/policy-core/src/test/java/org/onap/policy/drools/core/lock/PolicyResourceLockFeatureAPITest.java b/policy-core/src/test/java/org/onap/policy/drools/core/lock/PolicyResourceLockFeatureAPITest.java new file mode 100644 index 00000000..5a826bb7 --- /dev/null +++ b/policy-core/src/test/java/org/onap/policy/drools/core/lock/PolicyResourceLockFeatureAPITest.java @@ -0,0 +1,76 @@ +/* + * ============LICENSE_START======================================================= + * api-resource-locks + * ================================================================================ + * Copyright (C) 2018 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * Licensed 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. + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.drools.core.lock; + +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNull; +import org.junit.Before; +import org.junit.Test; + +public class PolicyResourceLockFeatureAPITest { + + private static final String RESOURCE_ID = "the resource"; + private static final String OWNER = "the owner"; + + private PolicyResourceLockFeatureAPI api; + + @Before + public void setUp() { + api = new PolicyResourceLockFeatureAPI() { + @Override + public int getSequenceNumber() { + return 0; + } + }; + } + + @Test + public void testBeforeLock() { + assertNull(api.beforeLock(RESOURCE_ID, OWNER, null)); + } + + @Test + public void testAfterLock() { + assertFalse(api.afterLock(RESOURCE_ID, OWNER, true)); + assertFalse(api.afterLock(RESOURCE_ID, OWNER, false)); + } + + @Test + public void testBeforeUnlock() { + assertNull(api.beforeUnlock(RESOURCE_ID, OWNER)); + } + + @Test + public void testAfterUnlock() { + assertFalse(api.afterUnlock(RESOURCE_ID, OWNER, true)); + assertFalse(api.afterUnlock(RESOURCE_ID, OWNER, false)); + } + + @Test + public void testBeforeIsLocked() { + assertNull(api.beforeIsLocked(RESOURCE_ID)); + } + + @Test + public void testBeforeIsLockedBy() { + assertNull(api.beforeIsLockedBy(RESOURCE_ID, OWNER)); + } +} diff --git a/policy-core/src/test/java/org/onap/policy/drools/core/lock/PolicyResourceLockManagerTest.java b/policy-core/src/test/java/org/onap/policy/drools/core/lock/PolicyResourceLockManagerTest.java new file mode 100644 index 00000000..2f8b5f83 --- /dev/null +++ b/policy-core/src/test/java/org/onap/policy/drools/core/lock/PolicyResourceLockManagerTest.java @@ -0,0 +1,509 @@ +/* + * ============LICENSE_START======================================================= + * ONAP + * ================================================================================ + * Copyright (C) 2018 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * Licensed 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. + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.drools.core.lock; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertTrue; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.anyBoolean; +import static org.mockito.ArgumentMatchers.anyString; +import static org.mockito.Mockito.doThrow; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.never; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; +import static org.onap.policy.drools.core.lock.TestUtils.expectException; +import java.util.Arrays; +import java.util.LinkedList; +import java.util.List; +import java.util.concurrent.Future; +import org.junit.AfterClass; +import org.junit.Before; +import org.junit.BeforeClass; +import org.junit.Test; +import org.onap.policy.drools.core.lock.PolicyResourceLockFeatureAPI.Callback; +import org.onap.policy.drools.core.lock.PolicyResourceLockManager.Factory; + +public class PolicyResourceLockManagerTest { + + private static final String NULL_RESOURCE_ID = "null resourceId"; + private static final String NULL_OWNER = "null owner"; + + private static final String RESOURCE_A = "resource.a"; + private static final String RESOURCE_B = "resource.b"; + private static final String RESOURCE_C = "resource.c"; + + private static final String OWNER1 = "owner.one"; + private static final String OWNER2 = "owner.two"; + private static final String OWNER3 = "owner.three"; + + /** + * Saved at the start of the tests and restored once all tests complete. + */ + private static Factory saveFactory; + + private Callback callback1; + private PolicyResourceLockFeatureAPI impl1; + private PolicyResourceLockFeatureAPI impl2; + private List implList; + + private Future fut; + + private PolicyResourceLockManager mgr; + + @BeforeClass + public static void setUpBeforeClass() { + saveFactory = PolicyResourceLockManager.getFactory(); + } + + @AfterClass + public static void tearDownAfterClass() { + PolicyResourceLockManager.setFactory(saveFactory); + } + + @Before + public void setUp() { + callback1 = mock(Callback.class); + impl1 = mock(PolicyResourceLockFeatureAPI.class); + impl2 = mock(PolicyResourceLockFeatureAPI.class); + + initImplementer(impl1); + initImplementer(impl2); + + // list of feature API implementers + implList = new LinkedList<>(Arrays.asList(impl1, impl2)); + + PolicyResourceLockManager.setFactory(new Factory() { + + @Override + public List getImplementers() { + return implList; + } + }); + + mgr = new PolicyResourceLockManager(); + } + + /** + * Initializes an implementer so it always returns {@code null}. + * + * @param impl + */ + private void initImplementer(PolicyResourceLockFeatureAPI impl) { + when(impl.beforeLock(anyString(), anyString(), any(Callback.class))).thenReturn(null); + when(impl.beforeUnlock(anyString(), anyString())).thenReturn(null); + when(impl.beforeIsLocked(anyString())).thenReturn(null); + when(impl.beforeIsLockedBy(anyString(), anyString())).thenReturn(null); + } + + @Test + public void testLock() throws Exception { + fut = mgr.lock(RESOURCE_A, OWNER1, callback1); + + assertTrue(fut.isDone()); + assertTrue(fut.get()); + + verify(impl1).beforeLock(RESOURCE_A, OWNER1, callback1); + verify(impl2).beforeLock(RESOURCE_A, OWNER1, callback1); + verify(impl1).afterLock(RESOURCE_A, OWNER1, true); + verify(impl2).afterLock(RESOURCE_A, OWNER1, true); + + assertTrue(mgr.isLocked(RESOURCE_A)); + assertTrue(mgr.isLockedBy(RESOURCE_A, OWNER1)); + assertFalse(mgr.isLocked(RESOURCE_B)); + assertFalse(mgr.isLockedBy(RESOURCE_A, OWNER2)); + + // null callback - not locked yet + fut = mgr.lock(RESOURCE_C, OWNER3, null); + assertTrue(fut.isDone()); + assertTrue(fut.get()); + + // null callback - already locked + fut = mgr.lock(RESOURCE_A, OWNER3, null); + assertTrue(fut.isDone()); + assertFalse(fut.get()); + } + + @Test + public void testLock_ArgEx() { + IllegalArgumentException ex = + expectException(IllegalArgumentException.class, xxx -> mgr.lock(null, OWNER1, callback1)); + assertEquals(NULL_RESOURCE_ID, ex.getMessage()); + + ex = expectException(IllegalArgumentException.class, xxx -> mgr.lock(RESOURCE_A, null, callback1)); + assertEquals(NULL_OWNER, ex.getMessage()); + + // this should not throw an exception + mgr.lock(RESOURCE_A, OWNER1, null); + } + + @Test + public void testLock_BeforeIntercepted() { + fut = mock(LockRequestFuture.class); + + // NOT async + when(fut.isDone()).thenReturn(true); + + // have impl1 intercept + when(impl1.beforeLock(RESOURCE_A, OWNER1, callback1)).thenReturn(fut); + + assertEquals(fut, mgr.lock(RESOURCE_A, OWNER1, callback1)); + + verify(impl1).beforeLock(RESOURCE_A, OWNER1, callback1); + verify(impl2, never()).beforeLock(anyString(), anyString(), any(Callback.class)); + + verify(impl1, never()).afterLock(anyString(), anyString(), anyBoolean()); + verify(impl2, never()).afterLock(anyString(), anyString(), anyBoolean()); + } + + @Test + public void testLock_Acquired_AfterIntercepted() throws Exception { + + // impl1 intercepts during afterLock() + when(impl1.afterLock(RESOURCE_A, OWNER1, true)).thenReturn(true); + + fut = mgr.lock(RESOURCE_A, OWNER1, callback1); + + assertTrue(fut.isDone()); + assertTrue(fut.get()); + + // impl1 sees it, but impl2 does not + verify(impl1).afterLock(RESOURCE_A, OWNER1, true); + verify(impl2, never()).afterLock(anyString(), anyString(), anyBoolean()); + } + + @Test + public void testLock_Acquired() throws Exception { + fut = mgr.lock(RESOURCE_A, OWNER1, callback1); + + assertTrue(fut.isDone()); + assertTrue(fut.get()); + + verify(impl1).afterLock(RESOURCE_A, OWNER1, true); + verify(impl2).afterLock(RESOURCE_A, OWNER1, true); + } + + @Test + public void testLock_Denied_AfterIntercepted() throws Exception { + + mgr.lock(RESOURCE_A, OWNER1, callback1); + + // impl1 intercepts during afterLock() + when(impl1.afterLock(RESOURCE_A, OWNER2, false)).thenReturn(true); + + // owner2 tries to lock + fut = mgr.lock(RESOURCE_A, OWNER2, null); + + assertTrue(fut.isDone()); + assertFalse(fut.get()); + + // impl1 sees it, but impl2 does not + verify(impl1).afterLock(RESOURCE_A, OWNER2, false); + verify(impl2, never()).afterLock(RESOURCE_A, OWNER2, false); + } + + @Test + public void testLock_Denied() { + + mgr.lock(RESOURCE_A, OWNER1, callback1); + + // owner2 tries to lock + fut = mgr.lock(RESOURCE_A, OWNER2, null); + + verify(impl1).afterLock(RESOURCE_A, OWNER2, false); + verify(impl2).afterLock(RESOURCE_A, OWNER2, false); + } + + @Test + public void testUnlock() throws Exception { + mgr.lock(RESOURCE_A, OWNER1, null); + mgr.lock(RESOURCE_B, OWNER1, null); + + assertTrue(mgr.unlock(RESOURCE_A, OWNER1)); + + verify(impl1).beforeUnlock(RESOURCE_A, OWNER1); + verify(impl2).beforeUnlock(RESOURCE_A, OWNER1); + + verify(impl1).afterUnlock(RESOURCE_A, OWNER1, true); + verify(impl2).afterUnlock(RESOURCE_A, OWNER1, true); + } + + @Test + public void testUnlock_ArgEx() { + IllegalArgumentException ex = expectException(IllegalArgumentException.class, xxx -> mgr.unlock(null, OWNER1)); + assertEquals(NULL_RESOURCE_ID, ex.getMessage()); + + ex = expectException(IllegalArgumentException.class, xxx -> mgr.unlock(RESOURCE_A, null)); + assertEquals(NULL_OWNER, ex.getMessage()); + } + + @Test + public void testUnlock_BeforeInterceptedTrue() { + + mgr.lock(RESOURCE_A, OWNER1, null); + + // have impl1 intercept + when(impl1.beforeUnlock(RESOURCE_A, OWNER1)).thenReturn(true); + + assertTrue(mgr.unlock(RESOURCE_A, OWNER1)); + + verify(impl1).beforeUnlock(RESOURCE_A, OWNER1); + verify(impl2, never()).beforeUnlock(anyString(), anyString()); + + verify(impl1, never()).afterUnlock(anyString(), anyString(), anyBoolean()); + verify(impl2, never()).afterUnlock(anyString(), anyString(), anyBoolean()); + } + + @Test + public void testUnlock_BeforeInterceptedFalse() { + + mgr.lock(RESOURCE_A, OWNER1, null); + + // have impl1 intercept + when(impl1.beforeUnlock(RESOURCE_A, OWNER1)).thenReturn(false); + + assertFalse(mgr.unlock(RESOURCE_A, OWNER1)); + + verify(impl1).beforeUnlock(RESOURCE_A, OWNER1); + verify(impl2, never()).beforeUnlock(anyString(), anyString()); + + verify(impl1, never()).afterUnlock(anyString(), anyString(), anyBoolean()); + verify(impl2, never()).afterUnlock(anyString(), anyString(), anyBoolean()); + } + + @Test + public void testUnlock_Unlocked() { + mgr.lock(RESOURCE_A, OWNER1, null); + + assertTrue(mgr.unlock(RESOURCE_A, OWNER1)); + + verify(impl1).beforeUnlock(RESOURCE_A, OWNER1); + verify(impl2).beforeUnlock(RESOURCE_A, OWNER1); + + verify(impl1).afterUnlock(RESOURCE_A, OWNER1, true); + verify(impl2).afterUnlock(RESOURCE_A, OWNER1, true); + } + + @Test + public void testUnlock_Unlocked_AfterIntercepted() { + // have impl1 intercept + when(impl1.afterUnlock(RESOURCE_A, OWNER1, true)).thenReturn(true); + + mgr.lock(RESOURCE_A, OWNER1, null); + + assertTrue(mgr.unlock(RESOURCE_A, OWNER1)); + + verify(impl1).beforeUnlock(RESOURCE_A, OWNER1); + verify(impl2).beforeUnlock(RESOURCE_A, OWNER1); + + verify(impl1).afterUnlock(RESOURCE_A, OWNER1, true); + verify(impl2, never()).afterUnlock(RESOURCE_A, OWNER1, true); + } + + @Test + public void testUnlock_NotUnlocked() { + assertFalse(mgr.unlock(RESOURCE_A, OWNER1)); + + verify(impl1).beforeUnlock(RESOURCE_A, OWNER1); + verify(impl2).beforeUnlock(RESOURCE_A, OWNER1); + + verify(impl1).afterUnlock(RESOURCE_A, OWNER1, false); + verify(impl2).afterUnlock(RESOURCE_A, OWNER1, false); + } + + @Test + public void testUnlock_NotUnlocked_AfterIntercepted() { + // have impl1 intercept + when(impl1.afterUnlock(RESOURCE_A, OWNER1, false)).thenReturn(true); + + assertFalse(mgr.unlock(RESOURCE_A, OWNER1)); + + verify(impl1).beforeUnlock(RESOURCE_A, OWNER1); + verify(impl2).beforeUnlock(RESOURCE_A, OWNER1); + + verify(impl1).afterUnlock(RESOURCE_A, OWNER1, false); + verify(impl2, never()).afterUnlock(RESOURCE_A, OWNER1, false); + } + + @Test + public void testIsLocked_True() { + mgr.lock(RESOURCE_A, OWNER1, null); + + assertTrue(mgr.isLocked(RESOURCE_A)); + + verify(impl1).beforeIsLocked(RESOURCE_A); + verify(impl2).beforeIsLocked(RESOURCE_A); + } + + @Test + public void testIsLocked_False() { + assertFalse(mgr.isLocked(RESOURCE_A)); + + verify(impl1).beforeIsLocked(RESOURCE_A); + verify(impl2).beforeIsLocked(RESOURCE_A); + } + + @Test + public void testIsLocked_ArgEx() { + IllegalArgumentException ex = expectException(IllegalArgumentException.class, xxx -> mgr.isLocked(null)); + assertEquals(NULL_RESOURCE_ID, ex.getMessage()); + } + + @Test + public void testIsLocked_BeforeIntercepted_True() { + + // have impl1 intercept + when(impl1.beforeIsLocked(RESOURCE_A)).thenReturn(true); + + assertTrue(mgr.isLocked(RESOURCE_A)); + + verify(impl1).beforeIsLocked(RESOURCE_A); + verify(impl2, never()).beforeIsLocked(RESOURCE_A); + } + + @Test + public void testIsLocked_BeforeIntercepted_False() { + + // lock it so we can verify that impl1 overrides the superclass isLocker() + mgr.lock(RESOURCE_A, OWNER1, null); + + // have impl1 intercept + when(impl1.beforeIsLocked(RESOURCE_A)).thenReturn(false); + + assertFalse(mgr.isLocked(RESOURCE_A)); + + verify(impl1).beforeIsLocked(RESOURCE_A); + verify(impl2, never()).beforeIsLocked(RESOURCE_A); + } + + @Test + public void testIsLockedBy_True() { + mgr.lock(RESOURCE_A, OWNER1, null); + + assertTrue(mgr.isLockedBy(RESOURCE_A, OWNER1)); + + verify(impl1).beforeIsLockedBy(RESOURCE_A, OWNER1); + verify(impl2).beforeIsLockedBy(RESOURCE_A, OWNER1); + } + + @Test + public void testIsLockedBy_False() { + // different owner + mgr.lock(RESOURCE_A, OWNER2, null); + + assertFalse(mgr.isLockedBy(RESOURCE_A, OWNER1)); + + verify(impl1).beforeIsLockedBy(RESOURCE_A, OWNER1); + verify(impl2).beforeIsLockedBy(RESOURCE_A, OWNER1); + } + + @Test + public void testIsLockedBy_ArgEx() { + IllegalArgumentException ex = + expectException(IllegalArgumentException.class, xxx -> mgr.isLockedBy(null, OWNER1)); + assertEquals(NULL_RESOURCE_ID, ex.getMessage()); + + ex = expectException(IllegalArgumentException.class, xxx -> mgr.isLockedBy(RESOURCE_A, null)); + assertEquals(NULL_OWNER, ex.getMessage()); + } + + @Test + public void testIsLockedBy_BeforeIntercepted_True() { + + // have impl1 intercept + when(impl1.beforeIsLockedBy(RESOURCE_A, OWNER1)).thenReturn(true); + + assertTrue(mgr.isLockedBy(RESOURCE_A, OWNER1)); + + verify(impl1).beforeIsLockedBy(RESOURCE_A, OWNER1); + verify(impl2, never()).beforeIsLockedBy(RESOURCE_A, OWNER1); + } + + @Test + public void testIsLockedBy_BeforeIntercepted_False() { + + // lock it so we can verify that impl1 overrides the superclass isLocker() + mgr.lock(RESOURCE_A, OWNER1, null); + + // have impl1 intercept + when(impl1.beforeIsLockedBy(RESOURCE_A, OWNER1)).thenReturn(false); + + assertFalse(mgr.isLockedBy(RESOURCE_A, OWNER1)); + + verify(impl1).beforeIsLockedBy(RESOURCE_A, OWNER1); + verify(impl2, never()).beforeIsLockedBy(RESOURCE_A, OWNER1); + } + + @Test + public void testGetInstance() { + PolicyResourceLockManager inst = PolicyResourceLockManager.getInstance(); + assertNotNull(inst); + + // should return the same instance each time + assertEquals(inst, PolicyResourceLockManager.getInstance()); + assertEquals(inst, PolicyResourceLockManager.getInstance()); + } + + @Test + public void testDoIntercept_Empty() { + // clear the implementer list + implList.clear(); + + mgr.lock(RESOURCE_A, OWNER1, null); + + assertTrue(mgr.isLocked(RESOURCE_A)); + assertFalse(mgr.isLocked(RESOURCE_B)); + + verify(impl1, never()).beforeIsLocked(anyString()); + } + + @Test + public void testDoIntercept_Impl1() { + when(impl1.beforeIsLocked(RESOURCE_A)).thenReturn(true); + + assertTrue(mgr.isLocked(RESOURCE_A)); + + verify(impl1).beforeIsLocked(RESOURCE_A); + verify(impl2, never()).beforeIsLocked(anyString()); + } + + @Test + public void testDoIntercept_Impl2() { + when(impl2.beforeIsLocked(RESOURCE_A)).thenReturn(true); + + assertTrue(mgr.isLocked(RESOURCE_A)); + + verify(impl1).beforeIsLocked(RESOURCE_A); + verify(impl2).beforeIsLocked(RESOURCE_A); + } + + @Test + public void testDoIntercept_Ex() { + doThrow(new RuntimeException("expected exception")).when(impl1).beforeIsLocked(RESOURCE_A); + + assertFalse(mgr.isLocked(RESOURCE_A)); + + verify(impl1).beforeIsLocked(RESOURCE_A); + verify(impl2).beforeIsLocked(RESOURCE_A); + } +} diff --git a/policy-core/src/test/java/org/onap/policy/drools/core/lock/SimpleLockManagerTest.java b/policy-core/src/test/java/org/onap/policy/drools/core/lock/SimpleLockManagerTest.java new file mode 100644 index 00000000..6abc5bf9 --- /dev/null +++ b/policy-core/src/test/java/org/onap/policy/drools/core/lock/SimpleLockManagerTest.java @@ -0,0 +1,280 @@ +/* + * ============LICENSE_START======================================================= + * ONAP + * ================================================================================ + * Copyright (C) 2018 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * Licensed 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. + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.drools.core.lock; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; +import static org.onap.policy.drools.core.lock.TestUtils.expectException; +import java.util.LinkedList; +import java.util.concurrent.CancellationException; +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.Future; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.atomic.AtomicInteger; +import org.junit.Before; +import org.junit.Test; + +public class SimpleLockManagerTest { + + private static final String NULL_RESOURCE_ID = "null resourceId"; + private static final String NULL_OWNER = "null owner"; + + private static final String RESOURCE_A = "resource.a"; + private static final String RESOURCE_B = "resource.b"; + private static final String RESOURCE_C = "resource.c"; + + private static final String OWNER1 = "owner.one"; + private static final String OWNER2 = "owner.two"; + private static final String OWNER3 = "owner.three"; + + private Future fut; + private SimpleLockManager mgr; + + @Before + public void setUp() { + mgr = new SimpleLockManager(); + } + + @Test + public void testLock() throws Exception { + fut = mgr.lock(RESOURCE_A, OWNER1, null); + + assertTrue(fut.isDone()); + assertTrue(fut.get()); + + assertTrue(mgr.isLocked(RESOURCE_A)); + assertTrue(mgr.isLockedBy(RESOURCE_A, OWNER1)); + assertFalse(mgr.isLocked(RESOURCE_B)); + assertFalse(mgr.isLockedBy(RESOURCE_A, OWNER2)); + + // null callback - not locked yet + fut = mgr.lock(RESOURCE_C, OWNER3, null); + assertTrue(fut.isDone()); + assertTrue(fut.get()); + + // null callback - already locked + fut = mgr.lock(RESOURCE_A, OWNER3, null); + assertTrue(fut.isDone()); + assertFalse(fut.get()); + } + + @Test + public void testLock_AlreadyLocked() throws Exception { + mgr.lock(RESOURCE_A, OWNER1, null); + + fut = mgr.lock(RESOURCE_A, OWNER2, null); + assertTrue(fut.isDone()); + assertFalse(fut.get()); + } + + @Test(expected = IllegalStateException.class) + public void testLock_SameOwner() throws Exception { + mgr.lock(RESOURCE_A, OWNER1, null); + + // should throw an exception + mgr.lock(RESOURCE_A, OWNER1, null); + } + + @Test + public void testLock_ArgEx() { + IllegalArgumentException ex = + expectException(IllegalArgumentException.class, xxx -> mgr.lock(null, OWNER1, null)); + assertEquals(NULL_RESOURCE_ID, ex.getMessage()); + + ex = expectException(IllegalArgumentException.class, xxx -> mgr.lock(RESOURCE_A, null, null)); + assertEquals(NULL_OWNER, ex.getMessage()); + + // this should not throw an exception + mgr.lock(RESOURCE_A, OWNER1, null); + } + + @Test + public void testUnlock() throws Exception { + mgr.lock(RESOURCE_A, OWNER1, null); + + // unlock it + assertTrue(mgr.unlock(RESOURCE_A, OWNER1)); + } + + @Test + public void testUnlock_ArgEx() { + IllegalArgumentException ex = expectException(IllegalArgumentException.class, xxx -> mgr.unlock(null, OWNER1)); + assertEquals(NULL_RESOURCE_ID, ex.getMessage()); + + ex = expectException(IllegalArgumentException.class, xxx -> mgr.unlock(RESOURCE_A, null)); + assertEquals(NULL_OWNER, ex.getMessage()); + } + + @Test + public void testUnlock_NotLocked() { + assertFalse(mgr.unlock(RESOURCE_A, OWNER1)); + } + + @Test + public void testIsLocked() { + assertFalse(mgr.isLocked(RESOURCE_A)); + + mgr.lock(RESOURCE_A, OWNER1, null); + mgr.lock(RESOURCE_B, OWNER1, null); + + assertTrue(mgr.isLocked(RESOURCE_A)); + assertTrue(mgr.isLocked(RESOURCE_B)); + assertFalse(mgr.isLocked(RESOURCE_C)); + + // unlock from first resource + mgr.unlock(RESOURCE_A, OWNER1); + assertFalse(mgr.isLocked(RESOURCE_A)); + assertTrue(mgr.isLocked(RESOURCE_B)); + assertFalse(mgr.isLocked(RESOURCE_C)); + + // unlock from second resource + mgr.unlock(RESOURCE_B, OWNER1); + assertFalse(mgr.isLocked(RESOURCE_A)); + assertFalse(mgr.isLocked(RESOURCE_B)); + assertFalse(mgr.isLocked(RESOURCE_C)); + } + + @Test + public void testIsLocked_ArgEx() { + IllegalArgumentException ex = expectException(IllegalArgumentException.class, xxx -> mgr.isLocked(null)); + assertEquals(NULL_RESOURCE_ID, ex.getMessage()); + } + + @Test + public void testIsLockedBy() { + assertFalse(mgr.isLockedBy(RESOURCE_A, OWNER1)); + + mgr.lock(RESOURCE_A, OWNER1, null); + + assertFalse(mgr.isLockedBy(RESOURCE_B, OWNER1)); + + assertTrue(mgr.isLockedBy(RESOURCE_A, OWNER1)); + assertFalse(mgr.isLockedBy(RESOURCE_A, OWNER2)); + + // unlock from the resource + mgr.unlock(RESOURCE_A, OWNER1); + assertFalse(mgr.isLockedBy(RESOURCE_A, OWNER1)); + assertFalse(mgr.isLockedBy(RESOURCE_A, OWNER2)); + assertFalse(mgr.isLockedBy(RESOURCE_B, OWNER1)); + } + + @Test + public void testIsLockedBy_ArgEx() { + IllegalArgumentException ex = + expectException(IllegalArgumentException.class, xxx -> mgr.isLockedBy(null, OWNER1)); + assertEquals(NULL_RESOURCE_ID, ex.getMessage()); + + ex = expectException(IllegalArgumentException.class, xxx -> mgr.isLockedBy(RESOURCE_A, null)); + assertEquals(NULL_OWNER, ex.getMessage()); + } + + @Test + public void testIsLockedBy_NotLocked() { + mgr.lock(RESOURCE_A, OWNER1, null); + + // different resource, thus no lock + assertFalse(mgr.isLockedBy(RESOURCE_B, OWNER1)); + } + + @Test + public void testIsLockedBy_LockedButNotOwner() { + mgr.lock(RESOURCE_A, OWNER1, null); + + // different owner + assertFalse(mgr.isLockedBy(RESOURCE_A, OWNER2)); + } + + @Test + public void testMultiThreaded() throws InterruptedException { + int nthreads = 10; + int nlocks = 100; + + LinkedList threads = new LinkedList<>(); + + String[] resources = {RESOURCE_A, RESOURCE_B}; + + AtomicInteger nfail = new AtomicInteger(0); + + CountDownLatch stopper = new CountDownLatch(1); + CountDownLatch completed = new CountDownLatch(nthreads); + + for (int x = 0; x < nthreads; ++x) { + String owner = "owner." + x; + + Thread t = new Thread() { + @Override + public void run() { + + for (int y = 0; y < nlocks; ++y) { + String res = resources[y % resources.length]; + + try { + // some locks will be acquired, some denied + mgr.lock(res, owner, null).get(); + + // do some "work" + stopper.await(1L, TimeUnit.MILLISECONDS); + + mgr.unlock(res, owner); + + } catch (CancellationException | ExecutionException e) { + nfail.incrementAndGet(); + + } catch (InterruptedException expected) { + Thread.currentThread().interrupt(); + break; + } + } + + completed.countDown(); + } + }; + + t.setDaemon(true); + threads.add(t); + } + + // start the threads + for (Thread t : threads) { + t.start(); + } + + // wait for them to complete + completed.await(5000L, TimeUnit.SECONDS); + + // stop the threads from sleeping + stopper.countDown(); + + completed.await(1L, TimeUnit.SECONDS); + + // interrupt those that are still alive + for (Thread t : threads) { + if (t.isAlive()) { + t.interrupt(); + } + } + + assertEquals(0, nfail.get()); + } + +} diff --git a/policy-core/src/test/java/org/onap/policy/drools/core/lock/TestUtils.java b/policy-core/src/test/java/org/onap/policy/drools/core/lock/TestUtils.java new file mode 100644 index 00000000..2e353936 --- /dev/null +++ b/policy-core/src/test/java/org/onap/policy/drools/core/lock/TestUtils.java @@ -0,0 +1,59 @@ +/* + * ============LICENSE_START======================================================= + * ONAP + * ================================================================================ + * Copyright (C) 2018 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * Licensed 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. + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.drools.core.lock; + +public class TestUtils { + + /** + * Invokes a function that is expected to throw an exception. + * + * @param clazz class of exception that is expected + * @param func + * @return + */ + public static T expectException(Class clazz, VoidFunction func) { + try { + func.apply(null); + throw new AssertionError("missing exception"); + + } catch (Exception e) { + try { + return clazz.cast(e); + + } catch (ClassCastException e2) { + throw new AssertionError("incorrect exception type", e2); + } + } + } + + /** + * Void function that may throw an exception. + */ + @FunctionalInterface + public static interface VoidFunction { + + /** + * + * @param arg always {@code null} + */ + public void apply(Void arg) throws Exception; + } +} -- cgit 1.2.3-korg