| /* |
| * 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 |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| /** |
| * @author Alexey V. Varlamov |
| */ |
| |
| package org.apache.harmony.security.tests; |
| |
| import java.net.URL; |
| import java.security.cert.Certificate; |
| import java.security.AllPermission; |
| import java.security.CodeSource; |
| import java.security.Permission; |
| import java.security.Principal; |
| import java.security.SecurityPermission; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.Collection; |
| import java.util.HashSet; |
| |
| import org.apache.harmony.security.PolicyEntry; |
| import org.apache.harmony.security.UnresolvedPrincipal; |
| import junit.framework.TestCase; |
| |
| |
| /** |
| * TODO Put your class description here |
| * |
| */ |
| |
| public class PolicyEntryTest extends TestCase { |
| |
| /** |
| * Tests constructor and accessors of PolicyEntry |
| */ |
| public void testCtor() { |
| PolicyEntry pe = new PolicyEntry(null, null, null); |
| assertTrue(pe.isVoid()); |
| assertNull(pe.getPermissions()); |
| |
| pe = new PolicyEntry(new CodeSource(null, (Certificate[])null), |
| new ArrayList(), new ArrayList()); |
| assertTrue(pe.isVoid()); |
| assertNull(pe.getPermissions()); |
| |
| Collection perms = Arrays.asList(new Permission[] { |
| new SecurityPermission("dsfg"), new AllPermission() }); |
| pe = new PolicyEntry(null, null, perms); |
| assertFalse(pe.isVoid()); |
| assertEquals(perms, new ArrayList(pe.getPermissions())); |
| } |
| |
| /** |
| * Null CodeSource of PolicyEntry implies any CodeSource; non-null |
| * CodeSource should delegate to its own imply() functionality |
| */ |
| public void testImpliesCodeSource() throws Exception { |
| CodeSource cs0 = new CodeSource(null, (Certificate[]) null); |
| |
| CodeSource cs10 = new CodeSource(new URL("file:"), (Certificate[]) null); |
| CodeSource cs11 = new CodeSource(new URL("file:/"), (Certificate[]) null); |
| CodeSource cs12 = new CodeSource(new URL("file://"), (Certificate[]) null); |
| CodeSource cs13 = new CodeSource(new URL("file:///"), (Certificate[]) null); |
| |
| CodeSource cs20 = new CodeSource(new URL("file:*"), (Certificate[]) null); |
| CodeSource cs21 = new CodeSource(new URL("file:/*"), (Certificate[]) null); |
| CodeSource cs22 = new CodeSource(new URL("file://*"), (Certificate[]) null); |
| CodeSource cs23 = new CodeSource(new URL("file:///*"), (Certificate[]) null); |
| |
| CodeSource cs30 = new CodeSource(new URL("file:-"), (Certificate[]) null); |
| CodeSource cs31 = new CodeSource(new URL("file:/-"), (Certificate[]) null); |
| CodeSource cs32 = new CodeSource(new URL("file://-"), (Certificate[]) null); |
| CodeSource cs33 = new CodeSource(new URL("file:///-"), (Certificate[]) null); |
| |
| PolicyEntry pe0 = new PolicyEntry(null, null, null); |
| |
| PolicyEntry pe10 = new PolicyEntry(cs10, null, null); |
| PolicyEntry pe11 = new PolicyEntry(cs11, null, null); |
| PolicyEntry pe12 = new PolicyEntry(cs12, null, null); |
| PolicyEntry pe13 = new PolicyEntry(cs13, null, null); |
| |
| PolicyEntry pe20 = new PolicyEntry(cs20, null, null); |
| PolicyEntry pe21 = new PolicyEntry(cs21, null, null); |
| PolicyEntry pe22 = new PolicyEntry(cs22, null, null); |
| PolicyEntry pe23 = new PolicyEntry(cs23, null, null); |
| |
| PolicyEntry pe30 = new PolicyEntry(cs30, null, null); |
| PolicyEntry pe31 = new PolicyEntry(cs31, null, null); |
| PolicyEntry pe32 = new PolicyEntry(cs32, null, null); |
| PolicyEntry pe33 = new PolicyEntry(cs33, null, null); |
| |
| assertTrue (pe0.impliesCodeSource(null)); |
| assertTrue (pe0.impliesCodeSource(cs10)); |
| assertTrue (pe0.impliesCodeSource(cs11)); |
| assertTrue (pe0.impliesCodeSource(cs12)); |
| assertTrue (pe0.impliesCodeSource(cs13)); |
| assertTrue (pe0.impliesCodeSource(cs20)); |
| assertTrue (pe0.impliesCodeSource(cs21)); |
| assertTrue (pe0.impliesCodeSource(cs22)); |
| assertTrue (pe0.impliesCodeSource(cs23)); |
| assertTrue (pe0.impliesCodeSource(cs30)); |
| assertTrue (pe0.impliesCodeSource(cs31)); |
| assertTrue (pe0.impliesCodeSource(cs32)); |
| assertTrue (pe0.impliesCodeSource(cs33)); |
| |
| assertFalse(pe10.impliesCodeSource(null)); |
| assertTrue (pe10.impliesCodeSource(cs10)); |
| assertFalse(pe10.impliesCodeSource(cs11)); |
| assertTrue (pe10.impliesCodeSource(cs12)); |
| assertFalse(pe10.impliesCodeSource(cs13)); |
| assertTrue (pe10.impliesCodeSource(cs20)); |
| assertFalse(pe10.impliesCodeSource(cs21)); |
| assertFalse(pe10.impliesCodeSource(cs22)); |
| assertFalse(pe10.impliesCodeSource(cs23)); |
| assertTrue (pe10.impliesCodeSource(cs30)); |
| assertFalse(pe10.impliesCodeSource(cs31)); |
| assertFalse(pe10.impliesCodeSource(cs32)); |
| assertFalse(pe10.impliesCodeSource(cs33)); |
| |
| assertFalse(pe11.impliesCodeSource(null)); |
| assertFalse(pe11.impliesCodeSource(cs10)); |
| assertTrue (pe11.impliesCodeSource(cs11)); |
| assertFalse(pe11.impliesCodeSource(cs12)); |
| assertTrue (pe11.impliesCodeSource(cs13)); |
| assertFalse(pe11.impliesCodeSource(cs20)); |
| assertFalse(pe11.impliesCodeSource(cs21)); |
| assertFalse(pe11.impliesCodeSource(cs22)); |
| assertFalse(pe11.impliesCodeSource(cs23)); |
| assertFalse(pe11.impliesCodeSource(cs30)); |
| assertFalse(pe11.impliesCodeSource(cs31)); |
| assertFalse(pe11.impliesCodeSource(cs32)); |
| assertFalse(pe11.impliesCodeSource(cs33)); |
| |
| assertFalse(pe12.impliesCodeSource(null)); |
| assertTrue (pe12.impliesCodeSource(cs10)); |
| assertFalse(pe12.impliesCodeSource(cs11)); |
| assertTrue (pe12.impliesCodeSource(cs12)); |
| assertFalse(pe12.impliesCodeSource(cs13)); |
| assertTrue (pe12.impliesCodeSource(cs20)); |
| assertFalse(pe12.impliesCodeSource(cs21)); |
| assertFalse(pe12.impliesCodeSource(cs22)); |
| assertFalse(pe12.impliesCodeSource(cs23)); |
| assertTrue (pe12.impliesCodeSource(cs30)); |
| assertFalse(pe12.impliesCodeSource(cs31)); |
| assertFalse(pe12.impliesCodeSource(cs32)); |
| assertFalse(pe12.impliesCodeSource(cs33)); |
| |
| assertFalse(pe13.impliesCodeSource(null)); |
| assertFalse(pe13.impliesCodeSource(cs10)); |
| assertTrue (pe13.impliesCodeSource(cs11)); |
| assertFalse(pe13.impliesCodeSource(cs12)); |
| assertTrue (pe13.impliesCodeSource(cs13)); |
| assertFalse(pe13.impliesCodeSource(cs20)); |
| assertFalse(pe13.impliesCodeSource(cs21)); |
| assertFalse(pe13.impliesCodeSource(cs22)); |
| assertFalse(pe13.impliesCodeSource(cs23)); |
| assertFalse(pe13.impliesCodeSource(cs30)); |
| assertFalse(pe13.impliesCodeSource(cs31)); |
| assertFalse(pe13.impliesCodeSource(cs32)); |
| assertFalse(pe13.impliesCodeSource(cs33)); |
| |
| assertFalse(pe20.impliesCodeSource(null)); |
| assertTrue (pe20.impliesCodeSource(cs10)); |
| assertFalse(pe20.impliesCodeSource(cs11)); |
| assertTrue (pe20.impliesCodeSource(cs12)); |
| assertFalse(pe20.impliesCodeSource(cs13)); |
| assertTrue (pe20.impliesCodeSource(cs20)); |
| assertFalse(pe20.impliesCodeSource(cs21)); |
| assertFalse(pe20.impliesCodeSource(cs22)); |
| assertFalse(pe20.impliesCodeSource(cs23)); |
| assertTrue (pe20.impliesCodeSource(cs30)); |
| assertFalse(pe20.impliesCodeSource(cs31)); |
| assertFalse(pe20.impliesCodeSource(cs32)); |
| assertFalse(pe20.impliesCodeSource(cs33)); |
| |
| assertFalse(pe21.impliesCodeSource(null)); |
| assertFalse(pe21.impliesCodeSource(cs10)); |
| assertTrue (pe21.impliesCodeSource(cs11)); |
| assertFalse(pe21.impliesCodeSource(cs12)); |
| assertTrue (pe21.impliesCodeSource(cs13)); |
| assertFalse(pe21.impliesCodeSource(cs20)); |
| assertTrue (pe21.impliesCodeSource(cs21)); |
| assertFalse(pe21.impliesCodeSource(cs22)); |
| assertTrue (pe21.impliesCodeSource(cs23)); |
| assertFalse(pe21.impliesCodeSource(cs30)); |
| assertTrue (pe21.impliesCodeSource(cs31)); |
| assertFalse(pe21.impliesCodeSource(cs32)); |
| assertTrue (pe21.impliesCodeSource(cs33)); |
| |
| assertFalse(pe22.impliesCodeSource(null)); |
| assertFalse(pe22.impliesCodeSource(cs10)); |
| // assertFalse(pe22.impliesCodeSource(cs11)); |
| assertFalse(pe22.impliesCodeSource(cs12)); |
| // assertFalse(pe22.impliesCodeSource(cs13)); |
| assertFalse(pe22.impliesCodeSource(cs20)); |
| assertFalse(pe22.impliesCodeSource(cs21)); |
| assertTrue (pe22.impliesCodeSource(cs22)); |
| assertFalse(pe22.impliesCodeSource(cs23)); |
| assertFalse(pe22.impliesCodeSource(cs30)); |
| assertFalse(pe22.impliesCodeSource(cs31)); |
| assertTrue (pe22.impliesCodeSource(cs32)); |
| assertFalse(pe22.impliesCodeSource(cs33)); |
| |
| assertFalse(pe23.impliesCodeSource(null)); |
| assertFalse(pe23.impliesCodeSource(cs10)); |
| assertTrue (pe23.impliesCodeSource(cs11)); |
| assertFalse(pe23.impliesCodeSource(cs12)); |
| assertTrue (pe23.impliesCodeSource(cs13)); |
| assertFalse(pe23.impliesCodeSource(cs20)); |
| assertTrue (pe23.impliesCodeSource(cs21)); |
| assertFalse(pe23.impliesCodeSource(cs22)); |
| assertTrue (pe23.impliesCodeSource(cs23)); |
| assertFalse(pe23.impliesCodeSource(cs30)); |
| assertTrue (pe23.impliesCodeSource(cs31)); |
| assertFalse(pe23.impliesCodeSource(cs32)); |
| assertTrue (pe23.impliesCodeSource(cs33)); |
| |
| assertFalse(pe30.impliesCodeSource(null)); |
| assertTrue (pe30.impliesCodeSource(cs10)); |
| assertFalse(pe30.impliesCodeSource(cs11)); |
| assertTrue (pe30.impliesCodeSource(cs12)); |
| assertFalse(pe30.impliesCodeSource(cs13)); |
| assertTrue (pe30.impliesCodeSource(cs20)); |
| assertFalse(pe30.impliesCodeSource(cs21)); |
| assertFalse(pe30.impliesCodeSource(cs22)); |
| assertFalse(pe30.impliesCodeSource(cs23)); |
| assertTrue (pe30.impliesCodeSource(cs30)); |
| assertFalse(pe30.impliesCodeSource(cs31)); |
| assertFalse(pe30.impliesCodeSource(cs32)); |
| assertFalse(pe30.impliesCodeSource(cs33)); |
| |
| assertFalse(pe31.impliesCodeSource(null)); |
| assertTrue (pe31.impliesCodeSource(cs10)); |
| assertTrue (pe31.impliesCodeSource(cs11)); |
| assertTrue (pe31.impliesCodeSource(cs12)); |
| assertTrue (pe31.impliesCodeSource(cs13)); |
| assertTrue (pe31.impliesCodeSource(cs20)); |
| assertTrue (pe31.impliesCodeSource(cs21)); |
| assertFalse(pe31.impliesCodeSource(cs22)); |
| assertTrue (pe31.impliesCodeSource(cs23)); |
| assertTrue (pe31.impliesCodeSource(cs30)); |
| assertTrue (pe31.impliesCodeSource(cs31)); |
| assertFalse(pe31.impliesCodeSource(cs32)); |
| assertTrue (pe31.impliesCodeSource(cs33)); |
| |
| assertFalse(pe32.impliesCodeSource(null)); |
| assertFalse(pe32.impliesCodeSource(cs10)); |
| assertFalse(pe32.impliesCodeSource(cs11)); |
| assertFalse(pe32.impliesCodeSource(cs12)); |
| assertFalse(pe32.impliesCodeSource(cs13)); |
| assertFalse(pe32.impliesCodeSource(cs20)); |
| assertFalse(pe32.impliesCodeSource(cs21)); |
| assertFalse(pe32.impliesCodeSource(cs22)); |
| assertFalse(pe32.impliesCodeSource(cs23)); |
| assertFalse(pe32.impliesCodeSource(cs30)); |
| assertFalse(pe32.impliesCodeSource(cs31)); |
| assertTrue (pe32.impliesCodeSource(cs32)); |
| assertFalse(pe32.impliesCodeSource(cs33)); |
| |
| assertFalse(pe33.impliesCodeSource(null)); |
| assertTrue (pe33.impliesCodeSource(cs10)); |
| assertTrue (pe33.impliesCodeSource(cs11)); |
| assertTrue (pe33.impliesCodeSource(cs12)); |
| assertTrue (pe33.impliesCodeSource(cs13)); |
| assertTrue (pe33.impliesCodeSource(cs20)); |
| assertTrue (pe33.impliesCodeSource(cs21)); |
| assertFalse(pe33.impliesCodeSource(cs22)); |
| assertTrue (pe33.impliesCodeSource(cs23)); |
| assertTrue (pe33.impliesCodeSource(cs30)); |
| assertTrue (pe33.impliesCodeSource(cs31)); |
| assertFalse(pe33.impliesCodeSource(cs32)); |
| assertTrue (pe33.impliesCodeSource(cs33)); |
| } |
| |
| /** |
| * Null or empty set of Principals of PolicyEntry implies any Principals; |
| * otherwise tested set must contain all Principals of PolicyEntry. |
| */ |
| public void testImpliesPrincipals() { |
| PolicyEntry pe = new PolicyEntry(null, null, null); |
| Principal[] pp1 = new Principal[] {}; |
| Principal[] pp2 = new Principal[] { new UnresolvedPrincipal("a.b.c", |
| "XXX") }; |
| Principal[] pp3 = new Principal[] { |
| new UnresolvedPrincipal("a.b.c", "YYY"), |
| new UnresolvedPrincipal("a.b.c", "XXX"), |
| new UnresolvedPrincipal("e.f.g", "ZZZ") }; |
| |
| assertTrue(pe.impliesPrincipals(null)); |
| assertTrue(pe.impliesPrincipals(pp1)); |
| |
| pe = new PolicyEntry(null, new HashSet(), null); |
| assertTrue(pe.impliesPrincipals(pp3)); |
| |
| pe = new PolicyEntry(null, Arrays.asList(pp2), null); |
| assertFalse(pe.impliesPrincipals(null)); |
| assertFalse(pe.impliesPrincipals(pp1)); |
| assertTrue(pe.impliesPrincipals(pp3)); |
| } |
| } |
