Quelle  StackWalkTest.java   Sprache: JAVA

/*
 * Copyright (c) 2015, 2017, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

import static java.lang.StackWalker.Option.*;
import java.lang.StackWalker.StackFrame;
import java.util.Arrays;
import java.util.EnumSet;
import java.util.HashSet;
import java.util.List;
import java.util.Random;
import java.util.Set;
import java.util.TreeSet;

import jdk.test.lib.RandomFactory;

/**
 * @test
 * @bug 8140450
 * @summary Stack Walk Test (use -Dseed=X to set PRNG seed)
 * @library /test/lib
 * @build jdk.test.lib.RandomFactory
 * @compile StackRecorderUtil.java
 * @run main/othervm StackWalkTest
 * @run main/othervm/java.security.policy=stackwalktest.policy StackWalkTest
 * @run main/othervm StackWalkTest -random:50
 * @run main/othervm/java.security.policy=stackwalktest.policy StackWalkTest -random:50
 * @author danielfuchs, bchristi
 * @key randomness
 */
public class StackWalkTest {
    private static boolean random = false;
    private static boolean verbose = false;
    private static int randomRuns = 50;

    private static final int MAX_RANDOM_DEPTH = 1000;

    static final Set<String> infrastructureClasses = new TreeSet<>(Arrays.asList(
            "jdk.internal.reflect.NativeMethodAccessorImpl",
            "jdk.internal.reflect.DelegatingMethodAccessorImpl",
            "java.lang.reflect.Method",
            "com.sun.javatest.regtest.MainWrapper$MainThread",
            "com.sun.javatest.regtest.agent.MainWrapper$MainThread",
            "java.lang.Thread"
    ));
    static final List<Class<?>> streamPipelines = Arrays.asList(
        classForName("java.util.stream.AbstractPipeline"),
        classForName("java.util.stream.TerminalOp")
    );
    static Class<?> classForName(String name) {
        try {
            return Class.forName(name);
        } catch (ClassNotFoundException e){
            throw new RuntimeException(e);
        }
    }

    private static boolean isStreamPipeline(Class<?> clazz) {
        for (Class<?> c : streamPipelines) {
            if (c.isAssignableFrom(clazz)) {
                return true;
            }
        }
        return false;
    }

    StackRecorderUtil recorder;
    int count = 0;
    boolean didWalk = false;

    final int estDepth;
    final Set<StackWalker.Option> swOptions;

    public StackWalkTest() {
        this(EnumSet.noneOf(StackWalker.Option.class), -1);
    }

    public StackWalkTest(Set<StackWalker.Option> swOptions) {
        this(swOptions, -1);
    }

    public StackWalkTest(int estimatedDepth) {
        this(EnumSet.noneOf(StackWalker.Option.class), -1);
    }

    public StackWalkTest(Set<StackWalker.Option> swOptions, int estimatedDepth) {
        this.swOptions = swOptions;
        this.estDepth = estimatedDepth;
    }

    private StackWalker createStackWalker() {
        // test all StackWalker factory methods
        if (this.estDepth < 0) {
            if (swOptions.isEmpty()) {
                return StackWalker.getInstance();
            } else {
                return StackWalker.getInstance(swOptions);
            }
        }
        return StackWalker.getInstance(swOptions, estDepth);
    }
    public void consume(StackFrame sf) {
        if (count == 0 && swOptions.contains(StackWalker.Option.RETAIN_CLASS_REFERENCE)
                && isStreamPipeline(sf.getDeclaringClass())) {
            return;
        }
        if (verbose) {
            System.out.println("\t" + sf.getClassName() + "." + sf.getMethodName());
        }
        if (count >= recorder.frameCount()) {
            // We've gone past main()...
            if (infrastructureClasses.contains(sf.getClassName())) {
                // safe to ignore
                return;
            }
        }
        try {
            recorder.compareFrame(count, sf);
        } catch (IndexOutOfBoundsException e) {
            // Extra non-infra frame in stream
            throw new RuntimeException("extra non-infra stack frame at count "
                    + count + ": <" + sf + ">", e);
        }
        count++;
    }

    public class Call {
        public void walk(int total, int markAt) {
            recorder.add(Call.class, "walk", "StackWalkTest.java");
            long swFrameCount = createStackWalker().walk(s -> s.count());

            if (verbose) {
                System.out.println("Call.walk() total=" + total + ", markAt=" + markAt);
                System.out.println("recorder frames:");
                for (StackRecorderUtil.TestFrame f : recorder) {
                    System.out.println("\t" + f.declaringClass + "." + f.methodName);
                }
                System.out.println("\nStackWalker recorded " + swFrameCount + " frames");
                System.out.flush();
            }
            long recFrameCount = (long)recorder.frameCount();
            if (swFrameCount < recFrameCount) {
                throw new RuntimeException("StackWalker recorded fewer frames ("+
                        swFrameCount + ") than recorded ("+ recorder.frameCount() +
                        ") - " + "estimatedDepth set to " + estDepth);
            }
            if (verbose) {
                System.out.println("StackWalker frames:");
            }
            createStackWalker().forEach(StackWalkTest.this::consume);
            didWalk = true;
        }
        public void call(int total, int current, int markAt) {
            recorder.add(Call.class, "call", "StackWalkTest.java");
            if (current < total) {
                testCall.call(total, current+1, markAt);
            } else {
                walk(total, markAt);
            }
        }
    }

    public class Marker extends Call {
        @Override
        public void call(int total, int current, int markAt) {
            recorder.add(Marker.class, "call", "StackWalkTest.java");
            if (current < total) {
                testCall.call(total, current+1, markAt);
            } else {
                walk(total, markAt);
            }
        }
    }
    private Call markerCall = new Marker();

    public class Test extends Call {
        @Override
        public void call(int total, int current, int markAt) {
            recorder.add(Test.class, "call", "StackWalkTest.java");
            if (current < total) {
                int nexti = current + 1;
                if (nexti==markAt) {
                    markerCall.call(total, nexti, markAt);
                } else {
                    testCall.call2(total, nexti, markAt);
                }
            } else {
                walk(total, markAt);
            }
        }
        public void call2(int total, int current, int markAt) {
            recorder.add(Test.class, "call2", "StackWalkTest.java");
            if (current < total) {
                int nexti = current + 1;
                if (nexti==markAt) {
                    markerCall.call(total, nexti, markAt);
                } else {
                    test2Call.call(total, nexti, markAt);
                }
            } else {
                walk(total, markAt);
            }
        }
    }
    private Test testCall = new Test();

    /** Inherits call() from Call */
    public class Test2 extends Call {}
    private Test2 test2Call = new Test2();

    public void runTest(Class callerClass, String callerMethod, int stackDepth,
                        int markAt) {
        if (didWalk) {
            throw new IllegalStateException("StackWalkTest already used");
        }
        // Test may run into StackOverflow when running in -Xcomp mode on deep stack
        assert stackDepth <= 1000;
        assert markAt <= stackDepth : "markAt(" + markAt + ") > stackDepth("
                + stackDepth + ")";
        System.out.print("runTest(" + swOptions
                + "), estimatedDepth=" + estDepth);

        recorder = new StackRecorderUtil(swOptions);
        recorder.add(callerClass, callerMethod, "StackWalkTest.java");
        recorder.add(StackWalkTest.class, "runTest", "StackWalkTest.java");

        Test test1 = new Test();
        test1.call(stackDepth, 0, markAt);

        System.out.println(" finished");
        if (!didWalk) {
            throw new IllegalStateException("Test wasn't actually performed");
        }
    }

    public static void main(String[] args) {
        String rand = "-random";
        String randItems = "-random:";
        for(String arg : args) {
            if (arg.startsWith(rand)) {
                random = true;
                try {
                    if(arg.startsWith(randItems)) {
                        randomRuns = Integer.valueOf(arg.substring(randItems.length()));
                    }
                } catch(NumberFormatException e) {}
            } else if("-verbose".equals(arg)) {
                verbose = true;
            }
        }
        if (random) {
            Random rng = RandomFactory.getRandom();
            for (int iters = 0; iters < randomRuns; iters++) {
                Set<StackWalker.Option> opts = new HashSet<>();
                if (rng.nextBoolean()) {
                    opts.add(RETAIN_CLASS_REFERENCE);
                }

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

                StackWalkTest swt;
                if (rng.nextBoolean() && depth > 1) {
                    // Test that specifying an estimatedDepth doesn't prevent
                    // full stack traversal
                    swt = new StackWalkTest(opts, 1+rng.nextInt(depth-1));
                } else {
                    swt = new StackWalkTest(opts);
                }

                int markAt = rng.nextInt(depth+1);
                System.out.print(depth + "@" + markAt + " ");
                System.out.flush();
                swt.runTest(StackWalkTest.class, "main", depth, markAt);
            }
        } else {
            // Long stack, default maxDepth
            StackWalkTest swt;
            swt = new StackWalkTest();
            swt.runTest(StackWalkTest.class, "main", 1000, 10);

            // Long stack, matching maxDepth
            swt = new StackWalkTest(2000);
            swt.runTest(StackWalkTest.class, "main", 1000, 10);

            // Long stack, maximum maxDepth
            swt = new StackWalkTest(Integer.MAX_VALUE);
            swt.runTest(StackWalkTest.class, "main", 1000, 10);

            //
            // Single batch
            //
            swt = new StackWalkTest(); // default maxDepth
            swt.runTest(StackWalkTest.class, "main", 6, 3);

            swt = new StackWalkTest(4); // maxDepth < stack
            swt.runTest(StackWalkTest.class, "main", 6, 3);

            swt = new StackWalkTest(2); // maxDepth < marker
            swt.runTest(StackWalkTest.class, "main", 6, 4);

            //
            // 2 batches
            //
            swt = new StackWalkTest(); // default maxDepth
            swt.runTest(StackWalkTest.class, "main", 24, 10);
            swt = new StackWalkTest(18); // maxDepth < stack
            swt.runTest(StackWalkTest.class, "main", 24, 10);
            swt = new StackWalkTest(8); // maxDepth < marker
            swt.runTest(StackWalkTest.class, "main", 24, 10);

            //
            // 3 batch
            //
            swt = new StackWalkTest(); // default maxDepth
            swt.runTest(StackWalkTest.class, "main", 60, 20);
            swt = new StackWalkTest(35); // maxDepth < stack
            swt.runTest(StackWalkTest.class, "main", 60, 20);
            swt = new StackWalkTest(8); // maxDepth < marker
            swt.runTest(StackWalkTest.class, "main", 60, 20);

            //
            // StackWalker.Options
            //
            swt = new StackWalkTest();
            swt.runTest(StackWalkTest.class, "main", 50, 10);

            swt = new StackWalkTest(EnumSet.of(RETAIN_CLASS_REFERENCE));
            swt.runTest(StackWalkTest.class, "main", 80, 40);

            swt = new StackWalkTest(EnumSet.of(RETAIN_CLASS_REFERENCE), 50);
            swt.runTest(StackWalkTest.class, "main", 1000, 524);
        }
    }
}