diff -r e9a1638b8cea -r 871b2f487dc0 hotspot/test/runtime/lambda-features/InterfaceInitializationStates.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/hotspot/test/runtime/lambda-features/InterfaceInitializationStates.java Wed Sep 21 09:56:18 2016 -0400 @@ -0,0 +1,202 @@ +/* + * 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. + * + */ + +/* + * @test + * @bug 8163969 + * @summary Test interface initialization states and when certain interfaces are initialized + * in the presence of initialization errors. + * @run main InterfaceInitializationStates + */ + +import java.util.List; +import java.util.Arrays; +import java.util.ArrayList; + +public class InterfaceInitializationStates { + + static List> cInitOrder = new ArrayList<>(); + + // K interface with a default method has an initialization error + interface K { + boolean v = InterfaceInitializationStates.out(K.class); + static final Object CONST = InterfaceInitializationStates.someMethod(); + default int method() { return 2; } + } + + // I is initialized when CONST is used, and doesn't trigger initialization of K, + // I also doesn't get an initialization error just because K has an initialization error. + interface I extends K { + boolean v = InterfaceInitializationStates.out(I.class); + static final Object CONST = InterfaceInitializationStates.someMethod(); + } + + // L can be fully initialized even though it extends an interface that has an + // initialization error + interface L extends K { + boolean v = InterfaceInitializationStates.out(L.class); + default void lx() {} + static void func() { + System.out.println("Calling function on interface with bad super interface."); + } + } + + // Another interface needing initialization. + // Initialization of this interface does not occur with ClassLIM because K throws + // an initialization error, so the interface initialization is abandoned + interface M { + boolean v = InterfaceInitializationStates.out(M.class); + default void mx() {} + } + + static class ClassLIM implements L, I, M { + boolean v = InterfaceInitializationStates.out(ClassLIM.class); + int callMethodInK() { return method(); } + static { + // Since interface initialization of K fails, this should never be called + System.out.println("Initializing C, but L is still good"); + L.func(); + } + } + + // Finally initialize M + static class ClassM implements M { + boolean v = InterfaceInitializationStates.out(ClassM.class); + } + + // Iunlinked is testing initialization like interface I, except interface I is linked when + // ClassLIM is linked. + // Iunlinked is not linked already when K gets an initialization error. Linking Iunlinked + // should succeed and not get NoClassDefFoundError because it does not depend on the + // initialization state of K for linking. There's bug now where it gets this error. + // See: https://bugs.openjdk.java.net/browse/JDK-8166203. + interface Iunlinked extends K { + boolean v = InterfaceInitializationStates.out(Iunlinked.class); + } + + // More tests. What happens if we use K for parameters and return types? + // K is a symbolic reference in the constant pool and the initialization error only + // matters when it's used. + interface Iparams { + boolean v = InterfaceInitializationStates.out(Iparams.class); + K the_k = null; + K m(K k); // abstract + default K method() { return new K(){}; } + } + + static class ClassIparams implements Iparams { + boolean v = InterfaceInitializationStates.out(ClassIparams.class); + public K m(K k) { return k; } + } + + public static void main(java.lang.String[] unused) { + // The rule this tests is the last sentence of JLS 12.4.1: + + // When a class is initialized, its superclasses are initialized (if they have not + // been previously initialized), as well as any superinterfaces (s8.1.5) that declare any + // default methods (s9.4.3) (if they have not been previously initialized). Initialization + // of an interface does not, of itself, cause initialization of any of its superinterfaces. + + // Trigger initialization. + // Now L is fully_initialized even though K should + // throw an error during initialization. + boolean v = L.v; + L.func(); + + try { + ClassLIM c = new ClassLIM(); // is K initialized, with a perfectly good L in the middle + // was bug: this used to succeed and be able to callMethodInK(). + throw new RuntimeException("FAIL exception not thrown for class"); + } catch (ExceptionInInitializerError e) { + System.out.println("ExceptionInInitializerError thrown as expected"); + } + + // Test that K already has initialization error so gets ClassNotFoundException because + // initialization was attempted with ClassLIM. + try { + Class.forName("InterfaceInitializationStates$K", true, InterfaceInitializationStates.class.getClassLoader()); + throw new RuntimeException("FAIL exception not thrown for forName(K)"); + } catch(ClassNotFoundException e) { + throw new RuntimeException("ClassNotFoundException should not be thrown"); + } catch(NoClassDefFoundError e) { + System.out.println("NoClassDefFoundError thrown as expected"); + } + + new ClassM(); + + // Initialize I, which doesn't cause K (super interface) to be initialized. + // Since the initialization of I does _not_ cause K to be initialized, it does + // not get NoClassDefFoundError because K is erroneous. + // But the initialization of I throws RuntimeException, so we expect + // ExceptionInInitializerError. + try { + Object ii = I.CONST; + throw new RuntimeException("FAIL exception not thrown for I's initialization"); + } catch (ExceptionInInitializerError e) { + System.out.println("ExceptionInInitializerError as expected"); + } + + // Initialize Iunlinked. This should not get NoClassDefFoundError because K + // (its super interface) is in initialization_error state. + // This is a bug. It does now. + try { + boolean bb = Iunlinked.v; + throw new RuntimeException("FAIL exception not thrown for Iunlinked initialization"); + } catch(NoClassDefFoundError e) { + System.out.println("NoClassDefFoundError thrown because of bug"); + } + + // This should be okay + boolean value = Iparams.v; + System.out.println("value is " + value); + + ClassIparams p = new ClassIparams(); + try { + // Now we get an error because K got an initialization_error + K kk = p.method(); + throw new RuntimeException("FAIL exception not thrown for calling method for K"); + } catch(NoClassDefFoundError e) { + System.out.println("NoClassDefFoundError thrown as expected"); + } + + // Check expected class initialization order + List> expectedCInitOrder = Arrays.asList(L.class, K.class, M.class, ClassM.class, + I.class, Iparams.class, + ClassIparams.class); + if (!cInitOrder.equals(expectedCInitOrder)) { + throw new RuntimeException( + String.format("Class initialization array %s not equal to expected array %s", + cInitOrder, expectedCInitOrder)); + } + } + + static boolean out(Class c) { + System.out.println("#: initializing " + c.getName()); + cInitOrder.add(c); + return true; + } + static Object someMethod() { + throw new RuntimeException(); + } +}