1 /*

     2  * Copyright (c) 2015, 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 import static java.lang.StackWalker.Option.*;

    25 import java.lang.StackWalker.StackFrame;

    26 import java.util.Arrays;

    27 import java.util.EnumSet;

    28 import java.util.HashSet;

    29 import java.util.List;

    30 import java.util.Random;

    31 import java.util.Set;

    32 import java.util.TreeSet;

    33 

    34 import jdk.testlibrary.RandomFactory;

    35 

    36 /**

    37  * @test

    38  * @bug 8140450

    39  * @summary Stack Walk Test (use -Dseed=X to set PRNG seed)

    40  * @library /lib/testlibrary

    41  * @build jdk.testlibrary.*

    42  * @compile StackRecorderUtil.java

    43  * @run main/othervm StackWalkTest

    44  * @run main/othervm/java.security.policy=stackwalktest.policy StackWalkTest

    45  * @run main/othervm StackWalkTest -random:50

    46  * @run main/othervm/java.security.policy=stackwalktest.policy StackWalkTest -random:50

    47  * @run main/othervm -XX:-MemberNameInStackFrame -Dstackwalk.newThrowable=false StackWalkTest -random:50

    48  * @run main/othervm -XX:-MemberNameInStackFrame -Dstackwalk.newThrowable=true  StackWalkTest -random:50

    49  * @run main/othervm -XX:+MemberNameInStackFrame -Dstackwalk.newThrowable=false StackWalkTest -random:50

    50  * @run main/othervm -XX:+MemberNameInStackFrame -Dstackwalk.newThrowable=true  StackWalkTest -random:50

    51  * @author danielfuchs, bchristi

    52  * @key randomness

    53  */

    54 public class StackWalkTest {

    55     private static boolean random = false;

    56     private static boolean verbose = false;

    57     private static int randomRuns = 50;

    58 

    59     private static final int MAX_RANDOM_DEPTH = 1000;

    60 

    61     static final Set<String> infrastructureClasses = new TreeSet<>(Arrays.asList(

    62             "sun.reflect.NativeMethodAccessorImpl",

    63             "sun.reflect.DelegatingMethodAccessorImpl",

    64             "java.lang.reflect.Method",

    65             "com.sun.javatest.regtest.MainWrapper$MainThread",

    66             "com.sun.javatest.regtest.agent.MainWrapper$MainThread",

    67             "java.lang.Thread"

    68     ));

    69     static final List<Class<?>> streamPipelines = Arrays.asList(

    70         classForName("java.util.stream.AbstractPipeline"),

    71         classForName("java.util.stream.TerminalOp")

    72     );

    73     static Class<?> classForName(String name) {

    74         try {

    75             return Class.forName(name);

    76         } catch (ClassNotFoundException e){

    77             throw new RuntimeException(e);

    78         }

    79     }

    80 

    81     private static boolean isStreamPipeline(Class<?> clazz) {

    82         for (Class<?> c : streamPipelines) {

    83             if (c.isAssignableFrom(clazz)) {

    84                 return true;

    85             }

    86         }

    87         return false;

    88     }

    89 

    90     StackRecorderUtil recorder;

    91     int count = 0;

    92     boolean didWalk = false;

    93 

    94     final int estDepth;

    95     final Set<StackWalker.Option> swOptions;

    96 

    97     public StackWalkTest() {

    98         this(EnumSet.noneOf(StackWalker.Option.class), -1);

    99     }

   100 

   101     public StackWalkTest(Set<StackWalker.Option> swOptions) {

   102         this(swOptions, -1);

   103     }

   104 

   105     public StackWalkTest(int estimatedDepth) {

   106         this(EnumSet.noneOf(StackWalker.Option.class), -1);

   107     }

   108 

   109     public StackWalkTest(Set<StackWalker.Option> swOptions, int estimatedDepth) {

   110         this.swOptions = swOptions;

   111         this.estDepth = estimatedDepth;

   112     }

   113 

   114     private StackWalker createStackWalker() {

   115         // test all StackWalker factory methods

   116         if (this.estDepth < 0) {

   117             if (swOptions.isEmpty()) {

   118                 return StackWalker.getInstance();

   119             } else {

   120                 return StackWalker.getInstance(swOptions);

   121             }

   122         }

   123         return StackWalker.getInstance(swOptions, estDepth);

   124     }

   125     public void consume(StackFrame sf) {

   126         if (count == 0 && swOptions.contains(StackWalker.Option.RETAIN_CLASS_REFERENCE)

   127                 && isStreamPipeline(sf.getDeclaringClass())) {

   128             return;

   129         }

   130         if (verbose) {

   131             System.out.println("\t" + sf.getClassName() + "." + sf.getMethodName());

   132         }

   133         if (count >= recorder.frameCount()) {

   134             // We've gone past main()...

   135             if (infrastructureClasses.contains(sf.getClassName())) {

   136                 // safe to ignore

   137                 return;

   138             }

   139         }

   140         try {

   141             recorder.compareFrame(count, sf);

   142         } catch (IndexOutOfBoundsException e) {

   143             // Extra non-infra frame in stream

   144             throw new RuntimeException("extra non-infra stack frame at count "

   145                     + count + ": <" + sf + ">", e);

   146         }

   147         count++;

   148     }

   149 

   150     public class Call {

   151         public void walk(int total, int markAt) {

   152             recorder.add(Call.class, "walk", "StackWalkTest.java");

   153             long swFrameCount = createStackWalker().walk(s -> s.count());

   154 

   155             if (verbose) {

   156                 System.out.println("Call.walk() total=" + total + ", markAt=" + markAt);

   157                 System.out.println("recorder frames:");

   158                 for (StackRecorderUtil.TestFrame f : recorder) {

   159                     System.out.println("\t" + f.declaringClass + "." + f.methodName);

   160                 }

   161                 System.out.println("\nStackWalker recorded " + swFrameCount + " frames");

   162                 System.out.flush();

   163             }

   164             long recFrameCount = (long)recorder.frameCount();

   165             if (swFrameCount < recFrameCount) {

   166                 throw new RuntimeException("StackWalker recorded fewer frames ("+

   167                         swFrameCount + ") than recorded ("+ recorder.frameCount() +

   168                         ") - " + "estimatedDepth set to " + estDepth);

   169             }

   170             if (verbose) {

   171                 System.out.println("StackWalker frames:");

   172             }

   173             createStackWalker().forEach(StackWalkTest.this::consume);

   174             didWalk = true;

   175         }

   176         public void call(int total, int current, int markAt) {

   177             recorder.add(Call.class, "call", "StackWalkTest.java");

   178             if (current < total) {

   179                 testCall.call(total, current+1, markAt);

   180             } else {

   181                 walk(total, markAt);

   182             }

   183         }

   184     }

   185 

   186     public class Marker extends Call {

   187         @Override

   188         public void call(int total, int current, int markAt) {

   189             recorder.add(Marker.class, "call", "StackWalkTest.java");

   190             if (current < total) {

   191                 testCall.call(total, current+1, markAt);

   192             } else {

   193                 walk(total, markAt);

   194             }

   195         }

   196     }

   197     private Call markerCall = new Marker();

   198 

   199     public class Test extends Call {

   200         @Override

   201         public void call(int total, int current, int markAt) {

   202             recorder.add(Test.class, "call", "StackWalkTest.java");

   203             if (current < total) {

   204                 int nexti = current + 1;

   205                 if (nexti==markAt) {

   206                     markerCall.call(total, nexti, markAt);

   207                 } else {

   208                     testCall.call2(total, nexti, markAt);

   209                 }

   210             } else {

   211                 walk(total, markAt);

   212             }

   213         }

   214         public void call2(int total, int current, int markAt) {

   215             recorder.add(Test.class, "call2", "StackWalkTest.java");

   216             if (current < total) {

   217                 int nexti = current + 1;

   218                 if (nexti==markAt) {

   219                     markerCall.call(total, nexti, markAt);

   220                 } else {

   221                     test2Call.call(total, nexti, markAt);

   222                 }

   223             } else {

   224                 walk(total, markAt);

   225             }

   226         }

   227     }

   228     private Test testCall = new Test();

   229 

   230     /** Inherits call() from Call */

   231     public class Test2 extends Call {}

   232     private Test2 test2Call = new Test2();

   233 

   234     public void runTest(Class callerClass, String callerMethod, int stackDepth,

   235                         int markAt) {

   236         if (didWalk) {

   237             throw new IllegalStateException("StackWalkTest already used");

   238         }

   239         assert markAt <= stackDepth : "markAt(" + markAt + ") > stackDepth("

   240                 + stackDepth + ")";

   241         System.out.print("runTest(" + swOptions

   242                 + "), estimatedDepth=" + estDepth);

   243 

   244         recorder = new StackRecorderUtil(swOptions);

   245         recorder.add(callerClass, callerMethod, "StackWalkTest.java");

   246         recorder.add(StackWalkTest.class, "runTest", "StackWalkTest.java");

   247 

   248         Test test1 = new Test();

   249         test1.call(stackDepth, 0, markAt);

   250 

   251         System.out.println(" finished");

   252         if (!didWalk) {

   253             throw new IllegalStateException("Test wasn't actually performed");

   254         }

   255     }

   256 

   257     public static void main(String[] args) {

   258         String rand = "-random";

   259         String randItems = "-random:";

   260         for(String arg : args) {

   261             if (arg.startsWith(rand)) {

   262                 random = true;

   263                 try {

   264                     if(arg.startsWith(randItems)) {

   265                         randomRuns = Integer.valueOf(arg.substring(randItems.length()));

   266                     }

   267                 } catch(NumberFormatException e) {}

   268             } else if("-verbose".equals(arg)) {

   269                 verbose = true;

   270             }

   271         }

   272         if (random) {

   273             Random rng = RandomFactory.getRandom();

   274             for (int iters = 0; iters < randomRuns; iters++) {

   275                 Set<StackWalker.Option> opts = new HashSet<>();

   276                 if (rng.nextBoolean()) {

   277                     opts.add(RETAIN_CLASS_REFERENCE);

   278                 }

   279 

   280                 int depth = 1 + rng.nextInt(MAX_RANDOM_DEPTH);

   281 

   282                 StackWalkTest swt;

   283                 if (rng.nextBoolean() && depth > 1) {

   284                     // Test that specifying an estimatedDepth doesn't prevent

   285                     // full stack traversal

   286                     swt = new StackWalkTest(opts, 1+rng.nextInt(depth-1));

   287                 } else {

   288                     swt = new StackWalkTest(opts);

   289                 }

   290 

   291                 int markAt = rng.nextInt(depth+1);

   292                 System.out.print(depth + "@" + markAt + " ");

   293                 System.out.flush();

   294                 swt.runTest(StackWalkTest.class, "main", depth, markAt);

   295             }

   296         } else {

   297             // Long stack, default maxDepth

   298             StackWalkTest swt;

   299             swt = new StackWalkTest();

   300             swt.runTest(StackWalkTest.class, "main", 2000, 10);

   301 

   302             // Long stack, matching maxDepth

   303             swt = new StackWalkTest(2000);

   304             swt.runTest(StackWalkTest.class, "main", 2000, 10);

   305 

   306             // Long stack, maximum maxDepth

   307             swt = new StackWalkTest(Integer.MAX_VALUE);

   308             swt.runTest(StackWalkTest.class, "main", 2000, 10);

   309 

   310             //

   311             // Single batch

   312             //

   313             swt = new StackWalkTest(); // default maxDepth

   314             swt.runTest(StackWalkTest.class, "main", 6, 3);

   315 

   316             swt = new StackWalkTest(4); // maxDepth < stack

   317             swt.runTest(StackWalkTest.class, "main", 6, 3);

   318 

   319             swt = new StackWalkTest(2); // maxDepth < marker

   320             swt.runTest(StackWalkTest.class, "main", 6, 4);

   321 

   322             //

   323             // 2 batches

   324             //

   325             swt = new StackWalkTest(); // default maxDepth

   326             swt.runTest(StackWalkTest.class, "main", 24, 10);

   327             swt = new StackWalkTest(18); // maxDepth < stack

   328             swt.runTest(StackWalkTest.class, "main", 24, 10);

   329             swt = new StackWalkTest(8); // maxDepth < marker

   330             swt.runTest(StackWalkTest.class, "main", 24, 10);

   331 

   332             //

   333             // 3 batch

   334             //

   335             swt = new StackWalkTest(); // default maxDepth

   336             swt.runTest(StackWalkTest.class, "main", 60, 20);

   337             swt = new StackWalkTest(35); // maxDepth < stack

   338             swt.runTest(StackWalkTest.class, "main", 60, 20);

   339             swt = new StackWalkTest(8); // maxDepth < marker

   340             swt.runTest(StackWalkTest.class, "main", 60, 20);

   341 

   342             //

   343             // StackWalker.Options

   344             //

   345             swt = new StackWalkTest();

   346             swt.runTest(StackWalkTest.class, "main", 50, 10);

   347 

   348             swt = new StackWalkTest(EnumSet.of(RETAIN_CLASS_REFERENCE));

   349             swt.runTest(StackWalkTest.class, "main", 80, 40);

   350 

   351             swt = new StackWalkTest(EnumSet.of(RETAIN_CLASS_REFERENCE), 50);

   352             swt.runTest(StackWalkTest.class, "main", 2000, 1048);

   353         }

   354     }

   355 }