X-Git-Url: https://gerrit.onap.org/r/gitweb?a=blobdiff_plain;f=auth%2Fauth-cass%2Fsrc%2Ftest%2Fjava%2Forg%2Fonap%2Faaf%2Fauth%2Fdao%2Fhl%2FJU_Function.java;h=ab7b2e59a0354713c34345a70397ca7880a4df74;hb=ff1417ff60baee231a28272f9a16ef2c9c8ea0a2;hp=df370b7ed9626622188af5fccaf90b3b7b8bfb30;hpb=da6154df2951bbdedea753f588d41153e3582ef5;p=aaf%2Fauthz.git

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 df370b7e..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
@@ -22,21 +22,24 @@
 
 package org.onap.aaf.auth.dao.hl;
 
+import static org.junit.Assert.assertNull;
 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.Modifier;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
 import java.text.DateFormat;
 import java.text.ParseException;
 import java.text.SimpleDateFormat;
 import java.util.ArrayList;
+import java.util.Date;
 import java.util.GregorianCalendar;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Properties;
 import java.util.Set;
+import java.util.UUID;
 
 import org.junit.Before;
 import org.junit.Test;
@@ -48,13 +51,19 @@ import org.onap.aaf.auth.dao.cached.CachedNSDAO;
 import org.onap.aaf.auth.dao.cached.CachedPermDAO;
 import org.onap.aaf.auth.dao.cached.CachedRoleDAO;
 import org.onap.aaf.auth.dao.cached.CachedUserRoleDAO;
+import org.onap.aaf.auth.dao.cass.ApprovalDAO;
 import org.onap.aaf.auth.dao.cass.CredDAO;
+import org.onap.aaf.auth.dao.cass.FutureDAO;
 import org.onap.aaf.auth.dao.cass.Namespace;
 import org.onap.aaf.auth.dao.cass.NsDAO;
+import org.onap.aaf.auth.dao.cass.NsSplit;
+import org.onap.aaf.auth.dao.cass.NsType;
 import org.onap.aaf.auth.dao.cass.PermDAO;
 import org.onap.aaf.auth.dao.cass.RoleDAO;
 import org.onap.aaf.auth.dao.cass.Status;
 import org.onap.aaf.auth.dao.cass.UserRoleDAO;
+import org.onap.aaf.auth.dao.hl.Function.FUTURE_OP;
+import org.onap.aaf.auth.dao.hl.Function.Lookup;
 import org.onap.aaf.auth.dao.hl.Question.Access;
 import org.onap.aaf.auth.env.AuthzTrans;
 import org.onap.aaf.auth.env.AuthzTrans.REQD_TYPE;
@@ -69,10 +78,10 @@ import org.onap.aaf.cadi.config.Config;
 import org.onap.aaf.misc.env.APIException;
 import org.onap.aaf.misc.env.LogTarget;
 
-import io.netty.util.internal.SystemPropertyUtil;
-
 public class JU_Function {
 
+	private static final Object NO_PARAM = new Object[0];
+	
 	@Mock
     AuthzTrans trans;
 	@Mock
@@ -81,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);
@@ -123,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>();
@@ -147,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);
@@ -162,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>();
@@ -182,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);
@@ -199,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>();
@@ -255,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>();
@@ -287,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);
@@ -295,149 +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();
-		}
-	}
+
 	@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>();
@@ -450,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";
@@ -470,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 {
@@ -485,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);
@@ -515,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";
@@ -559,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 {
@@ -591,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);
 		
@@ -598,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>();
@@ -620,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";
@@ -667,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 {
@@ -697,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);
@@ -705,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);
@@ -783,104 +593,1174 @@ 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<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(null,0,"test",new String[0]);
-//		Mockito.doReturn(retVal2).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 == 1);
-//
-//		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);
-//		
-//		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);
-//		
-//		CachedRoleDAO cachedRoleDAO = Mockito.mock(CachedRoleDAO.class);
-//		List<RoleDAO.Data> dataObj1 = new ArrayList<>();
-//		RoleDAO.Data indData1 = new RoleDAO.Data();
-//		indData1.ns = "test";
-//		indData1.name = "test";
-//		Set<String> permsSet = new HashSet<>();
-//		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");		
-//		setQuestionCachedRoleDao(ques, cachedRoleDAO);
-//		
-//		funcObj = new Function(trans, ques);
-//		result = funcObj.deleteNS(trans, "test");
-//		assertTrue(result.status == Status.ERR_DependencyExists);
-//
-//		Mockito.doReturn(true).when(trans).requested(REQD_TYPE.force);
-//		funcObj = new Function(trans, ques);
-//		result = funcObj.deleteNS(trans, "test");
-//		assertTrue(result.status == 2);
-//	}
-//	@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<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(null,0,"test",new String[0]);
-//		Mockito.doReturn(retVal2).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 == 1);
-//		
-//	}
+	
+	@Test
+	public void test4DeleteNsMayUserSuc() {
+		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",NO_PARAM);
+		Mockito.doReturn(retVal).when(nsDAO).read(Mockito.any(), Mockito.anyString());		
+		
+		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.deleteNS(trans, "test");
+		assertTrue(result.status == 1);
+
+		Mockito.doReturn(true).when(ques).isGranted(Mockito.any(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString());
+
+		Mockito.doReturn(retVal2).when(credDAO).readNS(Mockito.any(), Mockito.anyString());		
+
+		Result<List<PermDAO.Data>> retVal5 = new Result<List<PermDAO.Data>>(null,0,"test",NO_PARAM);
+		Mockito.doReturn(retVal5).when(permDAO).readNS(trans, "test");
+		
+		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",NO_PARAM);
+		Mockito.doReturn(retVal4).when(userRoleDAO).readByRole(trans, "test");
+		
+		List<RoleDAO.Data> dataObj1 = new ArrayList<>();
+		RoleDAO.Data indData1 = new RoleDAO.Data();
+		indData1.ns = "test";
+		indData1.name = "test";
+		Set<String> permsSet = new HashSet<>();
+		permsSet.add("test|test");
+		indData1.perms = permsSet;
+		dataObj1.add(indData1);
+		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);
+		
+		Mockito.doReturn(retVal4).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());	
+		
+		Mockito.doReturn(true).when(trans).requested(REQD_TYPE.force);
+		funcObj = new Function(trans, ques);
+		result = funcObj.deleteNS(trans, "test");
+		assertNull(result);
+	}
+	@Test
+	public void test4DeleteNsDrivensFailure() {
+		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",NO_PARAM);
+		Mockito.doReturn(retVal).when(nsDAO).read(Mockito.any(), Mockito.anyString());		
+		
+		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.deleteNS(trans, "test");
+		assertTrue(result.status == 1);
+
+		Mockito.doReturn(true).when(ques).isGranted(Mockito.any(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString());
+
+		Mockito.doReturn(retVal2).when(credDAO).readNS(Mockito.any(), Mockito.anyString());		
+
+		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",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);
+		
+		
+		List<RoleDAO.Data> dataObj1 = new ArrayList<>();
+		RoleDAO.Data indData1 = new RoleDAO.Data();
+		indData1.ns = "test";
+		indData1.name = "test";
+		Set<String> permsSet = new HashSet<>();
+		permsSet.add("test|test");
+		indData1.perms = permsSet;
+		dataObj1.add(indData1);
+		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");
+		assertTrue(result.status == Status.ERR_DependencyExists);
+		
+		NsDAO.Data data = new NsDAO.Data();
+		data.name="test";
+		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);
+		funcObj = new Function(trans, ques);
+		result = funcObj.deleteNS(trans, "test.test");
+		assertTrue(result.status == 1);
+	}
+
+	@Test
+	public void test4DeleteNsWithDot() {
+		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",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",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);
+		Result<Void> result = funcObj.deleteNS(trans, "test");
+		assertTrue(result.status == 1);
+
+		Mockito.doReturn(true).when(ques).isGranted(Mockito.any(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString());
+
+		Mockito.doReturn(retVal21).when(credDAO).readNS(Mockito.any(), Mockito.anyString());	
+		Mockito.doReturn(retVal21).when(credDAO).delete(Mockito.any(), Mockito.any(), Mockito.anyBoolean());		
+
+		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 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);
+		
+		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",NO_PARAM);
+		Mockito.doReturn(retVal4).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());
+		Mockito.doReturn(retVal4).when(userRoleDAO).readByUser(Mockito.any(), Mockito.anyString());
+		
+		List<RoleDAO.Data> dataObj1 = new ArrayList<>();
+		RoleDAO.Data indData1 = new RoleDAO.Data();
+		indData1.ns = "test";
+		indData1.name = "admin";
+		Set<String> permsSet = new HashSet<>();
+		permsSet.add("test|test");
+		indData1.perms = permsSet;
+		dataObj1.add(indData1);
+		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");
+		assertTrue(result.status == Status.ERR_DependencyExists);
+		
+		NsDAO.Data data = new NsDAO.Data();
+		data.name="test";
+		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);
+		funcObj = new Function(trans, ques);
+		result = funcObj.deleteNS(trans, "test.test");
+		assertNull(result);
+	}
+	
+	@Test
+	public void testGetOwners() {
+//		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",NO_PARAM);
+		Mockito.doReturn(retVal).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());		
+//		
+//		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<List<String>> result = funcObj.getOwners(trans, "test", false);
+		assertTrue(result.status == 1);
+//		
+	}
+	
+	@Test
+	public void testDelOwner() {
+		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));	
+
+		NsDAO.Data data = new NsDAO.Data();
+		data.name="test";
+		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",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",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",NO_PARAM);
+		Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
+		result = funcObj.delOwner(trans, "test", "test");
+		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");
+//		
+	}
+	
+	@Test
+	public void testGetAdmins() {
+//		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",NO_PARAM);
+		Mockito.doReturn(retVal).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());		
+//		
+//		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<List<String>> result = funcObj.getAdmins(trans, "test", false);
+		assertTrue(result.status == 1);
+//		
+	}
+	
+	@Test
+	public void testDelAdmin() {
+		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));	
+
+		NsDAO.Data data = new NsDAO.Data();
+		data.name="test";
+		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",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",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",NO_PARAM);
+		Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
+		result = funcObj.delOwner(trans, "test", "test");
+		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");
+//		
+	}
+	
+	@Test
+	public void testMovePerms() {
+//		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",NO_PARAM);
+		Mockito.doReturn(retVal).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());		
+		
+		Mockito.doReturn(retVal).when(roleDAO).delPerm(Mockito.any(), Mockito.any(), Mockito.any());	
+		
+		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",NO_PARAM);
+		
+		invokeMovePerms(nsDataObj, sb, retVal1);
+		
+		List<PermDAO.Data> dataObj5 = new ArrayList<>();
+		PermDAO.Data indData5 = new PermDAO.Data();
+		indData5.ns = "test";
+		indData5.type = "test";
+		Set<String> rolesSet = new HashSet<>();
+		rolesSet.add("testRole");
+		indData5.roles = rolesSet;
+		dataObj5.add(indData5);
+		indData5 = new PermDAO.Data();
+		indData5.ns = "test";
+		indData5.type = "access";
+		dataObj5.add(indData5);
+		retVal1 = new Result<List<PermDAO.Data>>(dataObj5,0,"test",NO_PARAM);
+
+		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",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",NO_PARAM);
+		Mockito.doReturn(retVal4).when(permDAO).create(Mockito.any(), Mockito.any());	
+		invokeMovePerms(nsDataObj, sb, retVal1);
+		
+		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);
+		
+	}
+	
+	private void invokeMovePerms(NsDAO.Data nsDataObj, StringBuilder sb,Result<List<PermDAO.Data>> retVal1) {
+		Function funcObj = new Function(trans, ques);
+		Method met;
+		try {
+			met = Function.class.getDeclaredMethod("movePerms", AuthzTrans.class, NsDAO.Data.class, StringBuilder.class, Result.class);
+			met.setAccessible(true);
+			met.invoke(funcObj, trans, nsDataObj, sb, retVal1);
+		} catch (NoSuchMethodException | SecurityException e) {
+			// TODO Auto-generated catch block
+			e.printStackTrace();
+		} catch (IllegalAccessException e) {
+			// TODO Auto-generated catch block
+			e.printStackTrace();
+		} catch (IllegalArgumentException e) {
+			// TODO Auto-generated catch block
+			e.printStackTrace();
+		} catch (InvocationTargetException e) {
+			// TODO Auto-generated catch block
+			e.printStackTrace();
+		}
+	}
+	
+	@Test
+	public void testMoveRoles() {
+//		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",NO_PARAM);
+		Mockito.doReturn(retVal).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());		
+		
+		Mockito.doReturn(retVal).when(roleDAO).delPerm(Mockito.any(), 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",NO_PARAM);
+		
+		invokeMoveRoles(nsDataObj, sb, retVal1);
+		
+		List<RoleDAO.Data> dataObj5 = new ArrayList<>();
+		RoleDAO.Data indData5 = new RoleDAO.Data();
+		indData5.ns = "test";
+		indData5.name = "test";
+		Set<String> rolesSet = new HashSet<>();
+		rolesSet.add("testRole");
+		indData5.perms = rolesSet;
+		dataObj5.add(indData5);
+		indData5 = new RoleDAO.Data();
+		indData5.ns = "test";
+		indData5.name = "admin";
+		dataObj5.add(indData5);
+		retVal1 = new Result<List<RoleDAO.Data>>(dataObj5,0,"test",NO_PARAM);
+		
+		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",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",NO_PARAM);
+		Mockito.doReturn(retVal4).when(roleDAO).create(Mockito.any(), Mockito.any());	
+		invokeMoveRoles(nsDataObj, sb, retVal1);
+		
+		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);
+		
+	}
+	
+	private void invokeMoveRoles(NsDAO.Data nsDataObj, StringBuilder sb,Result<List<RoleDAO.Data>> retVal1) {
+		Function funcObj = new Function(trans, ques);
+		Method met;
+		try {
+			met = Function.class.getDeclaredMethod("moveRoles", AuthzTrans.class, NsDAO.Data.class, StringBuilder.class, Result.class);
+			met.setAccessible(true);
+			met.invoke(funcObj, trans, nsDataObj, sb, retVal1);
+		} catch (NoSuchMethodException | SecurityException e) {
+			// TODO Auto-generated catch block
+			e.printStackTrace();
+		} catch (IllegalAccessException e) {
+			// TODO Auto-generated catch block
+			e.printStackTrace();
+		} catch (IllegalArgumentException e) {
+			// TODO Auto-generated catch block
+			e.printStackTrace();
+		} catch (InvocationTargetException e) {
+			// TODO Auto-generated catch block
+			e.printStackTrace();
+		}
+	}
+	
+	@Test
+	public void testCreatePerm() {
+		try {
+			Define.set(access);
+		} catch (CadiException e) {
+			// TODO Auto-generated catch block
+			e.printStackTrace();
+		}
+		List<PermDAO.Data> dataAl = new ArrayList<PermDAO.Data>();
+		PermDAO.Data perm = new PermDAO.Data();
+		Set<String> rolesSet = new HashSet<>();
+		rolesSet.add("testRole");
+		perm.roles = rolesSet;
+//		perm.type=1
+		dataAl.add(perm);
+		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());
+		
+		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(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",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",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",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(permDAO).read(trans, perm);	
+		result = funcObj.createPerm(trans, perm, true);
+		assertTrue(result.status == 1);
+
+		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",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() {
+		try {
+			Define.set(access);
+		} catch (CadiException e) {
+			// TODO Auto-generated catch block
+			e.printStackTrace();
+		}
+		List<PermDAO.Data> dataAl = new ArrayList<PermDAO.Data>();
+		PermDAO.Data perm = new PermDAO.Data();
+		Set<String> rolesSet = new HashSet<>();
+		rolesSet.add("testRole");
+		perm.roles = rolesSet;
+//		perm.type=1
+		dataAl.add(perm);
+		
+		Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(null,1,"test",NO_PARAM);
+		Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,perm, Access.write);
+		
+//		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",NO_PARAM);
+		Mockito.doReturn(retVal).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());		
+		
+		Function funcObj = new Function(trans, ques);
+		Result<Void> result = funcObj.deletePerm(trans, perm, true,false);
+		assertTrue(result.status == 1);
+
+//		Mockito.doReturn(retVal).when(cachedPermDAO).create(Mockito.any(), Mockito.any());
+		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",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",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",NO_PARAM);
+		Mockito.doReturn(retValNs).when(ques).deriveNsSplit(Mockito.any(), Mockito.anyString());
+		
+		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(roleDAO).delPerm(Mockito.any(), Mockito.any(), Mockito.any());	
+		result = funcObj.deletePerm(trans, perm, true,false);
+		assertNull(result);	
+		
+		result = funcObj.deletePerm(trans, perm, false,false);
+//		assertTrue(result.status == 1);
+	}
+	
+	@Test
+	public void testDeleteRole() {
+		try {
+			Define.set(access);
+		} catch (CadiException e) {
+			// TODO Auto-generated catch block
+			e.printStackTrace();
+		}
+
+		List<UserRoleDAO.Data> dataAlUser = new ArrayList<UserRoleDAO.Data>();
+		UserRoleDAO.Data roleUser = new UserRoleDAO.Data();
+		Set<String> rolesSetUser = new HashSet<>();
+		rolesSetUser.add("testRole|test|test");
+//		perm.roles = rolesSet;
+//		perm.type=1
+		dataAlUser.add(roleUser);
+		
+		List<RoleDAO.Data> dataAl = new ArrayList<RoleDAO.Data>();
+		RoleDAO.Data role = new RoleDAO.Data();
+		Set<String> rolesSet = new HashSet<>();
+		rolesSet.add("testRole|test|test");
+		role.perms = rolesSet;
+//		perm.roles = rolesSet;
+//		perm.type=1
+		dataAl.add(role);
+		
+		Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(null,1,"test",NO_PARAM);
+		Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,role, Access.write);
+		
+//		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",NO_PARAM);
+		Mockito.doReturn(retVal).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());		
+//		
+//		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);
+
+		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",NO_PARAM);
+		Mockito.doReturn(retVal3).when(ques).deriveNsSplit(Mockito.any(), Mockito.anyString());
+//		Mockito.doReturn(retVal).when(cachedPermDAO).create(Mockito.any(), Mockito.any());
+		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(permDAO).delRole(Mockito.any(), Mockito.any(),Mockito.any());
+		result = funcObj.deleteRole(trans, role, true, true);
+		assertNull(result);
+
+		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",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);
+	}
+	
+	@Test
+	public void testAddPermToRole() {
+		List<PermDAO.Data> dataAlPerm = new ArrayList<PermDAO.Data>();
+		PermDAO.Data rolePerm = new PermDAO.Data();
+		Set<String> rolesSetUser = new HashSet<>();
+		rolesSetUser.add("testRole|test|test");
+//		perm.roles = rolesSet;
+//		perm.type=1
+		dataAlPerm.add(rolePerm);
+		
+		List<RoleDAO.Data> dataAl = new ArrayList<RoleDAO.Data>();
+		RoleDAO.Data role = new RoleDAO.Data();
+		Set<String> rolesSet = new HashSet<>();
+		rolesSet.add("17623");
+		role.perms = rolesSet;
+//		perm.roles = rolesSet;
+//		perm.type=1
+		dataAl.add(role);
+		
+		NsDAO.Data nsObj = new NsDAO.Data();
+		nsObj.name="test";
+		NsDAO.Data nsObj1 = new NsDAO.Data();
+		nsObj1.name="test12";
+		
+//		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",NO_PARAM);
+		Mockito.doReturn(retVal).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());		
+
+		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",NO_PARAM);
+		Mockito.doReturn(retVal3).when(ques).mayUser(trans, null,rolePerm, Access.write);
+		Mockito.doReturn(retVal3).when(ques).mayUser(trans, null,role, Access.write);
+		
+		Function funcObj = new Function(trans, ques);
+		Result<Void> result = funcObj.addPermToRole(trans, role, rolePerm, false);
+		assertTrue(result.status == 1);
+
+		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",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",NO_PARAM);
+		Mockito.doReturn(retVal2).when(ques).deriveFirstNsForType(trans, role.ns, NsType.COMPANY);
+		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",NO_PARAM);
+		Mockito.doReturn(retVal3).when(ques).mayUser(trans, null,rolePerm, Access.write);
+		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);
+		
+//		Mockito.doReturn(retVal).when(cachedPermDAO).create(Mockito.any(), Mockito.any());
+		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",NO_PARAM);
+		Mockito.doReturn(retValPerm).when(permDAO).read(Mockito.any(), Mockito.any(PermDAO.Data.class));	
+		
+		Mockito.doReturn(retVal3).when(roleDAO).read(trans, role);
+		
+		result = funcObj.addPermToRole(trans, role, rolePerm, true);
+		assertTrue(result.status == 22);
+
+		Mockito.doReturn(true).when(trans).requested(REQD_TYPE.force);
+		result = funcObj.addPermToRole(trans, role, rolePerm, true);
+		assertTrue(result.status == 2);
+		
+		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(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",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",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() {
+		List<PermDAO.Data> dataAlPerm = new ArrayList<PermDAO.Data>();
+		PermDAO.Data rolePerm = new PermDAO.Data();
+		Set<String> rolesSetUser = new HashSet<>();
+		rolesSetUser.add("testRole|test|test");
+//		perm.roles = rolesSet;
+//		perm.type=1
+		dataAlPerm.add(rolePerm);
+		
+		List<RoleDAO.Data> dataAl = new ArrayList<RoleDAO.Data>();
+		RoleDAO.Data role = new RoleDAO.Data();
+		Set<String> rolesSet = new HashSet<>();
+		rolesSet.add("17623");
+		role.perms = rolesSet;
+		dataAl.add(role);
+		
+//		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",NO_PARAM);
+		Mockito.doReturn(retVal).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());		
+
+		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);
+		
+		Function funcObj = new Function(trans, ques);
+		Result<Void> result = funcObj.delPermFromRole(trans, role, rolePerm, false);
+		assertTrue(result.status == Status.ERR_Denied);
+		
+		Mockito.doReturn(retValFail).when(ques).mayUser(trans, null,rolePerm, Access.write);
+		Mockito.doReturn(retValSuc).when(ques).mayUser(trans, null,role, Access.write);		
+		
+		Mockito.doReturn(retValFail).when(roleDAO).read(trans, role);
+		
+		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",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",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);
+		
+		role.perms = null;
+		dataAl.add(role);
+		rolesSet.add("null|null|null|null");
+		role.perms = rolesSet;
+		dataAl.add(role);
+		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);
+		
+		Mockito.doReturn(true).when(trans).requested(REQD_TYPE.force);	
+		result = funcObj.delPermFromRole(trans, role, rolePerm, true);
+		assertTrue(result.status == 1);
+		
+		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(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(permDAO).read(Mockito.any(), Mockito.any(PermDAO.Data.class));
+		result = funcObj.delPermFromRole(trans, role, rolePerm, true);
+		assertTrue(result.status == 0);
+		
+		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",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",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() {
+		List<UserRoleDAO.Data> urDataAl = new ArrayList<>();
+		UserRoleDAO.Data urData = new UserRoleDAO.Data();
+		urData.ns="test";
+		urData.rname="test";
+		urData.user="test";
+		urDataAl.add(urData);
+		
+		Organization org = Mockito.mock(Organization.class);
+		Mockito.doReturn(org).when(trans).org();
+		Mockito.doReturn(Mockito.mock(GregorianCalendar.class)).when(org).expiration(Mockito.any(), Mockito.any(), Mockito.anyString());
+		
+		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());		
+
+		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());		
+		
+		Function funcObj = new Function(trans, ques);
+		Result<Void> result = funcObj.addUserRole(trans, urData);
+		assertTrue(result.status == 1);
+		
+		urData.rname=Question.ADMIN;
+		result = funcObj.addUserRole(trans, urData);
+		assertTrue(result.status == 1);
+		
+		NsDAO.Data data = new NsDAO.Data();
+		data.name="test";
+		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 {
+			Mockito.doReturn(Mockito.mock(Identity.class)).when(org).getIdentity(trans, "test");
+		} catch (OrganizationException e) {
+			// TODO Auto-generated catch block
+			e.printStackTrace();
+		}
+		urData.rname=Question.OWNER;
+		result = funcObj.addUserRole(trans, urData);
+		assertTrue(result.status == 1);
+
+		Mockito.doReturn(retValSuc).when(userRoleDAO).create(Mockito.any(), Mockito.any(UserRoleDAO.Data.class));	
+		result = funcObj.addUserRole(trans, urData);
+		assertTrue(result.status == 0);
+
+		Mockito.doReturn(retVal).when(roleDAO).read(Mockito.any(), Mockito.anyString(), Mockito.anyString());
+		result = funcObj.addUserRole(trans, urData);
+		assertTrue(result.status == Status.ERR_RoleNotFound);
+		
+		Mockito.doReturn(retValSuc).when(userRoleDAO).read(Mockito.any(), Mockito.any(UserRoleDAO.Data.class));
+		result = funcObj.addUserRole(trans, urData);
+		assertTrue(result.status == Status.ERR_ConflictAlreadyExists);
+		
+		result = funcObj.addUserRole(trans, "test", "test", "test");
+		assertTrue(result.status == 1);
+		
+		try {
+			Mockito.doReturn(null).when(org).getIdentity(trans, "test");
+		} catch (OrganizationException e) {
+			// TODO Auto-generated catch block
+			e.printStackTrace();
+		}
+		result = funcObj.addUserRole(trans, "test", "test", "test");
+		assertTrue(result.status == Result.ERR_BadData);
+		
+		try {
+			Mockito.doThrow(OrganizationException.class).when(org).getIdentity(trans, "test");
+		} catch (OrganizationException e) {
+			// TODO Auto-generated catch block
+			e.printStackTrace();
+		}
+		result = funcObj.addUserRole(trans, "test", "test", "test");
+		assertTrue(result.status == 20);
+	}
+	
+	@Test
+	public void testExtendUserRole() {
+		List<UserRoleDAO.Data> urDataAl = new ArrayList<>();
+		UserRoleDAO.Data urData = new UserRoleDAO.Data();
+		urData.ns="test";
+		urData.rname="test";
+		urData.user="test";
+		urData.expires=new Date();
+		urDataAl.add(urData);
+		
+//		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",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());
+
+		Organization org = Mockito.mock(Organization.class);
+		Mockito.doReturn(org).when(trans).org();
+		Mockito.doReturn(Mockito.mock(GregorianCalendar.class)).when(org).expiration(Mockito.any(), Mockito.any());
+		
+		Function funcObj = new Function(trans, ques);
+		Result<Void> result = funcObj.extendUserRole(trans, urData, false);
+		assertNull(result);
+		
+		Mockito.doReturn(retVal).when(roleDAO).read(Mockito.any(), Mockito.anyString(), Mockito.anyString());
+		Mockito.doReturn(retValSuc).when(userRoleDAO).read(trans, urData);
+		result = funcObj.extendUserRole(trans, urData, true);
+		assertTrue(result.status == Status.ERR_RoleNotFound);
+		
+		Mockito.doReturn(retVal).when(userRoleDAO).read(trans, urData);
+		result = funcObj.extendUserRole(trans, urData, true);
+		assertTrue(result.status == Status.ERR_UserRoleNotFound);
+	}
+	
+	@SuppressWarnings("deprecation")
+	@Test
+	public void testGetUsersByRole() {
+		List<UserRoleDAO.Data> urDataAl = new ArrayList<>();
+		UserRoleDAO.Data urData = new UserRoleDAO.Data();
+		urData.ns="test";
+		urData.rname="test";
+		urData.user="test";
+		urData.expires=new Date();
+		urDataAl.add(urData);
+		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());		
+
+		Function funcObj = new Function(trans, ques);
+		Result<List<String>> result = funcObj.getUsersByRole(trans, "test", false);
+		assertTrue(result.status == 0);
+
+		result = funcObj.getUsersByRole(trans, "test", true);
+		assertTrue(result.status == 0);
+		
+		urData.expires=new Date(130,1,1);
+		result = funcObj.getUsersByRole(trans, "test", true);
+		assertTrue(result.status == 0);
+//		
+	}
+	@Test
+	public void testDelUserRole() {
+		List<UserRoleDAO.Data> urDataAl = new ArrayList<>();
+		UserRoleDAO.Data urData = new UserRoleDAO.Data();
+		urData.ns="test";
+		urData.rname="test";
+		urData.user="test";
+		urData.expires=new Date();
+		urDataAl.add(urData);
+		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));		
+
+		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",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);	
+//		
+	}
+	
+	@Test
+	public void testCreateFuture() {
+		FutureDAO.Data data = new FutureDAO.Data();
+		data.memo = "test";
+		NsDAO.Data nsd = new NsDAO.Data();
+		nsd.name = "test";
+		
+		List<UserRoleDAO.Data> urDataAl = new ArrayList<>();
+		UserRoleDAO.Data urData = new UserRoleDAO.Data();
+		urData.ns="test";
+		urData.rname="test";
+		urData.user="test";
+		urData.expires=new Date();
+		urDataAl.add(urData);
+		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));	
+
+		Function funcObj = new Function(trans, ques);
+		Result<String> result = funcObj.createFuture(trans, data, "test", "test", nsd, FUTURE_OP.A);
+		assertTrue(result.status == 20);
+
+		Identity iden=Mockito.mock(Identity.class);
+		try {
+			Mockito.doReturn(iden).when(org).getIdentity(trans, "test");
+			Mockito.doReturn("test").when(iden).mayOwn();
+		} catch (OrganizationException e) {
+			// TODO Auto-generated catch block
+			e.printStackTrace();
+		}
+		FutureDAO.Data futureData = new FutureDAO.Data();
+		data.memo = "test";
+		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";
+		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);
+		assertTrue(result.status == 0);
+		
+		result = funcObj.createFuture(trans, data, "test", "test", null, FUTURE_OP.A);
+		assertTrue(result.status == 20);
+
+		Mockito.doReturn(retValFail).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());
+		result = funcObj.createFuture(trans, data, "test", "test", nsd, FUTURE_OP.A);
+		assertTrue(result.status == Result.ERR_NotFound);
+		
+		Mockito.doReturn(retVal).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());
+		try {
+			Mockito.doReturn(null).when(org).getIdentity(trans, "test");
+		} catch (OrganizationException e) {
+			// TODO Auto-generated catch block
+			e.printStackTrace();
+		}
+		result = funcObj.createFuture(trans, data, "test", "test", nsd, FUTURE_OP.A);
+		assertTrue(result.status == Result.ERR_NotFound);
+		
+		try {
+			Mockito.doReturn(iden).when(org).getIdentity(trans, "test");
+		} catch (OrganizationException e) {
+			// TODO Auto-generated catch block
+			e.printStackTrace();
+		}
+		result = funcObj.createFuture(trans, data, "test", "test", nsd, FUTURE_OP.C);
+		assertTrue(result.status == 0);
+		
+		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() {
+		Object[] objArr = new Object[10];
+		List<UserRoleDAO.Data> urDataAl = new ArrayList<>();
+		UserRoleDAO.Data urData = new UserRoleDAO.Data();
+		urData.ns="test";
+		urData.rname="test";
+		urData.user="test";
+		urData.expires=new Date();
+		urDataAl.add(urData);
+		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);	
+		
+		Function funcObj = new Function(trans, ques);
+		funcObj.urDBLookup.get(trans, objArr);
+		
+		Mockito.doReturn(retValFail).when(userRoleDAO).read(trans, objArr);	
+		funcObj.urDBLookup.get(trans, objArr);
+	}
+	
+	@Test
+	public void testPerformFutureOp() {
+		FutureDAO.Data futureDataDaoObj = new FutureDAO.Data();
+		futureDataDaoObj.memo="test";
+		futureDataDaoObj.target = "test";
+		futureDataDaoObj.id = new UUID(10L,10L);
+		
+		final List<ApprovalDAO.Data> apprs = new ArrayList<>();
+		ApprovalDAO.Data approvalObj = new ApprovalDAO.Data();
+		approvalObj.status = "approved";
+		approvalObj.type = "owner";
+		apprs.add(approvalObj);
+		Lookup<List<ApprovalDAO.Data>> lookupApprovalObj = new Lookup<List<ApprovalDAO.Data>>() {
+            @Override
+            public List<ApprovalDAO.Data> get(AuthzTrans trans, Object ... keys) {
+                return apprs;
+            }
+        };
+        
+        final UserRoleDAO.Data userObj = new UserRoleDAO.Data();
+        Lookup<UserRoleDAO.Data> lookupUserObj = new Lookup<UserRoleDAO.Data>() {
+            @Override
+            public UserRoleDAO.Data get(AuthzTrans trans, Object ... keys) {
+                return userObj;
+            }
+        };
+		
+        FutureDAO.Data futureData = new FutureDAO.Data();
+//		data.memo = "test";
+		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());
+		
+//		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",NO_PARAM);
+		Mockito.doReturn(retVal).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());		
+//		
+//		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<Function.OP_STATUS> result = funcObj.performFutureOp(trans, FUTURE_OP.A, futureDataDaoObj, lookupApprovalObj, lookupUserObj);
+		assertTrue(result.status == 0);
+		
+		approvalObj.status = "approved";
+		approvalObj.type = "supervisor";
+		result = funcObj.performFutureOp(trans, FUTURE_OP.A, futureDataDaoObj, lookupApprovalObj, lookupUserObj);
+		assertTrue(result.status == 0);
+		
+		approvalObj.status = "approved";
+		approvalObj.type = "";
+		result = funcObj.performFutureOp(trans, FUTURE_OP.A, futureDataDaoObj, lookupApprovalObj, lookupUserObj);
+		assertTrue(result.status == 0);
+		
+		approvalObj.status = "pending";
+		approvalObj.type = "supervisor";
+		result = funcObj.performFutureOp(trans, FUTURE_OP.A, futureDataDaoObj, lookupApprovalObj, lookupUserObj);
+		assertTrue(result.status == 0);
+		
+		approvalObj.status = "pending";
+		approvalObj.type = "owner";
+		result = funcObj.performFutureOp(trans, FUTURE_OP.A, futureDataDaoObj, lookupApprovalObj, lookupUserObj);
+		assertTrue(result.status == 0);
+		
+		approvalObj.status = "pending";
+		approvalObj.type = "";
+		result = funcObj.performFutureOp(trans, FUTURE_OP.A, futureDataDaoObj, lookupApprovalObj, lookupUserObj);
+		assertTrue(result.status == 0);
+		
+		approvalObj.status = "denied";
+		approvalObj.type = "";
+		result = funcObj.performFutureOp(trans, FUTURE_OP.A, futureDataDaoObj, lookupApprovalObj, lookupUserObj);
+		assertTrue(result.status == 0);
+		
+		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);
+//		
+	}
 }