/*
 *   Licensed to the Apache Software Foundation (ASF) under one
 *   or more contributor license agreements.  See the NOTICE file
 *   distributed with this work for additional information
 *   regarding copyright ownership.  The ASF licenses this file
 *   to you 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
 *
 *     https://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.
 *
 */
package org.apache.directory.fortress.core.impl;


import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.apache.directory.fortress.core.AdminMgr;
import org.apache.directory.fortress.core.GlobalErrIds;
import org.apache.directory.fortress.core.ReviewMgr;
import org.apache.directory.fortress.core.ReviewMgrFactory;
import org.apache.directory.fortress.core.SecurityException;
import org.apache.directory.fortress.core.model.PermObj;
import org.apache.directory.fortress.core.model.Permission;
import org.apache.directory.fortress.core.model.PermissionAttribute;
import org.apache.directory.fortress.core.model.PermissionAttributeSet;
import org.apache.directory.fortress.core.model.Role;
import org.apache.directory.fortress.core.model.RoleConstraint;
import org.apache.directory.fortress.core.model.SDSet;
import org.apache.directory.fortress.core.model.Session;
import org.apache.directory.fortress.core.model.User;
import org.apache.directory.fortress.core.model.UserRole;
import org.apache.directory.fortress.core.util.LogUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestSuite;


/**
 * ReviewMgrImpl Tester.
 *
 * @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a>
 * @version 1.0
 */
public class ReviewMgrImplTest extends TestCase
{
    private static final String CLS_NM = ReviewMgrImplTest.class.getName();
    private static final Logger LOG = LoggerFactory.getLogger( CLS_NM );
    private static Session adminSess = null;


    public ReviewMgrImplTest( String name )
    {
        super( name );
    }


    public static Test suite()
    {
        TestSuite suite = new TestSuite();

/*
        suite.addTest( new ReviewMgrImplTest( "testReadPermissionOp" ) );
        suite.addTest( new ReviewMgrImplTest( "testFindPermissionOps" ) );
        suite.addTest( new ReviewMgrImplTest( "testReadPermissionObj" ) );
        suite.addTest( new ReviewMgrImplTest( "testFindPermissionObjs" ) );
        suite.addTest( new ReviewMgrImplTest( "testReadRole" ) );
        suite.addTest( new ReviewMgrImplTest( "testFindRoles" ) );
        suite.addTest( new ReviewMgrImplTest( "testReadUser" ) );
        suite.addTest( new ReviewMgrImplTest( "testFindUsers" ) );
        suite.addTest( new ReviewMgrImplTest( "testAssignedRoles" ) );
        suite.addTest( new ReviewMgrImplTest( "testAuthorizedUsers" ) );
        suite.addTest( new ReviewMgrImplTest( "testAuthorizedRoles" ) );
        suite.addTest( new ReviewMgrImplTest( "testRolePermissions" ) );
        suite.addTest( new ReviewMgrImplTest( "testUserPermissions" ) );
        suite.addTest( new ReviewMgrImplTest( "testPermissionRoles" ) );
        suite.addTest( new ReviewMgrImplTest( "testAuthorizedPermissionRoles" ) );
        suite.addTest( new ReviewMgrImplTest( "testPermissionUsers" ) );
        suite.addTest( new ReviewMgrImplTest( "testAuthorizedPermissionUsers" ) );
        suite.addTest( new ReviewMgrImplTest( "testFindSsdSets" ) );
        suite.addTest( new ReviewMgrImplTest( "testFindDsdSets" ) );
*/

        //suite.addTest( new ReviewMgrImplTest( "testReadUserRoleConstraint" ) );
        //suite.addTest( new ReviewMgrImplTest( "testFindRoleConstraints" ) );
        suite.addTest( new ReviewMgrImplTest( "testAssignedUserRoleConstraints" ) );

        return suite;
    }


    public void setUp() throws Exception
    {
        super.setUp();
    }


    public void tearDown() throws Exception
    {
        super.tearDown();
    }


    public static Test suitex()
    {
        return new TestSuite( ReviewMgrImplTest.class );
    }


    public void testReadPermissionOp()
    {
        //    public Permission readPermission(Permission permOp)
        readPermissionOps( "RD-PRM-OPS TOB1 OPS_TOP1_UPD", PermTestData.OBJS_TOB1, PermTestData.OPS_TOP1_UPD );
        readPermissionOps( "RD-PRM-OPS TOB1 TOP2", PermTestData.OBJS_TOB2, PermTestData.OPS_TOP2 );
        readPermissionOps( "RD-PRM-OPS TOB1 TOP3", PermTestData.OBJS_TOB3, PermTestData.OPS_TOP3 );
    }


    /**
     * @param msg
     * @param pObjArray
     * @param pOpArray
     */
    public static void readPermissionOps( String msg, String[][] pObjArray, String[][] pOpArray )
    {
        Permission pOp = new Permission();
        LogUtil.logIt( msg );
        try
        {
            ReviewMgr reviewMgr = getManagedReviewMgr();
            for ( String[] objs : pObjArray )
            {
                for ( String[] ops : pOpArray )
                {
                    pOp = new Permission();
                    pOp.setObjName( PermTestData.getName( objs ) );
                    pOp.setOpName( PermTestData.getName( ops ) );
                    pOp.setObjId( PermTestData.getObjId( ops ) );
                    Permission entity = reviewMgr.readPermission( pOp );
                    assertNotNull( entity );
                    PermTestData.assertEquals( PermTestData.getName( objs ), entity, ops );
                    LOG.debug( "readPermissionOps object name [" + pOp.getObjName() + "] operation name ["
                        + pOp.getOpName() + "] objectId [" + pOp.getObjId() + "] successful" );
                }
            }
        }
        catch ( SecurityException ex )
        {
            LOG.error( "readPermissionOps object name [" + pOp.getObjName() + "] operation name ["
                + pOp.getOpName() + "] objectId [" + pOp.getObjId() + "] caught SecurityException rc="
                + ex.getErrorId() + ", msg=" + ex.getMessage() + ex );
            fail( ex.getMessage() );
        }
    }

    public void testReadPermissionAttributeSets()
    {
        readPermissionAttributeSet( "RD-PA-SET TPASET1", PermTestData.TPA_SET_1_NAME, PermTestData.loadPermissionAttributes(PermTestData.PA_TPSASET1) );

        Set<PermissionAttribute> paSetTwoPas = PermTestData.loadPermissionAttributes(PermTestData.PA_TPSASET2);
        paSetTwoPas.addAll(PermTestData.loadPermissionAttributes(PermTestData.PA_TPSASET2_ADDITIONAL));
        readPermissionAttributeSet( "RD-PA-SET TPASET2", PermTestData.TPA_SET_2_NAME, paSetTwoPas);
    }

    public static void readPermissionAttributeSet( String msg, String name, Set<PermissionAttribute> permAttributes )
    {
        LogUtil.logIt( msg );
        try
        {
            ReviewMgr reviewMgr = getManagedReviewMgr();
            
            PermissionAttributeSet entity = reviewMgr.readPermAttributeSet(new PermissionAttributeSet(name));
            assertNotNull(entity);
            assertEquals(name, entity.getName());
            assertEquals(PermTestData.TPA_SET_TYPE, entity.getType());
            
            for(PermissionAttribute pa : permAttributes){
                assertTrue(entity.getAttributes().contains(pa));
            }
            
            LOG.debug( "readPermissionAttributeSet name [" + name + "] successful" );
            
        }
        catch ( SecurityException ex )
        {
            LOG.error( "readPermissionAttributeSet name [" + name + "] caught SecurityException rc="
                + ex.getErrorId() + ", msg=" + ex.getMessage() + ex );
            fail( ex.getMessage() );
        }
    }
    
    public void testReadPASetFromPermission()
    {
        readPASetFromPermission( "RD-PASET-FROM-POP TOB_1 TOP_1", PermTestData.TPA_SET_1_NAME, "TOB1_1", PermTestData.OPS_TOP1[0] );       
    }

    public static void readPASetFromPermission( String msg, String paSetName, String obj, String[] op )
    {
        LogUtil.logIt(msg);
        try
        {
            ReviewMgr reviewMgr = getManagedReviewMgr();           

            Permission pop = PermTestData.getOp( obj, op );

            Permission entity = reviewMgr.readPermission(pop);
            assertTrue(paSetName, entity.getPaSets().contains(paSetName));
            
            LOG.debug( "readPASetFromPermission name [" + paSetName + "] successful" );
        }
        catch ( SecurityException ex )
        {
            LOG.error( "readPASetFromPermission name [" + paSetName
                    + "] caught SecurityException rc=" + ex.getErrorId() + ", msg=" + ex.getMessage(), ex );
            fail( ex.getMessage() );
        }
    }
    
    public void testFindPermissionOps()
    {
        // public List<Permission> findPermissions(Permission permOp)
        searchPermissionOps( "FND-PRM-OPS TOB1 OPS_TOP1_UPD",
            TestUtils.getSrchValue( PermTestData.getName( PermTestData.OPS_TOP1_UPD[0] ) ), PermTestData.OBJS_TOB1,
            PermTestData.OPS_TOP1_UPD );
        searchPermissionOps( "FND-PRM-OPS TOB2 TOP2",
            TestUtils.getSrchValue( PermTestData.getName( PermTestData.OPS_TOP2[0] ) ), PermTestData.OBJS_TOB2,
            PermTestData.OPS_TOP2 );
        searchPermissionOps( "FND-PRM-OPS TOB3 TOP3",
            TestUtils.getSrchValue( PermTestData.getName( PermTestData.OPS_TOP3[0] ) ), PermTestData.OBJS_TOB3,
            PermTestData.OPS_TOP3 );
    }


    /**
     * @param msg
     * @param srchValue
     * @param pObjArray
     */
    public static void searchPermissionOps( String msg, String srchValue, String[][] pObjArray, String[][] pOpArray )
    {
        LogUtil.logIt( msg );
        Permission pOp;
        try
        {
            ReviewMgr reviewMgr = getManagedReviewMgr();
            for ( String[] obj : pObjArray )
            {
                for ( String[] op : pOpArray )
                {
                    pOp = new Permission();
                    pOp.setObjName( PermTestData.getName( obj ) );
                    pOp.setOpName( srchValue );
                    List<Permission> ops = reviewMgr.findPermissions( pOp );
                    assertNotNull( ops );
                    assertTrue( CLS_NM + "searchPermissionOps srchValue [" + srchValue + "] list size check",
                        pOpArray.length == ops.size() );
                    int indx = ops.indexOf( new Permission( PermTestData.getName( obj ), PermTestData.getName( op ), PermTestData.getObjId( op ) ) );
                    if ( indx != -1 )
                    {
                        Permission entity = ops.get( indx );
                        assertNotNull( entity );
                        PermTestData.assertEquals( PermTestData.getName( obj ), entity, op );
                        LOG.debug( "searchPermissionOps objName [" + entity.getObjName()
                            + "] operation name [" + entity.getOpName() + "] successful" );
                    }
                    else
                    {
                        msg = "searchPermissionOps srchValue [" + srchValue + "] failed list search";
                        LogUtil.logIt( msg );
                        fail( msg );
                    }
                }
            }
        }
        catch ( SecurityException ex )
        {
            LOG.error(
                "searchPermissionOps srchValue [" + srchValue + "] caught SecurityException rc="
                    + ex.getErrorId() + ", msg=" + ex.getMessage(), ex );
            fail( ex.getMessage() );
        }
    }


    public void testReadPermissionObj()
    {
        //    public Permission readPermission(Permission permOp)
        readPermissionObjs( "RD-PRM-OBJS TOB1", PermTestData.OBJS_TOB1 );
        readPermissionObjs( "RD-PRM-OBJS TOB2", PermTestData.OBJS_TOB2 );
        readPermissionObjs( "RD-PRM-OBJS TOB3", PermTestData.OBJS_TOB3 );
        readPermissionObjs( "RD-PRM-OBJS TOB4_UPD", PermTestData.OBJS_TOB4_UPD );
    }


    /**
     * @param msg
     * @param pArray
     */
    public static void readPermissionObjs( String msg, String[][] pArray )
    {
        PermObj pObj = new PermObj();
        LogUtil.logIt( msg );
        try
        {
            ReviewMgr reviewMgr = getManagedReviewMgr();
            for ( String[] objs : pArray )
            {
                pObj = new PermObj();
                pObj.setObjName( PermTestData.getName( objs ) );
                PermObj entity = reviewMgr.readPermObj( pObj );
                assertNotNull( entity );
                PermTestData.assertEquals( entity, objs );
                LOG.debug( "readPermissionObjs object name [" + pObj.getObjName() + "] successful" );
            }
        }
        catch ( SecurityException ex )
        {
            LOG.error( "readPermissionOps object name [" + pObj.getObjName()
                + "] caught SecurityException rc=" + ex.getErrorId() + ", msg=" + ex.getMessage() + ex );
            fail( ex.getMessage() );
        }
    }


    public void testFindPermissionObjs()
    {
        // public List<Permission> findPermissions(Permission permOp)
        searchPermissionObjs( "FND-PRM-OBJS TOB1",
            TestUtils.getSrchValue( PermTestData.getName( PermTestData.OBJS_TOB1[0] ) ), PermTestData.OBJS_TOB1 );
        searchPermissionObjs( "FND-PRM-OBJS TOB2",
            TestUtils.getSrchValue( PermTestData.getName( PermTestData.OBJS_TOB2[0] ) ), PermTestData.OBJS_TOB2 );
        searchPermissionObjs( "FND-PRM-OBJS TOB3",
            TestUtils.getSrchValue( PermTestData.getName( PermTestData.OBJS_TOB3[0] ) ), PermTestData.OBJS_TOB3 );
        searchPermissionObjs( "FND-PRM-OBJS TOB4_UPD",
            TestUtils.getSrchValue( PermTestData.getName( PermTestData.OBJS_TOB4_UPD[0] ) ), PermTestData.OBJS_TOB4_UPD );
    }


    /**
     * @param msg
     * @param srchValue
     * @param pArray
     */
    public static void searchPermissionObjs( String msg, String srchValue, String[][] pArray )
    {
        LogUtil.logIt( msg );
        try
        {
            ReviewMgr reviewMgr = getManagedReviewMgr();
            List<PermObj> objs = reviewMgr.findPermObjs( new PermObj( srchValue ) );
            assertNotNull( objs );
            assertTrue( CLS_NM + "searchPermissionObjs srchValue [" + srchValue + "] list size check",
                pArray.length == objs.size() );
            for ( String[] obj : pArray )
            {
                int indx = objs.indexOf( new PermObj( PermTestData.getName( obj ) ) );
                if ( indx != -1 )
                {
                    PermObj entity = objs.get( indx );
                    assertNotNull( entity );
                    PermTestData.assertEquals( entity, obj );
                    LOG.debug( "searchPermissionObjs [" + entity.getObjName() + "] successful" );
                }
                else
                {
                    msg = "searchPermissionObjs srchValue [" + srchValue + "] failed list search";
                    LogUtil.logIt( msg );
                    fail( msg );
                }
            }
        }
        catch ( SecurityException ex )
        {
            LOG.error(
                "searchPermissionObjs srchValue [" + srchValue + "] caught SecurityException rc="
                    + ex.getErrorId() + ", msg=" + ex.getMessage(), ex );
            fail( ex.getMessage() );
        }
    }


    public void testReadRole()
    {
        // public Role readRole(Role role)
        readRoles( "RD-RLS TR1", RoleTestData.ROLES_TR1 );
        readRoles( "RD-RLS TR2", RoleTestData.ROLES_TR2 );
        readRoles( "RD-RLS TR3", RoleTestData.ROLES_TR3 );
        readRoles( "RD-RLS TR4_UPD", RoleTestData.ROLES_TR4_UPD );
    }


    /**
     * Determine if old fortress regression test cases are loaded in this directory and must be torn down.
     *
     * @param msg
     * @param rArray
     */
    public static boolean teardownRequired( String msg, String[][] rArray )
    {
        // default return is 'true':
        boolean tearDown = true;
        String methodName = ".teardownRequired";
        LogUtil.logIt( msg );
        try
        {
            ReviewMgr reviewMgr = getManagedReviewMgr();
            for ( String[] rle : rArray )
            {
                Role entity = reviewMgr.readRole( new Role( RoleTestData.getName( rle ) ) );
                RoleTestData.assertEquals( entity, rle );
            }
            // if we get to here it means that old test data must be removed from directory.
        }
        catch ( SecurityException ex )
        {
            // This is the expected when teardown is not required:
            if ( ex.getErrorId() == GlobalErrIds.ROLE_NOT_FOUND )
            {
                // did not find old test data no need to teardown
                tearDown = false;
            }
            else
            {
                // Something unexpected occurred here, Report as warning to the logger:
                String warning = methodName + " caught SecurityException=" + ex.getMessage();
                LOG.warn( warning );
                // TODO: Determine if it would be better to throw a SecurityException here.
            }
        }
        LOG.info( methodName + ":" + tearDown );
        return tearDown;
    }


    /**
     *
     * @param msg
     * @param rArray
     */
    public static void readRoles( String msg, String[][] rArray )
    {
        LogUtil.logIt( msg );
        try
        {
            ReviewMgr reviewMgr = getManagedReviewMgr();
            for ( String[] rle : rArray )
            {
                Role entity = reviewMgr.readRole( new Role( RoleTestData.getName( rle ) ) );
                RoleTestData.assertEquals( entity, rle );
                LOG.debug( "readRoles [" + entity.getName() + "] successful" );
            }
        }
        catch ( SecurityException ex )
        {
            LOG.error( "readRoles caught SecurityException=" + ex.getMessage(), ex );
            fail( ex.getMessage() );
        }
    }


    /**
     * RMT06
     *
     * @throws org.apache.directory.fortress.core.SecurityException
     */
    public void testFindRoles()
    {
        // public List<Role> findRoles(String searchVal)
        searchRoles( "SRCH-RLS TR1", TestUtils.getSrchValue( RoleTestData.getName( RoleTestData.ROLES_TR1[0] ) ),
            RoleTestData.ROLES_TR1 );
        searchRoles( "SRCH-RLS TR2", TestUtils.getSrchValue( RoleTestData.getName( RoleTestData.ROLES_TR2[0] ) ),
            RoleTestData.ROLES_TR2 );
        searchRoles( "SRCH-RLS TR3", TestUtils.getSrchValue( RoleTestData.getName( RoleTestData.ROLES_TR3[0] ) ),
            RoleTestData.ROLES_TR3 );
        searchRoles( "SRCH-RLS TR4_UPD", TestUtils.getSrchValue( RoleTestData.getName( RoleTestData.ROLES_TR4[0] ) ),
            RoleTestData.ROLES_TR4_UPD );
    }


    /**
     *
     * @param msg
     * @param srchValue
     * @param rArray
     */
    public static void searchRoles( String msg, String srchValue, String[][] rArray )
    {
        LogUtil.logIt( msg );
        try
        {
            ReviewMgr reviewMgr = getManagedReviewMgr();
            List<Role> roles = reviewMgr.findRoles( srchValue );
            assertNotNull( roles );
            assertTrue( CLS_NM + "searchRoles list size check", rArray.length == roles.size() );
            for ( String[] rle : rArray )
            {
                int indx = roles.indexOf( new Role( RoleTestData.getName( rle ) ) );
                if ( indx != -1 )
                {
                    Role entity = roles.get( indx );
                    assertNotNull( entity );
                    RoleTestData.assertEquals( entity, rle );
                    LOG.debug( "searchRoles [" + entity.getName() + "] successful" );
                }
                else
                {
                    msg = "searchRoles srchValue [" + srchValue + "] failed list search";
                    LogUtil.logIt( msg );
                    fail( msg );
                }
            }
        }
        catch ( SecurityException ex )
        {
            LOG.error(
                "searchRoles srchValue [" + srchValue + "] caught SecurityException rc=" + ex.getErrorId()
                    + ", msg=" + ex.getMessage(), ex );
            fail( ex.getMessage() );
        }
    }


    public void testReadUser()
    {
        // public User readUser(User user)
        readUsers( "READ-USRS TU1_UPD", UserTestData.USERS_TU1_UPD );
        readUsers( "READ-USRS TU3", UserTestData.USERS_TU3 );
        readUsers( "READ-USRS TU4", UserTestData.USERS_TU4 );
        readUsers( "READ-USRS TU5", UserTestData.USERS_TU5 );
        readUsers( "READ-USRS TU8", UserTestData.USERS_TU8_SSD );
        readUsers( "READ-USRS TU9", UserTestData.USERS_TU9_SSD_HIER );
        readUsers( "READ-USRS TU10", UserTestData.USERS_TU10_SSD_HIER );
        readUsers( "READ-USRS TU11", UserTestData.USERS_TU11_SSD_HIER );
        readUsers( "READ-USRS TU12", UserTestData.USERS_TU12_DSD );
        readUsers( "READ-USRS TU13", UserTestData.USERS_TU13_DSD_HIER );
        readUsers( "READ-USRS TU14", UserTestData.USERS_TU14_DSD_HIER );
        readUsers( "READ-USRS TU15", UserTestData.USERS_TU15_DSD_HIER );
    }


    /**
     *
     * @param msg
     * @param uArray
     */
    public static void readUsers( String msg, String[][] uArray )
    {
        LogUtil.logIt( msg );
        try
        {
            ReviewMgr reviewMgr = getManagedReviewMgr();
            for ( String[] usr : uArray )
            {
                User entity = reviewMgr.readUser( new User( UserTestData.getUserId( usr ) ) );
                assertNotNull( entity );
                UserTestData.assertEquals( entity, usr );
                LOG.debug( "readUsers userId [" + entity.getUserId() + "] successful" );
            }
        }
        catch ( SecurityException ex )
        {
            LOG.error(
                "readUsers caught SecurityException rc=" + ex.getErrorId() + ", msg=" + ex.getMessage(), ex );
            fail( ex.getMessage() );
        }
    }


    public void testFindUsers()
    {
        // public List<User> findUsers(User user)
        searchUsers( "SRCH-USRS TU1_UPD",
            TestUtils.getSrchValue( UserTestData.getUserId( UserTestData.USERS_TU1[0] ) ), UserTestData.USERS_TU1_UPD );
        searchUsers( "SRCH-USRS TU3", TestUtils.getSrchValue( UserTestData.getUserId( UserTestData.USERS_TU3[0] ) ),
            UserTestData.USERS_TU3 );
        searchUsers( "SRCH-USRS TU4", TestUtils.getSrchValue( UserTestData.getUserId( UserTestData.USERS_TU4[0] ) ),
            UserTestData.USERS_TU4 );
        searchUsers( "SRCH-USRS TU5", TestUtils.getSrchValue( UserTestData.getUserId( UserTestData.USERS_TU5[0] ) ),
            UserTestData.USERS_TU5 );
        searchUsers( "SRCH-USRS TU8",
            TestUtils.getSrchValue( UserTestData.getUserId( UserTestData.USERS_TU8_SSD[0] ) ),
            UserTestData.USERS_TU8_SSD );
        searchUsers( "SRCH-USRS TU9",
            TestUtils.getSrchValue( UserTestData.getUserId( UserTestData.USERS_TU9_SSD_HIER[0] ) ),
            UserTestData.USERS_TU9_SSD_HIER );
        searchUsers( "SRCH-USRS TU10",
            TestUtils.getSrchValue( UserTestData.getUserId( UserTestData.USERS_TU10_SSD_HIER[0] ) ),
            UserTestData.USERS_TU10_SSD_HIER );
        searchUsers( "SRCH-USRS TU11",
            TestUtils.getSrchValue( UserTestData.getUserId( UserTestData.USERS_TU11_SSD_HIER[0] ) ),
            UserTestData.USERS_TU11_SSD_HIER );
        searchUsers( "SRCH-USRS TU12",
            TestUtils.getSrchValue( UserTestData.getUserId( UserTestData.USERS_TU12_DSD[0] ) ),
            UserTestData.USERS_TU12_DSD );
        searchUsers( "SRCH-USRS TU13",
            TestUtils.getSrchValue( UserTestData.getUserId( UserTestData.USERS_TU13_DSD_HIER[0] ) ),
            UserTestData.USERS_TU13_DSD_HIER );
        searchUsers( "SRCH-USRS TU14",
            TestUtils.getSrchValue( UserTestData.getUserId( UserTestData.USERS_TU14_DSD_HIER[0] ) ),
            UserTestData.USERS_TU14_DSD_HIER );
        searchUsers( "SRCH-USRS TU15",
            TestUtils.getSrchValue( UserTestData.getUserId( UserTestData.USERS_TU15_DSD_HIER[0] ) ),
            UserTestData.USERS_TU15_DSD_HIER );
    }


    /**
     *
     * @param msg
     * @param srchValue
     * @param uArray
     */
    public static void searchUsers( String msg, String srchValue, String[][] uArray )
    {
        LogUtil.logIt( msg );
        try
        {
            ReviewMgr reviewMgr = getManagedReviewMgr();
            List<User> users = reviewMgr.findUsers( new User( srchValue ) );
            assertNotNull( users );
            assertTrue( "searchUsers list size check", uArray.length == users.size() );
            for ( String[] usr : uArray )
            {
                int indx = users.indexOf( new User( UserTestData.getUserId( usr ) ) );
                if ( indx != -1 )
                {
                    User entity = users.get( indx );
                    assertNotNull( entity );
                    UserTestData.assertEquals( entity, usr );
                    LOG.debug( "searchUsers userId [" + entity.getUserId() + "] successful" );
                }
                else
                {
                    msg = "searchUsers srchValue [" + srchValue + "] failed list search";
                    LogUtil.logIt( msg );
                    fail( msg );
                }
            }
        }
        catch ( SecurityException ex )
        {
            LOG.error(
                "searchUsers srchValue [" + srchValue + "] caught SecurityException rc=" + ex.getErrorId()
                    + ", msg=" + ex.getMessage(), ex );
            fail( ex.getMessage() );
        }
    }


    public void testAssignedRoles()
    {
        // public List<UserRole> assignedRoles(User userId)
        assignedRoles( "ASGN-RLS TU1_UPD TR1", UserTestData.USERS_TU1_UPD, RoleTestData.ROLES_TR1 );
        //assignedRoles("ASGN-RLS TU3 TR2", UserTestData.USERS_TU3, RoleTestData.ROLES_TR2);
        assignedRoles( "ASGN-RLS TU4 TR2", UserTestData.USERS_TU4, RoleTestData.ROLES_TR2 );
        assignedRoles( "ASGN-RLS TU3 TR3", UserTestData.USERS_TU3, RoleTestData.ROLES_TR3 );
    }


    /**
     * @param msg
     * @param uArray
     * @param rArray
     */
    public static void assignedRoles( String msg, String[][] uArray, String[][] rArray )
    {
        LogUtil.logIt( msg );
        try
        {
            ReviewMgr reviewMgr = getManagedReviewMgr();
            for ( String[] usr : uArray )
            {
                User user = reviewMgr.readUser( new User( UserTestData.getUserId( usr ) ) );
                assertNotNull( user );
                List<UserRole> uRoles = reviewMgr.assignedRoles( user );
                assertTrue( CLS_NM + "assignedRoles list size check", rArray.length == uRoles.size() );
                for ( String[] url : rArray )
                {
                    int indx = uRoles.indexOf( RoleTestData.getUserRole( UserTestData.getUserId( usr ), url ) );
                    if ( indx != -1 )
                    {
                        UserRole uRole = uRoles.get( indx );
                        assertNotNull( uRole );
                        RoleTestData.assertEquals( UserTestData.getUserId( usr ), uRole, url );
                        LOG.debug( "assignedRoles userId [" + uRole.getUserId() + "] role ["
                            + uRole.getName() + "] successful" );
                    }
                    else
                    {
                        msg = "assignedRoles userId [" + user.getUserId() + "] role ["
                            + RoleTestData.getName( url ) + "] failed list search";
                        LogUtil.logIt( msg );
                        fail( msg );
                    }
                }
            }
        }
        catch ( SecurityException ex )
        {
            LOG.error(
                "assignedRoles caught SecurityException rc=" + ex.getErrorId() + ", msg=" + ex.getMessage(),
                ex );
            fail( ex.getMessage() );
        }
    }


    /**
     *
     */
    public void testAuthorizedRoles()
    {
        // public Set<String> authorizedRoles(User user)
        authorizedRoles( "AUTHZ-RLS TU18 TR6 DESC", UserTestData.USERS_TU18U_TR6_DESC );
        authorizedRoles( "AUTHZ-RLS TU19 TR7 ASC", UserTestData.USERS_TU19U_TR7_ASC );
    }


    /**
     *
     * @param msg
     * @param uArray
     */
    public static void authorizedRoles( String msg, String[][] uArray )
    {
        LogUtil.logIt( msg );
        try
        {
            ReviewMgr reviewMgr = getManagedReviewMgr();
            for ( String[] usr : uArray )
            {
                User user = reviewMgr.readUser( new User( UserTestData.getUserId( usr ) ) );
                assertNotNull( user );

                // Get the authorized roles for this user:
                Collection<String> authZRoles = UserTestData.getAuthorizedRoles( usr );

                // If there are any assigned roles, add them to list of authorized.
                Set<String> asgnRoles = UserTestData.getAssignedRoles( usr );
                assertNotNull( asgnRoles );
                assertTrue( asgnRoles.size() > 0 );
                for ( String asgnRole : asgnRoles )
                {
                    authZRoles.add( asgnRole );
                }

                // Retrieve actual roles authorized to User according to LDAP:
                Set<String> actualRoles = reviewMgr.authorizedRoles( user );
                assertNotNull( actualRoles );
                assertTrue( actualRoles.size() > 0 );

                // The two list sizes better match or fail the test case.
                assertTrue( CLS_NM + "authorizedRoles list size test case", authZRoles.size() == actualRoles.size() );

                // For each authorized role found in User test data, check to see if it was found in LDAP for User.  If not fail the test case.
                for ( String roleName : authZRoles )
                {
                    assertTrue( CLS_NM + ".authorizedRoles userId [" + user.getUserId() + "] role [" + roleName
                        + "] not found", actualRoles.contains( roleName ) );
                }
            }
        }
        catch ( SecurityException ex )
        {
            LOG.error(
                "assignedRoles caught SecurityException rc=" + ex.getErrorId() + ", msg=" + ex.getMessage(),
                ex );
            fail( ex.getMessage() );
        }
    }


    public void testAuthorizedUsers()
    {
        // public List<User> authorizedUsers(Role role)
        authorizedUsers( "ATHZ-USRS TR1 TU1_UPD", RoleTestData.ROLES_TR1, UserTestData.USERS_TU1_UPD );
        authorizedUsers( "ATHZ-USRS TR2 TU4", RoleTestData.ROLES_TR2, UserTestData.USERS_TU4 );
        authorizedUsers( "ATHZ-USRS TR3 TU3", RoleTestData.ROLES_TR3, UserTestData.USERS_TU3 );
    }


    /**
     * @param msg
     * @param rArray
     * @param uArray
     */
    public static void authorizedUsers( String msg, String[][] rArray, String[][] uArray )
    {
        LogUtil.logIt( msg );
        try
        {
            ReviewMgr reviewMgr = getManagedReviewMgr();
            for ( String[] rle : rArray )
            {
                List<User> users = reviewMgr.authorizedUsers( new Role( RoleTestData.getName( rle ) ) );
                assertNotNull( users );
                //LOG.debug("authorizedUsers list source size=" + uArray.length + " ldap size="  + users.size());
                assertTrue( CLS_NM + "authorizedUsers list size check", uArray.length == users.size() );
                for ( String[] usr : uArray )
                {
                    int indx = users.indexOf( UserTestData.getUser( usr ) );
                    if ( indx != -1 )
                    {
                        User user = users.get( indx );
                        assertNotNull( user );
                        UserTestData.assertEquals( user, usr );
                        LOG.debug( "authorizedUsers role name [" + RoleTestData.getName( rle ) + "] userId ["
                            + user.getUserId() + "] successful" );
                    }
                    else
                    {
                        msg = "authorizedUsers role [" + RoleTestData.getName( rle ) + "] user ["
                            + UserTestData.getUserId( usr ) + "] failed list search";
                        LogUtil.logIt( msg );
                        fail( msg );
                    }
                }
            }
        }
        catch ( SecurityException ex )
        {
            LOG.error(
                "authorizedUsers caught SecurityException rc=" + ex.getErrorId() + ", msg=" + ex.getMessage(),
                ex );
            fail( ex.getMessage() );
        }
    }


    public void testAuthorizedUsersHier()
    {
        // public List<User> authorizedUsers(Role role)
        authorizedUsersHier( "ATHZ-USRS-HIER TR6 TU18", RoleTestData.TR6_AUTHORIZED_USERS );
        authorizedUsersHier( "ATHZ-USRS-HIER TR7 TU19", RoleTestData.TR7_AUTHORIZED_USERS );
    }


    /**
     *
     * @param msg
     * @param roleMap
     */
    public static void authorizedUsersHier( String msg, Map roleMap )
    {
        LogUtil.logIt( msg );
        try
        {
            ReviewMgr reviewMgr = getManagedReviewMgr();

            // create iterator based on rolemap:

            // iterate over every role entry found in map:
            for ( Object o : roleMap.entrySet() )
            {
                Map.Entry pairs = ( Map.Entry ) o;
                String roleName = ( String ) pairs.getKey();
                String szValidUsers = ( String ) pairs.getValue();
                Set<String> userSet = TestUtils.getSets( szValidUsers );
                assertNotNull( userSet );
                assertTrue( userSet.size() > 0 );
                List<User> actualUsers = reviewMgr.authorizedUsers( new Role( roleName ) );
                assertNotNull( actualUsers );
                assertTrue( actualUsers.size() > 0 );

                // Ensure the two list sizes match or fail the test case.
                assertTrue( CLS_NM + "authorizedUsersHier failed list size test case",
                    userSet.size() == actualUsers.size() );

                // for each valid user expected, ensure it actually pulled from API:
                for ( String userId : userSet )
                {
                    User validUser = new User( userId );
                    assertTrue( CLS_NM + ".authorizedUsersHier failed authorizedUsers test, role [" + roleName
                        + "] does not have user [" + validUser.getUserId() + "] as authorized",
                        actualUsers.contains( validUser ) );
                }
            }
        }
        catch ( SecurityException ex )
        {
            LOG.error(
                "authorizedUsersHier caught SecurityException rc=" + ex.getErrorId() + ", msg="
                    + ex.getMessage(), ex );
            fail( ex.getMessage() );
        }
    }


    public void testRolePermissions()
    {
        // public List<Permission> rolePermissions(Role role)
        rolePermissions( "ATHRZ-RLE-PRMS TR1 TOB1 TOP1_UPD", RoleTestData.ROLES_TR1, PermTestData.OBJS_TOB1,
            PermTestData.OPS_TOP1_UPD );
    }


    /**
     * @param msg
     * @param rArray
     * @param pObjArray
     * @param pOpArray
     */
    public static void rolePermissions( String msg, String[][] rArray, String[][] pObjArray, String[][] pOpArray )
    {
        LogUtil.logIt( msg );
        try
        {
            ReviewMgr reviewMgr = getManagedReviewMgr();
            for ( String[] rle : rArray )
            {
                Role role = RoleTestData.getRole( rle );
                List<Permission> perms = reviewMgr.rolePermissions( role );
                assertNotNull( perms );
                assertTrue( CLS_NM + "rolePermissions list size check",
                    pOpArray.length * pObjArray.length == perms.size() );
                for ( String[] obj : pObjArray )
                {
                    for ( String[] op : pOpArray )
                    {
                        int indx = perms.indexOf( new Permission( PermTestData.getName( obj ), PermTestData.getName( op ), PermTestData.getObjId( op ) ) );
                        if ( indx != -1 )
                        {
                            Permission pOp = perms.get( indx );
                            assertNotNull( pOp );
                            PermTestData.assertEquals( PermTestData.getName( obj ), pOp, op );
                            LOG.debug( "rolePermissions role name [" + role.getName() + "] perm objName ["
                                + PermTestData.getName( obj ) + "] operationName [" + PermTestData.getName( op )
                                + "] successful" );
                        }
                        else
                        {
                            msg = "rolePermissions role name [" + role.getName() + "] perm objName ["
                                + PermTestData.getName( obj ) + "] operationName [" + PermTestData.getName( op )
                                + "] failed list search";
                            LogUtil.logIt( msg );
                            fail( msg );
                        }
                    }
                }
            }
        }
        catch ( SecurityException ex )
        {
            LOG.error(
                "rolePermissions caught SecurityException rc=" + ex.getErrorId() + ", msg=" + ex.getMessage(),
                ex );
            fail( ex.getMessage() );
        }
    }


    public void testPermissionRoles()
    {
        // public List<Role> permissionRoles(Permission perm)
        permissionRoles( "PRM-RLS TOB1 TOP1 TR1", PermTestData.OBJS_TOB1, PermTestData.OPS_TOP1, RoleTestData.ROLES_TR1 );
    }


    /**
     * @param msg
     * @param pObjArray
     * @param pOpArray
     * @param rArray
     */
    public static void permissionRoles( String msg, String[][] pObjArray, String[][] pOpArray, String[][] rArray )
    {
        LogUtil.logIt( msg );
        Permission pOp;
        try
        {
            ReviewMgr reviewMgr = getManagedReviewMgr();
            for ( String[] obj : pObjArray )
            {
                for ( String[] op : pOpArray )
                {
                    pOp = new Permission();
                    pOp.setObjName( PermTestData.getName( obj ) );
                    pOp.setOpName( PermTestData.getName( op ) );
                    pOp.setObjId( PermTestData.getObjId( op ) );
                    List<String> roles = reviewMgr.permissionRoles( pOp );
                    assertNotNull( roles );
                    assertTrue( CLS_NM + "permissionRoles permission object [" + pOp.getObjName()
                        + "] operationName [" + pOp.getOpName() + "] objectId [" + pOp.getObjId() + "]",
                        rArray.length == roles.size() );
                    for ( String[] rle : rArray )
                    {
                        int indx = roles.indexOf( RoleTestData.getName( rle ) );
                        if ( indx != -1 )
                        {
                            String roleNm = roles.get( indx );
                            assertEquals( CLS_NM + ".permissionRoles failed compare role name",
                                RoleTestData.getName( rle ), roleNm );
                            LOG.debug( ".permissionRoles permission objName [" + pOp.getObjName()
                                + "] operationName [" + pOp.getOpName() + "] objectId [" + pOp.getObjId()
                                + "] roleNm [" + roleNm + "] successful" );
                        }
                        else
                        {
                            msg = "permissionRoles permission objName [" + pOp.getObjName()
                                + "] operationName [" + pOp.getOpName() + "]  objectId [" + pOp.getObjId()
                                + "] role [" + RoleTestData.getName( rle ) + "] failed list search";
                            LogUtil.logIt( msg );
                            fail( msg );
                        }
                    }
                }
            }
        }
        catch ( SecurityException ex )
        {
            LOG.error(
                "permissionRoles caught SecurityException rc=" + ex.getErrorId() + ", msg=" + ex.getMessage(),
                ex );
            fail( ex.getMessage() );
        }
    }


    /**
     *
     */
    public void testAuthorizedPermissionRoles()
    {
        // public Set<String> authorizedPermissionRoles(Permission perm)
        authorizedPermissionRoles( "AUTHZ PRM-RLES TOB6 TOP5 TR5B", PermTestData.OBJS_TOB6, PermTestData.OPS_TOP5,
            RoleTestData.ROLES_TR5B );
    }


    /**
     *
     * @param msg
     * @param pObjArray
     * @param pOpArray
     * @param rArray
     */
    public static void authorizedPermissionRoles( String msg, String[][] pObjArray, String[][] pOpArray,
        String[][] rArray )
    {
        LogUtil.logIt( msg );
        Permission pOp;
        try
        {
            ReviewMgr reviewMgr = getManagedReviewMgr();
            for ( String[] obj : pObjArray )
            {
                int i = 0;
                for ( String[] op : pOpArray )
                {
                    pOp = new Permission();
                    pOp.setObjName( PermTestData.getName( obj ) );
                    pOp.setOpName( PermTestData.getName( op ) );
                    pOp.setObjId( PermTestData.getObjId( op ) );
                    Set<String> roles = reviewMgr.authorizedPermissionRoles( pOp );
                    assertNotNull( roles );
                    int expectedAuthZedRoles = i + 1;
                    assertTrue( CLS_NM + "authorizedPermissionRoles permission object [" + pOp.getObjName()
                        + "] operationName [" + pOp.getOpName() + "] objectId [" + pOp.getObjId() + "]",
                        expectedAuthZedRoles == roles.size() );
                    int j = 1;
                    for ( String[] rle : rArray )
                    {
                        String roleName = RoleTestData.getName( rle );
                        if ( j++ <= expectedAuthZedRoles )
                        {
                            assertTrue(
                                CLS_NM + "authorizedPermissionRoles roleName [" + roleName
                                    + "] should be authorized for operationName [" + pOp.getOpName() + "] objectId ["
                                    + pOp.getObjId() + "]", roles.contains( roleName ) );
                        }
                        else
                        {
                            assertTrue( CLS_NM + "authorizedPermissionRoles roleName [" + roleName
                                + "] should not be authorized for operationName [" + pOp.getOpName() + "] objectId ["
                                + pOp.getObjId() + "]", !roles.contains( roleName ) );
                        }
                    }
                    i++;
                }
            }
        }
        catch ( SecurityException ex )
        {
            LOG.error( "authorizedPermissionRoles caught SecurityException rc=" + ex.getErrorId() + ", msg="
                + ex.getMessage(), ex );
            fail( ex.getMessage() );
        }
    }


    public void testPermissionUsers()
    {
        //  public List<User> permissionUsers(Permission perm)
        permissionUsers( "PRM-USRS TOB1 TOP1 TU1_UPD", PermTestData.OBJS_TOB1, PermTestData.OPS_TOP1,
            UserTestData.USERS_TU1_UPD );
    }


    /**
     * @param msg
     * @param pObjArray
     * @param pOpArray
     * @param uArray
     */
    public static void permissionUsers( String msg, String[][] pObjArray, String[][] pOpArray, String[][] uArray )
    {
        LogUtil.logIt( msg );
        Permission pOp;
        try
        {
            ReviewMgr reviewMgr = getManagedReviewMgr();
            for ( String[] obj : pObjArray )
            {
                for ( String[] op : pOpArray )
                {
                    pOp = new Permission();
                    pOp.setObjName( PermTestData.getName( obj ) );
                    pOp.setOpName( PermTestData.getName( op ) );
                    pOp.setObjId( PermTestData.getObjId( op ) );
                    List<String> users = reviewMgr.permissionUsers( pOp );
                    assertNotNull( users );
                    assertTrue( CLS_NM + "permissionUsers permission object [" + pOp.getObjName()
                        + "] operationName [" + pOp.getOpName() + "] objectId [" + pOp.getObjId() + "]",
                        uArray.length == users.size() );
                    for ( String[] usr : uArray )
                    {
                        int indx = users.indexOf( RoleTestData.getName( usr ) );
                        if ( indx != -1 )
                        {
                            String userId = users.get( indx );
                            assertEquals( CLS_NM + ".permissionUsers failed compare userId",
                                UserTestData.getUserId( usr ), userId );
                            LOG.debug( "permissionUsers permission objName [" + pOp.getObjName()
                                + "] operationName [" + pOp.getOpName() + "] objectId [" + pOp.getObjId()
                                + "] userId [" + userId + "] successful" );
                        }
                        else
                        {
                            msg = "permissionUsers permission objName [" + pOp.getObjName()
                                + "] operationName [" + pOp.getOpName() + "]  objectId [" + pOp.getObjId()
                                + "] userId [" + UserTestData.getUserId( usr ) + "] failed list search";
                            LogUtil.logIt( msg );
                            fail( msg );
                        }
                    }
                }
            }
        }
        catch ( SecurityException ex )
        {
            LOG.error(
                "permissionUsers caught SecurityException rc=" + ex.getErrorId() + ", msg=" + ex.getMessage(),
                ex );
            fail( ex.getMessage() );
        }
    }


    /**
     *
     */
    public void testAuthorizedPermissionUsers()
    {
        // public Set<String> authorizedPermissionUsers(Permission perm)
        authorizedPermissionUsers( "AUTHZ PRM-USRS TOB6 TOP5 TU20", PermTestData.OBJS_TOB6, PermTestData.OPS_TOP5,
            UserTestData.USERS_TU20U_TR5B );
    }


    /**
     *
     * @param msg
     * @param pObjArray
     * @param pOpArray
     * @param uArray
     */
    public static void authorizedPermissionUsers( String msg, String[][] pObjArray, String[][] pOpArray,
        String[][] uArray )
    {
        LogUtil.logIt( msg );
        Permission pOp;
        try
        {
            ReviewMgr reviewMgr = getManagedReviewMgr();
            for ( String[] obj : pObjArray )
            {
                int i = 0;
                for ( String[] op : pOpArray )
                {
                    pOp = new Permission();
                    pOp.setObjName( PermTestData.getName( obj ) );
                    pOp.setOpName( PermTestData.getName( op ) );
                    pOp.setObjId( PermTestData.getObjId( op ) );
                    Set<String> users = reviewMgr.authorizedPermissionUsers( pOp );
                    assertNotNull( users );
                    int expectedAuthZedUsers = i + 1;
                    assertTrue( CLS_NM + "authorizedPermissionUsers permission object [" + pOp.getObjName()
                        + "] operationName [" + pOp.getOpName() + "] objectId [" + pOp.getObjId() + "]",
                        expectedAuthZedUsers == users.size() );
                    int j = 1;
                    for ( String[] usr : uArray )
                    {
                        String userId = UserTestData.getUserId( usr );
                        if ( j++ <= expectedAuthZedUsers )
                        {
                            assertTrue(
                                CLS_NM + "authorizedPermissionUsers userId [" + userId
                                    + "] should be authorized for operationName [" + pOp.getOpName() + "] objectId ["
                                    + pOp.getObjId() + "]", users.contains( userId ) );
                        }
                        else
                        {
                            assertTrue( CLS_NM + "authorizedPermissionUsers userId [" + userId
                                + "] should not be authorized for operationName [" + pOp.getOpName() + "] objectId ["
                                + pOp.getObjId() + "]", !users.contains( userId ) );
                        }
                    }
                    i++;
                }
            }
        }
        catch ( SecurityException ex )
        {
            LOG.error( "authorizedPermissionUsers caught SecurityException rc=" + ex.getErrorId() + ", msg="
                + ex.getMessage(), ex );
            fail( ex.getMessage() );
        }
    }


    public void testUserPermissions()
    {
        // public List <Permission> userPermissions(User user)
        userPermissions( "USR-PRMS TU1_UPD TOB1 TOP1_UPD", UserTestData.USERS_TU1_UPD, PermTestData.OBJS_TOB1,
            PermTestData.OPS_TOP1_UPD );
        userPermissions( "USR-PRMS TU3 TOB3 TOP3", UserTestData.USERS_TU3, PermTestData.OBJS_TOB3,
            PermTestData.OPS_TOP3 );
        userPermissions( "USR-PRMS TU4 TOB2 TOP2", UserTestData.USERS_TU4, PermTestData.OBJS_TOB2,
            PermTestData.OPS_TOP2 );
    }


    /**
     * @param msg
     * @param uArray
     * @param pObjArray
     * @param pOpArray
     */
    public static void userPermissions( String msg, String[][] uArray, String[][] pObjArray, String[][] pOpArray )
    {
        LogUtil.logIt( msg );
        try
        {
            ReviewMgr reviewMgr = getManagedReviewMgr();
            for ( String[] usr : uArray )
            {
                User user = UserTestData.getUser( usr );
                List<Permission> perms = reviewMgr.userPermissions( user );
                assertNotNull( perms );
                assertTrue( CLS_NM + "userPermissions list size check",
                    pOpArray.length * pObjArray.length == perms.size() );
                for ( String[] obj : pObjArray )
                {
                    for ( String[] op : pOpArray )
                    {
                        int indx = perms.indexOf( new Permission( PermTestData.getName( obj ), PermTestData.getName(
                            op ), PermTestData.getObjId( op ) ) );
                        if ( indx != -1 )
                        {
                            Permission pOp = perms.get( indx );
                            assertNotNull( pOp );
                            PermTestData.assertEquals( PermTestData.getName( obj ), pOp, op );
                            LOG.debug( "userPermissions userId [" + user.getUserId() + "] perm objName ["
                                + PermTestData.getName( obj ) + "] operationName [" + PermTestData.getName( op )
                                + "] successful" );
                        }
                        else
                        {
                            msg = "userPermissions userId [" + user.getUserId() + "] perm objName ["
                                + PermTestData.getName( obj ) + "] operationName [" + PermTestData.getName( op )
                                + "] failed list search";
                            LogUtil.logIt( msg );
                            fail( msg );
                        }
                    }
                }
            }
        }
        catch ( SecurityException ex )
        {
            LOG.error(
                "userPermissions caught SecurityException rc=" + ex.getErrorId() + ", msg=" + ex.getMessage(),
                ex );
            fail( ex.getMessage() );
        }
    }


    public void testFindRoleNms()
    {
        // public List<String> findRoles(String searchVal, int limit)
        searchRolesNms( "SRCH-RLNMS TR1", TestUtils.getSrchValue( RoleTestData.getName( RoleTestData.ROLES_TR1[0] ) ),
            RoleTestData.ROLES_TR1 );
        searchRolesNms( "SRCH-RLNMS TR2", TestUtils.getSrchValue( RoleTestData.getName( RoleTestData.ROLES_TR2[0] ) ),
            RoleTestData.ROLES_TR2 );
        searchRolesNms( "SRCH-RLNMS TR3", TestUtils.getSrchValue( RoleTestData.getName( RoleTestData.ROLES_TR3[0] ) ),
            RoleTestData.ROLES_TR3 );
        searchRolesNms( "SRCH-RLNMS TR4_UPD",
            TestUtils.getSrchValue( RoleTestData.getName( RoleTestData.ROLES_TR4[0] ) ), RoleTestData.ROLES_TR4_UPD );
    }


    /**
     *
     * @param msg
     * @param srchValue
     * @param rArray
     */
    public static void searchRolesNms( String msg, String srchValue, String[][] rArray )
    {
        LogUtil.logIt( msg );
        try
        {
            ReviewMgr reviewMgr = getManagedReviewMgr();
            List<String> roles = reviewMgr.findRoles( srchValue, rArray.length );
            assertNotNull( roles );
            assertTrue( CLS_NM + "searchRolesNms list size check", rArray.length == roles.size() );
            for ( String[] rle : rArray )
            {
                int indx = roles.indexOf( RoleTestData.getName( rle ) );
                if ( indx != -1 )
                {
                    String roleNm = roles.get( indx );
                    assertNotNull( roleNm );
                    assertEquals( CLS_NM + ".searchRolesNms failed compare role name", RoleTestData.getName( rle ),
                        roleNm );
                }
                else
                {
                    msg = "searchRolesNms srchValue [" + srchValue + "] failed list search";
                    LogUtil.logIt( msg );
                    fail( msg );
                }
            }
        }
        catch ( SecurityException ex )
        {
            LOG.error(
                "searchRolesNms srchValue [" + srchValue + "] caught SecurityException rc=" + ex.getErrorId()
                    + ", msg=" + ex.getMessage(), ex );
            fail( ex.getMessage() );
        }
    }


    public void testFindUserIds()
    {
        // public List<String> findUsers(User user, int limit)
        searchUserIds( "SRCH-USRIDS TU1_UPD",
            TestUtils.getSrchValue( UserTestData.getUserId( UserTestData.USERS_TU1[0] ) ), UserTestData.USERS_TU1_UPD );
        searchUserIds( "SRCH-USRIDS TU3",
            TestUtils.getSrchValue( UserTestData.getUserId( UserTestData.USERS_TU3[0] ) ), UserTestData.USERS_TU3 );
        searchUserIds( "SRCH-USRIDS TU4",
            TestUtils.getSrchValue( UserTestData.getUserId( UserTestData.USERS_TU4[0] ) ), UserTestData.USERS_TU4 );
    }


    /**
     *
     * @param msg
     * @param srchValue
     * @param uArray
     */
    public static void searchUserIds( String msg, String srchValue, String[][] uArray )
    {
        LogUtil.logIt( msg );
        try
        {
            ReviewMgr reviewMgr = getManagedReviewMgr();
            List<String> users = reviewMgr.findUsers( new User( srchValue ), uArray.length );
            assertNotNull( users );
            assertTrue( CLS_NM + "searchUserIds list size check", uArray.length == users.size() );
            for ( String[] usr : uArray )
            {
                int indx = users.indexOf( UserTestData.getUserId( usr ) );
                if ( indx != -1 )
                {
                    String userId = users.get( indx );
                    assertNotNull( userId );
                    assertEquals( CLS_NM + ".searchUserIds failed compare user userId", UserTestData.getUserId( usr )
                        .toUpperCase(), userId.toUpperCase() );
                }
                else
                {
                    msg = "searchUserIds srchValue [" + srchValue + "] failed list search";
                    LogUtil.logIt( msg );
                    fail( msg );
                }
            }
        }
        catch ( SecurityException ex )
        {
            LOG.error(
                "searchUserIds srchValue [" + srchValue + "] caught SecurityException rc=" + ex.getErrorId()
                    + ", msg=" + ex.getMessage(), ex );
            fail( ex.getMessage() );
        }
    }


    public void testAuthorizedUserIds()
    {
        //  public List<String> authorizedUsers(Role role, int limit)
        assignedUserIds( "ATHZ-USRS TR1 TU1_UPD", RoleTestData.ROLES_TR1, UserTestData.USERS_TU1_UPD );
        assignedUserIds( "ATHZ-USRS TR2 TU4", RoleTestData.ROLES_TR2, UserTestData.USERS_TU4 );
        assignedUserIds( "ATHZ-USRS TR3 TU3", RoleTestData.ROLES_TR3, UserTestData.USERS_TU3 );
    }


    /**
     * @param msg
     * @param rArray
     * @param uArray
     */
    public static void assignedUserIds( String msg, String[][] rArray, String[][] uArray )
    {
        LogUtil.logIt( msg );
        try
        {
            ReviewMgr reviewMgr = getManagedReviewMgr();
            for ( String[] rle : rArray )
            {
                List<String> users = reviewMgr.assignedUsers( new Role( RoleTestData.getName( rle ) ), uArray.length );
                assertNotNull( users );
                assertTrue( CLS_NM + ".assignedUserIds list size check", uArray.length == users.size() );
                for ( String[] usr : uArray )
                {
                    users.indexOf( UserTestData.getUserId( usr ) );
                    // todo - figure out how to compare userid dns with userids:
                }
            }
        }
        catch ( SecurityException ex )
        {
            LOG.error(
                "assignedUserIds caught SecurityException rc=" + ex.getErrorId() + ", msg=" + ex.getMessage(),
                ex );
            fail( ex.getMessage() );
        }
    }


    public void testAssignedRoleNms()
    {
        //  public List<String> assignedRoles(String userId)
        assignedRoleNms( "ASGN-RLS TU1_UPD TR1", UserTestData.USERS_TU1_UPD, RoleTestData.ROLES_TR1 );
        //assignedRoles("ASGN-RLS TU3 TR2", UserTestData.USERS_TU3, RoleTestData.ROLES_TR2);
        assignedRoleNms( "ASGN-RLS TU4 TR2", UserTestData.USERS_TU4, RoleTestData.ROLES_TR2 );
        assignedRoleNms( "ASGN-RLS TU3 TR3", UserTestData.USERS_TU3, RoleTestData.ROLES_TR3 );
    }


    /**
     * @param msg
     * @param uArray
     * @param rArray
     */
    public static void assignedRoleNms( String msg, String[][] uArray, String[][] rArray )
    {
        LogUtil.logIt( msg );
        try
        {
            ReviewMgr reviewMgr = getManagedReviewMgr();
            for ( String[] usr : uArray )
            {
                List<String> uRoles = reviewMgr.assignedRoles( UserTestData.getUserId( usr ) );
                assertNotNull( uRoles );
                assertTrue( CLS_NM + "assignedRoleNms list size check", rArray.length == uRoles.size() );
                for ( String[] url : rArray )
                {
                    int indx = uRoles.indexOf( RoleTestData.getName( url ) );
                    if ( indx != -1 )
                    {
                        String uRole = uRoles.get( indx );
                        assertNotNull( uRole );
                        assertEquals( CLS_NM + ".assignedRoleNms failed compare role name",
                            RoleTestData.getName( url ), uRole );
                    }
                    else
                    {
                        msg = "assignedRoleNms userId [" + UserTestData.getUserId( usr ) + "] role ["
                            + RoleTestData.getName( url ) + "] failed list search";
                        LogUtil.logIt( msg );
                        fail( msg );
                    }
                }
            }
        }
        catch ( SecurityException ex )
        {
            LOG.error(
                "assignedRoleNms caught SecurityException rc=" + ex.getErrorId() + ", msg=" + ex.getMessage(),
                ex );
            fail( ex.getMessage() );
        }
    }


    public void testFindSsdSets()
    {
        searchSsdSets(
            "SRCH-SSD T1",
            TestUtils.getSrchValue( RoleTestData.getName( RoleTestData.SSD_T1[0] ),
                RoleTestData.getName( RoleTestData.SSD_T1[0] ).length() - 1 ), RoleTestData.SSD_T1 );
        searchSsdSets(
            "SRCH-SSD T4",
            TestUtils.getSrchValue( RoleTestData.getName( RoleTestData.SSD_T4[0] ),
                RoleTestData.getName( RoleTestData.SSD_T4[0] ).length() - 1 ), RoleTestData.SSD_T4 );
        searchSsdSets(
            "SRCH-SSD T5",
            TestUtils.getSrchValue( RoleTestData.getName( RoleTestData.SSD_T5[0] ),
                RoleTestData.getName( RoleTestData.SSD_T5[0] ).length() - 1 ), RoleTestData.SSD_T5 );
        searchSsdSets(
            "SRCH-SSD T6",
            TestUtils.getSrchValue( RoleTestData.getName( RoleTestData.SSD_T6[0] ),
                RoleTestData.getName( RoleTestData.SSD_T6[0] ).length() - 1 ), RoleTestData.SSD_T6 );
    }


    /**
     *
     * @param msg
     * @param srchValue
     * @param sArray
     */
    public static void searchSsdSets( String msg, String srchValue, String[][] sArray )
    {
        LogUtil.logIt( msg );
        try
        {
            ReviewMgr reviewMgr = getManagedReviewMgr();
            SDSet sdSet = new SDSet();
            sdSet.setName( srchValue );
            List<SDSet> sdSetList = reviewMgr.ssdSets( sdSet );
            assertNotNull( sdSetList );
        }
        catch ( SecurityException ex )
        {
            LOG.error(
                "searchRoles searchSsdSets [" + srchValue + "] caught SecurityException rc="
                    + ex.getErrorId() + ", msg=" + ex.getMessage(), ex );
            fail( ex.getMessage() );
        }
    }


    public void testFindDsdSets()
    {
        searchDsdSets(
            "SRCH-DSD T1",
            TestUtils.getSrchValue( RoleTestData.getName( RoleTestData.DSD_T1[0] ),
                RoleTestData.getName( RoleTestData.DSD_T1[0] ).length() - 1 ), RoleTestData.DSD_T1 );
        searchDsdSets(
            "SRCH-DSD T4",
            TestUtils.getSrchValue( RoleTestData.getName( RoleTestData.DSD_T4[0] ),
                RoleTestData.getName( RoleTestData.DSD_T4[0] ).length() - 1 ), RoleTestData.DSD_T4 );
        searchDsdSets(
            "SRCH-DSD T5",
            TestUtils.getSrchValue( RoleTestData.getName( RoleTestData.DSD_T5[0] ),
                RoleTestData.getName( RoleTestData.DSD_T5[0] ).length() - 1 ), RoleTestData.DSD_T5 );
        searchDsdSets(
            "SRCH-DSD T6",
            TestUtils.getSrchValue( RoleTestData.getName( RoleTestData.DSD_T6[0] ),
                RoleTestData.getName( RoleTestData.DSD_T6[0] ).length() - 1 ), RoleTestData.DSD_T6 );
    }


    /**
     *
     * @param msg
     * @param srchValue
     * @param sArray
     */
    public static void searchDsdSets( String msg, String srchValue, String[][] sArray )
    {
        LogUtil.logIt( msg );
        try
        {
            ReviewMgr reviewMgr = getManagedReviewMgr();
            SDSet sdSet = new SDSet();
            sdSet.setName( srchValue );
            List<SDSet> sdSetList = reviewMgr.ssdSets( sdSet );
            assertNotNull( sdSetList );
        }
        catch ( SecurityException ex )
        {
            LOG.error(
                "searchRoles searchDsdSets [" + srchValue + "] caught SecurityException rc="
                    + ex.getErrorId() + ", msg=" + ex.getMessage(), ex );
            fail( ex.getMessage() );
        }
    }

    public void testReadUserRoleConstraint()
    {
        readUserRoleConstraint( "RD-URC TU1 TR1", UserTestData.USERS_TU1[0], RoleTestData.ROLES_TR1[1], URATestData
            .getRC( URATestData.URC_T1 ) );
    }

    public static void readUserRoleConstraint( String msg, String[] usr, String[] rle, RoleConstraint rc )
    {
        LogUtil.logIt( msg );
        try
        {
            ReviewMgr reviewMgr = getManagedReviewMgr();           
            User user = UserTestData.getUser( usr );
            Role role = RoleTestData.getRole( rle );
            
            List<UserRole> urs = reviewMgr.assignedRoles(user);
            boolean uraFound = false;
            boolean urcFound = false;
            
            for(UserRole ur : urs){
                if(ur.getName().equals(role.getName())){
                    uraFound = true;
                    
                    List<RoleConstraint> rcs = ur.getRoleConstraints();
                    for(RoleConstraint r : rcs){
                        if(r.getKey().equals(rc.getKey())){
                            urcFound = true;
                            assertEquals(rc.getType(), r.getType());
                            assertEquals(rc.getValue(), r.getValue());
                            assertNotNull( r.getId() );
                        }
                    }
                }
            }
            
            if(!uraFound){
                fail("User Role Assignment Not Found");
            }
            if(!urcFound){
                fail("User Role Constraint Not Found");
            }
            
            LOG.debug( "readUserRoleConstraint value [" + rc.getValue() + "] successful" );
        }
        catch ( SecurityException ex )
        {
            LOG.error( "readUserRoleConstraint value [" + rc.getValue()
                    + "] caught SecurityException rc=" + ex.getErrorId() + ", msg=" + ex.getMessage(), ex );
            fail( ex.getMessage() );
        }
    }

    public void testAssignedUserRoleConstraints()
    {
        assignUserRoleConstraints( "ASSGN-USER-ROLE-CONSTRAINTS TR18 ABAC", RoleTestData.ROLE_CONSTRAINTS_TR18_ABAC );
        assignUserRoleConstraintsKey( "ASSGN-USER-ROLE-CONSTRAINTS WKEY TR18 ABAC", RoleTestData.ROLE_CONSTRAINTS_TR18_ABAC );
    }

    private void assignUserRoleConstraints( String msg, String[][] urArray )
    {
        LogUtil.logIt( msg );
        try
        {
            ReviewMgr reviewMgr = ReviewMgrImplTest.getManagedReviewMgr();
            for ( String[] urConstraint : urArray )
            {
                UserRole uRole = RoleTestData.getUserRoleConstraintAbac( urConstraint );
                RoleConstraint constraint = uRole.getConstraints().get( 0 );
                List<User> users = reviewMgr.assignedUsers( new Role( uRole.getName() ), constraint );
                assertTrue( users.size() > 0 );
            }
        }
        catch ( SecurityException ex )
        {
            LOG.error(
                "assignUserRoleConstraints caught SecurityException rc=" + ex.getErrorId() + ", msg="
                    + ex.getMessage(), ex );
            fail( ex.getMessage() );
        }
    }


    private void assignUserRoleConstraintsKey( String msg, String[][] urArray )
    {
        LogUtil.logIt( msg );
        try
        {
            ReviewMgr reviewMgr = ReviewMgrImplTest.getManagedReviewMgr();
            for ( String[] urConstraint : urArray )
            {
                UserRole uRole = RoleTestData.getUserRoleConstraintAbac( urConstraint );
                RoleConstraint constraint = uRole.getConstraints().get( 0 );
                List<UserRole> uRoles = reviewMgr.assignedUsers( new Role( uRole.getName() ), RoleConstraint.RCType.USER, constraint.getKey());
                assertTrue( "curly, moe, larry", uRoles.size() == 3 );
            }
        }
        catch ( SecurityException ex )
        {
            LOG.error(
                "assignUserRoleConstraintsKey caught SecurityException rc=" + ex.getErrorId() + ", msg="
                    + ex.getMessage(), ex );
            fail( ex.getMessage() );
        }
    }


    public void testFindRoleConstraints()
    {
        findRoleConstraints( "SRCH-RCS TU1 TR1", UserTestData.USERS_TU1[0][0], PermTestData.getOp("TOB1_1", PermTestData.OPS_TOP1_UPD[0]), URATestData.getRC(URATestData.URC_T1).getType() );
        findUserRoleWithConstraints( "SRCH-RCS TR1", RoleTestData.ROLES_TR1[1][0], URATestData.getRC( URATestData.URC_T1 ).getType(), URATestData.getRC( URATestData.URC_T1 ).getKey() );
        findUserRoleWithConstraints( "SRCH-RCS TR18 ABAC", RoleTestData.ROLES_ABAC_WASHERS[0][0], RoleConstraint.RCType.USER, RoleTestData.ROLE_CONSTRAINTS_TR18_ABAC[0][2] );
        findUserRoleWithConstraints( "SRCH-RCS TR18 ABAC", RoleTestData.ROLES_ABAC_TELLERS[0][0], RoleConstraint.RCType.USER, RoleTestData.ROLE_CONSTRAINTS_TR18_ABAC[0][2] );
    }
    
    public static void findUserRoleWithConstraints( String msg, String role, RoleConstraint.RCType rcType, String keyName )
    {
        LogUtil.logIt(msg);
        try
        {
            ReviewMgr reviewMgr = getManagedReviewMgr();           

            List<UserRole> urs = reviewMgr.assignedUsers( new Role(role), rcType, keyName);
            assertNotNull( "findUserRoleWithConstraints no results", urs );
                assertTrue(urs.size() > 0);
            assertTrue(urs.get(0).getRoleConstraints().size() > 0);
   
            LOG.debug( "findUserRoleWithConstraints paSetName [" + keyName + "] successful" );
        }
        catch ( SecurityException ex )
        {
            LOG.error( "findUserRoleWithConstraints paSetName [" + keyName
                    + "] caught SecurityException rc=" + ex.getErrorId() + ", msg=" + ex.getMessage(), ex );
            fail( ex.getMessage() );
        }
    }        
    
    public static void findRoleConstraints( String msg, String usr, Permission permission, RoleConstraint.RCType rcType )
    {
        LogUtil.logIt(msg);
        try
        {
            ReviewMgr reviewMgr = getManagedReviewMgr();        

            List<RoleConstraint> rcs = reviewMgr.findRoleConstraints(new User(usr), permission, rcType);
            assertTrue("no constraints found for user:" + usr, rcs.size() > 0);
            assertTrue("invalid constraint type", rcs.get(0).getType().equals( rcType ) );
            LOG.debug( "findRoleConstraints permission [" + permission.getObjName() + "." + permission.getOpName() + "] successful" );
        }
        catch ( SecurityException ex )
        {
            LOG.error( "findRoleConstraints permission [" + permission.getObjName() + "." + permission.getOpName()
                    + "] caught SecurityException rc=" + ex.getErrorId() + ", msg=" + ex.getMessage(), ex );
            fail( ex.getMessage() );
        }
    }   
    
    public void testDeassignRoleWithRoleConstraint() throws SecurityException{
        AdminMgr adminMgr = AdminMgrImplTest.getManagedAdminMgr();
        adminMgr.deassignUser( new UserRole( UserTestData.USERS_TU1[0][0], RoleTestData.ROLES_TR1[1][0] ) );
        
        ReviewMgr reviewMgr = getManagedReviewMgr();
        reviewMgr.assignedRoles( new User( UserTestData.USERS_TU1[0][0] ) );
        
        adminMgr.assignUser( new UserRole( UserTestData.USERS_TU1[0][0], RoleTestData.ROLES_TR1[1][0] ) );
    }
    
    /**
     *
     * @return
     * @throws org.apache.directory.fortress.core.SecurityException
     */
    public static ReviewMgr getManagedReviewMgr() throws SecurityException
    {
        if ( FortressJUnitTest.isAdminEnabled() && adminSess == null )
        {
            adminSess = DelegatedMgrImplTest.createAdminSession();
        }
        return ReviewMgrFactory.createInstance( TestUtils.getContext(), adminSess );
    }
}