Merge "Refactor duplicate code from lock managers"

6 files changed, 1144 insertions, 264 deletions

diff --git a/policy-management/src/main/java/org/onap/policy/drools/system/internal/FeatureLockImpl.java b/policy-management/src/main/java/org/onap/policy/drools/system/internal/FeatureLockImpl.java
new file mode 100644
index 00000000..d4e4f5fc
--- /dev/null
+++ b/policy-management/src/main/java/org/onap/policy/drools/system/internal/FeatureLockImpl.java
@@ -0,0 +1,211 @@
+/*
+ * ============LICENSE_START=======================================================
+ * ONAP
+ * ================================================================================
+ * Copyright (C) 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.system.internal;
+
+import java.util.concurrent.ScheduledExecutorService;
+import org.onap.policy.drools.core.lock.LockCallback;
+import org.onap.policy.drools.core.lock.LockImpl;
+import org.onap.policy.drools.core.lock.LockState;
+import org.onap.policy.drools.system.PolicyEngineConstants;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Lock implementation used by locking features.
+ */
+public abstract class FeatureLockImpl extends LockImpl {
+    private static final long serialVersionUID = 1L;
+    private static final Logger logger = LoggerFactory.getLogger(FeatureLockImpl.class);
+
+    public static final String LOCK_LOST_MSG = "lock lost";
+
+    /**
+     * {@code True} if this lock is attached to a feature, {@code false} if it is not.
+     */
+    private transient boolean attached;
+
+    /**
+     * Constructs the object.
+     */
+    public FeatureLockImpl() {
+        this.attached = false;
+    }
+
+    /**
+     * Constructs the object.
+     *
+     * @param state initial state of the lock
+     * @param resourceId identifier of the resource to be locked
+     * @param ownerKey information identifying the owner requesting the lock
+     * @param holdSec amount of time, in seconds, for which the lock should be held, after
+     *        which it will automatically be released
+     * @param callback callback to be invoked once the lock is granted, or subsequently
+     *        lost; must not be {@code null}
+     */
+    public FeatureLockImpl(LockState state, String resourceId, String ownerKey, int holdSec, LockCallback callback) {
+        super(state, resourceId, ownerKey, holdSec, callback);
+        this.attached = true;
+    }
+
+    /**
+     * Grants this lock. The notification is <i>always</i> invoked via a background
+     * thread.
+     *
+     * @param foreground {@code true} if to invoke the callback in the foreground thread,
+     *        {@code false} otherwise
+     */
+    protected synchronized void grant(boolean foreground) {
+        if (isUnavailable()) {
+            return;
+        }
+
+        setState(LockState.ACTIVE);
+        updateGrant();
+
+        logger.info("lock granted: {}", this);
+
+        if (foreground) {
+            notifyAvailable();
+        } else {
+            getThreadPool().execute(this::notifyAvailable);
+        }
+    }
+
+    /**
+     * Permanently denies this lock.
+     *
+     * @param reason the reason the lock was denied
+     * @param foreground {@code true} if to invoke the callback in the foreground thread,
+     *        {@code false} otherwise
+     */
+    public void deny(String reason, boolean foreground) {
+        synchronized (this) {
+            setState(LockState.UNAVAILABLE);
+        }
+
+        logger.info("{}: {}", reason, this);
+
+        if (foreground) {
+            notifyUnavailable();
+        } else {
+            getThreadPool().execute(this::notifyUnavailable);
+        }
+    }
+
+    /**
+     * The subclass should make use of {@link #freeAllowed()} in its implementation of
+     * {@link #free()}.
+     */
+    @Override
+    public abstract boolean free();
+
+    /**
+     * Determines if the lock can be freed.
+     *
+     * @return {@code true} if the lock can be freed, {@code false} if the lock is
+     *         unavailable
+     */
+    protected boolean freeAllowed() {
+        // do a quick check of the state
+        if (isUnavailable()) {
+            return false;
+        }
+
+        logger.info("releasing lock: {}", this);
+
+        if (!attachFeature()) {
+            setState(LockState.UNAVAILABLE);
+            return false;
+        }
+
+        return true;
+    }
+
+    /**
+     * The subclass should make use of {@link #extendAllowed()} in its implementation of
+     * {@link #extend()}.
+     */
+    @Override
+    public abstract void extend(int holdSec, LockCallback callback);
+
+    /**
+     * Determines if the lock can be extended.
+     *
+     * @param holdSec the additional amount of time to hold the lock, in seconds
+     * @param callback callback to be invoked when the extension completes
+     * @return {@code true} if the lock can be extended, {@code false} if the lock is
+     *         unavailable
+     */
+    protected boolean extendAllowed(int holdSec, LockCallback callback) {
+        if (holdSec < 0) {
+            throw new IllegalArgumentException("holdSec is negative");
+        }
+
+        setHoldSec(holdSec);
+        setCallback(callback);
+
+        // do a quick check of the state
+        if (isUnavailable() || !attachFeature()) {
+            deny(LOCK_LOST_MSG, true);
+            return false;
+        }
+
+        return true;
+    }
+
+    /**
+     * Attaches to the feature instance, if not already attached.
+     *
+     * @return {@code true} if the lock is now attached to a feature, {@code false}
+     *         otherwise
+     */
+    private synchronized boolean attachFeature() {
+        if (!attached) {
+            attached = addToFeature();
+        }
+
+        return attached;
+    }
+
+    /**
+     * Updates a lock when it is granted. The default method does nothing.
+     */
+    protected void updateGrant() {
+        // do nothing
+    }
+
+    /**
+     * Adds the lock to the relevant feature.
+     *
+     * @return {@code true} if the lock was added, {@code false} if it could not be added
+     *         (e.g., because there is no feature yet)
+     */
+    protected abstract boolean addToFeature();
+
+    /**
+     * Gets the thread pool.
+     *
+     * @return the thread pool
+     */
+    protected ScheduledExecutorService getThreadPool() {
+        return PolicyEngineConstants.getManager().getExecutorService();
+    }
+}
diff --git a/policy-management/src/main/java/org/onap/policy/drools/system/internal/LockManager.java b/policy-management/src/main/java/org/onap/policy/drools/system/internal/LockManager.java
new file mode 100644
index 00000000..7e4505be
--- /dev/null
+++ b/policy-management/src/main/java/org/onap/policy/drools/system/internal/LockManager.java
@@ -0,0 +1,197 @@
+/*
+ * ============LICENSE_START=======================================================
+ * ONAP
+ * ================================================================================
+ * Copyright (C) 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.system.internal;
+
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import lombok.AccessLevel;
+import lombok.Getter;
+import org.onap.policy.drools.core.lock.AlwaysFailLock;
+import org.onap.policy.drools.core.lock.Lock;
+import org.onap.policy.drools.core.lock.LockCallback;
+import org.onap.policy.drools.core.lock.LockState;
+import org.onap.policy.drools.core.lock.PolicyResourceLockManager;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+
+/**
+ * Super class for Lock Features.
+ *
+ * <p/>
+ * Note: this implementation does <i>not</i> honor the waitForLocks={@code true}
+ * parameter.
+ *
+ * <p/>
+ * When a lock is deserialized, it will not initially appear in this feature's map; it
+ * will be added to the map once free() or extend() is invoked, provided there isn't
+ * already an entry.
+ */
+public abstract class LockManager<T extends FeatureLockImpl> implements PolicyResourceLockManager {
+
+    private static final Logger logger = LoggerFactory.getLogger(LockManager.class);
+
+    public static final String NOT_LOCKED_MSG = "not locked";
+
+    /**
+     * Maps a resource to the lock that owns it.
+     */
+    @Getter(AccessLevel.PROTECTED)
+    private final Map<String, T> resource2lock = new ConcurrentHashMap<>();
+
+    /**
+     * {@code True} if this feature is running, {@code false} otherwise.
+     */
+    private boolean alive = false;
+
+    /**
+     * {@code True} if this feature is locked, {@code false} otherwise.
+     */
+    private boolean locked = false;
+
+
+    /**
+     * Constructs the object.
+     */
+    public LockManager() {
+        super();
+    }
+
+    @Override
+    public boolean isAlive() {
+        return alive;
+    }
+
+    @Override
+    public synchronized boolean start() {
+        if (alive) {
+            return false;
+        }
+
+        alive = true;
+        return true;
+    }
+
+    /**
+     * Stops the expiration checker. Does <i>not</i> invoke any lock call-backs.
+     */
+    @Override
+    public synchronized boolean stop() {
+        if (!alive) {
+            return false;
+        }
+
+        alive = false;
+        return true;
+    }
+
+    @Override
+    public void shutdown() {
+        stop();
+    }
+
+    @Override
+    public boolean isLocked() {
+        return locked;
+    }
+
+    @Override
+    public synchronized boolean lock() {
+        if (locked) {
+            return false;
+        }
+
+        locked = true;
+        return true;
+    }
+
+    @Override
+    public synchronized boolean unlock() {
+        if (!locked) {
+            return false;
+        }
+
+        locked = false;
+        return true;
+    }
+
+    /**
+     * After performing checks, this invokes
+     * {@link #makeLock(LockState, String, String, int, LockCallback)} to create a lock
+     * object, inserts it into the map, and then invokes {@link #finishLock(MgrLock)}.
+     */
+    @Override
+    public Lock createLock(String resourceId, String ownerKey, int holdSec, LockCallback callback,
+                    boolean waitForLock) {
+
+        if (hasInstanceChanged()) {
+            AlwaysFailLock lock = new AlwaysFailLock(resourceId, ownerKey, holdSec, callback);
+            lock.notifyUnavailable();
+            return lock;
+        }
+
+        T lock = makeLock(LockState.WAITING, resourceId, ownerKey, holdSec, callback);
+
+        T existingLock = resource2lock.putIfAbsent(resourceId, lock);
+
+        if (existingLock == null) {
+            logger.debug("added lock to map {}", lock);
+            finishLock(lock);
+        } else {
+            lock.deny("resource is busy", true);
+        }
+
+        return lock;
+    }
+
+    /**
+     * Determines if this object is no longer the current instance of this feature type.
+     *
+     * @return {@code true} if this object is no longer the current instance,
+     *         {@code false} otherwise
+     */
+    protected abstract boolean hasInstanceChanged();
+
+    /**
+     * Finishes the steps required to establish a lock, changing its state to ACTIVE, when
+     * appropriate.
+     *
+     * @param lock the lock to be locked
+     */
+    protected abstract void finishLock(T lock);
+
+    // these may be overridden by junit tests
+
+    /**
+     * Makes a lock of the appropriate type.
+     *
+     * @param state initial state of the lock
+     * @param resourceId identifier of the resource to be locked
+     * @param ownerKey information identifying the owner requesting the lock
+     * @param holdSec amount of time, in seconds, for which the lock should be held, after
+     *        which it will automatically be released
+     * @param callback callback to be invoked once the lock is granted, or subsequently
+     *        lost; must not be {@code null}
+     * @return a new lock
+     */
+    protected abstract T makeLock(LockState waiting, String resourceId, String ownerKey, int holdSec,
+                    LockCallback callback);
+}
diff --git a/policy-management/src/main/java/org/onap/policy/drools/system/internal/SimpleLockManager.java b/policy-management/src/main/java/org/onap/policy/drools/system/internal/SimpleLockManager.java
index f5163e9b..839c17dc 100644
--- a/policy-management/src/main/java/org/onap/policy/drools/system/internal/SimpleLockManager.java
+++ b/policy-management/src/main/java/org/onap/policy/drools/system/internal/SimpleLockManager.java
@@ -23,8 +23,6 @@ package org.onap.policy.drools.system.internal;
 import java.util.Map;
 import java.util.Map.Entry;
 import java.util.Properties;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.ScheduledFuture;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicBoolean;
@@ -34,13 +32,10 @@ import lombok.Getter;
 import lombok.Setter;
 import org.onap.policy.common.utils.properties.exception.PropertyException;
 import org.onap.policy.common.utils.time.CurrentTime;
-import org.onap.policy.drools.core.lock.AlwaysFailLock;
-import org.onap.policy.drools.core.lock.Lock;
 import org.onap.policy.drools.core.lock.LockCallback;
-import org.onap.policy.drools.core.lock.LockImpl;
 import org.onap.policy.drools.core.lock.LockState;
-import org.onap.policy.drools.core.lock.PolicyResourceLockManager;
 import org.onap.policy.drools.system.PolicyEngine;
+import org.onap.policy.drools.system.PolicyEngineConstants;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -58,13 +53,10 @@ import org.slf4j.LoggerFactory;
  * will be added to the map once free() or extend() is invoked, provided there isn't
  * already an entry.
  */
-public class SimpleLockManager implements PolicyResourceLockManager {
+public class SimpleLockManager extends LockManager<SimpleLockManager.SimpleLock> {
 
     private static final Logger logger = LoggerFactory.getLogger(SimpleLockManager.class);
 
-    private static final String NOT_LOCKED_MSG = "not locked";
-    private static final String LOCK_LOST_MSG = "lock lost";
-
     /**
      * Provider of current time. May be overridden by junit tests.
      */
@@ -74,12 +66,6 @@ public class SimpleLockManager implements PolicyResourceLockManager {
     @Setter(AccessLevel.PROTECTED)
     private static SimpleLockManager latestInstance = null;
 
-
-    /**
-     * Engine with which this manager is associated.
-     */
-    private final PolicyEngine engine;
-
     /**
      * Feature properties.
      */
@@ -88,13 +74,7 @@ public class SimpleLockManager implements PolicyResourceLockManager {
     /**
      * Maps a resource to the lock that owns it.
      */
-    private final Map<String, SimpleLock> resource2lock = new ConcurrentHashMap<>();
-
-    /**
-     * Thread pool used to check for lock expiration and to notify owners when locks are
-     * lost.
-     */
-    private ScheduledExecutorService exsvc = null;
+    private final Map<String, SimpleLock> resource2lock;
 
     /**
      * Used to cancel the expiration checker on shutdown.
@@ -110,8 +90,8 @@ public class SimpleLockManager implements PolicyResourceLockManager {
      */
     public SimpleLockManager(PolicyEngine engine, Properties properties) {
         try {
-            this.engine = engine;
             this.featProps = new SimpleLockProperties(properties);
+            this.resource2lock = getResource2lock();
 
         } catch (PropertyException e) {
             throw new SimpleLockManagerException(e);
@@ -119,24 +99,17 @@ public class SimpleLockManager implements PolicyResourceLockManager {
     }
 
     @Override
-    public boolean isAlive() {
-        return (checker != null);
-    }
-
-    @Override
-    public boolean start() {
-        if (checker != null) {
+    public synchronized boolean start() {
+        if (isAlive()) {
             return false;
         }
 
-        exsvc = getThreadPool();
-
-        checker = exsvc.scheduleWithFixedDelay(this::checkExpired, featProps.getExpireCheckSec(),
-                        featProps.getExpireCheckSec(), TimeUnit.SECONDS);
+        checker = PolicyEngineConstants.getManager().getExecutorService().scheduleWithFixedDelay(this::checkExpired,
+                        featProps.getExpireCheckSec(), featProps.getExpireCheckSec(), TimeUnit.SECONDS);
 
         setLatestInstance(this);
 
-        return true;
+        return super.start();
     }
 
     /**
@@ -144,9 +117,7 @@ public class SimpleLockManager implements PolicyResourceLockManager {
      */
     @Override
     public synchronized boolean stop() {
-        exsvc = null;
-
-        if (checker == null) {
+        if (!super.stop()) {
             return false;
         }
 
@@ -158,49 +129,6 @@ public class SimpleLockManager implements PolicyResourceLockManager {
         return true;
     }
 
-    @Override
-    public void shutdown() {
-        stop();
-    }
-
-    @Override
-    public boolean isLocked() {
-        return false;
-    }
-
-    @Override
-    public boolean lock() {
-        return true;
-    }
-
-    @Override
-    public boolean unlock() {
-        return true;
-    }
-
-    @Override
-    public Lock createLock(String resourceId, String ownerKey, int holdSec, LockCallback callback,
-                    boolean waitForLock) {
-
-        if (latestInstance != this) {
-            AlwaysFailLock lock = new AlwaysFailLock(resourceId, ownerKey, holdSec, callback);
-            lock.notifyUnavailable();
-            return lock;
-        }
-
-        SimpleLock lock = makeLock(LockState.WAITING, resourceId, ownerKey, holdSec, callback);
-
-        SimpleLock existingLock = resource2lock.putIfAbsent(resourceId, lock);
-
-        if (existingLock == null) {
-            lock.grant();
-        } else {
-            lock.deny("resource is busy");
-        }
-
-        return lock;
-    }
-
     /**
      * Checks for expired locks.
      */
@@ -230,15 +158,25 @@ public class SimpleLockManager implements PolicyResourceLockManager {
 
             SimpleLock lock = lockref.get();
             if (lock != null) {
-                lock.deny("lock expired");
+                lock.deny("lock expired", false);
             }
         }
     }
 
+    @Override
+    protected void finishLock(SimpleLock lock) {
+        lock.grant(true);
+    }
+
+    @Override
+    protected boolean hasInstanceChanged() {
+        return (getLatestInstance() != this);
+    }
+
     /**
      * Simple Lock implementation.
      */
-    public static class SimpleLock extends LockImpl {
+    public static class SimpleLock extends FeatureLockImpl {
         private static final long serialVersionUID = 1L;
 
         /**
@@ -248,17 +186,16 @@ public class SimpleLockManager implements PolicyResourceLockManager {
         private long holdUntilMs;
 
         /**
-         * Feature containing this lock. May be {@code null} until the feature is
-         * identified. Note: this can only be null if the lock has been de-serialized.
+         * Map that should hold this lock.
          */
-        private transient SimpleLockManager feature;
+        private transient Map<String, SimpleLock> resource2lock;
 
         /**
          * Constructs the object.
          */
         public SimpleLock() {
             this.holdUntilMs = 0;
-            this.feature = null;
+            this.resource2lock = null;
         }
 
         /**
@@ -276,7 +213,7 @@ public class SimpleLockManager implements PolicyResourceLockManager {
         public SimpleLock(LockState state, String resourceId, String ownerKey, int holdSec, LockCallback callback,
                         SimpleLockManager feature) {
             super(state, resourceId, ownerKey, holdSec, callback);
-            this.feature = feature;
+            this.resource2lock = feature.resource2lock;
         }
 
         /**
@@ -289,62 +226,15 @@ public class SimpleLockManager implements PolicyResourceLockManager {
             return (holdUntilMs <= currentMs);
         }
 
-        /**
-         * Grants this lock. The notification is <i>always</i> invoked via a background
-         * thread.
-         */
-        protected synchronized void grant() {
-            if (isUnavailable()) {
-                return;
-            }
-
-            setState(LockState.ACTIVE);
-            holdUntilMs = currentTime.getMillis() + TimeUnit.SECONDS.toMillis(getHoldSec());
-
-            logger.info("lock granted: {}", this);
-
-            feature.exsvc.execute(this::notifyAvailable);
-        }
-
-        /**
-         * Permanently denies this lock. The notification is invoked via a background
-         * thread, if a feature instance is attached, otherwise it uses the foreground
-         * thread.
-         *
-         * @param reason the reason the lock was denied
-         */
-        protected void deny(String reason) {
-            synchronized (this) {
-                setState(LockState.UNAVAILABLE);
-            }
-
-            logger.info("{}: {}", reason, this);
-
-            if (feature == null) {
-                notifyUnavailable();
-
-            } else {
-                feature.exsvc.execute(this::notifyUnavailable);
-            }
-        }
-
         @Override
         public boolean free() {
-            // do a quick check of the state
-            if (isUnavailable()) {
-                return false;
-            }
-
-            logger.info("releasing lock: {}", this);
-
-            if (!attachFeature()) {
-                setState(LockState.UNAVAILABLE);
+            if (!freeAllowed()) {
                 return false;
             }
 
             AtomicBoolean result = new AtomicBoolean(false);
 
-            feature.resource2lock.computeIfPresent(getResourceId(), (resourceId, curlock) -> {
+            resource2lock.computeIfPresent(getResourceId(), (resourceId, curlock) -> {
 
                 if (curlock == this) {
                     // this lock was the owner - resource is now available
@@ -362,46 +252,33 @@ public class SimpleLockManager implements PolicyResourceLockManager {
 
         @Override
         public void extend(int holdSec, LockCallback callback) {
-            if (holdSec < 0) {
-                throw new IllegalArgumentException("holdSec is negative");
-            }
-
-            setHoldSec(holdSec);
-            setCallback(callback);
-
-            // do a quick check of the state
-            if (isUnavailable() || !attachFeature()) {
-                deny(LOCK_LOST_MSG);
+            if (!extendAllowed(holdSec, callback)) {
                 return;
             }
 
-            if (feature.resource2lock.get(getResourceId()) == this) {
-                grant();
+            if (resource2lock.get(getResourceId()) == this) {
+                grant(true);
             } else {
-                deny(NOT_LOCKED_MSG);
+                deny(NOT_LOCKED_MSG, true);
             }
         }
 
-        /**
-         * Attaches to the feature instance, if not already attached.
-         *
-         * @return {@code true} if the lock is now attached to a feature, {@code false}
-         *         otherwise
-         */
-        private synchronized boolean attachFeature() {
-            if (feature != null) {
-                // already attached
-                return true;
-            }
+        @Override
+        protected void updateGrant() {
+            holdUntilMs = currentTime.getMillis() + TimeUnit.SECONDS.toMillis(getHoldSec());
+        }
 
-            feature = latestInstance;
+        @Override
+        protected boolean addToFeature() {
+            SimpleLockManager feature = getLatestInstance();
             if (feature == null) {
                 logger.warn("no feature yet for {}", this);
                 return false;
             }
 
             // put this lock into the map
-            feature.resource2lock.putIfAbsent(getResourceId(), this);
+            resource2lock = feature.resource2lock;
+            resource2lock.putIfAbsent(getResourceId(), this);
 
             return true;
         }
@@ -415,10 +292,6 @@ public class SimpleLockManager implements PolicyResourceLockManager {
 
     // these may be overridden by junit tests
 
-    protected ScheduledExecutorService getThreadPool() {
-        return engine.getExecutorService();
-    }
-
     protected SimpleLock makeLock(LockState waiting, String resourceId, String ownerKey, int holdSec,
                     LockCallback callback) {
         return new SimpleLock(waiting, resourceId, ownerKey, holdSec, callback, this);
diff --git a/policy-management/src/test/java/org/onap/policy/drools/system/internal/FeatureLockImplTest.java b/policy-management/src/test/java/org/onap/policy/drools/system/internal/FeatureLockImplTest.java
new file mode 100644
index 00000000..258ee0c5
--- /dev/null
+++ b/policy-management/src/test/java/org/onap/policy/drools/system/internal/FeatureLockImplTest.java
@@ -0,0 +1,415 @@
+/*
+ * ============LICENSE_START=======================================================
+ * ONAP
+ * ================================================================================
+ * Copyright (C) 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.system.internal;
+
+import static org.assertj.core.api.Assertions.assertThat;
+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.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.util.concurrent.ScheduledExecutorService;
+import org.junit.AfterClass;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.onap.policy.drools.core.lock.LockCallback;
+import org.onap.policy.drools.core.lock.LockState;
+import org.onap.policy.drools.system.PolicyEngineConstants;
+import org.powermock.reflect.Whitebox;
+
+public class FeatureLockImplTest {
+    private static final String POLICY_ENGINE_EXECUTOR_FIELD = "executorService";
+    private static final String OWNER_KEY = "my key";
+    private static final String RESOURCE = "my resource";
+    private static final int HOLD_SEC = 100;
+    private static final int HOLD_SEC2 = 120;
+
+    private static ScheduledExecutorService saveExec;
+
+    @Mock
+    private ScheduledExecutorService exsvc;
+
+    @Mock
+    private LockCallback callback;
+
+
+    /**
+     * Saves static fields and configures the location of the property files.
+     */
+    @BeforeClass
+    public static void setUpBeforeClass() {
+        saveExec = Whitebox.getInternalState(PolicyEngineConstants.getManager(), POLICY_ENGINE_EXECUTOR_FIELD);
+    }
+
+    /**
+     * Restores static fields.
+     */
+    @AfterClass
+    public static void tearDownAfterClass() {
+        Whitebox.setInternalState(PolicyEngineConstants.getManager(), POLICY_ENGINE_EXECUTOR_FIELD, saveExec);
+    }
+
+    /**
+     * Initializes the mocks and creates a feature that uses {@link #exsvc} to execute
+     * tasks.
+     */
+    @Before
+    public void setUp() {
+        MockitoAnnotations.initMocks(this);
+
+        Whitebox.setInternalState(PolicyEngineConstants.getManager(), POLICY_ENGINE_EXECUTOR_FIELD, exsvc);
+    }
+
+    @Test
+    public void testNoArgs() {
+        MyLock lock = new MyLock();
+        assertNull(lock.getResourceId());
+        assertNull(lock.getOwnerKey());
+        assertNull(lock.getCallback());
+        assertEquals(0, lock.getHoldSec());
+    }
+
+    @Test
+    public void testFeatureLockImpl() {
+        MyLock lock = new MyLock(LockState.WAITING, RESOURCE, OWNER_KEY, HOLD_SEC, callback);
+        assertTrue(lock.isWaiting());
+        assertEquals(RESOURCE, lock.getResourceId());
+        assertEquals(OWNER_KEY, lock.getOwnerKey());
+        assertSame(callback, lock.getCallback());
+        assertEquals(HOLD_SEC, lock.getHoldSec());
+    }
+
+    @Test
+    public void testSerializable() throws Exception {
+        MyLock lock = new MyLock(LockState.WAITING, RESOURCE, OWNER_KEY, HOLD_SEC, callback);
+        lock = roundTrip(lock);
+
+        assertTrue(lock.isWaiting());
+
+        assertEquals(RESOURCE, lock.getResourceId());
+        assertEquals(OWNER_KEY, lock.getOwnerKey());
+        assertNull(lock.getCallback());
+        assertEquals(HOLD_SEC, lock.getHoldSec());
+    }
+
+    /**
+     * Tests grant(), when using the foreground thread.
+     */
+    @Test
+    public void testGrantForeground() {
+        MyLock lock = new MyLock(LockState.WAITING, RESOURCE, OWNER_KEY, HOLD_SEC, callback);
+        lock.grant(true);
+
+        assertTrue(lock.isActive());
+        assertEquals(1, lock.nupdates);
+
+        verify(exsvc, never()).execute(any());
+
+        verify(callback).lockAvailable(any());
+        verify(callback, never()).lockUnavailable(any());
+    }
+
+    /**
+     * Tests grant(), when using the background thread.
+     */
+    @Test
+    public void testGrantBackground() {
+        MyLock lock = new MyLock(LockState.WAITING, RESOURCE, OWNER_KEY, HOLD_SEC, callback);
+        lock.grant(false);
+
+        assertTrue(lock.isActive());
+        assertEquals(1, lock.nupdates);
+
+        invokeCallback(1);
+        verify(callback).lockAvailable(any());
+        verify(callback, never()).lockUnavailable(any());
+    }
+
+    /**
+     * Tests grant() when the lock is already unavailable.
+     */
+    @Test
+    public void testGrantUnavailable() {
+        MyLock lock = new MyLock(LockState.UNAVAILABLE, RESOURCE, OWNER_KEY, HOLD_SEC, callback);
+        lock.setState(LockState.UNAVAILABLE);
+        lock.grant(true);
+
+        assertTrue(lock.isUnavailable());
+        assertEquals(0, lock.nupdates);
+
+        verify(exsvc, never()).execute(any());
+    }
+
+    /**
+     * Tests deny(), when using the foreground thread.
+     */
+    @Test
+    public void testDenyForeground() {
+        MyLock lock = new MyLock(LockState.WAITING, RESOURCE, OWNER_KEY, HOLD_SEC, callback);
+        lock.deny("my reason", true);
+
+        assertTrue(lock.isUnavailable());
+
+        verify(exsvc, never()).execute(any());
+
+        verify(callback, never()).lockAvailable(any());
+        verify(callback).lockUnavailable(any());
+    }
+
+    /**
+     * Tests deny(), when using the background thread.
+     */
+    @Test
+    public void testDenyBackground() {
+        MyLock lock = new MyLock(LockState.WAITING, RESOURCE, OWNER_KEY, HOLD_SEC, callback);
+        lock.deny("my reason", false);
+
+        assertTrue(lock.isUnavailable());
+
+        invokeCallback(1);
+        verify(callback, never()).lockAvailable(any());
+        verify(callback).lockUnavailable(any());
+    }
+
+    @Test
+    public void testFreeAllowed() {
+        MyLock lock = new MyLock(LockState.WAITING, RESOURCE, OWNER_KEY, HOLD_SEC, callback);
+        assertTrue(lock.freeAllowed());
+    }
+
+    /**
+     * Tests freeAllowed() when the lock is unavailable.
+     */
+    @Test
+    public void testFreeAllowedUnavailable() {
+        MyLock lock = new MyLock(LockState.UNAVAILABLE, RESOURCE, OWNER_KEY, HOLD_SEC, callback);
+        assertFalse(lock.freeAllowed());
+        assertTrue(lock.isUnavailable());
+    }
+
+    /**
+     * Tests that free() works on a serialized lock with a new feature.
+     *
+     * @throws Exception if an error occurs
+     */
+    @Test
+    public void testFreeAllowedSerialized() throws Exception {
+        MyLock lock = new MyLock(LockState.WAITING, RESOURCE, OWNER_KEY, HOLD_SEC, callback);
+
+        lock = roundTrip(lock);
+        assertTrue(lock.freeAllowed());
+    }
+
+    /**
+     * Tests free() on a serialized lock without a feature.
+     *
+     * @throws Exception if an error occurs
+     */
+    @Test
+    public void testFreeAllowedNoFeature() throws Exception {
+        MyLock lock = new MyLockNoFeature(LockState.WAITING, RESOURCE, OWNER_KEY, HOLD_SEC, callback);
+
+        lock = roundTrip(lock);
+        assertFalse(lock.freeAllowed());
+        assertTrue(lock.isUnavailable());
+    }
+
+    @Test
+    public void testExtendAllowed() {
+        MyLock lock = new MyLock(LockState.WAITING, RESOURCE, OWNER_KEY, HOLD_SEC, callback);
+
+        LockCallback scallback = mock(LockCallback.class);
+        assertTrue(lock.extendAllowed(HOLD_SEC2, scallback));
+        assertTrue(lock.isWaiting());
+        assertEquals(HOLD_SEC2, lock.getHoldSec());
+        assertSame(scallback, lock.getCallback());
+
+        verify(exsvc, never()).execute(any());
+
+        // invalid arguments
+
+        // @formatter:off
+        assertThatIllegalArgumentException().isThrownBy(
+            () -> new MyLock(LockState.WAITING, RESOURCE, OWNER_KEY, HOLD_SEC, callback)
+                            .extendAllowed(-1, callback))
+            .withMessageContaining("holdSec");
+        // @formatter:on
+    }
+
+    /**
+     * Tests extendAllowed() when the lock is unavailable.
+     */
+    @Test
+    public void testExtendAllowedUnavailable() {
+        MyLock lock = new MyLock(LockState.UNAVAILABLE, RESOURCE, OWNER_KEY, HOLD_SEC, callback);
+
+        LockCallback scallback = mock(LockCallback.class);
+        assertFalse(lock.extendAllowed(HOLD_SEC2, scallback));
+        assertTrue(lock.isUnavailable());
+        assertEquals(HOLD_SEC2, lock.getHoldSec());
+        assertSame(scallback, lock.getCallback());
+
+        verify(scallback, never()).lockAvailable(lock);
+        verify(scallback).lockUnavailable(lock);
+    }
+
+    /**
+     * Tests that extendAllowed() works on a serialized lock with a new feature.
+     *
+     * @throws Exception if an error occurs
+     */
+    @Test
+    public void testExtendAllowedSerialized() throws Exception {
+        MyLock lock = new MyLock(LockState.WAITING, RESOURCE, OWNER_KEY, HOLD_SEC, callback);
+
+        lock = roundTrip(lock);
+
+        LockCallback scallback = mock(LockCallback.class);
+        assertTrue(lock.extendAllowed(HOLD_SEC2, scallback));
+        assertTrue(lock.isWaiting());
+        assertEquals(HOLD_SEC2, lock.getHoldSec());
+        assertSame(scallback, lock.getCallback());
+
+        verify(exsvc, never()).execute(any());
+    }
+
+    /**
+     * Tests extendAllowed() on a serialized lock without a feature.
+     *
+     * @throws Exception if an error occurs
+     */
+    @Test
+    public void testExtendAllowedNoFeature() throws Exception {
+        MyLock lock = new MyLockNoFeature(LockState.WAITING, RESOURCE, OWNER_KEY, HOLD_SEC, callback);
+
+        lock = roundTrip(lock);
+
+        LockCallback scallback = mock(LockCallback.class);
+        assertFalse(lock.extendAllowed(HOLD_SEC2, scallback));
+        assertTrue(lock.isUnavailable());
+        assertEquals(HOLD_SEC2, lock.getHoldSec());
+        assertSame(scallback, lock.getCallback());
+
+        verify(scallback, never()).lockAvailable(lock);
+        verify(scallback).lockUnavailable(lock);
+    }
+
+    @Test
+    public void testToString() {
+        String text = new MyLock(LockState.WAITING, RESOURCE, OWNER_KEY, HOLD_SEC, callback).toString();
+        assertNotNull(text);
+        assertThat(text).contains("LockImpl");
+    }
+
+    private MyLock roundTrip(MyLock lock) throws Exception {
+        ByteArrayOutputStream baos = new ByteArrayOutputStream();
+        try (ObjectOutputStream oos = new ObjectOutputStream(baos)) {
+            oos.writeObject(lock);
+        }
+
+        ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
+        try (ObjectInputStream ois = new ObjectInputStream(bais)) {
+            return (MyLock) ois.readObject();
+        }
+    }
+
+    /**
+     * Invokes the last call-back in the work queue.
+     *
+     * @param nexpected number of call-backs expected in the work queue
+     */
+    private void invokeCallback(int nexpected) {
+        ArgumentCaptor<Runnable> captor = ArgumentCaptor.forClass(Runnable.class);
+        verify(exsvc, times(nexpected)).execute(captor.capture());
+
+        if (nexpected > 0) {
+            captor.getAllValues().get(nexpected - 1).run();
+        }
+    }
+
+    public static class MyLock extends FeatureLockImpl {
+        private static final long serialVersionUID = 1L;
+        private int nupdates = 0;
+
+        public MyLock() {
+            super();
+        }
+
+        public MyLock(LockState state, String resourceId, String ownerKey, int holdSec, LockCallback callback) {
+            super(state, resourceId, ownerKey, holdSec, callback);
+        }
+
+        @Override
+        protected void updateGrant() {
+            super.updateGrant();
+            ++nupdates;
+        }
+
+        @Override
+        public boolean free() {
+            return false;
+        }
+
+        @Override
+        public void extend(int holdSec, LockCallback callback) {
+            // do nothing
+        }
+
+        @Override
+        protected boolean addToFeature() {
+            return true;
+        }
+    }
+
+    public static class MyLockNoFeature extends MyLock {
+        private static final long serialVersionUID = 1L;
+
+        public MyLockNoFeature() {
+            super();
+        }
+
+        public MyLockNoFeature(LockState state, String resourceId, String ownerKey, int holdSec,
+                        LockCallback callback) {
+            super(state, resourceId, ownerKey, holdSec, callback);
+        }
+
+        @Override
+        protected boolean addToFeature() {
+            return false;
+        }
+    }
+}
diff --git a/policy-management/src/test/java/org/onap/policy/drools/system/internal/LockManagerTest.java b/policy-management/src/test/java/org/onap/policy/drools/system/internal/LockManagerTest.java
new file mode 100644
index 00000000..1cda079d
--- /dev/null
+++ b/policy-management/src/test/java/org/onap/policy/drools/system/internal/LockManagerTest.java
@@ -0,0 +1,259 @@
+/*
+ * ============LICENSE_START=======================================================
+ * ONAP
+ * ================================================================================
+ * Copyright (C) 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.system.internal;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import java.util.concurrent.ScheduledExecutorService;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.onap.policy.drools.core.lock.AlwaysFailLock;
+import org.onap.policy.drools.core.lock.Lock;
+import org.onap.policy.drools.core.lock.LockCallback;
+import org.onap.policy.drools.core.lock.LockState;
+
+public class LockManagerTest {
+    private static final String OWNER_KEY = "my key";
+    private static final String RESOURCE = "my resource";
+    private static final String RESOURCE2 = "my resource #2";
+    private static final int HOLD_SEC = 100;
+
+    @Mock
+    private LockCallback callback;
+
+    @Mock
+    private ScheduledExecutorService exsvc;
+
+    private MyManager mgr;
+
+    /**
+     * Resets fields and creates {@link #mgr}.
+     */
+    @Before
+    public void setUp() {
+        MockitoAnnotations.initMocks(this);
+
+        doAnswer(args -> {
+            args.getArgumentAt(0, Runnable.class).run();
+            return null;
+        }).when(exsvc).execute(any());
+
+        mgr = new MyManager();
+    }
+
+    @After
+    public void tearDown() {
+
+    }
+
+    @Test
+    public void testIsAlive() {
+        assertFalse(mgr.isAlive());
+        assertFalse(mgr.isLocked());
+
+        mgr.start();
+        assertTrue(mgr.isAlive());
+        assertFalse(mgr.isLocked());
+
+        mgr.stop();
+        assertFalse(mgr.isAlive());
+    }
+
+    @Test
+    public void testStart() {
+        assertTrue(mgr.start());
+        assertTrue(mgr.isAlive());
+
+        assertFalse(mgr.start());
+        assertTrue(mgr.isAlive());
+
+        mgr.stop();
+        assertTrue(mgr.start());
+        assertTrue(mgr.isAlive());
+    }
+
+    @Test
+    public void testStop() {
+        assertFalse(mgr.stop());
+
+        mgr.start();
+        assertTrue(mgr.stop());
+        assertFalse(mgr.isAlive());
+    }
+
+    @Test
+    public void testShutdown() {
+        mgr.start();
+        mgr.shutdown();
+        assertFalse(mgr.isAlive());
+
+        mgr.shutdown();
+        assertFalse(mgr.isAlive());
+    }
+
+    @Test
+    public void testIsLocked() {
+        assertFalse(mgr.isLocked());
+        assertFalse(mgr.isAlive());
+
+        mgr.lock();
+        assertTrue(mgr.isLocked());
+        assertFalse(mgr.isAlive());
+
+        mgr.unlock();
+        assertFalse(mgr.isLocked());
+    }
+
+    @Test
+    public void testLock() {
+        assertTrue(mgr.lock());
+        assertTrue(mgr.isLocked());
+
+        assertFalse(mgr.lock());
+        assertTrue(mgr.isLocked());
+
+        mgr.unlock();
+        assertTrue(mgr.lock());
+        assertTrue(mgr.isLocked());
+    }
+
+    @Test
+    public void testUnlock() {
+        assertFalse(mgr.unlock());
+
+        mgr.lock();
+        assertTrue(mgr.unlock());
+        assertFalse(mgr.isLocked());
+    }
+
+    @Test
+    public void testCreateLock() {
+        Lock lock = mgr.createLock(RESOURCE, OWNER_KEY, HOLD_SEC, callback, false);
+        assertTrue(lock.isActive());
+        verify(callback).lockAvailable(lock);
+        verify(callback, never()).lockUnavailable(lock);
+
+        // should not be able to lock it again
+        LockCallback callback2 = mock(LockCallback.class);
+        Lock lock2 = mgr.createLock(RESOURCE, OWNER_KEY, HOLD_SEC, callback2, false);
+        assertTrue(lock2.isUnavailable());
+        verify(callback2, never()).lockAvailable(lock2);
+        verify(callback2).lockUnavailable(lock2);
+
+        // should be able to lock another resource
+        LockCallback callback3 = mock(LockCallback.class);
+        Lock lock3 = mgr.createLock(RESOURCE2, OWNER_KEY, HOLD_SEC, callback3, false);
+        assertTrue(lock3.isActive());
+        verify(callback3).lockAvailable(lock3);
+        verify(callback3, never()).lockUnavailable(lock3);
+    }
+
+    /**
+     * Tests createLock() when the feature instance has changed.
+     */
+    @Test
+    public void testCreateLockInstanceChanged() {
+        mgr = spy(mgr);
+        when(mgr.hasInstanceChanged()).thenReturn(true);
+
+        Lock lock = mgr.createLock(RESOURCE, OWNER_KEY, HOLD_SEC, callback, false);
+        assertTrue(lock instanceof AlwaysFailLock);
+        assertTrue(lock.isUnavailable());
+
+        verify(callback, never()).lockAvailable(lock);
+        verify(callback).lockUnavailable(lock);
+    }
+
+    @Test
+    public void testGetResource2lock() {
+        assertNotNull(mgr.getResource2lock());
+    }
+
+    private class MyManager extends LockManager<MyLock> {
+
+        @Override
+        protected boolean hasInstanceChanged() {
+            return false;
+        }
+
+        @Override
+        protected void finishLock(MyLock lock) {
+            lock.grant(true);
+        }
+
+        @Override
+        protected MyLock makeLock(LockState waiting, String resourceId, String ownerKey, int holdSec,
+                        LockCallback callback) {
+            return new MyLock(waiting, resourceId, ownerKey, holdSec, callback);
+        }
+
+    }
+
+    private class MyLock extends FeatureLockImpl {
+        private static final long serialVersionUID = 1L;
+
+        public MyLock(LockState waiting, String resourceId, String ownerKey, int holdSec, LockCallback callback) {
+            super(waiting, resourceId, ownerKey, holdSec, callback);
+        }
+
+        @Override
+        public boolean free() {
+            return false;
+        }
+
+        @Override
+        public void extend(int holdSec, LockCallback callback) {
+            // do nothing
+        }
+
+        @Override
+        protected boolean addToFeature() {
+            return false;
+        }
+
+        @Override
+        public void notifyAvailable() {
+            getCallback().lockAvailable(this);
+        }
+
+        @Override
+        public void notifyUnavailable() {
+            getCallback().lockUnavailable(this);
+        }
+
+        @Override
+        protected ScheduledExecutorService getThreadPool() {
+            return exsvc;
+        }
+    }
+}
diff --git a/policy-management/src/test/java/org/onap/policy/drools/system/internal/SimpleLockManagerTest.java b/policy-management/src/test/java/org/onap/policy/drools/system/internal/SimpleLockManagerTest.java
index 66406898..79e20673 100644
--- a/policy-management/src/test/java/org/onap/policy/drools/system/internal/SimpleLockManagerTest.java
+++ b/policy-management/src/test/java/org/onap/policy/drools/system/internal/SimpleLockManagerTest.java
@@ -63,7 +63,6 @@ import org.onap.policy.common.utils.time.TestTime;
 import org.onap.policy.drools.core.lock.Lock;
 import org.onap.policy.drools.core.lock.LockCallback;
 import org.onap.policy.drools.core.lock.LockState;
-import org.onap.policy.drools.system.PolicyEngine;
 import org.onap.policy.drools.system.PolicyEngineConstants;
 import org.onap.policy.drools.system.internal.SimpleLockManager.SimpleLock;
 import org.powermock.reflect.Whitebox;
@@ -95,9 +94,6 @@ public class SimpleLockManagerTest {
     private ScheduledExecutorService exsvc;
 
     @Mock
-    private PolicyEngine engine;
-
-    @Mock
     private ScheduledFuture<?> future;
 
     @Mock
@@ -113,7 +109,6 @@ public class SimpleLockManagerTest {
         saveExec = Whitebox.getInternalState(PolicyEngineConstants.getManager(), POLICY_ENGINE_EXECUTOR_FIELD);
 
         realExec = Executors.newScheduledThreadPool(3);
-        Whitebox.setInternalState(PolicyEngineConstants.getManager(), POLICY_ENGINE_EXECUTOR_FIELD, realExec);
     }
 
     /**
@@ -141,7 +136,7 @@ public class SimpleLockManagerTest {
 
         Whitebox.setInternalState(SimpleLockManager.class, TIME_FIELD, testTime);
 
-        when(engine.getExecutorService()).thenReturn(exsvc);
+        Whitebox.setInternalState(PolicyEngineConstants.getManager(), POLICY_ENGINE_EXECUTOR_FIELD, exsvc);
 
         feature = new MyLockingFeature();
         feature.start();
@@ -156,19 +151,14 @@ public class SimpleLockManagerTest {
         Properties props = new Properties();
         props.setProperty(SimpleLockProperties.EXPIRE_CHECK_SEC, "abc");
 
-        assertThatThrownBy(() -> new MyLockingFeature(engine, props)).isInstanceOf(SimpleLockManagerException.class);
+        assertThatThrownBy(() -> new MyLockingFeature(props)).isInstanceOf(SimpleLockManagerException.class);
     }
 
     @Test
-    public void testIsAlive() {
+    public void testStart() {
         assertTrue(feature.isAlive());
+        verify(exsvc).scheduleWithFixedDelay(any(), anyLong(), anyLong(), any());
 
-        feature.stop();
-        assertFalse(feature.isAlive());
-    }
-
-    @Test
-    public void testStart() {
         assertFalse(feature.start());
 
         feature.stop();
@@ -178,6 +168,7 @@ public class SimpleLockManagerTest {
     @Test
     public void testStop() {
         assertTrue(feature.stop());
+        assertFalse(feature.isAlive());
         verify(future).cancel(true);
 
         assertFalse(feature.stop());
@@ -194,21 +185,12 @@ public class SimpleLockManagerTest {
     }
 
     @Test
-    public void testLockApi() {
-        assertFalse(feature.isLocked());
-        assertTrue(feature.lock());
-        assertTrue(feature.unlock());
-    }
-
-    @Test
     public void testCreateLock() {
         // this lock should be granted immediately
         SimpleLock lock = getLock(RESOURCE, OWNER_KEY, HOLD_SEC, callback, false);
         assertTrue(lock.isActive());
         assertEquals(testTime.getMillis() + HOLD_MS, lock.getHoldUntilMs());
 
-        invokeCallback(1);
-
         verify(callback).lockAvailable(lock);
         verify(callback, never()).lockUnavailable(lock);
 
@@ -218,8 +200,6 @@ public class SimpleLockManagerTest {
         assertFalse(lock2.isActive());
         assertTrue(lock2.isUnavailable());
 
-        invokeCallback(2);
-
         verify(callback, never()).lockAvailable(lock2);
         verify(callback).lockUnavailable(lock2);
 
@@ -231,13 +211,12 @@ public class SimpleLockManagerTest {
         // should work with "true" value also
         Lock lock3 = feature.createLock(RESOURCE2, OWNER_KEY, HOLD_SEC, callback, true);
         assertTrue(lock3.isActive());
-        invokeCallback(3);
         verify(callback).lockAvailable(lock3);
         verify(callback, never()).lockUnavailable(lock3);
     }
 
     /**
-     * Tests lock() when the feature is not the latest instance.
+     * Tests createLock() when the feature is not the latest instance.
      */
     @Test
     public void testCreateLockNotLatestInstance() {
@@ -275,7 +254,7 @@ public class SimpleLockManagerTest {
 
         // run the callbacks
         captor = ArgumentCaptor.forClass(Runnable.class);
-        verify(exsvc, times(5)).execute(captor.capture());
+        verify(exsvc, times(2)).execute(captor.capture());
         captor.getAllValues().forEach(Runnable::run);
         verify(callback).lockUnavailable(lock);
         verify(callback).lockUnavailable(lock2);
@@ -295,7 +274,7 @@ public class SimpleLockManagerTest {
 
         // run the callback
         captor = ArgumentCaptor.forClass(Runnable.class);
-        verify(exsvc, times(9)).execute(captor.capture());
+        verify(exsvc, times(3)).execute(captor.capture());
         captor.getValue().run();
         verify(callback).lockUnavailable(lock3);
     }
@@ -328,7 +307,6 @@ public class SimpleLockManagerTest {
         feature.start();
 
         feature.createLock(RESOURCE, OWNER_KEY, HOLD_SEC, callback, false);
-        invokeCallback(1);
 
         ArgumentCaptor<Runnable> captor = ArgumentCaptor.forClass(Runnable.class);
         verify(exsvc).scheduleWithFixedDelay(captor.capture(), anyLong(), anyLong(), any());
@@ -339,14 +317,12 @@ public class SimpleLockManagerTest {
 
         // lock should now be gone and we should be able to get another
         feature.createLock(RESOURCE, OWNER_KEY, HOLD_SEC, callback, false);
-        invokeCallback(2);
 
         // should have succeeded twice
         verify(callback, times(2)).lockAvailable(any());
 
         // lock should not be available now
         feature.createLock(RESOURCE, OWNER_KEY, HOLD_SEC, callback, false);
-        invokeCallback(3);
         verify(callback).lockUnavailable(any());
     }
 
@@ -389,7 +365,6 @@ public class SimpleLockManagerTest {
         feature.start();
 
         feature.createLock(RESOURCE, OWNER_KEY, HOLD_SEC, callback, false);
-        invokeCallback(1);
 
         ArgumentCaptor<Runnable> captor = ArgumentCaptor.forClass(Runnable.class);
         verify(exsvc).scheduleWithFixedDelay(captor.capture(), anyLong(), anyLong(), any());
@@ -400,14 +375,13 @@ public class SimpleLockManagerTest {
 
         // lock should not be available now
         feature.createLock(RESOURCE, OWNER_KEY, HOLD_SEC, callback, false);
-        invokeCallback(3);
         verify(callback).lockUnavailable(any());
     }
 
     @Test
     public void testGetThreadPool() {
         // use a real feature
-        feature = new SimpleLockManager(engine, new Properties());
+        feature = new SimpleLockManager(null, new Properties());
 
         // load properties
         feature.start();
@@ -459,45 +433,28 @@ public class SimpleLockManagerTest {
     @Test
     public void testSimpleLockExpired() {
         SimpleLock lock = getLock(RESOURCE, OWNER_KEY, HOLD_SEC, callback, false);
-        lock.grant();
+        lock.grant(true);
 
         assertFalse(lock.expired(testTime.getMillis()));
         assertFalse(lock.expired(testTime.getMillis() + HOLD_MS - 1));
         assertTrue(lock.expired(testTime.getMillis() + HOLD_MS));
     }
 
-    /**
-     * Tests grant() when the lock is already unavailable.
-     */
-    @Test
-    public void testSimpleLockGrantUnavailable() {
-        SimpleLock lock = getLock(RESOURCE, OWNER_KEY, HOLD_SEC, callback, false);
-        lock.setState(LockState.UNAVAILABLE);
-        lock.grant();
-
-        assertTrue(lock.isUnavailable());
-        verify(callback, never()).lockAvailable(any());
-        verify(callback, never()).lockUnavailable(any());
-    }
-
     @Test
     public void testSimpleLockFree() {
         final SimpleLock lock = getLock(RESOURCE, OWNER_KEY, HOLD_SEC, callback, false);
 
         // lock2 should be denied
         SimpleLock lock2 = getLock(RESOURCE, OWNER_KEY, HOLD_SEC, callback, false);
-        invokeCallback(2);
         verify(callback, never()).lockAvailable(lock2);
         verify(callback).lockUnavailable(lock2);
 
         // lock2 was denied, so nothing new should happen when freed
         assertFalse(lock2.free());
-        invokeCallback(2);
 
         // force lock2 to be active - still nothing should happen
         Whitebox.setInternalState(lock2, "state", LockState.ACTIVE);
         assertFalse(lock2.free());
-        invokeCallback(2);
 
         // now free the first lock
         assertTrue(lock.free());
@@ -506,6 +463,9 @@ public class SimpleLockManagerTest {
         // should be able to get the lock now
         SimpleLock lock3 = getLock(RESOURCE, OWNER_KEY, HOLD_SEC, callback, false);
         assertTrue(lock3.isActive());
+
+        verify(callback).lockAvailable(lock3);
+        verify(callback, never()).lockUnavailable(lock3);
     }
 
     /**
@@ -525,41 +485,22 @@ public class SimpleLockManagerTest {
         assertTrue(lock.isUnavailable());
     }
 
-    /**
-     * Tests free() on a serialized lock without a feature.
-     *
-     * @throws Exception if an error occurs
-     */
-    @Test
-    public void testSimpleLockFreeNoFeature() throws Exception {
-        SimpleLock lock = getLock(RESOURCE, OWNER_KEY, HOLD_SEC, callback, false);
-
-        SimpleLockManager.setLatestInstance(null);
-
-        lock = roundTrip(lock);
-        assertFalse(lock.free());
-        assertTrue(lock.isUnavailable());
-    }
-
     @Test
     public void testSimpleLockExtend() {
         final SimpleLock lock = getLock(RESOURCE, OWNER_KEY, HOLD_SEC, callback, false);
 
         // lock2 should be denied
         SimpleLock lock2 = getLock(RESOURCE, OWNER_KEY, HOLD_SEC, callback, false);
-        invokeCallback(2);
         verify(callback, never()).lockAvailable(lock2);
         verify(callback).lockUnavailable(lock2);
 
         // lock2 will still be denied
         lock2.extend(HOLD_SEC, callback);
-        invokeCallback(3);
         verify(callback, times(2)).lockUnavailable(lock2);
 
         // force lock2 to be active - should still be denied
         Whitebox.setInternalState(lock2, "state", LockState.ACTIVE);
         lock2.extend(HOLD_SEC, callback);
-        invokeCallback(4);
         verify(callback, times(3)).lockUnavailable(lock2);
 
         assertThatIllegalArgumentException().isThrownBy(() -> lock.extend(-1, callback))
@@ -569,8 +510,7 @@ public class SimpleLockManagerTest {
         lock.extend(HOLD_SEC2, callback);
         assertEquals(HOLD_SEC2, lock.getHoldSec());
         assertEquals(testTime.getMillis() + HOLD_MS2, lock.getHoldUntilMs());
-        invokeCallback(5);
-        verify(callback).lockAvailable(lock);
+        verify(callback, times(2)).lockAvailable(lock);
         verify(callback, never()).lockUnavailable(lock);
     }
 
@@ -592,13 +532,12 @@ public class SimpleLockManagerTest {
         lock.extend(HOLD_SEC, scallback);
         assertTrue(lock.isActive());
 
-        invokeCallback(1);
         verify(scallback).lockAvailable(lock);
         verify(scallback, never()).lockUnavailable(lock);
     }
 
     /**
-     * Tests extend() on a serialized lock without a feature.
+     * Tests that extend() fails when there is no feature.
      *
      * @throws Exception if an error occurs
      */
@@ -614,7 +553,6 @@ public class SimpleLockManagerTest {
         lock.extend(HOLD_SEC, scallback);
         assertTrue(lock.isUnavailable());
 
-        invokeCallback(1);
         verify(scallback, never()).lockAvailable(lock);
         verify(scallback).lockUnavailable(lock);
     }
@@ -635,7 +573,8 @@ public class SimpleLockManagerTest {
     @Test
     public void testMultiThreaded() throws InterruptedException {
         Whitebox.setInternalState(SimpleLockManager.class, TIME_FIELD, testTime);
-        feature = new SimpleLockManager(PolicyEngineConstants.getManager(), new Properties());
+        Whitebox.setInternalState(PolicyEngineConstants.getManager(), POLICY_ENGINE_EXECUTOR_FIELD, realExec);
+        feature = new SimpleLockManager(null, new Properties());
         feature.start();
 
         List<MyThread> threads = new ArrayList<>(MAX_THREADS);
@@ -677,33 +616,19 @@ public class SimpleLockManagerTest {
     }
 
     /**
-     * Invokes the last call-back in the work queue.
-     *
-     * @param nexpected number of call-backs expected in the work queue
-     */
-    private void invokeCallback(int nexpected) {
-        ArgumentCaptor<Runnable> captor = ArgumentCaptor.forClass(Runnable.class);
-        verify(exsvc, times(nexpected)).execute(captor.capture());
-
-        if (nexpected > 0) {
-            captor.getAllValues().get(nexpected - 1).run();
-        }
-    }
-
-    /**
      * Feature that uses <i>exsvc</i> to execute requests.
      */
     private class MyLockingFeature extends SimpleLockManager {
 
         public MyLockingFeature() {
-            this(engine, new Properties());
+            this(new Properties());
         }
 
-        public MyLockingFeature(PolicyEngine engine, Properties props) {
-            super(engine, props);
+        public MyLockingFeature(Properties props) {
+            super(null, props);
 
             exsvc = mock(ScheduledExecutorService.class);
-            when(engine.getExecutorService()).thenReturn(exsvc);
+            Whitebox.setInternalState(PolicyEngineConstants.getManager(), POLICY_ENGINE_EXECUTOR_FIELD, exsvc);
 
             when(exsvc.scheduleWithFixedDelay(any(), anyLong(), anyLong(), any())).thenAnswer(answer -> {
                 return future;