More DRY

Rather than following all `newBuilder` by `withLogHandler` ones, making
the builder use `JulHandler` by default.
This change required changes to `ExecCompilerTest` and
`HelloWorldCacheTest` to make use of log messages rather than stdout.

Author: hubertp

engine/runtime-integration-tests/src/test/java/org/enso/compiler/test/BindingsMapResolutionTest.java

@@ -11,22 +11,22 @@
 import java.util.List;
 import java.util.Set;
 import java.util.function.Consumer;
-import java.util.logging.Level;
 import org.enso.common.RuntimeOptions;
 import org.enso.compiler.data.BindingsMap;
 import org.enso.compiler.data.BindingsMap.ResolutionError;
 import org.enso.compiler.data.BindingsMap.ResolvedConstructor;
 import org.enso.compiler.data.BindingsMap.ResolvedModule;
 import org.enso.compiler.data.BindingsMap.ResolvedName;
 import org.enso.compiler.data.BindingsMap.ResolvedType;
-import org.enso.logger.JulHandler;
 import org.enso.pkg.QualifiedName;
 import org.enso.polyglot.PolyglotContext;
 import org.enso.test.utils.ContextUtils;
 import org.enso.test.utils.ProjectUtils;
 import org.enso.test.utils.SourceModule;
+import org.enso.testkit.ReportLogsOnFailureRule;
 import org.junit.ClassRule;
 import org.junit.Ignore;
+import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.TemporaryFolder;
 import scala.jdk.CollectionConverters;
@@ -36,6 +36,9 @@ public class BindingsMapResolutionTest {
 
   @ClassRule public static final TemporaryFolder TMP_DIR = new TemporaryFolder();
 
+  @Rule(order = Integer.MIN_VALUE)
+  public ReportLogsOnFailureRule appenderRule = new ReportLogsOnFailureRule();
+
   @Test
   public void resolveSingleName_FromSingleImport() throws IOException {
     var projDir = createProject("import local.Proj.My_Vector.My_Vector");
@@ -641,7 +644,6 @@ private static ContextUtils createCtx(Path projDir) {
     return ContextUtils.newBuilder()
         .withModifiedContext(
             bldr -> bldr.option(RuntimeOptions.PROJECT_ROOT, projDir.toAbsolutePath().toString()))
-        .withLogHandler(Level.FINE, JulHandler.get())
         .build();
   }
 

engine/runtime-integration-tests/src/test/java/org/enso/compiler/test/ExecCompilerTest.java

@@ -1,6 +1,5 @@
 package org.enso.compiler.test;
 
-import static org.enso.compiler.test.ExecStrictCompilerTest.ctxRule;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.Matchers.containsString;
 import static org.junit.Assert.assertEquals;
@@ -15,25 +14,22 @@
 import org.enso.common.RuntimeOptions;
 import org.enso.compiler.core.ir.expression.errors.Conversion.DeclaredAsPrivate$;
 import org.enso.test.utils.ContextUtils;
+import org.enso.testkit.ReportLogsOnFailureRule;
 import org.graalvm.polyglot.PolyglotException;
 import org.graalvm.polyglot.Source;
 import org.hamcrest.core.AllOf;
-import org.junit.After;
-import org.junit.ClassRule;
-import org.junit.Ignore;
-import org.junit.Test;
+import org.junit.*;
 
 public class ExecCompilerTest {
-  /**
-   * Not using JulHandler as a handler since some tests capture and verify reported errors in
-   * strict-errors mode.
-   */
   @ClassRule
   public static final ContextUtils ctxRule =
       ContextUtils.newBuilder()
           .withModifiedContext(ctxBldr -> ctxBldr.option(RuntimeOptions.STRICT_ERRORS, "false"))
           .build();
 
+  @Rule(order = Integer.MIN_VALUE)
+  public ReportLogsOnFailureRule appenderRule = new ReportLogsOnFailureRule();
+
   @After
   public void cleanup() {
     ctxRule.resetOut();
@@ -532,7 +528,8 @@ public void illegalPrivateConversion() {
     var expectedErrMsg = DeclaredAsPrivate$.MODULE$.explain();
     var runMethod = module.invokeMember(Module.EVAL_EXPRESSION, "run");
     runMethod.execute(0);
-    assertThat(ctxRule.getOut(), containsString(expectedErrMsg));
+    assertTrue(
+        appenderRule.pendingLogMessages().stream().anyMatch(e -> e.contains(expectedErrMsg)));
   }
 
   @Test

engine/runtime-integration-tests/src/test/java/org/enso/compiler/test/ExecStrictCompilerTest.java

@@ -10,11 +10,9 @@
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
 
-import java.util.logging.Level;
 import org.enso.common.LanguageInfo;
 import org.enso.common.MethodNames;
 import org.enso.common.RuntimeOptions;
-import org.enso.logger.JulHandler;
 import org.enso.test.utils.ContextUtils;
 import org.enso.testkit.ReportLogsOnFailureRule;
 import org.graalvm.polyglot.PolyglotException;
@@ -30,7 +28,6 @@ public class ExecStrictCompilerTest {
   public static final ContextUtils ctxRule =
       ContextUtils.newBuilder()
           .withModifiedContext(ctxBldr -> ctxBldr.option(RuntimeOptions.STRICT_ERRORS, "true"))
-          .withLogHandler(Level.FINE, JulHandler.get())
           .build();
 
   @Rule(order = Integer.MIN_VALUE)

engine/runtime-integration-tests/src/test/java/org/enso/compiler/test/ExportCycleDetectionTest.java

@@ -10,8 +10,6 @@
 import java.io.IOException;
 import java.nio.file.Path;
 import java.util.Set;
-import java.util.logging.Level;
-import org.enso.logger.JulHandler;
 import org.enso.pkg.QualifiedName;
 import org.enso.polyglot.PolyglotContext;
 import org.enso.test.utils.ContextUtils;
@@ -130,11 +128,7 @@ public void noCycleDetectedWhenExportingSymbolsFromItself_2() throws IOException
   private void expectNoCompilationErrors(Path projDir, String code) throws IOException {
     var mainMod = new SourceModule(QualifiedName.fromString("Main"), code);
     ProjectUtils.createProject("Proj", Set.of(mainMod), projDir);
-    try (var ctx =
-        ContextUtils.newBuilder()
-            .withProjectRoot(projDir)
-            .withLogHandler(Level.FINE, JulHandler.get())
-            .build()) {
+    try (var ctx = ContextUtils.newBuilder().withProjectRoot(projDir).build()) {
       var polyCtx = new PolyglotContext(ctx.context());
       try {
         polyCtx.getTopScope().compile(true);
@@ -148,11 +142,7 @@ private void expectNoCompilationErrors(Path projDir, String code) throws IOExcep
   }
 
   private void expectProjectCompilationError(Path projDir, Matcher<String> errMsgMatcher) {
-    try (var ctx =
-        ContextUtils.newBuilder()
-            .withProjectRoot(projDir)
-            .withLogHandler(Level.FINE, JulHandler.get())
-            .build()) {
+    try (var ctx = ContextUtils.newBuilder().withProjectRoot(projDir).build()) {
       var polyCtx = new PolyglotContext(ctx.context());
       try {
         polyCtx.getTopScope().compile(true);

engine/runtime-integration-tests/src/test/java/org/enso/compiler/test/ExportedSymbolsTest.java

@@ -13,10 +13,8 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
-import java.util.logging.Level;
 import org.enso.compiler.context.CompilerContext.Module;
 import org.enso.compiler.data.BindingsMap;
-import org.enso.logger.JulHandler;
 import org.enso.pkg.QualifiedName;
 import org.enso.polyglot.PolyglotContext;
 import org.enso.test.utils.ContextUtils;
@@ -233,10 +231,7 @@ public void exportSyntheticModule() throws IOException {
   }
 
   private static ContextUtils createCtx(Path projDir) {
-    return ContextUtils.newBuilder()
-        .withProjectRoot(projDir)
-        .withLogHandler(Level.FINE, JulHandler.get())
-        .build();
+    return ContextUtils.newBuilder().withProjectRoot(projDir).build();
   }
 
   private static void compile(ContextUtils ctx) {

engine/runtime-integration-tests/src/test/java/org/enso/compiler/test/ImportsAndFQNConsistencyTest.java

@@ -8,7 +8,6 @@
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
-import java.util.logging.Level;
 import java.util.stream.Collectors;
 import org.enso.common.RuntimeOptions;
 import org.enso.compiler.core.ir.module.scope.Definition;
@@ -17,7 +16,6 @@
 import org.enso.compiler.data.BindingsMap.ResolvedModule;
 import org.enso.compiler.data.BindingsMap.ResolvedType;
 import org.enso.interpreter.runtime.EnsoContext;
-import org.enso.logger.JulHandler;
 import org.enso.test.utils.ContextUtils;
 import org.enso.testkit.ReportLogsOnFailureRule;
 import org.junit.ClassRule;
@@ -48,7 +46,6 @@ public class ImportsAndFQNConsistencyTest {
   public static final ContextUtils ctxRule =
       ContextUtils.newBuilder()
           .withModifiedContext(ctxBldr -> ctxBldr.option(RuntimeOptions.DISABLE_IR_CACHES, "false"))
-          .withLogHandler(Level.FINE, JulHandler.get())
           .build();
 
   @Rule(order = Integer.MIN_VALUE)

engine/runtime-integration-tests/src/test/java/org/enso/compiler/test/WarningsAsErrorsTest.java

@@ -4,9 +4,7 @@
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
 
-import java.util.logging.Level;
 import org.enso.common.RuntimeOptions;
-import org.enso.logger.JulHandler;
 import org.enso.test.utils.ContextUtils;
 import org.enso.testkit.ReportLogsOnFailureRule;
 import org.graalvm.polyglot.PolyglotException;
@@ -20,7 +18,6 @@ public class WarningsAsErrorsTest {
       ContextUtils.newBuilder()
           .withModifiedContext(
               ctxBldr -> ctxBldr.option(RuntimeOptions.TREAT_WARNINGS_AS_ERRORS, "true"))
-          .withLogHandler(Level.FINE, JulHandler.get())
           .build();
 
   @Rule(order = Integer.MIN_VALUE)

engine/runtime-integration-tests/src/test/java/org/enso/interpreter/caches/HelloWorldCacheTest.java

@@ -10,11 +10,16 @@
 import java.util.stream.Collectors;
 import org.enso.common.RuntimeOptions;
 import org.enso.test.utils.ContextUtils;
+import org.enso.testkit.ReportLogsOnFailureRule;
 import org.graalvm.polyglot.Source;
+import org.junit.Rule;
 import org.junit.Test;
 
 public class HelloWorldCacheTest {
 
+  @Rule(order = Integer.MIN_VALUE)
+  public ReportLogsOnFailureRule appenderRule = new ReportLogsOnFailureRule();
+
   @Test
   public void loadingHelloWorldTwiceUsesCaching() throws Exception {
     var root = new File("../..").getAbsoluteFile();
@@ -23,23 +28,24 @@ public void loadingHelloWorldTwiceUsesCaching() throws Exception {
     assertTrue("Hello_World.enso found", helloWorld.exists());
 
     // the first run may or may not use caches
-    var firstMsgs = executeOnce(helloWorld);
+    var firstMsgs = executeOnce(helloWorld).stdout();
     assertTrue("Contains hello world:\n" + firstMsgs, firstMsgs.endsWith("Hello World"));
     // after the first run the caches for Hello_World.enso must be generated
 
     // the second run must read Hello_World from its .ir file!
-    var secondMsgs = executeOnce(helloWorld);
+    var secondMsgsOutput = executeOnce(helloWorld);
+    var secondMsgs = secondMsgsOutput.stdout();
     assertTrue("Contains hello world:\n" + secondMsgs, secondMsgs.contains("Hello World"));
     assertThat(
-        "Properly deserialized:\n" + secondMsgs,
-        secondMsgs,
+        "Properly deserialized:\n" + secondMsgsOutput.logs(),
+        secondMsgsOutput.logs(),
         allOf(
             containsString("Deserializing module"),
             containsString("Hello_World"),
             containsString("from IR file: true")));
   }
 
-  private static String executeOnce(File src) throws Exception {
+  private OutputPair executeOnce(File src) throws Exception {
     try (var ctx =
         ContextUtils.newBuilder()
             .withModifiedContext(
@@ -52,13 +58,22 @@ private static String executeOnce(File src) throws Exception {
       var code = Source.newBuilder("enso", src).build();
       var res = ctx.evalModule(code, "main");
       assertTrue("Result of IO.println is Nothing", res.isNull());
-      return ctx.getOut()
-          .lines()
-          .filter(l -> l.toUpperCase().contains("HELLO"))
-          .collect(Collectors.joining("\n"));
+      var result =
+          new OutputPair(
+              ctx.getOut()
+                  .lines()
+                  .filter(l -> l.toUpperCase().contains("HELLO"))
+                  .collect(Collectors.joining("\n")),
+              appenderRule.pendingLogMessages().stream()
+                  .filter(l -> l.toUpperCase().contains("HELLO"))
+                  .collect(Collectors.joining("\n")));
+      appenderRule.dropPendingMessages();
+      return result;
     }
   }
 
+  private record OutputPair(String stdout, String logs) {}
+
   private static File children(File f, String... names) {
     for (var n : names) {
       f = new File(f, n);

engine/runtime-integration-tests/src/test/java/org/enso/interpreter/caches/ModuleCacheTest.java

@@ -5,12 +5,10 @@
 import static org.junit.Assert.assertTrue;
 
 import java.nio.ByteBuffer;
-import java.util.logging.Level;
 import org.enso.common.CompilationStage;
 import org.enso.common.MethodNames;
 import org.enso.common.RuntimeOptions;
 import org.enso.compiler.test.CompilerTests;
-import org.enso.logger.JulHandler;
 import org.enso.test.utils.ContextUtils;
 import org.enso.testkit.ReportLogsOnFailureRule;
 import org.graalvm.polyglot.Source;
@@ -23,7 +21,6 @@ public class ModuleCacheTest {
   public static final ContextUtils ctxRule =
       ContextUtils.newBuilder()
           .withModifiedContext(ctxBldr -> ctxBldr.option(RuntimeOptions.DISABLE_IR_CACHES, "true"))
-          .withLogHandler(Level.FINE, JulHandler.get())
           .build();
 
   @Rule(order = Integer.MIN_VALUE)

engine/runtime-integration-tests/src/test/java/org/enso/interpreter/runtime/ModuleTest.java

@@ -10,13 +10,11 @@
 
 import java.io.File;
 import java.io.IOException;
-import java.util.logging.Level;
 import org.enso.common.LanguageInfo;
 import org.enso.common.MethodNames;
 import org.enso.common.RuntimeOptions;
 import org.enso.compiler.data.BindingsMap;
 import org.enso.compiler.data.BindingsMap$ModuleReference$Concrete;
-import org.enso.logger.JulHandler;
 import org.enso.pkg.QualifiedName;
 import org.enso.test.utils.ContextUtils;
 import org.enso.testkit.ReportLogsOnFailureRule;
@@ -36,7 +34,6 @@ public class ModuleTest {
   public static final ContextUtils ctxRule =
       ContextUtils.newBuilder()
           .withModifiedContext(b -> b.option(RuntimeOptions.STRICT_ERRORS, "false"))
-          .withLogHandler(Level.FINE, JulHandler.get())
           .build();
 
   @Rule(order = Integer.MIN_VALUE)