--- /dev/null	2015-11-09 17:15:05.000000000 -0800
+++ new/jdk/test/java/lang/StackWalker/StackRecorderUtil.java	2015-11-09 17:15:05.000000000 -0800
@@ -0,0 +1,137 @@
+/*
+ * Copyright (c) 2015, 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 java.lang.StackWalker.Option;
+import java.lang.StackWalker.StackFrame;
+import java.util.*;
+
+/**
+ * Utility class for recording a stack trace for later comparison to
+ * StackWalker results.
+ *
+ * StackTraceElement comparison does not include line number, isNativeMethod
+ */
+public class StackRecorderUtil implements Iterable<StackRecorderUtil.TestFrame> {
+    private List<TestFrame> testFrames = new LinkedList();
+
+    private boolean compareClasses;
+    private boolean compareClassNames = true;
+    private boolean compareMethodNames = true;
+    private boolean compareSTEs;
+
+    public StackRecorderUtil(Set<StackWalker.Option> swOptions) {
+        compareClasses = swOptions.contains(Option.RETAIN_CLASS_REFERENCE);
+        compareSTEs = true;
+    }
+
+    /**
+     * Add a method call to this recorded stack.
+     */
+    public void add(Class declaringClass, String methodName, String fileName) {
+        testFrames.add(0, new TestFrame(declaringClass, methodName, fileName));
+    }
+
+    public int frameCount() { return testFrames.size(); }
+
+    /**
+     * Compare the given StackFrame returned from the StackWalker to the
+     * recorded frame at the given index.
+     *
+     * Tests for equality, as well as functional correctness with respect to
+     * the StackWalker's options (e.g. throws or doesn't throw exceptions)
+     */
+    public void compareFrame(int index, StackFrame sf) {
+        TestFrame tf = testFrames.get(index);
+        if (compareClasses) {
+            if (!tf.declaringClass.equals(sf.getDeclaringClass())) {
+                throw new RuntimeException("Expected class: " +
+                  tf.declaringClass.toString() + ", but got: " +
+                  sf.getDeclaringClass().toString());
+            }
+        } else {
+            boolean caught = false;
+            try {
+                sf.getDeclaringClass();
+            } catch (UnsupportedOperationException e) {
+                caught = true;
+            }
+            if (!caught) {
+                throw new RuntimeException("StackWalker did not have " +
+                  "RETAIN_CLASS_REFERENCE Option, but did not throw " +
+                  "UnsupportedOperationException");
+            }
+        }
+
+        if (compareClassNames && !tf.className().equals(sf.getClassName())) {
+            throw new RuntimeException("Expected class name: " + tf.className() +
+                    ", but got: " + sf.getClassName());
+        }
+        if (compareMethodNames && !tf.methodName.equals(sf.getMethodName())) {
+            throw new RuntimeException("Expected method name: " + tf.methodName +
+                    ", but got: " + sf.getMethodName());
+        }
+        if (compareSTEs) {
+            StackTraceElement ste = sf.toStackTraceElement();
+            if (!(ste.getClassName().equals(tf.className()) &&
+                  ste.getMethodName().equals(tf.methodName)) &&
+                  ste.getFileName().equals(tf.fileName)) {
+                throw new RuntimeException("Expected StackTraceElement info: " +
+                        tf + ", but got: " + ste);
+            }
+            if (!Objects.equals(ste.getClassName(), sf.getClassName())
+                || !Objects.equals(ste.getMethodName(), sf.getMethodName())
+                || !Objects.equals(ste.getFileName(), sf.getFileName().orElse(null))
+                || !Objects.equals(ste.getLineNumber(), sf.getLineNumber().orElse(-1))
+                || !Objects.equals(ste.isNativeMethod(), sf.isNativeMethod())) {
+                throw new RuntimeException("StackFrame and StackTraceElement differ: " +
+                        "sf=" + sf + ", ste=" + ste);
+            }
+        }
+    }
+
+    public Iterator<TestFrame> iterator() {
+        return testFrames.iterator();
+    }
+
+    /**
+     * Class used to record stack frame information.
+     */
+    public static class TestFrame {
+        public Class declaringClass;
+        public String methodName;
+        public String fileName = null;
+
+        public TestFrame (Class declaringClass, String methodName, String fileName) {
+            this.declaringClass = declaringClass;
+            this.methodName = methodName;
+            this.fileName = fileName;
+        }
+        public String className() {
+            return declaringClass.getName();
+        }
+        public String toString() {
+            return "TestFrame: " + className() + "." + methodName +
+                    (fileName == null ? "" : "(" + fileName + ")");
+        }
+    }
+}