/*
    * 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.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 TimeoutInputStreamTest {
  	private static final int timeout = 250;
  
  	private PipedOutputStream out;
  
  	private PipedInputStream in;
  
  	private InterruptTimer timer;
  
  	private TimeoutInputStream is;
  
  	private long start;
  
  	@Before
  	public void setUp() throws Exception {
  		out = new PipedOutputStream();
  		in = new PipedInputStream(out);
  		timer = new InterruptTimer();
  		is = new TimeoutInputStream(in, timer);
  		is.setTimeout(timeout);
  	}
  
  	@After
  	public void tearDown() throws Exception {
  		timer.terminate();
  		for (Thread t : active())
  			assertFalse(t instanceof InterruptTimer.AlarmThread);
  	}
  
  	@Test
  	public void testTimeout_readByte_Success1() throws IOException {
  		out.write('a');
  		assertEquals('a', is.read());
  	}
  
  	@Test
  	public void testTimeout_readByte_Success2() throws IOException {
  		final byte[] exp = new byte[] { 'a', 'b', 'c' };
  		out.write(exp);
  		assertEquals(exp[0], is.read());
  		assertEquals(exp[1], is.read());
  		assertEquals(exp[2], is.read());
  		out.close();
  		assertEquals(-1, is.read());
  	}
  
  	@Test
  	public void testTimeout_readByte_Timeout() throws IOException {
  		beginRead();
  		try {
  			is.read();
  			fail("incorrectly read a byte");
  		} catch (InterruptedIOException e) {
  			// expected
  		}
  		assertTimeout();
  	}
  
  	@Test
  	public void testTimeout_readBuffer_Success1() throws IOException {
  		final byte[] exp = new byte[] { 'a', 'b', 'c' };
  		final byte[] act = new byte[exp.length];
  		out.write(exp);
  		IO.readFully(is, act, 0, act.length);
  		assertArrayEquals(exp, act);
  	}
  
  	@Test
  	public void testTimeout_readBuffer_Success2() throws IOException {
 		final byte[] exp = new byte[] { 'a', 'b', 'c' };
 		final byte[] act = new byte[exp.length];
 		out.write(exp);
 		IO.readFully(is, act, 0, 1);
 		IO.readFully(is, act, 1, 1);
 		IO.readFully(is, act, 2, 1);
 		assertArrayEquals(exp, act);
 	}
 
 	@Test
 	public void testTimeout_readBuffer_Timeout() throws IOException {
 		beginRead();
 		try {
 			IO.readFully(is, new byte[512], 0, 512);
 			fail("incorrectly read bytes");
 		} catch (InterruptedIOException e) {
 			// expected
 		}
 		assertTimeout();
 	}
 
 	@Test
 	public void testTimeout_skip_Success() throws IOException {
 		final byte[] exp = new byte[] { 'a', 'b', 'c' };
 		out.write(exp);
 		assertEquals(2, is.skip(2));
 		assertEquals('c', is.read());
 	}
 
 	@Test
 	public void testTimeout_skip_Timeout() throws IOException {
 		beginRead();
 		try {
 			is.skip(1024);
 			fail("incorrectly skipped bytes");
 		} catch (InterruptedIOException e) {
 			// expected
 		}
 		assertTimeout();
 	}
 
 	private void beginRead() {
 		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();
 	}
 }