| /* |
| * Copyright (C) 2009-2010, Google Inc. and others |
| * |
| * This program and the accompanying materials are made available under the |
| * terms of the Eclipse Distribution License v. 1.0 which is available at |
| * https://www.eclipse.org/org/documents/edl-v10.php. |
| * |
| * SPDX-License-Identifier: BSD-3-Clause |
| */ |
| |
| package org.eclipse.jgit.util.io; |
| |
| import static org.junit.Assert.assertArrayEquals; |
| import static org.junit.Assert.assertEquals; |
| import static org.junit.Assert.assertFalse; |
| import static org.junit.Assert.assertTrue; |
| import static org.junit.Assert.fail; |
| |
| import java.io.IOException; |
| import java.io.InterruptedIOException; |
| import java.io.OutputStream; |
| import java.io.PipedInputStream; |
| import java.io.PipedOutputStream; |
| import java.util.Arrays; |
| import java.util.List; |
| |
| import org.eclipse.jgit.util.IO; |
| import org.junit.After; |
| import org.junit.Before; |
| import org.junit.Test; |
| |
| public class TimeoutOutputStreamTest { |
| private static final int timeout = 250; |
| |
| private PipedOutputStream out; |
| |
| private FullPipeInputStream in; |
| |
| private InterruptTimer timer; |
| |
| private TimeoutOutputStream os; |
| |
| private long start; |
| |
| @Before |
| public void setUp() throws Exception { |
| out = new PipedOutputStream(); |
| in = new FullPipeInputStream(out); |
| timer = new InterruptTimer(); |
| os = new TimeoutOutputStream(out, timer); |
| os.setTimeout(timeout); |
| } |
| |
| @After |
| public void tearDown() throws Exception { |
| timer.terminate(); |
| for (Thread t : active()) |
| assertFalse(t instanceof InterruptTimer.AlarmThread); |
| } |
| |
| @Test |
| public void testTimeout_writeByte_Success1() throws IOException { |
| in.free(1); |
| os.write('a'); |
| in.want(1); |
| assertEquals('a', in.read()); |
| } |
| |
| @Test |
| public void testTimeout_writeByte_Success2() throws IOException { |
| final byte[] exp = new byte[] { 'a', 'b', 'c' }; |
| final byte[] act = new byte[exp.length]; |
| in.free(exp.length); |
| os.write(exp[0]); |
| os.write(exp[1]); |
| os.write(exp[2]); |
| in.want(exp.length); |
| in.read(act); |
| assertArrayEquals(exp, act); |
| } |
| |
| @Test |
| public void testTimeout_writeByte_Timeout() throws IOException { |
| beginWrite(); |
| try { |
| os.write('\n'); |
| fail("incorrectly write a byte"); |
| } catch (InterruptedIOException e) { |
| // expected |
| } |
| assertTimeout(); |
| } |
| |
| @Test |
| public void testTimeout_writeBuffer_Success1() throws IOException { |
| final byte[] exp = new byte[] { 'a', 'b', 'c' }; |
| final byte[] act = new byte[exp.length]; |
| in.free(exp.length); |
| os.write(exp); |
| in.want(exp.length); |
| in.read(act); |
| assertArrayEquals(exp, act); |
| } |
| |
| @Test |
| public void testTimeout_writeBuffer_Timeout() throws IOException { |
| beginWrite(); |
| try { |
| os.write(new byte[512]); |
| fail("incorrectly wrote bytes"); |
| } catch (InterruptedIOException e) { |
| // expected |
| } |
| assertTimeout(); |
| } |
| |
| @Test |
| public void testTimeout_flush_Success() throws IOException { |
| final boolean[] called = new boolean[1]; |
| os = new TimeoutOutputStream(new OutputStream() { |
| @Override |
| public void write(int b) throws IOException { |
| fail("should not have written"); |
| } |
| |
| @Override |
| public void flush() throws IOException { |
| called[0] = true; |
| } |
| }, timer); |
| os.setTimeout(timeout); |
| os.flush(); |
| assertTrue(called[0]); |
| } |
| |
| @Test |
| public void testTimeout_flush_Timeout() throws IOException { |
| final boolean[] called = new boolean[1]; |
| os = new TimeoutOutputStream(new OutputStream() { |
| @Override |
| public void write(int b) throws IOException { |
| fail("should not have written"); |
| } |
| |
| @Override |
| public void flush() throws IOException { |
| called[0] = true; |
| for (;;) { |
| try { |
| Thread.sleep(1000); |
| } catch (InterruptedException e) { |
| InterruptedIOException e1 = new InterruptedIOException(); |
| e1.initCause(e); |
| throw e1; |
| } |
| } |
| } |
| }, timer); |
| os.setTimeout(timeout); |
| |
| beginWrite(); |
| try { |
| os.flush(); |
| fail("incorrectly flushed"); |
| } catch (InterruptedIOException e) { |
| // expected |
| } |
| assertTimeout(); |
| assertTrue(called[0]); |
| } |
| |
| @Test |
| public void testTimeout_close_Success() throws IOException { |
| final boolean[] called = new boolean[1]; |
| os = new TimeoutOutputStream(new OutputStream() { |
| @Override |
| public void write(int b) throws IOException { |
| fail("should not have written"); |
| } |
| |
| @Override |
| public void close() throws IOException { |
| called[0] = true; |
| } |
| }, timer); |
| os.setTimeout(timeout); |
| os.close(); |
| assertTrue(called[0]); |
| } |
| |
| @Test |
| public void testTimeout_close_Timeout() throws IOException { |
| final boolean[] called = new boolean[1]; |
| os = new TimeoutOutputStream(new OutputStream() { |
| @Override |
| public void write(int b) throws IOException { |
| fail("should not have written"); |
| } |
| |
| @Override |
| public void close() throws IOException { |
| called[0] = true; |
| for (;;) { |
| try { |
| Thread.sleep(1000); |
| } catch (InterruptedException e) { |
| InterruptedIOException e1 = new InterruptedIOException(); |
| e1.initCause(e); |
| throw e1; |
| } |
| } |
| } |
| }, timer); |
| os.setTimeout(timeout); |
| |
| beginWrite(); |
| try { |
| os.close(); |
| fail("incorrectly closed"); |
| } catch (InterruptedIOException e) { |
| // expected |
| } |
| assertTimeout(); |
| assertTrue(called[0]); |
| } |
| |
| private void beginWrite() { |
| start = now(); |
| } |
| |
| private void assertTimeout() { |
| // Our timeout was supposed to be ~250 ms. Since this is a timing |
| // test we can't assume we spent *exactly* the timeout period, as |
| // there may be other activity going on in the system. Instead we |
| // look for the delta between the start and end times to be within |
| // 50 ms of the expected timeout. |
| // |
| final long wait = now() - start; |
| assertTrue("waited only " + wait + " ms", timeout - wait < 50); |
| } |
| |
| private static List<Thread> active() { |
| Thread[] all = new Thread[16]; |
| int n = Thread.currentThread().getThreadGroup().enumerate(all); |
| while (n == all.length) { |
| all = new Thread[all.length * 2]; |
| n = Thread.currentThread().getThreadGroup().enumerate(all); |
| } |
| return Arrays.asList(all).subList(0, n); |
| } |
| |
| private static long now() { |
| return System.currentTimeMillis(); |
| } |
| |
| private static final class FullPipeInputStream extends PipedInputStream { |
| FullPipeInputStream(PipedOutputStream src) throws IOException { |
| super(src); |
| src.write(new byte[PIPE_SIZE]); |
| } |
| |
| void want(int cnt) throws IOException { |
| IO.skipFully(this, PIPE_SIZE - cnt); |
| } |
| |
| void free(int cnt) throws IOException { |
| IO.skipFully(this, cnt); |
| } |
| } |
| } |