test/java/lang/Runtime/exec/ExecWithInput.java

Print this page




  22  */
  23 
  24 /* @test
  25  * @bug 4763384
  26  * @summary Ensure that piped input always works with exec'd processes
  27  */
  28 
  29 import java.io.*;
  30 
  31 
  32 /**
  33  * This class demonstrates a regression in java1.4.1 in the handling of the
  34  * Process OutputStream (exec'd process stdin).  The subprocess completes 100%
  35  * of the time in 1.4, but about only about 50% of the time under 1.4.1.  Issue
  36  * exists for client JVM, Linux Redhat 6.2 not sure about other variants of
  37  * Linux or other OSes, or server JVM.
  38  */
  39 
  40 public class ExecWithInput {
  41 
  42     private static final String CAT = "/bin/cat";

  43     private static final int N = 200;
  44 
  45     static int go(int i) throws Exception {
  46         /*
  47          * Execute /bin/cat supplying two lines of input. cat should
  48          * read the input lines and copy them to stdout. On completion,
  49          * p.waitFor should return and the exit status is printed and this
  50          * program exits. Under 1.4.1, cat sometimes gets stuck on a pipe
  51          * read and never terminates.
  52          */
  53         //Process p = Runtime.getRuntime().exec(new String[] { CAT } );
  54         Process p = Runtime.getRuntime().exec(CAT);
  55 
  56         String input = i + ": line 1\n" + i + ": line 2\n";
  57         StringBufferInputStream in = new StringBufferInputStream(input);
  58         // create threads to handle I/O streams
  59         IO ioIn = new IO("stdin", in, p.getOutputStream());
  60         IO ioOut = new IO("stdout", p.getInputStream(), System.out);
  61         IO ioErr = new IO("stderr", p.getErrorStream(), System.err);
  62 
  63         // wait for process to exit
  64         return p.waitFor();
  65     }
  66 
  67     public static void main(String[] args) throws Exception {
  68         if (!System.getProperty("os.name").equals("Linux"))
  69             return;
  70         if (File.separatorChar == '\\') {
  71             // no /bin/cat on windows
  72             return;
  73         }
  74         for (int i = 0; i < N; i++)
  75             go(i);
  76     }
  77 
  78     /**
  79      * Handle IO. Thread is started in constructor.
  80      */
  81     static class IO extends Thread {
  82 
  83         private InputStream in;
  84         private OutputStream out;
  85 
  86         IO(String name, InputStream in, OutputStream out)
  87         {
  88             this.in = in;
  89             this.out = out;
  90             setName(name);
  91             start();




  22  */
  23 
  24 /* @test
  25  * @bug 4763384
  26  * @summary Ensure that piped input always works with exec'd processes
  27  */
  28 
  29 import java.io.*;
  30 
  31 
  32 /**
  33  * This class demonstrates a regression in java1.4.1 in the handling of the
  34  * Process OutputStream (exec'd process stdin).  The subprocess completes 100%
  35  * of the time in 1.4, but about only about 50% of the time under 1.4.1.  Issue
  36  * exists for client JVM, Linux Redhat 6.2 not sure about other variants of
  37  * Linux or other OSes, or server JVM.
  38  */
  39 
  40 public class ExecWithInput {
  41 
  42     static final boolean isLinux =
  43             System.getProperty("os.name", "unknown").startsWith("Linux");
  44     private static final int N = 200;
  45 
  46     static int go(int i) throws Exception {
  47         /*
  48          * Execute /bin/cat supplying two lines of input. cat should
  49          * read the input lines and copy them to stdout. On completion,
  50          * p.waitFor should return and the exit status is printed and this
  51          * program exits. Under 1.4.1, cat sometimes gets stuck on a pipe
  52          * read and never terminates.
  53          */
  54         Process p = Runtime.getRuntime().exec("cat");

  55 
  56         String input = i + ": line 1\n" + i + ": line 2\n";
  57         StringBufferInputStream in = new StringBufferInputStream(input);
  58         // create threads to handle I/O streams
  59         IO ioIn = new IO("stdin", in, p.getOutputStream());
  60         IO ioOut = new IO("stdout", p.getInputStream(), System.out);
  61         IO ioErr = new IO("stderr", p.getErrorStream(), System.err);
  62 
  63         // wait for process to exit
  64         return p.waitFor();
  65     }
  66 
  67     public static void main(String[] args) throws Exception {
  68         if (! isLinux) {
  69             System.err.println("Only for Linux");


  70             return;
  71         }
  72         for (int i = 0; i < N; i++)
  73             go(i);
  74     }
  75 
  76     /**
  77      * Handle IO. Thread is started in constructor.
  78      */
  79     static class IO extends Thread {
  80 
  81         private InputStream in;
  82         private OutputStream out;
  83 
  84         IO(String name, InputStream in, OutputStream out)
  85         {
  86             this.in = in;
  87             this.out = out;
  88             setName(name);
  89             start();