corba/serialization/ObjectStreamTest.java

/*
 * 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.*
 * @compile ObjectStreamTest.java  ObjectStreamTest$_Echo_Stub.java
 *          ObjectStreamTest$_Server_Tie.java
 * @modules java.base/java.io:open
 *          java.corba/com.sun.corba.se.impl.io:+open
 *          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();
    }

}