Process .test.java as just .java in-memory for javac to accept the public class inside

Gedochao · Gedochao · commit 865857fb9640 · 2026-05-11T13:55:36.000+02:00
diff --git a/modules/build/src/main/scala/scala/build/preprocessing/JavaPreprocessor.scala b/modules/build/src/main/scala/scala/build/preprocessing/JavaPreprocessor.scala
@@ -52,15 +52,44 @@ final case class JavaPreprocessor(
             )
               .preprocess(content)
           }
-          Seq(PreprocessedSource.OnDisk(
-            path = j.path,
-            options = Some(preprocessedDirectives.globalUsings),
-            optionsWithTargetRequirements = preprocessedDirectives.usingsWithReqs,
-            requirements = Some(preprocessedDirectives.globalReqs),
-            scopedRequirements = preprocessedDirectives.scopedReqs,
-            mainClassOpt = None,
-            directivesPositions = preprocessedDirectives.directivesPositions
-          ))
+          // Java's source-file rule requires that a public class be declared in a file named
+          // exactly `<ClassName>.java`, so emit `*.test.java` as an in-memory source whose
+          // generated path strips the `.test` infix. This lets users follow the same naming
+          // convention as `.test.scala` for routing while still compiling under `javac`.
+          val testJavaSuffix          = ".test.java"
+          val preprocessedJavaSources =
+            if j.subPath.last.endsWith(testJavaSuffix) then {
+              val strippedFileName =
+                s"${j.subPath.last.stripSuffix(testJavaSuffix)}.java"
+              val strippedSubPath: os.SubPath =
+                if j.subPath.segments.sizeIs > 1 then
+                  os.sub / j.subPath.segments.init / strippedFileName
+                else os.sub / strippedFileName
+              Seq(PreprocessedSource.InMemory(
+                originalPath = Right((j.subPath, j.path)),
+                relPath = os.rel / strippedSubPath,
+                content = content.getBytes(StandardCharsets.UTF_8),
+                wrapperParamsOpt = None,
+                options = Some(preprocessedDirectives.globalUsings),
+                optionsWithTargetRequirements = preprocessedDirectives.usingsWithReqs,
+                requirements = Some(preprocessedDirectives.globalReqs),
+                scopedRequirements = preprocessedDirectives.scopedReqs,
+                mainClassOpt = None,
+                scopePath = scopePath,
+                directivesPositions = preprocessedDirectives.directivesPositions
+              ))
+            }
+            else
+              Seq(PreprocessedSource.OnDisk(
+                path = j.path,
+                options = Some(preprocessedDirectives.globalUsings),
+                optionsWithTargetRequirements = preprocessedDirectives.usingsWithReqs,
+                requirements = Some(preprocessedDirectives.globalReqs),
+                scopedRequirements = preprocessedDirectives.scopedReqs,
+                mainClassOpt = None,
+                directivesPositions = preprocessedDirectives.directivesPositions
+              ))
+          preprocessedJavaSources
         })
       case v: VirtualJavaFile =>
         val res = either {
diff --git a/modules/build/src/test/scala/scala/build/tests/SourcesTests.scala b/modules/build/src/test/scala/scala/build/tests/SourcesTests.scala
@@ -334,12 +334,12 @@ class SourcesTests extends TestUtil.ScalaCliBuildSuite {
     }
   }
 
-  /** Asserts that the only Java source produced by `testInputs` is routed to the test scope and
-    * appears at `expectedPath`.
+  /** Asserts that the only Java source produced by `testInputs` is routed to the test scope and is
+    * reachable on disk at `expectedOnDiskPath`.
     */
   private def expectJavaFileRoutedToTestScope(
     testInputs: TestInputs,
-    expectedPath: os.RelPath
+    expectedOnDiskPath: os.RelPath
   ): Unit =
     testInputs.withInputs { (root, inputs) =>
       val (crossSources, _) =
@@ -367,36 +367,68 @@ class SourcesTests extends TestUtil.ScalaCliBuildSuite {
         ).orThrow
 
       expect(mainSources.paths.isEmpty)
-      expect(testSources.paths.map(_._2) == Seq(expectedPath))
+      expect(mainSources.inMemory.isEmpty)
+      val onDiskPaths           = testSources.paths.map(_._2)
+      val inMemoryOriginalPaths =
+        testSources.inMemory.flatMap(_.originalPath.toOption.map(_._1: os.SubPath))
+      expect((onDiskPaths ++ inMemoryOriginalPaths.map(os.rel / _)) == Seq(expectedOnDiskPath))
     }
 
-  private val javaTestSourceContent: String =
-    """public class Something {
-      |  public int a = 1;
-      |}
-      |""".stripMargin
+  private val javaTestPublicClassName: String = "Something"
+  private val javaTestSourceContent: String   =
+    s"""public class $javaTestPublicClassName {
+       |  public int a = 1;
+       |}
+       |""".stripMargin
 
   test("a .test.java file should be routed to the test scope") {
-    val expectedPath = os.rel / "Something.test.java"
-    val testInputs   = TestInputs(expectedPath -> javaTestSourceContent)
-    expectJavaFileRoutedToTestScope(testInputs, expectedPath)
+    val onDiskPath = os.rel / s"$javaTestPublicClassName.test.java"
+    val testInputs = TestInputs(onDiskPath -> javaTestSourceContent)
+    expectJavaFileRoutedToTestScope(testInputs, onDiskPath)
+  }
+
+  test("a .test.java file's generated path strips the .test infix for javac") {
+    val onDiskPath = os.rel / s"$javaTestPublicClassName.test.java"
+    TestInputs(onDiskPath -> javaTestSourceContent).withInputs { (root, inputs) =>
+      val (crossSources, _) =
+        CrossSources.forInputs(
+          inputs,
+          preprocessors,
+          TestLogger(),
+          SuppressWarningOptions()
+        ).orThrow
+
+      val scopedSources = crossSources.scopedSources(BuildOptions()).orThrow
+      val testSources   =
+        scopedSources.sources(
+          Scope.Test,
+          crossSources.sharedOptions(BuildOptions()),
+          root,
+          TestLogger()
+        ).orThrow
+
+      val expectedGeneratedRelPath = os.rel / s"$javaTestPublicClassName.java"
+      expect(testSources.paths.isEmpty)
+      expect(testSources.inMemory.length == 1)
+      expect(testSources.inMemory.head.generatedRelPath == expectedGeneratedRelPath)
+    }
   }
 
   test("a .java file under a test/ directory should be routed to the test scope") {
-    val expectedPath = os.rel / "test" / "Something.java"
-    val testInputs   = TestInputs(Seq(expectedPath -> javaTestSourceContent), Seq("."))
-    expectJavaFileRoutedToTestScope(testInputs, expectedPath)
+    val onDiskPath = os.rel / "test" / s"$javaTestPublicClassName.java"
+    val testInputs = TestInputs(Seq(onDiskPath -> javaTestSourceContent), Seq("."))
+    expectJavaFileRoutedToTestScope(testInputs, onDiskPath)
   }
 
   test("a .java file with //> using target.scope test should be routed to the test scope") {
-    val expectedPath = os.rel / "Something.java"
-    val testInputs   = TestInputs(
-      expectedPath ->
+    val onDiskPath = os.rel / s"$javaTestPublicClassName.java"
+    val testInputs = TestInputs(
+      onDiskPath ->
         s"""//> using target.scope test
            |
            |$javaTestSourceContent""".stripMargin
     )
-    expectJavaFileRoutedToTestScope(testInputs, expectedPath)
+    expectJavaFileRoutedToTestScope(testInputs, onDiskPath)
   }
 
   test("should skip SheBang in .sc and .scala") {
diff --git a/modules/integration/src/test/scala/scala/cli/integration/TestTestDefinitions.scala b/modules/integration/src/test/scala/scala/cli/integration/TestTestDefinitions.scala
@@ -834,28 +834,41 @@ abstract class TestTestDefinitions extends ScalaCliSuite with TestScalaVersionAr
     }
   }
 
-  test("successful pure Java test with JUnit") {
-    val expectedMessage = "Hello from JUnit"
-    TestInputs(
-      os.rel / "test" / "MyTests.java" ->
-        s"""//> using test.dependencies junit:junit:4.13.2
-           |//> using test.dependencies com.novocode:junit-interface:0.11
-           |import org.junit.Test;
-           |import static org.junit.Assert.assertEquals;
-           |
-           |public class MyTests {
-           |  @Test
-           |  public void foo() {
-           |    assertEquals(4, 2 + 2);
-           |    System.out.println("$expectedMessage");
-           |  }
-           |}
-           |""".stripMargin
-    ).fromRoot { root =>
-      val res = os.proc(TestUtil.cli, "test", extraOptions, ".").call(cwd = root)
-      expect(res.out.text().contains(expectedMessage))
-    }
+  for {
+    (placementName, fileRelPath, extraDirectives, extraCliFlags) <- Seq(
+      (".test.java suffix", os.rel / "MyTests.test.java", "", Seq.empty[String]),
+      ("test/ subdirectory", os.rel / "test" / "MyTests.java", "", Seq.empty[String]),
+      (
+        "//> using target.scope test",
+        os.rel / "MyTests.java",
+        "//> using target.scope test\n",
+        Seq("--power")
+      )
+    )
+    expectedMessage = "Hello from JUnit"
   }
+    test(s"successful pure Java test with JUnit ($placementName)") {
+      TestInputs(
+        fileRelPath ->
+          s"""$extraDirectives//> using test.dep junit:junit:4.13.2
+             |//> using test.dep com.novocode:junit-interface:0.11
+             |import org.junit.Test;
+             |import static org.junit.Assert.assertEquals;
+             |
+             |public class MyTests {
+             |  @Test
+             |  public void foo() {
+             |    assertEquals(4, 2 + 2);
+             |    System.out.println("$expectedMessage");
+             |  }
+             |}
+             |""".stripMargin
+      ).fromRoot { root =>
+        val res =
+          os.proc(TestUtil.cli, extraCliFlags, "test", extraOptions, ".").call(cwd = root)
+        expect(res.out.text().contains(expectedMessage))
+      }
+    }
 
   test(s"zio-test warning when zio-test-sbt was not passed") {
     TestUtil.retryOnCi() {
