test/langtools/jdk/jshell/StartOptionTest.java - platform/libcore - Git at Google

 /*
  * Copyright (c) 2015, 2018, 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.
  */

  /*
  * @test 8151754 8080883 8160089 8170162 8166581 8172102 8171343 8178023 8186708 8179856 8185840 8190383
  * @summary Testing startExCe-up options.
  * @modules jdk.compiler/com.sun.tools.javac.api
  *          jdk.compiler/com.sun.tools.javac.main
  *          jdk.jdeps/com.sun.tools.javap
  *          jdk.jshell/jdk.internal.jshell.tool
  * @library /tools/lib
  * @build Compiler toolbox.ToolBox
  * @run testng StartOptionTest
  */
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.InputStream;
 import java.io.PrintStream;
 import java.nio.charset.StandardCharsets;
 import java.nio.file.Path;
 import java.util.HashMap;
 import java.util.Locale;
 import java.util.function.Consumer;

 import java.util.logging.Level;
 import java.util.logging.Logger;
 import java.util.regex.Pattern;

 import org.testng.annotations.AfterMethod;
 import org.testng.annotations.BeforeMethod;
 import org.testng.annotations.Test;
 import jdk.jshell.tool.JavaShellToolBuilder;
 import static org.testng.Assert.assertEquals;
 import static org.testng.Assert.assertFalse;
 import static org.testng.Assert.assertTrue;
 import static org.testng.Assert.fail;

 @Test
 public class StartOptionTest {

     protected ByteArrayOutputStream cmdout;
     protected ByteArrayOutputStream cmderr;
     protected ByteArrayOutputStream console;
     protected ByteArrayOutputStream userout;
     protected ByteArrayOutputStream usererr;
     protected InputStream cmdInStream;

     private JavaShellToolBuilder builder() {
         // turn on logging of launch failures
         Logger.getLogger("jdk.jshell.execution").setLevel(Level.ALL);
         return JavaShellToolBuilder
                 .builder()
                 .out(new PrintStream(cmdout), new PrintStream(console), new PrintStream(userout))
                 .err(new PrintStream(cmderr), new PrintStream(usererr))
                 .in(cmdInStream, null)
                 .persistence(new HashMap<>())
                 .env(new HashMap<>())
                 .locale(Locale.ROOT);
     }

     protected int runShell(String... args) {
         try {
             return builder()
                     .start(args);
         } catch (Exception ex) {
             fail("Repl tool died with exception", ex);
         }
         return -1; // for compiler
     }

     protected void check(ByteArrayOutputStream str, Consumer<String> checkOut, String label) {
         byte[] bytes = str.toByteArray();
         str.reset();
         String out = new String(bytes, StandardCharsets.UTF_8);
         out = stripAnsi(out);
         out = out.replaceAll("[\r\n]+", "\n");
         if (checkOut != null) {
             checkOut.accept(out);
         } else {
             assertEquals(out, "", label + ": Expected empty -- ");
         }
     }

     protected void checkExit(int ec, Consumer<Integer> checkCode) {
         if (checkCode != null) {
             checkCode.accept(ec);
         } else {
             assertEquals(ec, 0, "Expected standard exit code (0), but found: " + ec);
         }
     }

     // Start and check the resultant: exit code (Ex), command output (Co),
     // user output (Uo), command error (Ce), and console output (Cn)
     protected void startExCoUoCeCn(Consumer<Integer> checkExitCode,
             Consumer<String> checkCmdOutput,
             Consumer<String> checkUserOutput,
             Consumer<String> checkError,
             Consumer<String> checkConsole,
             String... args) {
         int ec = runShell(args);
         checkExit(ec, checkExitCode);
         check(cmdout, checkCmdOutput, "cmdout");
         check(cmderr, checkError, "cmderr");
         check(console, checkConsole, "console");
         check(userout, checkUserOutput, "userout");
         check(usererr, null, "usererr");
     }

     // Start with an exit code and command error check
     protected void startExCe(int eec, Consumer<String> checkError, String... args) {
         StartOptionTest.this.startExCoUoCeCn(
                 (Integer ec) -> assertEquals((int) ec, eec,
                         "Expected error exit code (" + eec + "), but found: " + ec),
                 null, null, checkError, null, args);
     }

     // Start with a command output check
     protected void startCo(Consumer<String> checkCmdOutput, String... args) {
         StartOptionTest.this.startExCoUoCeCn(null, checkCmdOutput, null, null, null, args);
     }

     private Consumer<String> assertOrNull(String expected, String label) {
         return expected == null
                 ? null
                 : s -> assertEquals(s.replaceAll("\\r\\n?", "\n").trim(), expected.trim(), label);
     }

     // Start and check the resultant: exit code (Ex), command output (Co),
     // user output (Uo), command error (Ce), and console output (Cn)
     protected void startExCoUoCeCn(int expectedExitCode,
             String expectedCmdOutput,
             String expectedUserOutput,
             String expectedError,
             String expectedConsole,
             String... args) {
         startExCoUoCeCn(
                 expectedExitCode == 0
                         ? null
                         : (Integer i) -> assertEquals((int) i, expectedExitCode,
                         "Expected exit code (" + expectedExitCode + "), but found: " + i),
                 assertOrNull(expectedCmdOutput, "cmdout: "),
                 assertOrNull(expectedUserOutput, "userout: "),
                 assertOrNull(expectedError, "cmderr: "),
                 assertOrNull(expectedConsole, "console: "),
                 args);
     }

     // Start with an expected exit code and command error
     protected void startExCe(int ec, String expectedError, String... args) {
         startExCoUoCeCn(ec, null, null, expectedError, null, args);
     }

     // Start with an expected command output
     protected void startCo(String expectedCmdOutput, String... args) {
         startExCoUoCeCn(0, expectedCmdOutput, null, null, null, args);
     }

     // Start with an expected user output
     protected void startUo(String expectedUserOutput, String... args) {
         startExCoUoCeCn(0, null, expectedUserOutput, null, null, args);
     }

     @BeforeMethod
     public void setUp() {
         cmdout = new ByteArrayOutputStream();
         cmderr = new ByteArrayOutputStream();
         console = new ByteArrayOutputStream();
         userout = new ByteArrayOutputStream();
         usererr = new ByteArrayOutputStream();
         setIn("/exit\n");
     }

     protected String writeToFile(String stuff) {
         Compiler compiler = new Compiler();
         Path p = compiler.getPath("doit.repl");
         compiler.writeToFile(p, stuff);
         return p.toString();
     }

     // Set the input from a String
     protected void setIn(String s) {
         cmdInStream = new ByteArrayInputStream(s.getBytes());
     }

     // Test load files
     public void testCommandFile() {
         String fn = writeToFile("String str = \"Hello \"\n" +
                 "/list\n" +
                 "System.out.println(str + str)\n" +
                 "/exit\n");
         startExCoUoCeCn(0,
                 "1 : String str = \"Hello \";\n",
                 "Hello Hello",
                 null,
                 null,
                 "--no-startup", fn, "-s");
     }

     // Test that the usage message is printed
     public void testUsage() {
         for (String opt : new String[]{"-?", "-h", "--help"}) {
             startCo(s -> {
                 assertTrue(s.split("\n").length >= 7, "Not enough usage lines: " + s);
                 assertTrue(s.startsWith("Usage:   jshell <option>..."), "Unexpect usage start: " + s);
                 assertTrue(s.contains("--show-version"), "Expected help: " + s);
                 assertFalse(s.contains("Welcome"), "Unexpected start: " + s);
             }, opt);
         }
     }

     // Test the --help-extra message
     public void testHelpExtra() {
         for (String opt : new String[]{"-X", "--help-extra"}) {
             startCo(s -> {
                 assertTrue(s.split("\n").length >= 5, "Not enough help-extra lines: " + s);
                 assertTrue(s.contains("--add-exports"), "Expected --add-exports: " + s);
                 assertTrue(s.contains("--execution"), "Expected --execution: " + s);
                 assertFalse(s.contains("Welcome"), "Unexpected start: " + s);
             }, opt);
         }
     }

     // Test handling of bogus options
     public void testUnknown() {
         startExCe(1, "Unknown option: u", "-unknown");
         startExCe(1, "Unknown option: unknown", "--unknown");
     }

     // Test that input is read with "-" and there is no extra output.
     public void testHypenFile() {
         setIn("System.out.print(\"Hello\");\n");
         startUo("Hello", "-");
         setIn("System.out.print(\"Hello\");\n");
         startUo("Hello", "-", "-");
         String fn = writeToFile("System.out.print(\"===\");");
         setIn("System.out.print(\"Hello\");\n");
         startUo("===Hello===", fn, "-", fn);
         // check that errors go to standard error
         setIn(") Foobar");
         startExCe(0, s -> assertTrue(s.contains("illegal start of expression"),
                 "cmderr: illegal start of expression"),
                 "-");
     }

     // Test that user specified exit codes are propagated
     public void testExitCode() {
         setIn("/exit 57\n");
         startExCoUoCeCn(57, null, null, null, "-> /exit 57", "-s");
         setIn("int eight = 8\n" +
                 "/exit eight + \n" +
                 " eight\n");
         startExCoUoCeCn(16, null, null, null,
                 "-> int eight = 8\n" +
                 "-> /exit eight + \n" +
                 ">>  eight",
                 "-s");
     }

     // Test that non-existent load file sends output to stderr and does not startExCe (no welcome).
     public void testUnknownLoadFile() {
         startExCe(1, "File 'UNKNOWN' for 'jshell' is not found.", "UNKNOWN");
     }

     // Test bad usage of the --startup option
     public void testStartup() {
         String fn = writeToFile("");
         startExCe(1, "Argument to startup missing.", "--startup");
         startExCe(1, "Conflicting options: both --startup and --no-startup were used.", "--no-startup", "--startup", fn);
         startExCe(1, "Conflicting options: both --startup and --no-startup were used.", "--startup", fn, "--no-startup");
         startExCe(1, "Argument to startup missing.", "--no-startup", "--startup");
     }

     // Test an option that causes the back-end to fail is propagated
     public void testStartupFailedOption() {
         startExCe(1, s -> assertTrue(s.contains("Unrecognized option: -hoge-foo-bar"), "cmderr: " + s),
                 "-R-hoge-foo-bar");
     }

     // Test the use of non-existant files with the --startup option
     public void testStartupUnknown() {
         startExCe(1, "File 'UNKNOWN' for '--startup' is not found.", "--startup", "UNKNOWN");
         startExCe(1, "File 'UNKNOWN' for '--startup' is not found.", "--startup", "DEFAULT", "--startup", "UNKNOWN");
     }

     // Test bad usage of --class-path option
     public void testClasspath() {
         for (String cp : new String[]{"--class-path"}) {
             startExCe(1, "Only one --class-path option may be used.", cp, ".", "--class-path", ".");
             startExCe(1, "Argument to class-path missing.", cp);
         }
     }

     // Test bogus module on --add-modules option
     public void testUnknownModule() {
         startExCe(1, s -> assertTrue(s.contains("rror") && s.contains("unKnown"), "cmderr: " + s),
                 "--add-modules", "unKnown");
     }

     // Test that muliple feedback options fail
     public void testFeedbackOptionConflict() {
         startExCe(1, "Only one feedback option (--feedback, -q, -s, or -v) may be used.",
                 "--feedback", "concise", "--feedback", "verbose");
         startExCe(1, "Only one feedback option (--feedback, -q, -s, or -v) may be used.", "--feedback", "concise", "-s");
         startExCe(1, "Only one feedback option (--feedback, -q, -s, or -v) may be used.", "--feedback", "verbose", "-q");
         startExCe(1, "Only one feedback option (--feedback, -q, -s, or -v) may be used.", "--feedback", "concise", "-v");
         startExCe(1, "Only one feedback option (--feedback, -q, -s, or -v) may be used.", "-v", "--feedback", "concise");
         startExCe(1, "Only one feedback option (--feedback, -q, -s, or -v) may be used.", "-q", "-v");
         startExCe(1, "Only one feedback option (--feedback, -q, -s, or -v) may be used.", "-s", "-v");
         startExCe(1, "Only one feedback option (--feedback, -q, -s, or -v) may be used.", "-v", "-q");
         startExCe(1, "Only one feedback option (--feedback, -q, -s, or -v) may be used.", "-q", "-s");
     }

     // Test bogus arguments to the --feedback option
     public void testNegFeedbackOption() {
         startExCe(1, "Argument to feedback missing.", "--feedback");
         startExCe(1, "Does not match any current feedback mode: blorp -- --feedback blorp", "--feedback", "blorp");
     }

     // Test --version
     public void testVersion() {
         startCo(s -> {
             assertTrue(s.startsWith("jshell"), "unexpected version: " + s);
             assertFalse(s.contains("Welcome"), "Unexpected start: " + s);
         },
                 "--version");
     }

     // Test --show-version
     public void testShowVersion() {
         startExCoUoCeCn(null,
                 s -> {
                     assertTrue(s.startsWith("jshell"), "unexpected version: " + s);
                     assertTrue(s.contains("Welcome"), "Expected start (but got no welcome): " + s);
                 },
                 null,
                 null,
                 s -> assertTrue(s.trim().startsWith("jshell>"), "Expected prompt, got: " + s),
                 "--show-version");
     }

     @AfterMethod
     public void tearDown() {
         cmdout = null;
         cmderr = null;
         console = null;
         userout = null;
         usererr = null;
         cmdInStream = null;
     }

     private static String stripAnsi(String str) {
         if (str == null) return "";
         return ANSI_CODE_PATTERN.matcher(str).replaceAll("");
     }

     public static final Pattern ANSI_CODE_PATTERN = Pattern.compile("\033\\[[\060-\077]*[\040-\057]*[\100-\176]");
 }
	/*
	* Copyright (c) 2015, 2018, 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.
	*/

	/*
	* @test 8151754 8080883 8160089 8170162 8166581 8172102 8171343 8178023 8186708 8179856 8185840 8190383
	* @summary Testing startExCe-up options.
	* @modules jdk.compiler/com.sun.tools.javac.api
	* jdk.compiler/com.sun.tools.javac.main
	* jdk.jdeps/com.sun.tools.javap
	* jdk.jshell/jdk.internal.jshell.tool
	* @library /tools/lib
	* @build Compiler toolbox.ToolBox
	* @run testng StartOptionTest
	*/
	import java.io.ByteArrayInputStream;
	import java.io.ByteArrayOutputStream;
	import java.io.InputStream;
	import java.io.PrintStream;
	import java.nio.charset.StandardCharsets;
	import java.nio.file.Path;
	import java.util.HashMap;
	import java.util.Locale;
	import java.util.function.Consumer;

	import java.util.logging.Level;
	import java.util.logging.Logger;
	import java.util.regex.Pattern;

	import org.testng.annotations.AfterMethod;
	import org.testng.annotations.BeforeMethod;
	import org.testng.annotations.Test;
	import jdk.jshell.tool.JavaShellToolBuilder;
	import static org.testng.Assert.assertEquals;
	import static org.testng.Assert.assertFalse;
	import static org.testng.Assert.assertTrue;
	import static org.testng.Assert.fail;

	@Test
	public class StartOptionTest {

	protected ByteArrayOutputStream cmdout;
	protected ByteArrayOutputStream cmderr;
	protected ByteArrayOutputStream console;
	protected ByteArrayOutputStream userout;
	protected ByteArrayOutputStream usererr;
	protected InputStream cmdInStream;

	private JavaShellToolBuilder builder() {
	// turn on logging of launch failures
	Logger.getLogger("jdk.jshell.execution").setLevel(Level.ALL);
	return JavaShellToolBuilder
	.builder()
	.out(new PrintStream(cmdout), new PrintStream(console), new PrintStream(userout))
	.err(new PrintStream(cmderr), new PrintStream(usererr))
	.in(cmdInStream, null)
	.persistence(new HashMap<>())
	.env(new HashMap<>())
	.locale(Locale.ROOT);
	}

	protected int runShell(String... args) {
	try {
	return builder()
	.start(args);
	} catch (Exception ex) {
	fail("Repl tool died with exception", ex);
	}
	return -1; // for compiler
	}

	protected void check(ByteArrayOutputStream str, Consumer<String> checkOut, String label) {
	byte[] bytes = str.toByteArray();
	str.reset();
	String out = new String(bytes, StandardCharsets.UTF_8);
	out = stripAnsi(out);
	out = out.replaceAll("[\r\n]+", "\n");
	if (checkOut != null) {
	checkOut.accept(out);
	} else {
	assertEquals(out, "", label + ": Expected empty -- ");
	}
	}

	protected void checkExit(int ec, Consumer<Integer> checkCode) {
	if (checkCode != null) {
	checkCode.accept(ec);
	} else {
	assertEquals(ec, 0, "Expected standard exit code (0), but found: " + ec);
	}
	}

	// Start and check the resultant: exit code (Ex), command output (Co),
	// user output (Uo), command error (Ce), and console output (Cn)
	protected void startExCoUoCeCn(Consumer<Integer> checkExitCode,
	Consumer<String> checkCmdOutput,
	Consumer<String> checkUserOutput,
	Consumer<String> checkError,
	Consumer<String> checkConsole,
	String... args) {
	int ec = runShell(args);
	checkExit(ec, checkExitCode);
	check(cmdout, checkCmdOutput, "cmdout");
	check(cmderr, checkError, "cmderr");
	check(console, checkConsole, "console");
	check(userout, checkUserOutput, "userout");
	check(usererr, null, "usererr");
	}

	// Start with an exit code and command error check
	protected void startExCe(int eec, Consumer<String> checkError, String... args) {
	StartOptionTest.this.startExCoUoCeCn(
	(Integer ec) -> assertEquals((int) ec, eec,
	"Expected error exit code (" + eec + "), but found: " + ec),
	null, null, checkError, null, args);
	}

	// Start with a command output check
	protected void startCo(Consumer<String> checkCmdOutput, String... args) {
	StartOptionTest.this.startExCoUoCeCn(null, checkCmdOutput, null, null, null, args);
	}

	private Consumer<String> assertOrNull(String expected, String label) {
	return expected == null
	? null
	: s -> assertEquals(s.replaceAll("\\r\\n?", "\n").trim(), expected.trim(), label);
	}

	// Start and check the resultant: exit code (Ex), command output (Co),
	// user output (Uo), command error (Ce), and console output (Cn)
	protected void startExCoUoCeCn(int expectedExitCode,
	String expectedCmdOutput,
	String expectedUserOutput,
	String expectedError,
	String expectedConsole,
	String... args) {
	startExCoUoCeCn(
	expectedExitCode == 0
	? null
	: (Integer i) -> assertEquals((int) i, expectedExitCode,
	"Expected exit code (" + expectedExitCode + "), but found: " + i),
	assertOrNull(expectedCmdOutput, "cmdout: "),
	assertOrNull(expectedUserOutput, "userout: "),
	assertOrNull(expectedError, "cmderr: "),
	assertOrNull(expectedConsole, "console: "),
	args);
	}

	// Start with an expected exit code and command error
	protected void startExCe(int ec, String expectedError, String... args) {
	startExCoUoCeCn(ec, null, null, expectedError, null, args);
	}

	// Start with an expected command output
	protected void startCo(String expectedCmdOutput, String... args) {
	startExCoUoCeCn(0, expectedCmdOutput, null, null, null, args);
	}

	// Start with an expected user output
	protected void startUo(String expectedUserOutput, String... args) {
	startExCoUoCeCn(0, null, expectedUserOutput, null, null, args);
	}

	@BeforeMethod
	public void setUp() {
	cmdout = new ByteArrayOutputStream();
	cmderr = new ByteArrayOutputStream();
	console = new ByteArrayOutputStream();
	userout = new ByteArrayOutputStream();
	usererr = new ByteArrayOutputStream();
	setIn("/exit\n");
	}

	protected String writeToFile(String stuff) {
	Compiler compiler = new Compiler();
	Path p = compiler.getPath("doit.repl");
	compiler.writeToFile(p, stuff);
	return p.toString();
	}

	// Set the input from a String
	protected void setIn(String s) {
	cmdInStream = new ByteArrayInputStream(s.getBytes());
	}

	// Test load files
	public void testCommandFile() {
	String fn = writeToFile("String str = \"Hello \"\n" +
	"/list\n" +
	"System.out.println(str + str)\n" +
	"/exit\n");
	startExCoUoCeCn(0,
	"1 : String str = \"Hello \";\n",
	"Hello Hello",
	null,
	null,
	"--no-startup", fn, "-s");
	}

	// Test that the usage message is printed
	public void testUsage() {
	for (String opt : new String[]{"-?", "-h", "--help"}) {
	startCo(s -> {
	assertTrue(s.split("\n").length >= 7, "Not enough usage lines: " + s);
	assertTrue(s.startsWith("Usage: jshell <option>..."), "Unexpect usage start: " + s);
	assertTrue(s.contains("--show-version"), "Expected help: " + s);
	assertFalse(s.contains("Welcome"), "Unexpected start: " + s);
	}, opt);
	}
	}

	// Test the --help-extra message
	public void testHelpExtra() {
	for (String opt : new String[]{"-X", "--help-extra"}) {
	startCo(s -> {
	assertTrue(s.split("\n").length >= 5, "Not enough help-extra lines: " + s);
	assertTrue(s.contains("--add-exports"), "Expected --add-exports: " + s);
	assertTrue(s.contains("--execution"), "Expected --execution: " + s);
	assertFalse(s.contains("Welcome"), "Unexpected start: " + s);
	}, opt);
	}
	}

	// Test handling of bogus options
	public void testUnknown() {
	startExCe(1, "Unknown option: u", "-unknown");
	startExCe(1, "Unknown option: unknown", "--unknown");
	}

	// Test that input is read with "-" and there is no extra output.
	public void testHypenFile() {
	setIn("System.out.print(\"Hello\");\n");
	startUo("Hello", "-");
	setIn("System.out.print(\"Hello\");\n");
	startUo("Hello", "-", "-");
	String fn = writeToFile("System.out.print(\"===\");");
	setIn("System.out.print(\"Hello\");\n");
	startUo("===Hello===", fn, "-", fn);
	// check that errors go to standard error
	setIn(") Foobar");
	startExCe(0, s -> assertTrue(s.contains("illegal start of expression"),
	"cmderr: illegal start of expression"),
	"-");
	}

	// Test that user specified exit codes are propagated
	public void testExitCode() {
	setIn("/exit 57\n");
	startExCoUoCeCn(57, null, null, null, "-> /exit 57", "-s");
	setIn("int eight = 8\n" +
	"/exit eight + \n" +
	" eight\n");
	startExCoUoCeCn(16, null, null, null,
	"-> int eight = 8\n" +
	"-> /exit eight + \n" +
	">> eight",
	"-s");
	}

	// Test that non-existent load file sends output to stderr and does not startExCe (no welcome).
	public void testUnknownLoadFile() {
	startExCe(1, "File 'UNKNOWN' for 'jshell' is not found.", "UNKNOWN");
	}

	// Test bad usage of the --startup option
	public void testStartup() {
	String fn = writeToFile("");
	startExCe(1, "Argument to startup missing.", "--startup");
	startExCe(1, "Conflicting options: both --startup and --no-startup were used.", "--no-startup", "--startup", fn);
	startExCe(1, "Conflicting options: both --startup and --no-startup were used.", "--startup", fn, "--no-startup");
	startExCe(1, "Argument to startup missing.", "--no-startup", "--startup");
	}

	// Test an option that causes the back-end to fail is propagated
	public void testStartupFailedOption() {
	startExCe(1, s -> assertTrue(s.contains("Unrecognized option: -hoge-foo-bar"), "cmderr: " + s),
	"-R-hoge-foo-bar");
	}

	// Test the use of non-existant files with the --startup option
	public void testStartupUnknown() {
	startExCe(1, "File 'UNKNOWN' for '--startup' is not found.", "--startup", "UNKNOWN");
	startExCe(1, "File 'UNKNOWN' for '--startup' is not found.", "--startup", "DEFAULT", "--startup", "UNKNOWN");
	}

	// Test bad usage of --class-path option
	public void testClasspath() {
	for (String cp : new String[]{"--class-path"}) {
	startExCe(1, "Only one --class-path option may be used.", cp, ".", "--class-path", ".");
	startExCe(1, "Argument to class-path missing.", cp);
	}
	}

	// Test bogus module on --add-modules option
	public void testUnknownModule() {
	startExCe(1, s -> assertTrue(s.contains("rror") && s.contains("unKnown"), "cmderr: " + s),
	"--add-modules", "unKnown");
	}

	// Test that muliple feedback options fail
	public void testFeedbackOptionConflict() {
	startExCe(1, "Only one feedback option (--feedback, -q, -s, or -v) may be used.",
	"--feedback", "concise", "--feedback", "verbose");
	startExCe(1, "Only one feedback option (--feedback, -q, -s, or -v) may be used.", "--feedback", "concise", "-s");
	startExCe(1, "Only one feedback option (--feedback, -q, -s, or -v) may be used.", "--feedback", "verbose", "-q");
	startExCe(1, "Only one feedback option (--feedback, -q, -s, or -v) may be used.", "--feedback", "concise", "-v");
	startExCe(1, "Only one feedback option (--feedback, -q, -s, or -v) may be used.", "-v", "--feedback", "concise");
	startExCe(1, "Only one feedback option (--feedback, -q, -s, or -v) may be used.", "-q", "-v");
	startExCe(1, "Only one feedback option (--feedback, -q, -s, or -v) may be used.", "-s", "-v");
	startExCe(1, "Only one feedback option (--feedback, -q, -s, or -v) may be used.", "-v", "-q");
	startExCe(1, "Only one feedback option (--feedback, -q, -s, or -v) may be used.", "-q", "-s");
	}

	// Test bogus arguments to the --feedback option
	public void testNegFeedbackOption() {
	startExCe(1, "Argument to feedback missing.", "--feedback");
	startExCe(1, "Does not match any current feedback mode: blorp -- --feedback blorp", "--feedback", "blorp");
	}

	// Test --version
	public void testVersion() {
	startCo(s -> {
	assertTrue(s.startsWith("jshell"), "unexpected version: " + s);
	assertFalse(s.contains("Welcome"), "Unexpected start: " + s);
	},
	"--version");
	}

	// Test --show-version
	public void testShowVersion() {
	startExCoUoCeCn(null,
	s -> {
	assertTrue(s.startsWith("jshell"), "unexpected version: " + s);
	assertTrue(s.contains("Welcome"), "Expected start (but got no welcome): " + s);
	},
	null,
	null,
	s -> assertTrue(s.trim().startsWith("jshell>"), "Expected prompt, got: " + s),
	"--show-version");
	}

	@AfterMethod
	public void tearDown() {
	cmdout = null;
	cmderr = null;
	console = null;
	userout = null;
	usererr = null;
	cmdInStream = null;
	}

	private static String stripAnsi(String str) {
	if (str == null) return "";
	return ANSI_CODE_PATTERN.matcher(str).replaceAll("");
	}

	public static final Pattern ANSI_CODE_PATTERN = Pattern.compile("\033\\[[\060-\077][\040-\057][\100-\176]");
	}