jdk/test/sun/reflect/ReflectionFactory/ReflectionFactoryTest.java - platform/libcore - Git at Google

 /*
  * 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
  * @bug 8137058 8164908 8168980
  * @run testng ReflectionFactoryTest
  * @run testng/othervm/policy=security.policy ReflectionFactoryTest
  * @summary Basic test for the unsupported ReflectionFactory
  */

 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();
         }
     }

     @DataProvider(name = "NonSerialConstructors")
     static Object[][] constructors() throws NoSuchMethodException {
         return new Object[][] {
                 {Foo.class, Object.class.getDeclaredConstructor()},
                 {Foo.class, Foo.class.getDeclaredConstructor()},
                 {Baz.class, Object.class.getDeclaredConstructor()},
                 {Baz.class, Foo.class.getDeclaredConstructor()},
                 {Baz.class, Baz.class.getDeclaredConstructor()}
         };
     }

     /**
      * Tests that the given Constructor, in the hierarchy, is run.
      */
     @Test(dataProvider="NonSerialConstructors")
     static void testNonSerializableConstructor(Class<?> cl,
                                                Constructor<?> constructorToCall)
         throws ReflectiveOperationException
     {
         @SuppressWarnings("unchecked")
         Constructor<?> c = factory.newConstructorForSerialization(cl,
                                                                   constructorToCall);

         Object o = c.newInstance();
         Assert.assertEquals(o.getClass(), cl, "Instance is wrong type");

         int expectedFoo = 0;
         int expectedBaz = 0;
         if (constructorToCall.getName().equals("ReflectionFactoryTest$Foo")) {
             expectedFoo = 1;
         } else if (constructorToCall.getName().equals("ReflectionFactoryTest$Baz")) {
             expectedFoo = 1;
             expectedBaz = 4;
         }

         Assert.assertEquals(((Foo)o).foo(), expectedFoo);
         if (o instanceof Baz) {
             Assert.assertEquals(((Baz)o).baz(), expectedBaz);
         }
     }

     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");
         }

         public int foo() { return foo; }
     }

     static class Bar extends Foo implements Serializable {
         private static final long serialVersionUID = 3L;

         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");
         }
     }

     static class Baz extends Foo {
         private static final long serialVersionUID = 4L;

         private final int baz;
         public Baz() { this.baz = 4; }
         public int baz() { return baz; }
     }

     /**
      * 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();
     }
 }
	/*
	* 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
	* @bug 8137058 8164908 8168980
	* @run testng ReflectionFactoryTest
	* @run testng/othervm/policy=security.policy ReflectionFactoryTest
	* @summary Basic test for the unsupported ReflectionFactory
	*/

	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();
	}
	}

	@DataProvider(name = "NonSerialConstructors")
	static Object[][] constructors() throws NoSuchMethodException {
	return new Object[][] {
	{Foo.class, Object.class.getDeclaredConstructor()},
	{Foo.class, Foo.class.getDeclaredConstructor()},
	{Baz.class, Object.class.getDeclaredConstructor()},
	{Baz.class, Foo.class.getDeclaredConstructor()},
	{Baz.class, Baz.class.getDeclaredConstructor()}
	};
	}

	/**
	* Tests that the given Constructor, in the hierarchy, is run.
	*/
	@Test(dataProvider="NonSerialConstructors")
	static void testNonSerializableConstructor(Class<?> cl,
	Constructor<?> constructorToCall)
	throws ReflectiveOperationException
	{
	@SuppressWarnings("unchecked")
	Constructor<?> c = factory.newConstructorForSerialization(cl,
	constructorToCall);

	Object o = c.newInstance();
	Assert.assertEquals(o.getClass(), cl, "Instance is wrong type");

	int expectedFoo = 0;
	int expectedBaz = 0;
	if (constructorToCall.getName().equals("ReflectionFactoryTest$Foo")) {
	expectedFoo = 1;
	} else if (constructorToCall.getName().equals("ReflectionFactoryTest$Baz")) {
	expectedFoo = 1;
	expectedBaz = 4;
	}

	Assert.assertEquals(((Foo)o).foo(), expectedFoo);
	if (o instanceof Baz) {
	Assert.assertEquals(((Baz)o).baz(), expectedBaz);
	}
	}

	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");
	}

	public int foo() { return foo; }
	}

	static class Bar extends Foo implements Serializable {
	private static final long serialVersionUID = 3L;

	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");
	}
	}

	static class Baz extends Foo {
	private static final long serialVersionUID = 4L;

	private final int baz;
	public Baz() { this.baz = 4; }
	public int baz() { return baz; }
	}

	/**
	* 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();
	}
	}