/*
* 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.
*/
package tests.api.java.util;
import dalvik.annotation.TestTargetNew;
import dalvik.annotation.TestTargets;
import dalvik.annotation.TestLevel;
import dalvik.annotation.TestTargetClass;
import java.io.Serializable;
import java.util.Enumeration;
import java.util.PropertyPermission;
import org.apache.harmony.testframework.serialization.SerializationTest;
import org.apache.harmony.testframework.serialization.SerializationTest.SerializableAssert;
@TestTargetClass(PropertyPermission.class)
public class PropertyPermissionTest extends junit.framework.TestCase {
static PropertyPermission javaPP = new PropertyPermission("java.*", "read");
static PropertyPermission userPP = new PropertyPermission("user.name",
"read,write");
/**
* @tests java.util.PropertyPermission#PropertyPermission(java.lang.String,
* java.lang.String)
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "PropertyPermission",
args = {java.lang.String.class, java.lang.String.class}
)
public void test_ConstructorLjava_lang_StringLjava_lang_String() {
// Test for method java.util.PropertyPermission(java.lang.String,
// java.lang.String)
assertTrue("Used to test", true);
}
/**
* @tests java.util.PropertyPermission#equals(java.lang.Object)
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "equals",
args = {java.lang.Object.class}
)
public void test_equalsLjava_lang_Object() {
// Test for method boolean
// java.util.PropertyPermission.equals(java.lang.Object)
PropertyPermission equalToJavaPP = new PropertyPermission("java.*",
"read");
PropertyPermission notEqualToJavaPP = new PropertyPermission("java.*",
"read, write");
PropertyPermission alsoNotEqualToJavaPP = new PropertyPermission(
"java.home", "read");
assertTrue("Equal returned false for equal objects", javaPP
.equals(equalToJavaPP));
assertTrue("Equal returned true for objects with different names",
!javaPP.equals(notEqualToJavaPP));
assertTrue(
"Equal returned true for objects with different permissions",
!javaPP.equals(alsoNotEqualToJavaPP));
}
/**
* @tests java.util.PropertyPermission#getActions()
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "getActions",
args = {}
)
public void test_getActions() {
// Test for method java.lang.String
// java.util.PropertyPermission.getActions()
assertEquals("getActions did not return proper action", "read", javaPP
.getActions());
assertEquals("getActions did not return proper canonical representation of actions",
"read,write", userPP.getActions());
}
/**
* @tests java.util.PropertyPermission#hashCode()
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "hashCode",
args = {}
)
public void test_hashCode() {
// Test for method int java.util.PropertyPermission.hashCode()
assertTrue("javaPP returned wrong hashCode",
javaPP.hashCode() == javaPP.getName().hashCode());
assertTrue("userPP returned wrong hashCode",
userPP.hashCode() == userPP.getName().hashCode());
}
/**
* @tests java.util.PropertyPermission#implies(java.security.Permission)
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "implies",
args = {java.security.Permission.class}
)
public void test_impliesLjava_security_Permission() {
// Test for method boolean
// java.util.PropertyPermission.implies(java.security.Permission)
PropertyPermission impliedByJavaPP = new PropertyPermission(
"java.home", "read");
PropertyPermission notImpliedByJavaPP = new PropertyPermission(
"java.home", "read,write");
PropertyPermission impliedByUserPP = new PropertyPermission(
"user.name", "read,write");
PropertyPermission alsoImpliedByUserPP = new PropertyPermission(
"user.name", "write");
assertTrue("Returned false for implied permission (subset of .*)",
javaPP.implies(impliedByJavaPP));
assertTrue("Returned true for unimplied permission", !javaPP
.implies(notImpliedByJavaPP));
assertTrue("Returned false for implied permission (equal)", userPP
.implies(impliedByUserPP));
assertTrue("Returned false for implied permission (subset of actions)",
userPP.implies(alsoImpliedByUserPP));
}
/**
* @tests java.util.PropertyPermission#newPermissionCollection()
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "newPermissionCollection",
args = {}
)
public void test_newPermissionCollection() {
// Test for method java.security.PermissionCollection
// java.util.PropertyPermission.newPermissionCollection()
java.security.PermissionCollection pc = javaPP
.newPermissionCollection();
pc.add(javaPP);
Enumeration elementEnum = pc.elements();
assertTrue("Invalid PermissionCollection returned", elementEnum
.nextElement().equals(javaPP));
}
/**
* @tests java.util.PropertyPermission#readObject(ObjectInputStream)
* @tests java.util.PropertyPermission#writeObject(ObjectOutputStream)
*/
@TestTargets({
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "Verifies serialization/deserialization.",
method = "!SerializationSelf",
args = {}
),
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "Verifies serialization/deserialization.",
method = "!SerializationGolden",
args = {}
)
})
public void test_serialization() throws Exception{
PropertyPermission pp = new PropertyPermission("test", "read");
SerializationTest.verifySelf(pp, comparator);
SerializationTest.verifyGolden(this, pp, comparator);
}
/**
* Sets up the fixture, for example, open a network connection. This method
* is called before a test is executed.
*/
protected void setUp() {
}
/**
* Tears down the fixture, for example, close a network connection. This
* method is called after a test is executed.
*/
protected void tearDown() {
}
private static final SerializableAssert comparator = new SerializableAssert() {
public void assertDeserialized(Serializable initial, Serializable deserialized) {
PropertyPermission initialPP = (PropertyPermission) initial;
PropertyPermission deseriaPP = (PropertyPermission) deserialized;
assertEquals("should be equal", initialPP, deseriaPP);
}
};
}