[GR-14161] Fix exceptions printed during unittest runs.

PullRequest: graal/3025

Author: gilles-duboscq

compiler/src/org.graalvm.compiler.hotspot.test/src/org/graalvm/compiler/hotspot/test/JVMCIInfopointErrorTest.java

@@ -24,6 +24,7 @@
  */
 package org.graalvm.compiler.hotspot.test;
 
+import static org.graalvm.compiler.debug.DebugOptions.DumpOnError;
 import static org.graalvm.compiler.lir.LIRInstruction.OperandFlag.REG;
 import static org.graalvm.compiler.lir.LIRInstruction.OperandFlag.STACK;
 import static org.graalvm.compiler.nodeinfo.NodeCycles.CYCLES_IGNORED;
@@ -52,6 +53,7 @@
 import org.graalvm.compiler.nodes.StructuredGraph;
 import org.graalvm.compiler.nodes.spi.LIRLowerable;
 import org.graalvm.compiler.nodes.spi.NodeLIRBuilderTool;
+import org.graalvm.compiler.options.OptionValues;
 import org.junit.Test;
 
 import jdk.vm.ci.code.BytecodeFrame;
@@ -139,6 +141,14 @@ private void test(TestSpec spec) {
         test(getDebugContext(), spec);
     }
 
+    /**
+     * Avoids dumping during tests which are expected to fail.
+     */
+    private void testNoDump(TestSpec spec) {
+        OptionValues options = new OptionValues(getInitialOptions(), DumpOnError, false);
+        test(getDebugContext(options, null, null), spec);
+    }
+
     private void test(DebugContext debug, TestSpec spec) {
         ResolvedJavaMethod method = getResolvedJavaMethod("testMethod");
 
@@ -154,7 +164,7 @@ private void test(DebugContext debug, TestSpec spec) {
 
     @Test(expected = Error.class)
     public void testInvalidShortOop() {
-        test((tool, state, safepoint) -> {
+        testNoDump((tool, state, safepoint) -> {
             PlatformKind kind = tool.target().arch.getPlatformKind(JavaKind.Short);
             LIRKind lirKind = LIRKind.reference(kind);
 
@@ -167,7 +177,7 @@ public void testInvalidShortOop() {
 
     @Test(expected = Error.class)
     public void testInvalidShortDerivedOop() {
-        test((tool, state, safepoint) -> {
+        testNoDump((tool, state, safepoint) -> {
             Variable baseOop = tool.newVariable(LIRKind.fromJavaKind(tool.target().arch, JavaKind.Object));
             tool.append(new ValueDef(baseOop));
 

compiler/src/org.graalvm.compiler.phases/src/org/graalvm/compiler/phases/util/GraphOrder.java

@@ -30,6 +30,7 @@
 import org.graalvm.collections.EconomicMap;
 import org.graalvm.collections.Equivalence;
 import org.graalvm.compiler.core.common.cfg.Loop;
+import org.graalvm.compiler.debug.DebugContext;
 import org.graalvm.compiler.debug.GraalError;
 import org.graalvm.compiler.graph.GraalGraphError;
 import org.graalvm.compiler.graph.Node;
@@ -153,9 +154,10 @@ private static void visitForward(ArrayList<Node> nodes, NodeBitMap visited, Node
      * This method schedules the graph and makes sure that, for every node, all inputs are available
      * at the position where it is scheduled. This is a very expensive assertion.
      */
+    @SuppressWarnings("try")
     public static boolean assertSchedulableGraph(final StructuredGraph graph) {
         assert graph.getGuardsStage() != GuardsStage.AFTER_FSA : "Cannot use the BlockIteratorClosure after FrameState Assignment, HIR Loop Data Structures are no longer valid.";
-        try {
+        try (DebugContext.Scope s = graph.getDebug().scope("AssertSchedulableGraph")) {
             final SchedulePhase schedulePhase = new SchedulePhase(SchedulingStrategy.LATEST_OUT_OF_LOOPS, true);
             final EconomicMap<LoopBeginNode, NodeBitMap> loopEntryStates = EconomicMap.create(Equivalence.IDENTITY);
             schedulePhase.apply(graph, false);

compiler/src/org.graalvm.compiler.replacements.test/src/org/graalvm/compiler/replacements/test/ReplacementsParseTest.java

@@ -24,6 +24,7 @@
  */
 package org.graalvm.compiler.replacements.test;
 
+import static org.graalvm.compiler.debug.DebugOptions.DumpOnError;
 import static org.graalvm.compiler.java.BytecodeParserOptions.InlinePartialIntrinsicExitDuringParsing;
 
 import java.util.function.Function;
@@ -48,9 +49,11 @@
 import org.graalvm.compiler.nodes.FrameState;
 import org.graalvm.compiler.nodes.PiNode;
 import org.graalvm.compiler.nodes.StructuredGraph;
+import org.graalvm.compiler.nodes.StructuredGraph.AllowAssumptions;
+import org.graalvm.compiler.nodes.StructuredGraph.Builder;
 import org.graalvm.compiler.nodes.ValueNode;
-import org.graalvm.compiler.nodes.extended.OpaqueNode;
 import org.graalvm.compiler.nodes.extended.ForeignCallNode;
+import org.graalvm.compiler.nodes.extended.OpaqueNode;
 import org.graalvm.compiler.nodes.graphbuilderconf.GraphBuilderContext;
 import org.graalvm.compiler.nodes.graphbuilderconf.InlineInvokePlugin;
 import org.graalvm.compiler.nodes.graphbuilderconf.InvocationPlugin.Receiver;
@@ -613,7 +616,10 @@ public static int div(int x, int y) {
     @Test
     public void testAssertionInMethodSubstitution() {
         try {
-            parseEager("div", StructuredGraph.AllowAssumptions.YES);
+            ResolvedJavaMethod method = getResolvedJavaMethod("div");
+            // avoid dumping graphs and printing exception since and exception is expected
+            OptionValues options = new OptionValues(getInitialOptions(), DumpOnError, false);
+            parse(new Builder(options, getDebugContext(options, null, method), AllowAssumptions.YES).method(method).compilationId(getCompilationId(method)), getEagerGraphBuilderSuite());
             throw GraalError.shouldNotReachHere("BytecodeParser should have complained about using assertion in an intrinsic.");
         } catch (BytecodeParserError e) {
             // Expected behavior

compiler/src/org.graalvm.compiler.truffle.test/src/org/graalvm/compiler/truffle/test/CompilerAssertsTest.java

@@ -81,10 +81,11 @@ public int execute(VirtualFrame frame) {
     }
 
     @Test
+    @SuppressWarnings("try")
     public void neverPartOfCompilationTest() {
         NeverPartOfCompilationTestNode result = new NeverPartOfCompilationTestNode();
         RootTestNode rootNode = new RootTestNode(new FrameDescriptor(), "neverPartOfCompilation", result);
-        try {
+        try (PreventDumping noDump = new PreventDumping()) {
             compileHelper("neverPartOfCompilation", rootNode, new Object[0]);
             Assert.fail("Expected bailout exception due to never part of compilation");
         } catch (BailoutException e) {
@@ -93,11 +94,12 @@ public void neverPartOfCompilationTest() {
     }
 
     @Test
+    @SuppressWarnings("try")
     public void compilationNonConstantTest() {
         FrameDescriptor descriptor = new FrameDescriptor();
         CompilationConstantTestNode result = new CompilationConstantTestNode(new NonConstantTestNode(5));
         RootTestNode rootNode = new RootTestNode(descriptor, "compilationConstant", result);
-        try {
+        try (PreventDumping noDump = new PreventDumping()) {
             compileHelper("compilationConstant", rootNode, new Object[0]);
             Assert.fail("Expected bailout exception because expression is not compilation constant");
         } catch (BailoutException e) {

compiler/src/org.graalvm.compiler.truffle.test/src/org/graalvm/compiler/truffle/test/InstrumentBranchesPhaseTest.java

@@ -28,10 +28,9 @@
 import static org.graalvm.compiler.truffle.compiler.TruffleCompilerOptions.TruffleInstrumentBranchesFilter;
 import static org.graalvm.compiler.truffle.compiler.TruffleCompilerOptions.TruffleInstrumentBranchesPretty;
 
-import org.graalvm.compiler.options.OptionValues;
-import org.graalvm.compiler.truffle.compiler.phases.InstrumentPhase;
 import org.graalvm.compiler.truffle.compiler.TruffleCompilerOptions;
 import org.graalvm.compiler.truffle.compiler.TruffleCompilerOptions.TruffleOptionsOverrideScope;
+import org.graalvm.compiler.truffle.compiler.phases.InstrumentPhase;
 import org.graalvm.compiler.truffle.runtime.OptimizedCallTarget;
 import org.graalvm.compiler.truffle.test.nodes.AbstractTestNode;
 import org.graalvm.compiler.truffle.test.nodes.RootTestNode;
@@ -96,10 +95,6 @@ public void disableInstrumentAfterTests() {
         overrides.close();
     }
 
-    private static OptionValues getOptions() {
-        return TruffleCompilerOptions.getOptions();
-    }
-
     @Test
     public void simpleIfTest() {
         InstrumentPhase.Instrumentation instrumentation = truffleCompiler.getPartialEvaluator().getInstrumentation();

compiler/src/org.graalvm.compiler.truffle.test/src/org/graalvm/compiler/truffle/test/PartialEvaluationTest.java

@@ -26,6 +26,7 @@
 
 import static org.graalvm.compiler.core.common.CompilationIdentifier.INVALID_COMPILATION_ID;
 import static org.graalvm.compiler.core.common.CompilationRequestIdentifier.asCompilationRequest;
+import static org.graalvm.compiler.debug.DebugOptions.DumpOnError;
 
 import org.graalvm.compiler.core.common.CompilationIdentifier;
 import org.graalvm.compiler.debug.DebugContext;
@@ -144,7 +145,7 @@ protected StructuredGraph partialEval(OptimizedCallTarget compilable, Object[] a
         } catch (IgnoreError e) {
         }
 
-        OptionValues options = TruffleCompilerOptions.getOptions();
+        OptionValues options = getOptions();
         DebugContext debug = getDebugContext(options);
         try (DebugContext.Scope s = debug.scope("TruffleCompilation", new TruffleDebugJavaMethod(compilable))) {
             TruffleInlining inliningDecision = new TruffleInlining(compilable, new DefaultInliningPolicy());
@@ -155,6 +156,30 @@ protected StructuredGraph partialEval(OptimizedCallTarget compilable, Object[] a
         }
     }
 
+    protected OptionValues getOptions() {
+        OptionValues options = TruffleCompilerOptions.getOptions();
+        if (preventDumping) {
+            options = new OptionValues(options, DumpOnError, false);
+        }
+        return options;
+    }
+
+    private boolean preventDumping = false;
+
+    protected class PreventDumping implements AutoCloseable {
+        private final boolean previous;
+
+        protected PreventDumping() {
+            previous = preventDumping;
+            preventDumping = true;
+        }
+
+        @Override
+        public void close() {
+            preventDumping = previous;
+        }
+    }
+
     protected void removeFrameStates(StructuredGraph graph) {
         for (FrameState frameState : graph.getNodes(FrameState.TYPE)) {
             frameState.replaceAtUsages(null);

compiler/src/org.graalvm.compiler.truffle.test/src/org/graalvm/compiler/truffle/test/SimplePartialEvaluationTest.java

@@ -99,13 +99,14 @@ public void addConstants() {
     }
 
     @Test
+    @SuppressWarnings("try")
     public void neverPartOfCompilationTest() {
         FrameDescriptor fd = new FrameDescriptor();
         AbstractTestNode firstTree = new NeverPartOfCompilationTestNode(new ConstantTestNode(1), 2);
         assertPartialEvalEquals("constant42", new RootTestNode(fd, "neverPartOfCompilationTest", firstTree));
 
         AbstractTestNode secondTree = new NeverPartOfCompilationTestNode(new ConstantTestNode(1), 1);
-        try {
+        try (PreventDumping noDump = new PreventDumping()) {
             assertPartialEvalEquals("constant42", new RootTestNode(fd, "neverPartOfCompilationTest", secondTree));
             Assert.fail("Expected verification error!");
         } catch (GraalBailoutException t) {