/*

* Copyright (c) 2008 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:

*

*/

package com.nokia.mj.impl.security.midp.authorization;

import java.util.Hashtable;

import com.nokia.mj.impl.utils.Uid;

import com.nokia.mj.impl.installer.utils.InstallerMain;

import com.nokia.mj.impl.security.midp.authorization.AccessControllerImpl;

import com.nokia.mj.impl.security.midp.authorization.PermissionResolver;

import com.nokia.mj.impl.security.midp.authorization.AccessControllerFactoryImpl;

import com.nokia.mj.impl.utils.exception.ExceptionBase;

import com.nokia.mj.impl.security.midp.authentication.AuthenticationModule;

import com.nokia.mj.impl.security.midp.authorization.PermissionGranter;

import com.nokia.mj.impl.security.midp.common.AuthenticationCredentials;

import com.nokia.mj.impl.security.midp.common.SecurityAttributes;

import com.nokia.mj.impl.security.midp.common.SigningCertificate;

import com.nokia.mj.impl.security.midp.common.AuthenticationAttribute;

import com.nokia.mj.impl.security.midp.common.MIDPPermission;

import com.nokia.mj.impl.security.midp.common.PermissionMappingTable;

import com.nokia.mj.impl.utils.Attribute;

import com.nokia.mj.impl.security.utils.*;

import java.security.*;

//import javax.microedition.io.*;

import com.nokia.mj.impl.security.midp.storage.SecurityStorage;

import com.nokia.mj.impl.storage.*;

import com.nokia.mj.impl.security.midp.common.PolicyBasedPermission;

import com.nokia.mj.impl.security.midp.common.PolicyBasedPermissionImpl;

import com.nokia.mj.impl.security.midp.common.UserSecuritySettings;

import com.nokia.mj.impl.security.midp.common.GeneralSecuritySettings;

import com.nokia.mj.impl.security.midp.common.UserSecuritySettingsImpl;

import com.nokia.mj.impl.rt.ui.RuntimeUiFactory;

import com.nokia.mj.impl.rt.ui.RuntimeUi;

import j2meunit.framework.Test;

import j2meunit.framework.TestCase;

import j2meunit.framework.TestMethod;

import j2meunit.framework.TestSuite;

import java.util.Vector;

/**

 * Interactive AccessController unit tests.

 */

public class InteractiveAccessControllerTests extends TestCase implements InstallerMain

{

    private static String TEST_DATA_DIR;

    static

    {

        String platform = System.getProperty("os.name");

        if (platform != null && platform.equalsIgnoreCase("linux"))

        {

            TEST_DATA_DIR = System.getProperty("JAVA_BIN_ROOT") + "/securitytestdata/";

        }

        else

        {

            TEST_DATA_DIR = "C:\\java\\securitytestdata\\";

        }

    }

    /**

     * Hashtable holding all the attributes. Tests populate this hashtable

     * prior to being executed

     */

    protected Hashtable allAttributes;

    AuthenticationModule authenticationModule;

    PermissionGranter permissionGranter;

    // general-purpose constants

    protected static final String MIDP_PROFILE_ATTRIBUTE_NAME = "MicroEdition-Profile";

    protected static final String MIDP3 = "MIDP-3.0";

    protected static final String MIDP2 = "MIDP-2.0";

    private static final String COMMA = ",";

    /**

     * The implementation's mapping between (MIDP2 and MIDP3 permissions) and the

     * internal class permissions

     */

    private Hashtable IMPL_PERMISSION_MAPPING_TABLE;

    /**

     * The mapping between (MIDP2 and MIDP3 permissions) and the internal

     * class permissions

     */

    //private Hashtable TEST_PERMISSION_MAPPING_TABLE;

    // Begin j2meunit test framework setup

    public void installerMain(String[] args)

    {

        TestSuite suite = new TestSuite(this.getClass().getName());

        suite.addTest(new InteractiveAccessControllerTests("testAVKONSecurityPrompts", new TestMethod()

        {

            public void run(TestCase tc)

            {

                ((InteractiveAccessControllerTests)tc).testAVKONSecurityPrompts();

            }

        }));

        com.nokia.mj.impl.utils.OmjTestRunner.run(suite);

    }

    public InteractiveAccessControllerTests()

    {

    }

    public InteractiveAccessControllerTests(String aTestName, TestMethod aTestMethod)

    {

        super(aTestName, aTestMethod);

    }

    public void assertFalse(String aMsg, boolean aCondition)

    {

        assertTrue(aMsg, !aCondition);

    }

    // End j2meunit test framework setup

    protected void setUp()

    {

        authenticationModule = authenticationModule.getInstance();

        permissionGranter = permissionGranter.getInstance();

    }

    protected void tearDown()

    {

    }

    private void testAVKONSecurityPrompts()

    {

        System.setProperty("com.nokia.mj.impl.rt.ui", "com.nokia.mj.impl.rt.ui.avkon.RuntimeUiAvkon");

        testSecurityPrompts();

    }

    private void testSecurityPrompts()

    {

        // init the new mapping & policies

        //initMappingTable();

        IMPL_PERMISSION_MAPPING_TABLE = PermissionMappingTable.setMappingTable(TestPermissionMappingTable.getMappingTable());

        SecurityPolicyModule.policiesDir = TEST_DATA_DIR;

        SecurityPolicyModule.policiesFileNamePrefix = "test_";

        allAttributes = new Hashtable();

        SecurityAttributes securityAttributes;

        SigningCertificate[] signingCerts;

        AuthenticationCredentials[] credentials;

        Uid appUID = Uid.createUid("myAppUID");

        String appName = "InteractiveSecurityTests";

        SecurityStorage storage = new SecurityStorage();

        StorageSession session = StorageFactory.createSession();

        session.open();

        Vector grantedPermissions;

        storage.removeGrantedPermissions(appUID);

        AccessControllerImpl ac = AccessControllerFactoryImpl.getAccessController(appUID, appName);

        session.remove(StorageNames.MIDP_PACKAGE_TABLE, appUID);

        StorageEntry entry = new StorageEntry();

        entry.addAttribute(new StorageAttribute(

                               StorageNames.ID,

                               appUID.getStringValue()));

        entry.addAttribute(new StorageAttribute(

                               StorageNames.SECURITY_WARNINGS,

                               "" + GeneralSecuritySettings.DEFAULT_SECURITY_MODE));

        session.write(StorageNames.MIDP_PACKAGE_TABLE, entry);

        // prompts for composite actions

        GeneralSecuritySettings.setSecurityWarningsMode(session, appUID, GeneralSecuritySettings.USER_SECURITY_MODE);

        PermissionResolver.testClearCache();

        grantedPermissions = new Vector();

        grantedPermissions.addElement(new PolicyBasedPermissionImpl(

                                          "com.nokia.mj.impl.security.midp.authorization.PermissionWithCompositeActionsImpl",

                                          "uri://",

                                          "action1",

                                          new UserSecuritySettingsImpl("Function Group",

                                                                       UserSecuritySettings.ONESHOT_INTERACTION_MODE,

                                                                       new int[] { UserSecuritySettings.ONESHOT_INTERACTION_MODE,

                                                                                   UserSecuritySettings.NO_INTERACTION_MODE

                                                                                 })));

        grantedPermissions.addElement(new PolicyBasedPermissionImpl(

                                          "com.nokia.mj.impl.security.midp.authorization.PermissionWithCompositeActionsImpl",

                                          "uri://",

                                          "action2",

                                          new UserSecuritySettingsImpl("Function Group",

                                                                       UserSecuritySettings.ONESHOT_INTERACTION_MODE,

                                                                       new int[] { UserSecuritySettings.ONESHOT_INTERACTION_MODE,

                                                                                   UserSecuritySettings.NO_INTERACTION_MODE

                                                                                 })));

        storage.removeGrantedPermissions(appUID);

        storage.writeGrantedPermissions(appUID, null, grantedPermissions);

        com.nokia.mj.impl.security.midp.authentication.InteractiveAuthenticationModuleTests.showGuidelines("Check that each of the following three prompts contains two identical texts");

        ac.checkPermission(new PermissionWithCompositeActionsImpl("uri://", "\nPrompt for action1", "action1"));

        ac.checkPermission(new PermissionWithCompositeActionsImpl("uri://", "\nPrompt for action2", "action2"));

        ac.checkPermission(new PermissionWithCompositeActionsImpl("uri://", "\nPrompt for action1 and action2", "action1,action2"));

        ac.checkPermission(new PermissionWithCompositeActionsImpl("uri://", "\nPrompt for action1 and action2", "action2,action1"));

        try

        {

            ac.checkPermission(new PermissionWithCompositeActionsImpl("uri://", "\n(IF YOU SEE THIS PROMPT THE TEST FAILED)", "action2,action1,action3"));

            assertTrue(false);

        }

        catch (AccessControlException e)

        {

            assertTrue(true);

        }

        try

        {

            ac.checkPermission(new PermissionWithCompositeActionsImpl("uri://", "\n(IF YOU SEE THIS PROMPT THE TEST FAILED)", "action2,action3"));

            assertTrue(false);

        }

        catch (AccessControlException e)

        {

            assertTrue(true);

        }

        assertTrue(true);

        // for NORMAL security mode, in case of identical prompts, only show one (even though they are part of different function groups)

        GeneralSecuritySettings.setSecurityWarningsMode(session, appUID, GeneralSecuritySettings.DEFAULT_SECURITY_MODE);

        PermissionResolver.testClearCache();

        grantedPermissions = new Vector();

        grantedPermissions.addElement(new PolicyBasedPermissionImpl(

                                          "com.nokia.mj.impl.security.midp.authorization.CommProtocolPermissionImpl",

                                          "comm://",

                                          null,

                                          new UserSecuritySettingsImpl("Low Level Net Access",

                                                                       UserSecuritySettings.ONESHOT_INTERACTION_MODE,

                                                                       new int[] { UserSecuritySettings.ONESHOT_INTERACTION_MODE,

                                                                                   UserSecuritySettings.SESSION_INTERACTION_MODE,

                                                                                   UserSecuritySettings.BLANKET_INTERACTION_MODE,

                                                                                   UserSecuritySettings.NO_INTERACTION_MODE

                                                                                 })));

        grantedPermissions.addElement(new PolicyBasedPermissionImpl(

                                          "com.nokia.mj.impl.security.midp.authorization.HttpProtocolPermissionImpl",

                                          "http://",

                                          null,

                                          new UserSecuritySettingsImpl("Net Access",

                                                                       UserSecuritySettings.ONESHOT_INTERACTION_MODE,

                                                                       new int[] { UserSecuritySettings.ONESHOT_INTERACTION_MODE,

                                                                                   UserSecuritySettings.SESSION_INTERACTION_MODE,

                                                                                   UserSecuritySettings.BLANKET_INTERACTION_MODE,

                                                                                   UserSecuritySettings.NO_INTERACTION_MODE

                                                                                 })));

        storage.removeGrantedPermissions(appUID);

        storage.writeGrantedPermissions(appUID, null, grantedPermissions);

        ac.checkPermission(new HttpProtocolPermissionImpl("http://", "\n(choose ALLOW and make sure this text is shown only once)"));

        ac.checkPermission(new CommProtocolPermissionImpl("comm://", "\n(choose ALLOW and make sure this text is shown only once)"));

        // for USER security mode, in case of identical prompts, show them both

        GeneralSecuritySettings.setSecurityWarningsMode(session, appUID, GeneralSecuritySettings.USER_SECURITY_MODE);

        AccessControllerFactoryImpl.destroyAccessController(appUID);

        ac = AccessControllerFactoryImpl.getAccessController(appUID, appName);

        PermissionResolver.testClearCache();

        grantedPermissions = new Vector();

        grantedPermissions.addElement(new PolicyBasedPermissionImpl(

                                          "com.nokia.mj.impl.security.midp.authorization.CommProtocolPermissionImpl",

                                          "comm://",

                                          null,

                                          new UserSecuritySettingsImpl("Low Level Net Access",

                                                                       UserSecuritySettings.ONESHOT_INTERACTION_MODE,

                                                                       new int[] { UserSecuritySettings.ONESHOT_INTERACTION_MODE,

                                                                                   UserSecuritySettings.SESSION_INTERACTION_MODE,

                                                                                   UserSecuritySettings.BLANKET_INTERACTION_MODE,

                                                                                   UserSecuritySettings.NO_INTERACTION_MODE

                                                                                 })));

        grantedPermissions.addElement(new PolicyBasedPermissionImpl(

                                          "com.nokia.mj.impl.security.midp.authorization.HttpProtocolPermissionImpl",

                                          "http://",

                                          null,

                                          new UserSecuritySettingsImpl("Net Access",

                                                                       UserSecuritySettings.ONESHOT_INTERACTION_MODE,

                                                                       new int[] { UserSecuritySettings.ONESHOT_INTERACTION_MODE,

                                                                                   UserSecuritySettings.SESSION_INTERACTION_MODE,

                                                                                   UserSecuritySettings.BLANKET_INTERACTION_MODE,

                                                                                   UserSecuritySettings.NO_INTERACTION_MODE

                                                                                 })));

        storage.removeGrantedPermissions(appUID);

        storage.writeGrantedPermissions(appUID, null, grantedPermissions);

        ac.checkPermission(new HttpProtocolPermissionImpl("http://", "\n(choose ALLOW and make sure this text is shown twice)"));

        ac.checkPermission(new CommProtocolPermissionImpl("comm://", "\n(choose ALLOW and make sure this text is shown twice)"));

        // check user permission with oneshot interaction mode -> multiple prompts and deny is oneshot deny

        GeneralSecuritySettings.setSecurityWarningsMode(session, appUID, GeneralSecuritySettings.USER_SECURITY_MODE);

        AccessControllerFactoryImpl.destroyAccessController(appUID);

        ac = AccessControllerFactoryImpl.getAccessController(appUID, appName);

        PermissionResolver.testClearCache();

        grantedPermissions = new Vector();

        grantedPermissions.addElement(new PolicyBasedPermissionImpl(

                                          "com.nokia.mj.impl.security.midp.authorization.CommProtocolPermissionImpl",

                                          "comm://",

                                          null,

                                          new UserSecuritySettingsImpl("Low Level Net Access",

                                                                       UserSecuritySettings.ONESHOT_INTERACTION_MODE,

                                                                       new int[] { UserSecuritySettings.ONESHOT_INTERACTION_MODE,

                                                                                   UserSecuritySettings.SESSION_INTERACTION_MODE,

                                                                                   UserSecuritySettings.BLANKET_INTERACTION_MODE,

                                                                                   UserSecuritySettings.NO_INTERACTION_MODE

                                                                                 })));

        storage.removeGrantedPermissions(appUID);

        storage.writeGrantedPermissions(appUID, null, grantedPermissions);

        ac.checkPermission(new CommProtocolPermissionImpl("comm://", "\n(choose ALLOW)"));

        try

        {

            ac.checkPermission(new CommProtocolPermissionImpl("comm://", "\n(choose DENY)"));

            assertTrue(false);

        }

        catch (AccessControlException e)

        {

            assertTrue(true);

        }

        try

        {

            ac.checkPermission(new CommProtocolPermissionImpl("comm://", "\n(choose DENY)"));

            assertTrue(false);

        }

        catch (AccessControlException e)

        {

            assertTrue(true);

        }

        storage.removeGrantedPermissions(appUID);

        // check user permission with session interaction mode -> only one user prompt

        AccessControllerFactoryImpl.destroyAccessController(appUID);

        ac = AccessControllerFactoryImpl.getAccessController(appUID, appName);

        GeneralSecuritySettings.setSecurityWarningsMode(session, appUID, GeneralSecuritySettings.DEFAULT_SECURITY_MODE);

        AccessControllerFactoryImpl.destroyAccessController(appUID);

        ac = AccessControllerFactoryImpl.getAccessController(appUID, appName);

        PermissionResolver.testClearCache();

        grantedPermissions = new Vector();

        grantedPermissions.addElement(new PolicyBasedPermissionImpl(

                                          "com.nokia.mj.impl.security.midp.authorization.HttpProtocolPermissionImpl",

                                          "http://",

                                          null,

                                          new UserSecuritySettingsImpl("Net Access",

                                                                       UserSecuritySettings.SESSION_INTERACTION_MODE,

                                                                       new int[] { UserSecuritySettings.ONESHOT_INTERACTION_MODE,

                                                                                   UserSecuritySettings.SESSION_INTERACTION_MODE,

                                                                                   UserSecuritySettings.BLANKET_INTERACTION_MODE,

                                                                                   UserSecuritySettings.NO_INTERACTION_MODE

                                                                                 })));

        storage.removeGrantedPermissions(appUID);

        storage.writeGrantedPermissions(appUID, null, grantedPermissions);

        ac.checkPermission(new HttpProtocolPermissionImpl("http://somethingelse", "\n(choose ALLOW)"));

        ac.checkPermission(new HttpProtocolPermissionImpl("http://somethingelse", "\n(IF YOU SEE THIS PROMPT THE TEST FAILED)"));

        assertTrue(ac.checkPermission("javax.microedition.io.Connector.http") == 1);

        storage.removeGrantedPermissions(appUID);

        assertTrue(true);

        // isPermissionAllowed

        AccessControllerFactoryImpl.destroyAccessController(appUID);

        ac = AccessControllerFactoryImpl.getAccessController(appUID, appName);

        GeneralSecuritySettings.setSecurityWarningsMode(session, appUID, GeneralSecuritySettings.USER_SECURITY_MODE);

        AccessControllerFactoryImpl.destroyAccessController(appUID);

        ac = AccessControllerFactoryImpl.getAccessController(appUID, appName);

        PermissionResolver.testClearCache();

        grantedPermissions = new Vector();

        grantedPermissions.addElement(new PolicyBasedPermissionImpl(

                                          "com.nokia.mj.impl.security.midp.authorization.HttpProtocolPermissionImpl",

                                          "http://",

                                          null,

                                          new UserSecuritySettingsImpl("Net Access",

                                                                       UserSecuritySettings.ONESHOT_INTERACTION_MODE,

                                                                       new int[] { UserSecuritySettings.ONESHOT_INTERACTION_MODE,

                                                                                   UserSecuritySettings.NO_INTERACTION_MODE

                                                                                 })));

        grantedPermissions.addElement(new PolicyBasedPermissionImpl(

                                          "com.nokia.mj.impl.security.midp.authorization.HttpsProtocolPermissionImpl",

                                          "https://",

                                          null,

                                          new UserSecuritySettingsImpl("Net Access",

                                                                       UserSecuritySettings.ONESHOT_INTERACTION_MODE,

                                                                       new int[] { UserSecuritySettings.ONESHOT_INTERACTION_MODE,

                                                                                   UserSecuritySettings.NO_INTERACTION_MODE

                                                                                 })));

        storage.removeGrantedPermissions(appUID);

        storage.writeGrantedPermissions(appUID, null, grantedPermissions);

        assertTrue(ac.checkPermission("javax.microedition.io.Connector.http") == -1);

        assertTrue(ac.checkPermission("javax.microedition.io.Connector.https") == -1);

        assertTrue(ac.checkPermission("javax.microedition.securityservice.CMSMessageSignatureService") == 0);

        // show note -> choose yes

        com.nokia.mj.impl.security.midp.authentication.InteractiveAuthenticationModuleTests.showGuidelines("Choose Yes for each of the following two prompts");

        assertTrue(ac.isPermissionAllowed("javax.microedition.io.Connector.http"));

        assertTrue(ac.isPermissionAllowed("javax.microedition.io.Connector.https"));

        assertTrue(ac.isPermissionAllowed("javax.microedition.media.control.VideoControl.getSnapshot") == false);

        // show note choose no

        com.nokia.mj.impl.security.midp.authentication.InteractiveAuthenticationModuleTests.showGuidelines("Choose No for each of the following two prompts");

        assertTrue(ac.isPermissionAllowed("javax.microedition.io.Connector.http") == false);

        assertTrue(ac.isPermissionAllowed("javax.microedition.io.Connector.https") == false);

        assertTrue(ac.isPermissionAllowed("javax.microedition.io.Connector.rtsp") == false);

        assertTrue(ac.isPermissionAllowed("javax.microedition.media.control.VideoControl.getSnapshot") == false);

        storage.removeGrantedPermissions(appUID);

        assertTrue(true);

        // check user permission with session interaction mode, user says no -> second prompt is not shown in normal security mode

        GeneralSecuritySettings.setSecurityWarningsMode(session, appUID, GeneralSecuritySettings.DEFAULT_SECURITY_MODE);

        AccessControllerFactoryImpl.destroyAccessController(appUID);

        ac = AccessControllerFactoryImpl.getAccessController(appUID, appName);

        PermissionResolver.testClearCache();

        grantedPermissions = new Vector();

        grantedPermissions.addElement(new PolicyBasedPermissionImpl(

                                          "com.nokia.mj.impl.security.midp.authorization.HttpProtocolPermissionImpl",

                                          "http://",

                                          null,

                                          new UserSecuritySettingsImpl("Net Access",

                                                                       UserSecuritySettings.SESSION_INTERACTION_MODE,

                                                                       new int[] { UserSecuritySettings.ONESHOT_INTERACTION_MODE,

                                                                                   UserSecuritySettings.SESSION_INTERACTION_MODE,

                                                                                   UserSecuritySettings.BLANKET_INTERACTION_MODE,

                                                                                   UserSecuritySettings.NO_INTERACTION_MODE

                                                                                 })));

        storage.removeGrantedPermissions(appUID);

        storage.writeGrantedPermissions(appUID, null, grantedPermissions);

        try

        {

            ac.checkPermission(new HttpProtocolPermissionImpl("http://somethingelse","\n(choose DENY)"));

            assertTrue(false);

        }

        catch (AccessControlException e)

        {

            assertTrue(true);

        }

        try

        {

            ac.checkPermission(new HttpProtocolPermissionImpl("http://somethingelse", "\n(IF YOU SEE THIS PROMPT THE TEST FAILED)"));

            assertTrue(false);

        }

        catch (AccessControlException e)

        {

            assertTrue(true);

        }

        storage.removeGrantedPermissions(appUID);

        assertTrue(true);

        // check user permission with session interaction mode, user says no -> second prompt is not shown in user security mode

        GeneralSecuritySettings.setSecurityWarningsMode(session, appUID, GeneralSecuritySettings.USER_SECURITY_MODE);

        AccessControllerFactoryImpl.destroyAccessController(appUID);

        ac = AccessControllerFactoryImpl.getAccessController(appUID, appName);

        PermissionResolver.testClearCache();

        grantedPermissions = new Vector();

        grantedPermissions.addElement(new PolicyBasedPermissionImpl(

                                          "com.nokia.mj.impl.security.midp.authorization.HttpProtocolPermissionImpl",

                                          "http://",

                                          null,

                                          new UserSecuritySettingsImpl("Net Access",

                                                                       UserSecuritySettings.SESSION_INTERACTION_MODE,

                                                                       new int[] { UserSecuritySettings.ONESHOT_INTERACTION_MODE,

                                                                                   UserSecuritySettings.SESSION_INTERACTION_MODE,

                                                                                   UserSecuritySettings.BLANKET_INTERACTION_MODE,

                                                                                   UserSecuritySettings.NO_INTERACTION_MODE

                                                                                 })));

        storage.removeGrantedPermissions(appUID);

        storage.writeGrantedPermissions(appUID, null, grantedPermissions);

        try

        {

            ac.checkPermission(new HttpProtocolPermissionImpl("http://somethingelse","\n(choose DENY)"));

            assertTrue(false);

        }

        catch (AccessControlException e)

        {

            assertTrue(true);

        }

        try

        {

            ac.checkPermission(new HttpProtocolPermissionImpl("http://somethingelse", "\n(IF YOU SEE THIS PROMPT THE TEST FAILED)"));

            assertTrue(false);

        }

        catch (AccessControlException e)

        {

            assertTrue(true);

        }

        storage.removeGrantedPermissions(appUID);

        assertTrue(true);

        // check user permission with blanket interaction mode, user says no -> second prompt is not shown

        GeneralSecuritySettings.setSecurityWarningsMode(session, appUID, GeneralSecuritySettings.DEFAULT_SECURITY_MODE);

        AccessControllerFactoryImpl.destroyAccessController(appUID);

        ac = AccessControllerFactoryImpl.getAccessController(appUID, appName);

        PermissionResolver.testClearCache();

        grantedPermissions = new Vector();

        grantedPermissions.addElement(new PolicyBasedPermissionImpl(

                                          "com.nokia.mj.impl.security.midp.authorization.FileProtocolPermissionImpl",

                                          "file://*",

                                          "read",

                                          new UserSecuritySettingsImpl("File Access",

                                                                       UserSecuritySettings.BLANKET_INTERACTION_MODE,

                                                                       new int[] { UserSecuritySettings.ONESHOT_INTERACTION_MODE,

                                                                                   UserSecuritySettings.SESSION_INTERACTION_MODE,

                                                                                   UserSecuritySettings.BLANKET_INTERACTION_MODE,

                                                                                   UserSecuritySettings.NO_INTERACTION_MODE

                                                                                 })));

        grantedPermissions.addElement(new PolicyBasedPermissionImpl(

                                          "com.nokia.mj.impl.security.midp.authorization.HttpProtocolPermissionImpl",

                                          "http://",

                                          null,

                                          new UserSecuritySettingsImpl("NetAccess",

                                                                       UserSecuritySettings.BLANKET_INTERACTION_MODE,

                                                                       new int[] { UserSecuritySettings.NO_INTERACTION_MODE})));

        storage.removeGrantedPermissions(appUID);

        storage.writeGrantedPermissions(appUID, null, grantedPermissions);

        try

        {

            ac.checkPermission(new FileProtocolPermissionImpl("file://myfile1.txt","read", "\n(choose DENY)"));

            assertTrue(false);

        }

        catch (AccessControlException e)

        {

            assertTrue(true);

        }

        try

        {

            ac.checkPermission(new FileProtocolPermissionImpl("file://myfile2.txt","read", "\n(IF YOU SEE THIS PROMPT THE TEST FAILED)"));

            assertTrue(false);

        }

        catch (AccessControlException e)

        {

            assertTrue(true);

        }

        storage.removeGrantedPermissions(appUID);

        assertTrue(true);

        storage.removeGrantedPermissions(appUID);