Java PipedOutputStream.write方法代码示例

import java.io.PipedOutputStream; //导入方法依赖的package包/类
@Test
public void testTestCommand() throws JSchException, IOException {
    JSch jsch = new JSch();
    Session session = jsch.getSession("admin", "localhost", properties.getShell().getPort());
    jsch.addIdentity("src/test/resources/id_rsa");
    Properties config = new Properties();
    config.put("StrictHostKeyChecking", "no");
    session.setConfig(config);
    session.connect();
    ChannelShell channel = (ChannelShell) session.openChannel("shell");
    PipedInputStream pis = new PipedInputStream();
    PipedOutputStream pos = new PipedOutputStream();
    channel.setInputStream(new PipedInputStream(pos));
    channel.setOutputStream(new PipedOutputStream(pis));
    channel.connect();
    pos.write("test run bob\r".getBytes(StandardCharsets.UTF_8));
    pos.flush();
    verifyResponse(pis, "test run bob");
    pis.close();
    pos.close();
    channel.disconnect();
    session.disconnect();
}
 

import java.io.PipedOutputStream; //导入方法依赖的package包/类
private void tupleWriter(PipedOutputStream pipeOut, Set<String> tuples) throws BiremeException {
  byte[] data = null;

  try {
    Iterator<String> iterator = tuples.iterator();

    while (iterator.hasNext() && !cxt.stop) {
      data = iterator.next().getBytes("UTF-8");
      pipeOut.write(data);
    }

    pipeOut.flush();
  } catch (IOException e) {
    throw new BiremeException("I/O error occurs while write to pipe.", e);
  } finally {
    try {
      pipeOut.close();
    } catch (IOException ignore) {
    }
  }
}
 

import java.io.PipedOutputStream; //导入方法依赖的package包/类
@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();
}
 

import java.io.PipedOutputStream; //导入方法依赖的package包/类
@Test
public void canHandleDataNotAlreadyPresentSeparatedByComma()
		throws Exception {
	List<String> expected = Arrays.asList("a", "b", "c");

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

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

	TimeUnit.SECONDS.sleep(2);
	os.write("a,b,c,".getBytes());

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

import java.io.PipedOutputStream; //导入方法依赖的package包/类
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();
    }
}
 

import java.io.PipedOutputStream; //导入方法依赖的package包/类
@Override
protected void setUp() throws Exception {

  outputStream = new ByteArrayOutputStream();
  pipe = new PipedOutputStream();

  connection = new BluetoothConnectionBase(outputStream, new PipedInputStream(pipe)) {
    @Override
    protected void bluetoothError(String functionName, int errorNumber, Object... messageArgs) {
      recordedErrorNumber = errorNumber;
    }
    @Override
    protected void write(String functionName, byte b) {
      super.write(functionName, b);
      try {
        pipe.write(b);
      } catch (IOException e) {
        throw new RuntimeException(e);
      }
    }
    @Override
    protected void write(String functionName, byte[] bytes) {
      super.write(functionName, bytes);
      try {
        pipe.write(bytes);
      } catch (IOException e) {
        throw new RuntimeException(e);
      }
    }
  };
}
 

import java.io.PipedOutputStream; //导入方法依赖的package包/类
/**
 * Test the static utility method that grabs the first four bytes from an
 * input stream and returns their value as an int.
 */
@Test
public void testPopLength() throws IOException {
  int testValue = 42;
  PipedInputStream inputStream = new PipedInputStream();
  PipedOutputStream outputStream = new PipedOutputStream();
  outputStream.connect(inputStream);
  
  ByteBuffer b = ByteBuffer.allocate(4);
  b.order(ByteOrder.BIG_ENDIAN);   // Network byte order.
  b.putInt(testValue);
  outputStream.write(b.array());
  assertEquals(testValue, Exchange.popLength(inputStream));
}
 

import java.io.PipedOutputStream; //导入方法依赖的package包/类
/**
 * @param length
 *            The length of the stream content.
 * @return An InputStream.
 * @throws IOException
 *             Exception.
 */
private PipedInputStream getInputStream(long length) throws IOException {
    PipedOutputStream outputStream = new PipedOutputStream();
    PipedInputStream inputStream = new PipedInputStream(outputStream);
    for (int i = 0; i < length; i++) {
        outputStream.write(Byte.MIN_VALUE);
    }
    outputStream.flush();
    outputStream.close();
    return inputStream;
}
 

import java.io.PipedOutputStream; //导入方法依赖的package包/类
/**
 * After instantiating a TarEntrySupplicant, the user must either invoke
 * write() or close(), to release system resources on the input
 * File/Stream.
 * <P>
 * <B>WARNING:</B>
 * Do not use this method unless the quantity of available RAM is
 * sufficient to accommodate the specified maxBytes all at one time.
 * This constructor loads all input from the specified InputStream into
 * RAM before anything is written to disk.
 * </P>
 *
 * @param maxBytes This method will fail if more than maxBytes bytes
 *                 are supplied on the specified InputStream.
 *                 As the type of this parameter enforces, the max
 *                 size you can request is 2GB.
 */
public TarEntrySupplicant(String path, InputStream origStream,
                          int maxBytes, char typeFlag,
                          TarFileOutputStream tarStream)
        throws IOException, TarMalformatException {

    /*
     * If you modify this, make sure to not intermix reading/writing of
     * the PipedInputStream and the PipedOutputStream, or you could
     * cause dead-lock.  Everything is safe if you close the
     * PipedOutputStream before reading the PipedInputStream.
     */
    this(path, typeFlag, tarStream, 0100000000000L);

    if (maxBytes < 1) {
        throw new IllegalArgumentException(RB.read_lt_1.getString());
    }

    int               i;
    PipedOutputStream outPipe = new PipedOutputStream();

    /*
     *  This constructor not available until Java 1.6:
     * inputStream = new PipedInputStream(outPipe, maxBytes);
     */
    try {
        inputStream =
            new InputStreamWrapper(new PipedInputStream(outPipe));

        while ((i =
                origStream.read(tarStream.writeBuffer, 0,
                                tarStream.writeBuffer.length)) > 0) {
            outPipe.write(tarStream.writeBuffer, 0, i);
        }

        outPipe.flush();    // Do any good on a pipe?
        dataSize = inputStream.available();

        if (TarFileOutputStream.debug) {
            System.out.println(
                RB.stream_buffer_report.getString(
                    Long.toString(dataSize)));
        }
    } catch (IOException ioe) {
        close();

        throw ioe;
    } finally {
        try {
            outPipe.close();
        } finally {
            outPipe = null;    // Encourage buffer GC
        }
    }

    modTime = new java.util.Date().getTime() / 1000L;
}
 

import java.io.PipedOutputStream; //导入方法依赖的package包/类
protected PIFData getPifData(TarEntryHeader header)
throws IOException, TarMalformatException {

    /*
     * If you modify this, make sure to not intermix reading/writing of
     * the PipedInputStream and the PipedOutputStream, or you could
     * cause dead-lock.  Everything is safe if you close the
     * PipedOutputStream before reading the PipedInputStream.
     */
    long dataSize = header.getDataSize();

    if (dataSize < 1) {
        throw new TarMalformatException(
            RB.singleton.getString(RB.PIF_UNKNOWN_DATASIZE));
    }

    if (dataSize > Integer.MAX_VALUE) {
        throw new TarMalformatException(
            RB.singleton.getString(
                RB.PIF_DATA_TOOBIG, Long.toString(dataSize),
                Integer.MAX_VALUE));
    }

    int readNow;
    int readBlocks = (int) (dataSize / 512L);
    int modulus    = (int) (dataSize % 512L);

    // Couldn't care less about the entry "name" field.
    PipedOutputStream outPipe = new PipedOutputStream();
    PipedInputStream  inPipe  = new PipedInputStream(outPipe);

    /* This constructor not available until Java 1.6:
            new PipedInputStream(outPipe, (int) dataSize);
    */
    try {
        while (readBlocks > 0) {
            readNow = (readBlocks > archive.getReadBufferBlocks())
                      ? archive.getReadBufferBlocks()
                      : readBlocks;

            archive.readBlocks(readNow);

            readBlocks -= readNow;

            outPipe.write(archive.readBuffer, 0, readNow * 512);
        }

        if (modulus != 0) {
            archive.readBlock();
            outPipe.write(archive.readBuffer, 0, modulus);
        }

        outPipe.flush();    // Do any good on a pipe?
    } catch (IOException ioe) {
        inPipe.close();

        throw ioe;
    } finally {
        outPipe.close();
    }

    return new PIFData(inPipe);
}
 

import java.io.PipedOutputStream; //导入方法依赖的package包/类
/**
 * After instantiating a TarEntrySupplicant, the user must either invoke
 * write() or close(), to release system resources on the input
 * File/Stream.
 * <P/>
 * <B>WARNING:</B>
 * Do not use this method unless the quantity of available RAM is
 * sufficient to accommodate the specified maxBytes all at one time.
 * This constructor loads all input from the specified InputStream into
 * RAM before anything is written to disk.
 *
 * @param maxBytes This method will fail if more than maxBytes bytes
 *                 are supplied on the specified InputStream.
 *                 As the type of this parameter enforces, the max
 *                 size you can request is 2GB.
 */
public TarEntrySupplicant(String path, InputStream origStream,
                          int maxBytes, char typeFlag,
                          TarFileOutputStream tarStream)
                          throws IOException, TarMalformatException {

    /*
     * If you modify this, make sure to not intermix reading/writing of
     * the PipedInputStream and the PipedOutputStream, or you could
     * cause dead-lock.  Everything is safe if you close the
     * PipedOutputStream before reading the PipedInputStream.
     */
    this(path, typeFlag, tarStream);

    if (maxBytes < 1) {
        throw new IllegalArgumentException(
            RB.singleton.getString(RB.READ_LT_1));
    }

    int               i;
    PipedOutputStream outPipe = new PipedOutputStream();

    inputStream = new PipedInputStream(outPipe);

    /* This constructor not available until Java 1.6:
    inputStream = new PipedInputStream(outPipe, maxBytes);
    */
    try {
        while ((i =
                origStream
                    .read(tarStream.writeBuffer, 0, tarStream
                        .writeBuffer.length)) > 0) {
            outPipe.write(tarStream.writeBuffer, 0, i);
        }

        outPipe.flush();    // Do any good on a pipe?

        dataSize = inputStream.available();

        if (TarFileOutputStream.debug) {
            System.out.println(
                RB.singleton.getString(
                    RB.STREAM_BUFFER_REPORT, Long.toString(dataSize)));
        }
    } catch (IOException ioe) {
        inputStream.close();

        throw ioe;
    } finally {
        outPipe.close();
    }

    modTime = new java.util.Date().getTime() / 1000L;
}
 

import java.io.PipedOutputStream; //导入方法依赖的package包/类
/**
 * Writes bytes to a PipedOutputStream and translates any IOException to an IllegalStateException.
 *
 * <p>PipedOutputStream throws IOException on write, not due to any environmental conditions, only
 * due to it being in an unwritable state. Some such states, such as not being connected to a
 * PipedInputStream, are impossible here. The rest, such as the fake process having terminated,
 * are rare and user-preventable, particuarly in the context of a test, which is expected to have
 * deterministic behavior. Moreover, if the write() methods did declare IOException, a test would
 * surely just rethrow it, so it's only impact would be added noise to the test code.
 */
private void writeToPipedOutputStream(PipedOutputStream pipedOutput, byte[] bytes) {
  try {
    pipedOutput.write(bytes);
  } catch (IOException e) {
    throw new IllegalStateException(e);
  }
}