/*
 *  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);
        }
        
    };
}