/*
 *  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.
 */

/**
* @author Vera Y. Petrashkova
*/

package org.apache.harmony.auth.tests.javax.security.sasl;

import java.io.IOException;
import java.security.Provider;
import java.security.Security;
import java.util.Map;

import javax.security.auth.callback.CallbackHandler;
import javax.security.auth.callback.TextOutputCallback;
import javax.security.auth.callback.UnsupportedCallbackException;
import javax.security.sasl.Sasl;
import javax.security.sasl.SaslException;
import javax.security.sasl.SaslServer;
import javax.security.sasl.SaslServerFactory;

import junit.framework.TestCase;

import org.apache.harmony.auth.tests.support.SpiEngUtils;

/**
 * Test for Sasl class
 */
public class Sasl4Test extends TestCase {
    private static final String SRVSSRV = "SaslServerFactory.";

    private static final String fServerClass = mySaslServerFactory.class.getName();

    private Provider [] provs;
    private boolean initProvs;

    @Override
    protected void setUp() throws Exception {
        super.setUp();
        if (!initProvs) {
            provs = Security.getProviders();
            initProvs = true;
        }
        if (provs != null) {
            for (Provider element : provs) {
                Security.removeProvider(element.getName());
            }
        }
    }

    protected Provider[] mProv;

    private void addProviders() {
        for (Provider element : mProv) {
            Security.insertProviderAt(element, 1);
        }
    }

    /*
     * @see TestCase#tearDown()
     */
    @Override
    protected void tearDown() throws Exception {
        super.tearDown();
        if (mProv != null) {
            for (Provider element : mProv) {
                Security.removeProvider(element.getName());
            }
        }
        if (provs != null) {
            for (int i = 0; i < provs.length; i++) {
                Security.insertProviderAt(provs[i], (i+1));
            }
        }    }

    /**
     * Test for <code>createSaslServer(String mechanism, 
     *      String protocol, String serverName,
     *      Map prop, CallbackHandler cbh))</code> method 
     * Assertions:
     * throws NullPointerException when mechanism is null;
     * throws SaslException when parameters (protocol, cbh,
     * mechanism) are wrong.
     * 
     * All providers are previously removed and 
     * 2 new providers were added.
     */
    public void testCreateServer01() throws SaslException {
        mProv = new Provider[] {
                (new SpiEngUtils()).new MyProvider("MySaslServerProvider1",
                        "Testing provider SaslServerFactory - 1", SRVSSRV
                                .concat("MECH-1"), fServerClass),
                (new SpiEngUtils()).new MyProvider("MySaslServerProvider2",
                        "Testing provider SaslServerFactory - 2", SRVSSRV
                                .concat("MECH-2"), fServerClass) };
        addProviders();

        CallbackHandler cbH = new Sasl3Test.cbHand();
        try {
            Sasl.createSaslServer(null, null, null, null, cbH);
            fail("NullPointerException should be thrown when mechanisms is null");
        } catch (NullPointerException e) {
        }
        try {
            Sasl.createSaslServer("MECH-2", "protocol", null, null, cbH);
            fail("SaslException should be thrown when CallbackHandler is wrong");
        } catch (SaslException e) {
        }
        cbH = new Sasl3Test.cbHandN();
        try {
            Sasl.createSaslServer("MECH-1", "protocol", null, null, cbH);
            fail("SaslException should be thrown when mechanisms is wrong");
        } catch (SaslException e) {
        }
        try {
            Sasl.createSaslServer("MECH-2", null, null, null, cbH);
            fail("SaslException should be thrown when protocol is null");
        } catch (SaslException e) {
        }
    }

    /**
     * Test for <code>createSaslServer(String mechanism, 
     *      String protocol, String serverName,
     *      Map prop, CallbackHandler cbh))</code>
     * method Assertions: throws NullPointerException when mechanisms is null;
     * returns null SaslServer.
     * 
     * All providers are previously removed.
     */
    public void testCreateServer02() throws SaslException {
        try {
            Sasl.createSaslServer(null, null, null, null, null);
            fail("NullPointerException should be thrown when mechanisms is null");
        } catch (NullPointerException e) {
        }
        assertNull("Not null result", Sasl.createSaslServer("MECH-999", null,
                null, null, null));
    }
    
    /**
     * Test for <code>createSaslServer(String mechanism, 
     *      String protocol, String serverName,
     *      Map prop, CallbackHandler cbh))</code> method
     *  
     * Assertions: 
     * returns SaslServer;
     * throws SaslServer for MECH-1 mechanism
     * 
     * All providers are previously removed and 
     * 2 new providers were added.
     */
    public void testCreateServer03() throws SaslException {
        mProv = new Provider[] {
                (new SpiEngUtils()).new MyProvider("MySaslServerProvider1",
                        "Testing provider SaslServerFactory - 1", SRVSSRV
                                .concat("MECH-1"), fServerClass),
                (new SpiEngUtils()).new MyProvider("MySaslServerProvider2",
                        "Testing provider SaslServerFactory - 2", SRVSSRV
                                .concat("MECH-2"), fServerClass) };
        addProviders();

        CallbackHandler cbH = new Sasl3Test.cbHandN();
        SaslServer saslS = Sasl.createSaslServer("MECH-2", "protocol", null,
                null, cbH);
        assertNotNull("Null result", saslS);
        try {
            saslS.unwrap(null, 1, 1);
            fail("SaslException sould be thrown");
        } catch (SaslException e) {
        }
        assertFalse("Incorrect isComplete() result", saslS.isComplete());
        // try to create Server for wrong mechanism
        try {
            saslS = Sasl
                    .createSaslServer("MECH-1", "protocol", null, null, cbH);
            fail("SaslException sould be thrown");
        } catch (SaslException e) {
        }
    }
    
    /**
     * Test for <code>createSaslServer(String mechanism, 
     *      String protocol, String serverName,
     *      Map prop, CallbackHandler cbh))</code> method
     *  
     * Assertions: 
     * returns SaslServer;
     * throws SaslServer for MECH-1 mechanism
     * 
     * All providers are previously removed and 
     * 1 new provider was added.
     */
    public void testCreateServer04() throws SaslException {
        mProv = new Provider[] { (new SpiEngUtils()).new MyProvider(
                "MySaslServerProvider1",
                "Testing provider SaslServerFactory - 1", SRVSSRV
                        .concat("MECH-1"), fServerClass) };
        mProv[0].put(SRVSSRV.concat("MECH-2"), fServerClass);
        addProviders();
        CallbackHandler cbH = new Sasl3Test.cbHandN();
        SaslServer saslS = Sasl.createSaslServer("MECH-2", "protocol", null,
                null, cbH);
        assertNotNull("Null result for MECH-2", saslS);
        assertFalse("Incorrect isComplete() result", saslS.isComplete());
        // try to create Server for wrong mechanism
        try {
            saslS = Sasl
                    .createSaslServer("MECH-1", "protocol", null, null, cbH);
            fail("SaslException sould be thrown");
        } catch (SaslException e) {
        }
    }

    /**
     * Test for <code>createSaslServer(String mechanism, 
     *      String protocol, String serverName,
     *      Map prop, CallbackHandler cbh))</code> method
     *  
     * Assertions: 
     * return null Server when there is no provider supported some mechanism
     * returns SaslServer when incorrect mechanism is used
     * 
     * All providers are previously removed and 
     * 2 new providers were added.
     */
    public void testCreateServer05() throws SaslException {
        mProv = new Provider[] {
                (new SpiEngUtils()).new MyProvider("MySaslServerProvider1",
                        "Testing provider SaslServerFactory - 1", SRVSSRV
                                .concat("MECH-2"), fServerClass.concat("Ext")),
                (new SpiEngUtils()).new MyProvider("MySaslServerProvider2",
                        "Testing provider SaslServerFactory - 2", SRVSSRV
                                .concat("MECH-1"), fServerClass),
                (new SpiEngUtils()).new MyProvider("MySaslServerProvider3",
                        "Testing provider SaslServerFactory - 3", SRVSSRV
                                .concat("MECH-6"), fServerClass) };
        mProv[2].put(SRVSSRV.concat("MECH-5"), fServerClass);
        addProviders();

        CallbackHandler cbH = new Sasl3Test.cbHandN();

        SaslServer saslS;
        // try to create SaslServer for wrong mechanism
        // there is no provider supported MECH-77, MECH-66 mechanisms

        assertNull("Not null object was created for wrong mechanism", Sasl
                .createSaslServer("MECH-77", "protocol", null, null, cbH));

        saslS = Sasl.createSaslServer("MECH-2", "protocol", null, null, cbH);
        assertNotNull("Null result for MECH-2", saslS);
        try {
            saslS.unwrap(null, 1, 1);
            fail("SaslException sould be thrown");
        } catch (SaslException e) {
        }
        assertFalse("Incorrect isComplete() result", saslS.isComplete());
        // MECH-1 was defined in some provider but it is supported in another
        // provider
        try {
            Sasl.createSaslServer("MECH-1", "protocol", null, null, cbH);
            fail("SaslException sould be thrown");
        } catch (SaslException e) {
        }
        // MECH-6 and MECH-5 were defined in one provider but they are supported
        // in another provider
        saslS = Sasl.createSaslServer("MECH-6", "protocol", null, null, cbH);
        assertNotNull("Null result for MECH-6", saslS);
        saslS = Sasl.createSaslServer("MECH-5", "protocol", null, null, cbH);
        assertNotNull("Null result for MECH-5", saslS);
    }

    /*
     * Additional class for creating SaslServer object
     */
    public static class mySaslServerFactory implements SaslServerFactory {
        public mySaslServerFactory() {
            super();
        }

        public String[] getMechanismNames(Map<String, ?> prop) {
            return new String[] { "MECH-1", "MECH-2", "MECH-3", "MECH-4" };
        }

        public SaslServer createSaslServer(String mech, String protocol,
                String srvName, Map<String, ?> prop, CallbackHandler hnd) throws SaslException {
            if (mech == null) {
                throw new SaslException();
            }
            if ("MECH-1".equals(mech)) {
                throw new SaslException("Incorrect mechanisms");
            }
            if (protocol == null) {
                throw new SaslException("Protocol is null");
            }
            TextOutputCallback[] cb = { new TextOutputCallback(
                    TextOutputCallback.INFORMATION, "Information") };
            try {
                hnd.handle(cb);
            } catch (UnsupportedCallbackException e) {
                throw new SaslException("Incorrect callback handlere", e);
            } catch (IOException e) {
                throw new SaslException("Incorrect callback handlere", e);
            }
            return new mySaslServer();
        }

        public class mySaslServer implements SaslServer {
            public mySaslServer() {
                super();
            }

            public void dispose() throws SaslException {
            }

            public byte[] evaluateResponse(byte[] challenge) throws SaslException {
                return new byte[0];
            }

            public String getMechanismName() {
                return "Server Proba";
            }

            public Object getNegotiatedProperty(String s) {
                return "";
            }

            public String getAuthorizationID() {
                return "";
            }

            public boolean isComplete() {
                return false;
            }

            public byte[] unwrap(byte[] incoming, int offset, int len)
                    throws SaslException {
                throw new SaslException();
            }

            public byte[] wrap(byte[] outgoing, int offset, int len)
                    throws SaslException {
                return new byte[0];
            }
        }
    }

    public static class mySaslServerFactoryExt extends mySaslServerFactory {
        @Override
        public String[] getMechanismNames(Map<String, ?> prop) {
            return new String[] { "MECH-5", "MECH-6" };
        }

        @Override
        public SaslServer createSaslServer(String mech, String protocol,
                String srvName, Map<String, ?> prop, CallbackHandler hnd) throws SaslException {
            if (mech == null) {
                throw new SaslException();
            }
            return new mySaslServer();
        }
    }
}