1 /*
2 * Copyright (c) 2016, 2026, 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 #include "classfile/symbolTable.hpp"
25 #include "classfile/systemDictionary.hpp"
26 #include "classfile/vmClasses.hpp"
27 #include "classfile/vmSymbols.hpp"
28 #include "memory/resourceArea.hpp"
29 #include "oops/instanceKlass.hpp"
30 #include "oops/klass.inline.hpp"
31 #include "oops/method.hpp"
32 #include "runtime/fieldDescriptor.hpp"
33 #include "runtime/interfaceSupport.inline.hpp"
34 #include "unittest.hpp"
35
36 using testing::HasSubstr;
37
38 // Tests for InstanceKlass::is_class_loader_instance_klass() function
39 TEST_VM(InstanceKlass, class_loader_class) {
40 InstanceKlass* klass = vmClasses::ClassLoader_klass();
41 ASSERT_TRUE(klass->is_class_loader_instance_klass());
42 }
43
44 TEST_VM(InstanceKlass, string_klass) {
45 InstanceKlass* klass = vmClasses::String_klass();
46 ASSERT_TRUE(!klass->is_class_loader_instance_klass());
47 }
48
49 TEST_VM(InstanceKlass, class_loader_printer) {
50 ThreadInVMfromNative scope(JavaThread::current());
51 ResourceMark rm;
52 oop loader = SystemDictionary::java_platform_loader();
53 stringStream st;
54 loader->print_on(&st);
55 // See if injected loader_data field is printed in string
56 ASSERT_THAT(st.base(), HasSubstr("injected 'loader_data'")) << "Must contain injected fields";
57 st.reset();
58 // See if mirror injected fields are printed.
59 oop mirror = vmClasses::ClassLoader_klass()->java_mirror();
60 mirror->print_on(&st);
61 ASSERT_THAT(st.base(), HasSubstr("injected 'array_klass'")) << "Must contain injected fields";
62 // We should test other printing functions too.
63 #ifndef PRODUCT
64 st.reset();
65 // method printing is non-product
66 Method* method = vmClasses::ClassLoader_klass()->methods()->at(0); // we know there's a method here!
67 method->print_on(&st);
68 ASSERT_THAT(st.base(), HasSubstr("method holder:")) << "Must contain method_holder field";
69 ASSERT_THAT(st.base(), HasSubstr("'java/lang/ClassLoader'")) << "Must be in ClassLoader";
70 #endif
71 }
72
73 TEST_VM(InstanceKlass, class_flag_printer) {
74 JavaThread* THREAD = JavaThread::current();
75 ThreadInVMfromNative scope(THREAD);
76 ResourceMark rm;
77 stringStream st;
78
79 vmClasses::String_klass()->print_class_flags(&st);
80 ASSERT_STREQ("public final ", st.base());
81
82 st.reset();
83 vmClasses::Runnable_klass()->print_class_flags(&st);
84 ASSERT_STREQ("public interface abstract ", st.base());
85
86 st.reset();
87 Symbol* override_symbol = SymbolTable::new_symbol("java/lang/Override");
88 Klass* override_klass = SystemDictionary::resolve_or_fail(override_symbol, true, THREAD);
89 ASSERT_FALSE(THREAD->has_pending_exception()) << "java/lang/Override must resolve";
90 InstanceKlass::cast(override_klass)->print_class_flags(&st);
91 ASSERT_STREQ("public interface abstract annotation ", st.base());
92
93 st.reset();
94 Symbol* thread_state_symbol = SymbolTable::new_symbol("java/lang/Thread$State");
95 Klass* thread_state_klass = SystemDictionary::resolve_or_fail(thread_state_symbol, true, THREAD);
96 ASSERT_FALSE(THREAD->has_pending_exception()) << "java/lang/Thread$State must resolve";
97 InstanceKlass::cast(thread_state_klass)->print_class_flags(&st);
98 ASSERT_STREQ("public static final enum ", st.base());
99
100 st.reset();
101 Symbol* certificate_rep_symbol = SymbolTable::new_symbol("java/security/cert/Certificate$CertificateRep");
102 Klass* certificate_rep_klass = SystemDictionary::resolve_or_fail(certificate_rep_symbol, true, THREAD);
103 ASSERT_FALSE(THREAD->has_pending_exception()) << "java/security/cert/Certificate$CertificateRep must resolve";
104 InstanceKlass::cast(certificate_rep_klass)->print_class_flags(&st);
105 ASSERT_STREQ("protected static ", st.base());
106
107 st.reset();
108 Symbol* arrays_array_list_symbol = SymbolTable::new_symbol("java/util/Arrays$ArrayList");
109 Klass* arrays_array_list_klass = SystemDictionary::resolve_or_fail(arrays_array_list_symbol, true, THREAD);
110 ASSERT_FALSE(THREAD->has_pending_exception()) << "java/util/Arrays$ArrayList must resolve";
111 InstanceKlass::cast(arrays_array_list_klass)->print_class_flags(&st);
112 ASSERT_STREQ("private static ", st.base());
113 }
114
115 TEST_VM(FieldDescriptor, access_flag_printer) {
116 JavaThread* THREAD = JavaThread::current();
117 ThreadInVMfromNative scope(THREAD);
118 ResourceMark rm;
119 stringStream st;
120
121 InstanceKlass* integer_klass = vmClasses::Integer_klass();
122 Symbol* min_value_symbol = SymbolTable::new_symbol("MIN_VALUE");
123
124 fieldDescriptor fd;
125 ASSERT_TRUE(integer_klass->find_local_field(min_value_symbol, vmSymbols::int_signature(), &fd))
126 << "Integer.MIN_VALUE must exist";
127 fd.print_on(&st);
128 ASSERT_THAT(st.base(), HasSubstr("public static final 'MIN_VALUE' (fields 0x00000008) 'I'")) << "Must print field access flags";
129
130 st.reset();
131 Symbol* thread_state_symbol = SymbolTable::new_symbol("java/lang/Thread$State");
132 Klass* thread_state_klass = SystemDictionary::resolve_or_fail(thread_state_symbol, true, THREAD);
133 ASSERT_FALSE(THREAD->has_pending_exception()) << "java/lang/Thread$State must resolve";
134
135 fieldDescriptor enum_fd;
136 Symbol* enum_symbol = SymbolTable::new_symbol("NEW");
137 Symbol* enum_signature = SymbolTable::new_symbol("Ljava/lang/Thread$State;");
138 ASSERT_TRUE(InstanceKlass::cast(thread_state_klass)->find_local_field(enum_symbol, enum_signature, &enum_fd))
139 << "Thread.State.NEW must exist";
140
141 enum_fd.print_on(&st);
142 ASSERT_THAT(st.base(), HasSubstr("public static final enum 'NEW' (fields 0x00000000) 'Ljava/lang/Thread$State;'"))
143 << "Must print enum field access flags";
144 }
145
146 #ifndef PRODUCT
147 // This class is friends with Method.
148 class MethodTest : public ::testing::Test{
149 public:
150 static void compare_names(Method* method, Symbol* name) {
151 ASSERT_EQ(method->_name, name) << "Method name field isn't set";
152 }
153 };
154
155 TEST_VM(Method, method_name) {
156 InstanceKlass* ik = vmClasses::Object_klass();
157 Symbol* tostring = SymbolTable::new_symbol("toString");
158 Method* method = ik->find_method(tostring, vmSymbols::void_string_signature());
159 ASSERT_TRUE(method != nullptr) << "Object must have toString";
160 MethodTest::compare_names(method, tostring);
161 }
162
163 TEST_VM(Method, access_flag_printer) {
164 ThreadInVMfromNative scope(JavaThread::current());
165 ResourceMark rm;
166 stringStream st;
167
168 InstanceKlass* object_klass = vmClasses::Object_klass();
169 Symbol* wait_symbol = SymbolTable::new_symbol("wait");
170 Method* wait_method = object_klass->find_method(wait_symbol, vmSymbols::long_void_signature());
171 ASSERT_TRUE(wait_method != nullptr) << "Object must have wait(long)";
172 wait_method->print_access_flags(&st);
173 ASSERT_STREQ("public final ", st.base());
174
175 st.reset();
176 Symbol* symbol_hash_code = SymbolTable::new_symbol("hashCode");
177 Method* hash_code = object_klass->find_method(symbol_hash_code, vmSymbols::void_int_signature());
178 ASSERT_TRUE(hash_code != nullptr) << "Object must have hashCode()";
179 hash_code->print_access_flags(&st);
180 ASSERT_STREQ("public native ", st.base());
181
182 st.reset();
183 InstanceKlass* string_klass = vmClasses::String_klass();
184 Symbol* format_symbol = SymbolTable::new_symbol("format");
185 Symbol* format_signature = SymbolTable::new_symbol("(Ljava/lang/String;[Ljava/lang/Object;)Ljava/lang/String;");
186 Method* format_method = string_klass->find_method(format_symbol, format_signature);
187 ASSERT_TRUE(format_method != nullptr) << "String must have format(String, Object...)";
188 format_method->print_access_flags(&st);
189 ASSERT_STREQ("public static varargs ", st.base());
190
191 st.reset();
192 Symbol* compare_to_symbol = SymbolTable::new_symbol("compareTo");
193 Method* compare_to_bridge_method = string_klass->find_method(compare_to_symbol, vmSymbols::object_int_signature());
194 ASSERT_TRUE(compare_to_bridge_method != nullptr) << "String must have bridge compareTo(Object)";
195 compare_to_bridge_method->print_access_flags(&st);
196 ASSERT_STREQ("public bridge synthetic ", st.base());
197 }
198 #endif