1/* 2 * Licensed to the Apache Software Foundation (ASF) under one or more 3 * contributor license agreements. See the NOTICE file distributed with 4 * this work for additional information regarding copyright ownership. 5 * The ASF licenses this file to You under the Apache License, Version 2.0 6 * (the "License"); you may not use this file except in compliance with 7 * the License. You may obtain a copy of the License at 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 11 * Unless required by applicable law or agreed to in writing, software 12 * distributed under the License is distributed on an "AS IS" BASIS, 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 * See the License for the specific language governing permissions and 15 * limitations under the License. 16 */ 17 18/** 19* @author Alexey V. Varlamov 20* @version $Revision$ 21*/ 22 23package tests.java.security; 24 25import dalvik.annotation.TestTargetClass; 26import dalvik.annotation.TestTargets; 27import dalvik.annotation.TestLevel; 28import dalvik.annotation.TestTargetNew; 29 30import java.security.BasicPermission; 31import java.security.PermissionCollection; 32 33import junit.framework.TestCase; 34 35/** 36 * Tests for <code>BasicPermission</code> 37 * 38 */ 39@TestTargetClass(BasicPermission.class) 40public class BasicPermissionTest extends TestCase { 41 42 public static void main(String[] args) { 43 junit.textui.TestRunner.run(BasicPermissionTest.class); 44 } 45 46 /** 47 * Check all constructors: an object is created with the specified valid name. 48 * If name equal null then NPE should be thrown. 49 * If name is empty then IAE should be thrown. 50 * Action is ignored. 51 */ 52 @TestTargets({ 53 @TestTargetNew( 54 level = TestLevel.COMPLETE, 55 notes = "", 56 method = "BasicPermission", 57 args = {java.lang.String.class} 58 ), 59 @TestTargetNew( 60 level = TestLevel.COMPLETE, 61 notes = "", 62 method = "BasicPermission", 63 args = {java.lang.String.class, java.lang.String.class} 64 ) 65 }) 66 public void testCtor() 67 { 68 String name = "basic123*$%#"; 69 BasicPermission test = new BasicPermission(name){}; 70 assertEquals(name, test.getName()); 71 assertEquals("", test.getActions()); 72 test = new BasicPermission(name, "#$!#12435"){}; 73 assertEquals(name, test.getName()); 74 assertEquals("", test.getActions()); 75 try{ 76 new BasicPermission(null){}; 77 fail("NPE is not thrown"); 78 } 79 catch (NullPointerException ok){} 80 81 try{ 82 new BasicPermission(null, "ds235"){}; 83 fail("NPE is not thrown"); 84 } 85 catch (NullPointerException ok){} 86 87 try{ 88 new BasicPermission(""){}; 89 fail("IAE is not thrown"); 90 } 91 catch (IllegalArgumentException ok){} 92 try{ 93 new BasicPermission("", "ertre 3454"){}; 94 fail("IAE is not thrown"); 95 } 96 catch (IllegalArgumentException ok){} 97 } 98 99 private final class BasicPermissionImpl extends BasicPermission 100 { 101 public BasicPermissionImpl(String name) 102 { 103 super(name); 104 } 105 } 106 107 /** 108 * two BasicPermissions are equal if name and class are equal; 109 * equal permissions should have the same hash code 110 */ 111 @TestTargetNew( 112 level = TestLevel.COMPLETE, 113 notes = "", 114 method = "equals", 115 args = {java.lang.Object.class} 116 ) 117 public void testEquals() 118 { 119 BasicPermission b1 = new BasicPermissionImpl("abc"); 120 BasicPermission b2 = null; 121 assertTrue(b1.equals(b1)); 122 assertFalse(b1.equals(null)); 123 assertFalse(b1.equals(new Object())); 124 assertFalse(b1.equals("abc")); 125 assertTrue(b1.equals(b2 = new BasicPermissionImpl("abc"))); 126 assertTrue(b1.hashCode() == b2.hashCode()); 127 assertFalse(b1.equals(new BasicPermission("abc"){})); 128 assertFalse(b1.equals(new BasicPermissionImpl("abc.*"))); 129 } 130 131 /** 132 * implies() should return true if a permission is equal to or is implied 133 * by wildcarded permission, false otherwise. 134 */ 135 @TestTargetNew( 136 level = TestLevel.COMPLETE, 137 notes = "", 138 method = "implies", 139 args = {java.security.Permission.class} 140 ) 141 public void testImplies() 142 { 143 BasicPermission b1 = new BasicPermissionImpl("a.b.c"); 144 assertTrue(b1.implies(b1)); 145 assertTrue(b1.implies(new BasicPermissionImpl("a.b.c"))); 146 assertFalse(b1.implies(new BasicPermissionImpl("a.b.c.*"))); 147 assertFalse(b1.implies(new BasicPermission("a.b.c"){})); 148 assertTrue(new BasicPermissionImpl("a.b.*").implies(b1)); 149 assertTrue(new BasicPermissionImpl("a.*").implies(b1)); 150 assertTrue(new BasicPermissionImpl("*").implies(b1)); 151 assertFalse(new BasicPermissionImpl("a.b*").implies(b1)); 152 assertFalse(new BasicPermissionImpl("a.b.c.*").implies(b1)); 153 assertTrue(new BasicPermissionImpl("1.*").implies(new BasicPermissionImpl("1.234.*"))); 154 assertTrue(new BasicPermissionImpl("*").implies(new BasicPermissionImpl("*"))); 155 } 156 157 /** 158 * newPermissionCollection() should return new BasicPermissionCollection on every invocation 159 */ 160 @TestTargetNew( 161 level = TestLevel.COMPLETE, 162 notes = "", 163 method = "newPermissionCollection", 164 args = {} 165 ) 166 public void testCollection() 167 { 168 BasicPermission b1 = new BasicPermissionImpl("a.b.c"); 169 PermissionCollection pc1 = b1.newPermissionCollection(); 170 PermissionCollection pc2 = b1.newPermissionCollection(); 171// assertTrue((pc1 instanceof BasicPermissionCollection) && (pc2 instanceof BasicPermissionCollection)); 172 assertNotSame(pc1, pc2); 173 } 174} 175