/**
 * ============LICENSE_START====================================================
 * org.onap.aaf
 * ===========================================================================
 * Copyright (c) 2018 AT&T Intellectual Property. All rights reserved.
 * ===========================================================================
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 * ============LICENSE_END====================================================
 *
 */

package org.onap.aaf.auth.service.facade;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.mockito.Mockito.mock;
import static org.mockito.MockitoAnnotations.initMocks;

import java.io.IOException;
import java.util.Date;

import javax.servlet.ServletInputStream;
import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.onap.aaf.auth.dao.cached.CachedCertDAO;
import org.onap.aaf.auth.dao.cached.CachedCredDAO;
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.CacheInfoDAO;
import org.onap.aaf.auth.dao.cass.DelegateDAO;
import org.onap.aaf.auth.dao.cass.FutureDAO;
import org.onap.aaf.auth.dao.cass.HistoryDAO;
import org.onap.aaf.auth.dao.cass.LocateDAO;
import org.onap.aaf.auth.dao.cass.NsType;
import org.onap.aaf.auth.dao.cass.Status;
import org.onap.aaf.auth.dao.hl.Question;
import org.onap.aaf.auth.env.AuthzEnv;
import org.onap.aaf.auth.env.AuthzTrans;
import org.onap.aaf.auth.layer.Result;
import org.onap.aaf.auth.rserv.RServlet;
import org.onap.aaf.auth.service.AuthzService;
import org.onap.aaf.auth.service.mapper.Mapper;
import org.onap.aaf.misc.env.APIException;
import org.onap.aaf.misc.env.Data;
import org.onap.aaf.misc.env.Data.TYPE;
import org.onap.aaf.misc.env.Encryptor;
import org.onap.aaf.misc.env.LogTarget;
import org.onap.aaf.misc.env.TimeTaken;
import org.onap.aaf.misc.rosetta.env.RosettaDF;
import org.onap.aaf.misc.rosetta.env.RosettaData;

import aaf.v2_0.Api;

public class JU_AuthzFacadeImpl<NSS, PERMS, PERMKEY, ROLES, USERS, USERROLES, DELGS, CERTS, KEYS, REQUEST, HISTORY, ERR, APPROVALS> {

    AuthzFacadeImpl<NSS, PERMS, PERMKEY, ROLES, USERS, USERROLES, DELGS, CERTS, KEYS, REQUEST, HISTORY, ERR, APPROVALS> facadeImplObj;

    @Mock
    AuthzEnv env;
    @Mock
    AuthzTrans trans;
    @Mock
    AuthzService authzService;
    @Mock
    Mapper mapper;

    @Mock
    RosettaDF rossetaObj;

    @Mock
    LogTarget lg;
    @Mock
    TimeTaken tt;
    //
    // NOTE: Annotation format (@Mock and @Spy) do NOT seem to always work as a
    // Base Class,
    // so we construct manually.
    //
    // Mock Objects
    protected HistoryDAO historyDAO = mock(HistoryDAO.class);
    protected CacheInfoDAO cacheInfoDAO = mock(CacheInfoDAO.class);
    protected CachedNSDAO nsDAO = mock(CachedNSDAO.class);
    protected CachedPermDAO permDAO = mock(CachedPermDAO.class);
    protected CachedRoleDAO roleDAO = mock(CachedRoleDAO.class);
    protected CachedUserRoleDAO userRoleDAO = mock(CachedUserRoleDAO.class);
    protected CachedCredDAO credDAO = mock(CachedCredDAO.class);
    protected CachedCertDAO certDAO = mock(CachedCertDAO.class);
    protected LocateDAO locateDAO = mock(LocateDAO.class);
    protected FutureDAO futureDAO = mock(FutureDAO.class);
    protected DelegateDAO delegateDAO = mock(DelegateDAO.class);
    protected ApprovalDAO approvalDAO = mock(ApprovalDAO.class);

    @Before
    public void setUp() throws APIException, IOException {
        initMocks(this);

        Mockito.doReturn(lg).when(trans).info();
        Mockito.doReturn(lg).when(trans).error();
        Mockito.doReturn(lg).when(trans).trace();
        Mockito.doReturn(tt).when(trans).start("createNamespace", 40);
        Mockito.doReturn(tt).when(trans).start(Mockito.anyString(),
                Mockito.anyInt());
        Mockito.doReturn(Mockito.mock(Encryptor.class)).when(env).encryptor();
        Mockito.doReturn(mapper).when(authzService).mapper();
        Mockito.doReturn(rossetaObj).when(env).newDataFactory(Mockito.any());
        Mockito.doReturn(rossetaObj).when(rossetaObj).in(Mockito.any());
        Mockito.doReturn(rossetaObj).when(rossetaObj).out(Mockito.any());
        facadeImplObj = new AuthzFacadeImplImpl(env, authzService,
                Data.TYPE.XML);
    }

    @Test
    public void testMapper() {
        facadeImplObj.mapper();
    }

    @SuppressWarnings({"unchecked", "rawtypes"})
    @Test
    public void testError() {
        facadeImplObj.error(trans, Mockito.mock(HttpServletResponse.class),
                Mockito.mock(Result.class));

        Result<?> rs = new Result(null, Result.ERR_ActionNotCompleted, "test",
                new Object[2]);
        facadeImplObj.error(trans, Mockito.mock(HttpServletResponse.class), rs);

        rs = new Result(null, Result.ERR_Policy, "test",
                new Object[]{"test", "test"});
        facadeImplObj.error(trans, Mockito.mock(HttpServletResponse.class), rs);

        rs = new Result(null, Result.ERR_Security, "test",
                new Object[]{"", "test"});
        facadeImplObj.error(trans, Mockito.mock(HttpServletResponse.class), rs);

        rs = new Result(null, Result.ERR_Denied, "test", null);
        facadeImplObj.error(trans, Mockito.mock(HttpServletResponse.class), rs);

        rs = new Result(null, 33, "test", null);
        facadeImplObj.error(trans, Mockito.mock(HttpServletResponse.class), rs);

        rs = new Result(null, 21, "test", null);
        facadeImplObj.error(trans, Mockito.mock(HttpServletResponse.class), rs);

        rs = new Result(null, 22, "test", null);
        facadeImplObj.error(trans, Mockito.mock(HttpServletResponse.class), rs);
        rs = new Result(null, 23, "test", null);
        facadeImplObj.error(trans, Mockito.mock(HttpServletResponse.class), rs);
        rs = new Result(null, 24, "test", null);
        facadeImplObj.error(trans, Mockito.mock(HttpServletResponse.class), rs);
        rs = new Result(null, 25, "test", null);
        facadeImplObj.error(trans, Mockito.mock(HttpServletResponse.class), rs);

        rs = new Result(null, 26, "test", null);
        facadeImplObj.error(trans, Mockito.mock(HttpServletResponse.class), rs);

        rs = new Result(null, 27, "test", null);
        facadeImplObj.error(trans, Mockito.mock(HttpServletResponse.class), rs);

        rs = new Result(null, 28, "test", null);
        facadeImplObj.error(trans, Mockito.mock(HttpServletResponse.class), rs);

        rs = new Result(null, 4, "test", null);
        facadeImplObj.error(trans, Mockito.mock(HttpServletResponse.class), rs);

        rs = new Result(null, 5, "test", null);
        facadeImplObj.error(trans, Mockito.mock(HttpServletResponse.class), rs);

        rs = new Result(null, 6, "test", null);
        facadeImplObj.error(trans, Mockito.mock(HttpServletResponse.class), rs);

        rs = new Result(null, 7, "test", null);
        facadeImplObj.error(trans, Mockito.mock(HttpServletResponse.class), rs);

        rs = new Result(null, 31, "test", null);
        facadeImplObj.error(trans, Mockito.mock(HttpServletResponse.class), rs);

        rs = new Result(null, 32, "test", null);
        facadeImplObj.error(trans, Mockito.mock(HttpServletResponse.class), rs);

        rs = new Result(null, 9, "test", null);
        facadeImplObj.error(trans, Mockito.mock(HttpServletResponse.class), rs);
    }

    @Test
    @SuppressWarnings("unchecked")
    public void testRequestNS() {
        RosettaData<?> dataObj = Mockito.mock(RosettaData.class);
        Mockito.doReturn(dataObj).when(rossetaObj).newData();
        try {
            Mockito.doThrow(new APIException("test exception")).when(dataObj)
                    .load(Mockito.any(ServletInputStream.class));
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        Result<Void> retVal = (Result<Void>) facadeImplObj.requestNS(trans,
                Mockito.mock(HttpServletRequest.class),
                Mockito.mock(HttpServletResponse.class), NsType.APP);
        assertTrue(retVal.status == Status.ERR_BadData);

        Data<?> rd = Mockito.mock(Data.class);
        try {
            Mockito.doReturn(dataObj).when(dataObj)
                    .load(Mockito.any(ServletInputStream.class));
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        retVal = (Result<Void>) facadeImplObj.requestNS(trans,
                Mockito.mock(HttpServletRequest.class),
                Mockito.mock(HttpServletResponse.class), NsType.APP);
        assertTrue(retVal.status == 20);

        Result<Void> rsVoid = new Result<Void>(null, 31, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService).createNS(Mockito.any(),
                Mockito.any(), Mockito.any());
        retVal = (Result<Void>) facadeImplObj.requestNS(trans,
                Mockito.mock(HttpServletRequest.class),
                Mockito.mock(HttpServletResponse.class), NsType.APP);
        assertTrue(retVal.status == 31);

        rsVoid = new Result<Void>(null, 0, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService).createNS(Mockito.any(),
                Mockito.any(), Mockito.any());
        retVal = (Result<Void>) facadeImplObj.requestNS(trans,
                Mockito.mock(HttpServletRequest.class),
                Mockito.mock(HttpServletResponse.class), NsType.APP);
        assertTrue(retVal.status == Status.OK);

        Mockito.doReturn("user").when(trans).user();
        Mockito.doReturn(env).when(trans).env();
        Question.specialLogOn(trans, trans.user());
        retVal = (Result<Void>) facadeImplObj.requestNS(trans,
                Mockito.mock(HttpServletRequest.class),
                Mockito.mock(HttpServletResponse.class), NsType.APP);
        assertTrue(retVal.status == 0);
    }

    @Test
    @SuppressWarnings("unchecked")
    public void testAddAdminToNS() {
        HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
        Result<Void> retVal = (Result<Void>) facadeImplObj.addAdminToNS(trans,
                respObj, "ns", "id");
        assertTrue(retVal.status == 20);

        Result<Void> rsVoid = new Result<Void>(null, 31, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService).addAdminNS(trans, "ns",
                "id");
        retVal = (Result<Void>) facadeImplObj.addAdminToNS(trans, respObj, "ns",
                "id");
        assertTrue(retVal.status == 31);

        rsVoid = new Result<Void>(null, 0, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService).addAdminNS(trans, "ns",
                "id");
        try {
            Mockito.doReturn(Mockito.mock(ServletOutputStream.class))
                    .when(respObj).getOutputStream();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        retVal = (Result<Void>) facadeImplObj.addAdminToNS(trans, respObj, "ns",
                "id");
        assertTrue(retVal.status == 0);
    }

    @Test
    @SuppressWarnings("unchecked")
    public void testDelAdminFromNS() {
        HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
        Result<Void> retVal = (Result<Void>) facadeImplObj.delAdminFromNS(trans,
                respObj, "ns", "id");
        assertTrue(retVal.status == 20);

        Result<Void> rsVoid = new Result<Void>(null, 31, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService).delAdminNS(trans, "ns",
                "id");
        retVal = (Result<Void>) facadeImplObj.delAdminFromNS(trans, respObj,
                "ns", "id");
        assertTrue(retVal.status == 31);

        rsVoid = new Result<Void>(null, 0, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService).delAdminNS(trans, "ns",
                "id");
        try {
            Mockito.doReturn(Mockito.mock(ServletOutputStream.class))
                    .when(respObj).getOutputStream();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        retVal = (Result<Void>) facadeImplObj.delAdminFromNS(trans, respObj,
                "ns", "id");
        assertTrue(retVal.status == 0);
    }
    @Test
    @SuppressWarnings("unchecked")
    public void testAddResponsibilityForNS() {
        HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
        Result<Void> retVal = (Result<Void>) facadeImplObj
                .addResponsibilityForNS(trans, respObj, "ns", "id");
        assertTrue(retVal.status == 20);

        Result<Void> rsVoid = new Result<Void>(null, 31, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService).addResponsibleNS(trans,
                "ns", "id");
        retVal = (Result<Void>) facadeImplObj.addResponsibilityForNS(trans,
                respObj, "ns", "id");
        assertTrue(retVal.status == 31);

        rsVoid = new Result<Void>(null, 0, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService).addResponsibleNS(trans,
                "ns", "id");
        try {
            Mockito.doReturn(Mockito.mock(ServletOutputStream.class))
                    .when(respObj).getOutputStream();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        retVal = (Result<Void>) facadeImplObj.addResponsibilityForNS(trans,
                respObj, "ns", "id");
        assertTrue(retVal.status == 0);
    }

    @Test
    @SuppressWarnings("unchecked")
    public void testDelResponsibilityForNS() {
        HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
        Result<Void> retVal = (Result<Void>) facadeImplObj
                .delResponsibilityForNS(trans, respObj, "ns", "id");
        assertTrue(retVal.status == 20);

        Result<Void> rsVoid = new Result<Void>(null, 31, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService).delResponsibleNS(trans,
                "ns", "id");
        retVal = (Result<Void>) facadeImplObj.delResponsibilityForNS(trans,
                respObj, "ns", "id");
        assertTrue(retVal.status == 31);

        rsVoid = new Result<Void>(null, 0, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService).delResponsibleNS(trans,
                "ns", "id");
        try {
            Mockito.doReturn(Mockito.mock(ServletOutputStream.class))
                    .when(respObj).getOutputStream();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        retVal = (Result<Void>) facadeImplObj.delResponsibilityForNS(trans,
                respObj, "ns", "id");
        assertTrue(retVal.status == 0);
    }

    @Test
    @SuppressWarnings("unchecked")
    public void testGetNSsByName() {
        HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
        Result<Void> retVal = (Result<Void>) facadeImplObj.getNSsByName(trans,
                respObj, "ns", true);
        assertTrue(retVal.status == 20);

        Result<NSS> rsVoid = new Result<NSS>(null, 31, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService).getNSbyName(trans, "ns",
                true);
        retVal = (Result<Void>) facadeImplObj.getNSsByName(trans, respObj, "ns",
                true);
        assertTrue(retVal.status == 31);

        rsVoid = new Result<NSS>(null, 0, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService).getNSbyName(trans, "ns",
                true);
        try {
            Mockito.doReturn(Mockito.mock(ServletOutputStream.class))
                    .when(respObj).getOutputStream();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        RosettaData<NSS> dataObj = Mockito.mock(RosettaData.class);
        Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
        try {
            Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        retVal = (Result<Void>) facadeImplObj.getNSsByName(trans, respObj, "ns",
                true);
        assertTrue(retVal.status == 0);

        Mockito.doReturn("user").when(trans).user();
        Mockito.doReturn(env).when(trans).env();
        Question.specialLogOn(trans, trans.user());
        retVal = (Result<Void>) facadeImplObj.getNSsByName(trans, respObj, "ns",
                true);
        assertTrue(retVal.status == 0);
    }

    @Test
    @SuppressWarnings("unchecked")
    public void testGetNSsByAdmin() {
        HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
        Result<Void> retVal = (Result<Void>) facadeImplObj.getNSsByAdmin(trans,
                respObj, "ns", true);
        assertTrue(retVal.status == 20);

        Result<NSS> rsVoid = new Result<NSS>(null, 31, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService).getNSbyAdmin(trans, "ns",
                true);
        retVal = (Result<Void>) facadeImplObj.getNSsByAdmin(trans, respObj,
                "ns", true);
        assertTrue(retVal.status == 31);

        rsVoid = new Result<NSS>(null, 0, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService).getNSbyAdmin(trans, "ns",
                true);
        try {
            Mockito.doReturn(Mockito.mock(ServletOutputStream.class))
                    .when(respObj).getOutputStream();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        RosettaData<NSS> dataObj = Mockito.mock(RosettaData.class);
        Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
        try {
            Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        retVal = (Result<Void>) facadeImplObj.getNSsByAdmin(trans, respObj,
                "ns", true);
        assertTrue(retVal.status == 0);

        Mockito.doReturn("user").when(trans).user();
        Mockito.doReturn(env).when(trans).env();
        Question.specialLogOn(trans, trans.user());
        retVal = (Result<Void>) facadeImplObj.getNSsByAdmin(trans, respObj,
                "ns", true);
        assertTrue(retVal.status == 0);
    }

    @Test
    @SuppressWarnings("unchecked")
    public void testGetNSsByResponsible() {
        HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
        Result<Void> retVal = (Result<Void>) facadeImplObj
                .getNSsByResponsible(trans, respObj, "ns", true);
        assertTrue(retVal.status == 20);

        Result<NSS> rsVoid = new Result<NSS>(null, 31, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService).getNSbyResponsible(trans,
                "ns", true);
        retVal = (Result<Void>) facadeImplObj.getNSsByResponsible(trans,
                respObj, "ns", true);
        assertTrue(retVal.status == 31);

        rsVoid = new Result<NSS>(null, 0, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService).getNSbyResponsible(trans,
                "ns", true);
        try {
            Mockito.doReturn(Mockito.mock(ServletOutputStream.class))
                    .when(respObj).getOutputStream();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        RosettaData<NSS> dataObj = Mockito.mock(RosettaData.class);
        Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
        try {
            Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        retVal = (Result<Void>) facadeImplObj.getNSsByResponsible(trans,
                respObj, "ns", true);
        assertTrue(retVal.status == 0);

        Mockito.doReturn("user").when(trans).user();
        Mockito.doReturn(env).when(trans).env();
        Question.specialLogOn(trans, trans.user());
        retVal = (Result<Void>) facadeImplObj.getNSsByResponsible(trans,
                respObj, "ns", true);
        assertTrue(retVal.status == 0);
    }

    @Test
    @SuppressWarnings("unchecked")
    public void testGetNSsByEither() {
        HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
        Result<Void> retVal = (Result<Void>) facadeImplObj.getNSsByEither(trans,
                respObj, "ns", true);
        assertTrue(retVal.status == 20);

        Result<NSS> rsVoid = new Result<NSS>(null, 31, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService).getNSbyEither(trans, "ns",
                true);
        retVal = (Result<Void>) facadeImplObj.getNSsByEither(trans, respObj,
                "ns", true);
        assertTrue(retVal.status == 31);

        rsVoid = new Result<NSS>(null, 0, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService).getNSbyEither(trans, "ns",
                true);
        try {
            Mockito.doReturn(Mockito.mock(ServletOutputStream.class))
                    .when(respObj).getOutputStream();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        RosettaData<NSS> dataObj = Mockito.mock(RosettaData.class);
        Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
        try {
            Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        retVal = (Result<Void>) facadeImplObj.getNSsByEither(trans, respObj,
                "ns", true);
        assertTrue(retVal.status == 0);

        Mockito.doReturn("user").when(trans).user();
        Mockito.doReturn(env).when(trans).env();
        Question.specialLogOn(trans, trans.user());
        retVal = (Result<Void>) facadeImplObj.getNSsByEither(trans, respObj,
                "ns", true);
        assertTrue(retVal.status == 0);
    }

    @Test
    @SuppressWarnings("unchecked")
    public void testGetNSsChildren() {
        HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
        Result<Void> retVal = (Result<Void>) facadeImplObj.getNSsChildren(trans,
                respObj, "ns");
        assertTrue(retVal.status == 20);

        Result<NSS> rsVoid = new Result<NSS>(null, 31, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService).getNSsChildren(trans, "ns");
        retVal = (Result<Void>) facadeImplObj.getNSsChildren(trans, respObj,
                "ns");
        assertTrue(retVal.status == 31);

        rsVoid = new Result<NSS>(null, 0, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService).getNSsChildren(trans, "ns");
        try {
            Mockito.doReturn(Mockito.mock(ServletOutputStream.class))
                    .when(respObj).getOutputStream();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        RosettaData<NSS> dataObj = Mockito.mock(RosettaData.class);
        Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
        try {
            Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        retVal = (Result<Void>) facadeImplObj.getNSsChildren(trans, respObj,
                "ns");
        assertTrue(retVal.status == 0);

        Mockito.doReturn("user").when(trans).user();
        Mockito.doReturn(env).when(trans).env();
        Question.specialLogOn(trans, trans.user());
        retVal = (Result<Void>) facadeImplObj.getNSsChildren(trans, respObj,
                "ns");
        assertTrue(retVal.status == 0);
    }
    @Test
    @SuppressWarnings("unchecked")
    public void testUpdateNsDescription() {
        HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
        Result<Void> retVal = (Result<Void>) facadeImplObj.updateNsDescription(
                trans, Mockito.mock(HttpServletRequest.class), respObj);
        assertTrue(retVal.status == 20);

        RosettaData<?> dataObj = Mockito.mock(RosettaData.class);
        Mockito.doReturn(dataObj).when(rossetaObj).newData();
        try {
            Mockito.doThrow(new APIException("test exception")).when(dataObj)
                    .load(Mockito.any(ServletInputStream.class));
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        retVal = (Result<Void>) facadeImplObj.updateNsDescription(trans,
                Mockito.mock(HttpServletRequest.class), respObj);
        assertTrue(retVal.status == 4);

        try {
            Mockito.doReturn(dataObj).when(dataObj)
                    .load(Mockito.any(ServletInputStream.class));
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        retVal = (Result<Void>) facadeImplObj.updateNsDescription(trans,
                Mockito.mock(HttpServletRequest.class), respObj);
        assertTrue(retVal.status == 20);

        Mockito.doReturn("user").when(trans).user();
        Mockito.doReturn(env).when(trans).env();
        Question.specialLogOn(trans, trans.user());
        retVal = (Result<Void>) facadeImplObj.updateNsDescription(trans,
                Mockito.mock(HttpServletRequest.class), respObj);
        assertTrue(retVal.status == 20);

        Result<NSS> rsVoid = new Result<NSS>(null, 31, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService)
                .updateNsDescription(Mockito.any(), Mockito.any());
        retVal = (Result<Void>) facadeImplObj.updateNsDescription(trans,
                Mockito.mock(HttpServletRequest.class), respObj);
        assertTrue(retVal.status == 31);

        rsVoid = new Result<NSS>(null, 0, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService)
                .updateNsDescription(Mockito.any(), Mockito.any());
        retVal = (Result<Void>) facadeImplObj.updateNsDescription(trans,
                Mockito.mock(HttpServletRequest.class), respObj);
        assertTrue(retVal.status == 0);
    }

    @Test
    @SuppressWarnings("unchecked")
    public void testDeleteNS() {
        HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
        Result<Void> retVal = (Result<Void>) facadeImplObj.deleteNS(trans,
                Mockito.mock(HttpServletRequest.class), respObj, "ns");
        assertTrue(retVal.status == 20);

        Result<NSS> rsVoid = new Result<NSS>(null, 31, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService).deleteNS(Mockito.any(),
                Mockito.any());
        retVal = (Result<Void>) facadeImplObj.deleteNS(trans,
                Mockito.mock(HttpServletRequest.class), respObj, "ns");
        assertTrue(retVal.status == 31);

        rsVoid = new Result<NSS>(null, 0, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService).deleteNS(Mockito.any(),
                Mockito.any());
        retVal = (Result<Void>) facadeImplObj.deleteNS(trans,
                Mockito.mock(HttpServletRequest.class), respObj, "ns");
        assertTrue(retVal.status == 0);
    }

    @Test
    @SuppressWarnings("unchecked")
    public void testCreateAttribForNS() {
        HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
        Result<Void> retVal = (Result<Void>) facadeImplObj
                .createAttribForNS(trans, respObj, "ns", "key", "value");
        assertTrue(retVal.status == 20);

        Result<NSS> rsVoid = new Result<NSS>(null, 31, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService).createNsAttrib(trans, "ns",
                "key", "value");
        retVal = (Result<Void>) facadeImplObj.createAttribForNS(trans, respObj,
                "ns", "key", "value");
        assertTrue(retVal.status == 31);

        try {
            Mockito.doReturn(Mockito.mock(ServletOutputStream.class))
                    .when(respObj).getOutputStream();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        rsVoid = new Result<NSS>(null, 0, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService).createNsAttrib(trans, "ns",
                "key", "value");
        retVal = (Result<Void>) facadeImplObj.createAttribForNS(trans, respObj,
                "ns", "key", "value");
        assertTrue(retVal.status == 0);
    }

    @Test
    @SuppressWarnings("unchecked")
    public void testReadNsByAttrib() {
        HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
        Result<Void> retVal = (Result<Void>) facadeImplObj.readNsByAttrib(trans,
                respObj, "key");
        assertTrue(retVal.status == 20);

        Result<KEYS> rsVoid = new Result<KEYS>(null, 31, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService).readNsByAttrib(trans,
                "key");
        retVal = (Result<Void>) facadeImplObj.readNsByAttrib(trans, respObj,
                "key");
        assertTrue(retVal.status == 31);

        RosettaData<KEYS> dataObj = Mockito.mock(RosettaData.class);
        Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
        try {
            Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        rsVoid = new Result<KEYS>(null, 0, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService).readNsByAttrib(trans,
                "key");
        retVal = (Result<Void>) facadeImplObj.readNsByAttrib(trans, respObj,
                "key");
        assertTrue(retVal.status == 0);

        Mockito.doReturn("user").when(trans).user();
        Mockito.doReturn(env).when(trans).env();
        Question.specialLogOn(trans, trans.user());
        retVal = (Result<Void>) facadeImplObj.readNsByAttrib(trans, respObj,
                "key");
        assertTrue(retVal.status == 0);
    }
    @Test
    @SuppressWarnings("unchecked")
    public void testUpdAttribForNS() {
        HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
        Result<Void> retVal = (Result<Void>) facadeImplObj.updAttribForNS(trans,
                respObj, "ns", "key", "value");
        assertTrue(retVal.status == 20);

        Result<KEYS> rsVoid = new Result<KEYS>(null, 31, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService).updateNsAttrib(trans, "ns",
                "key", "value");
        retVal = (Result<Void>) facadeImplObj.updAttribForNS(trans, respObj,
                "ns", "key", "value");
        assertTrue(retVal.status == 31);

        try {
            Mockito.doReturn(Mockito.mock(ServletOutputStream.class))
                    .when(respObj).getOutputStream();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        rsVoid = new Result<KEYS>(null, 0, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService).updateNsAttrib(trans, "ns",
                "key", "value");
        retVal = (Result<Void>) facadeImplObj.updAttribForNS(trans, respObj,
                "ns", "key", "value");
        assertTrue(retVal.status == 0);

    }

    @Test
    @SuppressWarnings("unchecked")
    public void testDelAttribForNS() {
        HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
        Result<Void> retVal = (Result<Void>) facadeImplObj.delAttribForNS(trans,
                respObj, "ns", "key");
        assertTrue(retVal.status == 20);

        Result<KEYS> rsVoid = new Result<KEYS>(null, 31, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService).deleteNsAttrib(trans, "ns",
                "key");
        retVal = (Result<Void>) facadeImplObj.delAttribForNS(trans, respObj,
                "ns", "key");
        assertTrue(retVal.status == 31);

        try {
            Mockito.doReturn(Mockito.mock(ServletOutputStream.class))
                    .when(respObj).getOutputStream();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        rsVoid = new Result<KEYS>(null, 0, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService).deleteNsAttrib(trans, "ns",
                "key");
        retVal = (Result<Void>) facadeImplObj.delAttribForNS(trans, respObj,
                "ns", "key");
        assertTrue(retVal.status == 0);

    }

    @Test
    @SuppressWarnings("unchecked")
    public void testCreatePerm() {
        HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);

        RosettaData<?> dataObj = Mockito.mock(RosettaData.class);
        Mockito.doReturn(dataObj).when(rossetaObj).newData();
        try {
            Mockito.doThrow(new APIException("test exception")).when(dataObj)
                    .load(Mockito.any(ServletInputStream.class));
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        Result<Void> retVal = (Result<Void>) facadeImplObj.createPerm(trans,
                Mockito.mock(HttpServletRequest.class), respObj);
        assertTrue(retVal.status == 4);

        try {
            Mockito.doReturn(dataObj).when(dataObj)
                    .load(Mockito.any(ServletInputStream.class));
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        retVal = (Result<Void>) facadeImplObj.createPerm(trans,
                Mockito.mock(HttpServletRequest.class), respObj);
        assertTrue(retVal.status == 20);

        Mockito.doReturn("user").when(trans).user();
        Mockito.doReturn(env).when(trans).env();
        Question.specialLogOn(trans, trans.user());
        retVal = (Result<Void>) facadeImplObj.createPerm(trans,
                Mockito.mock(HttpServletRequest.class), respObj);
        assertTrue(retVal.status == 20);

        Result<Void> rsVoid = new Result<Void>(null, 0, "test", new Object[0]);
        try {
            Mockito.when(authzService.createPerm(trans, dataObj.asObject()))
                    .thenReturn(rsVoid);
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        retVal = (Result<Void>) facadeImplObj.createPerm(trans,
                Mockito.mock(HttpServletRequest.class), respObj);
        assertTrue(retVal.status == 0);

        rsVoid = new Result<Void>(null, 31, "test", new Object[0]);
        try {
            Mockito.when(authzService.createPerm(trans, dataObj.asObject()))
                    .thenReturn(rsVoid);
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        retVal = (Result<Void>) facadeImplObj.createPerm(trans,
                Mockito.mock(HttpServletRequest.class), respObj);
        assertTrue(retVal.status == 31);
    }

    @Test
    @SuppressWarnings("unchecked")
    public void testGetPermsByType() {
        RosettaData<PERMS> dataObj = Mockito.mock(RosettaData.class);
        HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);

        Result<Void> retVal = (Result<Void>) facadeImplObj.getPermsByType(trans,
                respObj, "perm");
        assertTrue(retVal.status == 20);

        Result<PERMS> rsVoid = new Result<PERMS>(null, 31, "test",
                new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService)
                .getPermsByType(Mockito.any(), Mockito.any());
        retVal = (Result<Void>) facadeImplObj.getPermsByType(trans, respObj,
                "perm");
        assertTrue(retVal.status == 31);

        try {
            Mockito.doReturn(Mockito.mock(ServletOutputStream.class))
                    .when(respObj).getOutputStream();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        rsVoid = new Result<PERMS>(null, 0, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService)
                .getPermsByType(Mockito.any(), Mockito.any());
        Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
        try {
            Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        retVal = (Result<Void>) facadeImplObj.getPermsByType(trans, respObj,
                "perm");
        assertTrue(retVal.status == 0);

        Mockito.doReturn("user").when(trans).user();
        Mockito.doReturn(env).when(trans).env();
        Question.specialLogOn(trans, trans.user());
        Mockito.doReturn(Mockito.mock(Encryptor.class)).when(env).encryptor();
        retVal = (Result<Void>) facadeImplObj.getPermsByType(trans, respObj,
                "perm");
        assertTrue(retVal.status == 0);
    }
    @Test
    @SuppressWarnings("unchecked")
    public void testGetPermsByName() {
        RosettaData<PERMS> dataObj = Mockito.mock(RosettaData.class);
        HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);

        Result<Void> retVal = (Result<Void>) facadeImplObj.getPermsByName(trans,
                respObj, "type", "instance", "action");
        assertTrue(retVal.status == 20);

        Result<PERMS> rsVoid = new Result<PERMS>(null, 31, "test",
                new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService).getPermsByName(
                Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any());
        retVal = (Result<Void>) facadeImplObj.getPermsByName(trans, respObj,
                "type", "instance", "action");
        assertTrue(retVal.status == 31);

        try {
            Mockito.doReturn(Mockito.mock(ServletOutputStream.class))
                    .when(respObj).getOutputStream();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        rsVoid = new Result<PERMS>(null, 0, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService).getPermsByName(
                Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any());
        Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
        try {
            Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        retVal = (Result<Void>) facadeImplObj.getPermsByName(trans, respObj,
                "type", "instance", "action");
        assertTrue(retVal.status == 0);

        Mockito.doReturn("user").when(trans).user();
        Mockito.doReturn(env).when(trans).env();
        Question.specialLogOn(trans, trans.user());
        Mockito.doReturn(Mockito.mock(Encryptor.class)).when(env).encryptor();
        retVal = (Result<Void>) facadeImplObj.getPermsByName(trans, respObj,
                "type", "instance", "action");
        assertTrue(retVal.status == 0);
    }
    @Test
    @SuppressWarnings("unchecked")
    public void testGetPermsByUser() {
        RosettaData<PERMS> dataObj = Mockito.mock(RosettaData.class);
        HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);

        Result<Void> retVal = (Result<Void>) facadeImplObj.getPermsByUser(trans,
                respObj, "user");
        assertTrue(retVal.status == 20);

        Result<PERMS> rsVoid = new Result<PERMS>(null, 31, "test",
                new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService)
                .getPermsByUser(Mockito.any(), Mockito.any());
        retVal = (Result<Void>) facadeImplObj.getPermsByUser(trans, respObj,
                "user");
        assertTrue(retVal.status == 31);

        try {
            Mockito.doReturn(Mockito.mock(ServletOutputStream.class))
                    .when(respObj).getOutputStream();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        rsVoid = new Result<PERMS>(null, 0, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService)
                .getPermsByUser(Mockito.any(), Mockito.any());
        Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
        try {
            Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        retVal = (Result<Void>) facadeImplObj.getPermsByUser(trans, respObj,
                "user");
        assertTrue(retVal.status == 0);

        Mockito.doReturn("user").when(trans).user();
        Mockito.doReturn(env).when(trans).env();
        Question.specialLogOn(trans, trans.user());
        Mockito.doReturn(Mockito.mock(Encryptor.class)).when(env).encryptor();
        retVal = (Result<Void>) facadeImplObj.getPermsByUser(trans, respObj,
                "user");
        assertTrue(retVal.status == 0);
    }
    @Test
    @SuppressWarnings("unchecked")
    public void testGetPermsByUserScope() {
        RosettaData<PERMS> dataObj = Mockito.mock(RosettaData.class);
        HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);

        Result<Void> retVal = (Result<Void>) facadeImplObj
                .getPermsByUserScope(trans, respObj, "user", new String[]{});
        assertTrue(retVal.status == 20);

        Result<PERMS> rsVoid = new Result<PERMS>(null, 31, "test",
                new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService).getPermsByUserScope(trans,
                "user", new String[]{});
        retVal = (Result<Void>) facadeImplObj.getPermsByUserScope(trans,
                respObj, "user", new String[]{});
        assertTrue(retVal.status == 31);

        try {
            Mockito.doReturn(Mockito.mock(ServletOutputStream.class))
                    .when(respObj).getOutputStream();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        rsVoid = new Result<PERMS>(null, 0, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService).getPermsByUserScope(trans,
                "user", new String[]{});
        Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
        try {
            Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        retVal = (Result<Void>) facadeImplObj.getPermsByUserScope(trans,
                respObj, "user", new String[]{});
        assertTrue(retVal.status == 0);

        Mockito.doReturn("user").when(trans).user();
        Mockito.doReturn(env).when(trans).env();
        Question.specialLogOn(trans, trans.user());
        Mockito.doReturn(Mockito.mock(Encryptor.class)).when(env).encryptor();
        retVal = (Result<Void>) facadeImplObj.getPermsByUserScope(trans,
                respObj, "user", new String[]{});
        assertTrue(retVal.status == 0);
    }

    @Test
    @SuppressWarnings("unchecked")
    public void testGetPermsByUserWithAAFQuery() {
        RosettaData<PERMS> dataObj = Mockito.mock(RosettaData.class);
        HttpServletRequest reqObj = Mockito.mock(HttpServletRequest.class);
        HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);

        Result<Void> retVal = (Result<Void>) facadeImplObj
                .getPermsByUserWithAAFQuery(trans, reqObj, respObj, "user");
        assertTrue(retVal.status == 20);

        Mockito.doReturn(dataObj).when(rossetaObj).newData();
        try {
            Mockito.doThrow(new APIException("test exception")).when(dataObj)
                    .load(Mockito.any(ServletInputStream.class));
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        retVal = (Result<Void>) facadeImplObj.getPermsByUserWithAAFQuery(trans,
                reqObj, respObj, "user");
        assertTrue(retVal.status == Status.ERR_BadData);

        try {
            Mockito.doReturn(dataObj).when(dataObj)
                    .load(Mockito.any(ServletInputStream.class));
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        retVal = (Result<Void>) facadeImplObj.getPermsByUserWithAAFQuery(trans,
                reqObj, respObj, "user");
        assertTrue(retVal.status == 20);

        Result<PERMS> rsVoid = new Result<PERMS>(null, 31, "test",
                new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService).getPermsByUser(
                Mockito.any(), Mockito.any(), Mockito.anyString());
        retVal = (Result<Void>) facadeImplObj.getPermsByUserWithAAFQuery(trans,
                reqObj, respObj, "user");
        assertTrue(retVal.status == 31);

        rsVoid = new Result<PERMS>(null, 0, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService).getPermsByUser(
                Mockito.any(), Mockito.any(), Mockito.anyString());
        Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
        try {
            Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        retVal = (Result<Void>) facadeImplObj.getPermsByUserWithAAFQuery(trans,
                reqObj, respObj, "user");
        assertTrue(retVal.status == 0);

        Mockito.doReturn("user").when(trans).user();
        Mockito.doReturn(env).when(trans).env();
        Question.specialLogOn(trans, trans.user());
        retVal = (Result<Void>) facadeImplObj.getPermsByUserWithAAFQuery(trans,
                reqObj, respObj, "user");
        assertTrue(retVal.status == 0);
    }

    @Test
    @SuppressWarnings("unchecked")
    public void testGetPermsForRole() {
        RosettaData<PERMS> dataObj = Mockito.mock(RosettaData.class);
        HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);

        Result<Void> retVal = (Result<Void>) facadeImplObj
                .getPermsForRole(trans, respObj, "roleName");
        assertTrue(retVal.status == 20);

        Result<PERMS> rsVoid = new Result<PERMS>(null, 31, "test",
                new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService)
                .getPermsByRole(Mockito.any(), Mockito.anyString());
        retVal = (Result<Void>) facadeImplObj.getPermsForRole(trans, respObj,
                "roleName");
        assertTrue(retVal.status == 31);

        rsVoid = new Result<PERMS>(null, 0, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService)
                .getPermsByRole(Mockito.any(), Mockito.anyString());
        Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
        try {
            Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        retVal = (Result<Void>) facadeImplObj.getPermsForRole(trans, respObj,
                "roleName");
        assertTrue(retVal.status == 0);

        Mockito.doReturn("user").when(trans).user();
        Mockito.doReturn(env).when(trans).env();
        Question.specialLogOn(trans, trans.user());
        retVal = (Result<Void>) facadeImplObj.getPermsForRole(trans, respObj,
                "roleName");
        assertTrue(retVal.status == 0);
    }

    @Test
    @SuppressWarnings("unchecked")
    public void testGetPermsByNS() {
        RosettaData<PERMS> dataObj = Mockito.mock(RosettaData.class);
        HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);

        Result<Void> retVal = (Result<Void>) facadeImplObj.getPermsByNS(trans,
                respObj, "ns");
        assertTrue(retVal.status == 20);

        Result<PERMS> rsVoid = new Result<PERMS>(null, 31, "test",
                new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService).getPermsByNS(Mockito.any(),
                Mockito.anyString());
        retVal = (Result<Void>) facadeImplObj.getPermsByNS(trans, respObj,
                "ns");
        assertTrue(retVal.status == 31);

        rsVoid = new Result<PERMS>(null, 0, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService).getPermsByNS(Mockito.any(),
                Mockito.anyString());
        Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
        try {
            Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        retVal = (Result<Void>) facadeImplObj.getPermsByNS(trans, respObj,
                "ns");
        assertTrue(retVal.status == 0);

        Mockito.doReturn("user").when(trans).user();
        Mockito.doReturn(env).when(trans).env();
        Question.specialLogOn(trans, trans.user());
        retVal = (Result<Void>) facadeImplObj.getPermsByNS(trans, respObj,
                "ns");
        assertTrue(retVal.status == 0);
    }
    @Test
    @SuppressWarnings("unchecked")
    public void testRenamePerm() {
        RosettaData<PERMS> dataObj = Mockito.mock(RosettaData.class);
        HttpServletRequest reqObj = Mockito.mock(HttpServletRequest.class);
        HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);

        Result<Void> retVal = (Result<Void>) facadeImplObj.renamePerm(trans,
                reqObj, respObj, "origType", "origInstance", "origAction");
        assertTrue(retVal.status == 20);

        Mockito.doReturn(dataObj).when(rossetaObj).newData();
        try {
            Mockito.doThrow(new APIException("test exception")).when(dataObj)
                    .load(Mockito.any(ServletInputStream.class));
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        retVal = (Result<Void>) facadeImplObj.renamePerm(trans, reqObj, respObj,
                "origType", "origInstance", "origAction");
        assertTrue(retVal.status == Status.ERR_BadData);

        try {
            Mockito.doReturn(dataObj).when(dataObj)
                    .load(Mockito.any(ServletInputStream.class));
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        retVal = (Result<Void>) facadeImplObj.renamePerm(trans, reqObj, respObj,
                "origType", "origInstance", "origAction");
        assertTrue(retVal.status == 20);

        Result<PERMS> rsVoid = new Result<PERMS>(null, 31, "test",
                new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService).renamePerm(Mockito.any(),
                Mockito.any(), Mockito.anyString(), Mockito.anyString(),
                Mockito.anyString());
        retVal = (Result<Void>) facadeImplObj.renamePerm(trans, reqObj, respObj,
                "origType", "origInstance", "origAction");
        assertTrue(retVal.status == 31);

        rsVoid = new Result<PERMS>(null, 0, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService).renamePerm(Mockito.any(),
                Mockito.any(), Mockito.anyString(), Mockito.anyString(),
                Mockito.anyString());
        Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
        try {
            Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        retVal = (Result<Void>) facadeImplObj.renamePerm(trans, reqObj, respObj,
                "origType", "origInstance", "origAction");
        assertTrue(retVal.status == 0);

        Mockito.doReturn("user").when(trans).user();
        Mockito.doReturn(env).when(trans).env();
        Question.specialLogOn(trans, trans.user());
        retVal = (Result<Void>) facadeImplObj.renamePerm(trans, reqObj, respObj,
                "origType", "origInstance", "origAction");
        assertTrue(retVal.status == 0);
    }
    @Test
    @SuppressWarnings("unchecked")
    public void testUpdatePermDescription() {
        RosettaData<PERMS> dataObj = Mockito.mock(RosettaData.class);
        HttpServletRequest reqObj = Mockito.mock(HttpServletRequest.class);
        HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);

        Result<Void> retVal = (Result<Void>) facadeImplObj
                .updatePermDescription(trans, reqObj, respObj);
        assertTrue(retVal.status == 20);

        Mockito.doReturn(dataObj).when(rossetaObj).newData();
        try {
            Mockito.doThrow(new APIException("test exception")).when(dataObj)
                    .load(Mockito.any(ServletInputStream.class));
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        retVal = (Result<Void>) facadeImplObj.updatePermDescription(trans,
                reqObj, respObj);
        assertTrue(retVal.status == Status.ERR_BadData);

        try {
            Mockito.doReturn(dataObj).when(dataObj)
                    .load(Mockito.any(ServletInputStream.class));
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        retVal = (Result<Void>) facadeImplObj.updatePermDescription(trans,
                reqObj, respObj);
        assertTrue(retVal.status == 20);

        Result<PERMS> rsVoid = new Result<PERMS>(null, 31, "test",
                new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService)
                .updatePermDescription(Mockito.any(), Mockito.any());
        retVal = (Result<Void>) facadeImplObj.updatePermDescription(trans,
                reqObj, respObj);
        assertTrue(retVal.status == 31);

        rsVoid = new Result<PERMS>(null, 0, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService)
                .updatePermDescription(Mockito.any(), Mockito.any());
        Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
        try {
            Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        retVal = (Result<Void>) facadeImplObj.updatePermDescription(trans,
                reqObj, respObj);
        assertTrue(retVal.status == 0);

        Mockito.doReturn("user").when(trans).user();
        Mockito.doReturn(env).when(trans).env();
        Question.specialLogOn(trans, trans.user());
        retVal = (Result<Void>) facadeImplObj.updatePermDescription(trans,
                reqObj, respObj);
        assertTrue(retVal.status == 0);
    }
    @Test
    @SuppressWarnings("unchecked")
    public void testResetPermRoles() {
        RosettaData<PERMS> dataObj = Mockito.mock(RosettaData.class);
        HttpServletRequest reqObj = Mockito.mock(HttpServletRequest.class);
        HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);

        Result<Void> retVal = (Result<Void>) facadeImplObj.resetPermRoles(trans,
                reqObj, respObj);
        assertTrue(retVal.status == 20);

        Mockito.doReturn(dataObj).when(rossetaObj).newData();
        try {
            Mockito.doThrow(new APIException("test exception")).when(dataObj)
                    .load(Mockito.any(ServletInputStream.class));
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        retVal = (Result<Void>) facadeImplObj.resetPermRoles(trans, reqObj,
                respObj);
        assertTrue(retVal.status == Status.ERR_BadData);

        try {
            Mockito.doReturn(dataObj).when(dataObj)
                    .load(Mockito.any(ServletInputStream.class));
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        retVal = (Result<Void>) facadeImplObj.resetPermRoles(trans, reqObj,
                respObj);
        assertTrue(retVal.status == 20);

        Result<PERMS> rsVoid = new Result<PERMS>(null, 31, "test",
                new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService)
                .resetPermRoles(Mockito.any(), Mockito.any());
        retVal = (Result<Void>) facadeImplObj.resetPermRoles(trans, reqObj,
                respObj);
        assertTrue(retVal.status == 31);

        rsVoid = new Result<PERMS>(null, 0, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService)
                .resetPermRoles(Mockito.any(), Mockito.any());
        Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
        try {
            Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        retVal = (Result<Void>) facadeImplObj.resetPermRoles(trans, reqObj,
                respObj);
        assertTrue(retVal.status == 0);

        Mockito.doReturn("user").when(trans).user();
        Mockito.doReturn(env).when(trans).env();
        Question.specialLogOn(trans, trans.user());
        retVal = (Result<Void>) facadeImplObj.resetPermRoles(trans, reqObj,
                respObj);
        assertTrue(retVal.status == 0);
    }
    @Test
    @SuppressWarnings("unchecked")
    public void testDeletePerm() {
        RosettaData<PERMS> dataObj = Mockito.mock(RosettaData.class);
        HttpServletRequest reqObj = Mockito.mock(HttpServletRequest.class);
        HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);

        Result<Void> retVal = (Result<Void>) facadeImplObj.deletePerm(trans,
                reqObj, respObj);
        assertTrue(retVal.status == 20);

        Mockito.doReturn(dataObj).when(rossetaObj).newData();
        try {
            Mockito.doThrow(new APIException("test exception")).when(dataObj)
                    .load(Mockito.any(ServletInputStream.class));
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        retVal = (Result<Void>) facadeImplObj.deletePerm(trans, reqObj,
                respObj);
        assertTrue(retVal.status == Status.ERR_BadData);

        try {
            Mockito.doReturn(dataObj).when(dataObj)
                    .load(Mockito.any(ServletInputStream.class));
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        retVal = (Result<Void>) facadeImplObj.deletePerm(trans, reqObj,
                respObj);
        assertTrue(retVal.status == 20);

        Result<PERMS> rsVoid = new Result<PERMS>(null, 31, "test",
                new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService).deletePerm(Mockito.any(),
                Mockito.any());
        retVal = (Result<Void>) facadeImplObj.deletePerm(trans, reqObj,
                respObj);
        assertTrue(retVal.status == 31);

        rsVoid = new Result<PERMS>(null, 0, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService).deletePerm(Mockito.any(),
                Mockito.any());
        Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
        try {
            Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        retVal = (Result<Void>) facadeImplObj.deletePerm(trans, reqObj,
                respObj);
        assertTrue(retVal.status == 0);

        Mockito.doReturn("user").when(trans).user();
        Mockito.doReturn(env).when(trans).env();
        Question.specialLogOn(trans, trans.user());
        retVal = (Result<Void>) facadeImplObj.deletePerm(trans, reqObj,
                respObj);
        assertTrue(retVal.status == 0);
    }
    @Test
    @SuppressWarnings("unchecked")
    public void testDeletePermWithTypeInstanceAction() {
        RosettaData<PERMS> dataObj = Mockito.mock(RosettaData.class);
        HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);

        Result<Void> retVal = (Result<Void>) facadeImplObj.deletePerm(trans,
                respObj, "type", "instance", "action");
        assertTrue(retVal.status == 20);

        Result<PERMS> rsVoid = new Result<PERMS>(null, 31, "test",
                new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService).deletePerm(Mockito.any(),
                Mockito.anyString(), Mockito.anyString(), Mockito.anyString());
        retVal = (Result<Void>) facadeImplObj.deletePerm(trans, respObj, "type",
                "instance", "action");
        assertTrue(retVal.status == 31);

        rsVoid = new Result<PERMS>(null, 0, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService).deletePerm(Mockito.any(),
                Mockito.anyString(), Mockito.anyString(), Mockito.anyString());
        Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
        try {
            Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        retVal = (Result<Void>) facadeImplObj.deletePerm(trans, respObj, "type",
                "instance", "action");
        assertTrue(retVal.status == 0);

    }

    @Test
    @SuppressWarnings("unchecked")
    public void testCreateRole() {
        RosettaData<PERMS> dataObj = Mockito.mock(RosettaData.class);
        HttpServletRequest reqObj = Mockito.mock(HttpServletRequest.class);
        HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);

        Result<Void> retVal = (Result<Void>) facadeImplObj.createRole(trans,
                reqObj, respObj);
        assertTrue(retVal.status == 20);

        Mockito.doReturn(dataObj).when(rossetaObj).newData();
        try {
            Mockito.doThrow(new APIException("test exception")).when(dataObj)
                    .load(Mockito.any(ServletInputStream.class));
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        retVal = (Result<Void>) facadeImplObj.createRole(trans, reqObj,
                respObj);
        assertTrue(retVal.status == Status.ERR_BadData);

        try {
            Mockito.doReturn(dataObj).when(dataObj)
                    .load(Mockito.any(ServletInputStream.class));
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        retVal = (Result<Void>) facadeImplObj.createRole(trans, reqObj,
                respObj);
        assertTrue(retVal.status == 20);

        Result<PERMS> rsVoid = new Result<PERMS>(null, 31, "test",
                new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService).createRole(Mockito.any(),
                Mockito.any());
        retVal = (Result<Void>) facadeImplObj.createRole(trans, reqObj,
                respObj);
        assertTrue(retVal.status == 31);

        rsVoid = new Result<PERMS>(null, 0, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService).createRole(Mockito.any(),
                Mockito.any());
        Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
        try {
            Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        retVal = (Result<Void>) facadeImplObj.createRole(trans, reqObj,
                respObj);
        assertTrue(retVal.status == 0);

        Mockito.doReturn("user").when(trans).user();
        Mockito.doReturn(env).when(trans).env();
        Question.specialLogOn(trans, trans.user());
        retVal = (Result<Void>) facadeImplObj.createRole(trans, reqObj,
                respObj);
        assertTrue(retVal.status == 0);
    }
    @Test
    @SuppressWarnings("unchecked")
    public void testGetRolesByName() {
        RosettaData<ROLES> dataObj = Mockito.mock(RosettaData.class);
        HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);

        Result<Void> retVal = (Result<Void>) facadeImplObj.getRolesByName(trans,
                respObj, "role");
        assertTrue(retVal.status == 20);

        Result<ROLES> rsVoid = new Result<ROLES>(null, 31, "test",
                new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService)
                .getRolesByName(Mockito.any(), Mockito.any());
        retVal = (Result<Void>) facadeImplObj.getRolesByName(trans, respObj,
                "role");
        assertTrue(retVal.status == 31);

        rsVoid = new Result<ROLES>(null, 0, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService)
                .getRolesByName(Mockito.any(), Mockito.anyString());
        Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
        try {
            Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        retVal = (Result<Void>) facadeImplObj.getRolesByName(trans, respObj,
                "role");
        assertTrue(retVal.status == 0);

        Mockito.doReturn("user").when(trans).user();
        Mockito.doReturn(env).when(trans).env();
        Question.specialLogOn(trans, trans.user());
        retVal = (Result<Void>) facadeImplObj.getRolesByName(trans, respObj,
                "role");
        assertTrue(retVal.status == 0);
    }
    @Test
    @SuppressWarnings("unchecked")
    public void testGetRolesByUser() {
        RosettaData<ROLES> dataObj = Mockito.mock(RosettaData.class);
        HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);

        Result<Void> retVal = (Result<Void>) facadeImplObj.getRolesByUser(trans,
                respObj, "user");
        assertTrue(retVal.status == 20);

        Result<ROLES> rsVoid = new Result<ROLES>(null, 31, "test",
                new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService)
                .getRolesByUser(Mockito.any(), Mockito.any());
        retVal = (Result<Void>) facadeImplObj.getRolesByUser(trans, respObj,
                "user");
        assertTrue(retVal.status == 31);

        rsVoid = new Result<ROLES>(null, 0, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService)
                .getRolesByUser(Mockito.any(), Mockito.anyString());
        Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
        try {
            Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        retVal = (Result<Void>) facadeImplObj.getRolesByUser(trans, respObj,
                "user");
        assertTrue(retVal.status == 0);

        Mockito.doReturn("user").when(trans).user();
        Mockito.doReturn(env).when(trans).env();
        Question.specialLogOn(trans, trans.user());
        retVal = (Result<Void>) facadeImplObj.getRolesByUser(trans, respObj,
                "user");
        assertTrue(retVal.status == 0);
    }
    @Test
    @SuppressWarnings("unchecked")
    public void testGetRolesByNS() {
        Mockito.doReturn("user").when(trans).user();
        Mockito.doReturn(env).when(trans).env();
        RosettaData<ROLES> dataObj = Mockito.mock(RosettaData.class);
        HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);

        Result<Void> retVal = (Result<Void>) facadeImplObj.getRolesByNS(trans,
                respObj, "ns");
        assertTrue(retVal.status == 20);

        Result<ROLES> rsVoid = new Result<ROLES>(null, 31, "test",
                new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService).getRolesByNS(Mockito.any(),
                Mockito.any());
        retVal = (Result<Void>) facadeImplObj.getRolesByNS(trans, respObj,
                "ns");
        assertTrue(retVal.status == 31);

        rsVoid = new Result<ROLES>(null, 0, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService).getRolesByNS(Mockito.any(),
                Mockito.anyString());
        Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
        try {
            Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        retVal = (Result<Void>) facadeImplObj.getRolesByNS(trans, respObj,
                "ns");
        assertTrue(retVal.status == 0);

        rsVoid = Mockito.mock(Result.class);
        Mockito.doReturn(false).when(rsVoid).isEmpty();
        Mockito.doReturn(rsVoid).when(authzService).getRolesByNS(Mockito.any(),
                Mockito.anyString());
        Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
        try {
            Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        retVal = (Result<Void>) facadeImplObj.getRolesByNS(trans, respObj,
                "ns");
        assertTrue(retVal.status == 0);

        Question.specialLogOn(trans, trans.user());
        retVal = (Result<Void>) facadeImplObj.getRolesByNS(trans, respObj,
                "ns");
        assertTrue(retVal.status == 0);
    }

    @Test
    @SuppressWarnings("unchecked")
    public void testGetRolesByNameOnly() {
        Mockito.doReturn("user").when(trans).user();
        Mockito.doReturn(env).when(trans).env();
        RosettaData<ROLES> dataObj = Mockito.mock(RosettaData.class);
        HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);

        Result<Void> retVal = (Result<Void>) facadeImplObj
                .getRolesByNameOnly(trans, respObj, "ns");
        assertTrue(retVal.status == 20);

        Result<ROLES> rsVoid = new Result<ROLES>(null, 31, "test",
                new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService)
                .getRolesByNameOnly(Mockito.any(), Mockito.any());
        retVal = (Result<Void>) facadeImplObj.getRolesByNameOnly(trans, respObj,
                "ns");
        assertTrue(retVal.status == 31);

        rsVoid = new Result<ROLES>(null, 0, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService)
                .getRolesByNameOnly(Mockito.any(), Mockito.anyString());
        Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
        try {
            Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        retVal = (Result<Void>) facadeImplObj.getRolesByNameOnly(trans, respObj,
                "ns");
        assertTrue(retVal.status == 0);

        rsVoid = Mockito.mock(Result.class);
        Mockito.doReturn(false).when(rsVoid).isEmpty();
        Mockito.doReturn(rsVoid).when(authzService)
                .getRolesByNameOnly(Mockito.any(), Mockito.anyString());
        Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
        try {
            Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        retVal = (Result<Void>) facadeImplObj.getRolesByNameOnly(trans, respObj,
                "ns");
        assertTrue(retVal.status == 0);

        Question.specialLogOn(trans, trans.user());
        retVal = (Result<Void>) facadeImplObj.getRolesByNameOnly(trans, respObj,
                "ns");
        assertTrue(retVal.status == 0);
    }

    @Test
    @SuppressWarnings("unchecked")
    public void testGetRolesByPerm() {
        RosettaData<ROLES> dataObj = Mockito.mock(RosettaData.class);
        HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);

        Result<Void> retVal = (Result<Void>) facadeImplObj.getRolesByPerm(trans,
                respObj, "type", "instance", "action");
        assertTrue(retVal.status == 20);

        Result<ROLES> rsVoid = new Result<ROLES>(null, 31, "test",
                new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService).getRolesByPerm(trans,
                "type", "instance", "action");
        retVal = (Result<Void>) facadeImplObj.getRolesByPerm(trans, respObj,
                "type", "instance", "action");
        assertTrue(retVal.status == 31);

        rsVoid = new Result<ROLES>(null, 0, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService).getRolesByPerm(trans,
                "type", "instance", "action");
        Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
        try {
            Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        retVal = (Result<Void>) facadeImplObj.getRolesByPerm(trans, respObj,
                "type", "instance", "action");
        assertTrue(retVal.status == 0);

        Mockito.doReturn("user").when(trans).user();
        Mockito.doReturn(env).when(trans).env();
        Question.specialLogOn(trans, trans.user());
        retVal = (Result<Void>) facadeImplObj.getRolesByPerm(trans, respObj,
                "type", "instance", "action");
        assertTrue(retVal.status == 0);
    }
    @Test
    @SuppressWarnings("unchecked")
    public void testUpdateRoleDescription() {
        RosettaData<PERMS> dataObj = Mockito.mock(RosettaData.class);
        HttpServletRequest reqObj = Mockito.mock(HttpServletRequest.class);
        HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);

        Result<Void> retVal = (Result<Void>) facadeImplObj
                .updateRoleDescription(trans, reqObj, respObj);
        assertTrue(retVal.status == 20);

        Mockito.doReturn(dataObj).when(rossetaObj).newData();
        try {
            Mockito.doThrow(new APIException("test exception")).when(dataObj)
                    .load(Mockito.any(ServletInputStream.class));
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        retVal = (Result<Void>) facadeImplObj.updateRoleDescription(trans,
                reqObj, respObj);
        assertTrue(retVal.status == Status.ERR_BadData);

        try {
            Mockito.doReturn(dataObj).when(dataObj)
                    .load(Mockito.any(ServletInputStream.class));
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        retVal = (Result<Void>) facadeImplObj.updateRoleDescription(trans,
                reqObj, respObj);
        assertTrue(retVal.status == 20);

        Result<PERMS> rsVoid = new Result<PERMS>(null, 31, "test",
                new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService)
                .updateRoleDescription(Mockito.any(), Mockito.any());
        retVal = (Result<Void>) facadeImplObj.updateRoleDescription(trans,
                reqObj, respObj);
        assertTrue(retVal.status == 31);

        rsVoid = new Result<PERMS>(null, 0, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService)
                .updateRoleDescription(Mockito.any(), Mockito.any());
        Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
        try {
            Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        retVal = (Result<Void>) facadeImplObj.updateRoleDescription(trans,
                reqObj, respObj);
        assertTrue(retVal.status == 0);

        Mockito.doReturn("user").when(trans).user();
        Mockito.doReturn(env).when(trans).env();
        Question.specialLogOn(trans, trans.user());
        retVal = (Result<Void>) facadeImplObj.updateRoleDescription(trans,
                reqObj, respObj);
        assertTrue(retVal.status == 0);
    }
    @Test
    @SuppressWarnings("unchecked")
    public void testAddPermToRole() {
        RosettaData<REQUEST> dataObj = Mockito.mock(RosettaData.class);
        HttpServletRequest reqObj = Mockito.mock(HttpServletRequest.class);
        HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);

        Result<Void> retVal = (Result<Void>) facadeImplObj.addPermToRole(trans,
                reqObj, respObj);
        assertTrue(retVal.status == 20);

        Mockito.doReturn(dataObj).when(rossetaObj).newData();
        try {
            Mockito.doThrow(new APIException("test exception")).when(dataObj)
                    .load(Mockito.any(ServletInputStream.class));
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        retVal = (Result<Void>) facadeImplObj.addPermToRole(trans, reqObj,
                respObj);
        assertTrue(retVal.status == Status.ERR_BadData);

        try {
            Mockito.doReturn(dataObj).when(dataObj)
                    .load(Mockito.any(ServletInputStream.class));
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        retVal = (Result<Void>) facadeImplObj.addPermToRole(trans, reqObj,
                respObj);
        assertTrue(retVal.status == 20);

        Result<REQUEST> rsRequest = new Result<REQUEST>(null, 31, "test",
                new Object[0]);
        Mockito.doReturn(rsRequest).when(authzService)
                .addPermToRole(Mockito.any(), Mockito.any());
        retVal = (Result<Void>) facadeImplObj.addPermToRole(trans, reqObj,
                respObj);
        assertTrue(retVal.status == 31);

        rsRequest = new Result<REQUEST>(null, 0, "test", new Object[0]);
        Mockito.doReturn(rsRequest).when(authzService)
                .addPermToRole(Mockito.any(), Mockito.any());
        Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
        try {
            Mockito.doReturn(dataObj).when(dataObj).load(rsRequest.value);
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        try {
            Mockito.doReturn(Mockito.mock(ServletOutputStream.class))
                    .when(respObj).getOutputStream();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        retVal = (Result<Void>) facadeImplObj.addPermToRole(trans, reqObj,
                respObj);
        assertTrue(retVal.status == 0);

        Mockito.doReturn("user").when(trans).user();
        Mockito.doReturn(env).when(trans).env();
        Question.specialLogOn(trans, trans.user());
        retVal = (Result<Void>) facadeImplObj.addPermToRole(trans, reqObj,
                respObj);
        assertTrue(retVal.status == 0);
    }
    @Test
    @SuppressWarnings("unchecked")
    public void testDelPermFromRole() {
        RosettaData<REQUEST> dataObj = Mockito.mock(RosettaData.class);
        HttpServletRequest reqObj = Mockito.mock(HttpServletRequest.class);
        HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);

        Result<Void> retVal = (Result<Void>) facadeImplObj
                .delPermFromRole(trans, reqObj, respObj);
        assertTrue(retVal.status == 20);

        Mockito.doReturn(dataObj).when(rossetaObj).newData();
        try {
            Mockito.doThrow(new APIException("test exception")).when(dataObj)
                    .load(Mockito.any(ServletInputStream.class));
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        retVal = (Result<Void>) facadeImplObj.delPermFromRole(trans, reqObj,
                respObj);
        assertTrue(retVal.status == Status.ERR_BadData);

        try {
            Mockito.doReturn(dataObj).when(dataObj)
                    .load(Mockito.any(ServletInputStream.class));
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        retVal = (Result<Void>) facadeImplObj.delPermFromRole(trans, reqObj,
                respObj);
        assertTrue(retVal.status == 20);

        Result<REQUEST> rsRequest = new Result<REQUEST>(null, 31, "test",
                new Object[0]);
        Mockito.doReturn(rsRequest).when(authzService)
                .delPermFromRole(Mockito.any(), Mockito.any());
        retVal = (Result<Void>) facadeImplObj.delPermFromRole(trans, reqObj,
                respObj);
        assertTrue(retVal.status == 31);

        rsRequest = new Result<REQUEST>(null, 0, "test", new Object[0]);
        Mockito.doReturn(rsRequest).when(authzService)
                .delPermFromRole(Mockito.any(), Mockito.any());
        Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
        try {
            Mockito.doReturn(dataObj).when(dataObj).load(rsRequest.value);
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        try {
            Mockito.doReturn(Mockito.mock(ServletOutputStream.class))
                    .when(respObj).getOutputStream();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        retVal = (Result<Void>) facadeImplObj.delPermFromRole(trans, reqObj,
                respObj);
        assertTrue(retVal.status == 0);

        Mockito.doReturn("user").when(trans).user();
        Mockito.doReturn(env).when(trans).env();
        Question.specialLogOn(trans, trans.user());
        retVal = (Result<Void>) facadeImplObj.delPermFromRole(trans, reqObj,
                respObj);
        assertTrue(retVal.status == 0);
    }
    @Test
    @SuppressWarnings("unchecked")
    public void testDelPermFromRoleWithAddlParams() {
        RosettaData<REQUEST> dataObj = Mockito.mock(RosettaData.class);
        HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);

        Result<Void> retVal = (Result<Void>) facadeImplObj.delPermFromRole(
                trans, respObj, "role", "type", "instance", "action");
        assertTrue(retVal.status == 20);

        Result<REQUEST> rsRequest = new Result<REQUEST>(null, 31, "test",
                new Object[0]);
        Mockito.doReturn(rsRequest).when(authzService).delPermFromRole(trans,
                "role", "type", "instance", "action");
        retVal = (Result<Void>) facadeImplObj.delPermFromRole(trans, respObj,
                "role", "type", "instance", "action");
        assertTrue(retVal.status == 31);

        rsRequest = new Result<REQUEST>(null, 0, "test", new Object[0]);
        Mockito.doReturn(rsRequest).when(authzService).delPermFromRole(trans,
                "role", "type", "instance", "action");
        Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
        try {
            Mockito.doReturn(dataObj).when(dataObj).load(rsRequest.value);
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        try {
            Mockito.doReturn(Mockito.mock(ServletOutputStream.class))
                    .when(respObj).getOutputStream();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        retVal = (Result<Void>) facadeImplObj.delPermFromRole(trans, respObj,
                "role", "type", "instance", "action");
        assertTrue(retVal.status == 0);

        Mockito.doReturn("user").when(trans).user();
        Mockito.doReturn(env).when(trans).env();
        Question.specialLogOn(trans, trans.user());
        retVal = (Result<Void>) facadeImplObj.delPermFromRole(trans, respObj,
                "role", "type", "instance", "action");
        assertTrue(retVal.status == 0);
    }
    @Test
    @SuppressWarnings("unchecked")
    public void testDeleteRole() {
        RosettaData<REQUEST> dataObj = Mockito.mock(RosettaData.class);
        HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);

        Result<Void> retVal = (Result<Void>) facadeImplObj.deleteRole(trans,
                respObj, "role");
        assertTrue(retVal.status == 20);

        Result<REQUEST> rsRequest = new Result<REQUEST>(null, 31, "test",
                new Object[0]);
        Mockito.doReturn(rsRequest).when(authzService).deleteRole(trans,
                "role");
        retVal = (Result<Void>) facadeImplObj.deleteRole(trans, respObj,
                "role");
        assertTrue(retVal.status == 31);

        rsRequest = new Result<REQUEST>(null, 0, "test", new Object[0]);
        Mockito.doReturn(rsRequest).when(authzService).deleteRole(trans,
                "role");
        Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
        try {
            Mockito.doReturn(dataObj).when(dataObj).load(rsRequest.value);
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        retVal = (Result<Void>) facadeImplObj.deleteRole(trans, respObj,
                "role");
        assertTrue(retVal.status == 0);

        Mockito.doReturn("user").when(trans).user();
        Mockito.doReturn(env).when(trans).env();
        Question.specialLogOn(trans, trans.user());
        retVal = (Result<Void>) facadeImplObj.deleteRole(trans, respObj,
                "role");
        assertTrue(retVal.status == 0);
    }
    @Test
    @SuppressWarnings("unchecked")
    public void testDeleteRole2() {
        RosettaData<Void> dataObj = Mockito.mock(RosettaData.class);
        HttpServletRequest reqObj = Mockito.mock(HttpServletRequest.class);
        HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);

        Result<Void> retVal = (Result<Void>) facadeImplObj.deleteRole(trans,
                reqObj, respObj);
        assertTrue(retVal.status == 20);

        Mockito.doReturn(dataObj).when(rossetaObj).newData();
        try {
            Mockito.doThrow(new APIException("test exception")).when(dataObj)
                    .load(Mockito.any(ServletInputStream.class));
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        retVal = (Result<Void>) facadeImplObj.deleteRole(trans, reqObj,
                respObj);
        assertTrue(retVal.status == Status.ERR_BadData);

        Result<Void> rsRequest = new Result<Void>(null, 31, "test",
                new Object[0]);
        Mockito.doReturn(rsRequest).when(authzService).deleteRole(trans, null);

        try {
            Mockito.doReturn(dataObj).when(dataObj)
                    .load(Mockito.any(ServletInputStream.class));
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        retVal = (Result<Void>) facadeImplObj.deleteRole(trans, reqObj,
                respObj);
        assertTrue(retVal.status == 20);

        rsRequest = new Result<Void>(null, 0, "test", new Object[0]);
        Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
        try {
            Mockito.doReturn(dataObj).when(dataObj).load(rsRequest.value);
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        retVal = (Result<Void>) facadeImplObj.deleteRole(trans, reqObj,
                respObj);
        assertTrue(retVal.status == 20);

        Mockito.doReturn("user").when(trans).user();
        Mockito.doReturn(env).when(trans).env();
        Question.specialLogOn(trans, trans.user());
        retVal = (Result<Void>) facadeImplObj.deleteRole(trans, reqObj,
                respObj);
        assertTrue(retVal.status == 20);
    }

    @Test
    @SuppressWarnings("unchecked")
    public void testCreateUserCred() {
        RosettaData<REQUEST> dataObj = Mockito.mock(RosettaData.class);
        HttpServletRequest reqObj = Mockito.mock(HttpServletRequest.class);

        Result<Void> retVal = (Result<Void>) facadeImplObj.createUserCred(trans,
                reqObj);
        assertTrue(retVal.status == 20);

        Mockito.doReturn(dataObj).when(rossetaObj).newData();
        try {
            Mockito.doThrow(new APIException("test exception")).when(dataObj)
                    .load(Mockito.any(ServletInputStream.class));
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        retVal = (Result<Void>) facadeImplObj.createUserCred(trans, reqObj);
        assertTrue(retVal.status == Status.ERR_BadData);

        try {
            Mockito.doReturn(dataObj).when(dataObj)
                    .load(Mockito.any(ServletInputStream.class));
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        Result<Void> rsRequest = new Result<Void>(null, 31, "test",
                new Object[0]);
        Mockito.doReturn(rsRequest).when(authzService)
                .createUserCred(Mockito.any(), Mockito.any());
        retVal = (Result<Void>) facadeImplObj.createUserCred(trans, reqObj);

        assertTrue(retVal.status == 31);

        Mockito.doReturn("user").when(trans).user();
        Mockito.doReturn(env).when(trans).env();
        Question.specialLogOn(trans, trans.user());
        retVal = (Result<Void>) facadeImplObj.createUserCred(trans, reqObj);
        assertTrue(retVal.status == 31);
    }
    @Test
    @SuppressWarnings("unchecked")
    public void testChangeUserCred() {
        RosettaData<REQUEST> dataObj = Mockito.mock(RosettaData.class);
        HttpServletRequest reqObj = Mockito.mock(HttpServletRequest.class);

        Result<Void> retVal = (Result<Void>) facadeImplObj.changeUserCred(trans,
                reqObj);
        assertTrue(retVal.status == 20);

        Mockito.doReturn(dataObj).when(rossetaObj).newData();
        try {
            Mockito.doThrow(new APIException("test exception")).when(dataObj)
                    .load(Mockito.any(ServletInputStream.class));
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        retVal = (Result<Void>) facadeImplObj.changeUserCred(trans, reqObj);
        assertTrue(retVal.status == Status.ERR_BadData);

        try {
            Mockito.doReturn(dataObj).when(dataObj)
                    .load(Mockito.any(ServletInputStream.class));
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        Result<Void> rsRequest = new Result<Void>(null, 31, "test",
                new Object[0]);
        Mockito.doReturn(rsRequest).when(authzService)
                .resetUserCred(Mockito.any(), Mockito.any());
        retVal = (Result<Void>) facadeImplObj.changeUserCred(trans, reqObj);

        assertTrue(retVal.status == 31);

        Mockito.doReturn("user").when(trans).user();
        Mockito.doReturn(env).when(trans).env();
        Question.specialLogOn(trans, trans.user());
        retVal = (Result<Void>) facadeImplObj.changeUserCred(trans, reqObj);
        assertTrue(retVal.status == 31);
    }

    @Test
    @SuppressWarnings("unchecked")
    public void testExtendUserCred() {
        RosettaData<REQUEST> dataObj = Mockito.mock(RosettaData.class);
        HttpServletRequest reqObj = Mockito.mock(HttpServletRequest.class);

        Result<Void> retVal = (Result<Void>) facadeImplObj.extendUserCred(trans,
                reqObj, "10");
        assertTrue(retVal.status == 20);

        Mockito.doReturn(dataObj).when(rossetaObj).newData();
        try {
            Mockito.doThrow(new APIException("test exception")).when(dataObj)
                    .load(Mockito.any(ServletInputStream.class));
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        retVal = (Result<Void>) facadeImplObj.extendUserCred(trans, reqObj,
                "10");
        assertTrue(retVal.status == Status.ERR_BadData);

        try {
            Mockito.doReturn(dataObj).when(dataObj)
                    .load(Mockito.any(ServletInputStream.class));
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        Result<Void> rsRequest = new Result<Void>(null, 31, "test",
                new Object[0]);
        Mockito.doReturn(rsRequest).when(authzService).extendUserCred(
                Mockito.any(), Mockito.any(), Mockito.anyString());
        retVal = (Result<Void>) facadeImplObj.extendUserCred(trans, reqObj,
                "10");

        assertTrue(retVal.status == 31);

        Mockito.doReturn("user").when(trans).user();
        Mockito.doReturn(env).when(trans).env();
        Question.specialLogOn(trans, trans.user());
        retVal = (Result<Void>) facadeImplObj.extendUserCred(trans, reqObj,
                "10");
        assertTrue(retVal.status == 31);
    }

    @Test
    @SuppressWarnings("unchecked")
    public void testGetCredsByNS() {
        HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
        Result<Void> retVal = (Result<Void>) facadeImplObj.getCredsByNS(trans,
                respObj, "ns");
        assertTrue(retVal.status == 20);

        Result<NSS> rsVoid = new Result<NSS>(null, 31, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService).getCredsByNS(trans, "ns");
        retVal = (Result<Void>) facadeImplObj.getCredsByNS(trans, respObj,
                "ns");
        assertTrue(retVal.status == 31);

        rsVoid = new Result<NSS>(null, 0, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService).getCredsByNS(trans, "ns");
        try {
            Mockito.doReturn(Mockito.mock(ServletOutputStream.class))
                    .when(respObj).getOutputStream();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        RosettaData<NSS> dataObj = Mockito.mock(RosettaData.class);
        Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
        try {
            Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        retVal = (Result<Void>) facadeImplObj.getCredsByNS(trans, respObj,
                "ns");
        assertTrue(retVal.status == 0);

        Mockito.doReturn("user").when(trans).user();
        Mockito.doReturn(env).when(trans).env();
        Question.specialLogOn(trans, trans.user());
        retVal = (Result<Void>) facadeImplObj.getCredsByNS(trans, respObj,
                "ns");
        assertTrue(retVal.status == 0);
    }
    @Test
    @SuppressWarnings("unchecked")
    public void testGetCredsByID() {
        HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
        Result<Void> retVal = (Result<Void>) facadeImplObj.getCredsByID(trans,
                respObj, "id");
        assertTrue(retVal.status == 20);

        Result<NSS> rsVoid = new Result<NSS>(null, 31, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService).getCredsByID(trans, "id");
        retVal = (Result<Void>) facadeImplObj.getCredsByID(trans, respObj,
                "id");
        assertTrue(retVal.status == 31);

        rsVoid = new Result<NSS>(null, 0, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService).getCredsByID(trans, "id");
        try {
            Mockito.doReturn(Mockito.mock(ServletOutputStream.class))
                    .when(respObj).getOutputStream();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        RosettaData<NSS> dataObj = Mockito.mock(RosettaData.class);
        Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
        try {
            Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        retVal = (Result<Void>) facadeImplObj.getCredsByID(trans, respObj,
                "id");
        assertTrue(retVal.status == 0);

        Mockito.doReturn("user").when(trans).user();
        Mockito.doReturn(env).when(trans).env();
        Question.specialLogOn(trans, trans.user());
        retVal = (Result<Void>) facadeImplObj.getCredsByID(trans, respObj,
                "id");
        assertTrue(retVal.status == 0);
    }
    @Test
    @SuppressWarnings("unchecked")
    public void testDeleteUserCred() {
        HttpServletRequest reqObj = Mockito.mock(HttpServletRequest.class);
        Result<Void> retVal = (Result<Void>) facadeImplObj.deleteUserCred(trans,
                reqObj);
        assertTrue(retVal.status == 20);

        RosettaData<REQUEST> dataObj = Mockito.mock(RosettaData.class);
        Mockito.doReturn(dataObj).when(rossetaObj).newData();
        try {
            Mockito.doThrow(new APIException("test exception")).when(dataObj)
                    .load(Mockito.any(ServletInputStream.class));
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        retVal = (Result<Void>) facadeImplObj.deleteUserCred(trans, reqObj);
        assertTrue(retVal.status == 4);

        try {
            Mockito.doReturn(dataObj).when(dataObj)
                    .load(Mockito.any(ServletInputStream.class));
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        Result<NSS> rsVoid = new Result<NSS>(null, 31, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService)
                .deleteUserCred(Mockito.any(), Mockito.any());
        retVal = (Result<Void>) facadeImplObj.deleteUserCred(trans, reqObj);
        assertTrue(retVal.status == 31);

        Mockito.doReturn("user").when(trans).user();
        Mockito.doReturn(env).when(trans).env();
        Question.specialLogOn(trans, trans.user());
        retVal = (Result<Void>) facadeImplObj.deleteUserCred(trans, reqObj);
        assertTrue(retVal.status == 31);
    }
    @Test
    @SuppressWarnings("unchecked")
    public void testDoesCredentialMatch() {
        HttpServletRequest reqObj = Mockito.mock(HttpServletRequest.class);
        HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);

        RosettaData<REQUEST> dataObj = Mockito.mock(RosettaData.class);
        Mockito.doReturn(dataObj).when(rossetaObj).newData();
        try {
            Mockito.doThrow(new APIException("test exception")).when(dataObj)
                    .load(Mockito.any(ServletInputStream.class));
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        Result<Date> retVal = (Result<Date>) facadeImplObj
                .doesCredentialMatch(trans, reqObj, respObj);
        assertTrue(retVal.status == 4);

        try {
            Mockito.doReturn(dataObj).when(dataObj)
                    .load(Mockito.any(ServletInputStream.class));
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        Result<NSS> rsVoid = new Result<NSS>(null, 31, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService)
                .doesCredentialMatch(Mockito.any(), Mockito.any());
        retVal = (Result<Date>) facadeImplObj.doesCredentialMatch(trans, reqObj,
                respObj);
        assertTrue(retVal.status == 31);

        Mockito.doReturn("user").when(trans).user();
        Mockito.doReturn(env).when(trans).env();
        Question.specialLogOn(trans, trans.user());
        retVal = (Result<Date>) facadeImplObj.doesCredentialMatch(trans, reqObj,
                respObj);
        assertTrue(retVal.status == 31);

        try {
            Mockito.doThrow(new IOException("test exception")).when(reqObj)
                    .getInputStream();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        retVal = (Result<Date>) facadeImplObj.doesCredentialMatch(trans, reqObj,
                respObj);
        assertTrue(retVal.status == 20);
    }
    @Test
    @SuppressWarnings("unchecked")
    public void testValidBasicAuth() {
        HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);

        Result<NSS> rsVoid = new Result<NSS>(null, 31, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService).validateBasicAuth(trans,
                "basicAuth");
        Result<Void> retVal = (Result<Void>) facadeImplObj.validBasicAuth(trans,
                respObj, "basicAuth");
        assertTrue(retVal.status == 31);

        rsVoid = new Result<NSS>(null, 0, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService).validateBasicAuth(trans,
                "basicAuth");
        retVal = (Result<Void>) facadeImplObj.validBasicAuth(trans, respObj,
                "basicAuth");
        assertTrue(retVal.status == 20);

        try {
            Mockito.doReturn(Mockito.mock(ServletOutputStream.class))
                    .when(respObj).getOutputStream();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        rsVoid = new Result<NSS>(null, 0, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService).validateBasicAuth(trans,
                "basicAuth");
        retVal = (Result<Void>) facadeImplObj.validBasicAuth(trans, respObj,
                "basicAuth");
        assertTrue(retVal.status == 0);

    }
    @Test
    @SuppressWarnings("unchecked")
    public void testGetCertInfoByID() {
        HttpServletRequest reqObj = Mockito.mock(HttpServletRequest.class);
        HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);

        Result<NSS> rsVoid = new Result<NSS>(null, 31, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService).getCertInfoByID(trans,
                reqObj, "id");
        Result<Void> retVal = (Result<Void>) facadeImplObj
                .getCertInfoByID(trans, reqObj, respObj, "id");
        assertTrue(retVal.status == 31);

        rsVoid = new Result<NSS>(null, 0, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService).getCertInfoByID(trans,
                reqObj, "id");
        retVal = (Result<Void>) facadeImplObj.getCertInfoByID(trans, reqObj,
                respObj, "id");
        assertTrue(retVal.status == 0);

        Mockito.doReturn("user").when(trans).user();
        Mockito.doReturn(env).when(trans).env();
        Question.specialLogOn(trans, trans.user());
        RosettaData<NSS> dataObj = Mockito.mock(RosettaData.class);
        Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
        try {
            Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        retVal = (Result<Void>) facadeImplObj.getCertInfoByID(trans, reqObj,
                respObj, "id");
        assertTrue(retVal.status == 0);

        try {
            Mockito.doThrow(new APIException("test exception")).when(dataObj)
                    .load(rsVoid.value);
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        retVal = (Result<Void>) facadeImplObj.getCertInfoByID(trans, reqObj,
                respObj, "id");
        assertTrue(retVal.status == 20);
    }

    @Test
    @SuppressWarnings("unchecked")
    public void testCreateDelegate() {
        HttpServletRequest reqObj = Mockito.mock(HttpServletRequest.class);
        HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);

        Result<Void> retVal = (Result<Void>) facadeImplObj.createDelegate(trans,
                reqObj, respObj);
        assertTrue(retVal.status == 20);

        RosettaData<REQUEST> dataObj = Mockito.mock(RosettaData.class);
        Mockito.doReturn(dataObj).when(rossetaObj).newData();
        try {
            Mockito.doReturn(Mockito.mock(ServletInputStream.class))
                    .when(reqObj).getInputStream();

            Mockito.doReturn(dataObj).when(dataObj)
                    .load(Mockito.any(ServletInputStream.class));
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        Result<Void> rsVoid = new Result<Void>(null, 0, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService)
                .createDelegate(Mockito.any(), Mockito.anyObject());

        retVal = (Result<Void>) facadeImplObj.createDelegate(trans, reqObj,
                respObj);
        assertTrue(retVal.status == 0);

        Mockito.doReturn("user").when(trans).user();
        Mockito.doReturn(env).when(trans).env();
        Question.specialLogOn(trans, trans.user());

        rsVoid = new Result<Void>(null, 0, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService)
                .createDelegate(Mockito.any(), Mockito.any());
        retVal = (Result<Void>) facadeImplObj.createDelegate(trans, reqObj,
                respObj);
        assertTrue(retVal.status == 0);

    }
    @Test
    @SuppressWarnings("unchecked")
    public void testUpdateDelegate() {
        HttpServletRequest reqObj = Mockito.mock(HttpServletRequest.class);
        HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);

        Result<Void> retVal = (Result<Void>) facadeImplObj.updateDelegate(trans,
                reqObj, respObj);
        assertTrue(retVal.status == 20);

        RosettaData<REQUEST> dataObj = Mockito.mock(RosettaData.class);
        Mockito.doReturn(dataObj).when(rossetaObj).newData();
        try {
            Mockito.doReturn(Mockito.mock(ServletInputStream.class))
                    .when(reqObj).getInputStream();

            Mockito.doReturn(dataObj).when(dataObj)
                    .load(Mockito.any(ServletInputStream.class));
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        Result<Void> rsVoid = new Result<Void>(null, 0, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService)
                .updateDelegate(Mockito.any(), Mockito.anyObject());

        retVal = (Result<Void>) facadeImplObj.updateDelegate(trans, reqObj,
                respObj);
        assertTrue(retVal.status == 0);

        Mockito.doReturn("user").when(trans).user();
        Mockito.doReturn(env).when(trans).env();
        Question.specialLogOn(trans, trans.user());

        rsVoid = new Result<Void>(null, 0, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService)
                .updateDelegate(Mockito.any(), Mockito.any());
        retVal = (Result<Void>) facadeImplObj.updateDelegate(trans, reqObj,
                respObj);
        assertTrue(retVal.status == 0);

    }

    @Test
    @SuppressWarnings("unchecked")
    public void testDeleteDelegate() {
        HttpServletRequest reqObj = Mockito.mock(HttpServletRequest.class);
        HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);

        Result<Void> retVal = (Result<Void>) facadeImplObj.deleteDelegate(trans,
                reqObj, respObj);
        assertTrue(retVal.status == 20);

        RosettaData<REQUEST> dataObj = Mockito.mock(RosettaData.class);
        Mockito.doReturn(dataObj).when(rossetaObj).newData();
        try {
            Mockito.doReturn(Mockito.mock(ServletInputStream.class))
                    .when(reqObj).getInputStream();

            Mockito.doReturn(dataObj).when(dataObj)
                    .load(Mockito.any(ServletInputStream.class));
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        Result<Void> rsVoid = new Result<Void>(null, 0, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService)
                .deleteDelegate(Mockito.any(), Mockito.anyObject());

        retVal = (Result<Void>) facadeImplObj.deleteDelegate(trans, reqObj,
                respObj);
        assertNull(retVal);

        Mockito.doReturn("user").when(trans).user();
        Mockito.doReturn(env).when(trans).env();
        Question.specialLogOn(trans, trans.user());

        rsVoid = new Result<Void>(null, 0, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService)
                .deleteDelegate(Mockito.any(), Mockito.any());
        retVal = (Result<Void>) facadeImplObj.deleteDelegate(trans, reqObj,
                respObj);
        assertNull(retVal);

    }

    @Test
    @SuppressWarnings("unchecked")
    public void testDeleteDelegate2() {

        Result<Void> rsVoid = new Result<Void>(null, 0, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService).deleteDelegate(trans,
                "userName");

        Result<Void> retVal = (Result<Void>) facadeImplObj.deleteDelegate(trans,
                "userName");
        assertTrue(retVal.status == 0);

        Mockito.doThrow(new RuntimeException("test exception"))
                .when(authzService).deleteDelegate(trans, "userName");
        retVal = (Result<Void>) facadeImplObj.deleteDelegate(trans, "userName");
        assertTrue(retVal.status == 20);
    }
    @Test
    @SuppressWarnings("unchecked")
    public void testGetDelegatesByUser() {
        HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);

        Result<NSS> rsVoid = new Result<NSS>(null, 31, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService).getDelegatesByUser(trans,
                "user");
        Result<Void> retVal = (Result<Void>) facadeImplObj
                .getDelegatesByUser(trans, "user", respObj);
        assertTrue(retVal.status == 31);

        RosettaData<NSS> dataObj = Mockito.mock(RosettaData.class);
        Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
        try {
            Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        rsVoid = new Result<NSS>(null, 0, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService).getDelegatesByUser(trans,
                "user");
        retVal = (Result<Void>) facadeImplObj.getDelegatesByUser(trans, "user",
                respObj);
        assertTrue(retVal.status == 0);

        Mockito.doReturn("user").when(trans).user();
        Mockito.doReturn(env).when(trans).env();
        Question.specialLogOn(trans, trans.user());
        retVal = (Result<Void>) facadeImplObj.getDelegatesByUser(trans, "user",
                respObj);
        assertTrue(retVal.status == 0);

        try {
            Mockito.doThrow(new APIException("test exception")).when(dataObj)
                    .load(rsVoid.value);
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        retVal = (Result<Void>) facadeImplObj.getDelegatesByUser(trans, "user",
                respObj);
        assertTrue(retVal.status == 20);
    }
    @Test
    @SuppressWarnings("unchecked")
    public void testGetDelegatesByDelegate() {
        HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);

        Result<NSS> rsVoid = new Result<NSS>(null, 31, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService)
                .getDelegatesByDelegate(trans, "delegate");
        Result<Void> retVal = (Result<Void>) facadeImplObj
                .getDelegatesByDelegate(trans, "delegate", respObj);
        assertTrue(retVal.status == 31);

        RosettaData<NSS> dataObj = Mockito.mock(RosettaData.class);
        Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
        try {
            Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        rsVoid = new Result<NSS>(null, 0, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService)
                .getDelegatesByDelegate(trans, "delegate");
        retVal = (Result<Void>) facadeImplObj.getDelegatesByDelegate(trans,
                "delegate", respObj);
        assertTrue(retVal.status == 0);

        Mockito.doReturn("user").when(trans).user();
        Mockito.doReturn(env).when(trans).env();
        Question.specialLogOn(trans, trans.user());
        retVal = (Result<Void>) facadeImplObj.getDelegatesByDelegate(trans,
                "delegate", respObj);
        assertTrue(retVal.status == 0);

        try {
            Mockito.doThrow(new APIException("test exception")).when(dataObj)
                    .load(rsVoid.value);
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        retVal = (Result<Void>) facadeImplObj.getDelegatesByDelegate(trans,
                "delegate", respObj);
        assertTrue(retVal.status == 20);
    }

    @Test
    @SuppressWarnings("unchecked")
    public void testRequestUserRole() {
        RosettaData<?> dataObj = Mockito.mock(RosettaData.class);
        Mockito.doReturn(dataObj).when(rossetaObj).newData();
        try {
            Mockito.doThrow(new APIException("test exception")).when(dataObj)
                    .load(Mockito.any(ServletInputStream.class));
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        Result<Void> retVal = (Result<Void>) facadeImplObj.requestUserRole(
                trans, Mockito.mock(HttpServletRequest.class),
                Mockito.mock(HttpServletResponse.class));
        assertTrue(retVal.status == Status.ERR_BadData);

        try {
            Mockito.doReturn(dataObj).when(dataObj)
                    .load(Mockito.any(ServletInputStream.class));
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        retVal = (Result<Void>) facadeImplObj.requestUserRole(trans,
                Mockito.mock(HttpServletRequest.class),
                Mockito.mock(HttpServletResponse.class));
        assertTrue(retVal.status == 20);

        Result<Void> rsVoid = new Result<Void>(null, 31, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService)
                .createUserRole(Mockito.any(), Mockito.any());
        retVal = (Result<Void>) facadeImplObj.requestUserRole(trans,
                Mockito.mock(HttpServletRequest.class),
                Mockito.mock(HttpServletResponse.class));
        assertTrue(retVal.status == 31);

        rsVoid = new Result<Void>(null, 0, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService)
                .createUserRole(Mockito.any(), Mockito.any());
        retVal = (Result<Void>) facadeImplObj.requestUserRole(trans,
                Mockito.mock(HttpServletRequest.class),
                Mockito.mock(HttpServletResponse.class));
        assertTrue(retVal.status == Status.OK);

        Mockito.doReturn("user").when(trans).user();
        Mockito.doReturn(env).when(trans).env();
        Question.specialLogOn(trans, trans.user());
        retVal = (Result<Void>) facadeImplObj.requestUserRole(trans,
                Mockito.mock(HttpServletRequest.class),
                Mockito.mock(HttpServletResponse.class));
        assertTrue(retVal.status == 0);
    }

    @Test
    @SuppressWarnings("unchecked")
    public void testGetUserInRole() {
        RosettaData<USERS> dataObj = Mockito.mock(RosettaData.class);

        try {
            Mockito.doReturn(dataObj).when(dataObj)
                    .load(Mockito.any(ServletInputStream.class));
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        Result<Void> retVal = (Result<Void>) facadeImplObj.getUserInRole(trans,
                Mockito.mock(HttpServletResponse.class), "user", "role");
        assertTrue(retVal.status == 20);

        Result<USERS> rsVoid = new Result<USERS>(null, 31, "test",
                new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService).getUserInRole(trans, "user",
                "role");
        retVal = (Result<Void>) facadeImplObj.getUserInRole(trans,
                Mockito.mock(HttpServletResponse.class), "user", "role");
        assertTrue(retVal.status == 31);

        rsVoid = new Result<USERS>(null, 0, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService).getUserInRole(trans, "user",
                "role");
        Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
        try {
            Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        retVal = (Result<Void>) facadeImplObj.getUserInRole(trans,
                Mockito.mock(HttpServletResponse.class), "user", "role");
        assertTrue(retVal.status == 0);

        Mockito.doReturn("user").when(trans).user();
        Mockito.doReturn(env).when(trans).env();
        Question.specialLogOn(trans, trans.user());
        retVal = (Result<Void>) facadeImplObj.getUserInRole(trans,
                Mockito.mock(HttpServletResponse.class), "user", "role");
        assertTrue(retVal.status == 0);
    }
    @Test
    @SuppressWarnings("unchecked")
    public void testGetUserRolesByUser() {
        RosettaData<USERS> dataObj = Mockito.mock(RosettaData.class);

        try {
            Mockito.doReturn(dataObj).when(dataObj)
                    .load(Mockito.any(ServletInputStream.class));
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        Result<Void> retVal = (Result<Void>) facadeImplObj.getUserRolesByUser(
                trans, Mockito.mock(HttpServletResponse.class), "user");
        assertTrue(retVal.status == 20);

        Result<USERS> rsVoid = new Result<USERS>(null, 31, "test",
                new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService).getUserRolesByUser(trans,
                "user");
        retVal = (Result<Void>) facadeImplObj.getUserRolesByUser(trans,
                Mockito.mock(HttpServletResponse.class), "user");
        assertTrue(retVal.status == 31);

        rsVoid = new Result<USERS>(null, 0, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService).getUserRolesByUser(trans,
                "user");
        Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
        try {
            Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        retVal = (Result<Void>) facadeImplObj.getUserRolesByUser(trans,
                Mockito.mock(HttpServletResponse.class), "user");
        assertTrue(retVal.status == 0);

        Mockito.doReturn("user").when(trans).user();
        Mockito.doReturn(env).when(trans).env();
        Question.specialLogOn(trans, trans.user());
        retVal = (Result<Void>) facadeImplObj.getUserRolesByUser(trans,
                Mockito.mock(HttpServletResponse.class), "user");
        assertTrue(retVal.status == 0);
    }
    @Test
    @SuppressWarnings("unchecked")
    public void testGetUserRolesByRole() {
        RosettaData<USERS> dataObj = Mockito.mock(RosettaData.class);

        try {
            Mockito.doReturn(dataObj).when(dataObj)
                    .load(Mockito.any(ServletInputStream.class));
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        Result<Void> retVal = (Result<Void>) facadeImplObj.getUserRolesByRole(
                trans, Mockito.mock(HttpServletResponse.class), "role");
        assertTrue(retVal.status == 20);

        Result<USERS> rsVoid = new Result<USERS>(null, 31, "test",
                new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService).getUserRolesByRole(trans,
                "role");
        retVal = (Result<Void>) facadeImplObj.getUserRolesByRole(trans,
                Mockito.mock(HttpServletResponse.class), "role");
        assertTrue(retVal.status == 31);

        rsVoid = new Result<USERS>(null, 0, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService).getUserRolesByRole(trans,
                "role");
        Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
        try {
            Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        retVal = (Result<Void>) facadeImplObj.getUserRolesByRole(trans,
                Mockito.mock(HttpServletResponse.class), "role");
        assertTrue(retVal.status == 0);

        Mockito.doReturn("user").when(trans).user();
        Mockito.doReturn(env).when(trans).env();
        Question.specialLogOn(trans, trans.user());
        retVal = (Result<Void>) facadeImplObj.getUserRolesByRole(trans,
                Mockito.mock(HttpServletResponse.class), "role");
        assertTrue(retVal.status == 0);
    }

    @Test
    public void testExtendUserRoleExpiration() {

        Mockito.doThrow(new RuntimeException("test exception"))
                .when(authzService).extendUserRole(trans, "user", "role");
        Result<Void> retVal = (Result<Void>) facadeImplObj
                .extendUserRoleExpiration(trans,
                        Mockito.mock(HttpServletResponse.class), "user",
                        "role");
        assertTrue(retVal.status == 20);

        Result<USERS> rsVoid = new Result<USERS>(null, 31, "test",
                new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService).extendUserRole(trans,
                "user", "role");
        retVal = (Result<Void>) facadeImplObj.extendUserRoleExpiration(trans,
                Mockito.mock(HttpServletResponse.class), "user", "role");
        assertTrue(retVal.status == 31);

    }
    @Test
    @SuppressWarnings("unchecked")
    public void testDeleteUserRole() {

        Mockito.doThrow(new RuntimeException("test exception"))
                .when(authzService).deleteUserRole(trans, "user", "role");
        Result<Void> retVal = (Result<Void>) facadeImplObj.deleteUserRole(trans,
                Mockito.mock(HttpServletResponse.class), "user", "role");
        assertTrue(retVal.status == 20);

        Result<USERS> rsVoid = new Result<USERS>(null, 31, "test",
                new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService).deleteUserRole(trans,
                "user", "role");
        retVal = (Result<Void>) facadeImplObj.deleteUserRole(trans,
                Mockito.mock(HttpServletResponse.class), "user", "role");
        assertTrue(retVal.status == 31);

        rsVoid = new Result<USERS>(null, 0, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService).deleteUserRole(trans,
                "user", "role");

        retVal = (Result<Void>) facadeImplObj.deleteUserRole(trans,
                Mockito.mock(HttpServletResponse.class), "user", "role");
        assertTrue(retVal.status == 0);

    }
    @Test
    @SuppressWarnings("unchecked")
    public void testUpdateApproval() {
        RosettaData<USERS> dataObj = Mockito.mock(RosettaData.class);
        HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
        HttpServletRequest reqObj = Mockito.mock(HttpServletRequest.class);

        Mockito.doReturn(dataObj).when(rossetaObj).newData();
        try {
            Mockito.doReturn(dataObj).when(dataObj)
                    .load(Mockito.any(ServletInputStream.class));
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        Result<Void> retVal = (Result<Void>) facadeImplObj.updateApproval(trans,
                reqObj, respObj);
        assertTrue(retVal.status == 20);

        Result<USERS> rsVoid = new Result<USERS>(null, 31, "test",
                new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService)
                .updateApproval(Mockito.any(), Mockito.anyObject());
        retVal = (Result<Void>) facadeImplObj.updateApproval(trans, reqObj,
                respObj);
        assertTrue(retVal.status == 31);

        rsVoid = new Result<USERS>(null, 0, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService)
                .updateApproval(Mockito.any(), Mockito.anyObject());
        retVal = (Result<Void>) facadeImplObj.updateApproval(trans, reqObj,
                respObj);
        assertTrue(retVal.status == 0);

        Mockito.doReturn("user").when(trans).user();
        Mockito.doReturn(env).when(trans).env();
        Question.specialLogOn(trans, trans.user());
        retVal = (Result<Void>) facadeImplObj.updateApproval(trans, reqObj,
                respObj);
        assertTrue(retVal.status == 0);
    }
    @Test
    @SuppressWarnings("unchecked")
    public void testGetApprovalsByUser() {
        RosettaData<USERS> dataObj = Mockito.mock(RosettaData.class);
        HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);

        Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
        Result<Void> retVal = (Result<Void>) facadeImplObj
                .getApprovalsByUser(trans, respObj, "user");
        assertTrue(retVal.status == 20);

        Result<USERS> rsVoid = new Result<USERS>(null, 31, "test",
                new Object[0]);
        try {
            Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        Mockito.doReturn(rsVoid).when(authzService).getApprovalsByUser(trans,
                "user");
        retVal = (Result<Void>) facadeImplObj.getApprovalsByUser(trans, respObj,
                "user");
        assertTrue(retVal.status == 31);

        rsVoid = new Result<USERS>(null, 0, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService).getApprovalsByUser(trans,
                "user");
        retVal = (Result<Void>) facadeImplObj.getApprovalsByUser(trans, respObj,
                "user");
        assertTrue(retVal.status == 0);

        Mockito.doReturn("user").when(trans).user();
        Mockito.doReturn(env).when(trans).env();
        Question.specialLogOn(trans, trans.user());
        retVal = (Result<Void>) facadeImplObj.getApprovalsByUser(trans, respObj,
                "user");
        assertTrue(retVal.status == 0);
    }
    @Test
    @SuppressWarnings("unchecked")
    public void testGetApprovalsByApprover() {
        RosettaData<USERS> dataObj = Mockito.mock(RosettaData.class);
        HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);

        Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
        Result<Void> retVal = (Result<Void>) facadeImplObj
                .getApprovalsByApprover(trans, respObj, "approver");
        assertTrue(retVal.status == 20);

        Result<USERS> rsVoid = new Result<USERS>(null, 31, "test",
                new Object[0]);
        try {
            Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        Mockito.doReturn(rsVoid).when(authzService)
                .getApprovalsByApprover(trans, "approver");
        retVal = (Result<Void>) facadeImplObj.getApprovalsByApprover(trans,
                respObj, "approver");
        assertTrue(retVal.status == 31);

        rsVoid = new Result<USERS>(null, 0, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService)
                .getApprovalsByApprover(trans, "approver");
        retVal = (Result<Void>) facadeImplObj.getApprovalsByApprover(trans,
                respObj, "approver");
        assertTrue(retVal.status == 0);

        Mockito.doReturn("user").when(trans).user();
        Mockito.doReturn(env).when(trans).env();
        Question.specialLogOn(trans, trans.user());
        retVal = (Result<Void>) facadeImplObj.getApprovalsByApprover(trans,
                respObj, "approver");
        assertTrue(retVal.status == 0);
    }
    @Test
    @SuppressWarnings("unchecked")
    public void testGetApprovalsByTicket() {
        RosettaData<USERS> dataObj = Mockito.mock(RosettaData.class);
        HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);

        Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
        Result<Void> retVal = (Result<Void>) facadeImplObj
                .getApprovalsByTicket(trans, respObj, "ticket");
        assertTrue(retVal.status == 20);

        Result<USERS> rsVoid = new Result<USERS>(null, 31, "test",
                new Object[0]);
        try {
            Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        Mockito.doReturn(rsVoid).when(authzService).getApprovalsByTicket(trans,
                "ticket");
        retVal = (Result<Void>) facadeImplObj.getApprovalsByTicket(trans,
                respObj, "ticket");
        assertTrue(retVal.status == 31);

        rsVoid = new Result<USERS>(null, 0, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService).getApprovalsByTicket(trans,
                "ticket");
        retVal = (Result<Void>) facadeImplObj.getApprovalsByTicket(trans,
                respObj, "ticket");
        assertTrue(retVal.status == 0);

        Mockito.doReturn("user").when(trans).user();
        Mockito.doReturn(env).when(trans).env();
        Question.specialLogOn(trans, trans.user());
        retVal = (Result<Void>) facadeImplObj.getApprovalsByTicket(trans,
                respObj, "ticket");
        assertTrue(retVal.status == 0);
    }
    @Test
    @SuppressWarnings("unchecked")
    public void testGetUsersByRole() {
        RosettaData<USERS> dataObj = Mockito.mock(RosettaData.class);
        HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);

        Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
        Result<Void> retVal = (Result<Void>) facadeImplObj.getUsersByRole(trans,
                respObj, "role");
        assertTrue(retVal.status == 20);

        Result<USERS> rsVoid = new Result<USERS>(null, 31, "test",
                new Object[0]);
        try {
            Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        Mockito.doReturn(rsVoid).when(authzService).getUsersByRole(trans,
                "role");
        retVal = (Result<Void>) facadeImplObj.getUsersByRole(trans, respObj,
                "role");
        assertTrue(retVal.status == 31);

        rsVoid = new Result<USERS>(null, 0, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService).getUsersByRole(trans,
                "role");
        retVal = (Result<Void>) facadeImplObj.getUsersByRole(trans, respObj,
                "role");
        assertTrue(retVal.status == 0);

        Mockito.doReturn("user").when(trans).user();
        Mockito.doReturn(env).when(trans).env();
        Question.specialLogOn(trans, trans.user());
        retVal = (Result<Void>) facadeImplObj.getUsersByRole(trans, respObj,
                "role");
        assertTrue(retVal.status == 0);
    }
    @Test
    @SuppressWarnings("unchecked")
    public void testGetUsersByPermission() {
        RosettaData<USERS> dataObj = Mockito.mock(RosettaData.class);
        HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);

        Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
        Result<Void> retVal = (Result<Void>) facadeImplObj.getUsersByPermission(
                trans, respObj, "type", "instance", "action");
        assertTrue(retVal.status == 20);

        Result<USERS> rsVoid = new Result<USERS>(null, 31, "test",
                new Object[0]);
        try {
            Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        Mockito.doReturn(rsVoid).when(authzService).getUsersByPermission(trans,
                "type", "instance", "action");
        retVal = (Result<Void>) facadeImplObj.getUsersByPermission(trans,
                respObj, "type", "instance", "action");
        assertTrue(retVal.status == 31);

        rsVoid = new Result<USERS>(null, 0, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService).getUsersByPermission(trans,
                "type", "instance", "action");
        retVal = (Result<Void>) facadeImplObj.getUsersByPermission(trans,
                respObj, "type", "instance", "action");
        assertTrue(retVal.status == 0);

        Mockito.doReturn("user").when(trans).user();
        Mockito.doReturn(env).when(trans).env();
        Question.specialLogOn(trans, trans.user());
        retVal = (Result<Void>) facadeImplObj.getUsersByPermission(trans,
                respObj, "type", "instance", "action");
        assertTrue(retVal.status == 0);
    }

    @Test
    @SuppressWarnings("unchecked")
    public void testGetHistoryByUser() {
        RosettaData<USERS> dataObj = Mockito.mock(RosettaData.class);
        HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);

        Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
        Result<Void> retVal = (Result<Void>) facadeImplObj
                .getHistoryByUser(trans, respObj, "user", new int[]{201907}, 1);
        assertTrue(retVal.status == 20);

        Result<USERS> rsVoid = new Result<USERS>(null, 31, "test",
                new Object[0]);
        try {
            Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        Mockito.doReturn(rsVoid).when(authzService).getHistoryByUser(trans,
                "user", new int[]{201907}, 1);
        retVal = (Result<Void>) facadeImplObj.getHistoryByUser(trans, respObj,
                "user", new int[]{201907}, 1);
        assertTrue(retVal.status == 31);

        rsVoid = new Result<USERS>(null, 0, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService).getHistoryByUser(trans,
                "user", new int[]{201907}, 1);
        retVal = (Result<Void>) facadeImplObj.getHistoryByUser(trans, respObj,
                "user", new int[]{201907}, 1);
        assertTrue(retVal.status == 0);

        Mockito.doReturn("user").when(trans).user();
        Mockito.doReturn(env).when(trans).env();
        Question.specialLogOn(trans, trans.user());
        retVal = (Result<Void>) facadeImplObj.getHistoryByUser(trans, respObj,
                "user", new int[]{201907}, 1);
        assertTrue(retVal.status == 0);
    }
    @Test
    @SuppressWarnings("unchecked")
    public void testGetHistoryByRole() {
        RosettaData<USERS> dataObj = Mockito.mock(RosettaData.class);
        HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);

        Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
        Result<Void> retVal = (Result<Void>) facadeImplObj
                .getHistoryByRole(trans, respObj, "role", new int[]{201907}, 1);
        assertTrue(retVal.status == 20);

        Result<USERS> rsVoid = new Result<USERS>(null, 31, "test",
                new Object[0]);
        try {
            Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        Mockito.doReturn(rsVoid).when(authzService).getHistoryByRole(trans,
                "role", new int[]{201907}, 1);
        retVal = (Result<Void>) facadeImplObj.getHistoryByRole(trans, respObj,
                "role", new int[]{201907}, 1);
        assertTrue(retVal.status == 31);

        rsVoid = new Result<USERS>(null, 0, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService).getHistoryByRole(trans,
                "role", new int[]{201907}, 1);
        retVal = (Result<Void>) facadeImplObj.getHistoryByRole(trans, respObj,
                "role", new int[]{201907}, 1);
        assertTrue(retVal.status == 0);

        Mockito.doReturn("user").when(trans).user();
        Mockito.doReturn(env).when(trans).env();
        Question.specialLogOn(trans, trans.user());
        retVal = (Result<Void>) facadeImplObj.getHistoryByRole(trans, respObj,
                "role", new int[]{201907}, 1);
        assertTrue(retVal.status == 0);
    }
    @Test
    @SuppressWarnings("unchecked")
    public void testGetHistoryByNS() {
        RosettaData<USERS> dataObj = Mockito.mock(RosettaData.class);
        HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);

        Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
        Result<Void> retVal = (Result<Void>) facadeImplObj.getHistoryByNS(trans,
                respObj, "ns", new int[]{201907}, 1);
        assertTrue(retVal.status == 20);

        Result<USERS> rsVoid = new Result<USERS>(null, 31, "test",
                new Object[0]);
        try {
            Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        Mockito.doReturn(rsVoid).when(authzService).getHistoryByNS(trans, "ns",
                new int[]{201907}, 1);
        retVal = (Result<Void>) facadeImplObj.getHistoryByNS(trans, respObj,
                "ns", new int[]{201907}, 1);
        assertTrue(retVal.status == 31);

        rsVoid = new Result<USERS>(null, 0, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService).getHistoryByNS(trans, "ns",
                new int[]{201907}, 1);
        retVal = (Result<Void>) facadeImplObj.getHistoryByNS(trans, respObj,
                "ns", new int[]{201907}, 1);
        assertTrue(retVal.status == 0);

        Mockito.doReturn("user").when(trans).user();
        Mockito.doReturn(env).when(trans).env();
        Question.specialLogOn(trans, trans.user());
        retVal = (Result<Void>) facadeImplObj.getHistoryByNS(trans, respObj,
                "ns", new int[]{201907}, 1);
        assertTrue(retVal.status == 0);
    }
    @Test
    @SuppressWarnings("unchecked")
    public void testGetHistoryByPerm() {
        RosettaData<USERS> dataObj = Mockito.mock(RosettaData.class);
        HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);

        Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
        Result<Void> retVal = (Result<Void>) facadeImplObj
                .getHistoryByPerm(trans, respObj, "perm", new int[]{201907}, 1);
        assertTrue(retVal.status == 20);

        Result<USERS> rsVoid = new Result<USERS>(null, 31, "test",
                new Object[0]);
        try {
            Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        Mockito.doReturn(rsVoid).when(authzService).getHistoryByPerm(trans,
                "perm", new int[]{201907}, 1);
        retVal = (Result<Void>) facadeImplObj.getHistoryByPerm(trans, respObj,
                "perm", new int[]{201907}, 1);
        assertTrue(retVal.status == 31);

        rsVoid = new Result<USERS>(null, 0, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService).getHistoryByPerm(trans,
                "perm", new int[]{201907}, 1);
        retVal = (Result<Void>) facadeImplObj.getHistoryByPerm(trans, respObj,
                "perm", new int[]{201907}, 1);
        assertTrue(retVal.status == 0);

        Mockito.doReturn("user").when(trans).user();
        Mockito.doReturn(env).when(trans).env();
        Question.specialLogOn(trans, trans.user());
        retVal = (Result<Void>) facadeImplObj.getHistoryByPerm(trans, respObj,
                "perm", new int[]{201907}, 1);
        assertTrue(retVal.status == 0);
    }
    @Test
    @SuppressWarnings("unchecked")
    public void testGetHistoryBySubject() {
        RosettaData<USERS> dataObj = Mockito.mock(RosettaData.class);
        HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);

        Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
        Result<Void> retVal = (Result<Void>) facadeImplObj.getHistoryBySubject(
                trans, respObj, "subject", "target", new int[]{201907}, 1);
        assertTrue(retVal.status == 20);

        Result<USERS> rsVoid = new Result<USERS>(null, 31, "test",
                new Object[0]);
        try {
            Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        Mockito.doReturn(rsVoid).when(authzService).getHistoryBySubject(trans,
                "subject", "target", new int[]{201907}, 1);
        retVal = (Result<Void>) facadeImplObj.getHistoryBySubject(trans,
                respObj, "subject", "target", new int[]{201907}, 1);
        assertTrue(retVal.status == 31);

        rsVoid = new Result<USERS>(null, 0, "test", new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService).getHistoryBySubject(trans,
                "subject", "target", new int[]{201907}, 1);
        retVal = (Result<Void>) facadeImplObj.getHistoryBySubject(trans,
                respObj, "subject", "target", new int[]{201907}, 1);
        assertTrue(retVal.status == 0);

        Mockito.doReturn("user").when(trans).user();
        Mockito.doReturn(env).when(trans).env();
        Question.specialLogOn(trans, trans.user());
        retVal = (Result<Void>) facadeImplObj.getHistoryBySubject(trans,
                respObj, "subject", "target", new int[]{201907}, 1);
        assertTrue(retVal.status == 0);
    }
    @Test
    public void testCacheClear() {

        Mockito.doThrow(new RuntimeException("test exception"))
                .when(authzService).cacheClear(trans, "cname");
        Result<Void> retVal = (Result<Void>) facadeImplObj.cacheClear(trans,
                "cname");
        assertTrue(retVal.status == 20);

        Result<USERS> rsVoid = new Result<USERS>(null, 31, "test",
                new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService).cacheClear(trans, "cname");
        retVal = (Result<Void>) facadeImplObj.cacheClear(trans, "cname");
        assertTrue(retVal.status == 31);

    }
    @Test
    public void testCacheClear2() {

        Mockito.doThrow(new RuntimeException("test exception"))
                .when(authzService)
                .cacheClear(trans, "cname", new int[]{1, -1});
        Result<Void> retVal = (Result<Void>) facadeImplObj.cacheClear(trans,
                "cname", "1,a");
        assertTrue(retVal.status == 20);

        Result<USERS> rsVoid = new Result<USERS>(null, 31, "test",
                new Object[0]);
        Mockito.doReturn(rsVoid).when(authzService).cacheClear(trans, "cname",
                new int[]{1, 1});
        retVal = (Result<Void>) facadeImplObj.cacheClear(trans, "cname", "1,1");
        assertTrue(retVal.status == 31);

    }

    @Test
    public void testDbReset() {
        facadeImplObj.dbReset(trans);
    }
    @Test
    public void testGetAPI() {
        HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
        RServlet<AuthzTrans> rservlet = Mockito.mock(RServlet.class);
        facadeImplObj.getAPI(trans, respObj, rservlet);

        RosettaData<Api> dataObj = Mockito.mock(RosettaData.class);
        Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
        try {
            Mockito.doReturn(dataObj).when(dataObj)
                    .load(Mockito.any(Api.class));
        } catch (APIException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        facadeImplObj.getAPI(trans, respObj, rservlet);

        Mockito.doReturn("user").when(trans).user();
        Mockito.doReturn(env).when(trans).env();
        Question.specialLogOn(trans, trans.user());
        facadeImplObj.getAPI(trans, respObj, rservlet);
    }
    @Test
    public void testGetAPIExample() {
        HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
        facadeImplObj.getAPIExample(trans, respObj, "nameOrContentType", true);
    }
}
class AuthzFacadeImplImpl extends AuthzFacadeImpl {

    public AuthzFacadeImplImpl(AuthzEnv env, AuthzService service,
            TYPE dataType) throws APIException {
        super(env, service, dataType);
    }

}