rev 58143 : imported patch test_heap_walk
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 /*
25 * Unit tests for JVMTI IterateOverReachableObjects and
26 * IterateOverObjectsReachableFromObject functions.
27 *
28 */
29
30 package nsk.jvmti.unit.heap;
31
32 import nsk.share.jvmti.unit.*;
33 import java.io.PrintStream;
34
35 public class HeapWalkTests {
36
37 final static int JCK_STATUS_BASE = 95;
38 final static int PASSED = 0;
39 final static int FAILED = 2;
40
41 public static void main(String args[]) {
42 args = nsk.share.jvmti.JVMTITest.commonInit(args);
43
44 // produce JCK-like exit status.
45 System.exit(run(args, System.out) + JCK_STATUS_BASE);
46 }
47
48 public static int run(String args[], PrintStream out) {
49 test1();
50 test2();
51 test3();
52 return PASSED;
53 }
54
55 private static void test1() {
56 long tag;
57
58 // This test uses the heap_root_callback to tag all the roots
59
60 // It then examines a few known roots and checks that they
61 // are tagged.
62
63 // create a global reference
64 Object o = new Object();
65 Heap.newGlobalRef(o);
66
67 // make sure current thread isn't tagged
68 Heap.setTag(Thread.currentThread(), 0);
69
70 Heap.setHeapRootCallback();
71 Heap.iterateOverReachableObjects();
72
73 // o must be JNI global - there's no other way it can be a root
74
75 tag = Heap.getTag(o);
76
77 if (tag != Heap.JVMTI_HEAP_ROOT_JNI_GLOBAL) {
78 throw new RuntimeException("JNI global should have been tagged");
79 }
80
81 // Current thread is root but can't assume it will be
82 // tagged with JVMTI_HEAP_ROOT_JNI_GLOBAL
83
84 tag = Heap.getTag(Thread.currentThread());
85 if (tag == 0) {
86 throw new RuntimeException("Current thread isn't tagged");
87 }
88 }
89
90 private static void test2() {
91 long tag;
92
93 // This test uses the stack_ref_callback to tag all references
94 // from the thread stacks. The callback tags all objects with the tag
95 // of the thread.
96
97 Object o = new Object();
98
99 Heap.setTag(Thread.currentThread(), 888);
100
101 Heap.setStackRefCallback();
102 Heap.iterateOverReachableObjects();
103
104 tag = Heap.getTag(o);
105 if (tag != 888) {
106 throw new RuntimeException("stack local not tagged correctly");
107 }
108 }
109
110
111 // used by test3
112 static class Foo {
113 private Object fld;
114
115 Foo() {
116 fld = new Object();
117 }
118
119 Object field() {
120 return fld;
121 }
122
123 public static Object static_field = new Object();
124 }
125
126 private static int failures = 0;
127
128 private static void check(Object o, long tag) {
129 long actual_tag = Heap.getTag(o);
130 if (actual_tag != tag) {
131 if (actual_tag == 0) {
132 System.err.println(o + " is not tagged!");
133 } else {
134 System.err.println(o + " is incorrectly tagged");
135 }
136 failures++;
137 }
138 }
139
140 private static void test3() {
141 long tag;
142
143 // This test tags an object, and then calls IterateOverObjectsReachableFromObject
144 // The callback tags all objects with a tag value of 777.
145
146 Foo foo = new Foo();
147
148 Heap.setObjectRefCallback();
149 Heap.iterateOverObjectsReachableFromObject(foo);
150
151 check(Foo.class, 777);
152 check(Foo.static_field, 777);
153 check(foo.field(), 777);
154
155 if (failures > 0) {
156 throw new RuntimeException("IterateOverObjectsReachableFromObject test failed");
157 }
158 }
159 }
--- EOF ---