jdk/test/java/lang/StackWalker/LocalsAndOperands.java

/*
 * Copyright (c) 2015, 2016, 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.
 */

/*
 * @test
 * @bug 8020968 8147039
 * @summary Tests for locals and operands
 * @modules java.base/java.lang:open
 * @run testng LocalsAndOperands
 */

import org.testng.annotations.*;
import java.lang.StackWalker.StackFrame;
import java.lang.reflect.*;
import java.util.*;
import java.util.stream.*;

public class LocalsAndOperands {
    static final boolean debug = true;

    static Class<?> liveStackFrameClass;
    static Class<?> primitiveValueClass;
    static StackWalker extendedWalker;
    static Method getLocals;
    static Method getOperands;
    static Method getMonitors;
    static Method primitiveType;

    static {
        try {
            liveStackFrameClass = Class.forName("java.lang.LiveStackFrame");
            primitiveValueClass = Class.forName("java.lang.LiveStackFrame$PrimitiveValue");

            getLocals = liveStackFrameClass.getDeclaredMethod("getLocals");
            getLocals.setAccessible(true);

            getOperands = liveStackFrameClass.getDeclaredMethod("getStack");
            getOperands.setAccessible(true);

            getMonitors = liveStackFrameClass.getDeclaredMethod("getMonitors");
            getMonitors.setAccessible(true);

            primitiveType = primitiveValueClass.getDeclaredMethod("type");
            primitiveType.setAccessible(true);

            Method method = liveStackFrameClass.getMethod("getStackWalker");
            method.setAccessible(true);
            extendedWalker = (StackWalker) method.invoke(null);
        } catch (Throwable t) { throw new RuntimeException(t); }
    }

    /** Helper method to return a StackFrame's locals */
    static Object[] invokeGetLocals(StackFrame arg) {
        try {
            return (Object[]) getLocals.invoke(arg);
        } catch (Exception e) { throw new RuntimeException(e); }
    }

    /*****************
     * DataProviders *
     *****************/

    /** Calls testLocals() and provides LiveStackFrames for testLocals* methods */
    @DataProvider
    public static StackFrame[][] provider() {
        return new StackFrame[][] {
            new Tester().testLocals()
        };
    }

    /**
     * Calls testLocalsKeepAlive() and provides LiveStackFrames for testLocals* methods.
     * Local variables in testLocalsKeepAlive() are ensured to not become dead.
     */
    @DataProvider
    public static StackFrame[][] keepAliveProvider() {
        return new StackFrame[][] {
            new Tester().testLocalsKeepAlive()
        };
    }

    /**
     * Provides StackFrames from a StackWalker without the LOCALS_AND_OPERANDS
     * option.
     */
    @DataProvider
    public static StackFrame[][] noLocalsProvider() {
        // Use default StackWalker
        return new StackFrame[][] {
            new Tester(StackWalker.getInstance(), true).testLocals()
        };
    }

    /**
     * Calls testLocals() and provides LiveStackFrames for *all* called methods,
     * including test infrastructure (jtreg, testng, etc)
     *
     */
    @DataProvider
    public static StackFrame[][] unfilteredProvider() {
        return new StackFrame[][] {
            new Tester(extendedWalker, false).testLocals()
        };
    }

    /****************
     * Test methods *
     ****************/

    /**
     * Check for expected local values and types in the LiveStackFrame
     */
    @Test(dataProvider = "keepAliveProvider")
    public static void checkLocalValues(StackFrame... frames) {
        if (debug) {
            System.out.println("Running checkLocalValues");
            dumpStackWithLocals(frames);
        }
        Arrays.stream(frames).filter(f -> f.getMethodName()
                                           .equals("testLocalsKeepAlive"))
                                           .forEach(
            f -> {
                Object[] locals = invokeGetLocals(f);
                for (int i = 0; i < locals.length; i++) {
                    // Value
                    String expected = Tester.LOCAL_VALUES[i];
                    Object observed = locals[i];
                    if (expected != null /* skip nulls in golden values */ &&
                            !expected.equals(observed.toString())) {
                        System.err.println("Local value mismatch:");
                        if (!debug) { dumpStackWithLocals(frames); }
                        throw new RuntimeException("local " + i + " value is " +
                                observed + ", expected " + expected);
                    }

                    // Type
                    expected = Tester.LOCAL_TYPES[i];
                    observed = type(locals[i]);
                    if (expected != null /* skip nulls in golden values */ &&
                            !expected.equals(observed)) {
                        System.err.println("Local type mismatch:");
                        if (!debug) { dumpStackWithLocals(frames); }
                        throw new RuntimeException("local " + i + " type is " +
                                observed + ", expected " + expected);
                    }
                }
            }
        );
    }

    /**
     * Basic sanity check for locals and operands
     */
    @Test(dataProvider = "provider")
    public static void sanityCheck(StackFrame... frames) {
        if (debug) {
            System.out.println("Running sanityCheck");
        }
        try {
            Stream<StackFrame> stream = Arrays.stream(frames);
            if (debug) {
                stream.forEach(LocalsAndOperands::printLocals);
            } else {
                System.out.println(stream.count() + " frames");
            }
        } catch (Throwable t) {
            dumpStackWithLocals(frames);
            throw t;
        }
    }

    /**
     * Sanity check for locals and operands, including testng/jtreg frames
     */
    @Test(dataProvider = "unfilteredProvider")
    public static void unfilteredSanityCheck(StackFrame... frames) {
        if (debug) {
            System.out.println("Running unfilteredSanityCheck");
        }
        try {
            Stream<StackFrame> stream = Arrays.stream(frames);
            if (debug) {
                stream.forEach(f -> { System.out.println(f + ": " +
                        invokeGetLocals(f).length + " locals"); } );
            } else {
                System.out.println(stream.count() + " frames");
            }
        } catch (Throwable t) {
            dumpStackWithLocals(frames);
            throw t;
        }
    }

    /**
     * Test that LiveStackFrames are not provided with the default StackWalker
     * options.
     */
    @Test(dataProvider = "noLocalsProvider")
    public static void withoutLocalsAndOperands(StackFrame... frames) {
        for (StackFrame frame : frames) {
            if (liveStackFrameClass.isInstance(frame)) {
                throw new RuntimeException("should not be LiveStackFrame");
            }
        }
    }

    static class Tester {
        private StackWalker walker;
        private boolean filter = true; // Filter out testng/jtreg/etc frames?

        Tester() {
            this.walker = extendedWalker;
        }

        Tester(StackWalker walker, boolean filter) {
            this.walker = walker;
            this.filter = filter;
        }

        /**
         * Perform stackwalk without keeping local variables alive and return an
         * array of the collected StackFrames
         */
        private synchronized StackFrame[] testLocals() {
            // Unused local variables will become dead
            int x = 10;
            char c = 'z';
            String hi = "himom";
            long l = 1000000L;
            double d =  3.1415926;

            if (filter) {
                return walker.walk(s -> s.filter(f -> TEST_METHODS.contains(f
                        .getMethodName())).collect(Collectors.toList()))
                        .toArray(new StackFrame[0]);
            } else {
                return walker.walk(s -> s.collect(Collectors.toList()))
                        .toArray(new StackFrame[0]);
            }
        }

        /**
         * Perform stackwalk, keeping local variables alive, and return a list of
         * the collected StackFrames
         */
        private synchronized StackFrame[] testLocalsKeepAlive() {
            int x = 10;
            char c = 'z';
            String hi = "himom";
            long l = 1000000L;
            double d =  3.1415926;

            List<StackWalker.StackFrame> frames;
            if (filter) {
                frames = walker.walk(s -> s.filter(f -> TEST_METHODS.contains(f
                        .getMethodName())).collect(Collectors.toList()));
            } else {
                frames = walker.walk(s -> s.collect(Collectors.toList()));
            }

            // Use local variables so they stay alive
            System.out.println("Stayin' alive: "+x+" "+c+" "+hi+" "+l+" "+d);
            return frames.toArray(new StackFrame[0]); // FIXME: convert to Array here
        }

        // Expected values for locals in testLocals() & testLocalsKeepAlive()
        // TODO: use real values instead of Strings, rebuild doubles & floats, etc
        private final static String[] LOCAL_VALUES = new String[] {
            null, // skip, LocalsAndOperands$Tester@XXX identity is different each run
            "10",
            "122",
            "himom",
            "0",
            null, // skip, fix in 8156073
            null, // skip, fix in 8156073
            null, // skip, fix in 8156073
            "0"
        };

        // Expected types for locals in testLocals() & testLocalsKeepAlive()
        // TODO: use real types
        private final static String[] LOCAL_TYPES = new String[] {
            null, // skip
            "I",
            "I",
            "java.lang.String",
            "I",
            "I",
            "I",
            "I",
            "I"
        };

        final static Map NUM_LOCALS = Map.of("testLocals", 8,
                                             "testLocalsKeepAlive",
                                             LOCAL_VALUES.length);
        private final static Collection<String> TEST_METHODS = NUM_LOCALS.keySet();
    }

    /**
     * Print stack trace with locals
     */
    public static void dumpStackWithLocals(StackFrame...frames) {
        Arrays.stream(frames).forEach(LocalsAndOperands::printLocals);
    }

    /**
     * Print the StackFrame and an indexed list of its locals
     */
    public static void printLocals(StackWalker.StackFrame frame) {
        try {
            System.out.println(frame);
            Object[] locals = (Object[]) getLocals.invoke(frame);
            for (int i = 0; i < locals.length; i++) {
                System.out.format("  local %d: %s type %s\n", i, locals[i], type(locals[i]));
            }

            Object[] operands = (Object[]) getOperands.invoke(frame);
            for (int i = 0; i < operands.length; i++) {
                System.out.format("  operand %d: %s type %s%n", i, operands[i],
                                  type(operands[i]));
            }

            Object[] monitors = (Object[]) getMonitors.invoke(frame);
            for (int i = 0; i < monitors.length; i++) {
                System.out.format("  monitor %d: %s%n", i, monitors[i]);
            }
        } catch (Exception e) { throw new RuntimeException(e); }
    }

    private static String type(Object o) {
        try {
            if (o == null) {
                return "null";
            } else if (primitiveValueClass.isInstance(o)) {
                char c = (char)primitiveType.invoke(o);
                return String.valueOf(c);
            } else {
                return o.getClass().getName();
            }
        } catch(Exception e) { throw new RuntimeException(e); }
    }
}