public void ReadAndWriteMultipleFragmentsThreaded(int maxReadLength, int maxReserveLength)
{
this.reader = new TcpReader(this.readerTcpClient.Client, maxReadLength);
this.writer = new TcpWriter(this.writerTcpClient.Client, maxReserveLength);
this.writerTcpClient.Client.SendBufferSize = 1;
var xdrReader = new XdrReader(this.reader);
var xdrWriter = new XdrWriter(this.writer);
byte[] value = TestXdr.GenerateByteTestData(17);
var task = Task.Run(
() =>
{
NetworkReadResult readResult = this.reader.BeginReading();
Assert.That(readResult.SocketError, Is.EqualTo(SocketError.Success));
Assert.That(xdrReader.ReadOpaque(), Is.EqualTo(value));
Assert.That(xdrReader.ReadInt(), Is.EqualTo(42));
this.reader.EndReading();
});
this.writer.BeginWriting();
xdrWriter.WriteVariableLengthOpaque(value);
xdrWriter.Write(42);
this.writer.EndWriting(null);
task.Wait();
}
public void Go()
{
using (var tcpClient = new TcpClient())
{
tcpClient.NoDelay = true;
tcpClient.Connect(_host, _port);
var stream = tcpClient.GetStream();
_cancel = new CancellationTokenSource();
_pipe = new Pipe <dynamic>();
_writer = new TcpWriter(stream, _cancel.Token, _pipe);
_reader = new TcpReader(stream, _cancel.Token, _pipe);
_ai = new NibblesAi();
_aiHandler = new NibblesAiHandler(_ai, _pipe.ReceiveQueue, _pipe.SendQueue, _cancel.Token);
var tasks = new List <Task>();
tasks.Add(Task.Factory.StartNew(() => _aiHandler.Go(), _cancel.Token, TaskCreationOptions.LongRunning,
TaskScheduler.Default));
tasks.Add(Task.Factory.StartNew(() => _writer.Start(), _cancel.Token,
TaskCreationOptions.LongRunning, TaskScheduler.Default));
tasks.Add(Task.Factory.StartNew(() => _reader.Start(), _cancel.Token,
TaskCreationOptions.LongRunning, TaskScheduler.Default));
Console.WriteLine("Hit enter to cancel");
Console.ReadLine();
Console.WriteLine("Cancelling...");
_cancel.Cancel();
try
{
Task.WaitAll(tasks.ToArray());
}
catch (AggregateException e)
{
Console.WriteLine("\nAggregateException thrown with the following inner exceptions:");
// Display information about each exception.
foreach (var v in e.InnerExceptions)
{
if (v is TaskCanceledException)
{
Console.WriteLine(" TaskCanceledException: Task {0}", ((TaskCanceledException)v).Task.Id);
}
else
{
Console.WriteLine(" Exception: {0}", v.GetType().Name);
}
}
Console.WriteLine();
}
finally
{
_cancel.Dispose();
}
}
}
public void TcpSend(string message)
{
if (Connected)
{
try {
TcpWriter.Write(message);
Log.Print($"TCP send [{message}] -> {GamePlayer.Nickname}");
} catch (Exception) {
Disconnect();
}
}
}
public void SetUp()
{
this.listener = new TcpListener(IPAddress.Loopback, 0);
this.listener.Start();
int port = ((IPEndPoint)this.listener.Server.LocalEndPoint).Port;
this.readerTcpClient = new TcpClient();
Task task = Task.Run(() => this.writerTcpClient = this.listener.AcceptTcpClient());
this.readerTcpClient.Connect(IPAddress.Loopback, port);
task.GetAwaiter().GetResult();
this.reader = new TcpReader(this.readerTcpClient.Client);
this.writer = new TcpWriter(this.writerTcpClient.Client);
this.listener.Stop();
}
/// <summary>
/// Execute a test run based on the aruments passed
/// from Main.
/// </summary>
/// <param name="args">An array of arguments</param>
public void Execute(string[] args)
{
this.commandLineOptions = new CommandLineOptions();
commandLineOptions.Parse(args);
if (commandLineOptions.OutFile != null)
{
this.writer = new StreamWriter(commandLineOptions.OutFile);
}
TcpWriter tcpWriter = null;
if (listener == TestListener.NULL && commandLineOptions.Port != -1)
{
tcpWriter = new TcpWriter(new IPEndPoint(IPAddress.Loopback, commandLineOptions.Port));
listener = new XmlTestListener(tcpWriter);
}
// Ensure we always dispose the socket correctly.
using (tcpWriter)
ExecuteWithListener(args, tcpWriter);
}
private void BuildMessage(object state)
{
LinkedList <byte[]> blocks;
try
{
TcpWriter tw = new TcpWriter(_maxBlock);
_sendingTicket.BuildRpcMessage(tw);
blocks = tw.Build();
}
catch (Exception ex)
{
Log.Debug("TCP message not builded (xid:{0}) reason: {1}", _sendingTicket.Xid, ex);
lock (_sync)
_handlers.Remove(_sendingTicket.Xid);
_sendingTicket.Except(ex);
OnSend();
return;
}
BeginReceive();
Log.Debug("Begin sending TCP message (xid:{0})", _sendingTicket.Xid);
_client.AsyncWrite(blocks, OnBlocksWrited);
}
void ExecuteWithListener(string[] args, TcpWriter tcpWriter)
{
if (!commandLineOptions.NoHeader)
{
WriteHeader(this.writer);
}
if (commandLineOptions.ShowHelp)
{
writer.Write(commandLineOptions.HelpText);
}
else if (commandLineOptions.Error)
{
writer.WriteLine(commandLineOptions.ErrorMessage);
writer.WriteLine(commandLineOptions.HelpText);
}
else
{
WriteRuntimeEnvironment(this.writer);
if (commandLineOptions.Wait && commandLineOptions.OutFile != null)
{
writer.WriteLine("Ignoring /wait option - only valid for Console");
}
#if SILVERLIGHT
IDictionary loadOptions = new System.Collections.Generic.Dictionary <string, string>();
#else
IDictionary loadOptions = new Hashtable();
#endif
//if (options.Load.Count > 0)
// loadOptions["LOAD"] = options.Load;
//IDictionary runOptions = new Hashtable();
//if (commandLineOptions.TestCount > 0)
// runOptions["RUN"] = commandLineOptions.Tests;
ITestFilter filter = commandLineOptions.TestCount > 0
? new SimpleNameFilter(commandLineOptions.Tests)
: TestFilter.Empty;
try
{
if (TestRunner.LoadFileMethod != null)
{
foreach (string name in commandLineOptions.Parameters)
{
assemblies.Add(TestRunner.LoadFileMethod.Invoke(null, new[] { Path.GetFullPath(name) }));
}
}
if (assemblies.Count == 0)
{
assemblies.Add(Assembly.GetEntryAssembly());
}
// TODO: For now, ignore all but first assembly
Assembly assembly = assemblies[0] as Assembly;
if (!runner.Load(assembly, loadOptions))
{
AssemblyName assemblyName = AssemblyHelper.GetAssemblyName(assembly);
Console.WriteLine("No tests found in assembly {0}", assemblyName.Name);
return;
}
if (commandLineOptions.Explore)
{
ExploreTests();
}
else
{
if (commandLineOptions.Include != null && commandLineOptions.Include != string.Empty)
{
TestFilter includeFilter = new SimpleCategoryExpression(commandLineOptions.Include).Filter;
if (filter.IsEmpty)
{
filter = includeFilter;
}
else
{
filter = new AndFilter(filter, includeFilter);
}
}
if (commandLineOptions.Exclude != null && commandLineOptions.Exclude != string.Empty)
{
TestFilter excludeFilter = new NotFilter(new SimpleCategoryExpression(commandLineOptions.Exclude).Filter);
if (filter.IsEmpty)
{
filter = excludeFilter;
}
else if (filter is AndFilter)
{
((AndFilter)filter).Add(excludeFilter);
}
else
{
filter = new AndFilter(filter, excludeFilter);
}
}
if (MainLoop == null)
{
RunTests(filter);
}
else
{
MainLoop.InitializeToolkit();
System.Threading.ThreadPool.QueueUserWorkItem(d => {
try {
RunTests(filter);
} catch (Exception ex) {
Console.WriteLine("Unexpected error while running the tests: {0}", ex);
} finally {
Shutdown();
}
});
MainLoop.RunMainLoop();
}
}
}
catch (FileNotFoundException ex)
{
writer.WriteLine(ex.Message);
}
catch (Exception ex)
{
writer.WriteLine(ex.ToString());
ExitCode = 1;
}
finally
{
if (commandLineOptions.OutFile == null)
{
if (commandLineOptions.Wait)
{
Console.WriteLine("Press Enter key to continue . . .");
Console.ReadLine();
}
}
else
{
writer.Close();
}
}
}
}
public static int Main(string[] args)
{
var arguments = new Stack <string> ();
string host = null;
int port = 0;
bool closeAfterTestRun;
bool failed;
for (var i = args.Length - 1; i >= 0; i--)
{
arguments.Push(args[i]);
}
// First argument is the connection string if we're driven by harness.exe, otherwise we're driven by UITests
if (arguments.Count > 0 && arguments.Peek().StartsWith("tcp:", StringComparison.Ordinal))
{
var parts = arguments.Pop().Split(':');
if (parts.Length != 3)
{
throw new Exception();
}
host = parts [1];
port = Int32.Parse(parts [2]);
closeAfterTestRun = true;
}
else
{
closeAfterTestRun = false;
}
// Make sure the TLS subsystem including the DependencyInjector is initialized.
// This would normally happen on system startup in
// `xamarin-macios/src/ObjcRuntime/Runtime.cs`.
MonoTlsProviderFactory.Initialize();
// some tests assert having a SynchronizationContext for MONOTOUCH, provide a default one
SynchronizationContext.SetSynchronizationContext(new SynchronizationContext());
#if XUNIT_RUNNER
var writer = new TcpWriter(host, port);
var assemblyFileName = arguments.Pop();
var filters = XunitArgumentsParser.ParseArgumentsToFilter(arguments);
var configuration = new TestAssemblyConfiguration()
{
ShadowCopy = false
};
var discoveryOptions = TestFrameworkOptions.ForDiscovery(configuration);
var discoverySink = new TestDiscoverySink();
var diagnosticSink = new DiagnosticTextWriterMessageSink(writer);
var testOptions = TestFrameworkOptions.ForExecution(configuration);
var testSink = new TestMessageSink();
var controller = new XunitFrontController(AppDomainSupport.Denied, assemblyFileName, configFileName: null, shadowCopy: false, diagnosticMessageSink: diagnosticSink);
Interop.mono_sdks_ui_set_test_summary_message($"Running {assemblyFileName}...");
writer.WriteLine($"Discovering tests for {assemblyFileName}");
controller.Find(includeSourceInformation: false, discoverySink, discoveryOptions);
discoverySink.Finished.WaitOne();
var testCasesToRun = discoverySink.TestCases.Where(filters.Filter).ToList();
writer.WriteLine($"Discovery finished.");
var summarySink = new DelegatingExecutionSummarySink(testSink, () => false, (completed, summary) => { writer.WriteLine($"Tests run: {summary.Total}, Errors: 0, Failures: {summary.Failed}, Skipped: {summary.Skipped}{Environment.NewLine}Time: {TimeSpan.FromSeconds ((double)summary.Time).TotalSeconds}s"); });
var resultsXmlAssembly = new XElement("assembly");
var resultsSink = new DelegatingXmlCreationSink(summarySink, resultsXmlAssembly);
testSink.Execution.TestPassedEvent += args => { writer.WriteLine($"[PASS] {args.Message.Test.DisplayName}"); Interop.mono_sdks_ui_increment_testcase_result(0); };
testSink.Execution.TestSkippedEvent += args => { writer.WriteLine($"[SKIP] {args.Message.Test.DisplayName}"); Interop.mono_sdks_ui_increment_testcase_result(1); };
testSink.Execution.TestFailedEvent += args => { writer.WriteLine($"[FAIL] {args.Message.Test.DisplayName}{Environment.NewLine}{ExceptionUtility.CombineMessages (args.Message)}{Environment.NewLine}{ExceptionUtility.CombineStackTraces (args.Message)}"); Interop.mono_sdks_ui_increment_testcase_result(2); };
testSink.Execution.TestAssemblyStartingEvent += args => { writer.WriteLine($"Running tests for {args.Message.TestAssembly.Assembly}"); };
testSink.Execution.TestAssemblyFinishedEvent += args => { writer.WriteLine($"Finished {args.Message.TestAssembly.Assembly}{Environment.NewLine}"); };
controller.RunTests(testCasesToRun, resultsSink, testOptions);
resultsSink.Finished.WaitOne();
var resultsXml = new XElement("assemblies");
resultsXml.Add(resultsXmlAssembly);
resultsXml.Save(resultsXmlPath);
if (host != null)
{
writer.WriteLine($"STARTRESULTXML");
resultsXml.Save(((TcpWriter)writer).RawStream);
writer.WriteLine();
writer.WriteLine($"ENDRESULTXML");
}
failed = resultsSink.ExecutionSummary.Failed > 0 || resultsSink.ExecutionSummary.Errors > 0;
#else
MonoSdksTextUI runner;
TextWriter writer = null;
string resultsXmlPath = Path.GetTempFileName();
string assemblyFileName = arguments.Peek();
if (File.Exists("nunit-excludes.txt"))
{
var excludes = File.ReadAllLines("nunit-excludes.txt");
arguments.Push("-exclude:" + String.Join(",", excludes));
}
arguments.Push("-labels");
arguments.Push("-format:xunit");
arguments.Push($"-result:{resultsXmlPath}");
if (host != null)
{
Console.WriteLine($"Connecting to harness at {host}:{port}.");
writer = new TcpWriter(host, port);
}
else
{
writer = ConsoleWriter.Out;
}
Interop.mono_sdks_ui_set_test_summary_message($"Running {assemblyFileName}...");
runner = new MonoSdksTextUI(writer);
runner.Execute(arguments.ToArray());
if (host != null)
{
writer.WriteLine($"STARTRESULTXML");
using (var resultsXmlStream = File.OpenRead(resultsXmlPath)) resultsXmlStream.CopyTo(((TcpWriter)writer).RawStream);
writer.WriteLine();
writer.WriteLine($"ENDRESULTXML");
}
failed = runner.Failure;
#endif
Interop.mono_sdks_ui_set_test_summary_message($"Summary: {(failed ? "Failed" : "Succeeded")} for {assemblyFileName}.");
if (!closeAfterTestRun)
{
Thread.Sleep(Int32.MaxValue);
}
return(failed ? 1 : 0);
}
/// <summary>
/// Create a rendezvous endpoint from a <see cref="TcpWriter{T}"/>.
/// </summary>
/// <typeparam name="T">Type of data stream.</typeparam>
/// <param name="writer"><see cref="TcpWriter{T}"/> from which to create endpoint.</param>
/// <param name="address">Address with which to create endpoint.</param>
/// <param name="streamName">The name of the rendezvous stream.</param>
/// <returns>Rendezvous endpoint.</returns>
public static Rendezvous.Endpoint ToRendezvousEndpoint <T>(this TcpWriter <T> writer, string address, string streamName)
{
// Each TcpWriter is an endpoint emitting a single stream
return(new Rendezvous.TcpSourceEndpoint(address, writer.Port, new[] { new Rendezvous.Stream(streamName, typeof(T)) }));
}
public static int Main(string[] args)
{
string host = null;
int port = 0;
// First argument is the connection string
if (args [0].StartsWith("tcp:"))
{
var parts = args [0].Split(':');
if (parts.Length != 3)
{
throw new Exception();
}
host = parts [1];
port = Int32.Parse(parts [2]);
args = args.Skip(1).ToArray();
}
// Make sure the TLS subsystem including the DependencyInjector is initialized.
// This would normally happen on system startup in
// `xamarin-macios/src/ObjcRuntime/Runtime.cs`.
MonoTlsProviderFactory.Initialize();
#if XUNIT_RUNNER
var writer = new TcpWriter(host, port);
var assemblyFileName = args[0];
var configuration = new TestAssemblyConfiguration()
{
ShadowCopy = false
};
var discoveryOptions = TestFrameworkOptions.ForDiscovery(configuration);
var discoverySink = new TestDiscoverySink();
var diagnosticSink = new DiagnosticTextWriterMessageSink(writer);
var testOptions = TestFrameworkOptions.ForExecution(configuration);
var testSink = new TestMessageSink();
var controller = new XunitFrontController(AppDomainSupport.Denied, assemblyFileName, configFileName: null, shadowCopy: false, diagnosticMessageSink: diagnosticSink);
writer.WriteLine($"Discovering tests for {assemblyFileName}");
controller.Find(includeSourceInformation: false, discoverySink, discoveryOptions);
discoverySink.Finished.WaitOne();
writer.WriteLine($"Discovery finished.");
var summarySink = new DelegatingExecutionSummarySink(testSink, () => false, (completed, summary) => { writer.WriteLine($"Tests run: {summary.Total}, Errors: 0, Failures: {summary.Failed}, Skipped: {summary.Skipped}{Environment.NewLine}Time: {TimeSpan.FromSeconds ((double)summary.Time).TotalSeconds}s"); });
var resultsXmlAssembly = new XElement("assembly");
var resultsSink = new DelegatingXmlCreationSink(summarySink, resultsXmlAssembly);
testSink.Execution.TestPassedEvent += args => { writer.WriteLine($"[PASS] {args.Message.Test.DisplayName}"); Interop.mono_sdks_ui_increment_testcase_result(0); };
testSink.Execution.TestSkippedEvent += args => { writer.WriteLine($"[SKIP] {args.Message.Test.DisplayName}"); Interop.mono_sdks_ui_increment_testcase_result(1); };
testSink.Execution.TestFailedEvent += args => { writer.WriteLine($"[FAIL] {args.Message.Test.DisplayName}{Environment.NewLine}{ExceptionUtility.CombineMessages (args.Message)}{Environment.NewLine}{ExceptionUtility.CombineStackTraces (args.Message)}"); Interop.mono_sdks_ui_increment_testcase_result(2); };
testSink.Execution.TestAssemblyStartingEvent += args => { writer.WriteLine($"Running tests for {args.Message.TestAssembly.Assembly}"); };
testSink.Execution.TestAssemblyFinishedEvent += args => { writer.WriteLine($"Finished {args.Message.TestAssembly.Assembly}{Environment.NewLine}"); };
controller.RunTests(discoverySink.TestCases, resultsSink, testOptions);
resultsSink.Finished.WaitOne();
writer.WriteLine($"STARTRESULTXML");
var resultsXml = new XElement("assemblies");
resultsXml.Add(resultsXmlAssembly);
resultsXml.Save(writer.RawStream);
writer.WriteLine();
writer.WriteLine($"ENDRESULTXML");
var failed = resultsSink.ExecutionSummary.Failed > 0 || resultsSink.ExecutionSummary.Errors > 0;
return(failed ? 1 : 0);
#else
MonoSdksTextUI runner;
TcpWriter writer = null;
string resultsXml = null;
if (host != null)
{
Console.WriteLine($"Connecting to harness at {host}:{port}.");
resultsXml = Path.GetTempFileName();
args = args.Concat(new string[] { "-format:xunit", $"-result:{resultsXml}" }).ToArray();
writer = new TcpWriter(host, port);
runner = new MonoSdksTextUI(writer);
}
else
{
runner = new MonoSdksTextUI();
}
runner.Execute(args);
if (resultsXml != null)
{
writer.WriteLine($"STARTRESULTXML");
using (var resultsXmlStream = File.OpenRead(resultsXml)) resultsXmlStream.CopyTo(writer.RawStream);
writer.WriteLine();
writer.WriteLine($"ENDRESULTXML");
}
return(runner.Failure ? 1 : 0);
#endif
}
