/* * Copyright (c) 2023, 2025, 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.io.Writer; import java.lang.reflect.Method; import java.nio.file.Files; import java.nio.file.Path; import java.nio.file.Paths; import java.util.ArrayList; import java.util.stream.Stream; import jdk.test.lib.process.OutputAnalyzer; import jdk.test.lib.process.ProcessTools; import org.junit.jupiter.api.Assumptions; import org.junit.jupiter.api.BeforeAll; import org.junit.jupiter.api.Nested; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.condition.EnabledOnOs; import org.junit.jupiter.api.condition.OS; import org.junit.jupiter.api.extension.AfterTestExecutionCallback; import org.junit.jupiter.api.extension.BeforeTestExecutionCallback; import org.junit.jupiter.api.extension.ExtendWith; import org.junit.jupiter.api.extension.ExtensionContext; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.Arguments; import org.junit.jupiter.params.provider.MethodSource; import org.junit.jupiter.params.provider.ValueSource; import static org.junit.jupiter.api.Assertions.*; /* * @test * @bug 8305457 8342936 8351435 8344706 * @summary java.lang.IO tests * @library /test/lib * @modules jdk.internal.le * @run junit IO */ @ExtendWith(IO.TimingExtension.class) public class IO { @Nested @EnabledOnOs({OS.LINUX, OS.MAC}) public class OSSpecificTests { private static Path expect; @BeforeAll public static void prepareTTY() { expect = Paths.get("/usr/bin/expect"); // os-specific path if (!Files.exists(expect) || !Files.isExecutable(expect)) { Assumptions.abort("'" + expect + "' not found"); } try { var outputAnalyzer = ProcessTools.executeProcess( expect.toAbsolutePath().toString(), "-version"); outputAnalyzer.reportDiagnosticSummary(); } catch (Exception _) { } } /* * Unlike printTest, which tests a _default_ console that is normally * jdk.internal.org.jline.JdkConsoleProviderImpl, this test tests * jdk.internal.io.JdkConsoleImpl. Those console implementations operate * in different conditions and, thus, are tested separately. * * To test jdk.internal.io.JdkConsoleImpl one needs to ensure that both * conditions are met: * * - a non-existent console provider is requested * - isatty is true * * To achieve isatty, the test currently uses the EXPECT(1) Unix command, * which does not work for Windows. Later, a library like pty4j or JPty * might be used instead of EXPECT, to cover both Unix and Windows. */ @ParameterizedTest @ValueSource(strings = {"println", "print"}) public void outputTestInteractive(String mode) throws Exception { var testSrc = System.getProperty("test.src", "."); OutputAnalyzer output = ProcessTools.executeProcess( expect.toString(), Path.of(testSrc, "output.exp").toAbsolutePath().toString(), System.getProperty("test.jdk") + "/bin/java", "--enable-preview", "-Djdk.console=gibberish", Path.of(testSrc, "Output.java").toAbsolutePath().toString(), mode); assertEquals(0, output.getExitValue()); assertTrue(output.getStderr().isEmpty()); output.reportDiagnosticSummary(); String out = output.getStdout(); // The first half of the output is produced by Console, the second // half is produced by IO: those halves must match. // Executing Console and IO in the same VM (as opposed to // consecutive VM runs, which are cleaner) to be able to compare string // representation of objects. assertFalse(out.isBlank()); assertEquals(out.substring(0, out.length() / 2), out.substring(out.length() / 2)); } /* * This tests simulates terminal interaction (isatty), to check that the * prompt is output. * * To simulate a terminal, the test currently uses the EXPECT(1) Unix * command, which does not work for Windows. Later, a library like pty4j * or JPty might be used instead of EXPECT, to cover both Unix and Windows. */ @ParameterizedTest @MethodSource("args") public void inputTestInteractive(String console, String prompt) throws Exception { var testSrc = System.getProperty("test.src", "."); var command = new ArrayList(); command.add(expect.toString()); String expectInputName = PROMPT_NONE.equals(prompt) ? "input-no-prompt" : "input"; command.add(Path.of(testSrc, expectInputName + ".exp").toAbsolutePath().toString()); command.add(System.getProperty("test.jdk") + "/bin/java"); command.add("--enable-preview"); if (console != null) command.add("-Djdk.console=" + console); command.add(Path.of(testSrc, "Input.java").toAbsolutePath().toString()); command.add(prompt == null ? "0" : PROMPT_NONE.equals(prompt) ? "2" : "1"); command.add(String.valueOf(prompt)); OutputAnalyzer output = ProcessTools.executeProcess(command.toArray(new String[]{})); output.reportDiagnosticSummary(); assertEquals(0, output.getExitValue()); } private static final String PROMPT_NONE = "prompt-none"; public static Stream args() { // cross product: consoles x prompts return Stream.of("jdk.internal.le", "gibberish").flatMap(console -> Stream.of(null, "?", "%s", PROMPT_NONE) .map(prompt -> new String[]{console, prompt}).map(Arguments::of)); } } @ParameterizedTest @ValueSource(strings = {"println", "print"}) public void printTest(String mode) throws Exception { var file = Path.of(System.getProperty("test.src", "."), "Output.java") .toAbsolutePath().toString(); var pb = ProcessTools.createTestJavaProcessBuilder("-Djdk.console=jdk.internal.le", "--enable-preview", file, mode); OutputAnalyzer output = ProcessTools.executeProcess(pb); assertEquals(0, output.getExitValue()); assertTrue(output.getStderr().isEmpty()); output.reportDiagnosticSummary(); String out = output.getStdout(); // The first half of the output is produced by Console, the second // half is produced by IO: those halves must match. // Executing Console and IO in the same VM (as opposed to // consecutive VM runs, which are cleaner) to be able to compare string // representation of objects. assertFalse(out.isBlank()); assertEquals(out.substring(0, out.length() / 2), out.substring(out.length() / 2)); } @Test //JDK-8342936 public void printlnNoParamsTest() throws Exception { var file = Path.of("PrintlnNoParams.java"); try (Writer w = Files.newBufferedWriter(file)) { w.write(""" import static java.lang.IO.*; void main() { print("1 "); print("2 "); print("3 "); println(); } """); } var pb = ProcessTools.createTestJavaProcessBuilder("-Djdk.console=jdk.internal.le", "--enable-preview", file.toString()); OutputAnalyzer output = ProcessTools.executeProcess(pb); assertEquals(0, output.getExitValue()); assertTrue(output.getStderr().isEmpty()); output.reportDiagnosticSummary(); String out = output.getStdout(); String nl = System.getProperty("line.separator"); assertEquals("1 2 3 " + nl, out); } // adapted from https://junit.org/junit5/docs/current/user-guide/#extensions-lifecycle-callbacks-timing-extension // remove after CODETOOLS-7903752 propagates to jtreg that this test is routinely run by public static class TimingExtension implements BeforeTestExecutionCallback, AfterTestExecutionCallback { private static final System.Logger logger = System.getLogger( TimingExtension.class.getName()); private static final String START_TIME = "start time"; @Override public void beforeTestExecution(ExtensionContext context) { getStore(context).put(START_TIME, time()); } @Override public void afterTestExecution(ExtensionContext context) { Method testMethod = context.getRequiredTestMethod(); long startTime = getStore(context).remove(START_TIME, long.class); long duration = time() - startTime; logger.log(System.Logger.Level.INFO, () -> String.format("Method [%s] took %s ms.", testMethod.getName(), duration)); } private ExtensionContext.Store getStore(ExtensionContext context) { return context.getStore(ExtensionContext.Namespace.create(getClass(), context.getRequiredTestMethod())); } private long time() { return System.nanoTime() / 1_000_000; } } }