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