/*

 * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

import java.io.Serializable;

import java.lang.reflect.InvocationTargetException;

import java.lang.reflect.Method;

import java.math.BigDecimal;

import java.math.BigInteger;

import java.net.InetAddress;

import java.net.UnknownHostException;

import java.rmi.Remote;

import java.rmi.RemoteException;

import java.time.LocalTime;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.EnumSet;

import java.util.HashSet;

import java.util.HashMap;

import java.util.Objects;

import java.util.PropertyPermission;

import java.util.Set;

import java.util.concurrent.atomic.LongAdder;

import javax.rmi.CORBA.Util;

import javax.rmi.PortableRemoteObject;

import org.omg.CORBA_2_3.ORB;

import org.omg.CORBA_2_3.portable.OutputStream;

import org.omg.CORBA_2_3.portable.InputStream;

import org.testng.Assert;

import org.testng.annotations.AfterClass;

import org.testng.annotations.BeforeClass;

import org.testng.annotations.Test;

import org.testng.annotations.DataProvider;

import org.testng.TestNG;

/*

 * @test

 * @library /test/lib

 * @build jdk.test.lib.*

 *          java.corba/com.sun.corba.se.impl.activation

 * @summary Tests of ReflectionFactory use in IIOP Serialization

 * @run testng/othervm ObjectStreamTest

 * @run testng/othervm/policy=security.policy ObjectStreamTest

 */

@Test

public class ObjectStreamTest {

    enum Colors {RED, GREEN, YELLOW}

    static Set<Colors> colorSet = new HashSet<>();

    static {

        colorSet.add(Colors.RED);

        colorSet.add(Colors.GREEN);

    }

    @DataProvider(name = "Objects")

    static Object[][] patterns() {

        BigInteger bigInteger = new BigInteger("8943892002309239");

        InetAddress inetAddr;

        try {

            inetAddr = java.net.InetAddress.getByAddress(new byte[]{127, 0, 0, 1});

        } catch (UnknownHostException ignored) {

            inetAddr = null;

            // ignored

        }

        HashMap<String, Object> hashMap = new HashMap<>();

        hashMap.put("BigInteger", bigInteger);

        hashMap.put("InetAddress", inetAddr);

        hashMap.put("String", "bString");

        Object[][] patterns = new Object[][]{

                {"aString"},

                {Integer.valueOf(5)},

                {new SimpleObject(4, 4.0f)},

                {Arrays.asList("a", "b", "c")},

                {new String[]{"x", "y", "z"}},

                {new ArrayList<Object>(1)},     // uses readObject/writeObject

                {new StringBuffer("abc")},      // Has serialPersistentFields

                {new StringBuilder("abc")},

                {Colors.RED},

                {inetAddr},

                {LocalTime.MIDNIGHT},           // uses writeReplace/readResolve

                {new LongAdder()},              // uses writeReplace/readResolve

                {EnumSet.allOf(Colors.class)},  // used writeReplace/readResolve

                {bigInteger},

                {new BigDecimal(bigInteger)},

                {hashMap},

                {new PropertyPermission("abc", "read")}, // has serialPersistentFields

        };

        return patterns;

    }

    /**

     * Check ObjectStreamClass facts match between core serialization and CORBA.

     *

     * @param value

     */

    @Test(dataProvider = "Objects")

    void factCheck(Serializable value) {

        Class<?> clazz = value.getClass();

        java.io.ObjectStreamClass sOSC = java.io.ObjectStreamClass.lookup(clazz);

        java.io.ObjectStreamField[] sFields = sOSC.getFields();

        com.sun.corba.se.impl.io.ObjectStreamClass cOSC = corbaLookup(clazz);

        com.sun.corba.se.impl.io.ObjectStreamField[] cFields = cOSC.getFields();

        Assert.assertEquals(sFields.length, cFields.length, "Different number of fields");

        for (int i = 0; i < sFields.length; i++) {

            Assert.assertEquals(sFields[i].getName(), cFields[i].getName(),

                    "different field names " + cFields[i].getName());

            Assert.assertEquals(sFields[i].getType(), cFields[i].getType(),

                    "different field types " + cFields[i].getName());

            Assert.assertEquals(sFields[i].getTypeString(), cFields[i].getTypeString(),

                    "different field typestrings " + cFields[i].getName());

        }

        Assert.assertEquals(baseMethod("hasReadObjectMethod", sOSC, (Class<?>[]) null),

                corbaMethod("hasReadObject", cOSC, (Class<?>[]) null),

                "hasReadObject: " + value.getClass());

        Assert.assertEquals(baseMethod("hasWriteObjectMethod", sOSC, (Class<?>[]) null),

                corbaMethod("hasWriteObject", cOSC, (Class<?>[]) null),

                "hasWriteObject: " + value.getClass());

        Assert.assertEquals(baseMethod("hasWriteReplaceMethod", sOSC, (Class<?>[]) null),

                corbaMethod("hasWriteReplaceMethod", cOSC, (Class<?>[]) null),

                "hasWriteReplace: " + value.getClass());

        Assert.assertEquals(baseMethod("hasReadResolveMethod", sOSC, (Class<?>[]) null),

                corbaMethod("hasReadResolveMethod", cOSC, (Class<?>[]) null),

                "hasReadResolve: " + value.getClass());

        Assert.assertEquals(baseMethod("getSerialVersionUID", sOSC, (Class<?>[]) null),

                corbaMethod("getSerialVersionUID", cOSC, (Class<?>[]) null),

                "getSerialVersionUID: " + value.getClass());

    }

    /**

     * Test that objects written using Util.writeAny can be serialized

     * and deserialized using Util.readAny to equivalent objects.

     */

    @Test(dataProvider = "Objects", enabled = true, dependsOnMethods = {"factCheck"})

    void WriteValueObjectStreamTest01(Serializable value) throws Exception {

        ORB orb = (ORB) ORB.init(new String[0], null);

        OutputStream out = (OutputStream) orb.create_output_stream();

        Util.writeAny(out, value);

        InputStream in = (InputStream) out.create_input_stream();

        Object actual = Util.readAny(in);

        checkEquals(actual, value);

    }

    /**

     * Test that objects can be echoed to a server and come back equivalent.

     */

    @Test(dataProvider = "Objects", enabled = true, dependsOnMethods = {"factCheck"})

    void echoObjects(Serializable value) throws Exception {

        Echo echo = getEchoStub();

        Object actual = echo.echo(value);

        checkEquals(actual, value);

    }

    /**

     * Initialize the ORB and the singleton Echo server stub.

     * @return the stub for the Echo server.

     * @throws RemoteException if an error occurs

     */

    synchronized Echo getEchoStub() throws RemoteException {

        if (echoStub == null) {

            ORB orb = (ORB) ORB.init(new String[0], null);

            Echo server = new Server();

            echoStub = (javax.rmi.CORBA.Stub) PortableRemoteObject.toStub(server);

            echoStub.connect(orb);

        }

        return (Echo)echoStub;

    }

    /**

     * The stub for the Echo Server class. Initialized on first use.

     */

    private javax.rmi.CORBA.Stub echoStub;

    /**

     * After all the tests run shutdown the orb.

     */

    @AfterClass

    void shutdownOrb() {

        ORB orb = (ORB) ORB.init(new String[0], null);

        orb.shutdown(true);

    }

    /**

     * Check if the value and result are equals, with some tests depending on the type.

     * @param expected the expected value

     * @param actual the actual value

     */

    static void checkEquals(Object actual, Object expected) {

        Class<?> cl = expected.getClass();

        Assert.assertEquals(actual.getClass(), cl,

                "type of value not equal to class of result");

        try {

            if (cl.isArray() || !(cl.getDeclaredMethod("equals", cl) == null)) {

                Assert.assertEquals(actual, expected, "echo'd object not equal");

            } else {

                Assert.assertEquals(toString(actual), toString(expected),

                        "toString values not equal");

            }

        } catch (NoSuchMethodException ex) {

            Assert.assertEquals(toString(actual), toString(expected),

                    "toString values not equal");

        }

    }

    /**

     * Convert an object to a String, and correctly for arrays.

     * @param obj an object

     * @return the tostring for the object.

     */

    static String toString(Object obj) {

        return obj.getClass().isArray()

                ? Arrays.toString((Object[]) obj)

                : Objects.toString(obj);

    }

    /**

     * SimpleObject to test round trip.

     */

    static class SimpleObject implements Serializable {

        private static final long serialVersionUID = 5217577841494640354L;

        private int i = 0;

        private float f = 0.0f;

        SimpleObject(int i, float f) {

            this.i = i;

            this.f = f;

        }

        @Override

        public boolean equals(Object o) {

            if (this == o) return true;

            if (o == null || getClass() != o.getClass()) return false;

            SimpleObject that = (SimpleObject) o;

            if (i != that.i) return false;

            return Float.compare(that.f, f) == 0;

        }

        @Override

        public int hashCode() {

            int result = i;

            result = 31 * result + (f != +0.0f ? Float.floatToIntBits(f) : 0);

            return result;

        }

        @Override

        public String toString() {

            return "SimpleObject{" +

                    "i=" + i +

                    ", f=" + f +

                    '}';

        }

    }

    /**

     * Lookup the CORBA ObjectStreamClass instance for a class.

     * @param clazz the class

     * @return the CORBA ObjectStreamClass instance for the class

     */

    static com.sun.corba.se.impl.io.ObjectStreamClass corbaLookup(Class<?> clazz) {

        Class<?> oscClass = com.sun.corba.se.impl.io.ObjectStreamClass.class;

        try {

            Method meth = oscClass.getDeclaredMethod("lookup", Class.class);

            meth.setAccessible(true);

            return (com.sun.corba.se.impl.io.ObjectStreamClass) meth.invoke(null, clazz);

        } catch (NoSuchMethodException noMeth) {

            throw new RuntimeException("missing method", noMeth);

        } catch (IllegalAccessException | InvocationTargetException rex) {

            throw new RuntimeException("invocation failed", rex);

        }

    }

    /**

     * Lookup aand invoke method on a serializable object via the CORBA ObjectStreamClass.

     * @param methodName method name

     * @param osc CORBA ObjectStreamClass

     * @param argClasses method arguments

     * @return the value returned from invoking the method

     */

    static Object corbaMethod(String methodName,

                              com.sun.corba.se.impl.io.ObjectStreamClass osc,

                              Class<?>... argClasses) {

        Class<?> oscClass = com.sun.corba.se.impl.io.ObjectStreamClass.class;

        try {

            Method meth = oscClass.getDeclaredMethod(methodName, argClasses);

            meth.setAccessible(true);

            return meth.invoke(osc);

        } catch (NoSuchMethodException noMeth) {

            throw new RuntimeException("missing method" + osc.getName()

                    + "::" + methodName, noMeth);

        } catch (IllegalAccessException | InvocationTargetException rex) {

            throw new RuntimeException("invocation failed", rex);

        }

    }

    /**

     * Lookup aand invoke method on a serializable object via java.io.ObjectStreamClass.

     * @param methodName method name

     * @param osc java.io.ObjectStreamClass

     * @param argClasses method arguments

     * @return the value returned from invoking the method

     */

    static Object baseMethod(String methodName, java.io.ObjectStreamClass osc,

                             Class<?>... argClasses) {

        Class<?> oscClass = java.io.ObjectStreamClass.class;

        try {

            Method meth = oscClass.getDeclaredMethod(methodName, argClasses);

            meth.setAccessible(true);

            return meth.invoke(osc);

        } catch (NoSuchMethodException noMeth) {

            throw new RuntimeException("missing method: " + osc.getName()

                    + "::" + methodName, noMeth);

        } catch (IllegalAccessException | InvocationTargetException rex) {

            throw new RuntimeException("invocation failed", rex);

        }

    }

    /**

     * Simple echo interface to check IIOP serialization/deserialization.

     */

    interface Echo extends Remote {

        Object echo(Object obj) throws RemoteException;

    }

    static class Server extends PortableRemoteObject implements Echo {

        public Server() throws RemoteException {

            super();

        }

        public Object echo(Object obj) {

            return obj;

        }

    }

    // Main can be used to run the tests from the command line with only testng.jar.

    @SuppressWarnings("raw_types")

    @Test(enabled = false)

    public static void main(String[] args) {

        Class<?>[] testclass = {ObjectStreamTest.class};

        TestNG testng = new TestNG();

        testng.setTestClasses(testclass);

        testng.run();

    }

}