20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 */
23
24 /**
25 * @test
26 * @bug 8199852
27 * @summary Test exception messages of LinkageError. A class loader loads
28 * twice the same class. Should trigger exception in
29 * SystemDictionary::check_constraints().
30 * @compile ../common/Foo.java
31 * @compile ../common/J.java
32 * ../common/PreemptingClassLoader.java
33 * @run main/othervm Test
34 */
35
36 public class Test {
37
38 // Check that all names have external formatting ('.' and not '/' in package names).
39 // Check for parent of class loader.
40 static String expectedErrorMessage1 =
41 "loader \"<unnamed>\" (instance of PreemptingClassLoader, " +
42 "child of \"app\" jdk.internal.loader.ClassLoaders$AppClassLoader) " +
43 "attempted duplicate class definition for test.Foo.";
44
45 // Check that all names have external formatting ('.' and not '/' in package names).
46 // Check for name and parent of class loader.
47 static String expectedErrorMessage2 =
48 "loader \"DuplicateLE_Test_Loader\" (instance of PreemptingClassLoader, " +
49 "child of \"app\" jdk.internal.loader.ClassLoaders$AppClassLoader) " +
50 "attempted duplicate class definition for test.Foo.";
51
52 // Check that all names have external formatting ('.' and not '/' in package names).
53 // Check for name and parent of class loader. Type should be mentioned as 'interface'.
54 static String expectedErrorMessage3 =
55 "loader \"DuplicateLE_Test_Loader_IF\" (instance of PreemptingClassLoader, " +
56 "child of \"app\" jdk.internal.loader.ClassLoaders$AppClassLoader) " +
57 "attempted duplicate interface definition for test.J.";
58
59 // Test that the error message is correct when a loader constraint error is
60 // detected during vtable creation.
61 //
62 // In this test, during vtable creation for class Task, method "Task.m()LFoo;"
63 // overrides "J.m()LFoo;". But, Task's class Foo and super type J's class Foo
64 // are different. So, a LinkageError exception should be thrown because the
65 // loader constraint check will fail.
66 public static void test(String loaderName, String expectedErrorMessage, String testType) throws Exception {
67 String[] classNames = {testType};
68 ClassLoader l = new PreemptingClassLoader(loaderName, classNames, false);
69 l.loadClass(testType);
70 try {
71 l.loadClass(testType).newInstance();
72 throw new RuntimeException("Expected LinkageError exception not thrown");
73 } catch (LinkageError e) {
74 String errorMsg = e.getMessage();
75 if (!errorMsg.equals(expectedErrorMessage)) {
76 System.out.println("Expected: " + expectedErrorMessage + "\n" +
77 "but got: " + errorMsg);
78 throw new RuntimeException("Wrong LinkageError exception thrown: " + errorMsg);
79 }
80 System.out.println("Passed with message: " + errorMsg);
81 }
82 }
83
84 public static void main(String args[]) throws Exception {
85 test(null, expectedErrorMessage1, "test.Foo");
86 test("DuplicateLE_Test_Loader", expectedErrorMessage2, "test.Foo");
87 test("DuplicateLE_Test_Loader_IF", expectedErrorMessage3, "test.J");
88 }
89 }
90
|
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 */
23
24 /**
25 * @test
26 * @bug 8199852
27 * @summary Test exception messages of LinkageError. A class loader loads
28 * twice the same class. Should trigger exception in
29 * SystemDictionary::check_constraints().
30 * @compile ../common/Foo.java
31 * @compile ../common/J.java
32 * ../common/PreemptingClassLoader.java
33 * @run main/othervm Test
34 */
35
36 public class Test {
37
38 // Check that all names have external formatting ('.' and not '/' in package names).
39 // Check for parent of class loader.
40 // Break each expectedErrorMessage into 2 parts due to the class loader name containing
41 // the unique @<id> identity hash which cannot be compared against.
42 static String expectedErrorMessage1_part1 = "loader PreemptingClassLoader @";
43 static String expectedErrorMessage1_part2 =
44 " (instance of PreemptingClassLoader, " +
45 "child of 'app' jdk.internal.loader.ClassLoaders$AppClassLoader) " +
46 "attempted duplicate class definition for test.Foo.";
47
48
49 // Check that all names have external formatting ('.' and not '/' in package names).
50 // Check for name and parent of class loader.
51 static String expectedErrorMessage2_part1 = "loader 'DuplicateLE_Test_Loader' @";
52 static String expectedErrorMessage2_part2 =
53 " (instance of PreemptingClassLoader, " +
54 "child of 'app' jdk.internal.loader.ClassLoaders$AppClassLoader) " +
55 "attempted duplicate class definition for test.Foo.";
56
57
58 // Check that all names have external formatting ('.' and not '/' in package names).
59 // Check for name and parent of class loader. Type should be mentioned as 'interface'.
60 static String expectedErrorMessage3_part1 = "loader 'DuplicateLE_Test_Loader_IF' @";
61 static String expectedErrorMessage3_part2 =
62 " (instance of PreemptingClassLoader, " +
63 "child of 'app' jdk.internal.loader.ClassLoaders$AppClassLoader) " +
64 "attempted duplicate interface definition for test.J.";
65
66 // Test that the error message is correct when a loader constraint error is
67 // detected during vtable creation.
68 //
69 // In this test, during vtable creation for class Task, method "Task.m()LFoo;"
70 // overrides "J.m()LFoo;". But, Task's class Foo and super type J's class Foo
71 // are different. So, a LinkageError exception should be thrown because the
72 // loader constraint check will fail.
73 public static void test(String loaderName, String expectedErrorMessage_part1,
74 String expectedErrorMessage_part2, String testType) throws Exception {
75 String[] classNames = {testType};
76 ClassLoader l = new PreemptingClassLoader(loaderName, classNames, false);
77 l.loadClass(testType);
78 try {
79 l.loadClass(testType).newInstance();
80 throw new RuntimeException("Expected LinkageError exception not thrown");
81 } catch (LinkageError e) {
82 String errorMsg = e.getMessage();
83 if (!errorMsg.contains(expectedErrorMessage_part1) ||
84 !errorMsg.contains(expectedErrorMessage_part2)) {
85 System.out.println("Expected: " + expectedErrorMessage_part1 + "<id>" + expectedErrorMessage_part2 + "\n" +
86 "but got: " + errorMsg);
87 throw new RuntimeException("Wrong LinkageError exception thrown: " + errorMsg);
88 }
89 System.out.println("Passed with message: " + errorMsg);
90 }
91 }
92
93 public static void main(String args[]) throws Exception {
94 test(null, expectedErrorMessage1_part1, expectedErrorMessage1_part2, "test.Foo");
95 test("DuplicateLE_Test_Loader", expectedErrorMessage2_part1, expectedErrorMessage2_part2, "test.Foo");
96 test("DuplicateLE_Test_Loader_IF", expectedErrorMessage3_part1, expectedErrorMessage3_part2, "test.J");
97 }
98 }
99
|