/* 
 * 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 org.apache.harmony.security.tests.java.security;

import java.security.Identity;
import java.security.IdentityScope;
import java.security.KeyManagementException;
import java.security.KeyPairGenerator;
import java.security.PublicKey;
import java.util.Enumeration;
import java.util.Hashtable;

import org.apache.harmony.security.tests.java.security.Identity2Test.IdentitySubclass;

public class IdentityScope2Test extends junit.framework.TestCase {

    static PublicKey pubKey;

    static {
        try {
            pubKey = KeyPairGenerator.getInstance("DSA").genKeyPair().getPublic();
        } catch (Exception e) {
            fail(e.toString());
        }
    }

    public static class IdentityScopeSubclass extends IdentityScope {
        Hashtable identities;

        public IdentityScopeSubclass(String name, PublicKey pk) {
            super(name);
            try {
                setPublicKey(pk);
            } catch (KeyManagementException e) {
            }
            identities = new Hashtable();
        }

        public IdentityScopeSubclass() {
            super();
            identities = new Hashtable();
        }

        public IdentityScopeSubclass(String name) {
            super(name);
            identities = new Hashtable();
        }

        public IdentityScopeSubclass(String name, IdentityScope scope)
                throws KeyManagementException {
            super(name, scope);
            identities = new Hashtable();
        }

        public int size() {
            return identities.size();
        }

        public Identity getIdentity(String name) {
            Enumeration en = identities();
            while (en.hasMoreElements()) {
                Identity current = (Identity) en.nextElement();
                if (current.getName().equals(name))
                    return current;
            }
            return null;
        }

        public Identity getIdentity(PublicKey pk) {
            Enumeration en = identities();
            while (en.hasMoreElements()) {
                Identity current = (Identity) en.nextElement();
                if (current.getPublicKey() == pk)
                    return current;
            }
            return null;
        }

        public Enumeration identities() {
            return identities.elements();
        }

        public void addIdentity(Identity id) throws KeyManagementException {
            if (identities.containsKey(id))
                throw new KeyManagementException(
                        "This Identity is already contained in the scope");
            if (getIdentity(id.getPublicKey()) != null)
                throw new KeyManagementException(
                        "This Identity's public key already exists in the scope");
            identities.put(id, id);
        }

        public void removeIdentity(Identity id) throws KeyManagementException {
            if (!identities.containsKey(id))
                throw new KeyManagementException(
                        "This Identity is not contained in the scope");
            identities.remove(id);
        }
    }

    /**
     * @tests java.security.IdentityScope#IdentityScope()
     */
    public void test_Constructor() {
        new IdentityScopeSubclass();
    }

    /**
     * @tests java.security.IdentityScope#IdentityScope(java.lang.String)
     */
    public void test_ConstructorLjava_lang_String() {
        new IdentityScopeSubclass("test");
    }

    /**
     * @tests java.security.IdentityScope#IdentityScope(java.lang.String,
     *java.security.IdentityScope)
     */
    public void test_ConstructorLjava_lang_StringLjava_security_IdentityScope() throws Exception {
        new IdentityScopeSubclass("test", new IdentityScopeSubclass());
    }

    /**
     * @tests java.security.IdentityScope#addIdentity(java.security.Identity)
     */
    public void test_addIdentityLjava_security_Identity() throws Exception {
        IdentityScopeSubclass sub = new IdentityScopeSubclass("test",
                new IdentityScopeSubclass());
        Identity id = new IdentitySubclass("id1");
        id.setPublicKey(pubKey);
        sub.addIdentity(id);
        try {
            Identity id2 = new IdentitySubclass("id2");
            id2.setPublicKey(pubKey);
            sub.addIdentity(id2);
            fail("KeyManagementException should have been thrown");
        } catch (KeyManagementException e) {
            // Expected
        }
    }

    /**
     * @tests java.security.IdentityScope#removeIdentity(java.security.Identity)
     */
    public void test_removeIdentityLjava_security_Identity() throws Exception {
        IdentityScopeSubclass sub = new IdentityScopeSubclass("test",
                new IdentityScopeSubclass());
        Identity id = new IdentitySubclass();
        id.setPublicKey(pubKey);
        sub.addIdentity(id);
        sub.removeIdentity(id);
        try {
            sub.removeIdentity(id);
            fail("KeyManagementException should have been thrown");
        } catch (KeyManagementException e) {
            // expected
        }
    }

    /**
     * @tests java.security.IdentityScope#identities()
     */
    public void test_identities() throws Exception {
        IdentityScopeSubclass sub = new IdentityScopeSubclass("test",
                new IdentityScopeSubclass());
        Identity id = new IdentitySubclass();
        id.setPublicKey(pubKey);
        sub.addIdentity(id);
        Enumeration en = sub.identities();
        assertTrue("Wrong object contained in identities", en.nextElement()
                .equals(id));
        assertTrue("Contains too many elements", !en.hasMoreElements());
    }

    /**
     * @tests java.security.IdentityScope#getIdentity(java.security.Principal)
     */
    public void test_getIdentityLjava_security_Principal() throws Exception {
        Identity id = new IdentitySubclass("principal name");
        id.setPublicKey(pubKey);
        IdentityScopeSubclass sub = new IdentityScopeSubclass("test",
                new IdentityScopeSubclass());
        sub.addIdentity(id);
        Identity returnedId = sub.getIdentity(id);
        assertEquals("Returned Identity not the same as the added one", id,
                returnedId);
    }

    /**
     * @tests java.security.IdentityScope#getIdentity(java.security.PublicKey)
     */
    public void test_getIdentityLjava_security_PublicKey() throws Exception {
        IdentityScopeSubclass sub = new IdentityScopeSubclass("test",
                new IdentityScopeSubclass());
        Identity id = new IdentitySubclass();
        id.setPublicKey(pubKey);
        sub.addIdentity(id);
        Identity returnedId = sub.getIdentity(pubKey);
        assertEquals("Returned Identity not the same as the added one", id,
                returnedId);
    }

    /**
     * @tests java.security.IdentityScope#getIdentity(java.lang.String)
     */
    public void test_getIdentityLjava_lang_String() throws Exception {
        IdentityScopeSubclass sub = new IdentityScopeSubclass("test",
                new IdentityScopeSubclass());
        Identity id = new IdentitySubclass("test");
        id.setPublicKey(pubKey);
        sub.addIdentity(id);
        Identity returnedId = sub.getIdentity("test");
        assertEquals("Returned Identity not the same as the added one", id,
                returnedId);
    }

    /**
     * @tests java.security.IdentityScope#size()
     */
    public void test_size() throws Exception {
        IdentityScopeSubclass sub = new IdentityScopeSubclass("test",
                new IdentityScopeSubclass());
        Identity id = new IdentitySubclass();
        id.setPublicKey(pubKey);
        sub.addIdentity(id);
        assertEquals("Wrong size", 1, sub.size());
    }

    /**
     * @tests java.security.IdentityScope#toString()
     */
    public void test_toString() throws Exception {
        IdentityScopeSubclass sub = new IdentityScopeSubclass("test",
                new IdentityScopeSubclass());
        Identity id = new IdentitySubclass();
        id.setPublicKey(pubKey);
        sub.addIdentity(id);
        assertNotNull("toString returned a null", sub.toString());
        assertTrue("Not a valid String ", sub.toString().length() > 0);
    }

    public void test_getIdentity() throws Exception {
        //Regression for HARMONY-1173
        IdentityScope scope = IdentityScope.getSystemScope();
        try {
            scope.getIdentity((String) null);
            fail("NPE expected");
        } catch (NullPointerException npe) {
        }
    }
}