public void CanStart()
{
using (CompletionThread worker = new CompletionThread())
{
worker.Start();
}
}
public MetashareFixture()
{
pipeline = new PipelineSimulator();
completion = new CompletionThread();
completion.Start();
files = new FileFactory(completion);
}
public RepositoryFixture()
{
pipeline = new LeakPipeline();
pipeline.Start();
completion = new CompletionThread();
completion.Start();
files = new FileFactory(completion);
}
public void CanCreateNewTcpSocket()
{
using (CompletionThread worker = new CompletionThread())
{
SocketFactory factory = new SocketFactory(worker);
TcpSocket socket = factory.Tcp();
Assert.That(socket, Is.Not.Null);
}
}
public void CanDisposeNewUdpSocket()
{
using (CompletionThread worker = new CompletionThread())
{
SocketFactory factory = new SocketFactory(worker);
UdpSocket socket = factory.Udp();
socket.Dispose();
}
}
public void CanBindSocket()
{
using (CompletionThread worker = new CompletionThread())
{
SocketFactory factory = new SocketFactory(worker);
TcpSocket socket = factory.Tcp();
socket.Bind();
}
}
public void CanProceedWithNewLength()
{
using (CompletionThread worker = new CompletionThread())
{
string path = Path.Combine(sandbox.Directory, "abc.txt");
FileFactory factory = new FileFactory(worker);
using (File file = factory.OpenOrCreate(path))
{
Assert.That(file.SetLength(10), Is.True);
}
}
}
public async Task CanHandleNotBoundSocket()
{
using (CompletionThread worker = new CompletionThread())
{
SocketFactory factory = new SocketFactory(worker);
using (TcpSocket socket = factory.Tcp())
{
TcpSocketAccept accepted = await socket.Accept();
Assert.That(accepted.Status, Is.Not.EqualTo(SocketStatus.OK));
}
}
}
public void CanFailOnNotFoundFile()
{
using (CompletionThread worker = new CompletionThread())
{
string path = Path.Combine(sandbox.Directory, "abc.txt");
FileFactory factory = new FileFactory(worker);
using (File file = factory.Open(path))
{
Assert.That(file, Is.Null);
}
Assert.That(System.IO.File.Exists(path), Is.False);
}
}
public void CanCreateRussianFile()
{
using (CompletionThread worker = new CompletionThread())
{
string path = Path.Combine(sandbox.Directory, "абг.txt");
FileFactory factory = new FileFactory(worker);
using (File file = factory.OpenOrCreate(path))
{
}
Assert.That(System.IO.File.Exists(path), Is.True);
Assert.That(new FileInfo(path).Length, Is.Zero);
}
}
public async Task CanHandleNotBoundSocket()
{
using (CompletionThread worker = new CompletionThread())
{
SocketFactory factory = new SocketFactory(worker);
using (TcpSocket socket = factory.Tcp())
{
byte[] buffer = new byte[10];
TcpSocketSend sent = await socket.Send(buffer);
Assert.That(sent.Status, Is.Not.EqualTo(SocketStatus.OK));
}
}
}
public void CanSetNewLength()
{
using (CompletionThread worker = new CompletionThread())
{
string path = Path.Combine(sandbox.Directory, "abc.txt");
FileFactory factory = new FileFactory(worker);
using (File file = factory.OpenOrCreate(path))
{
file.SetLength(10);
}
Assert.That(new FileInfo(path).Length, Is.EqualTo(10));
}
}
public async Task CanHandleNotBoundSocket()
{
using (CompletionThread worker = new CompletionThread())
{
SocketFactory factory = new SocketFactory(worker);
using (TcpSocket socket = factory.Tcp())
{
IPEndPoint endpoint = new IPEndPoint(IPAddress.Loopback, 80);
TcpSocketConnect connected = await socket.Connect(endpoint);
Assert.That(connected.Status, Is.Not.EqualTo(SocketStatus.OK));
}
}
}
public void Stop()
{
lock (this)
{
if (worker != null)
{
worker.Dispose();
worker = null;
}
if (pipeline != null)
{
pipeline?.Stop();
pipeline = null;
}
}
}
public ConnectorFixture()
{
pipeline = new LeakPipeline();
pipeline.Start();
worker = new CompletionThread();
worker.Start();
pool =
new NetworkPoolBuilder()
.WithPipeline(pipeline)
.WithWorker(worker)
.WithMemory(new ConnectorMemory())
.Build();
pool.Start();
hooks = new PeerConnectorHooks();
}
public async Task CanHandleRequest()
{
using (CompletionThread worker = new CompletionThread())
{
SocketFactory factory = new SocketFactory(worker);
EchoClient client = new EchoClient(factory);
using (EchoServer server = new EchoServer(factory))
{
worker.Start();
server.Start();
string payload = "abc";
string response = await client.Send(server.Endpoint, payload);
Assert.That(response, Is.EqualTo(payload));
}
}
}
public void CanReceiveDataUsingCallbackToExampleSite()
{
TimeSpan timeout = TimeSpan.FromSeconds(2);
ManualResetEvent check = new ManualResetEvent(false);
IPAddress[] addresses = Dns.GetHostAddresses("www.example.com");
IPEndPoint endpoint = new IPEndPoint(addresses[0], 80);
string request = "GET /index.html HTTP/1.1\r\nHost: www.example.com\r\n\r\n";
byte[] data = Encoding.ASCII.GetBytes(request);
using (CompletionThread worker = new CompletionThread())
{
SocketFactory factory = new SocketFactory(worker);
TcpSocket socket = factory.Tcp();
socket.Bind();
worker.Start();
TcpSocketReceiveCallback onReceived = result =>
{
check.Set();
};
TcpSocketSendCallback onSent = result =>
{
socket.Receive(data, onReceived);
};
TcpSocketConnectCallback onConnected = result =>
{
socket.Send(data, onSent);
};
socket.Connect(endpoint, onConnected);
bool completed = check.WaitOne(timeout);
Assert.That(completed, Is.True);
socket.Dispose();
}
}
public static void Main(string[] args)
{
using (CompletionThread worker = new CompletionThread())
{
EchoOptions options = Argument.Parse <EchoOptions>(args);
SocketFactory factory = new SocketFactory(worker);
worker.Start();
if (options.Server != null)
{
EchoServerStarter.Start(options.Server, factory);
}
if (options.Benchmark != null)
{
EchoBenchmarkStarter.Start(options.Benchmark, factory);
}
}
}
public LoopFixture()
{
pipeline = new LeakPipeline();
pipeline.Start();
worker = new CompletionThread();
worker.Start();
pool =
new NetworkPoolBuilder()
.WithPipeline(pipeline)
.WithWorker(worker)
.WithMemory(new LoopMemory())
.Build();
pool.Start();
hooks = new ReceiverHooks();
samples = new LoopSamples();
}
public async Task CanConnectUsingTasksToNotAvailableSite()
{
IPAddress[] addresses = Dns.GetHostAddresses("www.example.com");
IPEndPoint endpoint = new IPEndPoint(addresses[0], 8123);
using (CompletionThread worker = new CompletionThread())
{
SocketFactory factory = new SocketFactory(worker);
TcpSocket socket = factory.Tcp();
socket.Bind();
worker.Start();
TcpSocketConnect connect = await socket.Connect(endpoint);
SocketStatus expected = SocketStatus.TimedOut;
Assert.That(connect.Status, Is.EqualTo(expected));
}
}
public void CanOpenExistingFile()
{
using (CompletionThread worker = new CompletionThread())
{
string path = Path.Combine(sandbox.Directory, "abc.txt");
FileFactory factory = new FileFactory(worker);
using (FileStream stream = System.IO.File.Create(path))
{
stream.Write(new byte[10], 0, 10);
stream.Flush(true);
}
using (File file = factory.OpenOrCreate(path))
{
}
Assert.That(System.IO.File.Exists(path), Is.True);
Assert.That(new FileInfo(path).Length, Is.EqualTo(10));
}
}
public void CanTransferDataUsingUdpSockets()
{
using (CompletionThread worker = new CompletionThread())
{
worker.Start();
using (ManualResetEvent sync = new ManualResetEvent(false))
{
IPEndPoint endpoint = new IPEndPoint(IPAddress.Loopback, 44556);
byte[] data = Encoding.ASCII.GetBytes("abc");
SocketBuffer buffer = new SocketBuffer(data);
SocketFactory factory = new SocketFactory(worker);
using (UdpSocket sender = factory.Udp())
using (UdpSocket receiver = factory.Udp())
{
sender.Bind();
receiver.Bind(endpoint.Port);
receiver.Receive(new SocketBuffer(10), received =>
{
Assert.That(received.Status, Is.EqualTo(SocketStatus.OK));
Assert.That(received.Count, Is.EqualTo(3));
Assert.That(received.Buffer.Data.Take(3), Is.EqualTo(data));
sync.Set();
});
sender.Send(endpoint, buffer, sent =>
{
Assert.That(sent.Status, Is.EqualTo(SocketStatus.OK));
Assert.That(sent.Count, Is.EqualTo(3));
});
}
Assert.That(sync.WaitOne(200), Is.True);
}
}
}
public async Task CanSendDataUsingAsyncToExampleSite()
{
IPAddress[] addresses = Dns.GetHostAddresses("www.example.com");
IPEndPoint endpoint = new IPEndPoint(addresses[0], 80);
string request = "GET /index.html HTTP/1.1\r\nHost: www.example.com\r\n\r\n";
byte[] data = Encoding.ASCII.GetBytes(request);
using (CompletionThread worker = new CompletionThread())
{
SocketFactory factory = new SocketFactory(worker);
TcpSocket socket = factory.Tcp();
socket.Bind();
worker.Start();
await socket.Connect(endpoint);
await socket.Send(data);
}
}
public void Start()
{
lock (this)
{
if (pipeline == null)
{
pipeline = new LeakPipeline();
pipeline.Start();
}
if (worker == null)
{
worker = new CompletionThread();
worker.Start();
}
if (files == null)
{
files = new FileFactory(worker);
}
}
}
public NegotiatorFixture()
{
pipeline = new LeakPipeline();
pipeline.Start();
worker = new CompletionThread();
worker.Start();
pool =
new NetworkPoolBuilder()
.WithPipeline(pipeline)
.WithWorker(worker)
.WithMemory(new NegotiatorMemory())
.Build();
pool.Start();
hooks = new HandshakeNegotiatorHooks();
negotiator =
new HandshakeNegotiatorBuilder()
.WithNetwork(pool)
.Build(hooks);
}
public async Task CanReceiveDataUsingTasksToHostedEchoServerInTwoPieces()
{
string request = "GET /index.html HTTP/1.1\r\nHost: www.example.com\r\n\r\n";
byte[] input = Encoding.ASCII.GetBytes(request);
byte[] output = new byte[input.Length];
byte[] part1 = new byte[input.Length / 2];
byte[] part2 = new byte[input.Length - part1.Length];
using (CompletionThread worker = new CompletionThread())
{
SocketFactory factory = new SocketFactory(worker);
TcpSocket socket = factory.Tcp();
using (EchoServer server = new EchoServer(factory))
{
socket.Bind();
worker.Start();
server.Start();
await socket.Connect(server.Endpoint);
await socket.Send(input);
TcpSocketReceive received1 = await socket.Receive(part1);
TcpSocketReceive received2 = await socket.Receive(part2);
Array.Copy(part1, 0, output, 0, received1.Count);
Array.Copy(part2, 0, output, received1.Count, received2.Count);
Assert.That(input, Is.EqualTo(output));
}
}
}
