| /* | |
| * Copyright (c) 2016, 2024, 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.ObjectStreamClass; | |
| import java.io.ObjectStreamException; | |
| import java.io.ObjectStreamField; | |
| import java.io.OptionalDataException; | |
| import java.io.Serial; | |
| import java.io.Serializable; | |
| import java.lang.invoke.MethodHandle; | |
| import java.lang.reflect.Constructor; | |
| import java.lang.reflect.InvocationTargetException; | |
| import java.util.Arrays; | |
| 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 8275137 8333796 | |
| * @summary Basic test for the unsupported ReflectionFactory | |
| * @modules jdk.unsupported | |
| * @run testng ReflectionFactoryTest | |
| */ | |
| 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 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 b) { | |
| Assert.assertEquals(b.baz(), expectedBaz); | |
| } | |
| } | |
| @Test(expectedExceptions = UnsupportedOperationException.class) | |
| static void testConstructorNotSuperClass() throws ReflectiveOperationException { | |
| factory.newConstructorForSerialization(Bar.class, Baz.class.getDeclaredConstructor()); | |
| } | |
| 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 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 final int baz; | |
| public Baz() { this.baz = 4; } | |
| public int baz() { return baz; } | |
| } | |
| /** | |
| * Tests that 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 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); | |
| 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, ClassNotFoundException { | |
| Assert.assertFalse(writeObjectCalled, "readObject called too many times"); | |
| readObjectCalled = ois.readBoolean(); | |
| } | |
| private void readObjectNoData() throws ObjectStreamException { | |
| 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() throws ObjectStreamException { | |
| Assert.assertFalse(writeReplaceCalled, "writeReplace called too many times"); | |
| writeReplaceCalled = true; | |
| return this; | |
| } | |
| private Object readResolve() throws ObjectStreamException { | |
| Assert.assertFalse(readResolveCalled, "readResolve called too many times"); | |
| readResolveCalled = true; | |
| return this; | |
| } | |
| } | |
| /** | |
| * Tests 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"); | |
| } | |
| private static final String[] names = { | |
| "boolean_", | |
| "final_boolean", | |
| "byte_", | |
| "final_byte", | |
| "char_", | |
| "final_char", | |
| "short_", | |
| "final_short", | |
| "int_", | |
| "final_int", | |
| "long_", | |
| "final_long", | |
| "float_", | |
| "final_float", | |
| "double_", | |
| "final_double", | |
| "str", | |
| "final_str", | |
| "writeFields", | |
| }; | |
| // test that the generated read/write objects are working properly | |
| @Test | |
| static void testDefaultReadWriteObject() throws Throwable { | |
| Ser2 ser = new Ser2((byte) 0x33, (short) 0x2244, (char) 0x5342, 0x05382716, 0xf035a73b09113bacL, 1234f, 3456.0, true, new Ser3(0x004917aa)); | |
| ser.byte_ = (byte) 0x44; | |
| ser.short_ = (short) 0x3355; | |
| ser.char_ = (char) 0x6593; | |
| ser.int_ = 0x4928a299; | |
| ser.long_ = 0x24aa19883f4b9138L; | |
| ser.float_ = 4321f; | |
| ser.double_ = 6543.0; | |
| ser.boolean_ = false; | |
| ser.ser = new Ser3(0x70b030a0); | |
| // first, ensure that each field gets written | |
| MethodHandle writeObject = factory.defaultWriteObjectForSerialization(Ser2.class); | |
| Assert.assertNotNull(writeObject, "writeObject not created"); | |
| boolean[] called = new boolean[19]; | |
| @SuppressWarnings("removal") | |
| ObjectOutputStream oos = new ObjectOutputStream() { | |
| protected void writeObjectOverride(final Object obj) throws IOException { | |
| throw new IOException("Wrong method called"); | |
| } | |
| public void defaultWriteObject() throws IOException { | |
| throw new IOException("Wrong method called"); | |
| } | |
| public void writeFields() { | |
| called[18] = true; | |
| } | |
| public PutField putFields() { | |
| return new PutField() { | |
| public void put(final String name, final boolean val) { | |
| switch (name) { | |
| case "boolean_" -> { | |
| Assert.assertFalse(val); | |
| called[0] = true; | |
| } | |
| case "final_boolean" -> { | |
| Assert.assertTrue(val); | |
| called[1] = true; | |
| } | |
| default -> throw new Error("Unexpected field " + name); | |
| } | |
| } | |
| public void put(final String name, final byte val) { | |
| switch (name) { | |
| case "byte_" -> { | |
| Assert.assertEquals(val, (byte) 0x44); | |
| called[2] = true; | |
| } | |
| case "final_byte" -> { | |
| Assert.assertEquals(val, (byte) 0x33); | |
| called[3] = true; | |
| } | |
| default -> throw new Error("Unexpected field " + name); | |
| } | |
| } | |
| public void put(final String name, final char val) { | |
| switch (name) { | |
| case "char_" -> { | |
| Assert.assertEquals(val, (char) 0x6593); | |
| called[4] = true; | |
| } | |
| case "final_char" -> { | |
| Assert.assertEquals(val, (char) 0x5342); | |
| called[5] = true; | |
| } | |
| default -> throw new Error("Unexpected field " + name); | |
| } | |
| } | |
| public void put(final String name, final short val) { | |
| switch (name) { | |
| case "short_" -> { | |
| Assert.assertEquals(val, (short) 0x3355); | |
| called[6] = true; | |
| } | |
| case "final_short" -> { | |
| Assert.assertEquals(val, (short) 0x2244); | |
| called[7] = true; | |
| } | |
| default -> throw new Error("Unexpected field " + name); | |
| } | |
| } | |
| public void put(final String name, final int val) { | |
| switch (name) { | |
| case "int_" -> { | |
| Assert.assertEquals(val, 0x4928a299); | |
| called[8] = true; | |
| } | |
| case "final_int" -> { | |
| Assert.assertEquals(val, 0x05382716); | |
| called[9] = true; | |
| } | |
| default -> throw new Error("Unexpected field " + name); | |
| } | |
| } | |
| public void put(final String name, final long val) { | |
| switch (name) { | |
| case "long_" -> { | |
| Assert.assertEquals(val, 0x24aa19883f4b9138L); | |
| called[10] = true; | |
| } | |
| case "final_long" -> { | |
| Assert.assertEquals(val, 0xf035a73b09113bacL); | |
| called[11] = true; | |
| } | |
| default -> throw new Error("Unexpected field " + name); | |
| } | |
| } | |
| public void put(final String name, final float val) { | |
| switch (name) { | |
| case "float_" -> { | |
| Assert.assertEquals(val, 4321f); | |
| called[12] = true; | |
| } | |
| case "final_float" -> { | |
| Assert.assertEquals(val, 1234f); | |
| called[13] = true; | |
| } | |
| default -> throw new Error("Unexpected field " + name); | |
| } | |
| } | |
| public void put(final String name, final double val) { | |
| switch (name) { | |
| case "double_" -> { | |
| Assert.assertEquals(val, 6543.0); | |
| called[14] = true; | |
| } | |
| case "final_double" -> { | |
| Assert.assertEquals(val, 3456.0); | |
| called[15] = true; | |
| } | |
| default -> throw new Error("Unexpected field " + name); | |
| } | |
| } | |
| public void put(final String name, final Object val) { | |
| switch (name) { | |
| case "ser" -> { | |
| Assert.assertEquals(val, new Ser3(0x70b030a0)); | |
| called[16] = true; | |
| } | |
| case "final_ser" -> { | |
| Assert.assertEquals(val, new Ser3(0x004917aa)); | |
| called[17] = true; | |
| } | |
| default -> throw new Error("Unexpected field " + name); | |
| } | |
| } | |
| @SuppressWarnings("removal") | |
| public void write(final ObjectOutput out) throws IOException { | |
| throw new IOException("Wrong method called"); | |
| } | |
| }; | |
| } | |
| }; | |
| writeObject.invokeExact(ser, oos); | |
| for (int i = 0; i < 19; i ++) { | |
| Assert.assertTrue(called[i], names[i]); | |
| } | |
| // now, test the read side | |
| MethodHandle readObject = factory.defaultReadObjectForSerialization(Ser2.class); | |
| Assert.assertNotNull(readObject, "readObject not created"); | |
| @SuppressWarnings("removal") | |
| ObjectInputStream ois = new ObjectInputStream() { | |
| protected Object readObjectOverride() throws IOException { | |
| throw new IOException("Wrong method called"); | |
| } | |
| public GetField readFields() { | |
| return new GetField() { | |
| public ObjectStreamClass getObjectStreamClass() { | |
| throw new Error("Wrong method called"); | |
| } | |
| public boolean defaulted(final String name) throws IOException { | |
| throw new IOException("Wrong method called"); | |
| } | |
| public boolean get(final String name, final boolean val) { | |
| return switch (name) { | |
| case "boolean_" -> { | |
| called[0] = true; | |
| yield true; | |
| } | |
| case "final_boolean" -> { | |
| called[1] = true; | |
| yield true; | |
| } | |
| default -> throw new Error("Unexpected field " + name); | |
| }; | |
| } | |
| public byte get(final String name, final byte val) { | |
| return switch (name) { | |
| case "byte_" -> { | |
| called[2] = true; | |
| yield (byte) 0x11; | |
| } | |
| case "final_byte" -> { | |
| called[3] = true; | |
| yield (byte) 0x9f; | |
| } | |
| default -> throw new Error("Unexpected field " + name); | |
| }; | |
| } | |
| public char get(final String name, final char val) { | |
| return switch (name) { | |
| case "char_" -> { | |
| called[4] = true; | |
| yield (char) 0x59a2; | |
| } | |
| case "final_char" -> { | |
| called[5] = true; | |
| yield (char) 0xe0d0; | |
| } | |
| default -> throw new Error("Unexpected field " + name); | |
| }; | |
| } | |
| public short get(final String name, final short val) { | |
| return switch (name) { | |
| case "short_" -> { | |
| called[6] = true; | |
| yield (short) 0x0917; | |
| } | |
| case "final_short" -> { | |
| called[7] = true; | |
| yield (short) 0x110e; | |
| } | |
| default -> throw new Error("Unexpected field " + name); | |
| }; | |
| } | |
| public int get(final String name, final int val) { | |
| return switch (name) { | |
| case "int_" -> { | |
| called[8] = true; | |
| yield 0xd0244e19; | |
| } | |
| case "final_int" -> { | |
| called[9] = true; | |
| yield 0x011004da; | |
| } | |
| default -> throw new Error("Unexpected field " + name); | |
| }; | |
| } | |
| public long get(final String name, final long val) { | |
| return switch (name) { | |
| case "long_" -> { | |
| called[10] = true; | |
| yield 0x0b8101d84aa31711L; | |
| } | |
| case "final_long" -> { | |
| called[11] = true; | |
| yield 0x30558aa7189ed821L; | |
| } | |
| default -> throw new Error("Unexpected field " + name); | |
| }; | |
| } | |
| public float get(final String name, final float val) { | |
| return switch (name) { | |
| case "float_" -> { | |
| called[12] = true; | |
| yield 0x5.01923ap18f; | |
| } | |
| case "final_float" -> { | |
| called[13] = true; | |
| yield 0x0.882afap1f; | |
| } | |
| default -> throw new Error("Unexpected field " + name); | |
| }; | |
| } | |
| public double get(final String name, final double val) { | |
| return switch (name) { | |
| case "double_" -> { | |
| called[14] = true; | |
| yield 0x9.4a8fp6; | |
| } | |
| case "final_double" -> { | |
| called[15] = true; | |
| yield 0xf.881a8p4; | |
| } | |
| default -> throw new Error("Unexpected field " + name); | |
| }; | |
| } | |
| public Object get(final String name, final Object val) { | |
| return switch (name) { | |
| case "ser" -> { | |
| called[16] = true; | |
| yield new Ser3(0x44cc55dd); | |
| } | |
| case "final_ser" -> { | |
| called[17] = true; | |
| yield new Ser3(0x9a8b7c6d); | |
| } | |
| default -> throw new Error("Unexpected field " + name); | |
| }; | |
| } | |
| }; | |
| } | |
| }; | |
| // all the same methods, except for `writeFields` | |
| Arrays.fill(called, false); | |
| Constructor<?> ctor = factory.newConstructorForSerialization(Ser2.class, Object.class.getDeclaredConstructor()); | |
| ser = (Ser2) ctor.newInstance(); | |
| readObject.invokeExact(ser, ois); | |
| // excluding "writeFields", so 18 instead of 19 | |
| for (int i = 0; i < 18; i ++) { | |
| Assert.assertTrue(called[i], names[i]); | |
| } | |
| Assert.assertEquals(ser.byte_, (byte)0x11); | |
| Assert.assertEquals(ser.final_byte, (byte)0x9f); | |
| Assert.assertEquals(ser.char_, (char)0x59a2); | |
| Assert.assertEquals(ser.final_char, (char)0xe0d0); | |
| Assert.assertEquals(ser.short_, (short)0x0917); | |
| Assert.assertEquals(ser.final_short, (short)0x110e); | |
| Assert.assertEquals(ser.int_, 0xd0244e19); | |
| Assert.assertEquals(ser.final_int, 0x011004da); | |
| Assert.assertEquals(ser.long_, 0x0b8101d84aa31711L); | |
| Assert.assertEquals(ser.final_long, 0x30558aa7189ed821L); | |
| Assert.assertEquals(ser.float_, 0x5.01923ap18f); | |
| Assert.assertEquals(ser.final_float, 0x0.882afap1f); | |
| Assert.assertEquals(ser.double_, 0x9.4a8fp6); | |
| Assert.assertEquals(ser.final_double, 0xf.881a8p4); | |
| Assert.assertEquals(ser.ser, new Ser3(0x44cc55dd)); | |
| Assert.assertEquals(ser.final_ser, new Ser3(0x9a8b7c6d)); | |
| } | |
| static class Ser2 implements Serializable { | |
| @Serial | |
| private static final long serialVersionUID = -2852896623833548574L; | |
| byte byte_; | |
| short short_; | |
| char char_; | |
| int int_; | |
| long long_; | |
| float float_; | |
| double double_; | |
| boolean boolean_; | |
| Ser3 ser; | |
| final byte final_byte; | |
| final short final_short; | |
| final char final_char; | |
| final int final_int; | |
| final long final_long; | |
| final float final_float; | |
| final double final_double; | |
| final boolean final_boolean; | |
| final Ser3 final_ser; | |
| Ser2(final byte final_byte, final short final_short, final char final_char, final int final_int, | |
| final long final_long, final float final_float, final double final_double, | |
| final boolean final_boolean, final Ser3 final_ser) { | |
| this.final_byte = final_byte; | |
| this.final_short = final_short; | |
| this.final_char = final_char; | |
| this.final_int = final_int; | |
| this.final_long = final_long; | |
| this.final_float = final_float; | |
| this.final_double = final_double; | |
| this.final_boolean = final_boolean; | |
| this.final_ser = final_ser; | |
| } | |
| } | |
| static class Ser3 implements Serializable { | |
| @Serial | |
| private static final long serialVersionUID = -1234752876749422678L; | |
| @Serial | |
| private static final ObjectStreamField[] serialPersistentFields = { | |
| new ObjectStreamField("value", int.class) | |
| }; | |
| final int value; | |
| Ser3(final int value) { | |
| this.value = value; | |
| } | |
| public boolean equals(final Object obj) { | |
| return obj instanceof Ser3 s && value == s.value; | |
| } | |
| public int hashCode() { | |
| return value; | |
| } | |
| } | |
| static class SerInvalidFields implements Serializable { | |
| // this is deliberately wrong | |
| @SuppressWarnings({"unused", "serial"}) | |
| @Serial | |
| private static final String serialPersistentFields = "Oops!"; | |
| @Serial | |
| private static final long serialVersionUID = -8090960816811629489L; | |
| } | |
| static class Ext1 implements Externalizable { | |
| @Serial | |
| private static final long serialVersionUID = 7109990719266285013L; | |
| public void writeExternal(final ObjectOutput objectOutput) { | |
| } | |
| public void readExternal(final ObjectInput objectInput) { | |
| } | |
| } | |
| static class Ext2 implements Externalizable { | |
| public void writeExternal(final ObjectOutput objectOutput) { | |
| } | |
| public void readExternal(final ObjectInput objectInput) { | |
| } | |
| } | |
| record Rec1(int hello, boolean world) implements Serializable { | |
| @Serial | |
| private static final long serialVersionUID = 12349876L; | |
| } | |
| enum Enum1 { | |
| hello, | |
| world, | |
| ; | |
| private static final long serialVersionUID = 1020304050L; | |
| } | |
| interface Proxy1 { | |
| void hello(); | |
| } | |
| static class SerialPersistentFields implements Serializable { | |
| @Serial | |
| private static final long serialVersionUID = -4947917866973382882L; | |
| @Serial | |
| private static final ObjectStreamField[] serialPersistentFields = { | |
| new ObjectStreamField("array1", Object[].class), | |
| new ObjectStreamField("nonExistent", String.class) | |
| }; | |
| private int int1; | |
| private Object[] array1; | |
| } | |
| // Check our simple accessors | |
| @Test | |
| static void testAccessors() { | |
| Assert.assertEquals(factory.serialPersistentFields(Ser3.class), Ser3.serialPersistentFields); | |
| Assert.assertNotSame(factory.serialPersistentFields(Ser3.class), Ser3.serialPersistentFields); | |
| Assert.assertNull(factory.serialPersistentFields(SerInvalidFields.class)); | |
| } | |
| // Ensure that classes with serialPersistentFields do not allow default setting/getting | |
| @Test | |
| static void testDisallowed() { | |
| Assert.assertNull(factory.defaultWriteObjectForSerialization(SerialPersistentFields.class)); | |
| Assert.assertNull(factory.defaultReadObjectForSerialization(SerialPersistentFields.class)); | |
| } | |
| // 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(); | |
| } | |
| } |