--- /dev/null
+/*-
+ * ============LICENSE_START=======================================================
+ * Integrity Monitor
+ * ================================================================================
+ * Copyright (C) 2017 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.statemanagement.test;
+
+import java.io.Serializable;
+
+import javax.persistence.Column;
+import javax.persistence.Entity;
+import javax.persistence.Id;
+import javax.persistence.Table;
+
+@Entity
+@Table(name="Audit")
+
+public class Audit implements Serializable {
+       private static final long serialVersionUID = 1L;
+
+       @Id
+       @Column(name="name", length=64, unique=true)
+       private String name;
+       
+       public Audit() {
+               //default constructor
+       }
+}
 
 
 import java.io.File;
 import java.io.FileInputStream;
+import java.io.IOException;
 import java.util.Properties;
 
 import javax.persistence.EntityManager;
 import javax.persistence.EntityManagerFactory;
 import javax.persistence.EntityTransaction;
 import javax.persistence.Persistence;
+import javax.ws.rs.core.Response;
 
 import org.junit.After;
 import org.junit.AfterClass;
 import org.junit.Before;
 import org.junit.BeforeClass;
-import org.junit.Ignore;
 import org.junit.Test;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.onap.policy.common.im.StateManagement;
 import org.onap.policy.drools.core.PolicySessionFeatureAPI;
+import org.onap.policy.drools.statemanagement.DbAudit;
+import org.onap.policy.drools.statemanagement.IntegrityMonitorRestManager;
+import org.onap.policy.drools.statemanagement.RepositoryAudit;
 import org.onap.policy.drools.statemanagement.StateManagementFeatureAPI;
 import org.onap.policy.drools.statemanagement.StateManagementProperties;
 
        private static Logger  logger = LoggerFactory.getLogger(StateManagementTest.class);     
        
        /*
-        * Sleep 5 seconds after each test to allow interrupt (shutdown) recovery.
+        * Sleep after each test to allow interrupt (shutdown) recovery.
         */
         
-       private long interruptRecoveryTime = 1000;
+       private long interruptRecoveryTime = 1500L;
        
        StateManagementFeatureAPI stateManagementFeature;
        
        public void tearDown() throws Exception {
                
        }
-
        
        /*
         * Verifies that StateManagementFeature starts and runs successfully.
 
                String configDir = "src/test/resources";
                
+               DbAudit.isJunit = true;
+               
                Properties fsmProperties = new Properties();
                fsmProperties.load(new FileInputStream(new File(
                                configDir + "/feature-state-management.properties")));
                String standby = stateManagementFeature.getStandbyStatus();
                
                logger.debug("admin = {}", admin);
-               System.out.println("admin = " + admin);
                logger.debug("oper = {}", oper);
-               System.out.println("oper = " + oper);
                logger.debug("avail = {}", avail);
-               System.out.println("avail = " + avail);
                logger.debug("standby = {}", standby);
-               System.out.println("standby = " + standby);
                
                assertTrue("Admin state not unlocked after initialization", admin.equals(StateManagement.UNLOCKED));
                assertTrue("Operational state not enabled after initialization", oper.equals(StateManagement.ENABLED));
                        stateManagementFeature.disableFailed();
                }catch(Exception e){
                        logger.error(e.getMessage());
-                       System.out.println(e.getMessage());
                        assertTrue(e.getMessage(), false);
                }
                
                standby = stateManagementFeature.getStandbyStatus();
                
                logger.debug("after disableFailed()");
-               System.out.println("after disableFailed()");
                logger.debug("admin = {}", admin);
-               System.out.println("admin = " + admin);
                logger.debug("oper = {}", oper);
-               System.out.println("oper = " + oper);
                logger.debug("avail = {}", avail);
-               System.out.println("avail = " + avail);
                logger.debug("standby = {}", standby);
-               System.out.println("standby = " + standby);
                
                assertTrue("Operational state not disabled after disableFailed()", oper.equals(StateManagement.DISABLED));
                assertTrue("Availability status not failed after disableFailed()", avail.equals(StateManagement.FAILED));
                        stateManagementFeature.promote();
                }catch(Exception e){
                        logger.debug(e.getMessage());
-                       System.out.println(e.getMessage());
                }
                
                Thread.sleep(interruptRecoveryTime);
                standby = stateManagementFeature.getStandbyStatus();
                
                logger.debug("after promote()");
-               System.out.println("after promote()");
                logger.debug("admin = {}", admin);
-               System.out.println("admin = " + admin);
                logger.debug("oper = {}", oper);
-               System.out.println("oper = " + oper);
                logger.debug("avail = {}", avail);
-               System.out.println("avail = " + avail);
                logger.debug("standby = {}", standby);
-               System.out.println("standby = " + standby);
 
                assertTrue("Standby status not coldstandby after promote()", standby.equals(StateManagement.COLD_STANDBY));
-                               
+
+               /**************Repository Audit Test**************/
+               logger.debug("\n\ntestStateManagementOperation: Repository Audit\n\n");
+               try{
+                       RepositoryAudit repositoryAudit = (RepositoryAudit) RepositoryAudit.getInstance();
+                       repositoryAudit.invoke(fsmProperties);
+               
+                       //Should not throw an IOException in Linux Foundation env 
+                       assertTrue(true);
+               }catch(IOException e){
+                       //Note: this catch is here because in a local environment mvn will not run in
+                       //in the temp directory
+                       logger.debug("testSubsytemTest RepositoryAudit IOException", e);
+               }catch(InterruptedException e){
+                       assertTrue(false);
+                       logger.debug("testSubsytemTest RepositoryAudit InterruptedException", e);
+               }
+
+               /*****************Db Audit Test***************/
+               logger.debug("\n\ntestStateManagementOperation: DB Audit\n\n");
+
+               try{
+                       DbAudit dbAudit = (DbAudit) DbAudit.getInstance();
+                       dbAudit.invoke(fsmProperties);
+               
+                       assertTrue(true);
+               }catch(Exception e){
+                       assertTrue(false);
+                       logger.debug("testSubsytemTest DbAudit exception", e);
+               }
+
+               /*************IntegrityMonitorRestManager Test*************/
+               logger.debug("\n\ntestStateManagementOperation: IntegrityMonitorRestManager\n\n");
+               IntegrityMonitorRestManager integrityMonitorRestManager = new IntegrityMonitorRestManager();
+               
+               Response response = integrityMonitorRestManager.test();
+               logger.debug("\n\nIntegrityMonitorRestManager response: " + response.toString());
+               
+               assertTrue(response.toString().contains("status=500"));
+
+               //All done
                logger.debug("\n\ntestStateManagementOperation: Exiting\n\n");
        }       
        
 
 # forwardprogressentity table and marks the node as disabled/failed in the statemanagemententity 
 # table. NOTE! It will only run on nodes that have a standbystatus = providingservice.
 # A value of <= 0 will turn off the state audit.
-state_audit_interval_ms=60000
+state_audit_interval_ms=-1000
 # The refresh state audit is run every (default) 10 minutes (600000 ms) to clean up any state corruption in the 
 # DB statemanagemententity table. It only refreshes the DB state entry for the local node.  That is, it does not
 # refresh the state of any other nodes.  A value <= 0 will turn the audit off. Any other value will override 
 # the default of 600000 ms.
-refresh_state_audit_interval_ms=600000
+refresh_state_audit_interval_ms=-1000
 
 
 # Repository audit properties
 # Flag to control the execution of the subsystemTest for the Nexus Maven repository
-repository.audit.is.active=false
+repository.audit.is.active=true
 repository.audit.ignore.errors=true
+# Timeout in seconds
+repository.audit.timeout=5
+repository.audit.id=statemanagement
+repository.audit.url=jdbc:h2:file:./sql/statemanagement
+repository.audit.username=sa
+repository.audit.password=
 
 # DB Audit Properties
 # Flag to control the execution of the subsystemTest for the Database
-db.audit.is.active=false
+db.audit.is.active=true