1 files changed, 0 insertions, 527 deletions
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
deleted file mode 100644
index 51cf68fc..00000000
--- a/policy-core/src/test/java/org/onap/policy/drools/core/lock/SimpleLockManagerTest.java
+++ /dev/null
@@ -1,527 +0,0 @@
-/*
- * ============LICENSE_START=======================================================
- * ONAP
- * ================================================================================
- * Copyright (C) 2018-2019 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.assertj.core.api.Assertions.assertThatIllegalArgumentException;
-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 java.util.LinkedList;
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicInteger;
-import org.junit.AfterClass;
-import org.junit.Before;
-import org.junit.BeforeClass;
-import org.junit.Test;
-import org.onap.policy.common.utils.time.CurrentTime;
-import org.onap.policy.common.utils.time.TestTime;
-import org.onap.policy.drools.core.lock.SimpleLockManager.Data;
-import org.powermock.reflect.Whitebox;
-
-public class SimpleLockManagerTest {
-
-    // Note: this must be a multiple of four
-    private static final int MAX_AGE_SEC = 4 * 60;
-    private static final int MAX_AGE_MS = MAX_AGE_SEC * 1000;
-    
-    private static final String EXPECTED_EXCEPTION = "expected exception";
-    
-    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 RESOURCE_D = "resource.d";
-
-    private static final String OWNER1 = "owner.one";
-    private static final String OWNER2 = "owner.two";
-    private static final String OWNER3 = "owner.three";
-    
-    /**
-     * Name of the "current time" field within the {@link SimpleLockManager} class.
-     */
-    private static final String TIME_FIELD = "currentTime";
-    
-    private static CurrentTime savedTime;
-
-    private TestTime testTime;
-    private SimpleLockManager mgr;
-    
-    @BeforeClass
-    public static void setUpBeforeClass() {
-        savedTime = Whitebox.getInternalState(SimpleLockManager.class, TIME_FIELD);
-    }
-    
-    @AfterClass
-    public static void tearDownAfterClass() {
-        Whitebox.setInternalState(SimpleLockManager.class, TIME_FIELD, savedTime);
-    }
-
-    /**
-     * Set up.
-     */
-    @Before
-    public void setUp() {
-        testTime = new TestTime();
-        Whitebox.setInternalState(SimpleLockManager.class, TIME_FIELD, testTime);
-        
-        mgr = new SimpleLockManager();
-    }
-    
-    @Test
-    public void testCurrentTime() {
-        assertNotNull(savedTime);
-    }
-
-    @Test
-    public void testLock() throws Exception {
-        assertTrue(mgr.lock(RESOURCE_A, OWNER1, MAX_AGE_SEC));
-
-        assertTrue(mgr.isLocked(RESOURCE_A));
-        assertTrue(mgr.isLockedBy(RESOURCE_A, OWNER1));
-        assertFalse(mgr.isLocked(RESOURCE_B));
-        assertFalse(mgr.isLockedBy(RESOURCE_A, OWNER2));
-
-        // different owner and resource - should succeed
-        assertTrue(mgr.lock(RESOURCE_C, OWNER3, MAX_AGE_SEC));
-
-        // different owner - already locked
-        assertFalse(mgr.lock(RESOURCE_A, OWNER3, MAX_AGE_SEC));
-    }
-
-    @Test
-    public void testLock_ExtendLock() throws Exception {
-        mgr.lock(RESOURCE_A, OWNER1, MAX_AGE_SEC);
-        
-        // sleep half of the cycle
-        testTime.sleep(MAX_AGE_MS / 2);
-        assertTrue(mgr.isLockedBy(RESOURCE_A, OWNER1));
-        
-        // extend the lock
-        mgr.refresh(RESOURCE_A, OWNER1, MAX_AGE_SEC);
-        
-        // verify still locked after sleeping the other half of the cycle
-        testTime.sleep(MAX_AGE_MS / 2 + 1);
-        assertTrue(mgr.isLockedBy(RESOURCE_A, OWNER1));
-        
-        // and should release after another half cycle
-        testTime.sleep(MAX_AGE_MS / 2);
-        assertFalse(mgr.isLockedBy(RESOURCE_A, OWNER1));
-    }
-
-    @Test
-    public void testLock_AlreadyLocked() throws Exception {
-        mgr.lock(RESOURCE_A, OWNER1, MAX_AGE_SEC);
-        
-        // same owner
-        assertFalse(mgr.lock(RESOURCE_A, OWNER1, MAX_AGE_SEC));
-
-        // different owner
-        assertFalse(mgr.lock(RESOURCE_A, OWNER2, MAX_AGE_SEC));
-    }
-
-    @Test
-    public void testLock_ArgEx() {
-        assertThatIllegalArgumentException().isThrownBy(() -> mgr.lock(null, OWNER1, MAX_AGE_SEC))
-                        .withMessage(NULL_RESOURCE_ID);
-
-        assertThatIllegalArgumentException().isThrownBy(() -> mgr.lock(RESOURCE_A, null, MAX_AGE_SEC))
-                        .withMessage(NULL_OWNER);
-
-        // this should not throw an exception
-        mgr.lock(RESOURCE_A, OWNER1, MAX_AGE_SEC);
-    }
-
-    @Test
-    public void testRefresh() throws Exception {
-        // don't own the lock yet - cannot refresh
-        assertFalse(mgr.refresh(RESOURCE_A, OWNER1, MAX_AGE_SEC));
-
-        assertTrue(mgr.lock(RESOURCE_A, OWNER1, MAX_AGE_SEC));
-
-        // now the lock is owned
-        assertTrue(mgr.refresh(RESOURCE_A, OWNER1, MAX_AGE_SEC));
-
-        // refresh again
-        assertTrue(mgr.refresh(RESOURCE_A, OWNER1, MAX_AGE_SEC + 1));
-
-        assertTrue(mgr.isLocked(RESOURCE_A));
-        assertTrue(mgr.isLockedBy(RESOURCE_A, OWNER1));
-        assertFalse(mgr.isLocked(RESOURCE_B));
-        assertFalse(mgr.isLockedBy(RESOURCE_A, OWNER2));
-
-        // different owner
-        assertFalse(mgr.refresh(RESOURCE_A, OWNER3, MAX_AGE_SEC));
-
-        // different resource
-        assertFalse(mgr.refresh(RESOURCE_C, OWNER1, MAX_AGE_SEC));
-    }
-
-    @Test
-    public void testRefresh_ExtendLock() throws Exception {
-        mgr.lock(RESOURCE_A, OWNER1, MAX_AGE_SEC);
-
-        // sleep half of the cycle
-        testTime.sleep(MAX_AGE_MS / 2);
-        assertTrue(mgr.isLockedBy(RESOURCE_A, OWNER1));
-
-        // extend the lock
-        mgr.refresh(RESOURCE_A, OWNER1, MAX_AGE_SEC);
-
-        // verify still locked after sleeping the other half of the cycle
-        testTime.sleep(MAX_AGE_MS / 2 + 1);
-        assertTrue(mgr.isLockedBy(RESOURCE_A, OWNER1));
-
-        // and should release after another half cycle
-        testTime.sleep(MAX_AGE_MS / 2);
-        
-        // cannot refresh expired lock
-        assertFalse(mgr.refresh(RESOURCE_A, OWNER1, MAX_AGE_SEC));
-        
-        assertFalse(mgr.isLockedBy(RESOURCE_A, OWNER1));
-    }
-
-    @Test
-    public void testRefresh_AlreadyLocked() throws Exception {
-        mgr.lock(RESOURCE_A, OWNER1, MAX_AGE_SEC);
-
-        // same owner
-        assertTrue(mgr.refresh(RESOURCE_A, OWNER1, MAX_AGE_SEC));
-
-        // different owner
-        assertFalse(mgr.refresh(RESOURCE_A, OWNER2, MAX_AGE_SEC));
-        assertFalse(mgr.lock(RESOURCE_A, OWNER2, MAX_AGE_SEC));
-    }
-
-    @Test
-    public void testRefresh_ArgEx() {
-        assertThatIllegalArgumentException().isThrownBy(() -> mgr.refresh(null, OWNER1, MAX_AGE_SEC))
-                        .withMessage(NULL_RESOURCE_ID);
-
-        assertThatIllegalArgumentException().isThrownBy(() -> mgr.refresh(RESOURCE_A, null, MAX_AGE_SEC))
-                        .withMessage(NULL_OWNER);
-
-        // this should not throw an exception
-        mgr.refresh(RESOURCE_A, OWNER1, MAX_AGE_SEC);
-    }
-
-    @Test
-    public void testUnlock() throws Exception {
-        mgr.lock(RESOURCE_A, OWNER1, MAX_AGE_SEC);
-
-        // unlock it
-        assertTrue(mgr.unlock(RESOURCE_A, OWNER1));
-    }
-
-    @Test
-    public void testUnlock_ArgEx() {
-        assertThatIllegalArgumentException().isThrownBy(() -> mgr.unlock(null, OWNER1)).withMessage(NULL_RESOURCE_ID);
-
-        assertThatIllegalArgumentException().isThrownBy(() -> mgr.unlock(RESOURCE_A, null)).withMessage(NULL_OWNER);
-    }
-
-    @Test
-    public void testUnlock_NotLocked() {
-        assertFalse(mgr.unlock(RESOURCE_A, OWNER1));
-    }
-
-    @Test
-    public void testUnlock_DiffOwner() {
-        mgr.lock(RESOURCE_A, OWNER1, MAX_AGE_SEC);
-        assertFalse(mgr.unlock(RESOURCE_A, OWNER2));
-    }
-
-    @Test
-    public void testIsLocked() {
-        assertFalse(mgr.isLocked(RESOURCE_A));
-
-        mgr.lock(RESOURCE_A, OWNER1, MAX_AGE_SEC);
-        mgr.lock(RESOURCE_B, OWNER1, MAX_AGE_SEC);
-
-        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() {
-        assertThatIllegalArgumentException().isThrownBy(() -> mgr.isLocked(null)).withMessage(NULL_RESOURCE_ID);
-    }
-
-    @Test
-    public void testIsLockedBy() {
-        assertFalse(mgr.isLockedBy(RESOURCE_A, OWNER1));
-
-        mgr.lock(RESOURCE_A, OWNER1, MAX_AGE_SEC);
-
-        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() {
-        assertThatIllegalArgumentException().isThrownBy(() -> mgr.isLockedBy(null, OWNER1))
-                        .withMessage(NULL_RESOURCE_ID);
-
-        assertThatIllegalArgumentException().isThrownBy(() -> mgr.isLockedBy(RESOURCE_A, null)).withMessage(NULL_OWNER);
-    }
-
-    @Test
-    public void testIsLockedBy_NotLocked() {
-        mgr.lock(RESOURCE_A, OWNER1, MAX_AGE_SEC);
-
-        // different resource, thus no lock
-        assertFalse(mgr.isLockedBy(RESOURCE_B, OWNER1));
-    }
-
-    @Test
-    public void testIsLockedBy_LockedButNotOwner() {
-        mgr.lock(RESOURCE_A, OWNER1, MAX_AGE_SEC);
-
-        // different owner
-        assertFalse(mgr.isLockedBy(RESOURCE_A, OWNER2));
-    }
-    
-    @Test
-    public void testCleanUpLocks() throws Exception {
-        // note: this assumes that MAX_AGE_MS is divisible by 4
-        mgr.lock(RESOURCE_A, OWNER1, MAX_AGE_SEC);
-        assertTrue(mgr.isLocked(RESOURCE_A));
-        
-        testTime.sleep(10);
-        mgr.lock(RESOURCE_B, OWNER1, MAX_AGE_SEC);
-        assertTrue(mgr.isLocked(RESOURCE_A));
-        assertTrue(mgr.isLocked(RESOURCE_B));
-        
-        testTime.sleep(MAX_AGE_MS / 4);
-        mgr.lock(RESOURCE_C, OWNER1, MAX_AGE_SEC);
-        assertTrue(mgr.isLocked(RESOURCE_A));
-        assertTrue(mgr.isLocked(RESOURCE_B));
-        assertTrue(mgr.isLocked(RESOURCE_C));
-        
-        testTime.sleep(MAX_AGE_MS / 4);
-        mgr.lock(RESOURCE_D, OWNER1, MAX_AGE_SEC);
-        assertTrue(mgr.isLocked(RESOURCE_A));
-        assertTrue(mgr.isLocked(RESOURCE_B));
-        assertTrue(mgr.isLocked(RESOURCE_C));
-        assertTrue(mgr.isLocked(RESOURCE_D));
-        
-        // sleep remainder of max age - first two should expire
-        testTime.sleep(MAX_AGE_MS / 2);
-        assertFalse(mgr.isLocked(RESOURCE_A));
-        assertFalse(mgr.isLocked(RESOURCE_B));
-        assertTrue(mgr.isLocked(RESOURCE_C));
-        assertTrue(mgr.isLocked(RESOURCE_D));
-        
-        // another quarter - next one should expire
-        testTime.sleep(MAX_AGE_MS / 4);
-        assertFalse(mgr.isLocked(RESOURCE_C));
-        assertTrue(mgr.isLocked(RESOURCE_D));
-        
-        // another quarter - last one should expire
-        testTime.sleep(MAX_AGE_MS / 4);
-        assertFalse(mgr.isLocked(RESOURCE_D));
-    }
-
-    @Test
-    public void testMakeNullArgException() {
-        IllegalArgumentException ex = SimpleLockManager.makeNullArgException(EXPECTED_EXCEPTION);
-        assertEquals(EXPECTED_EXCEPTION, ex.getMessage());
-    }
-    
-    @Test
-    public void testDataGetXxx() {
-        long ttime = System.currentTimeMillis() + 5;
-        Data data = new Data(OWNER1, RESOURCE_A, ttime);
-        
-        assertEquals(OWNER1, data.getOwner());
-        assertEquals(RESOURCE_A, data.getResource());
-        assertEquals(ttime, data.getExpirationMs());
-    }
-    
-    @Test
-    public void testDataCompareTo() {
-        long ttime = System.currentTimeMillis() + 50;
-        Data data = new Data(OWNER1, RESOURCE_A, ttime);
-        Data dataSame = new Data(OWNER1, RESOURCE_A, ttime);
-        Data dataDiffExpire = new Data(OWNER1, RESOURCE_A, ttime + 1);
-        
-        assertEquals(0, data.compareTo(data));
-        assertEquals(0, data.compareTo(dataSame));
-        
-        assertTrue(data.compareTo(dataDiffExpire) < 0);
-        assertTrue(dataDiffExpire.compareTo(data) > 0);
-        
-        Data dataDiffOwner = new Data(OWNER2, RESOURCE_A, ttime);
-        Data dataDiffResource = new Data(OWNER1, RESOURCE_B, ttime);
-
-        assertTrue(data.compareTo(dataDiffOwner) < 0);
-        assertTrue(dataDiffOwner.compareTo(data) > 0);
-        
-        assertTrue(data.compareTo(dataDiffResource) < 0);
-        assertTrue(dataDiffResource.compareTo(data) > 0);
-    }
-    
-    @Test
-    public void testDataHashCode() {
-        long ttime = System.currentTimeMillis() + 1;
-        Data data = new Data(OWNER1, RESOURCE_A, ttime);
-        Data dataSame = new Data(OWNER1, RESOURCE_A, ttime);
-        Data dataDiffExpire = new Data(OWNER1, RESOURCE_A, ttime + 1);
-        Data dataDiffOwner = new Data(OWNER2, RESOURCE_A, ttime);
-        
-        int hc1 = data.hashCode();
-        assertEquals(hc1, dataSame.hashCode());
-
-        assertTrue(hc1 != dataDiffExpire.hashCode());
-        assertTrue(hc1 != dataDiffOwner.hashCode());
-
-        Data dataDiffResource = new Data(OWNER1, RESOURCE_B, ttime);
-        Data dataNullOwner = new Data(null, RESOURCE_A, ttime);
-        Data dataNullResource = new Data(OWNER1, null, ttime);
-        
-        assertTrue(hc1 != dataDiffResource.hashCode());
-        assertTrue(hc1 != dataNullOwner.hashCode());
-        assertTrue(hc1 != dataNullResource.hashCode());
-    }
-    
-    @Test
-    public void testDataEquals() {
-        long ttime = System.currentTimeMillis() + 50;
-        Data data = new Data(OWNER1, RESOURCE_A, ttime);
-        Data dataSame = new Data(OWNER1, RESOURCE_A, ttime);
-        Data dataDiffExpire = new Data(OWNER1, RESOURCE_A, ttime + 1);
-        
-        assertTrue(data.equals(data));
-        assertTrue(data.equals(dataSame));
-
-        Data dataDiffOwner = new Data(OWNER2, RESOURCE_A, ttime);
-        Data dataDiffResource = new Data(OWNER1, RESOURCE_B, ttime);
-
-        assertFalse(data.equals(dataDiffExpire));
-        assertFalse(data.equals(dataDiffOwner));
-        assertFalse(data.equals(dataDiffResource));
-
-        assertFalse(data.equals(null));
-        assertFalse(data.equals("string"));
-
-        Data dataNullOwner = new Data(null, RESOURCE_A, ttime);
-        Data dataNullResource = new Data(OWNER1, null, ttime);
-
-        assertFalse(dataNullOwner.equals(data));
-        assertFalse(dataNullResource.equals(data));
-
-        assertTrue(dataNullOwner.equals(new Data(null, RESOURCE_A, ttime)));
-        assertTrue(dataNullResource.equals(new Data(OWNER1, null, ttime)));
-    }
-
-    @Test
-    public void testMultiThreaded() throws InterruptedException {
-        int nthreads = 10;
-        int nlocks = 100;
-
-        LinkedList<Thread> threads = new LinkedList<>();
-
-        String[] resources = {RESOURCE_A, RESOURCE_B};
-
-        final 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 thread = new Thread(() -> {
-
-                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, MAX_AGE_SEC);
-
-                        // do some "work"
-                        stopper.await(1L, TimeUnit.MILLISECONDS);
-
-                        mgr.unlock(res, owner);
-
-                    } catch (InterruptedException expected) {
-                        Thread.currentThread().interrupt();
-                        break;
-                    }
-                }
-
-                completed.countDown();
-            });
-
-            thread.setDaemon(true);
-            threads.add(thread);
-        }
-
-        // 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());
-    }
-
-}