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