Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Harmonize ReceiveMessageFrom tests and bring them back to Inner Loop #46862

Merged
merged 8 commits into from
Jan 13, 2021
+152 −213
Merged

Harmonize ReceiveMessageFrom tests and bring them back to Inner Loop #46862

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
8 commits
Select commit Hold shift + click to select a range
e0fbfb4
extend SocketTestHelper
antonfirsov Jan 11, 2021
a5543ad
SocketHelperMemoryNativeTask: implement UDP methods
antonfirsov Jan 11, 2021
83d773a
unified test for ReceiveSentMessages_Success
antonfirsov Jan 11, 2021
ba1f72c
oops, these overloads are not here yet
antonfirsov Jan 11, 2021
dd38c34
ReceiveSentMessages_ReuseEventArgs_Success
antonfirsov Jan 12, 2021
748c798
altering bufferMode does not work on Linux
antonfirsov Jan 12, 2021
10ae9cc
remove ReceiveMessageFromAsync.cs
antonfirsov Jan 12, 2021
ba25fd5
use AssertExtensions.SequenceEqual
antonfirsov Jan 12, 2021
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
207 changes: 88 additions & 119 deletions src/libraries/System.Net.Sockets/tests/FunctionalTests/ReceiveMessageFrom.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -3,173 +3,124 @@

using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
using Xunit;
using Xunit.Abstractions;

namespace System.Net.Sockets.Tests
{
public class ReceiveMessageFrom
public abstract class ReceiveMessageFrom<T> : SocketTestHelperBase<T> where T : SocketHelperBase, new()
{
[OuterLoop]
[Theory]
[InlineData(false)]
[InlineData(true)]
public void Success(bool forceNonBlocking)
{
if (Socket.OSSupportsIPv4)
{
using (Socket receiver = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp))
{
int port = receiver.BindToAnonymousPort(IPAddress.Loopback);
receiver.SetSocketOption(SocketOptionLevel.IP, SocketOptionName.PacketInformation, true);

receiver.ForceNonBlocking(forceNonBlocking);

Socket sender = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
sender.Bind(new IPEndPoint(IPAddress.Loopback, 0));

sender.ForceNonBlocking(forceNonBlocking);

sender.SendTo(new byte[1024], new IPEndPoint(IPAddress.Loopback, port));
protected ReceiveMessageFrom(ITestOutputHelper output) : base(output) { }

IPPacketInformation packetInformation;
SocketFlags flags = SocketFlags.None;
EndPoint remoteEP = new IPEndPoint(IPAddress.Any, 0);

int len = receiver.ReceiveMessageFrom(new byte[1024], 0, 1024, ref flags, ref remoteEP, out packetInformation);

Assert.Equal(1024, len);
Assert.Equal(sender.LocalEndPoint, remoteEP);
Assert.Equal(((IPEndPoint)sender.LocalEndPoint).Address, packetInformation.Address);

sender.Dispose();
}
}
}

[OuterLoop]
[Theory]
[InlineData(false)]
[InlineData(true)]
public void Success_IPv6(bool forceNonBlocking)
public async Task ReceiveSentMessages_Success(bool ipv4)
{
if (Socket.OSSupportsIPv6)
{
using (Socket receiver = new Socket(AddressFamily.InterNetworkV6, SocketType.Dgram, ProtocolType.Udp))
{
int port = receiver.BindToAnonymousPort(IPAddress.IPv6Loopback);
receiver.SetSocketOption(SocketOptionLevel.IPv6, SocketOptionName.PacketInformation, true);
const int DatagramSize = 256;
const int DatagramsToSend = 16;

receiver.ForceNonBlocking(forceNonBlocking);
IPAddress address = ipv4 ? IPAddress.Loopback : IPAddress.IPv6Loopback;
using Socket receiver = new Socket(address.AddressFamily, SocketType.Dgram, ProtocolType.Udp);
using Socket sender = new Socket(address.AddressFamily, SocketType.Dgram, ProtocolType.Udp);

Socket sender = new Socket(AddressFamily.InterNetworkV6, SocketType.Dgram, ProtocolType.Udp);
sender.Bind(new IPEndPoint(IPAddress.IPv6Loopback, 0));
receiver.SetSocketOption(ipv4 ? SocketOptionLevel.IP : SocketOptionLevel.IPv6, SocketOptionName.PacketInformation, true);
ConfigureNonBlocking(sender);
ConfigureNonBlocking(receiver);

sender.ForceNonBlocking(forceNonBlocking);
receiver.BindToAnonymousPort(address);
sender.BindToAnonymousPort(address);

sender.SendTo(new byte[1024], new IPEndPoint(IPAddress.IPv6Loopback, port));
byte[] sendBuffer = new byte[DatagramSize];
byte[] receiveBuffer = new byte[DatagramSize];
Random rnd = new Random(0);

IPPacketInformation packetInformation;
SocketFlags flags = SocketFlags.None;
EndPoint remoteEP = new IPEndPoint(IPAddress.IPv6Any, 0);
IPEndPoint remoteEp = new IPEndPoint(ipv4 ? IPAddress.Any : IPAddress.IPv6Any, 0);

int len = receiver.ReceiveMessageFrom(new byte[1024], 0, 1024, ref flags, ref remoteEP, out packetInformation);
for (int i = 0; i < DatagramsToSend; i++)
{
rnd.NextBytes(sendBuffer);
sender.SendTo(sendBuffer, receiver.LocalEndPoint);

Assert.Equal(1024, len);
Assert.Equal(sender.LocalEndPoint, remoteEP);
Assert.Equal(((IPEndPoint)sender.LocalEndPoint).Address, packetInformation.Address);
SocketReceiveMessageFromResult result = await ReceiveMessageFromAsync(receiver, receiveBuffer, remoteEp);
IPPacketInformation packetInformation = result.PacketInformation;

sender.Dispose();
}
Assert.Equal(DatagramSize, result.ReceivedBytes);
AssertExtensions.SequenceEqual(sendBuffer, receiveBuffer);
Assert.Equal(sender.LocalEndPoint, result.RemoteEndPoint);
Assert.Equal(((IPEndPoint)sender.LocalEndPoint).Address, packetInformation.Address);
}
}
}

[OuterLoop]
[Theory]
[InlineData(false)]
[InlineData(true)]
public void Success_APM(bool ipv4)
{
AddressFamily family;
IPAddress loopback, any;
SocketOptionLevel level;
if (ipv4)
{
if (!Socket.OSSupportsIPv4) return;
family = AddressFamily.InterNetwork;
loopback = IPAddress.Loopback;
any = IPAddress.Any;
level = SocketOptionLevel.IP;
}
else
{
if (!Socket.OSSupportsIPv6) return;
family = AddressFamily.InterNetworkV6;
loopback = IPAddress.IPv6Loopback;
any = IPAddress.IPv6Any;
level = SocketOptionLevel.IPv6;
}

using (var receiver = new Socket(family, SocketType.Dgram, ProtocolType.Udp))
using (var sender = new Socket(family, SocketType.Dgram, ProtocolType.Udp))
{
int port = receiver.BindToAnonymousPort(loopback);
receiver.SetSocketOption(level, SocketOptionName.PacketInformation, true);
sender.Bind(new IPEndPoint(loopback, 0));
public sealed class ReceiveMessageFrom_Sync : ReceiveMessageFrom<SocketHelperArraySync>
{
public ReceiveMessageFrom_Sync(ITestOutputHelper output) : base(output) { }
}

sender.SendTo(new byte[1024], new IPEndPoint(loopback, port));
public sealed class ReceiveMessageFrom_SyncForceNonBlocking : ReceiveMessageFrom<SocketHelperSyncForceNonBlocking>
{
public ReceiveMessageFrom_SyncForceNonBlocking(ITestOutputHelper output) : base(output) { }
}

IPPacketInformation packetInformation;
SocketFlags flags = SocketFlags.None;
EndPoint remoteEP = new IPEndPoint(any, 0);
public sealed class ReceiveMessageFrom_Apm : ReceiveMessageFrom<SocketHelperApm>
{
public ReceiveMessageFrom_Apm(ITestOutputHelper output) : base(output) { }
}

IAsyncResult ar = receiver.BeginReceiveMessageFrom(new byte[1024], 0, 1024, flags, ref remoteEP, null, null);
int len = receiver.EndReceiveMessageFrom(ar, ref flags, ref remoteEP, out packetInformation);
public sealed class ReceiveMessageFrom_Task : ReceiveMessageFrom<SocketHelperTask>
{
public ReceiveMessageFrom_Task(ITestOutputHelper output) : base(output) { }
}

Assert.Equal(1024, len);
Assert.Equal(sender.LocalEndPoint, remoteEP);
Assert.Equal(((IPEndPoint)sender.LocalEndPoint).Address, packetInformation.Address);
}
}
public sealed class ReceiveMessageFrom_Eap : ReceiveMessageFrom<SocketHelperEap>
{
public ReceiveMessageFrom_Eap(ITestOutputHelper output) : base(output) { }

[OuterLoop]
[Theory]
[InlineData(false, 0)]
[InlineData(false, 1)]
[InlineData(false, 2)]
[InlineData(true, 0)]
[InlineData(true, 1)]
[InlineData(true, 2)]
public void Success_EventArgs(bool ipv4, int bufferMode)
public void ReceiveSentMessages_ReuseEventArgs_Success(bool ipv4, int bufferMode)
{
const int DatagramsToSend = 30;
const int TimeoutMs = 30_000;

AddressFamily family;
IPAddress loopback, any;
SocketOptionLevel level;
if (ipv4)
{
if (!Socket.OSSupportsIPv4) return;
family = AddressFamily.InterNetwork;
loopback = IPAddress.Loopback;
any = IPAddress.Any;
level = SocketOptionLevel.IP;
}
else
{
if (!Socket.OSSupportsIPv6) return;
family = AddressFamily.InterNetworkV6;
loopback = IPAddress.IPv6Loopback;
any = IPAddress.IPv6Any;
level = SocketOptionLevel.IPv6;
}

using (var receiver = new Socket(family, SocketType.Dgram, ProtocolType.Udp))
using (var sender = new Socket(family, SocketType.Dgram, ProtocolType.Udp))
using (var saea = new SocketAsyncEventArgs())
{
int port = receiver.BindToAnonymousPort(loopback);
receiver.SetSocketOption(level, SocketOptionName.PacketInformation, true);
sender.Bind(new IPEndPoint(loopback, 0));
using var receiver = new Socket(family, SocketType.Dgram, ProtocolType.Udp);
using var sender = new Socket(family, SocketType.Dgram, ProtocolType.Udp);
using var saea = new SocketAsyncEventArgs();
var completed = new ManualResetEventSlim();
saea.Completed += delegate { completed.Set(); };

saea.RemoteEndPoint = new IPEndPoint(any, 0);
int port = receiver.BindToAnonymousPort(loopback);
receiver.SetSocketOption(level, SocketOptionName.PacketInformation, true);
sender.Bind(new IPEndPoint(loopback, 0));
saea.RemoteEndPoint = new IPEndPoint(any, 0);

for (int i = 0; i < DatagramsToSend; i++)
{
switch (bufferMode)
{
case 0: // single buffer
Expand All @@ -190,17 +141,35 @@ public void Success_EventArgs(bool ipv4, int bufferMode)
break;
}

var mres = new ManualResetEventSlim();
saea.Completed += delegate { mres.Set(); };

bool pending = receiver.ReceiveMessageFromAsync(saea);
sender.SendTo(new byte[1024], new IPEndPoint(loopback, port));
if (pending) Assert.True(mres.Wait(30000), "Expected operation to complete within timeout");
if (pending) Assert.True(completed.Wait(TimeoutMs), "Expected operation to complete within timeout");
completed.Reset();

Assert.Equal(1024, saea.BytesTransferred);
Assert.Equal(sender.LocalEndPoint, saea.RemoteEndPoint);
Assert.Equal(((IPEndPoint)sender.LocalEndPoint).Address, saea.ReceiveMessageFromPacketInfo.Address);
}
}
}
}

public sealed class ReceiveMessageFrom_SpanSync : ReceiveMessageFrom<SocketHelperSpanSync>
{
public ReceiveMessageFrom_SpanSync(ITestOutputHelper output) : base(output) { }
}

public sealed class ReceiveMessageFrom_SpanSyncForceNonBlocking : ReceiveMessageFrom<SocketHelperSpanSyncForceNonBlocking>
{
public ReceiveMessageFrom_SpanSyncForceNonBlocking(ITestOutputHelper output) : base(output) { }
}

public sealed class ReceiveMessageFrom_MemoryArrayTask : ReceiveMessageFrom<SocketHelperMemoryArrayTask>
{
public ReceiveMessageFrom_MemoryArrayTask(ITestOutputHelper output) : base(output) { }
}

public sealed class ReceiveMessageFrom_MemoryNativeTask : ReceiveMessageFrom<SocketHelperMemoryNativeTask>
{
public ReceiveMessageFrom_MemoryNativeTask(ITestOutputHelper output) : base(output) { }
}
}
90 changes: 0 additions & 90 deletions src/libraries/System.Net.Sockets/tests/FunctionalTests/ReceiveMessageFromAsync.cs
View file
Open in desktop

This file was deleted.

Loading