ice4j/test/org/ice4j/pseudotcp/PseudoTcpTestTransfer.java
2012-07-18 13:38:19 +00:00

446 lines
13 KiB
Java
Executable File

/*
* ice4j, the OpenSource Java Solution for NAT and Firewall Traversal.
* Maintained by the Jitsi community (https://jitsi.org).
*
* Distributable under LGPL license.
* See terms of license at gnu.org.
*/
package org.ice4j.pseudotcp;
import java.io.*;
import java.util.logging.*;
import org.ice4j.pseudotcp.util.*;
import static org.junit.Assert.*;
import org.junit.*;
/**
* Implements one way transfer test
*
* @author Pawel Domas
*/
public class PseudoTcpTestTransfer extends PseudoTcpTestBase
{
/**
* The logger.
*/
private static final Logger logger =
Logger.getLogger(PseudoTCPBase.class.getName());
public PseudoTcpTestTransfer()
{
super();
}
/**
* The send data
*/
private byte[] sendData;
/**
* Send stream size
*/
private int sendStreamSize;
/**
* Total bytes sent counter
*/
private int totalSent;
/**
* Receive stream
*/
private ByteArrayOutputStream recvStream;
/**
* Transfers the data of <tt>size</tt> bytes
*
* @param size
*/
public void TestTransfer(int size)
{
long start, elapsed;
int received;
// Create some dummy data to send
sendData = createDummyData(size);
sendStreamSize = size;
// Prepare the receive stream.
recvStream = new ByteArrayOutputStream(size);
// Connect and wait until connected.
start = PseudoTCPBase.Now();
StartClocks();
try
{
Connect();
//assertEquals(0, Connect());
}
catch (IOException ex)
{
fail(ex.getMessage());
}
assert_Connected_wait(kConnectTimeoutMs);
// Sending will start from OnTcpWriteable and complete when all data has
// been received.
long transferTout = MaxTransferTime(sendData.length, kMinTransferRate);
boolean transfferInTime = assert_Disconnected_wait(transferTout);
elapsed = PseudoTCPBase.Now() - start;
StopClocks();
received = recvStream.size();
assertEquals("Transfer timeout, transferred: " + received
+ " required: " + sendData.length
+ " elapsed: "
+ elapsed + " limit: " + transferTout,
true, transfferInTime);
// Ensure we closed down OK and we got the right data.
assertEquals(size, received);
byte[] recvdArray = recvStream.toByteArray();
assertArrayEquals(sendData, recvdArray);
logger.log(Level.INFO,
"Transferred " + received + " bytes in " + elapsed
+ " ms (" + (size * 8 / elapsed) + " Kbps");
}
/**
* Reads all data available at remote peer's buffer
*
* @throws IOException
*/
void ReadData() throws IOException
{
byte[] block = new byte[kBlockSize];
int rcvd;
do
{
rcvd = RemoteRecv(block, block.length);
UpdateRemoteClock();
if (rcvd != -1)
{
recvStream.write(block, 0, rcvd);
}
}
while (rcvd > 0);
}
/**
* Writes the data until there's space available
*
* @return true if there's no more data left to write
* @throws IOException
*/
boolean WriteData() throws IOException
{
int tosend;
int sent;
byte[] block = new byte[kBlockSize];
do
{
tosend = Math.min(sendStreamSize - totalSent, block.length);
System.arraycopy(sendData, totalSent, block, 0, tosend);
if (tosend > 0)
{
sent = LocalSend(block, tosend);
UpdateLocalClock();
if (sent != -1)
{
totalSent += sent;
}
else
{
logger.log(Level.FINE, "Flow Controlled");
}
}
else
{
sent = tosend = 0;
}
}
while (sent > 0);
if (logger.isLoggable(Level.FINER))
{
logger.log(Level.FINER, "Sent: " + totalSent
+ " remaining: " + (sendStreamSize - totalSent));
}
return tosend == 0;
}
/**
* Catches TCP readable event for remote peer and reads the data. When total
* read count equals send data size the test is finished.
*
* @param tcp
*/
@Override
public void OnTcpReadable(PseudoTCPBase tcp)
{
if (tcp == getRemoteTcp())
{
try
{
ReadData();
// TODO: OnTcpClosed() is currently only notified on error -
// there is no on-the-wire equivalent of TCP FIN.
// So we fake the notification when all the data has been read.
int received, required;
received = recvStream.size();
required = sendStreamSize;
if (logger.isLoggable(Level.FINER))
{
logger.log(Level.FINER, "Receivied: " + received
+ " required: " + required);
}
if (received == required)
{
OnTcpClosed(getRemoteTcp(), null);
}
}
catch (IOException ex)
{
throw new RuntimeException(ex);
}
}
}
/**
* Catches on TCP writeable event for local peer. Writes all data and closes
* the stream
*
* @param tcp
*/
@Override
public void OnTcpWriteable(PseudoTCPBase tcp)
{
if (tcp == getLocalTcp())
{
// Write bytes from the send stream when we can.
// Shut down when we've sent everything.
logger.log(Level.FINER, "Flow Control Lifted");
try
{
if (WriteData())
{
Close();
}
}
catch (IOException ex)
{
ex.printStackTrace();
fail(ex.getMessage());
}
}
}
/**
* Basic end-to-end data transfer tests Test the normal case of sending data
* from one side to the other.
*/
public void testSend()
{
//logger.log(Level.INFO, "Test send");
PseudoTcpTestTransfer test = new PseudoTcpTestTransfer();
test.SetLocalMtu(1500);
test.SetRemoteMtu(1500);
test.TestTransfer(1000000);
}
/**
* Test sending data with a 50 ms RTT. Transmission should take longer due
* to a slower ramp-up in send rate.
*/
public void testSendWithDelay()
{
//logger.log(Level.INFO, "Test send with delay");
PseudoTcpTestTransfer test = new PseudoTcpTestTransfer();
test.SetLocalMtu(1500);
test.SetRemoteMtu(1500);
test.SetDelay(50);
test.TestTransfer(1000000);
}
/**
* Test sending data with packet loss. Transmission should take much longer
* due to send back-off when loss occurs.
*/
public void testSendWithLoss()
{
//logger.log(Level.INFO, "Test send with loss");
PseudoTcpTestTransfer test = new PseudoTcpTestTransfer();
test.SetLocalMtu(1500);
test.SetRemoteMtu(1500);
test.SetLoss(10);
test.TestTransfer(100000); // less data so test runs faster
}
/**
* Test sending data with a 50 ms RTT and 10% packet loss. Transmission
* should take much longer due to send back-off and slower detection of
* loss.
*/
public void testSendWithDelayAndLoss()
{
//logger.log(Level.INFO, "Test send with delay and loss");
PseudoTcpTestTransfer test = new PseudoTcpTestTransfer();
test.SetLocalMtu(1500);
test.SetRemoteMtu(1500);
test.SetDelay(50);
test.SetLoss(10);
test.TestTransfer(100000); // less data so test runs faster
}
/**
* Test sending data with 10% packet loss and Nagling disabled. Transmission
* should take about the same time as with Nagling enabled.
*/
public void testSendWithLossAndOptNaglingOff()
{
//logger.log(Level.INFO, "Test send with loss and OptNagling off");
PseudoTcpTestTransfer test = new PseudoTcpTestTransfer();
test.SetLocalMtu(1500);
test.SetRemoteMtu(1500);
test.SetLoss(10);
test.SetOptNagling(false);
test.TestTransfer(100000); // less data so test runs faster
}
/**
* Test sending data with 10% packet loss and Delayed ACK disabled.
* Transmission should be slightly faster than with it enabled.
*/
public void testSendWithLossAndOptAckDelayOff()
{
//logger.log(Level.INFO, "Test send with loss and OptAckDelay off");
PseudoTcpTestTransfer test = new PseudoTcpTestTransfer();
test.SetLocalMtu(1500);
test.SetRemoteMtu(1500);
test.SetLoss(10);
test.SetOptAckDelay(0);
test.TestTransfer(100000);
}
/**
* Test sending data with 50ms delay and Nagling disabled.
*/
public void testSendWithDelayAndOptNaglingOff()
{
//logger.log(Level.INFO, "Test send with delay and OptNagling off");
PseudoTcpTestTransfer test = new PseudoTcpTestTransfer();
test.SetLocalMtu(1500);
test.SetRemoteMtu(1500);
test.SetDelay(50);
test.SetOptNagling(false);
test.TestTransfer(100000); // less data so test runs faster
}
/**
* Test sending data with 50ms delay and Delayed ACK disabled.
*/
public void testSendWithDelayAndOptAckDelayOff()
{
//logger.log(Level.INFO, "Test send with delay and OptAckDelay off");
PseudoTcpTestTransfer test = new PseudoTcpTestTransfer();
test.SetLocalMtu(1500);
test.SetRemoteMtu(1500);
test.SetDelay(50);
test.SetOptAckDelay(0);
test.TestTransfer(100000); // less data so test runs faster
}
/**
* Test a large receive buffer with a sender that doesn't support scaling.
*/
public void testSendRemoteNoWindowScale()
{
//logger.log(Level.INFO, "Test send - remote no window scale");
PseudoTcpTestTransfer test = new PseudoTcpTestTransfer();
test.SetLocalMtu(1500);
test.SetRemoteMtu(1500);
test.SetLocalOptRcvBuf(100000);
test.DisableRemoteWindowScale();
test.TestTransfer(1000000);
}
/**
* Test a large sender-side receive buffer with a receiver that doesn't
* support scaling.
*/
public void testSendLocalNoWindowScale()
{
//logger.log(Level.INFO, "Test send - local no window scale");
PseudoTcpTestTransfer test = new PseudoTcpTestTransfer();
test.SetLocalMtu(1500);
test.SetRemoteMtu(1500);
test.SetRemoteOptRcvBuf(100000);
test.DisableLocalWindowScale();
test.TestTransfer(1000000);
}
/**
* Test when both sides use window scaling.
*/
public void testSendBothUseWindowScale()
{
//logger.log(Level.INFO, "Test send - both use window scale");
PseudoTcpTestTransfer test = new PseudoTcpTestTransfer();
test.SetLocalMtu(1500);
test.SetRemoteMtu(1500);
test.SetRemoteOptRcvBuf(100000);
test.SetLocalOptRcvBuf(100000);
test.TestTransfer(1000000);
}
/**
* Test using a large window scale value.
*/
public void testSendLargeInFlight()
{
//logger.log(Level.INFO, "Test send large in flight");
PseudoTcpTestTransfer test = new PseudoTcpTestTransfer();
test.SetLocalMtu(1500);
test.SetRemoteMtu(1500);
test.SetRemoteOptRcvBuf(100000);
test.SetLocalOptRcvBuf(100000);
test.SetOptSndBuf(150000);
test.TestTransfer(1000000);
}
public void testSendBothUseLargeWindowScale()
{
//logger.log(Level.INFO, "Test send both use large window scale");
PseudoTcpTestTransfer test = new PseudoTcpTestTransfer();
test.SetLocalMtu(1500);
test.SetRemoteMtu(1500);
test.SetRemoteOptRcvBuf(1000000);
test.SetLocalOptRcvBuf(1000000);
test.TestTransfer(10000000);
}
/**
* Test using a small receive buffer.
*/
public void testSendSmallReceiveBuffer()
{
//logger.log(Level.INFO, "Test send small receive buffer");
PseudoTcpTestTransfer test = new PseudoTcpTestTransfer();
test.SetLocalMtu(1500);
test.SetRemoteMtu(1500);
test.SetRemoteOptRcvBuf(10000);
test.SetLocalOptRcvBuf(10000);
test.TestTransfer(1000000);
}
/**
* Test using a very small receive buffer.
*/
public void testSendVerySmallReceiveBuffer()
{
//logger.log(Level.INFO, "Test send very small receive buffer");
PseudoTcpTestTransfer test = new PseudoTcpTestTransfer();
test.SetLocalMtu(1500);
test.SetRemoteMtu(1500);
test.SetRemoteOptRcvBuf(100);
test.SetLocalOptRcvBuf(100);
test.TestTransfer(100000);
}
}