/*

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

 *

 * 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.ByteArrayInputStream;

import java.io.ByteArrayOutputStream;

import java.io.Externalizable;

import java.io.IOException;

import java.io.ObjectInput;

import java.io.ObjectInputStream;

import java.io.ObjectOutput;

import java.io.ObjectOutputStream;

import java.io.OptionalDataException;

import java.io.Serializable;

import java.lang.invoke.MethodHandle;

import java.lang.reflect.Constructor;

import java.lang.reflect.InvocationTargetException;

import sun.reflect.ReflectionFactory;

import org.testng.Assert;

import org.testng.annotations.BeforeClass;

import org.testng.annotations.Test;

import org.testng.annotations.DataProvider;

import org.testng.TestNG;

/*

 * @test

 * @run testng ReflectionFactoryTest

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

 * @summary Basic test for the unsupported ReflectionFactory

 * @modules jdk.unsupported

 */

public class ReflectionFactoryTest {

    // Initialized by init()

    static ReflectionFactory factory;

    @DataProvider(name = "ClassConstructors")

    static Object[][] classConstructors() {

        return new Object[][] {

                {Object.class},

                {Foo.class},

                {Bar.class},

        };

    }

    @BeforeClass

    static void init() {

        factory = ReflectionFactory.getReflectionFactory();

    }

    /**

     * Test that the correct Constructor is selected and run.

     * @param type type of object to create

     * @throws NoSuchMethodException - error

     * @throws InstantiationException - error

     * @throws IllegalAccessException - error

     * @throws InvocationTargetException - error

     */

    @Test(dataProvider="ClassConstructors")

    static void testConstructor(Class<?> type)

        throws NoSuchMethodException, InstantiationException,

            IllegalAccessException, InvocationTargetException

    {

        @SuppressWarnings("unchecked")

        Constructor<?> c = factory.newConstructorForSerialization(type);

        Object o = c.newInstance();

        Assert.assertEquals(o.getClass(), type, "Instance is wrong type");

        if (o instanceof Foo) {

            Foo foo = (Foo)o;

            foo.check();

        }

    }

    static class Foo {

        private int foo;

        public Foo() {

            this.foo = 1;

        }

        public String toString() {

            return "foo: " + foo;

        }

        public void check() {

            int expectedFoo = 1;

            Assert.assertEquals(foo, expectedFoo, "foo() constructor not run");

        }

    }

    static class Bar extends Foo implements Serializable {

        private int bar;

        public Bar() {

            this.bar = 1;

        }

        public String toString() {

            return super.toString() + ", bar: " + bar;

        }

        public void check() {

            super.check();

            int expectedBar = 0;

            Assert.assertEquals(bar, expectedBar, "bar() constructor not run");

        }

    }

    /**

     * Test newConstructorForExternalization returns the constructor and it can be called.

     * @throws NoSuchMethodException - error

     * @throws InstantiationException - error

     * @throws IllegalAccessException - error

     * @throws InvocationTargetException - error

     */

    @Test

    static void newConstructorForExternalization()

            throws NoSuchMethodException, InstantiationException,

            IllegalAccessException, InvocationTargetException {

        Constructor<?> cons = factory.newConstructorForExternalization(Ext.class);

        Ext ext = (Ext)cons.newInstance();

        Assert.assertEquals(ext.ext, 1, "Constructor not run");

    }

    static class Ext implements Externalizable {

        private static final long serialVersionUID = 1L;

        int ext;

        public Ext() {

            ext = 1;

        }

        @Override

        public void writeExternal(ObjectOutput out) throws IOException {}

        @Override

        public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {}

    }

    @Test

    static void testReadWriteObjectForSerialization() throws Throwable {

        MethodHandle readObjectMethod = factory.readObjectForSerialization(Ser.class);

        Assert.assertNotNull(readObjectMethod, "readObjectMethod not found");

        MethodHandle readObjectNoDataMethod = factory.readObjectNoDataForSerialization(Ser.class);

        Assert.assertNotNull(readObjectNoDataMethod, "readObjectNoDataMethod not found");

        MethodHandle writeObjectMethod = factory.writeObjectForSerialization(Ser.class);

        Assert.assertNotNull(writeObjectMethod, "writeObjectMethod not found");

        MethodHandle readResolveMethod = factory.readResolveForSerialization(Ser.class);

        Assert.assertNotNull(readResolveMethod, "readResolveMethod not found");

        MethodHandle writeReplaceMethod = factory.writeReplaceForSerialization(Ser.class);

        Assert.assertNotNull(writeReplaceMethod, "writeReplaceMethod not found");

        byte[] data = null;

        try (ByteArrayOutputStream baos = new ByteArrayOutputStream();

            ObjectOutputStream oos = new ObjectOutputStream(baos)) {

            Ser ser = new Ser();

            writeReplaceMethod.invoke(ser);

            Assert.assertTrue(ser.writeReplaceCalled, "writeReplace not called");

            Assert.assertFalse(ser.writeObjectCalled, "writeObject should not have been called");

            writeObjectMethod.invoke(ser, oos);

            Assert.assertTrue(ser.writeReplaceCalled, "writeReplace should have been called");

            Assert.assertTrue(ser.writeObjectCalled, "writeObject not called");

            oos.flush();

            data = baos.toByteArray();

        }

        try (ByteArrayInputStream bais = new ByteArrayInputStream(data);

             ObjectInputStream ois = new ObjectInputStream(bais)) {

            Ser ser2 = new Ser();

            readObjectMethod.invoke(ser2, ois);

            Assert.assertTrue(ser2.readObjectCalled, "readObject not called");

            Assert.assertFalse(ser2.readObjectNoDataCalled, "readObjectNoData should not be called");

            Assert.assertFalse(ser2.readResolveCalled, "readResolve should not be called");

            readObjectNoDataMethod.invoke(ser2, ois);

            Assert.assertTrue(ser2.readObjectCalled, "readObject should have been called");

            Assert.assertTrue(ser2.readObjectNoDataCalled, "readObjectNoData not called");

            Assert.assertFalse(ser2.readResolveCalled, "readResolve should not be called");

            readResolveMethod.invoke(ser2);

            Assert.assertTrue(ser2.readObjectCalled, "readObject should have been called");

            Assert.assertTrue(ser2.readObjectNoDataCalled, "readObjectNoData not called");

            Assert.assertTrue(ser2.readResolveCalled, "readResolve not called");

        }

    }

    @Test

    static void hasStaticInitializer() {

        boolean actual = factory.hasStaticInitializerForSerialization(Ser.class);

        Assert.assertTrue(actual, "hasStaticInitializerForSerialization is wrong");

    }

    static class Ser implements Serializable {

        private static final long serialVersionUID = 2L;

        static {

            // Define a static class initialization method

        }

        boolean readObjectCalled = false;

        boolean readObjectNoDataCalled = false;

        boolean writeObjectCalled = false;

        boolean readResolveCalled = false;

        boolean writeReplaceCalled = false;

        public Ser() {}

        private void readObject(ObjectInputStream ois) throws IOException {

            Assert.assertFalse(writeObjectCalled, "readObject called too many times");

            readObjectCalled = ois.readBoolean();

        }

        private void readObjectNoData(ObjectInputStream ois) throws IOException {

            Assert.assertFalse(readObjectNoDataCalled, "readObjectNoData called too many times");

            readObjectNoDataCalled = true;

        }

        private void writeObject(ObjectOutputStream oos) throws IOException {

            Assert.assertFalse(writeObjectCalled, "writeObject called too many times");

            writeObjectCalled = true;

            oos.writeBoolean(writeObjectCalled);

        }

        private Object writeReplace() {

            Assert.assertFalse(writeReplaceCalled, "writeReplace called too many times");

            writeReplaceCalled = true;

            return this;

        }

        private Object readResolve() {

            Assert.assertFalse(readResolveCalled, "readResolve called too many times");

            readResolveCalled = true;

            return this;

        }

    }

    /**

     * Test the constructor of OptionalDataExceptions.

     */

    @Test

    static void newOptionalDataException() {

        OptionalDataException ode = factory.newOptionalDataExceptionForSerialization(true);

        Assert.assertTrue(ode.eof, "eof wrong");

        ode = factory.newOptionalDataExceptionForSerialization(false);

        Assert.assertFalse(ode.eof, "eof wrong");

    }

    // 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 = {ReflectionFactoryTest.class};

        TestNG testng = new TestNG();

        testng.setTestClasses(testclass);

        testng.run();

    }

}