/*

* 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.storage;

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

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

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.UserSecuritySettingsImpl;

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

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

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

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

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

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

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

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

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

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

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

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

import java.util.Vector;

import j2meunit.framework.Test;

import j2meunit.framework.TestCase;

import j2meunit.framework.TestMethod;

import j2meunit.framework.TestSuite;

/**

 * SecurityDescriptorAttributes unit tests.

 */

public class SecurityStorageTests extends TestCase implements InstallerMain

{

    // data being tested

    private SecurityStorage storage = null;

    // Begin j2meunit test framework setup

    public void installerMain(String[] args)

    {

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

        suite.addTest(new SecurityStorageTests("testOpenAndClose", new TestMethod()

        {

            public void run(TestCase tc)

            {

                ((SecurityStorageTests)tc).testOpenAndClose();

            }

        }));

        suite.addTest(new SecurityStorageTests("testGrantedPermissions", new TestMethod()

        {

            public void run(TestCase tc)

            {

                ((SecurityStorageTests)tc).testGrantedPermissions();

            }

        }));

        suite.addTest(new SecurityStorageTests("testAuthenticationData", new TestMethod()

        {

            public void run(TestCase tc)

            {

                ((SecurityStorageTests)tc).testAuthenticationData();

            }

        }));

        suite.addTest(new SecurityStorageTests("testUserSettingsData", new TestMethod()

        {

            public void run(TestCase tc)

            {

                ((SecurityStorageTests)tc).testUserSettingsData();

            }

        }));

        suite.addTest(new SecurityStorageTests("testAppAccessAuthorizationRestrictionsData", new TestMethod()

        {

            public void run(TestCase tc)

            {

                ((SecurityStorageTests)tc).testAppAccessAuthorizationRestrictionsData();

            }

        }));

        suite.addTest(new SecurityStorageTests("testMisc", new TestMethod()

        {

            public void run(TestCase tc)

            {

                ((SecurityStorageTests)tc).testMisc();

            }

        }));

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

    }

    public SecurityStorageTests()

    {

    }

    public SecurityStorageTests(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()

    {

        storage = new SecurityStorage();

    }

    protected void tearDown()

    {

        storage.close();

    }

    protected void testOpenAndClose()

    {

        // another session

        StorageSession session = StorageFactory.createSession();

        storage = new SecurityStorage(session);

        assertTrue(storage != null);

        storage = new SecurityStorage();

        assertTrue(storage != null);

    }

    protected void testGrantedPermissions()

    {

        Vector readPermissions = null;

        Vector grantedPermissions = null;

        Vector grantedPermissions2 = null;

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

        Uid appUID2 = Uid.createUid("myUID2");

        // null values

        storage.readGrantedPermissions(null);

        storage.writeGrantedPermissions(null, null, null);

        storage.removeGrantedPermissions(null);

        assertTrue(true);

        // full read/write/remove cycle with default values for current interaction mode

        storage.removeGrantedPermissions(appUID);

        grantedPermissions = storage.readGrantedPermissions(appUID);

        assertTrue(grantedPermissions == null);

        grantedPermissions = new Vector();

        storage.writeGrantedPermissions(appUID, null, grantedPermissions);

        storage.removeGrantedPermissions(appUID);

        assertTrue(true);

        grantedPermissions.addElement(new PolicyBasedPermissionImpl(

                                          "permission1",

                                          "target1",

                                          "action1",

                                          PolicyBasedPermission.ALLOWED_TYPE));

        grantedPermissions.addElement(new PolicyBasedPermissionImpl(

                                          "permission2",

                                          "target2",

                                          "action2",

                                          PolicyBasedPermission.ASSIGNED_TYPE));

        grantedPermissions.addElement(new PolicyBasedPermissionImpl(

                                          "permission3",

                                          "target3",

                                          "action3",

                                          new UserSecuritySettingsImpl("settingsname",

                                                                       UserSecuritySettings.ONESHOT_INTERACTION_MODE,

                                                                       new int[] { UserSecuritySettings.ONESHOT_INTERACTION_MODE,

                                                                                   UserSecuritySettings.SESSION_INTERACTION_MODE,

                                                                                   UserSecuritySettings.BLANKET_INTERACTION_MODE,

                                                                                   UserSecuritySettings.NO_INTERACTION_MODE

                                                                                 })));

        storage.writeGrantedPermissions(appUID, null, grantedPermissions);

        readPermissions = storage.readGrantedPermissions(appUID);

        assertTrue(readPermissions != null

                   && readPermissions.size() == grantedPermissions.size()

                   && checkGrantedPermissions(readPermissions, grantedPermissions));

        storage.removeGrantedPermissions(appUID);

        readPermissions = storage.readGrantedPermissions(appUID);

        assertTrue(readPermissions == null);

        // full read/write/remove cycle with different valid values for permissions and user settings

        storage.removeGrantedPermissions(appUID);

        grantedPermissions = storage.readGrantedPermissions(appUID);

        assertTrue(grantedPermissions == null);

        grantedPermissions = new Vector();

        storage.writeGrantedPermissions(appUID, null, grantedPermissions);

        storage.removeGrantedPermissions(appUID);

        assertTrue(true);

        grantedPermissions.addElement(new PolicyBasedPermissionImpl(

                                          "permission1",

                                          "target1",

                                          "",

                                          PolicyBasedPermission.ALLOWED_TYPE));

        grantedPermissions.addElement(new PolicyBasedPermissionImpl(

                                          "permission2",

                                          "",

                                          null,

                                          PolicyBasedPermission.ASSIGNED_TYPE));

        grantedPermissions.addElement(new PolicyBasedPermissionImpl(

                                          "permission3",

                                          "target3",

                                          null,

                                          new UserSecuritySettingsImpl("settingsname",

                                                                       UserSecuritySettings.ONESHOT_INTERACTION_MODE,

                                                                       null)));

        storage.writeGrantedPermissions(appUID, null, grantedPermissions);

        readPermissions = storage.readGrantedPermissions(appUID);

        assertTrue(readPermissions != null

                   && readPermissions.size() == grantedPermissions.size()

                   && checkGrantedPermissions(readPermissions, grantedPermissions));

        storage.removeGrantedPermissions(appUID);

        readPermissions = storage.readGrantedPermissions(appUID);

        assertTrue(readPermissions == null);

        // full read/write/remove cycle with same permission settings

        storage.removeGrantedPermissions(appUID);

        grantedPermissions = storage.readGrantedPermissions(appUID);

        assertTrue(grantedPermissions == null);

        grantedPermissions = new Vector();

        storage.writeGrantedPermissions(appUID, null, grantedPermissions);

        storage.removeGrantedPermissions(appUID);

        assertTrue(true);

        grantedPermissions.addElement(new PolicyBasedPermissionImpl(

                                          "permission1",

                                          "target1",

                                          "",

                                          new UserSecuritySettingsImpl("settingsname",

                                                                       UserSecuritySettings.ONESHOT_INTERACTION_MODE,

                                                                       null)));

        grantedPermissions.addElement(new PolicyBasedPermissionImpl(

                                          "permission3",

                                          "target3",

                                          null,

                                          new UserSecuritySettingsImpl("settingsname",

                                                                       UserSecuritySettings.ONESHOT_INTERACTION_MODE,

                                                                       null)));

        storage.writeGrantedPermissions(appUID, null, grantedPermissions);

        readPermissions = storage.readGrantedPermissions(appUID);

        assertTrue(readPermissions != null

                   && readPermissions.size() == grantedPermissions.size()

                   && checkGrantedPermissions(readPermissions, grantedPermissions));

        storage.removeGrantedPermissions(appUID);

        readPermissions = storage.readGrantedPermissions(appUID);

        assertTrue(readPermissions == null);

        // full read/write/remove cycle with both valid & invalid values for user settings

        storage.removeGrantedPermissions(appUID);

        grantedPermissions = storage.readGrantedPermissions(appUID);

        assertTrue(grantedPermissions == null);

        grantedPermissions = new Vector();

        storage.writeGrantedPermissions(appUID, null, grantedPermissions);

        storage.removeGrantedPermissions(appUID);

        assertTrue(true);

        grantedPermissions.addElement(new PolicyBasedPermissionImpl(

                                          "permission1",

                                          "target1",

                                          "actionList1",

                                          new UserSecuritySettingsImpl(UserSecuritySettings.PHONE_CALL_SETTINGS,

                                                                       100,

                                                                       new int[] {UserSecuritySettings.ONESHOT_INTERACTION_MODE, 2000,

                                                                                  UserSecuritySettings.SESSION_INTERACTION_MODE

                                                                                 })));

        grantedPermissions.addElement(new PolicyBasedPermissionImpl(

                                          "permission2",

                                          "target2",

                                          "actionList2",

                                          new UserSecuritySettingsImpl(UserSecuritySettings.PHONE_CALL_SETTINGS,

                                                                       UserSecuritySettings.SESSION_INTERACTION_MODE,

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

        grantedPermissions.addElement(new PolicyBasedPermissionImpl(

                                          "permission3",

                                          "target3",

                                          "",

                                          new UserSecuritySettingsImpl(UserSecuritySettings.NET_ACCESS_SETTINGS,

                                                                       UserSecuritySettings.ONESHOT_INTERACTION_MODE,

                                                                       new int[] {2000})));

        storage.writeGrantedPermissions(appUID, null, grantedPermissions);

        readPermissions = storage.readGrantedPermissions(appUID);

        // grantedPermissions with all the unknown values filtered out, NO as available interaction mode and NO as current interaction mode where the interaction mode was unknown

        Vector expectedPermissions = new Vector();

        expectedPermissions.addElement(new PolicyBasedPermissionImpl(

                                           "permission1",

                                           "target1",

                                           "actionList1",

                                           new UserSecuritySettingsImpl(UserSecuritySettings.PHONE_CALL_SETTINGS,

                                                                        UserSecuritySettings.NO_INTERACTION_MODE,

                                                                        new int[] {UserSecuritySettings.ONESHOT_INTERACTION_MODE,

                                                                                   UserSecuritySettings.SESSION_INTERACTION_MODE, UserSecuritySettings.NO_INTERACTION_MODE

                                                                                  })));

        expectedPermissions.addElement(new PolicyBasedPermissionImpl(

                                           "permission2",

                                           "target2",

                                           "actionList2",

                                           new UserSecuritySettingsImpl(UserSecuritySettings.PHONE_CALL_SETTINGS,

                                                                        UserSecuritySettings.NO_INTERACTION_MODE,

                                                                        new int[] {UserSecuritySettings.ONESHOT_INTERACTION_MODE,

                                                                                   UserSecuritySettings.SESSION_INTERACTION_MODE, UserSecuritySettings.NO_INTERACTION_MODE

                                                                                  })));

        expectedPermissions.addElement(new PolicyBasedPermissionImpl(

                                           "permission3",

                                           "target3",

                                           "",

                                           new UserSecuritySettingsImpl(UserSecuritySettings.NET_ACCESS_SETTINGS,

                                                                        UserSecuritySettings.ONESHOT_INTERACTION_MODE,

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

        assertTrue(readPermissions != null

                   && readPermissions.size() == expectedPermissions.size()

                   && checkGrantedPermissions(readPermissions, expectedPermissions));

        storage.removeGrantedPermissions(appUID);

        readPermissions = storage.readGrantedPermissions(appUID);

        assertTrue(readPermissions == null);

    }

    protected void testAuthenticationData()

    {

        AuthenticationStorageData readData = null;

        AuthenticationStorageData writtenData = null;

        AuthenticationStorageData expectedData = null;

        String protectionDomain = null;

        String protectionDomainCategory = null;

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

        // null values

        readData = storage.readAuthenticationStorageData(null);

        storage.writeAuthenticationStorageData(null, null);

        storage.removeAuthenticationStorageData(null);

        protectionDomain = storage.readProtectionDomain(null);

        assertTrue(readData == null && protectionDomain == null);

        readData = storage.readAuthenticationStorageData(null, null, null, 0);

        assertTrue(readData == null);

        readData = storage.readAuthenticationStorageData("name", null, null, 0);

        assertTrue(readData == null);

        readData = storage.readAuthenticationStorageData("name", "version", null, 0);

        assertTrue(readData == null);

        // full read/write/remove cycle

        storage.removeAuthenticationStorageData(appUID);

        readData = storage.readAuthenticationStorageData(appUID);

        protectionDomain = storage.readProtectionDomain(appUID);

        assertTrue(readData == null && protectionDomain == null);

        readData = storage.readAuthenticationStorageData("name", "version", "vendor", 0);

        assertTrue(readData == null);

        readData = storage.readAuthenticationStorageData("name", "version", "vendor", SecurityStorage.AUTHENTICATION_DOMAIN_NAME_QUERY);

        assertTrue(readData == null);

        readData = storage.readAuthenticationStorageData("name", "version", "vendor", SecurityStorage.AUTHENTICATION_DOMAIN_CATEGORY_QUERY);

        assertTrue(readData == null);

        readData = storage.readAuthenticationStorageData("name", "version", "vendor", SecurityStorage.AUTHENTICATION_ROOT_HASH_QUERY);

        assertTrue(readData == null);

        readData = storage.readAuthenticationStorageData("name", "version", "vendor", SecurityStorage.AUTHENTICATION_JAR_HASH_QUERY);

        assertTrue(readData == null);

        readData = storage.readAuthenticationStorageData("name", "version", "vendor", SecurityStorage.AUTHENTICATION_VALID_CERTS_QUERY);

        assertTrue(readData == null);

        readData = storage.readAuthenticationStorageData("name", "version", "vendor",

                   SecurityStorage.AUTHENTICATION_DOMAIN_NAME_QUERY | SecurityStorage.AUTHENTICATION_DOMAIN_CATEGORY_QUERY

                   | SecurityStorage.AUTHENTICATION_ROOT_HASH_QUERY | SecurityStorage.AUTHENTICATION_JAR_HASH_QUERY

                   | SecurityStorage.AUTHENTICATION_VALID_CERTS_QUERY);

        assertTrue(readData == null);

        // no values at all -> protection domain is mandatory

        writtenData = new AuthenticationStorageData(null, null, null, null, null, null);

        storage.writeAuthenticationStorageData(appUID, writtenData);

        readData = storage.readAuthenticationStorageData(appUID);

        protectionDomain = storage.readProtectionDomain(appUID);

        assertTrue(readData == null && protectionDomain == null);

        storage.removeAuthenticationStorageData(appUID);

        assertTrue(true);

        // all possible combinations of authentication data

        writtenData = new AuthenticationStorageData("protDomain", "protDomainCategory", null, null, null, null);

        storage.writeAuthenticationStorageData(appUID, writtenData);

        readData = storage.readAuthenticationStorageData(appUID);

        storage.removeAuthenticationStorageData(appUID);

        assertTrue(checkAuthenticationStorageData(writtenData,readData));

        Vector validatedChainIndexes = new Vector();

        writtenData = new AuthenticationStorageData("protDomain", "protDomainCategory", "", "", validatedChainIndexes);

        expectedData = new AuthenticationStorageData("protDomain", "protDomainCategory", "jarHash", "certHash", null, null);

        storage.writeAuthenticationStorageData(appUID, writtenData);

        readData = storage.readAuthenticationStorageData(appUID);

        protectionDomain = storage.readProtectionDomain(appUID);

        protectionDomainCategory = storage.readProtectionDomainCategory(appUID);

        storage.removeAuthenticationStorageData(appUID);

        assertTrue(checkAuthenticationStorageData(expectedData,readData) && protectionDomain.equals("protDomain") && protectionDomainCategory.equals("protDomainCategory"));

        validatedChainIndexes = new Vector();

        validatedChainIndexes.addElement(new Integer(1));

        validatedChainIndexes.addElement(new Integer(2));

        validatedChainIndexes.addElement(new Integer(3));

        validatedChainIndexes.addElement(new Integer(4));

        validatedChainIndexes.addElement(new Integer(5));

        writtenData = new AuthenticationStorageData("protDomain", "protDomainCategory","jarHash", "certHash", validatedChainIndexes);

        storage.writeAuthenticationStorageData(appUID, writtenData);

        readData = storage.readAuthenticationStorageData(appUID);

        storage.removeAuthenticationStorageData(appUID);

        assertTrue(checkAuthenticationStorageData(writtenData,readData));

        // duplicates inside validated chain indexes are ignored

        validatedChainIndexes = new Vector();

        validatedChainIndexes.addElement(new Integer(1));

        validatedChainIndexes.addElement(new Integer(1));

        writtenData = new AuthenticationStorageData("protDomain", "category", "jarHash", "certHash", validatedChainIndexes);

        validatedChainIndexes = new Vector();

        validatedChainIndexes.addElement(new Integer(1));

        expectedData = new AuthenticationStorageData("protDomain", "category", "jarHash", "certHash", validatedChainIndexes);

        storage.writeAuthenticationStorageData(appUID, writtenData);

        readData = storage.readAuthenticationStorageData(appUID);

        storage.removeAuthenticationStorageData(appUID);

        assertTrue(checkAuthenticationStorageData(expectedData,readData));

        // update authentication data

        validatedChainIndexes = new Vector();

        storage.removeAuthenticationStorageData(appUID);

        validatedChainIndexes.addElement(new Integer(1));

        writtenData = new AuthenticationStorageData("protDomain", "protDomainCategory","jarHash", "certHash", validatedChainIndexes);

        storage.writeAuthenticationStorageData(appUID, writtenData);

        AuthenticationStorageData updatedData = new AuthenticationStorageData("protDomainUpdate", "protDomainCategoryUpdate","jarHashUpdate", "certHashUpdate", validatedChainIndexes);

        storage.writeAuthenticationStorageData(appUID, updatedData, true);

        readData = storage.readAuthenticationStorageData(appUID);

        storage.removeAuthenticationStorageData(appUID);

        assertTrue(checkAuthenticationStorageData(updatedData,readData));

        // populate the application package table with name, vendor and version

        StorageSession session = StorageFactory.createSession();

        session.open();

        StorageEntry entry = null;

        session.remove(StorageNames.APPLICATION_PACKAGE_TABLE, appUID);

        entry = new StorageEntry();

        entry.addAttribute(new StorageAttribute(

                               StorageNames.ID,

                               appUID.getStringValue()));

        entry.addAttribute(new StorageAttribute(

                               StorageNames.PACKAGE_NAME,

                               "appName"));

        entry.addAttribute(new StorageAttribute(

                               StorageNames.VENDOR,

                               "appVendor"));

        entry.addAttribute(new StorageAttribute(

                               StorageNames.VERSION,

                               "appVersion"));

        session.write(StorageNames.APPLICATION_PACKAGE_TABLE, entry);

        // auth data is not yet available

        readData = storage.readAuthenticationStorageData("appName", "appVersion", "appVendor",

                   SecurityStorage.AUTHENTICATION_DOMAIN_NAME_QUERY | SecurityStorage.AUTHENTICATION_DOMAIN_CATEGORY_QUERY

                   | SecurityStorage.AUTHENTICATION_ROOT_HASH_QUERY | SecurityStorage.AUTHENTICATION_JAR_HASH_QUERY

                   | SecurityStorage.AUTHENTICATION_VALID_CERTS_QUERY);

        assertTrue(readData == null);

        // populate storage with authentication data

        validatedChainIndexes = new Vector();

        validatedChainIndexes.addElement(new Integer(1));

        validatedChainIndexes.addElement(new Integer(2));

        validatedChainIndexes.addElement(new Integer(3));

        validatedChainIndexes.addElement(new Integer(4));

        validatedChainIndexes.addElement(new Integer(5));

        writtenData = new AuthenticationStorageData("protDomainName", "protDomainCategory","jarHash", "certHash", validatedChainIndexes);

        storage.writeAuthenticationStorageData(appUID, writtenData);

        readData = storage.readAuthenticationStorageData("appName", "appVersion", "appVendor", 0);

        assertTrue(readData == null);

        readData = storage.readAuthenticationStorageData("appName", "appVersion", "appVendor", SecurityStorage.AUTHENTICATION_DOMAIN_NAME_QUERY);

        assertTrue(readData != null

                   && readData.getProtectionDomain() != null && readData.getProtectionDomain().equals("protDomainName")

                   && readData.getProtectionDomainCategory() == null

                   && readData.getJarHashValue() == null

                   && readData.getRootHashValue() == null

                   && readData.getValidatedChainIndexes() == null);

        readData = storage.readAuthenticationStorageData("appName", "appVersion", "appVendor", SecurityStorage.AUTHENTICATION_DOMAIN_CATEGORY_QUERY);

        assertTrue(readData != null

                   && readData.getProtectionDomain() == null

                   && readData.getProtectionDomainCategory() != null && readData.getProtectionDomainCategory().equals("protDomainCategory")

                   && readData.getJarHashValue() == null

                   && readData.getRootHashValue() == null

                   && readData.getValidatedChainIndexes() == null);

        readData = storage.readAuthenticationStorageData("appName", "appVersion", "appVendor", SecurityStorage.AUTHENTICATION_JAR_HASH_QUERY);

        assertTrue(readData != null

                   && readData.getProtectionDomain() == null

                   && readData.getProtectionDomainCategory() == null

                   && readData.getJarHashValue() != null && readData.getJarHashValue().equals("jarHash")

                   && readData.getRootHashValue() == null

                   && readData.getValidatedChainIndexes() == null);

        readData = storage.readAuthenticationStorageData("appName", "appVersion", "appVendor", SecurityStorage.AUTHENTICATION_ROOT_HASH_QUERY);

        assertTrue(readData != null

                   && readData.getProtectionDomain() == null

                   && readData.getProtectionDomainCategory() == null

                   && readData.getJarHashValue() == null

                   && readData.getRootHashValue() != null && readData.getRootHashValue().equals("certHash")

                   && readData.getValidatedChainIndexes() == null);

        readData = storage.readAuthenticationStorageData("appName", "appVersion", "appVendor", SecurityStorage.AUTHENTICATION_VALID_CERTS_QUERY);

        assertTrue(readData != null

                   && readData.getProtectionDomain() == null

                   && readData.getProtectionDomainCategory() == null

                   && readData.getJarHashValue() == null

                   && readData.getRootHashValue() == null

                   && readData.getValidatedChainIndexes() != null && readData.getValidatedChainIndexes().length == 5);

        readData = storage.readAuthenticationStorageData("appName", "appVersion", "appVendor",

                   SecurityStorage.AUTHENTICATION_DOMAIN_NAME_QUERY | SecurityStorage.AUTHENTICATION_DOMAIN_CATEGORY_QUERY

                   | SecurityStorage.AUTHENTICATION_ROOT_HASH_QUERY | SecurityStorage.AUTHENTICATION_JAR_HASH_QUERY

                   | SecurityStorage.AUTHENTICATION_VALID_CERTS_QUERY);

        assertTrue(readData != null

                   && readData.getProtectionDomain() != null && readData.getProtectionDomain().equals("protDomainName")

                   && readData.getProtectionDomainCategory() != null && readData.getProtectionDomainCategory().equals("protDomainCategory")

                   && readData.getJarHashValue() != null && readData.getJarHashValue().equals("jarHash")

                   && readData.getRootHashValue() != null && readData.getRootHashValue().equals("certHash")

                   && readData.getValidatedChainIndexes() != null && readData.getValidatedChainIndexes().length == 5);

        session.remove(StorageNames.APPLICATION_PACKAGE_TABLE, appUID);

    }

    protected void testUserSettingsData()

    {

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

        Uid appUID2 = Uid.createUid("myUID2");

        UserSecuritySettings readSettings = null;

        UserSecuritySettings[] multipleSettings = null;

        boolean blanketPromptShown = false;

        // update settings which are not present into the storage

        storage.writeUserSecuritySettings(appUID, "settingsname",UserSecuritySettings.SESSION_INTERACTION_MODE);

        readSettings = storage.readUserSecuritySettings(appUID, "settingsname");

        multipleSettings = storage.readUserSecuritySettings(appUID);

        blanketPromptShown = storage.readUserSecuritySettingsPromptFlag(appUID, "settingsname");

        assertTrue(readSettings == null && !blanketPromptShown && multipleSettings == null);

        // populate storage with some data

        Vector perms = new Vector();

        perms.addElement(new PolicyBasedPermissionImpl(

                             "permission",

                             "target",

                             "actionList",

                             new UserSecuritySettingsImpl("settingsname",

                                                          UserSecuritySettings.ONESHOT_INTERACTION_MODE,

                                                          new int[] {UserSecuritySettings.ONESHOT_INTERACTION_MODE,

                                                                     UserSecuritySettings.SESSION_INTERACTION_MODE,

                                                                     UserSecuritySettings.BLANKET_INTERACTION_MODE