1 /* 2 * Copyright (c) 2020, 2024, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. 8 * 9 * This code is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12 * version 2 for more details (a copy is included in the LICENSE file that 13 * accompanied this code). 14 * 15 * You should have received a copy of the GNU General Public License version 16 * 2 along with this work; if not, write to the Free Software Foundation, 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 18 * 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20 * or visit www.oracle.com if you need additional information or have any 21 * questions. 22 */ 23 24 /* 25 * @test 26 * @bug 8255560 8326879 27 * @summary Class::isRecord should check that the current class is final and not abstract 28 * @modules java.base/jdk.internal.org.objectweb.asm 29 * @library /test/lib 30 * @run testng/othervm IsRecordTest 31 * @run testng/othervm --enable-preview IsRecordTest 32 * @run testng/othervm/java.security.policy=allPermissions.policy IsRecordTest 33 */ 34 35 import java.io.IOException; 36 import java.io.UncheckedIOException; 37 import java.util.List; 38 import java.util.Map; 39 import jdk.internal.org.objectweb.asm.ClassWriter; 40 import jdk.internal.org.objectweb.asm.Opcodes; 41 import jdk.test.lib.ByteCodeLoader; 42 import org.testng.annotations.DataProvider; 43 import org.testng.annotations.Test; 44 import static java.lang.System.out; 45 import static jdk.internal.org.objectweb.asm.ClassWriter.*; 46 import static org.testng.Assert.assertEquals; 47 import static org.testng.Assert.assertFalse; 48 import static org.testng.Assert.assertTrue; 49 50 public class IsRecordTest { 51 52 @DataProvider(name = "scenarios") 53 public Object[][] scenarios() { 54 return new Object[][] { 55 // isFinal, isAbstract, extendJLR, withRecAttr, expectIsRecord 56 { false, false, false, true, false }, 57 { false, false, true, true, false }, 58 { false, true, false, true, false }, 59 { false, true, true, true, false }, 60 { true, false, false, true, false }, 61 { true, false, true, true, true }, 62 63 { false, false, false, false, false }, 64 { false, false, true, false, false }, 65 { false, true, false, false, false }, 66 { false, true, true, false, false }, 67 { true, false, false, false, false }, 68 { true, false, true, false, false }, 69 }; 70 } 71 72 /** 73 * Tests the valid combinations of i) final/non-final, ii) abstract/non-abstract, 74 * iii) direct subclass of j.l.Record (or not), along with the presence or 75 * absence of a record attribute. 76 */ 77 @Test(dataProvider = "scenarios") 78 public void testDirectSubClass(boolean isFinal, 79 boolean isAbstract, 80 boolean extendsJLR, 81 boolean withRecordAttr, 82 boolean expectIsRecord) throws Exception { 83 out.println("\n--- testDirectSubClass isFinal=%s, isAbstract=%s, extendsJLR=%s, withRecordAttr=%s, expectIsRecord=%s ---" 84 .formatted(isFinal, isAbstract, extendsJLR, withRecordAttr, expectIsRecord)); 85 86 List<RecordComponentEntry> rc = null; 87 if (withRecordAttr) 88 rc = List.of(new RecordComponentEntry("x", "I")); 89 String superName = extendsJLR ? "java/lang/Record" : "java/lang/Object"; 90 var classBytes = generateClassBytes("C", isFinal, isAbstract, superName, rc); 91 Class<?> cls = ByteCodeLoader.load("C", classBytes); 92 out.println("cls=%s, Record::isAssignable=%s, isRecord=%s" 93 .formatted(cls, Record.class.isAssignableFrom(cls), cls.isRecord())); 94 assertEquals(cls.isRecord(), expectIsRecord); 95 var getRecordComponents = cls.getRecordComponents(); 96 assertTrue(expectIsRecord ? getRecordComponents != null : getRecordComponents == null); 97 } 98 99 /** 100 * Tests the valid combinations of i) final/non-final, ii) abstract/non-abstract, 101 * along with the presence or absence of a record attribute, where the class has 102 * a superclass whose superclass is j.l.Record. 103 */ 104 @Test(dataProvider = "scenarios") 105 public void testIndirectSubClass(boolean isFinal, 106 boolean isAbstract, 107 boolean unused1, 108 boolean withRecordAttr, 109 boolean unused2) throws Exception { 110 out.println("\n--- testIndirectSubClass isFinal=%s, isAbstract=%s withRecordAttr=%s ---" 111 .formatted(isFinal, isAbstract, withRecordAttr)); 112 113 List<RecordComponentEntry> rc = null; 114 if (withRecordAttr) 115 rc = List.of(new RecordComponentEntry("x", "I")); 116 var supFooClassBytes = generateClassBytes("SupFoo", false, isAbstract, "java/lang/Record", rc); 117 var subFooClassBytes = generateClassBytes("SubFoo", isFinal, isAbstract, "SupFoo", rc); 118 var allClassBytes = Map.of("SupFoo", supFooClassBytes, 119 "SubFoo", subFooClassBytes); 120 121 ClassLoader loader = new ByteCodeLoader(allClassBytes, null); 122 Class<?> supFooCls = loader.loadClass("SupFoo"); 123 Class<?> subFooCls = loader.loadClass("SubFoo"); 124 for (var cls : List.of(supFooCls, subFooCls)) 125 out.println("cls=%s, Record::isAssignable=%s, isRecord=%s" 126 .formatted(cls, Record.class.isAssignableFrom(cls), cls.isRecord())); 127 assertFalse(supFooCls.isRecord()); 128 assertFalse(subFooCls.isRecord()); 129 assertEquals(supFooCls.getRecordComponents(), null); 130 assertEquals(subFooCls.getRecordComponents(), null); 131 } 132 133 /** Tests record-ness properties of traditionally compiled classes. */ 134 @Test 135 public void testBasicRecords() { 136 out.println("\n--- testBasicRecords ---"); 137 record EmptyRecord () { } 138 assertTrue(EmptyRecord.class.isRecord()); 139 assertEquals(EmptyRecord.class.getRecordComponents().length, 0); 140 141 record FooRecord (int x) { } 142 assertTrue(FooRecord.class.isRecord()); 143 assertTrue(FooRecord.class.getRecordComponents() != null); 144 145 final record FinalFooRecord (int x) { } 146 assertTrue(FinalFooRecord.class.isRecord()); 147 assertTrue(FinalFooRecord.class.getRecordComponents() != null); 148 149 class A { } 150 assertFalse(A.class.isRecord()); 151 assertFalse(A.class.getRecordComponents() != null); 152 153 final class B { } 154 assertFalse(B.class.isRecord()); 155 assertFalse(B.class.getRecordComponents() != null); 156 } 157 158 // -- infra 159 160 // Generates a class with the given properties. 161 byte[] generateClassBytes(String className, 162 boolean isFinal, 163 boolean isAbstract, 164 String superName, 165 List<RecordComponentEntry> components) { 166 ClassWriter cw = new ClassWriter(COMPUTE_MAXS | COMPUTE_FRAMES); 167 168 int access = 0; 169 if (isFinal) 170 access = access | Opcodes.ACC_FINAL; 171 if (isAbstract) 172 access = access | Opcodes.ACC_ABSTRACT; 173 174 cw.visit(Opcodes.V16, 175 access | Opcodes.ACC_IDENTITY, 176 className, 177 null, 178 superName, 179 null); 180 181 if (components != null) 182 components.forEach(rc -> cw.visitRecordComponent(rc.name(), rc.descriptor(), null)); 183 184 cw.visitEnd(); 185 return cw.toByteArray(); 186 } 187 188 record RecordComponentEntry (String name, String descriptor) { } 189 190 }