@Test
public void testFewWrites() throws InterruptedException {
final AtomicInteger count = new AtomicInteger();
NuProcessHandler processListener =
new NuAbstractProcessHandler() {
@Override
public void onStdout(ByteBuffer buffer, boolean closed) {
count.addAndGet(buffer.remaining());
buffer.position(buffer.limit());
}
};
NuProcessBuilder pb = new NuProcessBuilder(processListener, command);
NuProcess nuProcess = pb.start();
ByteBuffer buffer = ByteBuffer.allocate(64);
buffer.put("This is a test".getBytes());
buffer.flip();
nuProcess.writeStdin(buffer);
Thread.sleep(500);
nuProcess.closeStdin(true);
nuProcess.waitFor(0, TimeUnit.SECONDS);
Assert.assertEquals("Count did not match", 14, count.get());
}
@Test
public void testConsecutiveWrites() throws InterruptedException {
final AtomicInteger count = new AtomicInteger();
NuProcessHandler processListener =
new NuAbstractProcessHandler() {
@Override
public void onStdout(ByteBuffer buffer, boolean closed) {
count.addAndGet(buffer.remaining());
buffer.position(buffer.limit());
}
};
NuProcessBuilder pb = new NuProcessBuilder(processListener, command);
NuProcess nuProcess = pb.start();
// TODO: given a large i (e.g. 1,000, 10,000), this unit test (testConsecutiveWrites) will
// produce a side-effect on InterruptTest (has problem on Mac OS X, but works on Linux and
// Win32).
// We do not reuse fork on surefire (reuseForks=false) to address this issue for now.
for (int i = 0; i < 1000; i++) {
ByteBuffer buffer = ByteBuffer.allocate(64);
buffer.put("This is a test".getBytes());
buffer.flip();
nuProcess.writeStdin(buffer);
}
Thread.sleep(500);
nuProcess.closeStdin(true);
nuProcess.waitFor(0, TimeUnit.SECONDS);
Assert.assertEquals("Count did not match", 14000, count.get());
}
@Test
public void noExecutableFound() {
System.err.println("Starting test noExecutableFound()");
final Semaphore semaphore = new Semaphore(0);
final AtomicInteger exitCode = new AtomicInteger();
NuProcessHandler processListener =
new NuAbstractProcessHandler() {
@Override
public void onExit(int statusCode) {
exitCode.set(statusCode);
semaphore.release();
}
};
NuProcessBuilder pb = new NuProcessBuilder(processListener, "/bin/zxczxc");
NuProcess process = pb.start();
semaphore.acquireUninterruptibly();
Assert.assertFalse("Process incorrectly reported running", process.isRunning());
Assert.assertEquals(
"Output did not matched expected result", Integer.MIN_VALUE, exitCode.get());
System.err.println("Completed test noExecutableFound()");
}
@Test
public void badExit() throws InterruptedException {
System.err.println("Starting test badExit()");
final AtomicInteger asyncExitCode = new AtomicInteger();
final CountDownLatch exitLatch = new CountDownLatch(1);
NuProcessHandler processListener =
new NuAbstractProcessHandler() {
@Override
public void onExit(int statusCode) {
asyncExitCode.set(statusCode);
exitLatch.countDown();
}
};
NuProcessBuilder pb = new NuProcessBuilder(processListener, command, "/tmp/sdfadsf");
NuProcess nuProcess = pb.start();
int syncExitCode = nuProcess.waitFor(5, TimeUnit.SECONDS);
boolean countedDown = exitLatch.await(5, TimeUnit.SECONDS);
Assert.assertTrue("Async exit latch was not triggered", countedDown);
int expectedExitCode = System.getProperty("os.name").toLowerCase().contains("win") ? -1 : 1;
Assert.assertEquals(
"Exit code (synchronous) did not match expectation", expectedExitCode, syncExitCode);
Assert.assertEquals(
"Exit code (asynchronous) did not match expectation",
expectedExitCode,
asyncExitCode.get());
System.err.println("Completed test badExit()");
}
// TODO: DirectWriteBig will explore a bug when using writeStdin at onStart()
// (has problem on Mac OS X and Linux, but works on Win32)
// @Test
public void testDirectWriteBig() throws InterruptedException {
ProcessHandler2 processListener = new ProcessHandler2();
NuProcessBuilder pb = new NuProcessBuilder(processListener, command);
NuProcess nuProcess = pb.start();
nuProcess.waitFor(0, TimeUnit.SECONDS);
Assert.assertEquals(
"Checksums did not match", processListener.checksum, processListener.checksum2);
}
@Test
public void testDirectWrite() throws InterruptedException {
ProcessHandler1 processListener = new ProcessHandler1();
NuProcessBuilder pb = new NuProcessBuilder(processListener, command);
NuProcess nuProcess = pb.start();
nuProcess.waitFor(0, TimeUnit.SECONDS);
Assert.assertEquals("Results did not match", "This is a test", processListener.result);
}
@Override
public void onStdout(ByteBuffer buffer, boolean closed) {
if (buffer.hasRemaining()) {
byte[] chars = new byte[buffer.remaining()];
buffer.get(chars);
result = new String(chars);
System.out.println("Read: " + result);
}
nuProcess.closeStdin(true);
}
@Override
public void onStdoutChars(CharBuffer buffer, boolean closed, CoderResult coderResult) {
charsRead += buffer.remaining();
decodedStdout.append(buffer);
buffer.position(buffer.limit());
if (charsRead == charsWritten) {
nuProcess.closeStdin();
}
}
@Override
public void onStart(NuProcess nuProcess) {
this.nuProcess = nuProcess;
ByteBuffer buffer = ByteBuffer.allocate(256);
buffer.put("This is a test".getBytes());
buffer.flip();
System.out.println("Writing: This is a test");
nuProcess.writeStdin(buffer);
}
@Override
public void onStdout(ByteBuffer buffer, boolean closed) {
size += buffer.remaining();
if (size == (WRITES * bytes.length)) {
nuProcess.closeStdin();
}
byte[] bytes = new byte[buffer.remaining()];
buffer.get(bytes);
readAdler32.update(bytes);
}
@Override
public void onStdout(ByteBuffer buffer, boolean closed) {
while (buffer.hasRemaining()) {
checksum2 += buffer.get();
}
System.out.println("Reading. Current checksum " + checksum2);
if (checksum2 == checksum) {
System.out.println("Checksums matched, exiting.");
nuProcess.closeStdin(true);
}
}
@Override
public void onStart(NuProcess nuProcess) {
this.nuProcess = nuProcess;
ByteBuffer buffer = ByteBuffer.allocate(1024 * 128);
for (int i = 0; i < buffer.capacity(); i++) {
byte b = (byte) (i % 256);
buffer.put(b);
checksum += b;
}
buffer.flip();
System.out.println("Writing: 128K of data, waiting for checksum " + checksum);
nuProcess.writeStdin(buffer);
}
@Override
public void onStart(NuProcess nuProcess) {
this.nuProcess = nuProcess;
nuProcess.wantWrite();
}