Mercurial Mercurial > oss > FCL > sf > app > jrt / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
javacommons/security/tsrc/javasrc/com/nokia/mj/impl/security/midp/authorization/AccessControllerTests.java
branchRCL_3
changeset 83 26b2b12093af
parent 71 d5e927d5853b
equal deleted inserted replaced
77:7cee158cb8cd 83:26b2b12093af 
    45  * AccessController unit tests.
 
    45  * AccessController unit tests.
 
    46  */
 
    46  */
 
    47 public class AccessControllerTests extends TestCase implements InstallerMain
 
    47 public class AccessControllerTests extends TestCase implements InstallerMain
 
    48 {
 
    48 {
 
    49 
    49 
    50     int assertTrace = 0;
 
       
    51     // Begin j2meunit test framework setup
 
    50     // Begin j2meunit test framework setup
 
    52     public void installerMain(String[] args)
 
    51     public void installerMain(String[] args)
 
    53     {
 
    52     {
 
    54         TestSuite suite = new TestSuite(this.getClass().getName());
 
    53         TestSuite suite = new TestSuite(this.getClass().getName());
 
    55 
    54 
    88     {
 
    87     {
 
    89     }
 
    88     }
 
    90 
    89 
    91     protected void tearDown()
 
    90     protected void tearDown()
 
    92     {
 
    91     {
 
    93     }
 
       
    94 
       
    95     private void assertWithTrace(boolean aCondition)
 
       
    96     {
 
       
    97         assertTrue("" + assertTrace, aCondition);
 
       
    98         assertTrace++;
 
       
    99     }
 
    92     }
 
   100 
    93 
   101     protected void testAccessControllerFactory()
 
    94     protected void testAccessControllerFactory()
 
   102     {
 
    95     {
 
   103         Uid appUID1 = Uid.createUid("appUID1");
 
    96         Uid appUID1 = Uid.createUid("appUID1");
 
   105         AccessControllerImpl ac1;
 
    98         AccessControllerImpl ac1;
 
   106         AccessControllerImpl ac2;
 
    99         AccessControllerImpl ac2;
 
   107         String appName = "AccessControllerTests";
 
   100         String appName = "AccessControllerTests";
 
   108         // check null values
 
   101         // check null values
 
   109         ac1 = AccessControllerFactoryImpl.getAccessController(null, null);
 
   102         ac1 = AccessControllerFactoryImpl.getAccessController(null, null);
 
   110         assertWithTrace(ac1 == null);
 
   103         assertTrue(ac1 == null);
 
   111         AccessControllerFactoryImpl.destroyAccessController(null);
 
   104         AccessControllerFactoryImpl.destroyAccessController(null);
 
   112         ac1 = AccessControllerFactoryImpl.getAccessController(null, "appName");
 
   105         ac1 = AccessControllerFactoryImpl.getAccessController(null, "appName");
 
   113         assertWithTrace(ac1 == null);
 
   106         assertTrue(ac1 == null);
 
   114         AccessControllerFactoryImpl.destroyAccessController(null);
 
   107         AccessControllerFactoryImpl.destroyAccessController(null);
 
   115         // check duplicates
 
   108         // check duplicates
 
   116         AccessControllerFactoryImpl.destroyAccessController(appUID1);
 
   109         AccessControllerFactoryImpl.destroyAccessController(appUID1);
 
   117         ac1 = AccessControllerFactoryImpl.getAccessController(appUID1, appName);
 
   110         ac1 = AccessControllerFactoryImpl.getAccessController(appUID1, appName);
 
   118         ac2 = AccessControllerFactoryImpl.getAccessController(appUID1, appName);
 
   111         ac2 = AccessControllerFactoryImpl.getAccessController(appUID1, appName);
 
   119         AccessControllerFactoryImpl.destroyAccessController(appUID1);
 
   112         AccessControllerFactoryImpl.destroyAccessController(appUID1);
 
   120         assertWithTrace(ac1 == ac2);
 
   113         assertTrue(ac1 == ac2);
 
   121         // check destroy
 
   114         // check destroy
 
   122         ac1 = AccessControllerFactoryImpl.getAccessController(appUID1, appName);
 
   115         ac1 = AccessControllerFactoryImpl.getAccessController(appUID1, appName);
 
   123         AccessControllerFactoryImpl.destroyAccessController(appUID1);
 
   116         AccessControllerFactoryImpl.destroyAccessController(appUID1);
 
   124         ac2 = AccessControllerFactoryImpl.getAccessController(appUID1, appName);
 
   117         ac2 = AccessControllerFactoryImpl.getAccessController(appUID1, appName);
 
   125         // call destroy two times (or calling it on a UID which does not have an instance)
 
   118         // call destroy two times (or calling it on a UID which does not have an instance)
 
   126         AccessControllerFactoryImpl.destroyAccessController(appUID1);
 
   119         AccessControllerFactoryImpl.destroyAccessController(appUID1);
 
   127         AccessControllerFactoryImpl.destroyAccessController(appUID1);
 
   120         AccessControllerFactoryImpl.destroyAccessController(appUID1);
 
   128         assertWithTrace(ac1 != ac2);
 
   121         assertTrue(ac1 != ac2);
 
   129     }
 
   122     }
 
   130 
   123 
   131     protected void testAccessController()
 
   124     protected void testAccessController()
 
   132     {
 
   125     {
 
   133         Uid appUID = Uid.createUid("myAppUID");
 
   126         Uid appUID = Uid.createUid("myAppUID");
 
   140         // check null values
 
   133         // check null values
 
   141         PermissionResolver.testClearCache();
 
   134         PermissionResolver.testClearCache();
 
   142         try
 
   135         try
 
   143         {
 
   136         {
 
   144             ac.checkPermission((Permission)null);
 
   137             ac.checkPermission((Permission)null);
 
   145             assertWithTrace(false);
 
   138             assertTrue(false);
 
   146         }
 
   139         }
 
   147         catch (AccessControlException e)
 
   140         catch (AccessControlException e)
 
   148         {
 
   141         {
 
   149             assertWithTrace(true);
 
   142             assertTrue(true);
 
   150         }
 
   143         }
 
   151         assertWithTrace(ac.checkPermission((String)null) == 0);
 
   144         assertTrue(ac.checkPermission((String)null) == 0);
 
   152         // check permission which is not granted
 
   145         // check permission which is not granted
 
   153         PermissionResolver.testClearCache();
 
   146         PermissionResolver.testClearCache();
 
   154         try
 
   147         try
 
   155         {
 
   148         {
 
   156             ac.checkPermission(new CommProtocolPermission("comm://"));
 
   149             ac.checkPermission(new CommProtocolPermission("comm://"));
 
   157             assertWithTrace(false);
 
   150             assertTrue(false);
 
   158         }
 
   151         }
 
   159         catch (AccessControlException e)
 
   152         catch (AccessControlException e)
 
   160         {
 
   153         {
 
   161             assertWithTrace(true);
 
   154             assertTrue(true);
 
   162         }
 
   155         }
 
   163         try
 
   156         try
 
   164         {
 
   157         {
 
   165             ac.checkPermission(new CommProtocolPermission("comm://"));
 
   158             ac.checkPermission(new CommProtocolPermission("comm://"));
 
   166             assertWithTrace(false);
 
   159             assertTrue(false);
 
   167         }
 
   160         }
 
   168         catch (AccessControlException e)
 
   161         catch (AccessControlException e)
 
   169         {
 
   162         {
 
   170             assertWithTrace(true);
 
   163             assertTrue(true);
 
   171         }
 
   164         }
 
   172         // check allowed permission which is granted
 
   165         // check allowed permission which is granted
 
   173         PermissionResolver.testClearCache();
 
   166         PermissionResolver.testClearCache();
 
   174         grantedPermissions = new Vector();
 
   167         grantedPermissions = new Vector();
 
   175         grantedPermissions.addElement(new PolicyBasedPermissionImpl(
 
   168         grantedPermissions.addElement(new PolicyBasedPermissionImpl(
 
   181         storage.writeGrantedPermissions(appUID, null, grantedPermissions);
 
   174         storage.writeGrantedPermissions(appUID, null, grantedPermissions);
 
   182         ac.checkPermission(new CommProtocolPermission("comm://"));
 
   175         ac.checkPermission(new CommProtocolPermission("comm://"));
 
   183         try
 
   176         try
 
   184         {
 
   177         {
 
   185             ac.checkPermission(new FileProtocolPermission("file://myFile.txt", "read"));
 
   178             ac.checkPermission(new FileProtocolPermission("file://myFile.txt", "read"));
 
   186             assertWithTrace(false);
 
   179             assertTrue(false);
 
   187         }
 
   180         }
 
   188         catch (AccessControlException e)
 
   181         catch (AccessControlException e)
 
   189         {
 
   182         {
 
   190             assertWithTrace(true);
 
   183             assertTrue(true);
 
   191         }
 
   184         }
 
   192         storage.removeGrantedPermissions(appUID);
 
   185         storage.removeGrantedPermissions(appUID);
 
   193         // check permission not allowed
 
   186         // check permission not allowed
 
   194         PermissionResolver.testClearCache();
 
   187         PermissionResolver.testClearCache();
 
   195         grantedPermissions = new Vector();
 
   188         grantedPermissions = new Vector();
 
   207         storage.removeGrantedPermissions(appUID);
 
   200         storage.removeGrantedPermissions(appUID);
 
   208         storage.writeGrantedPermissions(appUID, null, grantedPermissions);
 
   201         storage.writeGrantedPermissions(appUID, null, grantedPermissions);
 
   209         try
 
   202         try
 
   210         {
 
   203         {
 
   211             ac.checkPermission(new SocketProtocolPermission("socket://:100"));
 
   204             ac.checkPermission(new SocketProtocolPermission("socket://:100"));
 
   212             assertWithTrace(false);
 
   205             assertTrue(false);
 
   213         }
 
   206         }
 
   214         catch (AccessControlException e)
 
   207         catch (AccessControlException e)
 
   215         {
 
   208         {
 
   216             assertWithTrace(true);
 
   209             assertTrue(true);
 
   217         }
 
   210         }
 
   218         storage.removeGrantedPermissions(appUID);
 
   211         storage.removeGrantedPermissions(appUID);
 
   219         // check user permission with NO as interaction mode -> security exception thrown
 
   212         // check user permission with NO as interaction mode -> security exception thrown
 
   220         PermissionResolver.testClearCache();
 
   213         PermissionResolver.testClearCache();
 
   221         grantedPermissions = new Vector();
 
   214         grantedPermissions = new Vector();
 
   233         storage.removeGrantedPermissions(appUID);
 
   226         storage.removeGrantedPermissions(appUID);
 
   234         storage.writeGrantedPermissions(appUID, null, grantedPermissions);
 
   227         storage.writeGrantedPermissions(appUID, null, grantedPermissions);
 
   235         try
 
   228         try
 
   236         {
 
   229         {
 
   237             ac.checkPermission(new HttpProtocolPermissionImpl("http://"));
 
   230             ac.checkPermission(new HttpProtocolPermissionImpl("http://"));
 
   238             assertWithTrace(false);
 
   231             assertTrue(false);
 
   239         }
 
   232         }
 
   240         catch (AccessControlException e)
 
   233         catch (AccessControlException e)
 
   241         {
 
   234         {
 
   242             assertWithTrace(true);
 
   235             assertTrue(true);
 
   243         }
 
   236         }
 
   244         try
 
   237         try
 
   245         {
 
   238         {
 
   246             ac.checkPermission(new HttpProtocolPermission("http://"));
 
   239             ac.checkPermission(new HttpProtocolPermission("http://"));
 
   247             assertWithTrace(false);
 
   240             assertTrue(false);
 
   248         }
 
   241         }
 
   249         catch (AccessControlException e)
 
   242         catch (AccessControlException e)
 
   250         {
 
   243         {
 
   251             assertWithTrace(true);
 
   244             assertTrue(true);
 
   252         }
 
   245         }
 
   253         storage.removeGrantedPermissions(appUID);
 
   246         storage.removeGrantedPermissions(appUID);
 
   254         // check the named permissions: unknown permission
 
   247         // check the named permissions: unknown permission
 
   255         assertWithTrace(ac.checkPermission("unknownPermission") == 0);
 
   248         assertTrue(ac.checkPermission("unknownPermission") == 0);
 
   256         // check the named permissions: allowed permission
 
   249         // check the named permissions: allowed permission
 
   257         PermissionResolver.testClearCache();
 
   250         PermissionResolver.testClearCache();
 
   258         grantedPermissions = new Vector();
 
   251         grantedPermissions = new Vector();
 
   259         grantedPermissions.addElement(new PolicyBasedPermissionImpl(
 
   252         grantedPermissions.addElement(new PolicyBasedPermissionImpl(
 
   260                                           "com.nokia.mj.impl.gcf.protocol.socket.SocketPermissionImpl",
 
   253                                           "com.nokia.mj.impl.gcf.protocol.socket.SocketPermissionImpl",
 
   261                                           "socket://*",
 
   254                                           "socket://",
 
   262                                           null,
 
   255                                           null,
 
   263                                           null));
 
   256                                           null));
 
   264         storage.removeGrantedPermissions(appUID);
 
   257         storage.removeGrantedPermissions(appUID);
 
   265         storage.writeGrantedPermissions(appUID, null, grantedPermissions);
 
   258         storage.writeGrantedPermissions(appUID, null, grantedPermissions);
 
   266         assertWithTrace(ac.checkPermission("javax.microedition.io.Connector.socket") == 1);
 
   259         assertTrue(ac.checkPermission("javax.microedition.io.Connector.socket") == 1);
 
   267         // check the named permissions: user permission with NO interaction mode
 
   260         // check the named permissions: user permission with NO interaction mode
 
   268         PermissionResolver.testClearCache();
 
   261         PermissionResolver.testClearCache();
 
   269         grantedPermissions = new Vector();
 
   262         grantedPermissions = new Vector();
 
   270         grantedPermissions.addElement(new PolicyBasedPermissionImpl(
 
   263         grantedPermissions.addElement(new PolicyBasedPermissionImpl(
 
   271                                           "com.nokia.mj.impl.gcf.protocol.http.HttpPermissionImpl",
 
   264                                           "com.nokia.mj.impl.gcf.protocol.http.HttpPermissionImpl",
 
   278                                                                                    UserSecuritySettings.BLANKET_INTERACTION_MODE,
 
   271                                                                                    UserSecuritySettings.BLANKET_INTERACTION_MODE,
 
   279                                                                                    UserSecuritySettings.NO_INTERACTION_MODE
 
   272                                                                                    UserSecuritySettings.NO_INTERACTION_MODE
 
   280                                                                                  })));
 
   273                                                                                  })));
 
   281         storage.removeGrantedPermissions(appUID);
 
   274         storage.removeGrantedPermissions(appUID);
 
   282         storage.writeGrantedPermissions(appUID, null, grantedPermissions);
 
   275         storage.writeGrantedPermissions(appUID, null, grantedPermissions);
 
   283         assertWithTrace(ac.checkPermission("javax.microedition.io.Connector.http") == 0);
 
   276         assertTrue(ac.checkPermission("javax.microedition.io.Connector.http") == 0);
 
   284         // check the named permissions: user permission with ONESHOT interaction mode
 
   277         // check the named permissions: user permission with ONESHOT interaction mode
 
   285         PermissionResolver.testClearCache();
 
   278         PermissionResolver.testClearCache();
 
   286         grantedPermissions = new Vector();
 
   279         grantedPermissions = new Vector();
 
   287         grantedPermissions.addElement(new PolicyBasedPermissionImpl(
 
   280         grantedPermissions.addElement(new PolicyBasedPermissionImpl(
 
   288                                           "com.nokia.mj.impl.gcf.protocol.http.HttpPermissionImpl",
 
   281                                           "com.nokia.mj.impl.gcf.protocol.http.HttpPermissionImpl",
 
   295                                                                                    UserSecuritySettings.BLANKET_INTERACTION_MODE,
 
   288                                                                                    UserSecuritySettings.BLANKET_INTERACTION_MODE,
 
   296                                                                                    UserSecuritySettings.NO_INTERACTION_MODE
 
   289                                                                                    UserSecuritySettings.NO_INTERACTION_MODE
 
   297                                                                                  })));
 
   290                                                                                  })));
 
   298         storage.removeGrantedPermissions(appUID);
 
   291         storage.removeGrantedPermissions(appUID);
 
   299         storage.writeGrantedPermissions(appUID, null, grantedPermissions);
 
   292         storage.writeGrantedPermissions(appUID, null, grantedPermissions);
 
   300         assertWithTrace(ac.checkPermission("javax.microedition.io.Connector.http") == -1);
 
   293         assertTrue(ac.checkPermission("javax.microedition.io.Connector.http") == -1);
 
   301         // check the named permissions: user permission with BLANKET interaction mode (blanket prompt not shown yet)
 
   294         // check the named permissions: user permission with BLANKET interaction mode (blanket prompt not shown yet)
 
   302         PermissionResolver.testClearCache();
 
   295         PermissionResolver.testClearCache();
 
   303         grantedPermissions = new Vector();
 
   296         grantedPermissions = new Vector();
 
   304         grantedPermissions.addElement(new PolicyBasedPermissionImpl(
 
   297         grantedPermissions.addElement(new PolicyBasedPermissionImpl(
 
   305                                           "com.nokia.mj.impl.gcf.protocol.http.HttpPermissionImpl",
 
   298                                           "com.nokia.mj.impl.gcf.protocol.http.HttpPermissionImpl",
 
   312                                                                                    UserSecuritySettings.BLANKET_INTERACTION_MODE,
 
   305                                                                                    UserSecuritySettings.BLANKET_INTERACTION_MODE,
 
   313                                                                                    UserSecuritySettings.NO_INTERACTION_MODE
 
   306                                                                                    UserSecuritySettings.NO_INTERACTION_MODE
 
   314                                                                                  })));
 
   307                                                                                  })));
 
   315         storage.removeGrantedPermissions(appUID);
 
   308         storage.removeGrantedPermissions(appUID);
 
   316         storage.writeGrantedPermissions(appUID, null, grantedPermissions);
 
   309         storage.writeGrantedPermissions(appUID, null, grantedPermissions);
 
   317         assertWithTrace(ac.checkPermission("javax.microedition.io.Connector.http") == -1);
 
   310         assertTrue(ac.checkPermission("javax.microedition.io.Connector.http") == -1);
 
   318         // check the named permissions: user permission with BLANKET interaction mode (blanket prompt shown already)
 
   311         // check the named permissions: user permission with BLANKET interaction mode (blanket prompt shown already)
 
   319         PermissionResolver.testClearCache();
 
   312         PermissionResolver.testClearCache();
 
   320         grantedPermissions = new Vector();
 
   313         grantedPermissions = new Vector();
 
   321         grantedPermissions.addElement(new PolicyBasedPermissionImpl(
 
   314         grantedPermissions.addElement(new PolicyBasedPermissionImpl(
 
   322                                           "com.nokia.mj.impl.gcf.protocol.http.HttpPermissionImpl",
 
   315                                           "com.nokia.mj.impl.gcf.protocol.http.HttpPermissionImpl",
 
   330                                                                                    UserSecuritySettings.NO_INTERACTION_MODE
 
   323                                                                                    UserSecuritySettings.NO_INTERACTION_MODE
 
   331                                                                                  })));
 
   324                                                                                  })));
 
   332         storage.removeGrantedPermissions(appUID);
 
   325         storage.removeGrantedPermissions(appUID);
 
   333         storage.writeGrantedPermissions(appUID, null, grantedPermissions);
 
   326         storage.writeGrantedPermissions(appUID, null, grantedPermissions);
 
   334         storage.writeUserSecuritySettingsPromptFlag(appUID, "Net Access", true);
 
   327         storage.writeUserSecuritySettingsPromptFlag(appUID, "Net Access", true);
 
   335         assertWithTrace(ac.checkPermission("javax.microedition.io.Connector.http") == 1);
 
   328         assertTrue(ac.checkPermission("javax.microedition.io.Connector.http") == 1);
 
   336         // check the named permissions: user permission with SESSION interaction mode (session prompt not shown already)
 
   329         // check the named permissions: user permission with SESSION interaction mode (session prompt not shown already)
 
   337         PermissionResolver.testClearCache();
 
   330         PermissionResolver.testClearCache();
 
   338         grantedPermissions = new Vector();
 
   331         grantedPermissions = new Vector();
 
   339         grantedPermissions.addElement(new PolicyBasedPermissionImpl(
 
   332         grantedPermissions.addElement(new PolicyBasedPermissionImpl(
 
   340                                           "com.nokia.mj.impl.gcf.protocol.http.HttpPermissionImpl",
 
   333                                           "com.nokia.mj.impl.gcf.protocol.http.HttpPermissionImpl",
 
   348                                                                                    UserSecuritySettings.NO_INTERACTION_MODE
 
   341                                                                                    UserSecuritySettings.NO_INTERACTION_MODE
 
   349                                                                                  })));
 
   342                                                                                  })));
 
   350         storage.removeGrantedPermissions(appUID);
 
   343         storage.removeGrantedPermissions(appUID);
 
   351         storage.writeGrantedPermissions(appUID, null, grantedPermissions);
 
   344         storage.writeGrantedPermissions(appUID, null, grantedPermissions);
 
   352         storage.writeUserSecuritySettingsPromptFlag(appUID, "Net Access", true);
 
   345         storage.writeUserSecuritySettingsPromptFlag(appUID, "Net Access", true);
 
   353         assertWithTrace(ac.checkPermission("javax.microedition.io.Connector.http") == -1);
 
   346         assertTrue(ac.checkPermission("javax.microedition.io.Connector.http") == -1);
 
   354         // check the named permissions: denied permission
 
   347         // check the named permissions: denied permission
 
   355         PermissionResolver.testClearCache();
 
   348         PermissionResolver.testClearCache();
 
   356         grantedPermissions = new Vector();
 
   349         grantedPermissions = new Vector();
 
   357         grantedPermissions.addElement(new PolicyBasedPermissionImpl(
 
   350         grantedPermissions.addElement(new PolicyBasedPermissionImpl(
 
   358                                           "com.nokia.mj.impl.gcf.protocol.datagram.DatagramPermissionImpl",
 
   351                                           "com.nokia.mj.impl.gcf.protocol.datagram.DatagramPermissionImpl",
 
   359                                           "datagram://",
 
   352                                           "datagram://",
 
   360                                           null,
 
   353                                           null,
 
   361                                           null));
 
   354                                           null));
 
   362         storage.removeGrantedPermissions(appUID);
 
   355         storage.removeGrantedPermissions(appUID);
 
   363         storage.writeGrantedPermissions(appUID, null, grantedPermissions);
 
   356         storage.writeGrantedPermissions(appUID, null, grantedPermissions);
 
   364         assertWithTrace(ac.checkPermission("javax.wireless.messaging.mms.send") == 0);
 
   357         assertTrue(ac.checkPermission("javax.wireless.messaging.mms.send") == 0);
 
   365         // cleanup
 
   358         // cleanup
 
   366         storage.removeGrantedPermissions(appUID);
 
   359         storage.removeGrantedPermissions(appUID);
 
   367         AccessControllerFactoryImpl.destroyAccessController(appUID);
 
   360         AccessControllerFactoryImpl.destroyAccessController(appUID);
 
   368     }
 
   361     }
 
   369 }
 
   362 }
FCL/sf/app/jrt