test/jdk/java/io/Serializable/records/AbsentStreamValuesTest.java - master - niceSOFT/openjdk21

test/jdk/java/io/Serializable/records/AbsentStreamValuesTest.java
175 строк6 KB
Roland Mesde
8373623: Refactor Serialization tests for Records to JUnit
13 апр 2026, 19:53
13 апр 2026, 19:53598aac9
/*
 * Copyright (c) 2019, 2025, 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.
 */

/*
 * @test
 * @bug 8246774
 * @summary Checks that the appropriate default value is given to the canonical ctr
 * @run junit AbsentStreamValuesTest
 * @run junit/othervm/java.security.policy=empty_security.policy AbsentStreamValuesTest
 */

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.Serializable;
import static java.io.ObjectStreamConstants.*;
import static java.lang.System.out;

import static org.junit.jupiter.api.Assertions.*;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestInstance;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.MethodSource;

/**
 * Basic test to check that default primitive / reference values are presented
 * to the record's canonical constructor, for fields not in the stream.
 */
@TestInstance(TestInstance.Lifecycle.PER_CLASS)
public class AbsentStreamValuesTest {

    record R01(boolean  x) implements Serializable { }
    record R02(byte     x) implements Serializable { }
    record R03(short    x) implements Serializable { }
    record R04(char     x) implements Serializable { }
    record R05(int      x) implements Serializable { }
    record R06(long     x) implements Serializable { }
    record R07(float    x) implements Serializable { }
    record R08(double   x) implements Serializable { }
    record R09(Object   x) implements Serializable { }
    record R10(String   x) implements Serializable { }
    record R11(int[]    x) implements Serializable { }
    record R12(Object[] x) implements Serializable { }
    record R13(R12      x) implements Serializable { }
    record R14(R13[]    x) implements Serializable { }

    public Object[][] recordTypeAndExpectedValue() {
        return new Object[][] {
                new Object[] { R01.class, false    },
                new Object[] { R02.class, (byte)0  },
                new Object[] { R03.class, (short)0 },
                new Object[] { R04.class, '\u0000' },
                new Object[] { R05.class, 0        },
                new Object[] { R06.class, 0L       },
                new Object[] { R07.class, 0.0f     },
                new Object[] { R08.class, 0.0d     },
                new Object[] { R09.class, null     },
                new Object[] { R10.class, null     },
                new Object[] { R11.class, null     },
                new Object[] { R12.class, null     },
                new Object[] { R13.class, null     },
                new Object[] { R14.class, null     },
        };
    }

    @ParameterizedTest
    @MethodSource("recordTypeAndExpectedValue")
    public void testWithDifferentTypes(Class<?> clazz, Object expectedXValue)
        throws Exception
    {
        out.println("\n---");
        assert clazz.isRecord();
        byte[] bytes = minimalByteStreamFor(clazz.getName());

        Object obj = deserialize(bytes);
        out.println("deserialized: " + obj);
        Object actualXValue = clazz.getDeclaredMethod("x").invoke(obj);
        assertEquals(expectedXValue, actualXValue);
    }

    // --- all together

    record R15(boolean a, byte b, short c, char d, int e, long f, float g, double h, Object i, String j, long[] k, Object[] l)
        implements Serializable { }

    @Test
    public void testWithAllTogether() throws Exception {
        out.println("\n---");
        byte[] bytes = minimalByteStreamFor(R15.class.getName());

        R15 obj = (R15)deserialize(bytes);
        out.println("deserialized: " + obj);
        assertEquals(false, obj.a);
        assertEquals(0, obj.b);
        assertEquals(0, obj.c);
        assertEquals('\u0000', obj.d);
        assertEquals(0, obj.e);
        assertEquals(0l, obj.f);
        assertEquals(0f, obj.g);
        assertEquals(0d, obj.h);
        assertEquals(null, obj.i);
        assertEquals(null, obj.j);
        assertEquals(null, obj.k);
        assertEquals(null, obj.l);
    }

    // --- generic type

    record R16<T, U>(T t, U u) implements Serializable { }

    @Test
    public void testGenericType() throws Exception {
        out.println("\n---");
        byte[] bytes = minimalByteStreamFor(R16.class.getName());

        R16 obj = (R16)deserialize(bytes);
        out.println("deserialized: " + obj);
        assertEquals(null, obj.t);
        assertEquals(null, obj.u);
    }

    // --- infra

    /**
     * Returns the serial bytes for the given class name. The stream
     * will have no stream field values.
     */
    static byte[] minimalByteStreamFor(String className) throws Exception {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        DataOutputStream dos = new DataOutputStream(baos);
        dos.writeShort(STREAM_MAGIC);
        dos.writeShort(STREAM_VERSION);
        dos.writeByte(TC_OBJECT);
        dos.writeByte(TC_CLASSDESC);
        dos.writeUTF(className);
        dos.writeLong(0L);
        dos.writeByte(SC_SERIALIZABLE);
        dos.writeShort(0);             // number of fields
        dos.writeByte(TC_ENDBLOCKDATA);   // no annotations
        dos.writeByte(TC_NULL);           // no superclasses
        dos.close();
        return baos.toByteArray();
    }

    @SuppressWarnings("unchecked")
    static <T> T deserialize(byte[] streamBytes)
        throws IOException, ClassNotFoundException
    {
        ByteArrayInputStream bais = new ByteArrayInputStream(streamBytes);
        ObjectInputStream ois  = new ObjectInputStream(bais);
        return (T) ois.readObject();
    }
}