1 /*
2  * Copyright (c) 2003, 2018, 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 <stdio.h>
25 #include <string.h>
26 #include "jni_tools.h"
27 #include "agent_common.h"
28 #include "jvmti_tools.h"
29 
30 extern "C" {
31 
32 #define CAPABILITY can_get_line_numbers
33 #define CAPABILITY_STR "can_get_line_numbers"
34 
35 /* The test checks capability can_get_line_numbers
36  * and correspondent functions:
37  *     GetLineNumberTable
38  *
39  * Testcases:
40  *   1. Check if GetPotentialCapabilities returns the capability
41  *   2. Add the capability during Onload phase
42  *   3. Check if GetCapabilities returns the capability
43  *   4. Relinquish the capability during Onload phase
44  *   5. Check if GetCapabilities does not return the capability
45  *   6. Add back the capability and check with GetCapabilities
46  *   7. Check that only correspondent function work and functions of
47  *      other capabilities return JVMTI_ERROR_MUST_POSSESS_CAPABILITY
48  *   8. Check if VM exits well with the capability has not been relinquished
49  */
50 
51 /* ========================================================================== */
52 
53 /* scaffold objects */
54 static JNIEnv* jni = NULL;
55 static jvmtiEnv *jvmti = NULL;
56 static jlong timeout = 0;
57 
58 /* test objects */
59 static jthread thread = NULL;
60 static jclass klass = NULL;
61 static jmethodID method = NULL;
62 static jfieldID field = NULL;
63 
64 /* ========================================================================== */
65 
prepare()66 static int prepare() {
67     const char* THREAD_NAME = "Debuggee Thread";
68     jvmtiThreadInfo info;
69     jthread *threads = NULL;
70     jint threads_count = 0;
71     int i;
72 
73     NSK_DISPLAY0("Prepare: find tested thread\n");
74 
75     /* get all live threads */
76     if (!NSK_JVMTI_VERIFY(jvmti->GetAllThreads(&threads_count, &threads)))
77         return NSK_FALSE;
78 
79     if (!NSK_VERIFY(threads_count > 0 && threads != NULL))
80         return NSK_FALSE;
81 
82     /* find tested thread */
83     for (i = 0; i < threads_count; i++) {
84         if (!NSK_VERIFY(threads[i] != NULL))
85             return NSK_FALSE;
86 
87         /* get thread information */
88         if (!NSK_JVMTI_VERIFY(jvmti->GetThreadInfo(threads[i], &info)))
89             return NSK_FALSE;
90 
91         NSK_DISPLAY3("    thread #%d (%s): %p\n", i, info.name, threads[i]);
92 
93         /* find by name */
94         if (info.name != NULL && (strcmp(info.name, THREAD_NAME) == 0)) {
95             thread = threads[i];
96         }
97     }
98 
99     /* deallocate threads list */
100     if (!NSK_JVMTI_VERIFY(jvmti->Deallocate((unsigned char*)threads)))
101         return NSK_FALSE;
102 
103     /* get tested thread class */
104     if (!NSK_JNI_VERIFY(jni, (klass = jni->GetObjectClass(thread)) != NULL))
105         return NSK_FALSE;
106 
107     /* get tested thread method 'run' */
108     if (!NSK_JNI_VERIFY(jni, (method = jni->GetMethodID(klass, "run", "()V")) != NULL))
109         return NSK_FALSE;
110 
111     /* get tested thread field 'waitingMonitor' */
112     if (!NSK_JNI_VERIFY(jni, (field =
113             jni->GetFieldID(klass, "waitingMonitor", "Ljava/lang/Object;")) != NULL))
114         return NSK_FALSE;
115 
116     return NSK_TRUE;
117 }
118 
119 /* ========================================================================== */
120 
121 /* Check "can_suspend" functions
122  */
checkSuspend()123 static int checkSuspend() {
124     jvmtiError err;
125 
126     NSK_DISPLAY0("Checking negative: SuspendThread\n");
127     if (!NSK_JVMTI_VERIFY_CODE(JVMTI_ERROR_MUST_POSSESS_CAPABILITY, jvmti->SuspendThread(thread)))
128         return NSK_FALSE;
129 
130     NSK_DISPLAY0("Checking negative: ResumeThread\n");
131     if (!NSK_JVMTI_VERIFY_CODE(JVMTI_ERROR_MUST_POSSESS_CAPABILITY, jvmti->ResumeThread(thread)))
132         return NSK_FALSE;
133 
134     NSK_DISPLAY0("Checking negative: SuspendThreadList\n");
135     if (!NSK_JVMTI_VERIFY_CODE(JVMTI_ERROR_MUST_POSSESS_CAPABILITY,
136             jvmti->SuspendThreadList(1, &thread, &err)))
137         return NSK_FALSE;
138 
139     NSK_DISPLAY0("Checking negative: ResumeThreadList\n");
140     if (!NSK_JVMTI_VERIFY_CODE(JVMTI_ERROR_MUST_POSSESS_CAPABILITY,
141             jvmti->ResumeThreadList(1, &thread, &err)))
142         return NSK_FALSE;
143 
144     return NSK_TRUE;
145 }
146 
147 /* Check "can_signal_thread" functions
148  */
checkSignalThread()149 static int checkSignalThread() {
150     const char* THREAD_DEATH_CLASS_NAME = "java/lang/ThreadDeath";
151     const char* THREAD_DEATH_CTOR_NAME = "<init>";
152     const char* THREAD_DEATH_CTOR_SIGNATURE = "()V";
153     jclass cls = NULL;
154     jmethodID ctor = NULL;
155     jobject exception = NULL;
156 
157     if (!NSK_JNI_VERIFY(jni, (cls = jni->FindClass(THREAD_DEATH_CLASS_NAME)) != NULL))
158         return NSK_FALSE;
159 
160     if (!NSK_JNI_VERIFY(jni, (ctor =
161             jni->GetMethodID(cls, THREAD_DEATH_CTOR_NAME, THREAD_DEATH_CTOR_SIGNATURE)) != NULL))
162         return NSK_FALSE;
163 
164     if (!NSK_JNI_VERIFY(jni, (exception = jni->NewObject(cls, ctor)) != NULL))
165         return NSK_FALSE;
166 
167     NSK_DISPLAY0("Checking negative: StopThread\n");
168     if (!NSK_JVMTI_VERIFY_CODE(JVMTI_ERROR_MUST_POSSESS_CAPABILITY,
169             jvmti->StopThread(thread, exception)))
170         return NSK_FALSE;
171 
172     NSK_DISPLAY0("Checking negative: InterruptThread\n");
173     if (!NSK_JVMTI_VERIFY_CODE(JVMTI_ERROR_MUST_POSSESS_CAPABILITY, jvmti->InterruptThread(thread)))
174         return NSK_FALSE;
175 
176     return NSK_TRUE;
177 }
178 
179 /* Check "can_get_owned_monitor_info" function
180  */
checkGetOwnedMonitorInfo()181 static int checkGetOwnedMonitorInfo() {
182     jint count;
183     jobject *monitors = NULL;
184 
185     NSK_DISPLAY0("Checking negative: GetOwnedMonitorInfo\n");
186     if (!NSK_JVMTI_VERIFY_CODE(JVMTI_ERROR_MUST_POSSESS_CAPABILITY,
187             jvmti->GetOwnedMonitorInfo(thread, &count, &monitors)))
188         return NSK_FALSE;
189 
190     return NSK_TRUE;
191 }
192 
193 /* Check "can_get_current_contended_monitor" function
194  */
checkGetCurrentContendedMonitor()195 static int checkGetCurrentContendedMonitor() {
196     jobject monitor = NULL;
197 
198     NSK_DISPLAY0("Checking negative: GetCurrentContendedMonitor\n");
199     if (!NSK_JVMTI_VERIFY_CODE(JVMTI_ERROR_MUST_POSSESS_CAPABILITY,
200             jvmti->GetCurrentContendedMonitor(thread, &monitor)))
201         return NSK_FALSE;
202 
203     return NSK_TRUE;
204 }
205 
206 /* Check "can_pop_frame" function
207  */
checkPopFrame()208 static int checkPopFrame() {
209     NSK_DISPLAY0("Checking negative: PopFrame\n");
210     if (!NSK_JVMTI_VERIFY_CODE(JVMTI_ERROR_MUST_POSSESS_CAPABILITY, jvmti->PopFrame(thread)))
211         return NSK_FALSE;
212 
213     return NSK_TRUE;
214 }
215 
216 /* Check "can_tag_objects" functions
217  */
218 
219 static jvmtiIterationControl JNICALL
HeapObject(jlong class_tag,jlong size,jlong * tag_ptr,void * user_data)220 HeapObject(jlong class_tag, jlong size, jlong *tag_ptr, void *user_data) {
221     return JVMTI_ITERATION_ABORT;
222 }
223 
224 static jvmtiIterationControl JNICALL
HeapRoot(jvmtiHeapRootKind root_kind,jlong class_tag,jlong size,jlong * tag_ptr,void * user_data)225 HeapRoot(jvmtiHeapRootKind root_kind, jlong class_tag, jlong size,
226         jlong *tag_ptr, void *user_data) {
227     return JVMTI_ITERATION_ABORT;
228 }
229 
230 static jvmtiIterationControl JNICALL
StackReference(jvmtiHeapRootKind root_kind,jlong class_tag,jlong size,jlong * tag_ptr,jlong thread_tag,jint depth,jmethodID method,jint slot,void * user_data)231 StackReference(jvmtiHeapRootKind root_kind, jlong class_tag, jlong size,
232         jlong *tag_ptr, jlong thread_tag, jint depth, jmethodID method,
233         jint slot, void *user_data) {
234     return JVMTI_ITERATION_ABORT;
235 }
236 
237 static jvmtiIterationControl JNICALL
ObjectReference(jvmtiObjectReferenceKind reference_kind,jlong class_tag,jlong size,jlong * tag_ptr,jlong referrer_tag,jint referrer_index,void * user_data)238 ObjectReference(jvmtiObjectReferenceKind reference_kind, jlong class_tag,
239         jlong size, jlong *tag_ptr, jlong referrer_tag,
240         jint referrer_index, void *user_data) {
241     return JVMTI_ITERATION_ABORT;
242 }
243 
checkHeapFunctions()244 static int checkHeapFunctions() {
245     const jlong TAG_VALUE = (123456789L);
246     jlong tag;
247     jint count;
248     jobject *res_objects = NULL;
249     jlong *res_tags = NULL;
250     jint dummy_user_data = 0;
251 
252     NSK_DISPLAY0("Checking negative: SetTag\n");
253     if (!NSK_JVMTI_VERIFY_CODE(JVMTI_ERROR_MUST_POSSESS_CAPABILITY,
254             jvmti->SetTag(thread, TAG_VALUE)))
255         return NSK_FALSE;
256 
257     NSK_DISPLAY0("Checking negative: GetTag\n");
258     if (!NSK_JVMTI_VERIFY_CODE(JVMTI_ERROR_MUST_POSSESS_CAPABILITY, jvmti->GetTag(thread, &tag)))
259         return NSK_FALSE;
260 
261     NSK_DISPLAY0("Checking negative: GetObjectsWithTags\n");
262     tag = TAG_VALUE;
263     if (!NSK_JVMTI_VERIFY_CODE(JVMTI_ERROR_MUST_POSSESS_CAPABILITY,
264             jvmti->GetObjectsWithTags(1, &tag, &count, &res_objects, &res_tags)))
265         return NSK_FALSE;
266 
267     NSK_DISPLAY0("Checking negative: IterateOverHeap\n");
268     if (!NSK_JVMTI_VERIFY_CODE(JVMTI_ERROR_MUST_POSSESS_CAPABILITY,
269             jvmti->IterateOverHeap(JVMTI_HEAP_OBJECT_TAGGED, HeapObject, &dummy_user_data)))
270         return NSK_FALSE;
271 
272     NSK_DISPLAY0("Checking negative: IterateOverInstancesOfClass\n");
273     if (!NSK_JVMTI_VERIFY_CODE(JVMTI_ERROR_MUST_POSSESS_CAPABILITY,
274             jvmti->IterateOverInstancesOfClass(klass,
275                                                JVMTI_HEAP_OBJECT_UNTAGGED,
276                                                HeapObject,
277                                                &dummy_user_data)))
278         return NSK_FALSE;
279 
280     NSK_DISPLAY0("Checking negative: IterateOverObjectsReachableFromObject\n");
281     if (!NSK_JVMTI_VERIFY_CODE(JVMTI_ERROR_MUST_POSSESS_CAPABILITY,
282             jvmti->IterateOverObjectsReachableFromObject(thread,
283                                                          ObjectReference,
284                                                          &dummy_user_data)))
285         return NSK_FALSE;
286 
287     NSK_DISPLAY0("Checking negative: IterateOverReachableObjects\n");
288     if (!NSK_JVMTI_VERIFY_CODE(JVMTI_ERROR_MUST_POSSESS_CAPABILITY,
289             jvmti->IterateOverReachableObjects(HeapRoot,
290                                                StackReference,
291                                                ObjectReference,
292                                                &dummy_user_data)))
293         return NSK_FALSE;
294 
295     return NSK_TRUE;
296 }
297 
298 /* Check "can_access_local_variables" functions
299  */
checkLocalVariableFunctions()300 static int checkLocalVariableFunctions() {
301     jint count;
302     jvmtiLocalVariableEntry *local_variable_table = NULL;
303     jobject object_value;
304     jint int_value;
305     jlong long_value;
306     jfloat float_value;
307     jdouble double_value;
308 
309     NSK_DISPLAY0("Checking negative: GetLocalVariableTable\n");
310     if (!NSK_JVMTI_VERIFY_CODE(JVMTI_ERROR_MUST_POSSESS_CAPABILITY,
311             jvmti->GetLocalVariableTable(method, &count, &local_variable_table)))
312         return NSK_FALSE;
313 
314     NSK_DISPLAY0("Checking negative: GetLocalObject\n");
315     if (!NSK_JVMTI_VERIFY_CODE(JVMTI_ERROR_MUST_POSSESS_CAPABILITY,
316             jvmti->GetLocalObject(thread, 0, 0, &object_value)))
317         return NSK_FALSE;
318 
319     NSK_DISPLAY0("Checking negative: GetLocalInt\n");
320     if (!NSK_JVMTI_VERIFY_CODE(JVMTI_ERROR_MUST_POSSESS_CAPABILITY,
321             jvmti->GetLocalInt(thread, 0, 0, &int_value)))
322         return NSK_FALSE;
323 
324     NSK_DISPLAY0("Checking negative: GetLocalLong\n");
325     if (!NSK_JVMTI_VERIFY_CODE(JVMTI_ERROR_MUST_POSSESS_CAPABILITY,
326             jvmti->GetLocalLong(thread, 0, 0, &long_value)))
327         return NSK_FALSE;
328 
329     NSK_DISPLAY0("Checking negative: GetLocalFloat\n");
330     if (!NSK_JVMTI_VERIFY_CODE(JVMTI_ERROR_MUST_POSSESS_CAPABILITY,
331             jvmti->GetLocalFloat(thread, 0, 0, &float_value)))
332         return NSK_FALSE;
333 
334     NSK_DISPLAY0("Checking negative: GetLocalDouble\n");
335     if (!NSK_JVMTI_VERIFY_CODE(JVMTI_ERROR_MUST_POSSESS_CAPABILITY,
336             jvmti->GetLocalDouble(thread, 0, 0, &double_value)))
337         return NSK_FALSE;
338 
339     NSK_DISPLAY0("Checking negative: SetLocalObject\n");
340     if (!NSK_JVMTI_VERIFY_CODE(JVMTI_ERROR_MUST_POSSESS_CAPABILITY,
341             jvmti->SetLocalObject(thread, 0, 0, thread)))
342         return NSK_FALSE;
343 
344     NSK_DISPLAY0("Checking negative: SetLocalInt\n");
345     if (!NSK_JVMTI_VERIFY_CODE(JVMTI_ERROR_MUST_POSSESS_CAPABILITY,
346             jvmti->SetLocalInt(thread, 0, 0, (jint)0)))
347         return NSK_FALSE;
348 
349     NSK_DISPLAY0("Checking negative: SetLocalLong\n");
350     if (!NSK_JVMTI_VERIFY_CODE(JVMTI_ERROR_MUST_POSSESS_CAPABILITY,
351             jvmti->SetLocalLong(thread, 0, 0, (jlong)0)))
352         return NSK_FALSE;
353 
354     NSK_DISPLAY0("Checking negative: SetLocalFloat\n");
355     if (!NSK_JVMTI_VERIFY_CODE(JVMTI_ERROR_MUST_POSSESS_CAPABILITY,
356             jvmti->SetLocalFloat(thread, 0, 0, (jfloat)0.0)))
357         return NSK_FALSE;
358 
359     NSK_DISPLAY0("Checking negative: SetLocalDouble\n");
360     if (!NSK_JVMTI_VERIFY_CODE(JVMTI_ERROR_MUST_POSSESS_CAPABILITY,
361             jvmti->SetLocalDouble(thread, 0, 0, (jdouble)0.0)))
362         return NSK_FALSE;
363 
364     return NSK_TRUE;
365 }
366 
367 /* Check "can_get_source_info" functions
368  */
checkSourceInfoFunctions()369 static int checkSourceInfoFunctions() {
370     char *name;
371     jint count;
372     jvmtiLineNumberEntry *line_number_table = NULL;
373 
374     NSK_DISPLAY0("Checking negative: GetSourceFileName\n");
375     if (!NSK_JVMTI_VERIFY_CODE(JVMTI_ERROR_MUST_POSSESS_CAPABILITY,
376             jvmti->GetSourceFileName(klass, &name)))
377         return NSK_FALSE;
378 
379     NSK_DISPLAY0("Checking negative: GetSourceDebugExtension\n");
380     if (!NSK_JVMTI_VERIFY_CODE(JVMTI_ERROR_MUST_POSSESS_CAPABILITY,
381             jvmti->GetSourceDebugExtension(klass, &name)))
382         return NSK_FALSE;
383 
384     NSK_DISPLAY0("Checking positive: GetLineNumberTable\n");
385     if (!NSK_JVMTI_VERIFY(jvmti->GetLineNumberTable(method, &count, &line_number_table)))
386         return NSK_FALSE;
387 
388     return NSK_TRUE;
389 }
390 
391 /* Check "can_redefine_classes" functions
392  */
checkRedefineClasses()393 static int checkRedefineClasses() {
394     jvmtiClassDefinition class_def;
395 
396     NSK_DISPLAY0("Checking negative: RedefineClasses\n");
397     class_def.klass = klass;
398     class_def.class_byte_count = 0;
399     class_def.class_bytes = NULL;
400     if (!NSK_JVMTI_VERIFY_CODE(JVMTI_ERROR_MUST_POSSESS_CAPABILITY,
401             jvmti->RedefineClasses(1, &class_def)))
402         return NSK_FALSE;
403 
404     return NSK_TRUE;
405 }
406 
407 /* Check "can_get_monitor_info" function
408  */
checkGetObjectMonitorUsage()409 static int checkGetObjectMonitorUsage() {
410     jvmtiMonitorUsage monitor_info;
411 
412     NSK_DISPLAY0("Checking negative: GetObjectMonitorUsage\n");
413     if (!NSK_JVMTI_VERIFY_CODE(JVMTI_ERROR_MUST_POSSESS_CAPABILITY,
414             jvmti->GetObjectMonitorUsage(thread, &monitor_info)))
415         return NSK_FALSE;
416 
417     return NSK_TRUE;
418 }
419 
420 /* Check "can_get_synthetic_attribute" functions
421  */
checkIsSyntheticFunctions()422 static int checkIsSyntheticFunctions() {
423     jboolean is_synthetic;
424 
425     NSK_DISPLAY0("Checking negative: IsFieldSynthetic\n");
426     if (!NSK_JVMTI_VERIFY_CODE(JVMTI_ERROR_MUST_POSSESS_CAPABILITY,
427             jvmti->IsFieldSynthetic(klass, field, &is_synthetic)))
428         return NSK_FALSE;
429 
430     NSK_DISPLAY0("Checking negative: IsMethodSynthetic\n");
431     if (!NSK_JVMTI_VERIFY_CODE(JVMTI_ERROR_MUST_POSSESS_CAPABILITY,
432             jvmti->IsMethodSynthetic(method, &is_synthetic)))
433         return NSK_FALSE;
434 
435     return NSK_TRUE;
436 }
437 
438 /* Check "can_get_bytecodes" function
439  */
checkGetBytecodes()440 static int checkGetBytecodes() {
441     jint count;
442     unsigned char *bytecodes;
443 
444     NSK_DISPLAY0("Checking negative: GetBytecodes\n");
445     if (!NSK_JVMTI_VERIFY_CODE(JVMTI_ERROR_MUST_POSSESS_CAPABILITY,
446             jvmti->GetBytecodes(method, &count, &bytecodes)))
447         return NSK_FALSE;
448 
449     return NSK_TRUE;
450 }
451 
452 /* Check "can_get_current_thread_cpu_time" function
453  */
checkGetCurrentThreadCpuTime()454 static int checkGetCurrentThreadCpuTime() {
455     jvmtiTimerInfo info;
456     jlong nanos;
457 
458     NSK_DISPLAY0("Checking negative: GetCurrentThreadCpuTimerInfo\n");
459     if (!NSK_JVMTI_VERIFY_CODE(JVMTI_ERROR_MUST_POSSESS_CAPABILITY,
460             jvmti->GetCurrentThreadCpuTimerInfo(&info)))
461         return NSK_FALSE;
462 
463     NSK_DISPLAY0("Checking negative: GetCurrentThreadCpuTime\n");
464     if (!NSK_JVMTI_VERIFY_CODE(JVMTI_ERROR_MUST_POSSESS_CAPABILITY,
465             jvmti->GetCurrentThreadCpuTime(&nanos)))
466         return NSK_FALSE;
467 
468     return NSK_TRUE;
469 }
470 
471 /* Check "can_get_thread_cpu_time" function
472  */
checkGetThreadCpuTime()473 static int checkGetThreadCpuTime() {
474     jvmtiTimerInfo info;
475     jlong nanos;
476 
477     NSK_DISPLAY0("Checking negative: GetThreadCpuTimerInfo\n");
478     if (!NSK_JVMTI_VERIFY_CODE(JVMTI_ERROR_MUST_POSSESS_CAPABILITY,
479             jvmti->GetThreadCpuTimerInfo(&info)))
480         return NSK_FALSE;
481 
482     NSK_DISPLAY0("Checking negative: GetThreadCpuTime\n");
483     if (!NSK_JVMTI_VERIFY_CODE(JVMTI_ERROR_MUST_POSSESS_CAPABILITY,
484             jvmti->GetThreadCpuTime(thread, &nanos)))
485         return NSK_FALSE;
486 
487     return NSK_TRUE;
488 }
489 
490 /* ========================================================================== */
491 
492 /* agent algorithm */
493 static void JNICALL
agentProc(jvmtiEnv * jvmti,JNIEnv * agentJNI,void * arg)494 agentProc(jvmtiEnv* jvmti, JNIEnv* agentJNI, void* arg) {
495     jni = agentJNI;
496 
497     /* wait for initial sync */
498     if (!nsk_jvmti_waitForSync(timeout))
499         return;
500 
501     if (!prepare()) {
502         nsk_jvmti_setFailStatus();
503         return;
504     }
505 
506     /* testcase #7: check that only correspondent function work */
507     NSK_DISPLAY0("Testcase #7: check that only correspondent function work but not others\n");
508     if (!checkSuspend())
509         nsk_jvmti_setFailStatus();
510     if (!checkSignalThread())
511         nsk_jvmti_setFailStatus();
512     if (!checkGetOwnedMonitorInfo())
513         nsk_jvmti_setFailStatus();
514     if (!checkGetCurrentContendedMonitor())
515         nsk_jvmti_setFailStatus();
516     if (!checkPopFrame())
517         nsk_jvmti_setFailStatus();
518     if (!checkHeapFunctions())
519         nsk_jvmti_setFailStatus();
520     if (!checkLocalVariableFunctions())
521         nsk_jvmti_setFailStatus();
522     if (!checkSourceInfoFunctions())
523         nsk_jvmti_setFailStatus();
524     if (!checkRedefineClasses())
525         nsk_jvmti_setFailStatus();
526     if (!checkGetObjectMonitorUsage())
527         nsk_jvmti_setFailStatus();
528     if (!checkIsSyntheticFunctions())
529         nsk_jvmti_setFailStatus();
530     if (!checkGetBytecodes())
531         nsk_jvmti_setFailStatus();
532     if (!checkGetCurrentThreadCpuTime())
533         nsk_jvmti_setFailStatus();
534     if (!checkGetThreadCpuTime())
535         nsk_jvmti_setFailStatus();
536 
537     /* testcase #8: exits with the capability has not been relinquished */
538     NSK_DISPLAY0("Testcase #8: check if VM exits well with the capability has not been relinquished\n");
539 
540     /* resume debugee after last sync */
541     if (!nsk_jvmti_resumeSync())
542         return;
543 }
544 
545 /* ========================================================================== */
546 
547 /* agent library initialization */
548 #ifdef STATIC_BUILD
Agent_OnLoad_cm01t013(JavaVM * jvm,char * options,void * reserved)549 JNIEXPORT jint JNICALL Agent_OnLoad_cm01t013(JavaVM *jvm, char *options, void *reserved) {
550     return Agent_Initialize(jvm, options, reserved);
551 }
Agent_OnAttach_cm01t013(JavaVM * jvm,char * options,void * reserved)552 JNIEXPORT jint JNICALL Agent_OnAttach_cm01t013(JavaVM *jvm, char *options, void *reserved) {
553     return Agent_Initialize(jvm, options, reserved);
554 }
JNI_OnLoad_cm01t013(JavaVM * jvm,char * options,void * reserved)555 JNIEXPORT jint JNI_OnLoad_cm01t013(JavaVM *jvm, char *options, void *reserved) {
556     return JNI_VERSION_1_8;
557 }
558 #endif
Agent_Initialize(JavaVM * jvm,char * options,void * reserved)559 jint Agent_Initialize(JavaVM *jvm, char *options, void *reserved) {
560     jvmtiCapabilities caps;
561 
562     /* init framework and parse options */
563     if (!NSK_VERIFY(nsk_jvmti_parseOptions(options)))
564         return JNI_ERR;
565 
566     timeout = nsk_jvmti_getWaitTime() * 60000;
567     NSK_DISPLAY1("Timeout: %d msc\n", (int)timeout);
568 
569     /* create JVMTI environment */
570     if (!NSK_VERIFY((jvmti =
571             nsk_jvmti_createJVMTIEnv(jvm, reserved)) != NULL))
572         return JNI_ERR;
573 
574     /* register agent proc and arg */
575     if (!NSK_VERIFY(nsk_jvmti_setAgentProc(agentProc, NULL)))
576         return JNI_ERR;
577 
578     /* testcase #1: check GetPotentialCapabilities */
579     NSK_DISPLAY0("Testcase #1: check if GetPotentialCapabilities returns the capability\n");
580     if (!NSK_JVMTI_VERIFY(jvmti->GetPotentialCapabilities(&caps)))
581         return JNI_ERR;
582     if (!caps.CAPABILITY) {
583         NSK_COMPLAIN1("GetPotentialCapabilities does not return \"%s\" capability\n",
584             CAPABILITY_STR);
585         return JNI_ERR;
586     }
587 
588     /* testcase #2: add the capability during Onload phase */
589     NSK_DISPLAY0("Testcase #2: add the capability during Onload phase\n");
590     memset(&caps, 0, sizeof(caps));
591     caps.CAPABILITY = 1;
592     if (!NSK_JVMTI_VERIFY(jvmti->AddCapabilities(&caps)))
593         return JNI_ERR;
594 
595     /* testcase #3: check if GetCapabilities returns the capability */
596     NSK_DISPLAY0("Testcase #3: check if GetCapabilities returns the capability\n");
597     memset(&caps, 0, sizeof(caps));
598     if (!NSK_JVMTI_VERIFY(jvmti->GetCapabilities(&caps)))
599         return JNI_ERR;
600     if (!caps.CAPABILITY) {
601         NSK_COMPLAIN1("GetCapabilities does not return \"%s\" capability\n",
602             CAPABILITY_STR);
603         return JNI_ERR;
604     }
605 
606     /* testcase #4: relinquish the capability during Onload phase */
607     NSK_DISPLAY0("Testcase #4: relinquish the capability during Onload phase\n");
608     memset(&caps, 0, sizeof(caps));
609     caps.CAPABILITY = 1;
610     if (!NSK_JVMTI_VERIFY(jvmti->RelinquishCapabilities(&caps)))
611         return JNI_ERR;
612 
613     /* testcase #5: check if GetCapabilities does not return the capability */
614     NSK_DISPLAY0("Testcase #5: check if GetCapabilities does not return the capability\n");
615     memset(&caps, 0, sizeof(caps));
616     if (!NSK_JVMTI_VERIFY(jvmti->GetCapabilities(&caps)))
617         return JNI_ERR;
618     if (caps.CAPABILITY) {
619         NSK_COMPLAIN1("GetCapabilities returns relinquished \"%s\" capability\n",
620             CAPABILITY_STR);
621         return JNI_ERR;
622     }
623 
624     /* testcase #6: add back the capability and check with GetCapabilities */
625     NSK_DISPLAY0("Testcase #6: add back the capability and check with GetCapabilities\n");
626     memset(&caps, 0, sizeof(caps));
627     caps.CAPABILITY = 1;
628     if (!NSK_JVMTI_VERIFY(jvmti->AddCapabilities(&caps)))
629         return JNI_ERR;
630     memset(&caps, 0, sizeof(caps));
631     if (!NSK_JVMTI_VERIFY(jvmti->GetCapabilities(&caps)))
632         return JNI_ERR;
633     if (!caps.CAPABILITY) {
634         NSK_COMPLAIN1("GetCapabilities does not return \"%s\" capability\n",
635             CAPABILITY_STR);
636         return JNI_ERR;
637     }
638 
639     return JNI_OK;
640 }
641 
642 /* ========================================================================== */
643 
644 }
645