java.io.PipedInputStream Java Examples

@Test
public void testUnrecoverable() throws Throwable {
    try (PipedOutputStream pos = new PipedOutputStream();
         PipedInputStream pis = new PipedInputStream(pos, 512);
         RLPStream stream = new RLPStream(pis)) {
        pos.write(0x81);
        pos.write(0x00);
        Iterator<RLPItem> iter = stream.iterator();
        TestUtils.assertThrown(IllegalArgumentException.class, "invalid rlp for single byte @ 0", iter::hasNext);
        try (RLPStream stream2 = new RLPStream(pis)) {
            pos.write(0xf8);
            pos.write(0x37);
            Iterator<RLPItem> iter2 = stream2.iterator();
            for (int i = 0; i < 3; i++) {
                TestUtils.assertThrown(
                        IllegalArgumentException.class,
                        "long element data length must be 56 or greater; found: 55 for element @ 0",
                        iter2::hasNext
                );
            }
        }
    }
}
 

@Test
public void buildACommand() throws IOException {
  PipedInputStream pis = new PipedInputStream();
  BufferedInputStream bis = new BufferedInputStream(pis);
  PipedOutputStream pos = new PipedOutputStream(pis);
  RedisOutputStream ros = new RedisOutputStream(pos);

  Protocol.sendCommand(ros, Protocol.Command.GET, "SOMEKEY".getBytes(Protocol.CHARSET));
  ros.flush();
  pos.close();
  String expectedCommand = "*2\r\n$3\r\nGET\r\n$7\r\nSOMEKEY\r\n";

  int b;
  StringBuilder sb = new StringBuilder();
  while ((b = bis.read()) != -1) {
    sb.append((char) b);
  }

  assertEquals(expectedCommand, sb.toString());
}
 

private static void testJarExtract(String jarFile) throws IOException {
    List<String> argList = new ArrayList<String>();
    argList.add("-xvf");
    argList.add(jarFile);
    argList.add(JARBACKSLASH + File.separatorChar + DIR + File.separatorChar + FILENAME);

    String jarArgs[] = new String[argList.size()];
    jarArgs = argList.toArray(jarArgs);

    PipedOutputStream pipedOutput = new PipedOutputStream();
    PipedInputStream pipedInput = new PipedInputStream(pipedOutput);
    PrintStream out = new PrintStream(pipedOutput);

    Main jarTool = new Main(out, System.err, "jar");
    if (!jarTool.run(jarArgs)) {
        fail("Could not list jar file.");
    }

    out.flush();
    check(pipedInput.available() > 0);
}
 

public DuplexAsync(Endpoint client_endpoint, Endpoint server_endpoint) throws Exception
{
	this.client = client_endpoint;
	this.server = server_endpoint;
	client_input  = (client_endpoint != null) ? client_endpoint.getInputStream() : null;
	client_output = (client_endpoint != null) ? client_endpoint.getOutputStream() : null;
	server_input  = (server_endpoint != null) ? server_endpoint.getInputStream() : null;
	server_output = (server_endpoint != null) ? server_endpoint.getOutputStream() : null;
	
	flow_controlled_client_output = new PipedOutputStream();
	flow_controlled_client_input = new PipedInputStream(flow_controlled_client_output, 65536);

	flow_controlled_server_output = new PipedOutputStream();
	flow_controlled_server_input = new PipedInputStream(flow_controlled_server_output, 65536);

	client_to_server = createClientToServerSimplex(client_input, flow_controlled_server_output);
	server_to_client = createServerToClientSimplex(server_input, flow_controlled_client_output);
	
	disableDuplexEventListener();
}
 

/**
 * Return InputStream from which a new generated resource bundle can be retrieved.
 */
public SupportBundle generateNewBundle(List<String> generatorNames, BundleType bundleType) throws IOException {
  List<BundleContentGeneratorDefinition> defs = getRequestedDefinitions(generatorNames);

  PipedInputStream inputStream = new PipedInputStream();
  PipedOutputStream outputStream = new PipedOutputStream();
  inputStream.connect(outputStream);
  ZipOutputStream zipOutputStream = new ZipOutputStream(outputStream);

  executor.submit(() -> generateNewBundleInternal(defs, bundleType, zipOutputStream));

  String bundleName = generateBundleName(bundleType);
  String bundleKey = generateBundleDate(bundleType) + "/" + bundleName;

  return new SupportBundle(
    bundleKey,
    bundleName,
    inputStream
  );
}
 

private static void testJarList(String jarFile) throws IOException {
    List<String> argList = new ArrayList<String>();
    argList.add("-tvf");
    argList.add(jarFile);
    argList.add(JARBACKSLASH + File.separatorChar + DIR + File.separatorChar + FILENAME);

    String jarArgs[] = new String[argList.size()];
    jarArgs = argList.toArray(jarArgs);

    PipedOutputStream pipedOutput = new PipedOutputStream();
    PipedInputStream pipedInput = new PipedInputStream(pipedOutput);
    PrintStream out = new PrintStream(pipedOutput);

    int rc = JAR_TOOL.run(out, System.err, jarArgs);
    if (rc != 0) {
        fail("Could not list jar file.");
    }

    out.flush();
    check(pipedInput.available() > 0);
}
 

private static void testJarList(String jarFile) throws IOException {
    List<String> argList = new ArrayList<String>();
    argList.add("-tvf");
    argList.add(jarFile);
    argList.add(JARBACKSLASH + File.separatorChar + DIR + File.separatorChar + FILENAME);

    String jarArgs[] = new String[argList.size()];
    jarArgs = argList.toArray(jarArgs);

    PipedOutputStream pipedOutput = new PipedOutputStream();
    PipedInputStream pipedInput = new PipedInputStream(pipedOutput);
    PrintStream out = new PrintStream(pipedOutput);

    Main jarTool = new Main(out, System.err, "jar");
    if (!jarTool.run(jarArgs)) {
        fail("Could not list jar file.");
    }

    out.flush();
    check(pipedInput.available() > 0);
}
 

public S3CommonPipedOutputStream( S3CommonFileSystem fileSystem, String bucketId, String key, int partSize ) throws IOException {
  this.pipedInputStream = new PipedInputStream();

  try {
    this.pipedInputStream.connect( this );
  } catch ( IOException e ) {
    // FATAL, unexpected
    throw new IOException( "could not connect to pipedInputStream", e );
  }

  this.s3AsyncTransferRunner = new S3AsyncTransferRunner();
  this.bucketId = bucketId;
  this.key = key;
  this.fileSystem = fileSystem;
  this.partSize = partSize;
}
 

private static void testJarExtract(String jarFile) throws IOException {
    List<String> argList = new ArrayList<String>();
    argList.add("-xvf");
    argList.add(jarFile);
    argList.add(JARBACKSLASH + File.separatorChar + DIR + File.separatorChar + FILENAME);

    String jarArgs[] = new String[argList.size()];
    jarArgs = argList.toArray(jarArgs);

    PipedOutputStream pipedOutput = new PipedOutputStream();
    PipedInputStream pipedInput = new PipedInputStream(pipedOutput);
    PrintStream out = new PrintStream(pipedOutput);

    Main jarTool = new Main(out, System.err, "jar");
    if (!jarTool.run(jarArgs)) {
        fail("Could not list jar file.");
    }

    out.flush();
    check(pipedInput.available() > 0);
}
 

static void redirectSystemOut() throws Exception {
	PipedOutputStream pos = new PipedOutputStream();
	PrintStream ps = new PrintStream(pos);
	PipedInputStream pis = new PipedInputStream(pos);
	final BufferedReader reader = new BufferedReader(new InputStreamReader(pis));

	new Thread() {
		public void run() {
			try {
				String line = null;
				while ((line = reader.readLine()) != null) {
					MvsConsole.wto(line, 
									MvsConsole.ROUTCDE_SYSPROG_INFORMATION,
									MvsConsole.DESC_JOB_STATUS);
				}
			} catch(IOException ioe) {
				// Pipe breaks when shutting down; ignore
			}
		}
	}.start();
	System.setOut(ps);
}
 

private static void testJarExtract(String jarFile) throws IOException {
    List<String> argList = new ArrayList<String>();
    argList.add("-xvf");
    argList.add(jarFile);
    argList.add(JARBACKSLASH + File.separatorChar + DIR + File.separatorChar + FILENAME);

    String jarArgs[] = new String[argList.size()];
    jarArgs = argList.toArray(jarArgs);

    PipedOutputStream pipedOutput = new PipedOutputStream();
    PipedInputStream pipedInput = new PipedInputStream(pipedOutput);
    PrintStream out = new PrintStream(pipedOutput);

    Main jarTool = new Main(out, System.err, "jar");
    if (!jarTool.run(jarArgs)) {
        fail("Could not list jar file.");
    }

    out.flush();
    check(pipedInput.available() > 0);
}
 

private static void testJarExtract(String jarFile) throws IOException {
    List<String> argList = new ArrayList<String>();
    argList.add("-xvf");
    argList.add(jarFile);
    argList.add(JARBACKSLASH + File.separatorChar + DIR + File.separatorChar + FILENAME);

    String jarArgs[] = new String[argList.size()];
    jarArgs = argList.toArray(jarArgs);

    PipedOutputStream pipedOutput = new PipedOutputStream();
    PipedInputStream pipedInput = new PipedInputStream(pipedOutput);
    PrintStream out = new PrintStream(pipedOutput);

    Main jarTool = new Main(out, System.err, "jar");
    if (!jarTool.run(jarArgs)) {
        fail("Could not list jar file.");
    }

    out.flush();
    check(pipedInput.available() > 0);
}
 

/**
 * Instantiates a new microphone input stream.
 *
 * @param opusEncoded the opus encoded
 */
public MicrophoneInputStream(boolean opusEncoded) {
  captureThread = new MicrophoneCaptureThread(this, opusEncoded);
  if (opusEncoded == true) {
    CONTENT_TYPE = ContentType.OPUS;
  } else {
    CONTENT_TYPE = ContentType.RAW;
  }
  os = new PipedOutputStream();
  is = new PipedInputStream();
  try {
    is.connect(os);
  } catch (IOException e) {
    Log.e(TAG, e.getMessage());
  }
  captureThread.start();
}
 

private static void testJarExtract(String jarFile) throws IOException {
    List<String> argList = new ArrayList<String>();
    argList.add("-xvf");
    argList.add(jarFile);
    argList.add(JARBACKSLASH + File.separatorChar + DIR + File.separatorChar + FILENAME);

    String jarArgs[] = new String[argList.size()];
    jarArgs = argList.toArray(jarArgs);

    PipedOutputStream pipedOutput = new PipedOutputStream();
    PipedInputStream pipedInput = new PipedInputStream(pipedOutput);
    PrintStream out = new PrintStream(pipedOutput);

    Main jarTool = new Main(out, System.err, "jar");
    if (!jarTool.run(jarArgs)) {
        fail("Could not list jar file.");
    }

    out.flush();
    check(pipedInput.available() > 0);
}
 

private static void testJarExtract(String jarFile) throws IOException {
    List<String> argList = new ArrayList<String>();
    argList.add("-xvf");
    argList.add(jarFile);
    argList.add(JARBACKSLASH + File.separatorChar + DIR + File.separatorChar + FILENAME);

    String jarArgs[] = new String[argList.size()];
    jarArgs = argList.toArray(jarArgs);

    PipedOutputStream pipedOutput = new PipedOutputStream();
    PipedInputStream pipedInput = new PipedInputStream(pipedOutput);
    PrintStream out = new PrintStream(pipedOutput);

    Main jarTool = new Main(out, System.err, "jar");
    if (!jarTool.run(jarArgs)) {
        fail("Could not list jar file.");
    }

    out.flush();
    check(pipedInput.available() > 0);
}
 

private static void testJarExtract(String jarFile) throws IOException {
    List<String> argList = new ArrayList<String>();
    argList.add("-xvf");
    argList.add(jarFile);
    argList.add(JARBACKSLASH + File.separatorChar + DIR + File.separatorChar + FILENAME);

    String jarArgs[] = new String[argList.size()];
    jarArgs = argList.toArray(jarArgs);

    PipedOutputStream pipedOutput = new PipedOutputStream();
    PipedInputStream pipedInput = new PipedInputStream(pipedOutput);
    PrintStream out = new PrintStream(pipedOutput);

    Main jarTool = new Main(out, System.err, "jar");
    if (!jarTool.run(jarArgs)) {
        fail("Could not list jar file.");
    }

    out.flush();
    check(pipedInput.available() > 0);
}
 

@Override
public InputStream getInputStream() throws IOException {
  final PipedInputStream pin = new PipedInputStream();
  final PipedOutputStream pout = new PipedOutputStream(pin);
  new Thread() {
    public void run() {
      try {
        BarTransformer.transform(barXmlURL, pout);
      } catch (Exception e) {
        LOGGER.warn("Bundle cannot be generated");
      } finally {
        try {
          pout.close();
        } catch (IOException ignore) {
          // if we get here something is very wrong
          LOGGER.error("Bundle cannot be generated", ignore);
        }
      }
    }
  }.start();
  return pin;
}
 

public LineDisciplineTerminal(String name,
                              String type,
                              OutputStream masterOutput) throws IOException {
    super(name, type);
    PipedInputStream input = new LinePipedInputStream(PIPE_SIZE);
    this.slaveInputPipe = new PipedOutputStream(input);
    // This is a hack to fix a problem in gogo where closure closes
    // streams for commands if they are instances of PipedInputStream.
    // So we need to get around and make sure it's not an instance of
    // that class by using a dumb FilterInputStream class to wrap it.
    this.slaveInput = new FilterInputStream(input) {};
    this.slaveOutput = new FilteringOutputStream();
    this.masterOutput = masterOutput;
    this.attributes = new Attributes();
    this.size = new Size(160, 50);
}
 

@Test
public void canHandleDataNotAlreadyPresentSeparatedByNewline()
		throws Exception {
	List<String> expected = Arrays.asList("a", "b", "c");

	PipedOutputStream os = new PipedOutputStream();
	PipedInputStream is = new PipedInputStream(os);

	StreamReader reader = process(is, "\n", expected);

	TimeUnit.SECONDS.sleep(2);
	os.write("a\nb\nc\n".getBytes());

	waitUntil(expected.size());
	assertThat(received, is(expected));
	reader.close();
}
 

/**
 * Create an instance of process IO data generator.
 * <p/>
 * @param in      Process standard input (second side of pipe
 *                to connect).
 * @param out     Process standard output (second side of pipe
 *                to connect).
 * @param dataOut Content of process standard output to be sent trough
 *                the pipe.
 * @throws IOException When there is an issue with connecting pipes
 *         or opening local {@link Reader}s and {@link Writer}s.
 */
private DataSrc(final PipedOutputStream in, final PipedInputStream out,
        final String[] dataOut) throws IOException {
    try {
        srcIn = new InputStreamReader(new PipedInputStream(in));
        srcOut = new OutputStreamWriter(new PipedOutputStream(out));
        this.dataOut = dataOut != null ? dataOut : new String[0];
    } catch (IOException ex) {
        close();
        throw ex;
    }
    
}
 

@Test
public void testGobbleMultiLineBlockingStream() throws Exception {
    PipedOutputStream pipedOutputStream = new PipedOutputStream();
    PipedInputStream stream = new PipedInputStream(pipedOutputStream);
    ByteArrayOutputStream out = new ByteArrayOutputStream();
    StreamGobbler gobbler = new StreamGobbler(stream, out, null);
    gobbler.start();
    try {
        pipedOutputStream.write("line1\n".getBytes());
        pipedOutputStream.flush();
        assertEqualsEventually(out, "line1" + NL);

        pipedOutputStream.write("line2\n".getBytes());
        pipedOutputStream.flush();
        assertEqualsEventually(out, "line1" + NL + "line2" + NL);

        pipedOutputStream.write("line".getBytes());
        pipedOutputStream.write("3\n".getBytes());
        pipedOutputStream.flush();
        assertEqualsEventually(out, "line1" + NL + "line2" + NL + "line3" + NL);

        pipedOutputStream.close();
        
        gobbler.join(10*1000);
        assertFalse(gobbler.isAlive());
        assertEquals(new String(out.toByteArray()), "line1" + NL + "line2" + NL + "line3" + NL);
    } finally {
        gobbler.close();
        gobbler.interrupt();
    }
}
 

public DemuxTester() throws IOException {
    feeder = new PipedOutputStream();

    feeder_input_stream = new PipedInputStream();
    feeder_input_stream.connect(feeder);
    
    stream = new DockerMultiplexedInputStream(feeder_input_stream);
    sink = new ByteArrayOutputStream();
    eof = false;
    exc = null;

    thread = new Thread(this);
    thread.start();
}
 

public static GunzippingOutputStream create(OutputStream finalOut) throws IOException {
  PipedInputStream pipeIn = new PipedInputStream();
  PipedOutputStream pipeOut = new PipedOutputStream(pipeIn);

  Future<Void> copyFuture = sExecutor.submit(
      new GunzippingCallable(pipeIn, finalOut));

  return new GunzippingOutputStream(pipeOut, copyFuture);
}
 

@Override
public OutputStream receiveUpload(String filename, String mimeType) {
    try {
        final PipedInputStream in = new PipedInputStream();
        final PipedOutputStream out = new PipedOutputStream(in);
        writeResponce(in, filename, mimeType);
        return out;
    } catch (IOException ex) {
        throw new RuntimeException(ex);
    }
}
 

public void testStopDetectingInputBufferWaitStop() throws Exception {
    Runnable shouldNotHappenRun =
            () -> { throw new AssertionError("Should not happen."); };
    Consumer<Exception> shouldNotHappenExc =
            exc -> { throw new AssertionError("Should not happen.", exc); };
    StopDetectingInputStream sd = new StopDetectingInputStream(shouldNotHappenRun, shouldNotHappenExc);
    CountDownLatch reading = new CountDownLatch(1);
    PipedInputStream is = new PipedInputStream() {
        @Override
        public int read() throws IOException {
            reading.countDown();
            return super.read();
        }
    };
    PipedOutputStream os = new PipedOutputStream(is);

    sd.setInputStream(is);
    sd.setState(State.BUFFER);
    reading.await();
    sd.setState(State.WAIT);
    os.write(3);
    int value = sd.read();

    if (value != 3) {
        throw new AssertionError();
    }
}
 

public AdxPipedImporter( DataValueSetService dataValueSetService, ImportOptions importOptions,
    JobConfiguration id, PipedOutputStream pipeOut, SessionFactory sessionFactory ) throws IOException
{
    this.dataValueSetService = dataValueSetService;
    this.pipeIn = new PipedInputStream( pipeOut, PIPE_BUFFER_SIZE );
    this.importOptions = importOptions;
    this.id = id;
    this.sessionFactory = sessionFactory;
    this.authentication = SecurityContextHolder.getContext().getAuthentication();
}
 

@Test
public void testFactory() throws Exception {
	String left = "message";
	ByteArrayInputStream bufferInput = new ByteArrayInputStream(left.getBytes(StringUtility.CHARSET));
	PipedOutputStream pipeOutput = new PipedOutputStream();
	PipedInputStream pipeInput = new PipedInputStream(pipeOutput);
	ByteArrayOutputStream bufferOutput = new ByteArrayOutputStream();

	PressUtility.compress("gz", bufferInput, pipeOutput);
	PressUtility.decompress("gz", pipeInput, bufferOutput);

	String right = bufferOutput.toString(StringUtility.CHARSET.name());
	Assert.assertEquals(left, right);
}
 

public ContentHandlerOutputStream(ContentHandler handler, ThreadConnector threadConnector) throws StreamingException {
	this.handler=handler;
	this.threadConnector=threadConnector;
	try {
		pipedInputStream=new PipedInputStream();
		connect(pipedInputStream);
		pipeReader.setUncaughtExceptionHandler(this);
		pipeReader.start();
	} catch (IOException e) {
		throw new StreamingException(e);
	}
}
 

GZipUncompressorOutputStream(OutputStream out, int bufferSize) {
    super(out);
    this.bufferSize = bufferSize;
    this.encodedBytesReceiver = new PipedInputStream();
    this.encodedBytesSink = new PipedOutputStream();
    this.executorService = Executors.newSingleThreadExecutor();
}
 

/**
 * Decorator for InputStream, which allows to convert an XML input stream to
 * SQL
 *
 * @param inputStream
 *            XML input stream
 * @throws IOException
 */
@Override
   public void initialize(InputStream inputStream, DumpTableEnum table)
		throws IOException {

	unbufferedResult = new PipedInputStream();
	decodedStream = new PipedOutputStream(unbufferedResult);
	result = new BufferedInputStream(unbufferedResult, BUFFERSIZE);

	xmlInputThread = new XMLDumpTableInputStreamThread(inputStream,
			decodedStream, table);
	xmlInputThread.start();

}