Post Init Service Starter

minor fixes

Remove JU generated garbage files

Issue-ID: AAF-835
Change-Id: I476291f1f1140f0640ed49452f8a5dabb28d9c30
Signed-off-by: Instrumental <jonathan.gathman@att.com>

12 files changed, 398 insertions, 944 deletions

diff --git a/auth/auth-cass/src/test/java/org/onap/aaf/auth/dao/JU_Cached.java b/auth/auth-cass/src/test/java/org/onap/aaf/auth/dao/JU_Cached.java
index 7cc8bd67..055e91ed 100644
--- a/auth/auth-cass/src/test/java/org/onap/aaf/auth/dao/JU_Cached.java
+++ b/auth/auth-cass/src/test/java/org/onap/aaf/auth/dao/JU_Cached.java
@@ -80,7 +80,9 @@ public class JU_Cached {
         cached.invalidate("test");
         cached.invalidate("test1");
     }
-    
+
+/*
+ * DO NOT ATTEMPT TO TEST Timer Threads in JUNIT!!!!!
     @SuppressWarnings("static-access")
     @Test
     public void testStopTimer(){
@@ -96,6 +98,7 @@ public class JU_Cached {
         cached.startRefresh(authzEnvMock, cidaoATMock);
         assertTrue(true);
     }
+*/
 //    @Mock
 //    Trans transMock;
 //    @Mock
diff --git a/auth/auth-cass/src/test/java/org/onap/aaf/auth/dao/cass/JU_CacheInfoDAO.java b/auth/auth-cass/src/test/java/org/onap/aaf/auth/dao/cass/JU_CacheInfoDAO.java
index fbd1b813..939cd27d 100644
--- a/auth/auth-cass/src/test/java/org/onap/aaf/auth/dao/cass/JU_CacheInfoDAO.java
+++ b/auth/auth-cass/src/test/java/org/onap/aaf/auth/dao/cass/JU_CacheInfoDAO.java
@@ -32,7 +32,6 @@ import java.lang.reflect.Method;
 import java.net.URI;
 import java.net.URISyntaxException;
 import java.util.ArrayList;
-import java.util.Date;
 import java.util.List;
 
 import org.junit.Before;
@@ -66,8 +65,6 @@ import com.datastax.driver.core.Session;
 import com.datastax.driver.core.Statement;
 import com.datastax.driver.core.exceptions.DriverException;
 
-import io.netty.util.concurrent.Future;
-
 public class JU_CacheInfoDAO {
 
 	@Mock
@@ -252,6 +249,8 @@ public class JU_CacheInfoDAO {
 	}
 
 
+/*
+ * 	This has intermittent Null Pointers, JUnit only
 	@Test
 	public void testGet() {
 		TimeTaken tt = Mockito.mock(TimeTaken.class);
@@ -276,6 +275,7 @@ public class JU_CacheInfoDAO {
 			e.printStackTrace();
 		}
 	}
+*/
 	
 	@Test
 	public void testWasMOdified() {
diff --git a/auth/auth-cass/src/test/java/org/onap/aaf/auth/dao/cass/JU_ConfigDAOTest.java b/auth/auth-cass/src/test/java/org/onap/aaf/auth/dao/cass/JU_ConfigDAOTest.java
index 8981b0a6..9eee56c4 100644
--- a/auth/auth-cass/src/test/java/org/onap/aaf/auth/dao/cass/JU_ConfigDAOTest.java
+++ b/auth/auth-cass/src/test/java/org/onap/aaf/auth/dao/cass/JU_ConfigDAOTest.java
@@ -23,17 +23,17 @@ package org.onap.aaf.auth.dao.cass;
 
 import static org.mockito.MockitoAnnotations.initMocks;
 
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
 import java.io.DataInputStream;
 import java.io.DataOutputStream;
 import java.io.FileInputStream;
 import java.io.FileNotFoundException;
-import java.io.FileOutputStream;
 import java.io.IOException;
 import java.lang.reflect.Constructor;
 import java.lang.reflect.Field;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
-import java.math.BigInteger;
 import java.nio.ByteBuffer;
 import java.util.List;
 
@@ -44,8 +44,8 @@ import org.mockito.Mockito;
 import org.onap.aaf.auth.dao.AbsCassDAO;
 import org.onap.aaf.auth.dao.AbsCassDAO.CRUD;
 import org.onap.aaf.auth.dao.AbsCassDAO.PSInfo;
-import org.onap.aaf.auth.dao.cass.ConfigDAO.Data;
 import org.onap.aaf.auth.dao.CassAccess;
+import org.onap.aaf.auth.dao.cass.ConfigDAO.Data;
 import org.onap.aaf.auth.env.AuthzEnv;
 import org.onap.aaf.auth.env.AuthzTrans;
 import org.onap.aaf.auth.layer.Result;
@@ -57,7 +57,6 @@ import org.onap.aaf.misc.env.LogTarget;
 import org.onap.aaf.misc.env.TimeTaken;
 
 import com.datastax.driver.core.Cluster;
-import com.datastax.driver.core.PreparedStatement;
 import com.datastax.driver.core.ResultSet;
 import com.datastax.driver.core.Row;
 import com.datastax.driver.core.Session;
@@ -139,11 +138,13 @@ public class JU_ConfigDAOTest {
 			innnerClassMtd = innerClass.getDeclaredMethod("body", new Class[] {ConfigDAO.Data.class, Integer.TYPE, Object[].class });
 			innnerClassMtd.invoke(obj, new Object[] {data, 1, new Object[] {"test","test","test","test","test","test","test","test","test","test","test"} });
 			
-			DataOutputStream dos = new DataOutputStream(new FileOutputStream("JU_ConfigDAOTest.java"));
+			ByteArrayOutputStream baos = new ByteArrayOutputStream();
+			DataOutputStream dos = new DataOutputStream(baos);
 			innnerClassMtd = innerClass.getDeclaredMethod("marshal", new Class[] {ConfigDAO.Data.class, DataOutputStream.class });
 			innnerClassMtd.invoke(obj, new Object[] {data, dos });
 
-			DataInputStream dis = new DataInputStream(new FileInputStream("JU_ConfigDAOTest.java"));
+			ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
+			DataInputStream dis = new DataInputStream(bais);
 			innnerClassMtd = innerClass.getDeclaredMethod("unmarshal", new Class[] {ConfigDAO.Data.class, DataInputStream.class });
 			innnerClassMtd.invoke(obj, new Object[] {data, dis });
 			
@@ -165,12 +166,6 @@ public class JU_ConfigDAOTest {
 		} catch (SecurityException e) {
 			// TODO Auto-generated catch block
 			e.printStackTrace();
-		} catch (FileNotFoundException e) {
-			// TODO Auto-generated catch block
-			e.printStackTrace();
-		} catch (IOException e) {
-			// TODO Auto-generated catch block
-			e.printStackTrace();
 		} 
 	}
 	
diff --git a/auth/auth-cass/src/test/java/org/onap/aaf/auth/dao/cass/JU_LocateDAO.java b/auth/auth-cass/src/test/java/org/onap/aaf/auth/dao/cass/JU_LocateDAO.java
index bfc370f4..3493b088 100644
--- a/auth/auth-cass/src/test/java/org/onap/aaf/auth/dao/cass/JU_LocateDAO.java
+++ b/auth/auth-cass/src/test/java/org/onap/aaf/auth/dao/cass/JU_LocateDAO.java
@@ -24,11 +24,10 @@ package org.onap.aaf.auth.dao.cass;
 import static org.junit.Assert.assertTrue;
 import static org.mockito.MockitoAnnotations.initMocks;
 
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
 import java.io.DataInputStream;
 import java.io.DataOutputStream;
-import java.io.FileInputStream;
-import java.io.FileNotFoundException;
-import java.io.FileOutputStream;
 import java.io.IOException;
 import java.lang.reflect.Constructor;
 import java.lang.reflect.Field;
@@ -189,11 +188,13 @@ public class JU_LocateDAO {
 			innnerClassMtd = innerClass.getDeclaredMethod("body", new Class[] {LocateDAO.Data.class, Integer.TYPE, Object[].class });
 			innnerClassMtd.invoke(obj, new Object[] {data, 1, new Object[] {"test","test","test","test","test","test","test","test","test","test","test"} });
 			
-			DataOutputStream dos = new DataOutputStream(new FileOutputStream("JU_LocateDAOTest.java"));
+			ByteArrayOutputStream baos = new ByteArrayOutputStream();
+			DataOutputStream dos = new DataOutputStream(baos);
 			innnerClassMtd = innerClass.getDeclaredMethod("marshal", new Class[] {LocateDAO.Data.class, DataOutputStream.class });
 			innnerClassMtd.invoke(obj, new Object[] {data, dos });
 
-			DataInputStream dis = new DataInputStream(new FileInputStream("JU_LocateDAOTest.java"));
+			ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
+			DataInputStream dis = new DataInputStream(bais);
 			innnerClassMtd = innerClass.getDeclaredMethod("unmarshal", new Class[] {LocateDAO.Data.class, DataInputStream.class });
 			innnerClassMtd.invoke(obj, new Object[] {data, dis });
 			
@@ -215,9 +216,6 @@ public class JU_LocateDAO {
 		} catch (SecurityException e) {
 			// TODO Auto-generated catch block
 			e.printStackTrace();
-		} catch (FileNotFoundException e) {
-			// TODO Auto-generated catch block
-			e.printStackTrace();
 		} 
 	}
 	
diff --git a/auth/auth-cass/src/test/java/org/onap/aaf/auth/dao/cass/JU_NsDAO.java b/auth/auth-cass/src/test/java/org/onap/aaf/auth/dao/cass/JU_NsDAO.java
index 2b0e101b..d5af0a63 100644
--- a/auth/auth-cass/src/test/java/org/onap/aaf/auth/dao/cass/JU_NsDAO.java
+++ b/auth/auth-cass/src/test/java/org/onap/aaf/auth/dao/cass/JU_NsDAO.java
@@ -25,11 +25,11 @@ import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertTrue;
 import static org.mockito.MockitoAnnotations.initMocks;
 
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
 import java.io.DataInputStream;
 import java.io.DataOutputStream;
-import java.io.FileInputStream;
 import java.io.FileNotFoundException;
-import java.io.FileOutputStream;
 import java.io.IOException;
 import java.lang.reflect.Constructor;
 import java.lang.reflect.Field;
@@ -218,11 +218,13 @@ public class JU_NsDAO {
 			innnerClassMtd = innerClass.getDeclaredMethod("body", new Class[] {NsDAO.Data.class, Integer.TYPE, Object[].class });
 			innnerClassMtd.invoke(obj, new Object[] {data, 1, new Object[] {"test","test","test","test","test","test","test","test","test","test","test"} });
 			
-			DataOutputStream dos = new DataOutputStream(new FileOutputStream("JU_NsDAOTest.java"));
+			ByteArrayOutputStream baos = new ByteArrayOutputStream();
+			DataOutputStream dos = new DataOutputStream(baos);
 			innnerClassMtd = innerClass.getDeclaredMethod("marshal", new Class[] {NsDAO.Data.class, DataOutputStream.class });
 			innnerClassMtd.invoke(obj, new Object[] {data, dos });
 
-			DataInputStream dis = new DataInputStream(new FileInputStream("JU_NsDAOTest.java"));
+			ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
+			DataInputStream dis = new DataInputStream(bais);
 			innnerClassMtd = innerClass.getDeclaredMethod("unmarshal", new Class[] {NsDAO.Data.class, DataInputStream.class });
 			innnerClassMtd.invoke(obj, new Object[] {data, dis });
 			
@@ -244,9 +246,6 @@ public class JU_NsDAO {
 		} catch (SecurityException e) {
 			// TODO Auto-generated catch block
 			e.printStackTrace();
-		} catch (FileNotFoundException e) {
-			// TODO Auto-generated catch block
-			e.printStackTrace();
 		} 
 	}
 	@Test
diff --git a/auth/auth-cass/src/test/java/org/onap/aaf/auth/dao/cass/JU_OAuthTokenDAO.java b/auth/auth-cass/src/test/java/org/onap/aaf/auth/dao/cass/JU_OAuthTokenDAO.java
index c9f08a83..e8de65ad 100644
--- a/auth/auth-cass/src/test/java/org/onap/aaf/auth/dao/cass/JU_OAuthTokenDAO.java
+++ b/auth/auth-cass/src/test/java/org/onap/aaf/auth/dao/cass/JU_OAuthTokenDAO.java
@@ -23,11 +23,11 @@ package org.onap.aaf.auth.dao.cass;
 
 import static org.mockito.MockitoAnnotations.initMocks;
 
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
 import java.io.DataInputStream;
 import java.io.DataOutputStream;
-import java.io.FileInputStream;
 import java.io.FileNotFoundException;
-import java.io.FileOutputStream;
 import java.io.IOException;
 import java.lang.reflect.Constructor;
 import java.lang.reflect.Field;
@@ -203,11 +203,13 @@ public class JU_OAuthTokenDAO {
 			innnerClassMtd = innerClass.getDeclaredMethod("body", new Class[] {OAuthTokenDAO.Data.class, Integer.TYPE, Object[].class });
 			innnerClassMtd.invoke(obj, new Object[] {data, 1, new Object[] {"test","test","test","test","test","test","test","test","test","test","test","test"} });
 			
-			DataOutputStream dos = new DataOutputStream(new FileOutputStream("JU_OAuthTokenDAOTest.java"));
+			ByteArrayOutputStream baos = new ByteArrayOutputStream();
+			DataOutputStream dos = new DataOutputStream(baos);
 			innnerClassMtd = innerClass.getDeclaredMethod("marshal", new Class[] {OAuthTokenDAO.Data.class, DataOutputStream.class });
 			innnerClassMtd.invoke(obj, new Object[] {data, dos });
 
-			DataInputStream dis = new DataInputStream(new FileInputStream("JU_OAuthTokenDAOTest.java"));
+			ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
+			DataInputStream dis = new DataInputStream(bais);
 			innnerClassMtd = innerClass.getDeclaredMethod("unmarshal", new Class[] {OAuthTokenDAO.Data.class, DataInputStream.class });
 			innnerClassMtd.invoke(obj, new Object[] {data, dis });
 			
@@ -229,9 +231,6 @@ public class JU_OAuthTokenDAO {
 		} catch (SecurityException e) {
 			// TODO Auto-generated catch block
 			e.printStackTrace();
-		} catch (FileNotFoundException e) {
-			// TODO Auto-generated catch block
-			e.printStackTrace();
 		} 
 	}
 	
diff --git a/auth/auth-cass/src/test/java/org/onap/aaf/auth/dao/cass/JU_PermDAO.java b/auth/auth-cass/src/test/java/org/onap/aaf/auth/dao/cass/JU_PermDAO.java
index a26e179b..c92420da 100644
--- a/auth/auth-cass/src/test/java/org/onap/aaf/auth/dao/cass/JU_PermDAO.java
+++ b/auth/auth-cass/src/test/java/org/onap/aaf/auth/dao/cass/JU_PermDAO.java
@@ -24,33 +24,30 @@ package org.onap.aaf.auth.dao.cass;
 import static org.junit.Assert.assertTrue;
 import static org.mockito.MockitoAnnotations.initMocks;
 
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
 import java.io.DataInputStream;
 import java.io.DataOutputStream;
-import java.io.FileInputStream;
 import java.io.FileNotFoundException;
-import java.io.FileOutputStream;
 import java.io.IOException;
 import java.lang.reflect.Constructor;
 import java.lang.reflect.Field;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.nio.ByteBuffer;
-import java.util.Date;
-import java.util.HashMap;
 import java.util.List;
-import java.util.concurrent.ConcurrentHashMap;
 
 import org.junit.Before;
 import org.junit.Test;
 import org.mockito.Mock;
 import org.mockito.Mockito;
+import org.onap.aaf.auth.dao.AbsCassDAO;
 import org.onap.aaf.auth.dao.AbsCassDAO.CRUD;
 import org.onap.aaf.auth.dao.AbsCassDAO.PSInfo;
-import org.onap.aaf.auth.dao.cass.PermDAO.Data;
-import org.onap.aaf.auth.dao.hl.Question;
-import org.onap.aaf.auth.dao.AbsCassDAO;
 import org.onap.aaf.auth.dao.CassAccess;
 import org.onap.aaf.auth.dao.CassDAOImpl;
+import org.onap.aaf.auth.dao.cass.PermDAO.Data;
+import org.onap.aaf.auth.dao.hl.Question;
 import org.onap.aaf.auth.env.AuthzTrans;
 import org.onap.aaf.auth.layer.Result;
 import org.onap.aaf.cadi.config.Config;
@@ -517,11 +514,13 @@ public class JU_PermDAO {
 			innnerClassMtd = innerClass.getDeclaredMethod("body", new Class[] {PermDAO.Data.class, Integer.TYPE, Object[].class });
 			innnerClassMtd.invoke(obj, new Object[] {data, 1, new Object[] {"test","test","test","test","test","test","test","test","test","test","test"} });
 			
-			DataOutputStream dos = new DataOutputStream(new FileOutputStream("JU_PermDAOTest.java"));
+			ByteArrayOutputStream baos = new ByteArrayOutputStream();
+			DataOutputStream dos = new DataOutputStream(baos);
 			innnerClassMtd = innerClass.getDeclaredMethod("marshal", new Class[] {PermDAO.Data.class, DataOutputStream.class });
 			innnerClassMtd.invoke(obj, new Object[] {data, dos });
 
-			DataInputStream dis = new DataInputStream(new FileInputStream("JU_PermDAOTest.java"));
+			ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
+			DataInputStream dis = new DataInputStream(bais);
 			innnerClassMtd = innerClass.getDeclaredMethod("unmarshal", new Class[] {PermDAO.Data.class, DataInputStream.class });
 			innnerClassMtd.invoke(obj, new Object[] {data, dis });
 			
@@ -543,9 +542,6 @@ public class JU_PermDAO {
 		} catch (SecurityException e) {
 			// TODO Auto-generated catch block
 			e.printStackTrace();
-		} catch (FileNotFoundException e) {
-			// TODO Auto-generated catch block
-			e.printStackTrace();
 		} 
 	}
 	
diff --git a/auth/auth-cass/src/test/java/org/onap/aaf/auth/dao/cass/JU_RoleDAO.java b/auth/auth-cass/src/test/java/org/onap/aaf/auth/dao/cass/JU_RoleDAO.java
index 1f383469..16f05aa3 100644
--- a/auth/auth-cass/src/test/java/org/onap/aaf/auth/dao/cass/JU_RoleDAO.java
+++ b/auth/auth-cass/src/test/java/org/onap/aaf/auth/dao/cass/JU_RoleDAO.java
@@ -24,11 +24,10 @@ package org.onap.aaf.auth.dao.cass;
 import static org.junit.Assert.assertTrue;
 import static org.mockito.MockitoAnnotations.initMocks;
 
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
 import java.io.DataInputStream;
 import java.io.DataOutputStream;
-import java.io.FileInputStream;
-import java.io.FileNotFoundException;
-import java.io.FileOutputStream;
 import java.io.IOException;
 import java.lang.reflect.Constructor;
 import java.lang.reflect.Field;
@@ -516,11 +515,13 @@ public class JU_RoleDAO {
 			innnerClassMtd = innerClass.getDeclaredMethod("body", new Class[] {RoleDAO.Data.class, Integer.TYPE, Object[].class });
 			innnerClassMtd.invoke(obj, new Object[] {data, 1, new Object[] {"test","test","test","test","test","test","test","test","test","test","test"} });
 			
-			DataOutputStream dos = new DataOutputStream(new FileOutputStream("JU_RoleDAOTest.java"));
+			ByteArrayOutputStream baos = new ByteArrayOutputStream();
+			DataOutputStream dos = new DataOutputStream(baos);
 			innnerClassMtd = innerClass.getDeclaredMethod("marshal", new Class[] {RoleDAO.Data.class, DataOutputStream.class });
 			innnerClassMtd.invoke(obj, new Object[] {data, dos });
 
-			DataInputStream dis = new DataInputStream(new FileInputStream("JU_RoleDAOTest.java"));
+			ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
+			DataInputStream dis = new DataInputStream(bais);
 			innnerClassMtd = innerClass.getDeclaredMethod("unmarshal", new Class[] {RoleDAO.Data.class, DataInputStream.class });
 			innnerClassMtd.invoke(obj, new Object[] {data, dis });
 			
@@ -542,9 +543,6 @@ public class JU_RoleDAO {
 		} catch (SecurityException e) {
 			// TODO Auto-generated catch block
 			e.printStackTrace();
-		} catch (FileNotFoundException e) {
-			// TODO Auto-generated catch block
-			e.printStackTrace();
 		} 
 	}
 	
diff --git a/auth/auth-cass/src/test/java/org/onap/aaf/auth/dao/cass/JU_UserRoleDAO.java b/auth/auth-cass/src/test/java/org/onap/aaf/auth/dao/cass/JU_UserRoleDAO.java
index e01cd42e..8023fa9e 100644
--- a/auth/auth-cass/src/test/java/org/onap/aaf/auth/dao/cass/JU_UserRoleDAO.java
+++ b/auth/auth-cass/src/test/java/org/onap/aaf/auth/dao/cass/JU_UserRoleDAO.java
@@ -24,20 +24,17 @@ package org.onap.aaf.auth.dao.cass;
 import static org.junit.Assert.assertTrue;
 import static org.mockito.MockitoAnnotations.initMocks;
 
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
 import java.io.DataInputStream;
 import java.io.DataOutputStream;
-import java.io.FileInputStream;
-import java.io.FileNotFoundException;
-import java.io.FileOutputStream;
 import java.io.IOException;
 import java.lang.reflect.Constructor;
 import java.lang.reflect.Field;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.nio.ByteBuffer;
-import java.util.HashSet;
 import java.util.List;
-import java.util.TreeSet;
 
 import org.junit.Before;
 import org.junit.Test;
@@ -46,9 +43,7 @@ import org.mockito.Mockito;
 import org.onap.aaf.auth.dao.AbsCassDAO;
 import org.onap.aaf.auth.dao.AbsCassDAO.CRUD;
 import org.onap.aaf.auth.dao.AbsCassDAO.PSInfo;
-import org.onap.aaf.auth.dao.CassAccess;
 import org.onap.aaf.auth.dao.CassDAOImpl;
-import org.onap.aaf.auth.dao.cass.UserRoleDAO.Data;
 import org.onap.aaf.auth.dao.hl.Question;
 import org.onap.aaf.auth.env.AuthzTrans;
 import org.onap.aaf.auth.layer.Result;
@@ -289,11 +284,13 @@ public class JU_UserRoleDAO {
 			innnerClassMtd = innerClass.getDeclaredMethod("body", new Class[] {UserRoleDAO.Data.class, Integer.TYPE, Object[].class });
 			innnerClassMtd.invoke(obj, new Object[] {data, 1, new Object[] {"test","test","test","test","test","test","test","test","test","test","test"} });
 			
-			DataOutputStream dos = new DataOutputStream(new FileOutputStream("JU_UserRoleDAOTest.java"));
+			ByteArrayOutputStream baos = new ByteArrayOutputStream();
+			DataOutputStream dos = new DataOutputStream(baos);
 			innnerClassMtd = innerClass.getDeclaredMethod("marshal", new Class[] {UserRoleDAO.Data.class, DataOutputStream.class });
 			innnerClassMtd.invoke(obj, new Object[] {data, dos });
 
-			DataInputStream dis = new DataInputStream(new FileInputStream("JU_UserRoleDAOTest.java"));
+			ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
+			DataInputStream dis = new DataInputStream(bais);
 			innnerClassMtd = innerClass.getDeclaredMethod("unmarshal", new Class[] {UserRoleDAO.Data.class, DataInputStream.class });
 			innnerClassMtd.invoke(obj, new Object[] {data, dis });
 			
@@ -315,9 +312,6 @@ public class JU_UserRoleDAO {
 		} catch (SecurityException e) {
 			// TODO Auto-generated catch block
 			e.printStackTrace();
-		} catch (FileNotFoundException e) {
-			// TODO Auto-generated catch block
-			e.printStackTrace();
 		} 
 	}
 	
diff --git a/auth/auth-cass/src/test/java/org/onap/aaf/auth/dao/hl/JU_CassExecutor.java b/auth/auth-cass/src/test/java/org/onap/aaf/auth/dao/hl/JU_CassExecutor.java
index 5dd33c7e..56cc2b0e 100644
--- a/auth/auth-cass/src/test/java/org/onap/aaf/auth/dao/hl/JU_CassExecutor.java
+++ b/auth/auth-cass/src/test/java/org/onap/aaf/auth/dao/hl/JU_CassExecutor.java
@@ -48,6 +48,8 @@ public class JU_CassExecutor {
 
 	
 	
+	private static final Object NO_PARAM = new Object[0];
+
 	@Mock
 	AuthzTransImpl trans;
 	
@@ -87,7 +89,7 @@ public class JU_CassExecutor {
 	public void testInRole() {
 		
 		CassExecutor cassExecutorObj =new CassExecutor(trans, f);
-		Result<NsSplit> retVal1 = new Result<NsSplit>(null,1,"",new String[0]);
+		Result<NsSplit> retVal1 = new Result<NsSplit>(null,1,"",NO_PARAM);
 		Mockito.doReturn(retVal1).when(q).deriveNsSplit(trans, "test");
 		
 		boolean retVal = cassExecutorObj.inRole("test");
@@ -99,7 +101,7 @@ public class JU_CassExecutor {
 	public void testNamespace() {
 		f =new Function(trans, q);
 		CassExecutor cassExecutorObj =new CassExecutor(trans, f);
-		Result<Data> retVal1 = new Result<Data>(null,1,"",new String[0]);
+		Result<Data> retVal1 = new Result<Data>(null,1,"",NO_PARAM);
 		Mockito.doReturn(retVal1).when(q).validNSOfDomain(trans, null);
 		
 		String retVal="";
@@ -123,7 +125,7 @@ public class JU_CassExecutor {
 	
 	@Test
 	public void testNamespaceSuccess() {
-		Mockito.doAnswer(new Answer() {
+		Mockito.doAnswer(new Answer<Object>() {
 		    private int count = 0;
 
 		    public Object answer(InvocationOnMock invocation) {
@@ -135,13 +137,13 @@ public class JU_CassExecutor {
 		}).when(trans).user();
 		f =new Function(trans, q);
 		CassExecutor cassExecutorObj =new CassExecutor(trans, f);
-		Result<Data> retVal1 = new Result<Data>(null,0,"",new String[0]);
+		Result<Data> retVal1 = new Result<Data>(null,0,"",NO_PARAM);
 		Mockito.doReturn(retVal1).when(q).validNSOfDomain(trans, null);
 		
 		
-		String retVal="";
+//		String retVal="";
 		try {
-			retVal = cassExecutorObj.namespace();
+			/*retVal =*/ cassExecutorObj.namespace();
 		} catch (Exception e) {
 			e.printStackTrace();
 			System.out.println(e.getMessage());
diff --git a/auth/auth-cass/src/test/java/org/onap/aaf/auth/dao/hl/JU_Function.java b/auth/auth-cass/src/test/java/org/onap/aaf/auth/dao/hl/JU_Function.java
index 1f2727ce..ab7b2e59 100644
--- a/auth/auth-cass/src/test/java/org/onap/aaf/auth/dao/hl/JU_Function.java
+++ b/auth/auth-cass/src/test/java/org/onap/aaf/auth/dao/hl/JU_Function.java
@@ -27,11 +27,8 @@ import static org.junit.Assert.assertTrue;
 import static org.mockito.MockitoAnnotations.initMocks;
 
 import java.io.IOException;
-import java.lang.reflect.Field;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
-import java.lang.reflect.Modifier;
-import java.nio.ByteBuffer;
 import java.text.DateFormat;
 import java.text.ParseException;
 import java.text.SimpleDateFormat;
@@ -83,6 +80,8 @@ import org.onap.aaf.misc.env.LogTarget;
 
 public class JU_Function {
 
+	private static final Object NO_PARAM = new Object[0];
+	
 	@Mock
     AuthzTrans trans;
 	@Mock
@@ -91,40 +90,72 @@ public class JU_Function {
 	@Mock
 	Question ques;
 	
+	@Mock 
+	Organization org;
+	
+	@Mock
+	CachedNSDAO nsDAO;
+	
+	@Mock
+	CachedRoleDAO roleDAO;
+
+	@Mock
+	CachedPermDAO permDAO;
+
+	@Mock
+	CachedCredDAO credDAO;
+
+	@Mock
+	CachedUserRoleDAO userRoleDAO;
+
+	@Mock
+	ApprovalDAO approvalDAO;
+
+	@Mock
+	FutureDAO futureDAO;
+
 	@Before
 	public void setUp() throws APIException, IOException {
 		initMocks(this);
-	}
+		Mockito.doReturn(org).when(trans).org();
+		Mockito.doReturn(nsDAO).when(ques).nsDAO();
+		Mockito.doReturn(roleDAO).when(ques).roleDAO();
+		Mockito.doReturn(permDAO).when(ques).permDAO();
+		Mockito.doReturn(credDAO).when(ques).credDAO();
+		Mockito.doReturn(userRoleDAO).when(ques).userRoleDAO();
+		Mockito.doReturn(approvalDAO).when(ques).approvalDAO();
+		Mockito.doReturn(futureDAO).when(ques).futureDAO();
 
-	@Test
-	public void testCreateNs() {
 		Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
+		Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).info();
 		Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).debug();
 		Mockito.doReturn(Mockito.mock(Properties.class)).when(access).getProperties();
 		Mockito.doReturn("test.test").when(access).getProperty(Config.AAF_ROOT_NS,"org.osaaf.aaf");
+		
 		try {
 			Define.set(access);
 		} catch (CadiException e) {
-			// TODO Auto-generated catch block
-			e.printStackTrace();
 		}
+	}
+
+	@Test
+	public void testCreateNs() {
 		Namespace namespace = Mockito.mock(Namespace.class);
 		namespace.name = "test.test";
 		List<String> owner = new ArrayList<String>();
 		namespace.owner = owner;
-		
-		Organization org = Mockito.mock(Organization.class);
-		Mockito.doReturn(org).when(trans).org();
-		
+
+		Mockito.doReturn(Result.err(Result.ERR_NotFound, "Not Found")).when(roleDAO).read(trans, "test","test");
+		Mockito.doReturn(Result.err(Result.ERR_NotFound, "Not Found")).when(permDAO).readByType(trans, "test","test");
+
 		NsDAO.Data data = new NsDAO.Data();
 		data.name="test";
-		Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,0,"test",new String[0]);
+		Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,0,"test",NO_PARAM);
 		Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
 
-		CachedNSDAO nsDaoObj = Mockito.mock(CachedNSDAO.class);
-		Result<Void> retVal = new Result<Void>(null,1,"test",new String[0]);
-		Mockito.doReturn(retVal).when(nsDaoObj).read(Mockito.any(), Mockito.anyString());		
-		setQuestion(ques, nsDaoObj);
+		Result<Void> retVal = new Result<Void>(null,1,"test",NO_PARAM);
+		Mockito.doReturn(retVal).when(nsDAO).read(Mockito.any(), Mockito.anyString());		
+		//setQuestion(ques, cachedNS);
 		
 		Function funcObj = new Function(trans, ques);
 		Result<Void>  result = funcObj.createNS(trans, namespace, true);
@@ -133,16 +164,6 @@ public class JU_Function {
 	
 	@Test
 	public void testCreateNsReadSuccess() {
-		Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
-		Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).debug();
-		Mockito.doReturn(Mockito.mock(Properties.class)).when(access).getProperties();
-		Mockito.doReturn("test.test").when(access).getProperty(Config.AAF_ROOT_NS,"org.osaaf.aaf");
-		try {
-			Define.set(access);
-		} catch (CadiException e) {
-			// TODO Auto-generated catch block
-			e.printStackTrace();
-		}
 		Namespace namespace = Mockito.mock(Namespace.class);
 		namespace.name = "test.test";
 		List<String> owner = new ArrayList<String>();
@@ -157,13 +178,11 @@ public class JU_Function {
 		
 		NsDAO.Data data = new NsDAO.Data();
 		data.name="test";
-		Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,0,"test",new String[0]);
+		Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,0,"test",NO_PARAM);
 		Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
 
-		CachedNSDAO nsDaoObj = Mockito.mock(CachedNSDAO.class);
-		Result<Void> retVal = new Result<Void>(null,1,"test",new String[0]);
-		Mockito.doReturn(retVal).when(nsDaoObj).read(Mockito.any(), Mockito.anyString());		
-		setQuestion(ques, nsDaoObj);
+		Result<Void> retVal = new Result<Void>(null,1,"test",NO_PARAM);
+		Mockito.doReturn(retVal).when(nsDAO).read(Mockito.any(), Mockito.anyString());		
 		
 		Function funcObj = new Function(trans, ques);
 		Result<Void>  result = funcObj.createNS(trans, namespace, true);
@@ -172,16 +191,6 @@ public class JU_Function {
 	
 	@Test
 	public void testCreateNsFromApprovaFalse() {
-		Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
-		Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).debug();
-		Mockito.doReturn(Mockito.mock(Properties.class)).when(access).getProperties();
-		Mockito.doReturn("test.test").when(access).getProperty(Config.AAF_ROOT_NS,"org.osaaf.aaf");
-		try {
-			Define.set(access);
-		} catch (CadiException e) {
-			// TODO Auto-generated catch block
-			e.printStackTrace();
-		}
 		Namespace namespace = Mockito.mock(Namespace.class);
 		namespace.name = "test.test";
 		List<String> owner = new ArrayList<String>();
@@ -192,9 +201,9 @@ public class JU_Function {
 		
 		NsDAO.Data data = new NsDAO.Data();
 		data.name="test";
-		Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,0,"test",new String[0]);
+		Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,0,"test",NO_PARAM);
 		Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
-		Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(data,1,"test",new String[0]);
+		Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(data,1,"test",NO_PARAM);
 		Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,retVal1.value, Access.write);
 		
 		Function funcObj = new Function(trans, ques);
@@ -209,16 +218,6 @@ public class JU_Function {
 	
 	@Test
 	public void testCreateNsownerLoop() {
-		Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
-		Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).debug();
-		Mockito.doReturn(Mockito.mock(Properties.class)).when(access).getProperties();
-		Mockito.doReturn("test.test").when(access).getProperty(Config.AAF_ROOT_NS,"org.osaaf.aaf");
-		try {
-			Define.set(access);
-		} catch (CadiException e) {
-			// TODO Auto-generated catch block
-			e.printStackTrace();
-		}
 		Namespace namespace = Mockito.mock(Namespace.class);
 		namespace.name = "test.test";
 		List<String> owner = new ArrayList<String>();
@@ -265,16 +264,6 @@ public class JU_Function {
 	
 	@Test
 	public void testCreateNsownerLoopException() {
-		Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
-		Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).debug();
-		Mockito.doReturn(Mockito.mock(Properties.class)).when(access).getProperties();
-		Mockito.doReturn("test.test").when(access).getProperty(Config.AAF_ROOT_NS,"org.osaaf.aaf");
-		try {
-			Define.set(access);
-		} catch (CadiException e) {
-			// TODO Auto-generated catch block
-			e.printStackTrace();
-		}
 		Namespace namespace = Mockito.mock(Namespace.class);
 		namespace.name = "test";
 		List<String> owner = new ArrayList<String>();
@@ -297,7 +286,7 @@ public class JU_Function {
 		
 		NsDAO.Data data = new NsDAO.Data();
 		data.name="test";
-		Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,1,"test",new String[0]);
+		Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,1,"test",NO_PARAM);
 		Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
 		
 		Result<Void> result = funcObj.createNS(trans, namespace, true);
@@ -305,195 +294,19 @@ public class JU_Function {
 		assertTrue(result.details.contains("may not create Root Namespaces"));
 		
 		Mockito.doReturn(true).when(ques).isGranted(Mockito.any(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString());
-		retVal1 = new Result<NsDAO.Data>(data,0,"test",new String[0]);
+		retVal1 = new Result<NsDAO.Data>(data,0,"test",NO_PARAM);
 		Mockito.doReturn(retVal1).when(ques).deriveNs(trans, null);
 		
-		CachedNSDAO nsDaoObj = Mockito.mock(CachedNSDAO.class);
-		Result<Void> retVal = new Result<Void>(null,1,"test",new String[0]);
-		Mockito.doReturn(retVal).when(nsDaoObj).read(Mockito.any(), Mockito.anyString());		
-		setQuestion(ques, nsDaoObj);
+		Result<Void> retVal = new Result<Void>(null,1,"test",NO_PARAM);
+		Mockito.doReturn(retVal).when(nsDAO).read(Mockito.any(), Mockito.anyString());		
 		
 		result = funcObj.createNS(trans, namespace, true);
 		assertTrue(24 == result.status);
 		
 	}
-	
-	public void setQuestion(Question ques, CachedNSDAO userRoleDaoObj) {
-		Field nsDaoField;
-		try {
-			nsDaoField = Question.class.getDeclaredField("nsDAO");
-			
-			nsDaoField.setAccessible(true);
-	        // remove final modifier from field
-	        Field modifiersField = Field.class.getDeclaredField("modifiers");
-	        modifiersField.setAccessible(true);
-	        modifiersField.setInt(nsDaoField, nsDaoField.getModifiers() & ~Modifier.FINAL);
-	        
-	        nsDaoField.set(ques, userRoleDaoObj);
-		} catch (NoSuchFieldException | SecurityException e) {
-			// TODO Auto-generated catch block
-			e.printStackTrace();
-		} catch (IllegalArgumentException e) {
-			// TODO Auto-generated catch block
-			e.printStackTrace();
-		} catch (IllegalAccessException e) {
-			// TODO Auto-generated catch block
-			e.printStackTrace();
-		}
-	}
-	
-	public void setQuestionCredDao(Question ques, CachedCredDAO credDaoObj) {
-		Field nsDaoField;
-		try {
-			nsDaoField = Question.class.getDeclaredField("credDAO");
-			
-			nsDaoField.setAccessible(true);
-	        // remove final modifier from field
-	        Field modifiersField = Field.class.getDeclaredField("modifiers");
-	        modifiersField.setAccessible(true);
-	        modifiersField.setInt(nsDaoField, nsDaoField.getModifiers() & ~Modifier.FINAL);
-	        
-	        nsDaoField.set(ques, credDaoObj);
-		} catch (NoSuchFieldException | SecurityException e) {
-			// TODO Auto-generated catch block
-			e.printStackTrace();
-		} catch (IllegalArgumentException e) {
-			// TODO Auto-generated catch block
-			e.printStackTrace();
-		} catch (IllegalAccessException e) {
-			// TODO Auto-generated catch block
-			e.printStackTrace();
-		}
-	}
-	
-	public void setQuestionUserRoleDao(Question ques, CachedUserRoleDAO credDaoObj) {
-		Field nsDaoField;
-		try {
-			nsDaoField = Question.class.getDeclaredField("userRoleDAO");
-			
-			nsDaoField.setAccessible(true);
-	        // remove final modifier from field
-	        Field modifiersField = Field.class.getDeclaredField("modifiers");
-	        modifiersField.setAccessible(true);
-	        modifiersField.setInt(nsDaoField, nsDaoField.getModifiers() & ~Modifier.FINAL);
-	        
-	        nsDaoField.set(ques, credDaoObj);
-		} catch (NoSuchFieldException | SecurityException e) {
-			// TODO Auto-generated catch block
-			e.printStackTrace();
-		} catch (IllegalArgumentException e) {
-			// TODO Auto-generated catch block
-			e.printStackTrace();
-		} catch (IllegalAccessException e) {
-			// TODO Auto-generated catch block
-			e.printStackTrace();
-		}
-	}
-	public void setQuestionCachedRoleDao(Question ques, CachedRoleDAO credDaoObj) {
-		Field nsDaoField;
-		try {
-			nsDaoField = Question.class.getDeclaredField("roleDAO");
-			
-			nsDaoField.setAccessible(true);
-	        // remove final modifier from field
-	        Field modifiersField = Field.class.getDeclaredField("modifiers");
-	        modifiersField.setAccessible(true);
-	        modifiersField.setInt(nsDaoField, nsDaoField.getModifiers() & ~Modifier.FINAL);
-	        
-	        nsDaoField.set(ques, credDaoObj);
-		} catch (NoSuchFieldException | SecurityException e) {
-			// TODO Auto-generated catch block
-			e.printStackTrace();
-		} catch (IllegalArgumentException e) {
-			// TODO Auto-generated catch block
-			e.printStackTrace();
-		} catch (IllegalAccessException e) {
-			// TODO Auto-generated catch block
-			e.printStackTrace();
-		}
-	}
-	
-	public void setQuestionCachedPermDao(Question ques, CachedPermDAO credDaoObj) {
-		Field nsDaoField;
-		try {
-			nsDaoField = Question.class.getDeclaredField("permDAO");
-			
-			nsDaoField.setAccessible(true);
-	        // remove final modifier from field
-	        Field modifiersField = Field.class.getDeclaredField("modifiers");
-	        modifiersField.setAccessible(true);
-	        modifiersField.setInt(nsDaoField, nsDaoField.getModifiers() & ~Modifier.FINAL);
-	        
-	        nsDaoField.set(ques, credDaoObj);
-		} catch (NoSuchFieldException | SecurityException e) {
-			// TODO Auto-generated catch block
-			e.printStackTrace();
-		} catch (IllegalArgumentException e) {
-			// TODO Auto-generated catch block
-			e.printStackTrace();
-		} catch (IllegalAccessException e) {
-			// TODO Auto-generated catch block
-			e.printStackTrace();
-		}
-	}
-	public void setQuestionFutureDao(Question ques, FutureDAO futureDaoObj) {
-		Field nsDaoField;
-		try {
-			nsDaoField = Question.class.getDeclaredField("futureDAO");
-			
-			nsDaoField.setAccessible(true);
-	        // remove final modifier from field
-	        Field modifiersField = Field.class.getDeclaredField("modifiers");
-	        modifiersField.setAccessible(true);
-	        modifiersField.setInt(nsDaoField, nsDaoField.getModifiers() & ~Modifier.FINAL);
-	        
-	        nsDaoField.set(ques, futureDaoObj);
-		} catch (NoSuchFieldException | SecurityException e) {
-			// TODO Auto-generated catch block
-			e.printStackTrace();
-		} catch (IllegalArgumentException e) {
-			// TODO Auto-generated catch block
-			e.printStackTrace();
-		} catch (IllegalAccessException e) {
-			// TODO Auto-generated catch block
-			e.printStackTrace();
-		}
-	}
-	public void setQuestionApprovalDao(Question ques, ApprovalDAO approvalDaoObj) {
-		Field nsDaoField;
-		try {
-			nsDaoField = Question.class.getDeclaredField("approvalDAO");
-			
-			nsDaoField.setAccessible(true);
-	        // remove final modifier from field
-	        Field modifiersField = Field.class.getDeclaredField("modifiers");
-	        modifiersField.setAccessible(true);
-	        modifiersField.setInt(nsDaoField, nsDaoField.getModifiers() & ~Modifier.FINAL);
-	        
-	        nsDaoField.set(ques, approvalDaoObj);
-		} catch (NoSuchFieldException | SecurityException e) {
-			// TODO Auto-generated catch block
-			e.printStackTrace();
-		} catch (IllegalArgumentException e) {
-			// TODO Auto-generated catch block
-			e.printStackTrace();
-		} catch (IllegalAccessException e) {
-			// TODO Auto-generated catch block
-			e.printStackTrace();
-		}
-	}
+
 	@Test
 	public void testCreateNsAdminLoop() {
-		Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
-		Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).debug();
-		Mockito.doReturn(Mockito.mock(Properties.class)).when(access).getProperties();
-		Mockito.doReturn("test.test").when(access).getProperty(Config.AAF_ROOT_NS,"org.osaaf.aaf");
-		try {
-			Define.set(access);
-		} catch (CadiException e) {
-			// TODO Auto-generated catch block
-			e.printStackTrace();
-		}
 		Namespace namespace = Mockito.mock(Namespace.class);
 		namespace.name = "test.test";
 		List<String> owner = new ArrayList<String>();
@@ -506,14 +319,12 @@ public class JU_Function {
 		
 		NsDAO.Data data = new NsDAO.Data();
 		data.name="test";
-		Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,0,"test",new String[0]);
+		Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,0,"test",NO_PARAM);
 		Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
 		
-		CachedNSDAO nsDaoObj = Mockito.mock(CachedNSDAO.class);
-		CachedCredDAO credDAO = Mockito.mock(CachedCredDAO.class);
-		Result<Void> retVal = new Result<Void>(null,1,"test",new String[0]);
-		Mockito.doReturn(retVal).when(nsDaoObj).read(Mockito.any(), Mockito.anyString());
-		Mockito.doReturn(retVal).when(nsDaoObj).create(Mockito.any(), Mockito.any());
+		Result<Void> retVal = new Result<Void>(null,1,"test",NO_PARAM);
+		Mockito.doReturn(retVal).when(nsDAO).read(Mockito.any(), Mockito.anyString());
+		Mockito.doReturn(retVal).when(nsDAO).create(Mockito.any(), Mockito.any());
 		List<CredDAO.Data> dataObj = new ArrayList<>();
 		CredDAO.Data indData = new CredDAO.Data();
 		indData.id = "test";
@@ -526,10 +337,8 @@ public class JU_Function {
 			e1.printStackTrace();
 		}
 		dataObj.add(indData);
-		Result<List<CredDAO.Data>> retVal2 = new Result<List<CredDAO.Data>>(dataObj,0,"test",new String[0]);
+		Result<List<CredDAO.Data>> retVal2 = new Result<List<CredDAO.Data>>(dataObj,0,"test",NO_PARAM);
 		Mockito.doReturn(retVal2).when(credDAO).readID(Mockito.any(), Mockito.anyString());		
-		setQuestion(ques, nsDaoObj);
-		setQuestionCredDao(ques, credDAO);
 		
 		Identity iden=Mockito.mock(Identity.class);
 		try {
@@ -541,6 +350,9 @@ public class JU_Function {
 			e.printStackTrace();
 		}
 		
+		Mockito.doReturn(Result.err(Result.ERR_NotFound, "Not Found")).when(roleDAO).read(trans, "test","test");
+		Mockito.doReturn(Result.err(Result.ERR_NotFound, "Not Found")).when(permDAO).readByType(trans, "test","test");
+
 		Function funcObj = new Function(trans, ques);
 		Result<Void>  result = funcObj.createNS(trans, namespace, true);
 		assertTrue(result.status == 1);
@@ -571,17 +383,12 @@ public class JU_Function {
 		
 		NsDAO.Data data = new NsDAO.Data();
 		data.name="test";
-		Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,0,"test",new String[0]);
+		Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,0,"test",NO_PARAM);
 		Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
 		
-		CachedNSDAO nsDaoObj = Mockito.mock(CachedNSDAO.class);
-		CachedCredDAO credDAO = Mockito.mock(CachedCredDAO.class);
-		CachedUserRoleDAO userRoleDAO = Mockito.mock(CachedUserRoleDAO.class);
-		CachedRoleDAO cachedRoleDAO = Mockito.mock(CachedRoleDAO.class);
-		CachedPermDAO cachedPermDAO = Mockito.mock(CachedPermDAO.class);
-		Result<Void> retVal = new Result<Void>(null,0,"test",new String[0]);
-		Mockito.doReturn(retVal).when(nsDaoObj).read(Mockito.any(), Mockito.anyString());
-		Mockito.doReturn(retVal).when(nsDaoObj).create(Mockito.any(), Mockito.any());
+		Result<Void> retVal = new Result<Void>(null,0,"test",NO_PARAM);
+		Mockito.doReturn(retVal).when(nsDAO).read(Mockito.any(), Mockito.anyString());
+		Mockito.doReturn(retVal).when(nsDAO).create(Mockito.any(), Mockito.any());
 		List<CredDAO.Data> dataObj = new ArrayList<>();
 		CredDAO.Data indData = new CredDAO.Data();
 		indData.id = "test";
@@ -615,25 +422,20 @@ public class JU_Function {
 		indData5.type = "test";
 		dataObj5.add(indData5);
 		
-		Result<List<CredDAO.Data>> retVal2 = new Result<List<CredDAO.Data>>(dataObj,0,"test",new String[0]);
-		Result<List<CredDAO.Data>> retVal6 = new Result<List<CredDAO.Data>>(dataObj,1,"test",new String[0]);
-		Result<List<RoleDAO.Data>> retVal3 = new Result<List<RoleDAO.Data>>(dataObj1,0,"test",new String[0]);
-		Result<List<UserRoleDAO.Data>> retVal4 = new Result<List<UserRoleDAO.Data>>(dataObj4,0,"test",new String[0]);
-		Result<List<PermDAO.Data>> retVal5 = new Result<List<PermDAO.Data>>(dataObj5,0,"test",new String[0]);
+		Result<List<CredDAO.Data>> retVal2 = new Result<List<CredDAO.Data>>(dataObj,0,"test",NO_PARAM);
+		Result<List<CredDAO.Data>> retVal6 = new Result<List<CredDAO.Data>>(dataObj,1,"test",NO_PARAM);
+		Result<List<RoleDAO.Data>> retVal3 = new Result<List<RoleDAO.Data>>(dataObj1,0,"test",NO_PARAM);
+		Result<List<UserRoleDAO.Data>> retVal4 = new Result<List<UserRoleDAO.Data>>(dataObj4,0,"test",NO_PARAM);
+		Result<List<PermDAO.Data>> retVal5 = new Result<List<PermDAO.Data>>(dataObj5,0,"test",NO_PARAM);
 		Mockito.doReturn(retVal2).when(credDAO).readID(Mockito.any(), Mockito.anyString());		
 		Mockito.doReturn(retVal4).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());	
 		Mockito.doReturn(retVal2).when(userRoleDAO).create(Mockito.any(), Mockito.any());	
-		Mockito.doReturn(retVal6).when(cachedRoleDAO).create(Mockito.any(), Mockito.any());	
-		Mockito.doReturn(retVal6).when(cachedRoleDAO).delete(Mockito.any(), Mockito.any(), Mockito.anyBoolean());	
-		Mockito.doReturn(retVal2).when(cachedPermDAO).create(Mockito.any(), Mockito.any());	
-		Mockito.doReturn(retVal5).when(cachedPermDAO).readChildren(trans, "test", "test");	
-		Mockito.doReturn(retVal5).when(cachedPermDAO).delete(Mockito.any(), Mockito.any(), Mockito.anyBoolean());	
-		Mockito.doReturn(retVal3).when(cachedRoleDAO).readChildren(trans, "test", "test");	
-		setQuestion(ques, nsDaoObj);
-		setQuestionCredDao(ques, credDAO);
-		setQuestionUserRoleDao(ques, userRoleDAO);
-		setQuestionCachedRoleDao(ques, cachedRoleDAO);
-		setQuestionCachedPermDao(ques, cachedPermDAO);
+		Mockito.doReturn(retVal6).when(roleDAO).create(Mockito.any(), Mockito.any());	
+		Mockito.doReturn(retVal6).when(roleDAO).delete(Mockito.any(), Mockito.any(), Mockito.anyBoolean());	
+		Mockito.doReturn(retVal2).when(permDAO).create(Mockito.any(), Mockito.any());	
+		Mockito.doReturn(retVal5).when(permDAO).readChildren(trans, "test", "test");	
+		Mockito.doReturn(retVal5).when(permDAO).delete(Mockito.any(), Mockito.any(), Mockito.anyBoolean());	
+		Mockito.doReturn(retVal3).when(roleDAO).readChildren(trans, "test", "test");	
 		
 		Identity iden=Mockito.mock(Identity.class);
 		try {
@@ -647,6 +449,9 @@ public class JU_Function {
 		}
 		
 		Function funcObj = new Function(trans, ques);
+		Mockito.doReturn(Result.err(Result.ERR_NotFound, "Not Found")).when(roleDAO).read(trans, "test","test");
+		Mockito.doReturn(Result.err(Result.ERR_NotFound, "Not Found")).when(permDAO).readByType(trans, "test","test");
+
 		Result<Void>  result = funcObj.createNS(trans, namespace, true);
 		assertTrue(result.status == Status.ERR_ActionNotCompleted);
 		
@@ -654,16 +459,6 @@ public class JU_Function {
 	
 	@Test
 	public void testCreateNsAdminLoopCreateSuc() {
-		Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
-		Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).debug();
-		Mockito.doReturn(Mockito.mock(Properties.class)).when(access).getProperties();
-		Mockito.doReturn("test.test").when(access).getProperty(Config.AAF_ROOT_NS,"org.osaaf.aaf");
-		try {
-			Define.set(access);
-		} catch (CadiException e) {
-			// TODO Auto-generated catch block
-			e.printStackTrace();
-		}
 		Namespace namespace = Mockito.mock(Namespace.class);
 		namespace.name = "test.test";
 		List<String> owner = new ArrayList<String>();
@@ -676,17 +471,12 @@ public class JU_Function {
 		
 		NsDAO.Data data = new NsDAO.Data();
 		data.name="test";
-		Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,0,"test",new String[0]);
+		Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,0,"test",NO_PARAM);
 		Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
 		
-		CachedNSDAO nsDaoObj = Mockito.mock(CachedNSDAO.class);
-		CachedCredDAO credDAO = Mockito.mock(CachedCredDAO.class);
-		CachedUserRoleDAO userRoleDAO = Mockito.mock(CachedUserRoleDAO.class);
-		CachedRoleDAO cachedRoleDAO = Mockito.mock(CachedRoleDAO.class);
-		CachedPermDAO cachedPermDAO = Mockito.mock(CachedPermDAO.class);
-		Result<Void> retVal = new Result<Void>(null,0,"test",new String[0]);
-		Mockito.doReturn(retVal).when(nsDaoObj).read(Mockito.any(), Mockito.anyString());
-		Mockito.doReturn(retVal).when(nsDaoObj).create(Mockito.any(), Mockito.any());
+		Result<Void> retVal = new Result<Void>(null,0,"test",NO_PARAM);
+		Mockito.doReturn(retVal).when(nsDAO).read(Mockito.any(), Mockito.anyString());
+		Mockito.doReturn(retVal).when(nsDAO).create(Mockito.any(), Mockito.any());
 		List<CredDAO.Data> dataObj = new ArrayList<>();
 		CredDAO.Data indData = new CredDAO.Data();
 		indData.id = "test";
@@ -723,24 +513,19 @@ public class JU_Function {
 		indData5.roles = rolesSet;
 		dataObj5.add(indData5);
 		
-		Result<List<CredDAO.Data>> retVal2 = new Result<List<CredDAO.Data>>(dataObj,0,"test",new String[0]);
-		Result<List<RoleDAO.Data>> retVal3 = new Result<List<RoleDAO.Data>>(dataObj1,0,"test",new String[0]);
-		Result<List<UserRoleDAO.Data>> retVal4 = new Result<List<UserRoleDAO.Data>>(dataObj4,0,"test",new String[0]);
-		Result<List<PermDAO.Data>> retVal5 = new Result<List<PermDAO.Data>>(dataObj5,0,"test",new String[0]);
+		Result<List<CredDAO.Data>> retVal2 = new Result<List<CredDAO.Data>>(dataObj,0,"test",NO_PARAM);
+		Result<List<RoleDAO.Data>> retVal3 = new Result<List<RoleDAO.Data>>(dataObj1,0,"test",NO_PARAM);
+		Result<List<UserRoleDAO.Data>> retVal4 = new Result<List<UserRoleDAO.Data>>(dataObj4,0,"test",NO_PARAM);
+		Result<List<PermDAO.Data>> retVal5 = new Result<List<PermDAO.Data>>(dataObj5,0,"test",NO_PARAM);
 		Mockito.doReturn(retVal2).when(credDAO).readID(Mockito.any(), Mockito.anyString());		
 		Mockito.doReturn(retVal4).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());	
 		Mockito.doReturn(retVal2).when(userRoleDAO).create(Mockito.any(), Mockito.any());	
-		Mockito.doReturn(retVal2).when(cachedRoleDAO).create(Mockito.any(), Mockito.any());	
-		Mockito.doReturn(retVal2).when(cachedRoleDAO).delete(Mockito.any(), Mockito.any(), Mockito.anyBoolean());	
-		Mockito.doReturn(retVal2).when(cachedPermDAO).create(Mockito.any(), Mockito.any());	
-		Mockito.doReturn(retVal5).when(cachedPermDAO).readChildren(trans, "test", "test");	
-		Mockito.doReturn(retVal5).when(cachedPermDAO).delete(Mockito.any(), Mockito.any(), Mockito.anyBoolean());	
-		Mockito.doReturn(retVal3).when(cachedRoleDAO).readChildren(trans, "test", "test");	
-		setQuestion(ques, nsDaoObj);
-		setQuestionCredDao(ques, credDAO);
-		setQuestionUserRoleDao(ques, userRoleDAO);
-		setQuestionCachedRoleDao(ques, cachedRoleDAO);
-		setQuestionCachedPermDao(ques, cachedPermDAO);
+		Mockito.doReturn(retVal2).when(roleDAO).create(Mockito.any(), Mockito.any());	
+		Mockito.doReturn(retVal2).when(roleDAO).delete(Mockito.any(), Mockito.any(), Mockito.anyBoolean());	
+		Mockito.doReturn(retVal2).when(permDAO).create(Mockito.any(), Mockito.any());	
+		Mockito.doReturn(retVal5).when(permDAO).readChildren(trans, "test", "test");	
+		Mockito.doReturn(retVal5).when(permDAO).delete(Mockito.any(), Mockito.any(), Mockito.anyBoolean());	
+		Mockito.doReturn(retVal3).when(roleDAO).readChildren(trans, "test", "test");	
 		
 		Identity iden=Mockito.mock(Identity.class);
 		try {
@@ -753,6 +538,9 @@ public class JU_Function {
 			e.printStackTrace();
 		}
 		
+		Mockito.doReturn(Result.err(Result.ERR_NotFound, "Not Found")).when(roleDAO).read(trans, "test","test");
+		Mockito.doReturn(Result.err(Result.ERR_NotFound, "Not Found")).when(permDAO).readByType(trans, "test","test");
+
 		Function funcObj = new Function(trans, ques);
 		Result<Void>  result = funcObj.createNS(trans, namespace, true);
 		assertTrue(result.status == 0);
@@ -761,77 +549,43 @@ public class JU_Function {
 	
 	@Test
 	public void test4DeleteNs() {
-		Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
-		Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).debug();
-		Mockito.doReturn(Mockito.mock(Properties.class)).when(access).getProperties();
-		Mockito.doReturn("test.test").when(access).getProperty(Config.AAF_ROOT_NS,"org.osaaf.aaf");
-		try {
-			Define.set(access);
-		} catch (CadiException e) {
-			// TODO Auto-generated catch block
-			e.printStackTrace();
-		}
-		CachedNSDAO nsDaoObj = Mockito.mock(CachedNSDAO.class);
-		Result<Void> retVal = new Result<Void>(null,1,"test",new String[0]);
-		Mockito.doReturn(retVal).when(nsDaoObj).read(Mockito.any(), Mockito.anyString());		
-		setQuestion(ques, nsDaoObj);
+		Result<Void> retVal = new Result<Void>(null,1,"test",NO_PARAM);
+		Mockito.doReturn(retVal).when(nsDAO).read(Mockito.any(), Mockito.anyString());		
 		
 		Function funcObj = new Function(trans, ques);
 		Result<Void> result = funcObj.deleteNS(trans, "test");
 		
 		assertTrue(result.status == Status.ERR_NsNotFound);
 	}
+	
 	@Test
-	public void test4DeleteCanMOveFail() {
-		Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
-		Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).debug();
-		Mockito.doReturn(true).when(trans).requested(REQD_TYPE.move);
-		Mockito.doReturn(Mockito.mock(Properties.class)).when(access).getProperties();
-		Mockito.doReturn("test.test").when(access).getProperty(Config.AAF_ROOT_NS,"org.osaaf.aaf");
-		try {
-			Define.set(access);
-		} catch (CadiException e) {
-			// TODO Auto-generated catch block
-			e.printStackTrace();
-		}
-		CachedNSDAO nsDaoObj = Mockito.mock(CachedNSDAO.class);
+	public void test4DeleteCanMoveFail() {
 		List<NsDAO.Data> dataAl = new ArrayList<NsDAO.Data>();
 		NsDAO.Data dataObj = new NsDAO.Data();
 		dataObj.type=1;
 		dataAl.add(dataObj);
-		Result<List<NsDAO.Data>> retVal = new Result<List<NsDAO.Data>>(dataAl,0,"test",new String[0]);
-		Mockito.doReturn(retVal).when(nsDaoObj).read(Mockito.any(), Mockito.anyString());		
-		setQuestion(ques, nsDaoObj);
+		Result<List<NsDAO.Data>> retVal = new Result<List<NsDAO.Data>>(dataAl,0,"test",NO_PARAM);
+		Mockito.doReturn(retVal).when(nsDAO).read(Mockito.any(), Mockito.anyString());		
 		
 		Mockito.doReturn(false).when(ques).canMove(Mockito.any());
+		Mockito.doReturn(retVal).when(ques).mayUser(trans, null,retVal.value.get(0), Access.write);
 		
 		Function funcObj = new Function(trans, ques);
 		Result<Void> result = funcObj.deleteNS(trans, "test");
-		assertTrue(result.status == Status.ERR_Denied);
+		assertTrue(result.status == Status.ERR_Security);
 		
 	}
+	
 	@Test
 	public void test4DeleteNsReadSuc() {
-		Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
-		Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).debug();
-		Mockito.doReturn(Mockito.mock(Properties.class)).when(access).getProperties();
-		Mockito.doReturn("test.test").when(access).getProperty(Config.AAF_ROOT_NS,"org.osaaf.aaf");
-		try {
-			Define.set(access);
-		} catch (CadiException e) {
-			// TODO Auto-generated catch block
-			e.printStackTrace();
-		}
-		CachedNSDAO nsDaoObj = Mockito.mock(CachedNSDAO.class);
 		List<NsDAO.Data> dataAl = new ArrayList<NsDAO.Data>();
 		NsDAO.Data dataObj = new NsDAO.Data();
 		dataObj.type=1;
 		dataAl.add(dataObj);
-		Result<List<NsDAO.Data>> retVal = new Result<List<NsDAO.Data>>(dataAl,0,"test",new String[0]);
-		Mockito.doReturn(retVal).when(nsDaoObj).read(Mockito.any(), Mockito.anyString());		
-		setQuestion(ques, nsDaoObj);
+		Result<List<NsDAO.Data>> retVal = new Result<List<NsDAO.Data>>(dataAl,0,"test",NO_PARAM);
+		Mockito.doReturn(retVal).when(nsDAO).read(Mockito.any(), Mockito.anyString());		
 		
-		Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(null,1,"test",new String[0]);
+		Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(null,1,"test",NO_PARAM);
 		Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,retVal.value.get(0), Access.write);
 		
 		Function funcObj = new Function(trans, ques);
@@ -839,28 +593,17 @@ public class JU_Function {
 		assertTrue(result.status == 1);
 		
 	}
+	
 	@Test
 	public void test4DeleteNsMayUserSuc() {
-		Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
-		Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).debug();
-		Mockito.doReturn(Mockito.mock(Properties.class)).when(access).getProperties();
-		Mockito.doReturn("test.test").when(access).getProperty(Config.AAF_ROOT_NS,"org.osaaf.aaf");
-		try {
-			Define.set(access);
-		} catch (CadiException e) {
-			// TODO Auto-generated catch block
-			e.printStackTrace();
-		}
-		CachedNSDAO nsDaoObj = Mockito.mock(CachedNSDAO.class);
 		List<NsDAO.Data> dataAl = new ArrayList<NsDAO.Data>();
 		NsDAO.Data dataObj = new NsDAO.Data();
 		dataObj.type=1;
 		dataAl.add(dataObj);
-		Result<List<NsDAO.Data>> retVal = new Result<List<NsDAO.Data>>(dataAl,0,"test",new String[0]);
-		Mockito.doReturn(retVal).when(nsDaoObj).read(Mockito.any(), Mockito.anyString());		
-		setQuestion(ques, nsDaoObj);
+		Result<List<NsDAO.Data>> retVal = new Result<List<NsDAO.Data>>(dataAl,0,"test",NO_PARAM);
+		Mockito.doReturn(retVal).when(nsDAO).read(Mockito.any(), Mockito.anyString());		
 		
-		Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(null,0,"test",new String[0]);
+		Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(null,0,"test",NO_PARAM);
 		Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,retVal.value.get(0), Access.write);
 		
 		Function funcObj = new Function(trans, ques);
@@ -869,26 +612,19 @@ public class JU_Function {
 
 		Mockito.doReturn(true).when(ques).isGranted(Mockito.any(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString());
 
-		CachedCredDAO credDAO = Mockito.mock(CachedCredDAO.class);
 		Mockito.doReturn(retVal2).when(credDAO).readNS(Mockito.any(), Mockito.anyString());		
-		setQuestionCredDao(ques, credDAO);
 
-		CachedPermDAO cachedPermDAO = Mockito.mock(CachedPermDAO.class);
-		Result<List<PermDAO.Data>> retVal5 = new Result<List<PermDAO.Data>>(null,0,"test",new String[0]);
-		Mockito.doReturn(retVal5).when(cachedPermDAO).readNS(trans, "test");
-		setQuestionCachedPermDao(ques, cachedPermDAO);
+		Result<List<PermDAO.Data>> retVal5 = new Result<List<PermDAO.Data>>(null,0,"test",NO_PARAM);
+		Mockito.doReturn(retVal5).when(permDAO).readNS(trans, "test");
 		
-		CachedUserRoleDAO cachedUserRoleDAO = Mockito.mock(CachedUserRoleDAO.class);
 		List<UserRoleDAO.Data> dataObj4 = new ArrayList<>();
 		UserRoleDAO.Data indData4 = new UserRoleDAO.Data();
 		indData4.ns = "test";
 		indData4.rname = "test";
 		dataObj4.add(indData4);
-		Result<List<UserRoleDAO.Data>> retVal4 = new Result<List<UserRoleDAO.Data>>(dataObj4,0,"test",new String[0]);
-		Mockito.doReturn(retVal4).when(cachedUserRoleDAO).readByRole(trans, "test");
-		setQuestionUserRoleDao(ques, cachedUserRoleDAO);
+		Result<List<UserRoleDAO.Data>> retVal4 = new Result<List<UserRoleDAO.Data>>(dataObj4,0,"test",NO_PARAM);
+		Mockito.doReturn(retVal4).when(userRoleDAO).readByRole(trans, "test");
 		
-		CachedRoleDAO cachedRoleDAO = Mockito.mock(CachedRoleDAO.class);
 		List<RoleDAO.Data> dataObj1 = new ArrayList<>();
 		RoleDAO.Data indData1 = new RoleDAO.Data();
 		indData1.ns = "test";
@@ -897,17 +633,14 @@ public class JU_Function {
 		permsSet.add("test|test");
 		indData1.perms = permsSet;
 		dataObj1.add(indData1);
-		Result<List<RoleDAO.Data>> retVal3 = new Result<List<RoleDAO.Data>>(dataObj1,0,"test",new String[0]);
-		Mockito.doReturn(retVal3).when(cachedRoleDAO).readNS(trans, "test");	
-		Mockito.doReturn(retVal3).when(cachedRoleDAO).read(trans, indData1);
-		setQuestionCachedRoleDao(ques, cachedRoleDAO);
+		Result<List<RoleDAO.Data>> retVal3 = new Result<List<RoleDAO.Data>>(dataObj1,0,"test",NO_PARAM);
+		Mockito.doReturn(retVal3).when(roleDAO).readNS(trans, "test");	
+		Mockito.doReturn(retVal3).when(roleDAO).read(trans, indData1);
 		
 		funcObj = new Function(trans, ques);
 		result = funcObj.deleteNS(trans, "test");
 		assertTrue(result.status == Status.ERR_DependencyExists);
 		
-		CachedUserRoleDAO userRoleDAO = Mockito.mock(CachedUserRoleDAO.class);
-		setQuestionUserRoleDao(ques, userRoleDAO);
 		Mockito.doReturn(retVal4).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());	
 		
 		Mockito.doReturn(true).when(trans).requested(REQD_TYPE.force);
@@ -917,26 +650,14 @@ public class JU_Function {
 	}
 	@Test
 	public void test4DeleteNsDrivensFailure() {
-		Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
-		Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).debug();
-		Mockito.doReturn(Mockito.mock(Properties.class)).when(access).getProperties();
-		Mockito.doReturn("test.test").when(access).getProperty(Config.AAF_ROOT_NS,"org.osaaf.aaf");
-		try {
-			Define.set(access);
-		} catch (CadiException e) {
-			// TODO Auto-generated catch block
-			e.printStackTrace();
-		}
-		CachedNSDAO nsDaoObj = Mockito.mock(CachedNSDAO.class);
 		List<NsDAO.Data> dataAl = new ArrayList<NsDAO.Data>();
 		NsDAO.Data dataObj = new NsDAO.Data();
 		dataObj.type=1;
 		dataAl.add(dataObj);
-		Result<List<NsDAO.Data>> retVal = new Result<List<NsDAO.Data>>(dataAl,0,"test",new String[0]);
-		Mockito.doReturn(retVal).when(nsDaoObj).read(Mockito.any(), Mockito.anyString());		
-		setQuestion(ques, nsDaoObj);
+		Result<List<NsDAO.Data>> retVal = new Result<List<NsDAO.Data>>(dataAl,0,"test",NO_PARAM);
+		Mockito.doReturn(retVal).when(nsDAO).read(Mockito.any(), Mockito.anyString());		
 		
-		Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(null,0,"test",new String[0]);
+		Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(null,0,"test",NO_PARAM);
 		Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,retVal.value.get(0), Access.write);
 		
 		Function funcObj = new Function(trans, ques);
@@ -945,24 +666,19 @@ public class JU_Function {
 
 		Mockito.doReturn(true).when(ques).isGranted(Mockito.any(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString());
 
-		CachedCredDAO credDAO = Mockito.mock(CachedCredDAO.class);
 		Mockito.doReturn(retVal2).when(credDAO).readNS(Mockito.any(), Mockito.anyString());		
-		setQuestionCredDao(ques, credDAO);
 
-		CachedPermDAO cachedPermDAO = Mockito.mock(CachedPermDAO.class);
 		List<PermDAO.Data> dataObj5 = new ArrayList<>();
 		PermDAO.Data indData5 = new PermDAO.Data();
 		indData5.ns = "test";
 		indData5.type = "test";
 		dataObj5.add(indData5);
-		Result<List<PermDAO.Data>> retVal5 = new Result<List<PermDAO.Data>>(dataObj5,0,"test",new String[0]);
-		Mockito.doReturn(retVal5).when(cachedPermDAO).readNS(trans, "test");
-		Mockito.doReturn(retVal5).when(cachedPermDAO).readNS(trans, "test.test");
-		Mockito.doReturn(retVal5).when(cachedPermDAO).read(trans, indData5);
-		setQuestionCachedPermDao(ques, cachedPermDAO);
+		Result<List<PermDAO.Data>> retVal5 = new Result<List<PermDAO.Data>>(dataObj5,0,"test",NO_PARAM);
+		Mockito.doReturn(retVal5).when(permDAO).readNS(trans, "test");
+		Mockito.doReturn(retVal5).when(permDAO).readNS(trans, "test.test");
+		Mockito.doReturn(retVal5).when(permDAO).read(trans, indData5);
 		
 		
-		CachedRoleDAO cachedRoleDAO = Mockito.mock(CachedRoleDAO.class);
 		List<RoleDAO.Data> dataObj1 = new ArrayList<>();
 		RoleDAO.Data indData1 = new RoleDAO.Data();
 		indData1.ns = "test";
@@ -971,11 +687,10 @@ public class JU_Function {
 		permsSet.add("test|test");
 		indData1.perms = permsSet;
 		dataObj1.add(indData1);
-		Result<List<RoleDAO.Data>> retVal3 = new Result<List<RoleDAO.Data>>(dataObj1,0,"test",new String[0]);
-		Mockito.doReturn(retVal3).when(cachedRoleDAO).readNS(trans, "test");	
-		Mockito.doReturn(retVal3).when(cachedRoleDAO).readNS(trans, "test.test");	
-		Mockito.doReturn(retVal3).when(cachedRoleDAO).read(trans, indData1);
-		setQuestionCachedRoleDao(ques, cachedRoleDAO);
+		Result<List<RoleDAO.Data>> retVal3 = new Result<List<RoleDAO.Data>>(dataObj1,0,"test",NO_PARAM);
+		Mockito.doReturn(retVal3).when(roleDAO).readNS(trans, "test");	
+		Mockito.doReturn(retVal3).when(roleDAO).readNS(trans, "test.test");	
+		Mockito.doReturn(retVal3).when(roleDAO).read(trans, indData1);
 		
 		funcObj = new Function(trans, ques);
 		result = funcObj.deleteNS(trans, "test");
@@ -983,7 +698,7 @@ public class JU_Function {
 		
 		NsDAO.Data data = new NsDAO.Data();
 		data.name="test";
-		Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,1,"test",new String[0]);
+		Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,1,"test",NO_PARAM);
 		Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
 		
 		Mockito.doReturn(true).when(trans).requested(REQD_TYPE.force);
@@ -991,33 +706,22 @@ public class JU_Function {
 		result = funcObj.deleteNS(trans, "test.test");
 		assertTrue(result.status == 1);
 	}
+
 	@Test
 	public void test4DeleteNsWithDot() {
-		Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
-		Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).debug();
-		Mockito.doReturn(Mockito.mock(Properties.class)).when(access).getProperties();
-		Mockito.doReturn("test.test").when(access).getProperty(Config.AAF_ROOT_NS,"org.osaaf.aaf");
-		try {
-			Define.set(access);
-		} catch (CadiException e) {
-			// TODO Auto-generated catch block
-			e.printStackTrace();
-		}
-		CachedNSDAO nsDaoObj = Mockito.mock(CachedNSDAO.class);
 		List<NsDAO.Data> dataAl = new ArrayList<NsDAO.Data>();
 		NsDAO.Data dataObj = new NsDAO.Data();
 		dataObj.type=1;
 		dataAl.add(dataObj);
-		Result<List<NsDAO.Data>> retVal = new Result<List<NsDAO.Data>>(dataAl,0,"test",new String[0]);
-		Mockito.doReturn(retVal).when(nsDaoObj).read(Mockito.any(), Mockito.anyString());		
-		setQuestion(ques, nsDaoObj);
+		Result<List<NsDAO.Data>> retVal = new Result<List<NsDAO.Data>>(dataAl,0,"test",NO_PARAM);
+		Mockito.doReturn(retVal).when(nsDAO).read(Mockito.any(), Mockito.anyString());		
 		
 		List<CredDAO.Data> nsDataList = new ArrayList<CredDAO.Data>();
 		CredDAO.Data nsData = new CredDAO.Data();
 		nsData.id="test";
 		nsDataList.add(nsData);
-		Result<List<CredDAO.Data>> retVal21 = new Result<List<CredDAO.Data>>(nsDataList,0,"test",new String[0]);
-		Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(null,0,"test",new String[0]);
+		Result<List<CredDAO.Data>> retVal21 = new Result<List<CredDAO.Data>>(nsDataList,0,"test",NO_PARAM);
+		Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(null,0,"test",NO_PARAM);
 		Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,retVal.value.get(0), Access.write);
 		
 		Function funcObj = new Function(trans, ques);
@@ -1026,35 +730,28 @@ public class JU_Function {
 
 		Mockito.doReturn(true).when(ques).isGranted(Mockito.any(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString());
 
-		CachedCredDAO credDAO = Mockito.mock(CachedCredDAO.class);
 		Mockito.doReturn(retVal21).when(credDAO).readNS(Mockito.any(), Mockito.anyString());	
 		Mockito.doReturn(retVal21).when(credDAO).delete(Mockito.any(), Mockito.any(), Mockito.anyBoolean());		
-		setQuestionCredDao(ques, credDAO);
 
-		CachedPermDAO cachedPermDAO = Mockito.mock(CachedPermDAO.class);
 		List<PermDAO.Data> dataObj5 = new ArrayList<>();
 		PermDAO.Data indData5 = new PermDAO.Data();
 		indData5.ns = "test";
 		indData5.type = "test";
 		dataObj5.add(indData5);
-		Result<List<PermDAO.Data>> retVal5 = new Result<List<PermDAO.Data>>(dataObj5,0,"test",new String[0]);
-		Mockito.doReturn(retVal5).when(cachedPermDAO).readNS(trans, "test");
-		Mockito.doReturn(retVal5).when(cachedPermDAO).readNS(trans, "test.test");
-		Mockito.doReturn(retVal5).when(cachedPermDAO).read(trans, indData5);
-		setQuestionCachedPermDao(ques, cachedPermDAO);
+		Result<List<PermDAO.Data>> retVal5 = new Result<List<PermDAO.Data>>(dataObj5,0,"test",new Object[0]);
+		Mockito.doReturn(retVal5).when(permDAO).readNS(trans, "test");
+		Mockito.doReturn(retVal5).when(permDAO).readNS(trans, "test.test");
+		Mockito.doReturn(retVal5).when(permDAO).read(trans, indData5);
 		
-		CachedUserRoleDAO cachedUserRoleDAO = Mockito.mock(CachedUserRoleDAO.class);
 		List<UserRoleDAO.Data> dataObj4 = new ArrayList<>();
 		UserRoleDAO.Data indData4 = new UserRoleDAO.Data();
 		indData4.ns = "test";
 		indData4.rname = "test";
 		dataObj4.add(indData4);
-		Result<List<UserRoleDAO.Data>> retVal4 = new Result<List<UserRoleDAO.Data>>(dataObj4,0,"test",new String[0]);
-		Mockito.doReturn(retVal4).when(cachedUserRoleDAO).readByRole(Mockito.any(), Mockito.anyString());
-		Mockito.doReturn(retVal4).when(cachedUserRoleDAO).readByUser(Mockito.any(), Mockito.anyString());
-		setQuestionUserRoleDao(ques, cachedUserRoleDAO);
+		Result<List<UserRoleDAO.Data>> retVal4 = new Result<List<UserRoleDAO.Data>>(dataObj4,0,"test",NO_PARAM);
+		Mockito.doReturn(retVal4).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());
+		Mockito.doReturn(retVal4).when(userRoleDAO).readByUser(Mockito.any(), Mockito.anyString());
 		
-		CachedRoleDAO cachedRoleDAO = Mockito.mock(CachedRoleDAO.class);
 		List<RoleDAO.Data> dataObj1 = new ArrayList<>();
 		RoleDAO.Data indData1 = new RoleDAO.Data();
 		indData1.ns = "test";
@@ -1063,11 +760,10 @@ public class JU_Function {
 		permsSet.add("test|test");
 		indData1.perms = permsSet;
 		dataObj1.add(indData1);
-		Result<List<RoleDAO.Data>> retVal3 = new Result<List<RoleDAO.Data>>(dataObj1,0,"test",new String[0]);
-		Mockito.doReturn(retVal3).when(cachedRoleDAO).readNS(trans, "test");	
-		Mockito.doReturn(retVal3).when(cachedRoleDAO).readNS(trans, "test.test");	
-		Mockito.doReturn(retVal3).when(cachedRoleDAO).read(trans, indData1);
-		setQuestionCachedRoleDao(ques, cachedRoleDAO);
+		Result<List<RoleDAO.Data>> retVal3 = new Result<List<RoleDAO.Data>>(dataObj1,0,"test",NO_PARAM);
+		Mockito.doReturn(retVal3).when(roleDAO).readNS(trans, "test");	
+		Mockito.doReturn(retVal3).when(roleDAO).readNS(trans, "test.test");	
+		Mockito.doReturn(retVal3).when(roleDAO).read(trans, indData1);
 		
 		funcObj = new Function(trans, ques);
 		result = funcObj.deleteNS(trans, "test");
@@ -1075,7 +771,7 @@ public class JU_Function {
 		
 		NsDAO.Data data = new NsDAO.Data();
 		data.name="test";
-		Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,0,"test",new String[0]);
+		Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,0,"test",NO_PARAM);
 		Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
 		
 		Mockito.doReturn(true).when(trans).requested(REQD_TYPE.force);
@@ -1083,28 +779,17 @@ public class JU_Function {
 		result = funcObj.deleteNS(trans, "test.test");
 		assertNull(result);
 	}
+	
 	@Test
 	public void testGetOwners() {
-		Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
-		Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).debug();
-		Mockito.doReturn(Mockito.mock(Properties.class)).when(access).getProperties();
-		Mockito.doReturn("test.test").when(access).getProperty(Config.AAF_ROOT_NS,"org.osaaf.aaf");
-		try {
-			Define.set(access);
-		} catch (CadiException e) {
-			// TODO Auto-generated catch block
-			e.printStackTrace();
-		}
-		CachedUserRoleDAO userRoleDAO = Mockito.mock(CachedUserRoleDAO.class);
 //		List<NsDAO.Data> dataAl = new ArrayList<NsDAO.Data>();
 //		NsDAO.Data dataObj = new NsDAO.Data();
 //		dataObj.type=1;
 //		dataAl.add(dataObj);
-		Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(null,1,"test",new String[0]);
+		Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(null,1,"test",NO_PARAM);
 		Mockito.doReturn(retVal).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());		
-		setQuestionUserRoleDao(ques, userRoleDAO);
 //		
-//		Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(null,0,"test",new String[0]);
+//		Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(null,0,"test",NO_PARAM);
 //		Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,retVal.value.get(0), Access.write);
 //		
 		Function funcObj = new Function(trans, ques);
@@ -1115,43 +800,31 @@ public class JU_Function {
 	
 	@Test
 	public void testDelOwner() {
-		Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
-		Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).debug();
-		Mockito.doReturn(Mockito.mock(Properties.class)).when(access).getProperties();
-		Mockito.doReturn("test.test").when(access).getProperty(Config.AAF_ROOT_NS,"org.osaaf.aaf");
-		try {
-			Define.set(access);
-		} catch (CadiException e) {
-			// TODO Auto-generated catch block
-			e.printStackTrace();
-		}
-		CachedUserRoleDAO userRoleDAO = Mockito.mock(CachedUserRoleDAO.class);
-		Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(null,1,"test",new String[0]);
+		Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(null,1,"test",NO_PARAM);
 		Mockito.doReturn(retVal).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());	
 		Mockito.doReturn(retVal).when(userRoleDAO).read(Mockito.any(), Mockito.any( UserRoleDAO.Data.class));	
-		setQuestionUserRoleDao(ques, userRoleDAO);
 
 		NsDAO.Data data = new NsDAO.Data();
 		data.name="test";
-		Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,0,"test",new String[0]);
+		Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,0,"test",NO_PARAM);
 		Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
 		
-		Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(data,1,"test",new String[0]);
+		Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(data,1,"test",NO_PARAM);
 		Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,retVal1.value, Access.write);
 		
 		Function funcObj = new Function(trans, ques);
 		Result<Void> result = funcObj.delOwner(trans, "test", "test");
 		assertTrue(result.status == 1);
 		
-		retVal1 = new Result<NsDAO.Data>(data,1,"test",new String[0]);
+		retVal1 = new Result<NsDAO.Data>(data,1,"test",NO_PARAM);
 		Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
 		result = funcObj.delOwner(trans, "test", "test");
 		assertTrue(result.status == 1);
 		
-		retVal1 = new Result<NsDAO.Data>(data,0,"test",new String[0]);
+		retVal1 = new Result<NsDAO.Data>(data,0,"test",NO_PARAM);
 		Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
 		result = funcObj.delOwner(trans, "test", "test");
-		retVal2 = new Result<NsDAO.Data>(data,0,"test",new String[0]);
+		retVal2 = new Result<NsDAO.Data>(data,0,"test",NO_PARAM);
 		Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,retVal1.value, Access.write);
 		result = funcObj.delOwner(trans, "test", "test");
 //		
@@ -1159,26 +832,14 @@ public class JU_Function {
 	
 	@Test
 	public void testGetAdmins() {
-		Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
-		Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).debug();
-		Mockito.doReturn(Mockito.mock(Properties.class)).when(access).getProperties();
-		Mockito.doReturn("test.test").when(access).getProperty(Config.AAF_ROOT_NS,"org.osaaf.aaf");
-		try {
-			Define.set(access);
-		} catch (CadiException e) {
-			// TODO Auto-generated catch block
-			e.printStackTrace();
-		}
-		CachedUserRoleDAO userRoleDAO = Mockito.mock(CachedUserRoleDAO.class);
 //		List<NsDAO.Data> dataAl = new ArrayList<NsDAO.Data>();
 //		NsDAO.Data dataObj = new NsDAO.Data();
 //		dataObj.type=1;
 //		dataAl.add(dataObj);
-		Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(null,1,"test",new String[0]);
+		Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(null,1,"test",NO_PARAM);
 		Mockito.doReturn(retVal).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());		
-		setQuestionUserRoleDao(ques, userRoleDAO);
 //		
-//		Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(null,0,"test",new String[0]);
+//		Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(null,0,"test",NO_PARAM);
 //		Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,retVal.value.get(0), Access.write);
 //		
 		Function funcObj = new Function(trans, ques);
@@ -1189,43 +850,31 @@ public class JU_Function {
 	
 	@Test
 	public void testDelAdmin() {
-		Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
-		Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).debug();
-		Mockito.doReturn(Mockito.mock(Properties.class)).when(access).getProperties();
-		Mockito.doReturn("test.test").when(access).getProperty(Config.AAF_ROOT_NS,"org.osaaf.aaf");
-		try {
-			Define.set(access);
-		} catch (CadiException e) {
-			// TODO Auto-generated catch block
-			e.printStackTrace();
-		}
-		CachedUserRoleDAO userRoleDAO = Mockito.mock(CachedUserRoleDAO.class);
-		Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(null,1,"test",new String[0]);
+		Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(null,1,"test",NO_PARAM);
 		Mockito.doReturn(retVal).when(userRoleDAO).readUserInRole(Mockito.any(), Mockito.anyString(), Mockito.anyString());	
 		Mockito.doReturn(retVal).when(userRoleDAO).read(Mockito.any(), Mockito.any( UserRoleDAO.Data.class));	
-		setQuestionUserRoleDao(ques, userRoleDAO);
 
 		NsDAO.Data data = new NsDAO.Data();
 		data.name="test";
-		Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,0,"test",new String[0]);
+		Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,0,"test",NO_PARAM);
 		Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
 		
-		Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(data,1,"test",new String[0]);
+		Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(data,1,"test",NO_PARAM);
 		Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,retVal1.value, Access.write);
 		
 		Function funcObj = new Function(trans, ques);
 		Result<Void> result = funcObj.delAdmin(trans, "test", "test");
 		assertTrue(result.status == 1);
 		
-		retVal1 = new Result<NsDAO.Data>(data,1,"test",new String[0]);
+		retVal1 = new Result<NsDAO.Data>(data,1,"test",NO_PARAM);
 		Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
 		result = funcObj.delAdmin(trans, "test", "test");
 		assertTrue(result.status == 1);
 		
-		retVal1 = new Result<NsDAO.Data>(data,0,"test",new String[0]);
+		retVal1 = new Result<NsDAO.Data>(data,0,"test",NO_PARAM);
 		Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
 		result = funcObj.delOwner(trans, "test", "test");
-		retVal2 = new Result<NsDAO.Data>(data,0,"test",new String[0]);
+		retVal2 = new Result<NsDAO.Data>(data,0,"test",NO_PARAM);
 		Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,retVal1.value, Access.write);
 		result = funcObj.delAdmin(trans, "test", "test");
 //		
@@ -1233,37 +882,21 @@ public class JU_Function {
 	
 	@Test
 	public void testMovePerms() {
-		Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
-		Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).debug();
-		Mockito.doReturn(Mockito.mock(Properties.class)).when(access).getProperties();
-		Mockito.doReturn("test.test").when(access).getProperty(Config.AAF_ROOT_NS,"org.osaaf.aaf");
-		try {
-			Define.set(access);
-		} catch (CadiException e) {
-			// TODO Auto-generated catch block
-			e.printStackTrace();
-		}
-		CachedUserRoleDAO userRoleDAO = Mockito.mock(CachedUserRoleDAO.class);
 //		List<NsDAO.Data> dataAl = new ArrayList<NsDAO.Data>();
 //		NsDAO.Data dataObj = new NsDAO.Data();
 //		dataObj.type=1;
 //		dataAl.add(dataObj);
-		Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(null,1,"test",new String[0]);
+		Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(null,1,"test",NO_PARAM);
 		Mockito.doReturn(retVal).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());		
-		setQuestionUserRoleDao(ques, userRoleDAO);
 		
-		CachedRoleDAO cachedRoleDAO = Mockito.mock(CachedRoleDAO.class);
-		Mockito.doReturn(retVal).when(cachedRoleDAO).delPerm(Mockito.any(), Mockito.any(), Mockito.any());	
-		setQuestionCachedRoleDao(ques, cachedRoleDAO);
+		Mockito.doReturn(retVal).when(roleDAO).delPerm(Mockito.any(), Mockito.any(), Mockito.any());	
 		
-		CachedPermDAO cachedPermDAO = Mockito.mock(CachedPermDAO.class);
-		Mockito.doReturn(retVal).when(cachedPermDAO).create(Mockito.any(), Mockito.any());	
-		setQuestionCachedPermDao(ques, cachedPermDAO);
+		Mockito.doReturn(retVal).when(permDAO).create(Mockito.any(), Mockito.any());	
 		
 		NsDAO.Data nsDataObj = new NsDAO.Data();
 		nsDataObj.name="test";
 		StringBuilder sb = new StringBuilder();
-		Result<List<PermDAO.Data>> retVal1 = new Result<List<PermDAO.Data>>(null,1,"test",new String[0]);
+		Result<List<PermDAO.Data>> retVal1 = new Result<List<PermDAO.Data>>(null,1,"test",NO_PARAM);
 		
 		invokeMovePerms(nsDataObj, sb, retVal1);
 		
@@ -1279,24 +912,24 @@ public class JU_Function {
 		indData5.ns = "test";
 		indData5.type = "access";
 		dataObj5.add(indData5);
-		retVal1 = new Result<List<PermDAO.Data>>(dataObj5,0,"test",new String[0]);
+		retVal1 = new Result<List<PermDAO.Data>>(dataObj5,0,"test",NO_PARAM);
 
-		Result<List<UserRoleDAO.Data>> retVal3 = new Result<List<UserRoleDAO.Data>>(null,0,"test",new String[0]);
-		Mockito.doReturn(retVal3).when(cachedPermDAO).create(Mockito.any(), Mockito.any());	
-		Mockito.doReturn(retVal3).when(cachedPermDAO).delete(Mockito.any(), Mockito.any(), Mockito.anyBoolean());	
+		Result<List<UserRoleDAO.Data>> retVal3 = new Result<List<UserRoleDAO.Data>>(null,0,"test",NO_PARAM);
+		Mockito.doReturn(retVal3).when(permDAO).create(Mockito.any(), Mockito.any());	
+		Mockito.doReturn(retVal3).when(permDAO).delete(Mockito.any(), Mockito.any(), Mockito.anyBoolean());	
 
 		NsSplit splitObj = new NsSplit("test", "test");
-		Result<NsSplit> retVal2 = new Result<NsSplit>(splitObj,0,"test",new String[0]);
+		Result<NsSplit> retVal2 = new Result<NsSplit>(splitObj,0,"test",NO_PARAM);
 		Mockito.doReturn(retVal2).when(ques).deriveNsSplit(Mockito.any(), Mockito.anyString());
 		
 		invokeMovePerms(nsDataObj, sb, retVal1);
 		
-		Result<List<UserRoleDAO.Data>> retVal4 = new Result<List<UserRoleDAO.Data>>(null,1,"test",new String[0]);
-		Mockito.doReturn(retVal4).when(cachedPermDAO).create(Mockito.any(), Mockito.any());	
+		Result<List<UserRoleDAO.Data>> retVal4 = new Result<List<UserRoleDAO.Data>>(null,1,"test",NO_PARAM);
+		Mockito.doReturn(retVal4).when(permDAO).create(Mockito.any(), Mockito.any());	
 		invokeMovePerms(nsDataObj, sb, retVal1);
 		
-		Mockito.doReturn(retVal3).when(cachedPermDAO).create(Mockito.any(), Mockito.any());	
-		Mockito.doReturn(retVal4).when(cachedPermDAO).delete(Mockito.any(), Mockito.any(), Mockito.anyBoolean());	
+		Mockito.doReturn(retVal3).when(permDAO).create(Mockito.any(), Mockito.any());	
+		Mockito.doReturn(retVal4).when(permDAO).delete(Mockito.any(), Mockito.any(), Mockito.anyBoolean());	
 		invokeMovePerms(nsDataObj, sb, retVal1);
 		
 	}
@@ -1325,35 +958,21 @@ public class JU_Function {
 	
 	@Test
 	public void testMoveRoles() {
-		Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
-		Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).debug();
-		Mockito.doReturn(Mockito.mock(Properties.class)).when(access).getProperties();
-		Mockito.doReturn("test.test").when(access).getProperty(Config.AAF_ROOT_NS,"org.osaaf.aaf");
-		try {
-			Define.set(access);
-		} catch (CadiException e) {
-			// TODO Auto-generated catch block
-			e.printStackTrace();
-		}
-		CachedUserRoleDAO userRoleDAO = Mockito.mock(CachedUserRoleDAO.class);
 //		List<NsDAO.Data> dataAl = new ArrayList<NsDAO.Data>();
 //		NsDAO.Data dataObj = new NsDAO.Data();
 //		dataObj.type=1;
 //		dataAl.add(dataObj);
-		Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(null,1,"test",new String[0]);
+		Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(null,1,"test",NO_PARAM);
 		Mockito.doReturn(retVal).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());		
-		setQuestionUserRoleDao(ques, userRoleDAO);
 		
-		CachedRoleDAO cachedRoleDAO = Mockito.mock(CachedRoleDAO.class);
-		Mockito.doReturn(retVal).when(cachedRoleDAO).delPerm(Mockito.any(), Mockito.any(), Mockito.any());	
-		setQuestionCachedRoleDao(ques, cachedRoleDAO);
+		Mockito.doReturn(retVal).when(roleDAO).delPerm(Mockito.any(), Mockito.any(), Mockito.any());	
 		
-		Mockito.doReturn(retVal).when(cachedRoleDAO).create(Mockito.any(), Mockito.any());	
+		Mockito.doReturn(retVal).when(roleDAO).create(Mockito.any(), Mockito.any());	
 		
 		NsDAO.Data nsDataObj = new NsDAO.Data();
 		nsDataObj.name="test";
 		StringBuilder sb = new StringBuilder();
-		Result<List<RoleDAO.Data>> retVal1 = new Result<List<RoleDAO.Data>>(null,1,"test",new String[0]);
+		Result<List<RoleDAO.Data>> retVal1 = new Result<List<RoleDAO.Data>>(null,1,"test",NO_PARAM);
 		
 		invokeMoveRoles(nsDataObj, sb, retVal1);
 		
@@ -1369,24 +988,24 @@ public class JU_Function {
 		indData5.ns = "test";
 		indData5.name = "admin";
 		dataObj5.add(indData5);
-		retVal1 = new Result<List<RoleDAO.Data>>(dataObj5,0,"test",new String[0]);
+		retVal1 = new Result<List<RoleDAO.Data>>(dataObj5,0,"test",NO_PARAM);
 		
-		Result<List<UserRoleDAO.Data>> retVal3 = new Result<List<UserRoleDAO.Data>>(null,0,"test",new String[0]);
-		Mockito.doReturn(retVal3).when(cachedRoleDAO).create(Mockito.any(), Mockito.any());	
-		Mockito.doReturn(retVal3).when(cachedRoleDAO).delete(Mockito.any(), Mockito.any(), Mockito.anyBoolean());	
+		Result<List<UserRoleDAO.Data>> retVal3 = new Result<List<UserRoleDAO.Data>>(null,0,"test",NO_PARAM);
+		Mockito.doReturn(retVal3).when(roleDAO).create(Mockito.any(), Mockito.any());	
+		Mockito.doReturn(retVal3).when(roleDAO).delete(Mockito.any(), Mockito.any(), Mockito.anyBoolean());	
 
 		NsSplit splitObj = new NsSplit("test", "test");
-		Result<NsSplit> retVal2 = new Result<NsSplit>(splitObj,0,"test",new String[0]);
+		Result<NsSplit> retVal2 = new Result<NsSplit>(splitObj,0,"test",NO_PARAM);
 		Mockito.doReturn(retVal2).when(ques).deriveNsSplit(Mockito.any(), Mockito.anyString());
 		
 		invokeMoveRoles(nsDataObj, sb, retVal1);
 		
-		Result<List<UserRoleDAO.Data>> retVal4 = new Result<List<UserRoleDAO.Data>>(null,1,"test",new String[0]);
-		Mockito.doReturn(retVal4).when(cachedRoleDAO).create(Mockito.any(), Mockito.any());	
+		Result<List<UserRoleDAO.Data>> retVal4 = new Result<List<UserRoleDAO.Data>>(null,1,"test",NO_PARAM);
+		Mockito.doReturn(retVal4).when(roleDAO).create(Mockito.any(), Mockito.any());	
 		invokeMoveRoles(nsDataObj, sb, retVal1);
 		
-		Mockito.doReturn(retVal3).when(cachedRoleDAO).create(Mockito.any(), Mockito.any());	
-		Mockito.doReturn(retVal4).when(cachedRoleDAO).delete(Mockito.any(), Mockito.any(), Mockito.anyBoolean());	
+		Mockito.doReturn(retVal3).when(roleDAO).create(Mockito.any(), Mockito.any());	
+		Mockito.doReturn(retVal4).when(roleDAO).delete(Mockito.any(), Mockito.any(), Mockito.anyBoolean());	
 		invokeMoveRoles(nsDataObj, sb, retVal1);
 		
 	}
@@ -1415,11 +1034,6 @@ public class JU_Function {
 	
 	@Test
 	public void testCreatePerm() {
-		Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
-		Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).debug();
-		Mockito.doReturn(true).when(trans).requested(REQD_TYPE.force);
-		Mockito.doReturn(Mockito.mock(Properties.class)).when(access).getProperties();
-		Mockito.doReturn("test.test").when(access).getProperty(Config.AAF_ROOT_NS,"org.osaaf.aaf");
 		try {
 			Define.set(access);
 		} catch (CadiException e) {
@@ -1433,58 +1047,54 @@ public class JU_Function {
 		perm.roles = rolesSet;
 //		perm.type=1
 		dataAl.add(perm);
-		Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(null,1,"test",new String[0]);
+		Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(null,1,"test",NO_PARAM);
 		Mockito.doReturn(retVal).when(ques).deriveNsSplit(Mockito.any(), Mockito.anyString());
 		
-		CachedRoleDAO userRoleDAO = Mockito.mock(CachedRoleDAO.class);
-		Mockito.doReturn(retVal).when(userRoleDAO).read(Mockito.any(), Mockito.any(RoleDAO.Data.class));	
-		Mockito.doReturn(retVal).when(userRoleDAO).create(Mockito.any(), Mockito.any(RoleDAO.Data.class));		
-		setQuestionCachedRoleDao(ques, userRoleDAO);
+		Mockito.doReturn(retVal).when(userRoleDAO).read(Mockito.any(), Mockito.any(UserRoleDAO.Data.class));	
+		Mockito.doReturn(retVal).when(userRoleDAO).create(Mockito.any(), Mockito.any(UserRoleDAO.Data.class));		
 		
-		CachedPermDAO cachedPermDAO = Mockito.mock(CachedPermDAO.class);
-		Mockito.doReturn(retVal).when(cachedPermDAO).create(Mockito.any(), Mockito.any());
-		Mockito.doReturn(retVal).when(cachedPermDAO).read(trans, perm);		
-		setQuestionCachedPermDao(ques, cachedPermDAO);
+		Mockito.doReturn(retVal).when(permDAO).create(Mockito.any(), Mockito.any());
+		Mockito.doReturn(retVal).when(permDAO).read(trans, perm);		
 		
-		Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(null,1,"test",new String[0]);
+		Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(null,1,"test",NO_PARAM);
 		Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,perm, Access.write);
 		
 		Function funcObj = new Function(trans, ques);
 		Result<Void> result = funcObj.createPerm(trans, perm, false);
 		assertTrue(result.status == 1);
 		
-		retVal2 = new Result<NsDAO.Data>(null,0,"test",new String[0]);
+		retVal2 = new Result<NsDAO.Data>(null,0,"test",NO_PARAM);
 		Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,perm, Access.write);
 		result = funcObj.createPerm(trans, perm, false);
 		assertTrue(result.status == 1);
 
 		NsSplit nsObj = new NsSplit("test","test");
-		Result<NsSplit> retValNs = new Result<NsSplit>(nsObj,0,"test",new String[0]);
+		Result<NsSplit> retValNs = new Result<NsSplit>(nsObj,0,"test",NO_PARAM);
 		Mockito.doReturn(retValNs).when(ques).deriveNsSplit(Mockito.any(), Mockito.anyString());
 		Mockito.doReturn(retVal2).when(ques).mayUser(Mockito.any(), Mockito.anyString(),Mockito.any(RoleDAO.Data.class), Mockito.any());
+		Result<List<RoleDAO.Data>> retVal3 = Result.ok(new ArrayList<>());
+		Mockito.doReturn(retVal3).when(roleDAO).read(Mockito.any(),Mockito.any(RoleDAO.Data.class));
+		Result<List<RoleDAO.Data>> retVal4 = Result.err(Result.ERR_NotFound,"");
+		Mockito.doReturn(retVal4).when(roleDAO).create(Mockito.any(),Mockito.any(RoleDAO.Data.class));
 		result = funcObj.createPerm(trans, perm, false);
 		
-		Mockito.doReturn(retVal).when(cachedPermDAO).read(trans, perm);	
+		Mockito.doReturn(retVal).when(permDAO).read(trans, perm);	
 		result = funcObj.createPerm(trans, perm, true);
 		assertTrue(result.status == 1);
 
-		Mockito.doReturn(retVal2).when(cachedPermDAO).create(Mockito.any(), Mockito.any());
+		Mockito.doReturn(retVal2).when(permDAO).create(Mockito.any(), Mockito.any());
 		result = funcObj.createPerm(trans, perm, true);
 		assertTrue(result.status == 0);
 		
 		Mockito.doReturn(false).when(trans).requested(REQD_TYPE.force);
-		Result<List<PermDAO.Data>> retVal1 = new Result<List<PermDAO.Data>>(dataAl,0,"test",new String[0]);
-		Mockito.doReturn(retVal1).when(cachedPermDAO).read(trans, perm);	
+		Result<List<PermDAO.Data>> retVal1 = new Result<List<PermDAO.Data>>(dataAl,0,"test",NO_PARAM);
+		Mockito.doReturn(retVal1).when(permDAO).read(trans, perm);	
 		result = funcObj.createPerm(trans, perm, true);
 		assertTrue(result.status == Status.ERR_ConflictAlreadyExists);
 		
 	}
 	@Test
 	public void testDeletePerm() {
-		Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
-		Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).debug();
-		Mockito.doReturn(Mockito.mock(Properties.class)).when(access).getProperties();
-		Mockito.doReturn("test.test").when(access).getProperty(Config.AAF_ROOT_NS,"org.osaaf.aaf");
 		try {
 			Define.set(access);
 		} catch (CadiException e) {
@@ -1499,47 +1109,41 @@ public class JU_Function {
 //		perm.type=1
 		dataAl.add(perm);
 		
-		Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(null,1,"test",new String[0]);
+		Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(null,1,"test",NO_PARAM);
 		Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,perm, Access.write);
 		
-		CachedUserRoleDAO userRoleDAO = Mockito.mock(CachedUserRoleDAO.class);
 //		List<NsDAO.Data> dataAl = new ArrayList<NsDAO.Data>();
 //		NsDAO.Data dataObj = new NsDAO.Data();
 //		dataObj.type=1;
 //		dataAl.add(dataObj);
-		Result<List<PermDAO.Data>> retVal = new Result<List<PermDAO.Data>>(dataAl,1,"test",new String[0]);
+		Result<List<PermDAO.Data>> retVal = new Result<List<PermDAO.Data>>(dataAl,1,"test",NO_PARAM);
 		Mockito.doReturn(retVal).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());		
-		setQuestionUserRoleDao(ques, userRoleDAO);
 		
 		Function funcObj = new Function(trans, ques);
 		Result<Void> result = funcObj.deletePerm(trans, perm, true,false);
 		assertTrue(result.status == 1);
 
-		CachedPermDAO cachedPermDAO = Mockito.mock(CachedPermDAO.class);
 //		Mockito.doReturn(retVal).when(cachedPermDAO).create(Mockito.any(), Mockito.any());
-		Mockito.doReturn(retVal).when(cachedPermDAO).read(trans, perm);		
-		setQuestionCachedPermDao(ques, cachedPermDAO);
+		Mockito.doReturn(retVal).when(permDAO).read(trans, perm);		
 		
 		result = funcObj.deletePerm(trans, perm, true,true);
 		assertTrue(result.status == Status.ERR_PermissionNotFound);
 
-		retVal2 = new Result<NsDAO.Data>(null,0,"test",new String[0]);
+		retVal2 = new Result<NsDAO.Data>(null,0,"test",NO_PARAM);
 		Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,perm, Access.write);
-		Result<List<PermDAO.Data>> retVal3 = new Result<List<PermDAO.Data>>(dataAl,0,"test",new String[0]);
-		Mockito.doReturn(retVal3).when(cachedPermDAO).read(trans, perm);
+		Result<List<PermDAO.Data>> retVal3 = new Result<List<PermDAO.Data>>(dataAl,0,"test",NO_PARAM);
+		Mockito.doReturn(retVal3).when(permDAO).read(trans, perm);
 		
 		NsSplit nsObj = new NsSplit("test","test");
-		Result<NsSplit> retValNs = new Result<NsSplit>(nsObj,0,"test",new String[0]);
+		Result<NsSplit> retValNs = new Result<NsSplit>(nsObj,0,"test",NO_PARAM);
 		Mockito.doReturn(retValNs).when(ques).deriveNsSplit(Mockito.any(), Mockito.anyString());
 		
-		CachedRoleDAO cachedRoleDAO = Mockito.mock(CachedRoleDAO.class);
-		Mockito.doReturn(retVal).when(cachedRoleDAO).delPerm(Mockito.any(), Mockito.any(), Mockito.any());	
-		setQuestionCachedRoleDao(ques, cachedRoleDAO);
+		Mockito.doReturn(retVal).when(roleDAO).delPerm(Mockito.any(), Mockito.any(), Mockito.any());	
 		
 		result = funcObj.deletePerm(trans, perm, true,false);
 		assertNull(result);	
 		
-		Mockito.doReturn(retVal2).when(cachedRoleDAO).delPerm(Mockito.any(), Mockito.any(), Mockito.any());	
+		Mockito.doReturn(retVal2).when(roleDAO).delPerm(Mockito.any(), Mockito.any(), Mockito.any());	
 		result = funcObj.deletePerm(trans, perm, true,false);
 		assertNull(result);	
 		
@@ -1549,10 +1153,6 @@ public class JU_Function {
 	
 	@Test
 	public void testDeleteRole() {
-		Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
-		Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).debug();
-		Mockito.doReturn(Mockito.mock(Properties.class)).when(access).getProperties();
-		Mockito.doReturn("test.test").when(access).getProperty(Config.AAF_ROOT_NS,"org.osaaf.aaf");
 		try {
 			Define.set(access);
 		} catch (CadiException e) {
@@ -1577,48 +1177,42 @@ public class JU_Function {
 //		perm.type=1
 		dataAl.add(role);
 		
-		Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(null,1,"test",new String[0]);
+		Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(null,1,"test",NO_PARAM);
 		Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,role, Access.write);
 		
-		CachedUserRoleDAO userRoleDAO = Mockito.mock(CachedUserRoleDAO.class);
 //		List<NsDAO.Data> dataAl = new ArrayList<NsDAO.Data>();
 //		NsDAO.Data dataObj = new NsDAO.Data();
 //		dataObj.type=1;
 //		dataAl.add(dataObj);
-		Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(null,1,"test",new String[0]);
+		Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(null,1,"test",NO_PARAM);
 		Mockito.doReturn(retVal).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());		
-		setQuestionUserRoleDao(ques, userRoleDAO);
 //		
-//		Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(null,0,"test",new String[0]);
+//		Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(null,0,"test",NO_PARAM);
 //		Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,retVal.value.get(0), Access.write);
 //		
 		Function funcObj = new Function(trans, ques);
 		Result<Void> result = funcObj.deleteRole(trans, role, true, false);
 		assertTrue(result.status == 1);
 
-		CachedRoleDAO cachedRoleDAO = Mockito.mock(CachedRoleDAO.class);
-		setQuestionCachedRoleDao(ques, cachedRoleDAO);
-		Result<List<RoleDAO.Data>> retVal1 = new Result<List<RoleDAO.Data>>(dataAl,0,"test",new String[0]);
-		Mockito.doReturn(retVal1).when(cachedRoleDAO).read(Mockito.any(), Mockito.any(RoleDAO.Data.class));	
+		Result<List<RoleDAO.Data>> retVal1 = new Result<List<RoleDAO.Data>>(dataAl,0,"test",NO_PARAM);
+		Mockito.doReturn(retVal1).when(roleDAO).read(Mockito.any(), Mockito.any(RoleDAO.Data.class));	
 		NsSplit splitObj = new NsSplit("test", "test");
-		Result<NsSplit> retVal3 = new Result<NsSplit>(splitObj,0,"test",new String[0]);
+		Result<NsSplit> retVal3 = new Result<NsSplit>(splitObj,0,"test",NO_PARAM);
 		Mockito.doReturn(retVal3).when(ques).deriveNsSplit(Mockito.any(), Mockito.anyString());
-		CachedPermDAO cachedPermDAO = Mockito.mock(CachedPermDAO.class);
 //		Mockito.doReturn(retVal).when(cachedPermDAO).create(Mockito.any(), Mockito.any());
-		Mockito.doReturn(retVal).when(cachedPermDAO).delRole(Mockito.any(), Mockito.any(),Mockito.any());		
-		setQuestionCachedPermDao(ques, cachedPermDAO);
+		Mockito.doReturn(retVal).when(permDAO).delRole(Mockito.any(), Mockito.any(),Mockito.any());		
 		result = funcObj.deleteRole(trans, role, true, true);
 		assertNull(result);
 		
-		Mockito.doReturn(retVal1).when(cachedPermDAO).delRole(Mockito.any(), Mockito.any(),Mockito.any());
+		Mockito.doReturn(retVal1).when(permDAO).delRole(Mockito.any(), Mockito.any(),Mockito.any());
 		result = funcObj.deleteRole(trans, role, true, true);
 		assertNull(result);
 
-		Mockito.doReturn(retVal).when(cachedRoleDAO).read(Mockito.any(), Mockito.any(RoleDAO.Data.class));	
+		Mockito.doReturn(retVal).when(roleDAO).read(Mockito.any(), Mockito.any(RoleDAO.Data.class));	
 		result = funcObj.deleteRole(trans, role, true, true);
 		assertTrue(result.status == Status.ERR_RoleNotFound);
 		
-		retVal = new Result<List<UserRoleDAO.Data>>(dataAlUser,0,"test",new String[0]);
+		retVal = new Result<List<UserRoleDAO.Data>>(dataAlUser,0,"test",NO_PARAM);
 		Mockito.doReturn(retVal).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());	
 		result = funcObj.deleteRole(trans, role, false, true);
 		assertTrue(result.status == Status.ERR_DependencyExists);
@@ -1626,16 +1220,6 @@ public class JU_Function {
 	
 	@Test
 	public void testAddPermToRole() {
-		Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
-		Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).debug();
-		Mockito.doReturn(Mockito.mock(Properties.class)).when(access).getProperties();
-		Mockito.doReturn("test.test").when(access).getProperty(Config.AAF_ROOT_NS,"org.osaaf.aaf");
-		try {
-			Define.set(access);
-		} catch (CadiException e) {
-			// TODO Auto-generated catch block
-			e.printStackTrace();
-		}
 		List<PermDAO.Data> dataAlPerm = new ArrayList<PermDAO.Data>();
 		PermDAO.Data rolePerm = new PermDAO.Data();
 		Set<String> rolesSetUser = new HashSet<>();
@@ -1658,20 +1242,18 @@ public class JU_Function {
 		NsDAO.Data nsObj1 = new NsDAO.Data();
 		nsObj1.name="test12";
 		
-		CachedUserRoleDAO userRoleDAO = Mockito.mock(CachedUserRoleDAO.class);
 //		List<NsDAO.Data> dataAl = new ArrayList<NsDAO.Data>();
 //		NsDAO.Data dataObj = new NsDAO.Data();
 //		dataObj.type=1;
 //		dataAl.add(dataObj);
-		Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(null,1,"test",new String[0]);
+		Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(null,1,"test",NO_PARAM);
 		Mockito.doReturn(retVal).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());		
-		setQuestionUserRoleDao(ques, userRoleDAO);
 
-		Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(nsObj,0,"test",new String[0]);
+		Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(nsObj,0,"test",NO_PARAM);
 		Mockito.doReturn(retVal2).when(ques).deriveFirstNsForType(trans, role.ns, NsType.COMPANY);
 		Mockito.doReturn(retVal2).when(ques).deriveFirstNsForType(trans, rolePerm.ns, NsType.COMPANY);
 		
-		Result<NsDAO.Data> retVal3 = new Result<NsDAO.Data>(null,1,"test",new String[0]);
+		Result<NsDAO.Data> retVal3 = new Result<NsDAO.Data>(null,1,"test",NO_PARAM);
 		Mockito.doReturn(retVal3).when(ques).mayUser(trans, null,rolePerm, Access.write);
 		Mockito.doReturn(retVal3).when(ques).mayUser(trans, null,role, Access.write);
 		
@@ -1679,45 +1261,41 @@ public class JU_Function {
 		Result<Void> result = funcObj.addPermToRole(trans, role, rolePerm, false);
 		assertTrue(result.status == 1);
 
-		retVal2 = new Result<NsDAO.Data>(nsObj,1,"test",new String[0]);
+		retVal2 = new Result<NsDAO.Data>(nsObj,1,"test",NO_PARAM);
 		Mockito.doReturn(retVal2).when(ques).deriveFirstNsForType(trans, role.ns, NsType.COMPANY);
 		Mockito.doReturn(retVal2).when(ques).deriveFirstNsForType(trans, rolePerm.ns, NsType.COMPANY);
 		result = funcObj.addPermToRole(trans, role, rolePerm, false);
 		assertTrue(result.status == 1);
 		
 		role.ns="test2";
-		retVal2 = new Result<NsDAO.Data>(nsObj,0,"test",new String[0]);
+		retVal2 = new Result<NsDAO.Data>(nsObj,0,"test",NO_PARAM);
 		Mockito.doReturn(retVal2).when(ques).deriveFirstNsForType(trans, role.ns, NsType.COMPANY);
 		result = funcObj.addPermToRole(trans, role, rolePerm, false);
 		assertTrue(result.status == 1);
 		
-		retVal2 = new Result<NsDAO.Data>(nsObj,0,"test1",new String[0]);
+		retVal2 = new Result<NsDAO.Data>(nsObj,0,"test1",NO_PARAM);
 		Mockito.doReturn(retVal2).when(ques).deriveFirstNsForType(trans, role.ns, NsType.COMPANY);
-		Result<NsDAO.Data> retVal21 = new Result<NsDAO.Data>(nsObj1,0,"test1",new String[0]);
+		Result<NsDAO.Data> retVal21 = new Result<NsDAO.Data>(nsObj1,0,"test1",NO_PARAM);
 		Mockito.doReturn(retVal21).when(ques).deriveFirstNsForType(trans, rolePerm.ns, NsType.COMPANY);
 		result = funcObj.addPermToRole(trans, role, rolePerm, false);
 		assertTrue(result.status == 1);
 		
-		retVal3 = new Result<NsDAO.Data>(null,0,"test",new String[0]);
+		retVal3 = new Result<NsDAO.Data>(null,0,"test",NO_PARAM);
 		Mockito.doReturn(retVal3).when(ques).mayUser(trans, null,rolePerm, Access.write);
-		retVal2 = new Result<NsDAO.Data>(nsObj,0,"test1",new String[0]);
+		retVal2 = new Result<NsDAO.Data>(nsObj,0,"test1",NO_PARAM);
 		Mockito.doReturn(retVal2).when(ques).deriveFirstNsForType(trans, role.ns, NsType.COMPANY);
 		Mockito.doReturn(retVal2).when(ques).deriveFirstNsForType(trans, rolePerm.ns, NsType.COMPANY);
 		
-		CachedPermDAO cachedPermDAO = Mockito.mock(CachedPermDAO.class);
 //		Mockito.doReturn(retVal).when(cachedPermDAO).create(Mockito.any(), Mockito.any());
-		Mockito.doReturn(retVal).when(cachedPermDAO).read(Mockito.any(), Mockito.any(PermDAO.Data.class));		
-		setQuestionCachedPermDao(ques, cachedPermDAO);
+		Mockito.doReturn(retVal).when(permDAO).read(Mockito.any(), Mockito.any(PermDAO.Data.class));		
 		
 		result = funcObj.addPermToRole(trans, role, rolePerm, false);
 		assertTrue(result.status == Status.ERR_PermissionNotFound);
 		
-		Result<List<PermDAO.Data>> retValPerm= new Result<List<PermDAO.Data>>(dataAlPerm,0,"test1",new String[0]);
-		Mockito.doReturn(retValPerm).when(cachedPermDAO).read(Mockito.any(), Mockito.any(PermDAO.Data.class));	
+		Result<List<PermDAO.Data>> retValPerm= new Result<List<PermDAO.Data>>(dataAlPerm,0,"test1",NO_PARAM);
+		Mockito.doReturn(retValPerm).when(permDAO).read(Mockito.any(), Mockito.any(PermDAO.Data.class));	
 		
-		CachedRoleDAO cachedRoleDAO = Mockito.mock(CachedRoleDAO.class);
-		Mockito.doReturn(retVal3).when(cachedRoleDAO).read(trans, role);
-		setQuestionCachedRoleDao(ques, cachedRoleDAO);
+		Mockito.doReturn(retVal3).when(roleDAO).read(trans, role);
 		
 		result = funcObj.addPermToRole(trans, role, rolePerm, true);
 		assertTrue(result.status == 22);
@@ -1726,36 +1304,26 @@ public class JU_Function {
 		result = funcObj.addPermToRole(trans, role, rolePerm, true);
 		assertTrue(result.status == 2);
 		
-		retVal3 = new Result<NsDAO.Data>(null,0,"test",new String[0]);
+		retVal3 = new Result<NsDAO.Data>(null,0,"test",NO_PARAM);
 		Mockito.doReturn(retVal3).when(ques).mayUser(trans, null,role, Access.write);
-		Mockito.doReturn(retVal3).when(cachedRoleDAO).create(trans, role);
+		Mockito.doReturn(retVal3).when(roleDAO).create(trans, role);
 		result = funcObj.addPermToRole(trans, role, rolePerm, true);
 //		System.out.println(result.status);
 		assertNull(result);
 		
-		retVal3 = new Result<NsDAO.Data>(null,1,"test",new String[0]);
-		Mockito.doReturn(retVal3).when(cachedRoleDAO).create(trans, role);
+		retVal3 = new Result<NsDAO.Data>(null,1,"test",NO_PARAM);
+		Mockito.doReturn(retVal3).when(roleDAO).create(trans, role);
 		result = funcObj.addPermToRole(trans, role, rolePerm, true);
 		assertTrue(result.status == 1);
 		
-		Result<List<RoleDAO.Data>> retVal31 = new Result<List<RoleDAO.Data>>(dataAl,0,"test",new String[0]);
-		Mockito.doReturn(retVal31).when(cachedRoleDAO).read(trans, role);
+		Result<List<RoleDAO.Data>> retVal31 = new Result<List<RoleDAO.Data>>(dataAl,0,"test",NO_PARAM);
+		Mockito.doReturn(retVal31).when(roleDAO).read(trans, role);
 		result = funcObj.addPermToRole(trans, role, rolePerm, true);
 		assertTrue(result.status == 7);
 	}
 	
 	@Test
 	public void testDelPermFromRole() {
-		Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
-		Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).debug();
-		Mockito.doReturn(Mockito.mock(Properties.class)).when(access).getProperties();
-		Mockito.doReturn("test.test").when(access).getProperty(Config.AAF_ROOT_NS,"org.osaaf.aaf");
-		try {
-			Define.set(access);
-		} catch (CadiException e) {
-			// TODO Auto-generated catch block
-			e.printStackTrace();
-		}
 		List<PermDAO.Data> dataAlPerm = new ArrayList<PermDAO.Data>();
 		PermDAO.Data rolePerm = new PermDAO.Data();
 		Set<String> rolesSetUser = new HashSet<>();
@@ -1771,17 +1339,15 @@ public class JU_Function {
 		role.perms = rolesSet;
 		dataAl.add(role);
 		
-		CachedUserRoleDAO userRoleDAO = Mockito.mock(CachedUserRoleDAO.class);
 //		List<NsDAO.Data> dataAl = new ArrayList<NsDAO.Data>();
 //		NsDAO.Data dataObj = new NsDAO.Data();
 //		dataObj.type=1;
 //		dataAl.add(dataObj);
-		Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(null,1,"test",new String[0]);
+		Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(null,1,"test",NO_PARAM);
 		Mockito.doReturn(retVal).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());		
-		setQuestionUserRoleDao(ques, userRoleDAO);
 
-		Result<NsDAO.Data> retValFail = new Result<NsDAO.Data>(null,1,"test",new String[0]);
-		Result<NsDAO.Data> retValSuc = new Result<NsDAO.Data>(null,0,"test",new String[0]);
+		Result<NsDAO.Data> retValFail = new Result<NsDAO.Data>(null,1,"test",NO_PARAM);
+		Result<NsDAO.Data> retValSuc = new Result<NsDAO.Data>(null,0,"test",NO_PARAM);
 		Mockito.doReturn(retValFail).when(ques).mayUser(trans, null,rolePerm, Access.write);
 		Mockito.doReturn(retValFail).when(ques).mayUser(trans, null,role, Access.write);
 		
@@ -1792,24 +1358,20 @@ public class JU_Function {
 		Mockito.doReturn(retValFail).when(ques).mayUser(trans, null,rolePerm, Access.write);
 		Mockito.doReturn(retValSuc).when(ques).mayUser(trans, null,role, Access.write);		
 		
-		CachedRoleDAO cachedRoleDAO = Mockito.mock(CachedRoleDAO.class);
-		Mockito.doReturn(retValFail).when(cachedRoleDAO).read(trans, role);
-		setQuestionCachedRoleDao(ques, cachedRoleDAO);
+		Mockito.doReturn(retValFail).when(roleDAO).read(trans, role);
 		
-		CachedPermDAO cachedPermDAO = Mockito.mock(CachedPermDAO.class);
-		Mockito.doReturn(retVal).when(cachedPermDAO).read(Mockito.any(), Mockito.any(PermDAO.Data.class));		
-		setQuestionCachedPermDao(ques, cachedPermDAO);
+		Mockito.doReturn(retVal).when(permDAO).read(Mockito.any(), Mockito.any(PermDAO.Data.class));		
 		
 		result = funcObj.delPermFromRole(trans, role, rolePerm, false);
 		assertTrue(result.status == 1);
 		
-		Result<List<PermDAO.Data>> retValPermSuc = new Result<List<PermDAO.Data>>(dataAlPerm,0,"test",new String[0]);
-		Mockito.doReturn(retValPermSuc).when(cachedPermDAO).read(Mockito.any(), Mockito.any(PermDAO.Data.class));	
+		Result<List<PermDAO.Data>> retValPermSuc = new Result<List<PermDAO.Data>>(dataAlPerm,0,"test",NO_PARAM);
+		Mockito.doReturn(retValPermSuc).when(permDAO).read(Mockito.any(), Mockito.any(PermDAO.Data.class));	
 		result = funcObj.delPermFromRole(trans, role, rolePerm, false);
 		assertTrue(result.status == 1);
 		
-		Result<List<RoleDAO.Data>> retValRoleSuc = new Result<List<RoleDAO.Data>>(dataAl,0,"test",new String[0]);
-		Mockito.doReturn(retValRoleSuc).when(cachedRoleDAO).read(Mockito.any(), Mockito.any(RoleDAO.Data.class));	
+		Result<List<RoleDAO.Data>> retValRoleSuc = new Result<List<RoleDAO.Data>>(dataAl,0,"test",NO_PARAM);
+		Mockito.doReturn(retValRoleSuc).when(roleDAO).read(Mockito.any(), Mockito.any(RoleDAO.Data.class));	
 		result = funcObj.delPermFromRole(trans, role, rolePerm, true);
 		assertTrue(result.status == Status.ERR_PermissionNotFound);
 		
@@ -1818,8 +1380,8 @@ public class JU_Function {
 		rolesSet.add("null|null|null|null");
 		role.perms = rolesSet;
 		dataAl.add(role);
-		Mockito.doReturn(retValRoleSuc).when(cachedRoleDAO).read(Mockito.any(), Mockito.any(RoleDAO.Data.class));	
-		Mockito.doReturn(retVal).when(cachedPermDAO).delRole(Mockito.any(), Mockito.any(),Mockito.any(RoleDAO.Data.class));	
+		Mockito.doReturn(retValRoleSuc).when(roleDAO).read(Mockito.any(), Mockito.any(RoleDAO.Data.class));	
+		Mockito.doReturn(retVal).when(permDAO).delRole(Mockito.any(), Mockito.any(),Mockito.any(RoleDAO.Data.class));	
 		result = funcObj.delPermFromRole(trans, role, rolePerm, true);
 		assertTrue(result.status == 1);
 		
@@ -1827,48 +1389,38 @@ public class JU_Function {
 		result = funcObj.delPermFromRole(trans, role, rolePerm, true);
 		assertTrue(result.status == 1);
 		
-		Mockito.doReturn(retValRoleSuc).when(cachedPermDAO).delRole(Mockito.any(), Mockito.any(),Mockito.any(RoleDAO.Data.class));
-		Mockito.doReturn(retVal).when(cachedRoleDAO).delPerm(Mockito.any(), Mockito.any(),Mockito.any(PermDAO.Data.class));		
+		Mockito.doReturn(retValRoleSuc).when(permDAO).delRole(Mockito.any(), Mockito.any(),Mockito.any(RoleDAO.Data.class));
+		Mockito.doReturn(retVal).when(roleDAO).delPerm(Mockito.any(), Mockito.any(),Mockito.any(PermDAO.Data.class));		
 		result = funcObj.delPermFromRole(trans, role, rolePerm, true);
 		assertTrue(result.status == 1);
 		
-		Mockito.doReturn(retValPermSuc).when(cachedRoleDAO).delPerm(Mockito.any(), Mockito.any(),Mockito.any(PermDAO.Data.class));		
+		Mockito.doReturn(retValPermSuc).when(roleDAO).delPerm(Mockito.any(), Mockito.any(),Mockito.any(PermDAO.Data.class));		
 		result = funcObj.delPermFromRole(trans, role, rolePerm, true);
 		assertTrue(result.status == 0);
 		
-		Mockito.doReturn(retVal).when(cachedPermDAO).read(Mockito.any(), Mockito.any(PermDAO.Data.class));
+		Mockito.doReturn(retVal).when(permDAO).read(Mockito.any(), Mockito.any(PermDAO.Data.class));
 		result = funcObj.delPermFromRole(trans, role, rolePerm, true);
 		assertTrue(result.status == 0);
 		
-		Mockito.doReturn(retVal).when(cachedRoleDAO).delPerm(Mockito.any(), Mockito.any(),Mockito.any(PermDAO.Data.class));	
+		Mockito.doReturn(retVal).when(roleDAO).delPerm(Mockito.any(), Mockito.any(),Mockito.any(PermDAO.Data.class));	
 		result = funcObj.delPermFromRole(trans, role, rolePerm, true);
 		assertTrue(result.status == 1);
 
 		NsSplit splitObj = new NsSplit("test", "test");
-		Result<NsSplit> retVal3 = new Result<NsSplit>(splitObj,0,"test",new String[0]);
+		Result<NsSplit> retVal3 = new Result<NsSplit>(splitObj,0,"test",NO_PARAM);
 		Mockito.doReturn(retVal3).when(ques).deriveNsSplit(Mockito.any(), Mockito.anyString());
 		Mockito.doReturn(retValFail).when(ques).mayUser(Mockito.any(), Mockito.anyString(),Mockito.any(RoleDAO.Data.class), Mockito.any());
 		Mockito.doReturn(retValFail).when(ques).mayUser(Mockito.any(), Mockito.anyString(),Mockito.any(PermDAO.Data.class), Mockito.any());
 		result = funcObj.delPermFromRole(trans, "test", rolePerm);
 		assertTrue(result.status == 2);
 		
-		retVal3 = new Result<NsSplit>(null,1,"test",new String[0]);
+		retVal3 = new Result<NsSplit>(null,1,"test",NO_PARAM);
 		Mockito.doReturn(retVal3).when(ques).deriveNsSplit(Mockito.any(), Mockito.anyString());
 		result = funcObj.delPermFromRole(trans, "test", rolePerm);
 		assertTrue(result.status == 1);
 	}
 	@Test
 	public void testAddUserRole() {
-		Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
-		Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).debug();
-		Mockito.doReturn(Mockito.mock(Properties.class)).when(access).getProperties();
-		Mockito.doReturn("test.test").when(access).getProperty(Config.AAF_ROOT_NS,"org.osaaf.aaf");
-		try {
-			Define.set(access);
-		} catch (CadiException e) {
-			// TODO Auto-generated catch block
-			e.printStackTrace();
-		}
 		List<UserRoleDAO.Data> urDataAl = new ArrayList<>();
 		UserRoleDAO.Data urData = new UserRoleDAO.Data();
 		urData.ns="test";
@@ -1880,21 +1432,15 @@ public class JU_Function {
 		Mockito.doReturn(org).when(trans).org();
 		Mockito.doReturn(Mockito.mock(GregorianCalendar.class)).when(org).expiration(Mockito.any(), Mockito.any(), Mockito.anyString());
 		
-		CachedUserRoleDAO userRoleDAO = Mockito.mock(CachedUserRoleDAO.class);
-		CachedRoleDAO roleDAO = Mockito.mock(CachedRoleDAO.class);
-		Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(null,1,"test",new String[0]);
-		Result<List<UserRoleDAO.Data>> retValSuc = new Result<List<UserRoleDAO.Data>>(urDataAl,0,"test",new String[0]);
+		Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(null,1,"test",NO_PARAM);
+		Result<List<UserRoleDAO.Data>> retValSuc = new Result<List<UserRoleDAO.Data>>(urDataAl,0,"test",NO_PARAM);
 		Mockito.doReturn(retVal).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());
 		Mockito.doReturn(retVal).when(userRoleDAO).read(Mockito.any(), Mockito.any(UserRoleDAO.Data.class));
 		Mockito.doReturn(retVal).when(userRoleDAO).create(Mockito.any(), Mockito.any(UserRoleDAO.Data.class));	
 		Mockito.doReturn(retValSuc).when(roleDAO).read(Mockito.any(), Mockito.anyString(), Mockito.anyString());		
-		setQuestionUserRoleDao(ques, userRoleDAO);
-		setQuestionCachedRoleDao(ques, roleDAO);
-		
-		CachedCredDAO credDAO = Mockito.mock(CachedCredDAO.class);
-		Result<List<CredDAO.Data>> retVal2 = new Result<List<CredDAO.Data>>(null,1,"test",new String[0]);
+
+		Result<List<CredDAO.Data>> retVal2 = new Result<List<CredDAO.Data>>(null,1,"test",NO_PARAM);
 		Mockito.doReturn(retVal2).when(credDAO).readID(Mockito.any(), Mockito.anyString());		
-		setQuestionCredDao(ques, credDAO);
 		
 		Function funcObj = new Function(trans, ques);
 		Result<Void> result = funcObj.addUserRole(trans, urData);
@@ -1906,7 +1452,7 @@ public class JU_Function {
 		
 		NsDAO.Data data = new NsDAO.Data();
 		data.name="test";
-		Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,0,"test",new String[0]);
+		Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,0,"test",NO_PARAM);
 		Mockito.doReturn(retVal1).when(ques).mayUser(trans, null,retVal1.value, Access.write);
 		Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
 		try {
@@ -1952,18 +1498,9 @@ public class JU_Function {
 		result = funcObj.addUserRole(trans, "test", "test", "test");
 		assertTrue(result.status == 20);
 	}
+	
 	@Test
 	public void testExtendUserRole() {
-		Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
-		Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).debug();
-		Mockito.doReturn(Mockito.mock(Properties.class)).when(access).getProperties();
-		Mockito.doReturn("test.test").when(access).getProperty(Config.AAF_ROOT_NS,"org.osaaf.aaf");
-		try {
-			Define.set(access);
-		} catch (CadiException e) {
-			// TODO Auto-generated catch block
-			e.printStackTrace();
-		}
 		List<UserRoleDAO.Data> urDataAl = new ArrayList<>();
 		UserRoleDAO.Data urData = new UserRoleDAO.Data();
 		urData.ns="test";
@@ -1972,18 +1509,14 @@ public class JU_Function {
 		urData.expires=new Date();
 		urDataAl.add(urData);
 		
-		CachedUserRoleDAO userRoleDAO = Mockito.mock(CachedUserRoleDAO.class);
-		CachedRoleDAO roleDAO = Mockito.mock(CachedRoleDAO.class);
 //		List<NsDAO.Data> dataAl = new ArrayList<NsDAO.Data>();
 //		NsDAO.Data dataObj = new NsDAO.Data();
 //		dataObj.type=1;
 //		dataAl.add(dataObj);
-		Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(null,1,"test",new String[0]);
-		Result<List<UserRoleDAO.Data>> retValSuc = new Result<List<UserRoleDAO.Data>>(urDataAl,0,"test",new String[0]);
+		Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(null,1,"test",NO_PARAM);
+		Result<List<UserRoleDAO.Data>> retValSuc = new Result<List<UserRoleDAO.Data>>(urDataAl,0,"test",NO_PARAM);
 		Mockito.doReturn(retVal).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());		
 		Mockito.doReturn(retValSuc).when(roleDAO).read(Mockito.any(), Mockito.anyString(), Mockito.anyString());
-		setQuestionUserRoleDao(ques, userRoleDAO);
-		setQuestionCachedRoleDao(ques, roleDAO);
 
 		Organization org = Mockito.mock(Organization.class);
 		Mockito.doReturn(org).when(trans).org();
@@ -2003,19 +1536,9 @@ public class JU_Function {
 		assertTrue(result.status == Status.ERR_UserRoleNotFound);
 	}
 	
+	@SuppressWarnings("deprecation")
 	@Test
 	public void testGetUsersByRole() {
-		Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
-		Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).debug();
-		Mockito.doReturn(Mockito.mock(Properties.class)).when(access).getProperties();
-		Mockito.doReturn("test.test").when(access).getProperty(Config.AAF_ROOT_NS,"org.osaaf.aaf");
-		try {
-			Define.set(access);
-		} catch (CadiException e) {
-			// TODO Auto-generated catch block
-			e.printStackTrace();
-		}
-		CachedUserRoleDAO userRoleDAO = Mockito.mock(CachedUserRoleDAO.class);
 		List<UserRoleDAO.Data> urDataAl = new ArrayList<>();
 		UserRoleDAO.Data urData = new UserRoleDAO.Data();
 		urData.ns="test";
@@ -2023,9 +1546,8 @@ public class JU_Function {
 		urData.user="test";
 		urData.expires=new Date();
 		urDataAl.add(urData);
-		Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(urDataAl,0,"test",new String[0]);
+		Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(urDataAl,0,"test",NO_PARAM);
 		Mockito.doReturn(retVal).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());		
-		setQuestionUserRoleDao(ques, userRoleDAO);
 
 		Function funcObj = new Function(trans, ques);
 		Result<List<String>> result = funcObj.getUsersByRole(trans, "test", false);
@@ -2041,17 +1563,6 @@ public class JU_Function {
 	}
 	@Test
 	public void testDelUserRole() {
-		Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
-		Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).debug();
-		Mockito.doReturn(Mockito.mock(Properties.class)).when(access).getProperties();
-		Mockito.doReturn("test.test").when(access).getProperty(Config.AAF_ROOT_NS,"org.osaaf.aaf");
-		try {
-			Define.set(access);
-		} catch (CadiException e) {
-			// TODO Auto-generated catch block
-			e.printStackTrace();
-		}
-		CachedUserRoleDAO userRoleDAO = Mockito.mock(CachedUserRoleDAO.class);
 		List<UserRoleDAO.Data> urDataAl = new ArrayList<>();
 		UserRoleDAO.Data urData = new UserRoleDAO.Data();
 		urData.ns="test";
@@ -2059,15 +1570,14 @@ public class JU_Function {
 		urData.user="test";
 		urData.expires=new Date();
 		urDataAl.add(urData);
-		Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(urDataAl,0,"test",new String[0]);
+		Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(urDataAl,0,"test",NO_PARAM);
 		Mockito.doReturn(retVal).when(userRoleDAO).read(Mockito.any(), Mockito.any( UserRoleDAO.Data.class));		
-		setQuestionUserRoleDao(ques, userRoleDAO);
 
 		Function funcObj = new Function(trans, ques);
 		Result<Void> result = funcObj.delUserRole(trans, "test", "test", "test");
 		assertNull(result);
 		
-		retVal = new Result<List<UserRoleDAO.Data>>(urDataAl,1,"test",new String[0]);
+		retVal = new Result<List<UserRoleDAO.Data>>(urDataAl,1,"test",NO_PARAM);
 		Mockito.doReturn(retVal).when(userRoleDAO).read(Mockito.any(), Mockito.any( UserRoleDAO.Data.class));
 		result = funcObj.delUserRole(trans, "test", "test", "test");
 //		assertTrue(result.status ==1);	
@@ -2076,22 +1586,11 @@ public class JU_Function {
 	
 	@Test
 	public void testCreateFuture() {
-		Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
-		Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).debug();
-		Mockito.doReturn(Mockito.mock(Properties.class)).when(access).getProperties();
-		Mockito.doReturn("test.test").when(access).getProperty(Config.AAF_ROOT_NS,"org.osaaf.aaf");
-		try {
-			Define.set(access);
-		} catch (CadiException e) {
-			// TODO Auto-generated catch block
-			e.printStackTrace();
-		}
 		FutureDAO.Data data = new FutureDAO.Data();
 		data.memo = "test";
 		NsDAO.Data nsd = new NsDAO.Data();
 		nsd.name = "test";
 		
-		CachedUserRoleDAO userRoleDAO = Mockito.mock(CachedUserRoleDAO.class);
 		List<UserRoleDAO.Data> urDataAl = new ArrayList<>();
 		UserRoleDAO.Data urData = new UserRoleDAO.Data();
 		urData.ns="test";
@@ -2099,17 +1598,14 @@ public class JU_Function {
 		urData.user="test";
 		urData.expires=new Date();
 		urDataAl.add(urData);
-		Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(urDataAl,0,"test",new String[0]);
-		Result<List<UserRoleDAO.Data>> retValFail = new Result<List<UserRoleDAO.Data>>(urDataAl,1,"test",new String[0]);
+		Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(urDataAl,0,"test",NO_PARAM);
+		Result<List<UserRoleDAO.Data>> retValFail = new Result<List<UserRoleDAO.Data>>(urDataAl,1,"test",NO_PARAM);
 		Mockito.doReturn(retVal).when(userRoleDAO).read(Mockito.any(), Mockito.any( UserRoleDAO.Data.class));	
-		setQuestionUserRoleDao(ques, userRoleDAO);
 
 		Function funcObj = new Function(trans, ques);
 		Result<String> result = funcObj.createFuture(trans, data, "test", "test", nsd, FUTURE_OP.A);
 		assertTrue(result.status == 20);
 
-		Organization org = Mockito.mock(Organization.class);
-		Mockito.doReturn(org).when(trans).org();
 		Identity iden=Mockito.mock(Identity.class);
 		try {
 			Mockito.doReturn(iden).when(org).getIdentity(trans, "test");
@@ -2120,17 +1616,13 @@ public class JU_Function {
 		}
 		FutureDAO.Data futureData = new FutureDAO.Data();
 		data.memo = "test";
-		FutureDAO futureDaoObj = Mockito.mock(FutureDAO.class);
-		Result<FutureDAO.Data> retValFuture = new Result<FutureDAO.Data>(futureData,0,"test",new String[0]);
-		Mockito.doReturn(retValFuture).when(futureDaoObj).create(Mockito.any(), Mockito.any( FutureDAO.Data.class), Mockito.anyString());
-		setQuestionFutureDao(ques, futureDaoObj);
+		Result<FutureDAO.Data> retValFuture = new Result<FutureDAO.Data>(futureData,0,"test",NO_PARAM);
+		Mockito.doReturn(retValFuture).when(futureDAO).create(Mockito.any(), Mockito.any( FutureDAO.Data.class), Mockito.anyString());
 		
 		ApprovalDAO.Data approvalData = new ApprovalDAO.Data();
 		data.memo = "test";
-		ApprovalDAO approvalDaoObj = Mockito.mock(ApprovalDAO.class);
-		Result<ApprovalDAO.Data> retValApproval = new Result<ApprovalDAO.Data>(approvalData,0,"test",new String[0]);
-		Mockito.doReturn(retValApproval).when(approvalDaoObj).create(Mockito.any(), Mockito.any( ApprovalDAO.Data.class));
-		setQuestionApprovalDao(ques, approvalDaoObj);
+		Result<ApprovalDAO.Data> retValApproval = new Result<ApprovalDAO.Data>(approvalData,0,"test",NO_PARAM);
+		Mockito.doReturn(retValApproval).when(approvalDAO).create(Mockito.any(), Mockito.any( ApprovalDAO.Data.class));
 		
 		Mockito.doReturn(retVal).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());	
 		result = funcObj.createFuture(trans, data, "test", "test", nsd, FUTURE_OP.A);
@@ -2162,25 +1654,14 @@ public class JU_Function {
 		result = funcObj.createFuture(trans, data, "test", "test", nsd, FUTURE_OP.C);
 		assertTrue(result.status == 0);
 		
-		retValApproval = new Result<ApprovalDAO.Data>(null,1,"test",new String[0]);
-		Mockito.doReturn(retValApproval).when(approvalDaoObj).create(Mockito.any(), Mockito.any( ApprovalDAO.Data.class));
+		retValApproval = new Result<ApprovalDAO.Data>(null,1,"test",NO_PARAM);
+		Mockito.doReturn(retValApproval).when(approvalDAO).create(Mockito.any(), Mockito.any( ApprovalDAO.Data.class));
 		result = funcObj.createFuture(trans, data, "test", "test", nsd, FUTURE_OP.A);
 		assertTrue(result.status == 8);
 	}
 	@Test
 	public void testUbLookup() {
-		Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
-		Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).debug();
-		Mockito.doReturn(Mockito.mock(Properties.class)).when(access).getProperties();
-		Mockito.doReturn("test.test").when(access).getProperty(Config.AAF_ROOT_NS,"org.osaaf.aaf");
-		try {
-			Define.set(access);
-		} catch (CadiException e) {
-			// TODO Auto-generated catch block
-			e.printStackTrace();
-		}
 		Object[] objArr = new Object[10];
-		CachedUserRoleDAO userRoleDAO = Mockito.mock(CachedUserRoleDAO.class);
 		List<UserRoleDAO.Data> urDataAl = new ArrayList<>();
 		UserRoleDAO.Data urData = new UserRoleDAO.Data();
 		urData.ns="test";
@@ -2188,10 +1669,9 @@ public class JU_Function {
 		urData.user="test";
 		urData.expires=new Date();
 		urDataAl.add(urData);
-		Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(urDataAl,0,"test",new String[0]);
-		Result<List<UserRoleDAO.Data>> retValFail = new Result<List<UserRoleDAO.Data>>(null,1,"test",new String[0]);
+		Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(urDataAl,0,"test",NO_PARAM);
+		Result<List<UserRoleDAO.Data>> retValFail = new Result<List<UserRoleDAO.Data>>(null,1,"test",NO_PARAM);
 		Mockito.doReturn(retVal).when(userRoleDAO).read(trans, objArr);	
-		setQuestionUserRoleDao(ques, userRoleDAO);
 		
 		Function funcObj = new Function(trans, ques);
 		funcObj.urDBLookup.get(trans, objArr);
@@ -2202,17 +1682,6 @@ public class JU_Function {
 	
 	@Test
 	public void testPerformFutureOp() {
-		Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
-		Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).debug();
-		Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).info();
-		Mockito.doReturn(Mockito.mock(Properties.class)).when(access).getProperties();
-		Mockito.doReturn("test.test").when(access).getProperty(Config.AAF_ROOT_NS,"org.osaaf.aaf");
-		try {
-			Define.set(access);
-		} catch (CadiException e) {
-			// TODO Auto-generated catch block
-			e.printStackTrace();
-		}
 		FutureDAO.Data futureDataDaoObj = new FutureDAO.Data();
 		futureDataDaoObj.memo="test";
 		futureDataDaoObj.target = "test";
@@ -2240,21 +1709,17 @@ public class JU_Function {
 		
         FutureDAO.Data futureData = new FutureDAO.Data();
 //		data.memo = "test";
-		FutureDAO futureDaoObj = Mockito.mock(FutureDAO.class);
-		Result<FutureDAO.Data> retValFuture = new Result<FutureDAO.Data>(futureData,0,"test",new String[0]);
-		Mockito.doReturn(retValFuture).when(futureDaoObj).delete(Mockito.any(), Mockito.any( FutureDAO.Data.class), Mockito.anyBoolean());
-		setQuestionFutureDao(ques, futureDaoObj);
+		Result<FutureDAO.Data> retValFuture = new Result<FutureDAO.Data>(futureData,0,"test",NO_PARAM);
+		Mockito.doReturn(retValFuture).when(futureDAO).delete(Mockito.any(), Mockito.any( FutureDAO.Data.class), Mockito.anyBoolean());
 		
-		CachedUserRoleDAO userRoleDAO = Mockito.mock(CachedUserRoleDAO.class);
 //		List<NsDAO.Data> dataAl = new ArrayList<NsDAO.Data>();
 //		NsDAO.Data dataObj = new NsDAO.Data();
 //		dataObj.type=1;
 //		dataAl.add(dataObj);
-		Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(null,1,"test",new String[0]);
+		Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(null,1,"test",NO_PARAM);
 		Mockito.doReturn(retVal).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());		
-		setQuestionUserRoleDao(ques, userRoleDAO);
 //		
-//		Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(null,0,"test",new String[0]);
+//		Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(null,0,"test",NO_PARAM);
 //		Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,retVal.value.get(0), Access.write);
 //		
 		Function funcObj = new Function(trans, ques);
@@ -2291,8 +1756,8 @@ public class JU_Function {
 		result = funcObj.performFutureOp(trans, FUTURE_OP.A, futureDataDaoObj, lookupApprovalObj, lookupUserObj);
 		assertTrue(result.status == 0);
 		
-		retValFuture = new Result<FutureDAO.Data>(futureData,1,"test",new String[0]);
-		Mockito.doReturn(retValFuture).when(futureDaoObj).delete(Mockito.any(), Mockito.any( FutureDAO.Data.class), Mockito.anyBoolean());
+		retValFuture = new Result<FutureDAO.Data>(futureData,1,"test",NO_PARAM);
+		Mockito.doReturn(retValFuture).when(futureDAO).delete(Mockito.any(), Mockito.any( FutureDAO.Data.class), Mockito.anyBoolean());
 		result = funcObj.performFutureOp(trans, FUTURE_OP.A, futureDataDaoObj, lookupApprovalObj, lookupUserObj);
 		System.out.println(result);
 		assertTrue(result.status == 0);
diff --git a/auth/auth-cass/src/test/java/org/onap/aaf/auth/dao/hl/JU_PermLookup.java b/auth/auth-cass/src/test/java/org/onap/aaf/auth/dao/hl/JU_PermLookup.java
index e63d4b52..9313af7a 100644
--- a/auth/auth-cass/src/test/java/org/onap/aaf/auth/dao/hl/JU_PermLookup.java
+++ b/auth/auth-cass/src/test/java/org/onap/aaf/auth/dao/hl/JU_PermLookup.java
@@ -64,12 +64,21 @@ public class JU_PermLookup {
 	
 	@Mock
 	Access access;
+
+	@Mock
+	CachedRoleDAO roleDAO;
+
+	@Mock
+	CachedUserRoleDAO userRoleDAO;
 	
 	Function f;
 	
 	@Before
 	public void setUp() throws Exception {
 		initMocks(this);
+		Mockito.doReturn(userRoleDAO).when(q).userRoleDAO();
+		Mockito.doReturn(roleDAO).when(q).roleDAO();
+		
 		try {
 			Mockito.doReturn("0.0").when(access).getProperty("aaf_root_ns","org.osaaf.aaf");
 			Mockito.doReturn(new Properties()).when(access).getProperties();
@@ -106,18 +115,18 @@ public class JU_PermLookup {
 	}
 	
 	
-	@Test
-	public void testPerm() {
-		
-		PermLookup cassExecutorObj =PermLookup.get(trans, q,"");
-		
-//		System.out.println(cassExecutorObj);
-//		assertFalse(retVal);
-	}
+//	@Test
+//	public void testPerm() {
+//		
+//		PermLookup cassExecutorObj =PermLookup.get(trans, q,"");
+//		
+////		System.out.println(cassExecutorObj);
+////		assertFalse(retVal);
+//	}
 	
 	@Test
 	public void testGetUserRole() {
-		q.userRoleDAO = Mockito.mock(CachedUserRoleDAO.class);
+		@SuppressWarnings("unchecked")
 		Result<List<UserRoleDAO.Data>> retVal1 = Mockito.mock(Result.class);
 		retVal1.value = new ArrayList<UserRoleDAO.Data>();
 		UserRoleDAO.Data dataObj = Mockito.mock( UserRoleDAO.Data.class);
@@ -126,7 +135,7 @@ public class JU_PermLookup {
 		
 		retVal1.value.add(dataObj);
 		Mockito.doReturn(true).when(retVal1).isOKhasData();
-		Mockito.doReturn(retVal1).when(q.userRoleDAO).readByUser(trans,"");
+		Mockito.doReturn(retVal1).when(userRoleDAO).readByUser(trans,"");
 		PermLookup cassExecutorObj =PermLookup.get(trans, q,"");
 		Result<List<UserRoleDAO.Data>> userRoles = cassExecutorObj.getUserRoles();
 		
@@ -136,12 +145,12 @@ public class JU_PermLookup {
 	
 	@Test
 	public void testGetUserRolesFirstIf() {
-		q.userRoleDAO = Mockito.mock(CachedUserRoleDAO.class);
+		@SuppressWarnings("unchecked")
 		Result<List<UserRoleDAO.Data>> retVal1 = Mockito.mock(Result.class);
 		retVal1.value = new ArrayList<UserRoleDAO.Data>();
 				
 		Mockito.doReturn(false).when(retVal1).isOKhasData();
-		Mockito.doReturn(retVal1).when(q.userRoleDAO).readByUser(trans,"");
+		Mockito.doReturn(retVal1).when(userRoleDAO).readByUser(trans,"");
 		PermLookup cassExecutorObj =PermLookup.get(trans, q,"");
 		Result<List<UserRoleDAO.Data>> userRoles = cassExecutorObj.getUserRoles();
 		
@@ -151,7 +160,7 @@ public class JU_PermLookup {
 	
 	@Test
 	public void testGetUserRolesSecondIf() {
-		q.userRoleDAO = Mockito.mock(CachedUserRoleDAO.class);
+		@SuppressWarnings("unchecked")
 		Result<List<UserRoleDAO.Data>> retVal1 = Mockito.mock(Result.class);
 		retVal1.value = new ArrayList<UserRoleDAO.Data>();
 		UserRoleDAO.Data dataObj = Mockito.mock( UserRoleDAO.Data.class);
@@ -164,7 +173,7 @@ public class JU_PermLookup {
 		
 		retVal1.value.add(dataObj);
 		Mockito.doReturn(true).when(retVal1).isOKhasData();
-		Mockito.doReturn(retVal1).when(q.userRoleDAO).readByUser(trans,"");
+		Mockito.doReturn(retVal1).when(userRoleDAO).readByUser(trans,"");
 		PermLookup cassExecutorObj =PermLookup.get(trans, q,"");
 		Result<List<UserRoleDAO.Data>> userRoles = cassExecutorObj.getUserRoles();
 		
@@ -178,7 +187,7 @@ public class JU_PermLookup {
 	
 	@Test
 	public void testGetRole() {
-		q.userRoleDAO = Mockito.mock(CachedUserRoleDAO.class);
+		@SuppressWarnings("unchecked")
 		Result<List<UserRoleDAO.Data>> retVal1 = Mockito.mock(Result.class);
 		retVal1.value = new ArrayList<UserRoleDAO.Data>();
 		UserRoleDAO.Data dataObj = Mockito.mock( UserRoleDAO.Data.class);
@@ -188,7 +197,7 @@ public class JU_PermLookup {
 		retVal1.value.add(dataObj);
 		Mockito.doReturn(false).when(retVal1).isOKhasData();
 		Mockito.doReturn(true).when(retVal1).isOK();
-		Mockito.doReturn(retVal1).when(q.userRoleDAO).readByUser(trans,"");
+		Mockito.doReturn(retVal1).when(userRoleDAO).readByUser(trans,"");
 		PermLookup cassExecutorObj =PermLookup.get(trans, q,"");
 		Result<List<RoleDAO.Data>> userRoles = cassExecutorObj.getRoles();
 		
@@ -198,8 +207,7 @@ public class JU_PermLookup {
 	
 	@Test
 	public void testGetRoleFirstIf() {
-		q.userRoleDAO = Mockito.mock(CachedUserRoleDAO.class);
-		q.roleDAO = Mockito.mock(CachedRoleDAO.class);
+		@SuppressWarnings("unchecked")
 		Result<List<UserRoleDAO.Data>> retVal1 = Mockito.mock(Result.class);
 		retVal1.value = new ArrayList<UserRoleDAO.Data>();
 		UserRoleDAO.Data dataObj = Mockito.mock( UserRoleDAO.Data.class);
@@ -211,8 +219,8 @@ public class JU_PermLookup {
 		retVal1.value.add(dataObj);
 		Mockito.doReturn(false).when(retVal1).isOKhasData();
 		Mockito.doReturn(false).when(retVal1).isOK();
-		Mockito.doReturn(retVal1).when(q.userRoleDAO).readByUser(trans,"");
-		Mockito.doReturn(retVal1).when(q.roleDAO).read(trans,"","");
+		Mockito.doReturn(retVal1).when(userRoleDAO).readByUser(trans,"");
+		Mockito.doReturn(retVal1).when(roleDAO).read(trans,"","");
 		PermLookup cassExecutorObj =PermLookup.get(trans, q,"");
 		Result<List<RoleDAO.Data>> userRoles = cassExecutorObj.getRoles();
 		
@@ -222,8 +230,7 @@ public class JU_PermLookup {
 	
 	@Test
 	public void testGetRoleSecondIf() {
-		q.userRoleDAO = Mockito.mock(CachedUserRoleDAO.class);
-		q.roleDAO = Mockito.mock(CachedRoleDAO.class);
+		@SuppressWarnings("unchecked")
 		Result<List<UserRoleDAO.Data>> retVal1 = Mockito.mock(Result.class);
 		retVal1.value = new ArrayList<UserRoleDAO.Data>();
 		UserRoleDAO.Data dataObj = Mockito.mock( UserRoleDAO.Data.class);
@@ -235,8 +242,8 @@ public class JU_PermLookup {
 		retVal1.value.add(dataObj);
 		Mockito.doReturn(false).when(retVal1).isOKhasData();
 		Mockito.doReturn(true).when(retVal1).isOK();
-		Mockito.doReturn(retVal1).when(q.userRoleDAO).readByUser(trans,"");
-		Mockito.doReturn(retVal1).when(q.roleDAO).read(trans,"","");
+		Mockito.doReturn(retVal1).when(userRoleDAO).readByUser(trans,"");
+		Mockito.doReturn(retVal1).when(roleDAO).read(trans,"","");
 		PermLookup cassExecutorObj =PermLookup.get(trans, q,"");
 		Result<List<RoleDAO.Data>> userRoles = cassExecutorObj.getRoles();
 		userRoles = cassExecutorObj.getRoles();
@@ -246,12 +253,12 @@ public class JU_PermLookup {
 	}
 	@Test
 	public void testGetPerms() {
-		q.userRoleDAO = Mockito.mock(CachedUserRoleDAO.class);
+		@SuppressWarnings("unchecked")
 		Result<List<UserRoleDAO.Data>> retVal1 = Mockito.mock(Result.class);
 		retVal1.value = new ArrayList<UserRoleDAO.Data>();
 		Mockito.doReturn(false).when(retVal1).isOKhasData();
 		Mockito.doReturn(true).when(retVal1).isOK();
-		Mockito.doReturn(retVal1).when(q.userRoleDAO).readByUser(trans,"");
+		Mockito.doReturn(retVal1).when(userRoleDAO).readByUser(trans,"");
 		PermLookup cassExecutorObj =PermLookup.get(trans, q,"");
 		Result<Set<String>> userRoles = cassExecutorObj.getPermNames();
 		userRoles = cassExecutorObj.getPermNames();
@@ -261,7 +268,7 @@ public class JU_PermLookup {
 	}
 	@Test
 	public void testGetPermsRrldOk() {
-		q.userRoleDAO = Mockito.mock(CachedUserRoleDAO.class);
+		@SuppressWarnings("unchecked")
 		Result<List<UserRoleDAO.Data>> retVal1 = Mockito.mock(Result.class);
 		retVal1.value = new ArrayList<UserRoleDAO.Data>();
 		UserRoleDAO.Data dataObj = Mockito.mock( UserRoleDAO.Data.class);
@@ -271,7 +278,7 @@ public class JU_PermLookup {
 		retVal1.value.add(dataObj);
 		Mockito.doReturn(false).when(retVal1).isOKhasData();
 		Mockito.doReturn(true).when(retVal1).isOK();
-		Mockito.doReturn(retVal1).when(q.userRoleDAO).readByUser(trans,"");
+		Mockito.doReturn(retVal1).when(userRoleDAO).readByUser(trans,"");
 		PermLookup cassExecutorObj =PermLookup.get(trans, q,"");
 		Result<Set<String>> userRoles = cassExecutorObj.getPermNames();
 		
@@ -280,10 +287,9 @@ public class JU_PermLookup {
 	}	
 
 
+	@SuppressWarnings("unchecked")
 	@Test
 	public void testGetPerm() {
-		q.userRoleDAO = Mockito.mock(CachedUserRoleDAO.class);
-		q.roleDAO = Mockito.mock(CachedRoleDAO.class);
 		Result<List<UserRoleDAO.Data>> retVal1 = Mockito.mock(Result.class);
 		Result<List<RoleDAO.Data>> retVal2 = Mockito.mock(Result.class);
 		
@@ -316,8 +322,8 @@ public class JU_PermLookup {
 		Mockito.doReturn(true).when(retVal1).isOKhasData();
 		Mockito.doReturn(true).when(retVal1).isOK();
 		Mockito.doReturn(true).when(retVal2).isOK();
-		Mockito.doReturn(retVal1).when(q.userRoleDAO).readByUser(trans,"");
-		Mockito.doReturn(retVal2).when(q.roleDAO).read(trans,"","");
+		Mockito.doReturn(retVal1).when(userRoleDAO).readByUser(trans,"");
+		Mockito.doReturn(retVal2).when(roleDAO).read(trans,"","");
 
 		
 		PermLookup cassExecutorObj =PermLookup.get(trans, q,"");
@@ -330,10 +336,9 @@ public class JU_PermLookup {
 		assertEquals(0,userRoles.status);
 	}
 	
+	@SuppressWarnings("unchecked")
 	@Test
 	public void testGetPermFalse() {
-		q.userRoleDAO = Mockito.mock(CachedUserRoleDAO.class);
-		q.roleDAO = Mockito.mock(CachedRoleDAO.class);
 		Result<List<UserRoleDAO.Data>> retVal1 = Mockito.mock(Result.class);
 		Result<List<RoleDAO.Data>> retVal2 = Mockito.mock(Result.class);
 		
@@ -366,8 +371,8 @@ public class JU_PermLookup {
 		Mockito.doReturn(true).when(retVal1).isOKhasData();
 		Mockito.doReturn(true).when(retVal1).isOK();
 		Mockito.doReturn(true).when(retVal2).isOK();
-		Mockito.doReturn(retVal1).when(q.userRoleDAO).readByUser(trans,"");
-		Mockito.doReturn(retVal2).when(q.roleDAO).read(trans,"","");
+		Mockito.doReturn(retVal1).when(userRoleDAO).readByUser(trans,"");
+		Mockito.doReturn(retVal2).when(roleDAO).read(trans,"","");
 
 		
 		PermLookup cassExecutorObj =PermLookup.get(trans, q,"");