dotnet/corefx#15697 changed this value to 1, and no-one touched it since then.
As the comment in that PR points out, the root cause of the UDP test failures wasn't packet loss, but IPv4 / IPv6 port collision on Unix in dual-mode cases.
The value and the for loops are complicating Socket test code unnecessarily, simplification seems reasonable.
public const int PassingTestTimeout = 10000;
public const int FailingTestTimeout = 100;
- // Number of redundant UDP packets to send to increase test reliability
- // Update: was 10, changing to 1 to measure impact of random test failures occurring on *nix.
- // Certain random failures appear to be caused by a UDP client sending in a loop (based on UDPRedundancy)
- // to a server which was closed but another server created (on a different thread \ test) that happens to
- // have the same port #.
- // This occurs on *nix but not Windows because *nix uses random values (1024-65535) while Windows increments.
- public const int UDPRedundancy = 1;
-
public static Task WhenAllOrAnyFailedWithTimeout(params Task[] tasks) => tasks.WhenAllOrAnyFailed(PassingTestTimeout);
}
}
using (Socket client = new Socket(SocketType.Dgram, ProtocolType.Udp))
using (SocketUdpServer server = new SocketUdpServer(_log, listenOn, dualModeServer, out int port))
{
- // Send a few packets, in case they aren't delivered reliably.
- for (int i = 0; i < (expectedToTimeout ? 1 : TestSettings.UDPRedundancy); i++)
- {
- int sent = client.SendTo(new byte[1], new IPEndPoint(connectTo, port));
- Assert.Equal(1, sent);
- }
+ int sent = client.SendTo(new byte[1], new IPEndPoint(connectTo, port));
+ Assert.Equal(1, sent);
bool success = server.WaitHandle.WaitOne(expectedToTimeout ? TestSettings.FailingTestTimeout : TestSettings.PassingTestTimeout); // Make sure the bytes were received
if (!success)
using (Socket client = new Socket(SocketType.Dgram, ProtocolType.Udp))
using (SocketUdpServer server = new SocketUdpServer(_log, listenOn, dualModeServer, out int port))
{
- // Send a few packets, in case they aren't delivered reliably.
- for (int i = 0; i < (expectedToTimeout ? 1 : TestSettings.UDPRedundancy); i++)
- {
- IAsyncResult async = client.BeginSendTo(new byte[1], 0, 1, SocketFlags.None, new IPEndPoint(connectTo, port), null, null);
+ IAsyncResult async = client.BeginSendTo(new byte[1], 0, 1, SocketFlags.None, new IPEndPoint(connectTo, port), null, null);
- int sent = client.EndSendTo(async);
- Assert.Equal(1, sent);
- }
+ int sent = client.EndSendTo(async);
+ Assert.Equal(1, sent);
bool success = server.WaitHandle.WaitOne(expectedToTimeout ? TestSettings.FailingTestTimeout : TestSettings.PassingTestTimeout); // Make sure the bytes were received
if (!success)
using (Socket client = new Socket(SocketType.Dgram, ProtocolType.Udp))
using (SocketUdpServer server = new SocketUdpServer(_log, listenOn, dualModeServer, out int port))
{
- // Send a few packets, in case they aren't delivered reliably.
- for (int i = 0; i < (expectedToTimeout ? 1 : TestSettings.UDPRedundancy); i++)
+ using (ManualResetEvent waitHandle = new ManualResetEvent(false))
{
- using (ManualResetEvent waitHandle = new ManualResetEvent(false))
+ SocketAsyncEventArgs args = new SocketAsyncEventArgs();
+ args.RemoteEndPoint = new IPEndPoint(connectTo, port);
+ args.SetBuffer(new byte[1], 0, 1);
+ args.UserToken = waitHandle;
+ args.Completed += AsyncCompleted;
+
+ bool async = client.SendToAsync(args);
+ if (async)
{
- SocketAsyncEventArgs args = new SocketAsyncEventArgs();
- args.RemoteEndPoint = new IPEndPoint(connectTo, port);
- args.SetBuffer(new byte[1], 0, 1);
- args.UserToken = waitHandle;
- args.Completed += AsyncCompleted;
-
- bool async = client.SendToAsync(args);
- if (async)
- {
- Assert.True(waitHandle.WaitOne(TestSettings.PassingTestTimeout), "Timeout while waiting for connection");
- }
-
- Assert.Equal(1, args.BytesTransferred);
- if (args.SocketError != SocketError.Success)
- {
- throw new SocketException((int)args.SocketError);
- }
+ Assert.True(waitHandle.WaitOne(TestSettings.PassingTestTimeout), "Timeout while waiting for connection");
+ }
+
+ Assert.Equal(1, args.BytesTransferred);
+ if (args.SocketError != SocketError.Success)
+ {
+ throw new SocketException((int)args.SocketError);
}
}
// Assert.Equal(AddressFamily.InterNetworkV6, remoteEndPoint.AddressFamily);
// Assert.Equal(connectTo.MapToIPv6(), remoteEndPoint.Address);
- SocketUdpClient client = new SocketUdpClient(_log, serverSocket, connectTo, port, redundant: !expectedToTimeout);
+ SocketUdpClient client = new SocketUdpClient(_log, serverSocket, connectTo, port);
bool success = async.AsyncWaitHandle.WaitOne(expectedToTimeout ? TestSettings.FailingTestTimeout : TestSettings.PassingTestTimeout);
if (!success)
{
args.Completed += AsyncCompleted;
bool async = serverSocket.ReceiveFromAsync(args);
- SocketUdpClient client = new SocketUdpClient(_log, serverSocket, connectTo, port, redundant: !expectedToTimeout);
+ SocketUdpClient client = new SocketUdpClient(_log, serverSocket, connectTo, port);
if (async && !waitHandle.WaitOne(expectedToTimeout ? TestSettings.FailingTestTimeout : TestSettings.PassingTestTimeout))
{
throw new TimeoutException();
var ep = new IPEndPoint(loopback, receiverPort);
for (int iters = 0; iters < 5; iters++)
{
- for (int i = 0; i < TestSettings.UDPRedundancy; i++)
- {
- sender.SendTo(new byte[DataLength], ep);
- }
+ sender.SendTo(new byte[DataLength], ep);
if (!receiver.ReceiveMessageFromAsync(args))
{
// Assert.Equal(AddressFamily.InterNetworkV6, remoteEndPoint.AddressFamily);
// Assert.Equal(connectTo.MapToIPv6(), remoteEndPoint.Address);
- SocketUdpClient client = new SocketUdpClient(_log, serverSocket, connectTo, port, redundant: !expectedToTimeout);
+ SocketUdpClient client = new SocketUdpClient(_log, serverSocket, connectTo, port);
bool success = async.AsyncWaitHandle.WaitOne(expectedToTimeout ? TestSettings.FailingTestTimeout : TestSettings.PassingTestTimeout);
if (!success)
{
bool async = serverSocket.ReceiveMessageFromAsync(args);
Assert.True(async);
- SocketUdpClient client = new SocketUdpClient(_log, serverSocket, connectTo, port, redundant: !expectedToTimeout);
+ SocketUdpClient client = new SocketUdpClient(_log, serverSocket, connectTo, port);
if (!waitHandle.WaitOne(serverSocket.ReceiveTimeout))
{
throw new TimeoutException();
private IPAddress _connectTo;
private Socket _serverSocket;
- public SocketUdpClient(ITestOutputHelper output, Socket serverSocket, IPAddress connectTo, int port, bool redundant = true, bool sendNow = true)
+ public SocketUdpClient(ITestOutputHelper output, Socket serverSocket, IPAddress connectTo, int port, bool sendNow = true)
{
_output = output;
if (sendNow)
{
- Task.Run(() => ClientSend(redundant));
+ Task.Run(() => ClientSend());
}
}
- public void ClientSend(bool redundant = true, int timeout = 3)
+ public void ClientSend(int timeout = 3)
{
try
{
Socket socket = new Socket(_connectTo.AddressFamily, SocketType.Dgram, ProtocolType.Udp);
socket.SendTimeout = timeout * 1000;
- for (int i = 0; i < (redundant ? TestSettings.UDPRedundancy : 1); i++)
- {
- SocketAsyncEventArgs e = new SocketAsyncEventArgs();
- e.RemoteEndPoint = new IPEndPoint(_connectTo, _port);
- e.SetBuffer(new byte[1], 0, 1);
+ SocketAsyncEventArgs e = new SocketAsyncEventArgs();
+ e.RemoteEndPoint = new IPEndPoint(_connectTo, _port);
+ e.SetBuffer(new byte[1], 0, 1);
- socket.SendToAsync(e);
- }
+ socket.SendToAsync(e);
}
catch (SocketException e)
{
Assert.True(receiver.ReceiveMessageFromAsync(receiveArgs), "receiver.ReceiveMessageFromAsync");
// Send a few packets, in case they aren't delivered reliably.
- for (int i = 0; i < TestSettings.UDPRedundancy; i++)
- {
- sender.SendTo(new byte[1], new IPEndPoint(IPAddress.Loopback, port));
- }
+ sender.SendTo(new byte[1], new IPEndPoint(IPAddress.Loopback, port));
Assert.True(waitHandle.WaitOne(ReceiveTimeout), "waitHandle.WaitOne");
sender.ForceNonBlocking(forceNonBlocking);
- for (int i = 0; i < TestSettings.UDPRedundancy; i++)
- {
- sender.SendTo(new byte[1024], new IPEndPoint(IPAddress.Loopback, port));
- }
+ sender.SendTo(new byte[1024], new IPEndPoint(IPAddress.Loopback, port));
IPPacketInformation packetInformation;
SocketFlags flags = SocketFlags.None;
sender.ForceNonBlocking(forceNonBlocking);
- for (int i = 0; i < TestSettings.UDPRedundancy; i++)
- {
- sender.SendTo(new byte[1024], new IPEndPoint(IPAddress.IPv6Loopback, port));
- }
+ sender.SendTo(new byte[1024], new IPEndPoint(IPAddress.IPv6Loopback, port));
IPPacketInformation packetInformation;
SocketFlags flags = SocketFlags.None;
receiver.SetSocketOption(level, SocketOptionName.PacketInformation, true);
sender.Bind(new IPEndPoint(loopback, 0));
- for (int i = 0; i < TestSettings.UDPRedundancy; i++)
- {
- sender.SendTo(new byte[1024], new IPEndPoint(loopback, port));
- }
+ sender.SendTo(new byte[1024], new IPEndPoint(loopback, port));
IPPacketInformation packetInformation;
SocketFlags flags = SocketFlags.None;
saea.Completed += delegate { mres.Set(); };
bool pending = receiver.ReceiveMessageFromAsync(saea);
- for (int i = 0; i < TestSettings.UDPRedundancy; i++)
- {
- sender.SendTo(new byte[1024], new IPEndPoint(loopback, port));
- }
+ sender.SendTo(new byte[1024], new IPEndPoint(loopback, port));
if (pending) Assert.True(mres.Wait(30000), "Expected operation to complete within timeout");
Assert.Equal(1024, saea.BytesTransferred);
for (int iters = 0; iters < 5; iters++)
{
- for (int i = 0; i < TestSettings.UDPRedundancy; i++)
- {
- sender.SendTo(new byte[DataLength], new IPEndPoint(loopback, port));
- }
+ sender.SendTo(new byte[DataLength], new IPEndPoint(loopback, port));
if (changeReceiveBufferEachCall)
{
for (int iters = 0; iters < 5; iters++)
{
- for (int i = 0; i < TestSettings.UDPRedundancy; i++)
- {
- sender.SendTo(new byte[DataLength], new IPEndPoint(loopback, port));
- }
+ sender.SendTo(new byte[DataLength], new IPEndPoint(loopback, port));
SocketReceiveMessageFromResult result = await receiver.ReceiveMessageFromAsync(
new ArraySegment<byte>(new byte[DataLength], 0, DataLength), SocketFlags.None,
int receiverPort = receiver.BindToAnonymousPort(IPAddress.Loopback);
var receiverEndpoint = new IPEndPoint(IPAddress.Loopback, receiverPort);
- for (int i = 0; i < TestSettings.UDPRedundancy; i++)
- {
- sender.SendTo(new byte[1], SocketFlags.None, receiverEndpoint);
- }
+ sender.SendTo(new byte[1], SocketFlags.None, receiverEndpoint);
var list = new List<Socket> { receiver };
Socket.Select(list, null, null, SelectSuccessTimeoutMicroseconds);
int secondReceiverPort = secondReceiver.BindToAnonymousPort(IPAddress.Loopback);
var secondReceiverEndpoint = new IPEndPoint(IPAddress.Loopback, secondReceiverPort);
- for (int i = 0; i < TestSettings.UDPRedundancy; i++)
- {
- sender.SendTo(new byte[1], SocketFlags.None, firstReceiverEndpoint);
- sender.SendTo(new byte[1], SocketFlags.None, secondReceiverEndpoint);
- }
+ sender.SendTo(new byte[1], SocketFlags.None, firstReceiverEndpoint);
+ sender.SendTo(new byte[1], SocketFlags.None, secondReceiverEndpoint);
var sw = Stopwatch.StartNew();
Assert.True(SpinWait.SpinUntil(() =>
int secondReceiverPort = secondReceiver.BindToAnonymousPort(IPAddress.Loopback);
var secondReceiverEndpoint = new IPEndPoint(IPAddress.Loopback, secondReceiverPort);
- for (int i = 0; i < TestSettings.UDPRedundancy; i++)
- {
- sender.SendTo(new byte[1], SocketFlags.None, secondReceiverEndpoint);
- }
+ sender.SendTo(new byte[1], SocketFlags.None, secondReceiverEndpoint);
var list = new List<Socket> { firstReceiver, secondReceiver };
Socket.Select(list, null, null, SelectSuccessTimeoutMicroseconds);
int receiverPort = receiver.BindToAnonymousPort(IPAddress.Loopback);
var receiverEndpoint = new IPEndPoint(IPAddress.Loopback, receiverPort);
- for (int i = 0; i < TestSettings.UDPRedundancy; i++)
- {
- sender.SendTo(new byte[1], SocketFlags.None, receiverEndpoint);
- }
+ sender.SendTo(new byte[1], SocketFlags.None, receiverEndpoint);
Assert.True(receiver.Poll(SelectSuccessTimeoutMicroseconds, SelectMode.SelectRead));
}
var receiveBuffer = new byte[1024];
var receiveTask = receiveSocket.ReceiveAsync(new ArraySegment<byte>(receiveBuffer), SocketFlags.None);
- for (int i = 0; i < TestSettings.UDPRedundancy; i++)
- {
- sendSocket.SendTo(Encoding.UTF8.GetBytes(message), new IPEndPoint(multicastAddress, port));
- }
+ sendSocket.SendTo(Encoding.UTF8.GetBytes(message), new IPEndPoint(multicastAddress, port));
var cts = new CancellationTokenSource();
Assert.True(await Task.WhenAny(receiveTask, Task.Delay(30_000, cts.Token)) == receiveTask, "Waiting for received data timed out");
var receiveBuffer = new byte[1024];
var receiveTask = receiveSocket.ReceiveAsync(new ArraySegment<byte>(receiveBuffer), SocketFlags.None);
- for (int i = 0; i < TestSettings.UDPRedundancy; i++)
- {
- sendSocket.SendTo(Encoding.UTF8.GetBytes(message), new IPEndPoint(multicastAddress, port));
- }
+ sendSocket.SendTo(Encoding.UTF8.GetBytes(message), new IPEndPoint(multicastAddress, port));
var cts = new CancellationTokenSource();
Assert.True(await Task.WhenAny(receiveTask, Task.Delay(30_000, cts.Token)) == receiveTask, "Waiting for received data timed out");
using (var receiver = new UdpClient(new IPEndPoint(address, 0)))
using (var sender = new UdpClient(new IPEndPoint(address, 0)))
{
- for (int i = 0; i < TestSettings.UDPRedundancy; i++)
- {
- sender.Send(new byte[1], 1, new IPEndPoint(address, ((IPEndPoint)receiver.Client.LocalEndPoint).Port));
- }
+ sender.Send(new byte[1], 1, new IPEndPoint(address, ((IPEndPoint)receiver.Client.LocalEndPoint).Port));
IPEndPoint remoteEP = null;
byte[] data = receiver.Receive(ref remoteEP);
using (var receiver = new UdpClient("localhost", 0))
using (var sender = new UdpClient("localhost", ((IPEndPoint)receiver.Client.LocalEndPoint).Port))
{
- for (int i = 0; i < TestSettings.UDPRedundancy; i++)
- {
- sender.Send(new byte[1], 1);
- }
+ sender.Send(new byte[1], 1);
IPEndPoint remoteEP = null;
byte[] data = receiver.Receive(ref remoteEP);
using (var receiver = new UdpClient(new IPEndPoint(address, 0)))
using (var sender = new UdpClient(new IPEndPoint(address, 0)))
{
- for (int i = 0; i < TestSettings.UDPRedundancy; i++)
- {
- sender.Send(new byte[1], 1, new IPEndPoint(address, ((IPEndPoint)receiver.Client.LocalEndPoint).Port));
- }
+ sender.Send(new byte[1], 1, new IPEndPoint(address, ((IPEndPoint)receiver.Client.LocalEndPoint).Port));
Assert.True(SpinWait.SpinUntil(() => receiver.Available > 0, 30000), "Expected data to be available for receive within time limit");
}
using (var receiver = new UdpClient(new IPEndPoint(address, 0)))
using (var sender = new UdpClient(new IPEndPoint(address, 0)))
{
- for (int i = 0; i < TestSettings.UDPRedundancy; i++)
- {
- sender.EndSend(sender.BeginSend(new byte[1], 1, new IPEndPoint(address, ((IPEndPoint)receiver.Client.LocalEndPoint).Port), null, null));
- }
+ sender.EndSend(sender.BeginSend(new byte[1], 1, new IPEndPoint(address, ((IPEndPoint)receiver.Client.LocalEndPoint).Port), null, null));
IPEndPoint remoteEP = null;
byte[] data = receiver.EndReceive(receiver.BeginReceive(null, null), ref remoteEP);
using (var receiver = new UdpClient("localhost", 0))
using (var sender = new UdpClient("localhost", ((IPEndPoint)receiver.Client.LocalEndPoint).Port))
{
- for (int i = 0; i < TestSettings.UDPRedundancy; i++)
- {
- sender.EndSend(sender.BeginSend(new byte[1], 1, null, null));
- }
+ sender.EndSend(sender.BeginSend(new byte[1], 1, null, null));
IPEndPoint remoteEP = null;
byte[] data = receiver.EndReceive(receiver.BeginReceive(null, null), ref remoteEP);
using (var receiver = new UdpClient(new IPEndPoint(address, 0)))
using (var sender = new UdpClient(new IPEndPoint(address, 0)))
{
- for (int i = 0; i < TestSettings.UDPRedundancy; i++)
- {
- await sender.SendAsync(new byte[1], 1, new IPEndPoint(address, ((IPEndPoint)receiver.Client.LocalEndPoint).Port));
- }
+ await sender.SendAsync(new byte[1], 1, new IPEndPoint(address, ((IPEndPoint)receiver.Client.LocalEndPoint).Port));
UdpReceiveResult result = await receiver.ReceiveAsync();
Assert.NotNull(result.RemoteEndPoint);
using (var receiver = new UdpClient("localhost", 0))
using (var sender = new UdpClient("localhost", ((IPEndPoint)receiver.Client.LocalEndPoint).Port))
{
- for (int i = 0; i < TestSettings.UDPRedundancy; i++)
- {
- await sender.SendAsync(new byte[1], 1);
- }
+ await sender.SendAsync(new byte[1], 1);
UdpReceiveResult result = await receiver.ReceiveAsync();
Assert.NotNull(result.RemoteEndPoint);
projects / platform / upstream / dotnet / runtime.git / commitdiff