jdk-sandbox: comparison jdk/test/java/lang/ProcessBuilder/Basic.java

equal deleted inserted replaced

-:f96e172a6ce8
+:268fbc344d53
 /*
-* Copyright (c) 2003, 2013, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 2003, 2014, 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.
 pb.redirectError(efile);
 equal(pb.redirectError().file(), efile);
 equal(pb.redirectError(), Redirect.to(efile));
 THROWS(IllegalArgumentException.class,
-new Fun(){void f() {
+() -> pb.redirectInput(Redirect.to(ofile)),
-pb.redirectInput(Redirect.to(ofile)); }},
+() -> pb.redirectOutput(Redirect.from(ifile)),
-new Fun(){void f() {
+() -> pb.redirectError(Redirect.from(ifile)));
-pb.redirectInput(Redirect.appendTo(ofile)); }},
-new Fun(){void f() {
-pb.redirectOutput(Redirect.from(ifile)); }},
-new Fun(){void f() {
-pb.redirectError(Redirect.from(ifile)); }});
 THROWS(IOException.class,
 // Input file does not exist
-new Fun(){void f() throws Throwable { pb.start(); }});
+() -> pb.start());
 setFileContents(ifile, "standard input");
 //----------------------------------------------------------------
 // Writing to non-existent files
 //----------------------------------------------------------------
 = new FilePermission("<<ALL FILES>>", "write,execute");
 final Permission rwxPermission
 = new FilePermission("<<ALL FILES>>", "read,write,execute");
 THROWS(SecurityException.class,
-new Fun() { void f() throws IOException {
+() -> { policy.setPermissions(xPermission);
-policy.setPermissions(xPermission);
+redirectIO(pb, from(tmpFile), PIPE, PIPE);
-redirectIO(pb, from(tmpFile), PIPE, PIPE);
+pb.start();},
-pb.start();}},
+() -> { policy.setPermissions(rxPermission);
-new Fun() { void f() throws IOException {
+redirectIO(pb, PIPE, to(ofile), PIPE);
-policy.setPermissions(rxPermission);
+pb.start();},
-redirectIO(pb, PIPE, to(ofile), PIPE);
+() -> { policy.setPermissions(rxPermission);
-pb.start();}},
+redirectIO(pb, PIPE, PIPE, to(efile));
-new Fun() { void f() throws IOException {
+pb.start();});
-policy.setPermissions(rxPermission);
-redirectIO(pb, PIPE, PIPE, to(efile));
-pb.start();}});
 {
 policy.setPermissions(rxPermission);
 redirectIO(pb, from(tmpFile), PIPE, PIPE);
 ProcessResults r = run(pb);
 //----------------------------------------------------------------
 // System.getenv() is read-only.
 //----------------------------------------------------------------
 THROWS(UnsupportedOperationException.class,
-new Fun(){void f(){ getenv().put("FOO","BAR");}},
+() -> getenv().put("FOO","BAR"),
-new Fun(){void f(){ getenv().remove("PATH");}},
+() -> getenv().remove("PATH"),
-new Fun(){void f(){ getenv().keySet().remove("PATH");}},
+() -> getenv().keySet().remove("PATH"),
-new Fun(){void f(){ getenv().values().remove("someValue");}});
+() -> getenv().values().remove("someValue"));
 try {
 Collection<Map.Entry<String,String>> c = getenv().entrySet();
 if (! c.isEmpty())
 try {
 // or an env var name or value containing NUL.
 //----------------------------------------------------------------
 {
 final Map<String,String> m = new ProcessBuilder().environment();
 THROWS(IllegalArgumentException.class,
-new Fun(){void f(){ m.put("FOO=","BAR");}},
+() -> m.put("FOO=","BAR"),
-new Fun(){void f(){ m.put("FOO\u0000","BAR");}},
+() -> m.put("FOO\u0000","BAR"),
-new Fun(){void f(){ m.put("FOO","BAR\u0000");}});
+() -> m.put("FOO","BAR\u0000"));
 }
 //----------------------------------------------------------------
 // Commands must never be null.
 //----------------------------------------------------------------
 THROWS(NullPointerException.class,
-new Fun(){void f(){
+() -> new ProcessBuilder((List<String>)null),
-new ProcessBuilder((List<String>)null);}},
+() -> new ProcessBuilder().command((List<String>)null));
-new Fun(){void f(){
-new ProcessBuilder().command((List<String>)null);}});
 //----------------------------------------------------------------
 // Put in a command; get the same one back out.
 //----------------------------------------------------------------
 try {
 //----------------------------------------------------------------
 // Commands must contain at least one element.
 //----------------------------------------------------------------
 THROWS(IndexOutOfBoundsException.class,
-new Fun() { void f() throws IOException {
+() -> new ProcessBuilder().start(),
-new ProcessBuilder().start();}},
+() -> new ProcessBuilder(new ArrayList<String>()).start(),
-new Fun() { void f() throws IOException {
+() -> Runtime.getRuntime().exec(new String[]{}));
-new ProcessBuilder(new ArrayList<String>()).start();}},
-new Fun() { void f() throws IOException {
-Runtime.getRuntime().exec(new String[]{});}});
 //----------------------------------------------------------------
 // Commands must not contain null elements at start() time.
 //----------------------------------------------------------------
 THROWS(NullPointerException.class,
-new Fun() { void f() throws IOException {
+() -> new ProcessBuilder("foo",null,"bar").start(),
-new ProcessBuilder("foo",null,"bar").start();}},
+() -> new ProcessBuilder((String)null).start(),
-new Fun() { void f() throws IOException {
+() -> new ProcessBuilder(new String[]{null}).start(),
-new ProcessBuilder((String)null).start();}},
+() -> new ProcessBuilder(new String[]{"foo",null,"bar"}).start());
-new Fun() { void f() throws IOException {
-new ProcessBuilder(new String[]{null}).start();}},
-new Fun() { void f() throws IOException {
-new ProcessBuilder(new String[]{"foo",null,"bar"}).start();}});
 //----------------------------------------------------------------
 // Command lists are growable.
 //----------------------------------------------------------------
 try {
 // Nulls in environment updates generate NullPointerException
 //----------------------------------------------------------------
 try {
 final Map<String,String> env = new ProcessBuilder().environment();
 THROWS(NullPointerException.class,
-new Fun(){void f(){ env.put("foo",null);}},
+() -> env.put("foo",null),
-new Fun(){void f(){ env.put(null,"foo");}},
+() -> env.put(null,"foo"),
-new Fun(){void f(){ env.remove(null);}},
+() -> env.remove(null),
-new Fun(){void f(){
+() -> { for (Map.Entry<String,String> e : env.entrySet())
-for (Map.Entry<String,String> e : env.entrySet())
+e.setValue(null);},
-e.setValue(null);}},
+() -> Runtime.getRuntime().exec(new String[]{"foo"},
-new Fun() { void f() throws IOException {
+new String[]{null}));
-Runtime.getRuntime().exec(new String[]{"foo"},
-new String[]{null});}});
 } catch (Throwable t) { unexpected(t); }
 //----------------------------------------------------------------
 // Non-String types in environment updates generate ClassCastException
 //----------------------------------------------------------------
 try {
 final Map<String,String> env = new ProcessBuilder().environment();
 THROWS(ClassCastException.class,
-new Fun(){void f(){ env.remove(TRUE);}},
+() -> env.remove(TRUE),
-new Fun(){void f(){ env.keySet().remove(TRUE);}},
+() -> env.keySet().remove(TRUE),
-new Fun(){void f(){ env.values().remove(TRUE);}},
+() -> env.values().remove(TRUE),
-new Fun(){void f(){ env.entrySet().remove(TRUE);}});
+() -> env.entrySet().remove(TRUE));
 } catch (Throwable t) { unexpected(t); }
 //----------------------------------------------------------------
 // Check query operations on environment maps
 //----------------------------------------------------------------
 for (final Map<String,String> env : envs) {
 //----------------------------------------------------------------
 // Nulls in environment queries are forbidden.
 //----------------------------------------------------------------
 THROWS(NullPointerException.class,
-new Fun(){void f(){ getenv(null);}},
+() -> getenv(null),
-new Fun(){void f(){ env.get(null);}},
+() -> env.get(null),
-new Fun(){void f(){ env.containsKey(null);}},
+() -> env.containsKey(null),
-new Fun(){void f(){ env.containsValue(null);}},
+() -> env.containsValue(null),
-new Fun(){void f(){ env.keySet().contains(null);}},
+() -> env.keySet().contains(null),
-new Fun(){void f(){ env.values().contains(null);}});
+() -> env.values().contains(null));
 //----------------------------------------------------------------
 // Non-String types in environment queries are forbidden.
 //----------------------------------------------------------------
 THROWS(ClassCastException.class,
-new Fun(){void f(){ env.get(TRUE);}},
+() -> env.get(TRUE),
-new Fun(){void f(){ env.containsKey(TRUE);}},
+() -> env.containsKey(TRUE),
-new Fun(){void f(){ env.containsValue(TRUE);}},
+() -> env.containsValue(TRUE),
-new Fun(){void f(){ env.keySet().contains(TRUE);}},
+() -> env.keySet().contains(TRUE),
-new Fun(){void f(){ env.values().contains(TRUE);}});
+() -> env.values().contains(TRUE));
 //----------------------------------------------------------------
 // Illegal String values in environment queries are (grumble) OK
 //----------------------------------------------------------------
 equal(env.get("\u0000"), null);
 try {
 final Set<Map.Entry<String,String>> entrySet =
 new ProcessBuilder().environment().entrySet();
 THROWS(NullPointerException.class,
-new Fun(){void f(){ entrySet.contains(null);}});
+() -> entrySet.contains(null));
 THROWS(ClassCastException.class,
-new Fun(){void f(){ entrySet.contains(TRUE);}},
+() -> entrySet.contains(TRUE),
-new Fun(){void f(){
+() -> entrySet.contains(
-entrySet.contains(
+new SimpleImmutableEntry<Boolean,String>(TRUE,"")));
-new SimpleImmutableEntry<Boolean,String>(TRUE,""));}});
 check(! entrySet.contains
 (new SimpleImmutableEntry<String,String>("", "")));
 } catch (Throwable t) { unexpected(t); }
 new File("suBdiR").mkdirs();
 copy("/bin/true", "suBdiR/unliKely");
 final ProcessBuilder pb =
 new ProcessBuilder(new String[]{"unliKely"});
 pb.environment().put("PATH", "suBdiR");
-THROWS(IOException.class,
+THROWS(IOException.class, () -> pb.start());
-new Fun() {void f() throws Throwable {pb.start();}});
 } catch (Throwable t) { unexpected(t);
 } finally {
 new File("suBdiR/unliKely").delete();
 new File("suBdiR").delete();
 }
 print4095(p.getOutputStream(), (byte) '!'); // Might hang!
 p.waitFor();                                // Might hang!
 equal(SIZE, p.getInputStream().available());
 equal(SIZE, p.getErrorStream().available());
 THROWS(IOException.class,
-new Fun(){void f() throws IOException {
+() -> { p.getOutputStream().write((byte) '!');
-p.getOutputStream().write((byte) '!');
+p.getOutputStream().flush();});
-p.getOutputStream().flush();
-}});
 final byte[] bytes = new byte[SIZE + 1];
 equal(SIZE, p.getInputStream().read(bytes));
 for (int i = 0; i < SIZE; i++)
 equal((byte) '!', bytes[i]);
 try { p.getOutputStream().close(); } catch (IOException flushFailed) { }
 InputStream[] streams = { p.getInputStream(), p.getErrorStream() };
 for (final InputStream in : streams) {
 Fun[] ops = {
-new Fun(){void f() throws IOException {
+() -> in.read(),
-in.read(); }},
+() -> in.read(bytes),
-new Fun(){void f() throws IOException {
+() -> in.available()
-in.read(bytes); }},
-new Fun(){void f() throws IOException {
-in.available(); }}
 };
 for (Fun op : ops) {
 try {
 op.f();
 fail();
 new ProcessBuilder("env").directory(new File("dir")).directory();
 new ProcessBuilder("env").command("??").command();
 } catch (Throwable t) { unexpected(t); }
 THROWS(SecurityException.class,
-new Fun() { void f() throws IOException {
+() -> { policy.setPermissions(/* Nothing */);
-policy.setPermissions(/* Nothing */);
+System.getenv("foo");},
-System.getenv("foo");}},
+() -> { policy.setPermissions(/* Nothing */);
-new Fun() { void f() throws IOException {
+System.getenv();},
-policy.setPermissions(/* Nothing */);
+() -> { policy.setPermissions(/* Nothing */);
-System.getenv();}},
+new ProcessBuilder("echo").start();},
-new Fun() { void f() throws IOException {
+() -> { policy.setPermissions(/* Nothing */);
-policy.setPermissions(/* Nothing */);
+Runtime.getRuntime().exec("echo");},
-new ProcessBuilder("echo").start();}},
+() -> { policy.setPermissions(
-new Fun() { void f() throws IOException {
+new RuntimePermission("getenv.bar"));
-policy.setPermissions(/* Nothing */);
+System.getenv("foo");});
-Runtime.getRuntime().exec("echo");}},
-new Fun() { void f() throws IOException {
-policy.setPermissions(new RuntimePermission("getenv.bar"));
-System.getenv("foo");}});
 try {
 policy.setPermissions(new RuntimePermission("getenv.foo"));
 System.getenv("foo");
 final Permission execPermission
 = new FilePermission("<<ALL FILES>>", "execute");
 THROWS(SecurityException.class,
-new Fun() { void f() throws IOException {
+() -> { // environment permission by itself insufficient
-// environment permission by itself insufficient
+policy.setPermissions(new RuntimePermission("getenv.*"));
-policy.setPermissions(new RuntimePermission("getenv.*"));
+ProcessBuilder pb = new ProcessBuilder("env");
-ProcessBuilder pb = new ProcessBuilder("env");
+pb.environment().put("foo","bar");
-pb.environment().put("foo","bar");
+pb.start();},
-pb.start();}},
+() -> { // exec permission by itself insufficient
-new Fun() { void f() throws IOException {
+policy.setPermissions(execPermission);
-// exec permission by itself insufficient
+ProcessBuilder pb = new ProcessBuilder("env");
-policy.setPermissions(execPermission);
+pb.environment().put("foo","bar");
-ProcessBuilder pb = new ProcessBuilder("env");
+pb.start();});
-pb.environment().put("foo","bar");
-pb.start();}});
 try {
 // Both permissions? OK.
 policy.setPermissions(new RuntimePermission("getenv.*"),
 execPermission);
 public static void main(String[] args) throws Throwable {
 try {realMain(args);} catch (Throwable t) {unexpected(t);}
 System.out.printf("%nPassed = %d, failed = %d%n%n", passed, failed);
 if (failed > 0) throw new AssertionError("Some tests failed");}
-private static abstract class Fun {abstract void f() throws Throwable;}
+interface Fun {void f() throws Throwable;}
 static void THROWS(Class<? extends Throwable> k, Fun... fs) {
 for (Fun f : fs)
 try { f.f(); fail("Expected " + k.getName() + " not thrown"); }
 catch (Throwable t) {
 if (k.isAssignableFrom(t.getClass())) pass();

changeset 24692	268fbc344d53
parent 24577	b3bf9c82a050
child 25804	4ae4525723a5