public void Test10()
{
var port = NetworkHelpers.FindFreePort();
// Same as Test9, but now we shutdown the socket for sending.
_listener = CreateAndStartListener("http://127.0.0.1:" + port + "/test10/");
MyNetworkStream ns = CreateNS(port);
Send(ns, "POST /test10/ HTTP/1.0\r\nHost: 127.0.0.1\r\nTransfer-Encoding: chunked\r\n\r\n3\r\n123\r\n0\r\n\r\n");
ns.GetSocket().Shutdown(SocketShutdown.Send);
bool timeout;
string response = ReceiveWithTimeout(ns, 512, 1000, out timeout);
ns.Close();
Assert.IsFalse(timeout);
Assert.IsTrue(response.StartsWith("HTTP/1.1 411"));
}
public ActivationServer()
{
TcpPort = NetworkHelpers.FindFreePort();
HttpPort = NetworkHelpers.FindFreePort();
tcp = new TcpChannel(TcpPort);
http = new HttpChannel(HttpPort);
ChannelServices.RegisterChannel(tcp);
ChannelServices.RegisterChannel(http);
RemotingConfiguration.RegisterActivatedServiceType(typeof(CaObject1));
RemotingConfiguration.RegisterActivatedServiceType(typeof(CaObject2));
RemotingConfiguration.RegisterWellKnownServiceType(typeof(WkObjectSinglecall1), "wkoSingleCall1", WellKnownObjectMode.SingleCall);
RemotingConfiguration.RegisterWellKnownServiceType(typeof(WkObjectSingleton1), "wkoSingleton1", WellKnownObjectMode.Singleton);
RemotingConfiguration.RegisterWellKnownServiceType(typeof(WkObjectSinglecall2), "wkoSingleCall2", WellKnownObjectMode.SingleCall);
RemotingConfiguration.RegisterWellKnownServiceType(typeof(WkObjectSingleton2), "wkoSingleton2", WellKnownObjectMode.Singleton);
}
public void Test_EmptyLineAtStart()
{
var port = NetworkHelpers.FindFreePort();
var listener = HttpListener2Test.CreateAndStartListener("http://127.0.0.1:" + port + "/");
var ns = HttpListener2Test.CreateNS(port);
HttpListener2Test.Send(ns, "\r\nGET / HTTP/1.1\r\nHost: 127.0.0.1\r\n\r\n");
bool timedout;
HttpListener2Test.GetContextWithTimeout(listener, 1000, out timedout);
Assert.IsFalse(timedout, "timed out");
ns.Close();
listener.Close();
}
public void Close_Disposed()
{
IPEndPoint ep = NetworkHelpers.LocalEphemeralEndPoint();
string url = "http://" + ep.ToString() + "/test/";
using (SocketResponder responder = new SocketResponder(ep, s => FullResponseHandler(s))) {
HttpWebRequest req = (HttpWebRequest)WebRequest.Create(url);
req.Method = "GET";
req.Timeout = 2000;
req.ReadWriteTimeout = 2000;
req.KeepAlive = false;
HttpWebResponse resp = (HttpWebResponse)req.GetResponse();
((IDisposable)resp).Dispose();
resp.Close();
}
}
public void EmptyWrite()
{
HttpListener listener = NetworkHelpers.CreateAndStartHttpListener("http://localhost:", out var port, "/", out var prefix);
Task.Run(() => {
var context = listener.GetContext();
var s = context.Response.OutputStream;
s.Write(new byte[10], 0, 0);
return;
});
var request = (HttpWebRequest)WebRequest.Create(prefix);
var rsp = request.GetResponseAsync();
Assert.IsFalse(rsp.Wait(1000), "Don't send on empty write");
}
public void Constructor6()
{
Socket s;
IPEndPoint localEP;
using (MyUdpClient client = new MyUdpClient("127.0.0.1", NetworkHelpers.FindFreePort()))
{
s = client.Client;
Assert.IsNotNull(s, "#A:Client");
Assert.AreEqual(AddressFamily.InterNetwork, s.AddressFamily, "#A:Client:AddressFamily");
Assert.IsTrue(s.Connected, "#A:Client:Connected");
Assert.IsTrue(s.IsBound, "#A:Client:IsBound");
Assert.AreEqual(ProtocolType.Udp, s.ProtocolType, "#A:Client:ProtocolType");
Assert.AreEqual(SocketType.Dgram, s.SocketType, "#A:Client:SocketType");
Assert.IsTrue(client.Active, "#A:Active");
Assert.IsFalse(client.DontFragment, "#A:DontFragment");
Assert.IsFalse(client.EnableBroadcast, "#A:EnableBroadcast");
//Assert.IsFalse (client.ExclusiveAddressUse, "#A:ExclusiveAddressUse");
//Assert.IsFalse (client.MulticastLoopback, "#A:MulticastLoopback");
//Assert.AreEqual (32, client.Ttl, "#A:Ttl");
localEP = s.LocalEndPoint as IPEndPoint;
Assert.IsNotNull(localEP, "#A:Client:LocalEndpoint");
Assert.AreEqual(IPAddress.Loopback, localEP.Address, "#A:Client:LocalEndPoint/Address");
Assert.AreEqual(AddressFamily.InterNetwork, localEP.AddressFamily, "#A:Client:LocalEndPoint/AddressFamily");
}
using (MyUdpClient client = new MyUdpClient("127.0.0.1", IPEndPoint.MaxPort))
{
s = client.Client;
Assert.IsNotNull(s, "#B:Client");
Assert.AreEqual(AddressFamily.InterNetwork, s.AddressFamily, "#B:Client:AddressFamily");
Assert.IsTrue(s.Connected, "#B:Client:Connected");
Assert.IsTrue(s.IsBound, "#B:Client:IsBound");
Assert.AreEqual(ProtocolType.Udp, s.ProtocolType, "#B:Client:ProtocolType");
Assert.AreEqual(SocketType.Dgram, s.SocketType, "#B:Client:SocketType");
Assert.IsTrue(client.Active, "#B:Active");
Assert.IsFalse(client.DontFragment, "#B:DontFragment");
Assert.IsFalse(client.EnableBroadcast, "#B:EnableBroadcast");
//Assert.IsFalse (client.ExclusiveAddressUse, "#B:ExclusiveAddressUse");
//Assert.IsFalse (client.MulticastLoopback, "#B:MulticastLoopback");
//Assert.AreEqual (32, client.Ttl, "#B:Ttl");
localEP = s.LocalEndPoint as IPEndPoint;
Assert.IsNotNull(localEP, "#B:Client:LocalEndpoint");
Assert.AreEqual(IPAddress.Loopback, localEP.Address, "#B:Client:LocalEndPoint/Address");
Assert.AreEqual(AddressFamily.InterNetwork, localEP.AddressFamily, "#B:Client:LocalEndPoint/AddressFamily");
}
}
public void Bug32886_Test() // test in one of the comment
{
// Init service
int port = NetworkHelpers.FindFreePort();
ServiceHost serviceHost = new ServiceHost(typeof(TempConvertSoapImpl), new Uri("http://localhost:" + port + "/TempConvertSoap"));
serviceHost.AddServiceEndpoint(typeof(TempConvertSoap), new BasicHttpBinding(), string.Empty);
// Enable metadata exchange (WSDL publishing)
var mexBehavior = new ServiceMetadataBehavior();
mexBehavior.HttpGetEnabled = true;
serviceHost.Description.Behaviors.Add(mexBehavior);
serviceHost.AddServiceEndpoint(typeof(IMetadataExchange), MetadataExchangeBindings.CreateMexHttpBinding(), "mex");
serviceHost.Open();
try {
// client
var binding = new BasicHttpBinding();
var remoteAddress = new EndpointAddress("http://localhost:" + port + "/TempConvertSoap");
var client = new TempConvertSoapClient(binding, remoteAddress);
var wait = new ManualResetEvent(false);
Exception error = null;
string result = null;
client.CelsiusToFahrenheitCompleted += delegate(object o, CelsiusToFahrenheitCompletedEventArgs e) {
try {
error = e.Error;
result = e.Error == null ? e.Result : null;
} finally {
wait.Set();
}
};
client.CelsiusToFahrenheitAsync("24.5");
Assert.IsTrue(wait.WaitOne(TimeSpan.FromSeconds(20)), "timeout");
Assert.IsNull(error, "#1, inner exception: {0}", error);
Assert.AreEqual("76.1", result, "#2");
} finally {
serviceHost.Close();
}
}
public void SpecificActionTest()
{
//EndpointDispatcher d = new EndpointDispatcher(
var ep = NetworkHelpers.LocalEphemeralEndPoint().ToString();
ServiceHost h = new ServiceHost(typeof(SpecificAction), new Uri("http://" + ep));
h.AddServiceEndpoint(typeof(Action1Interface), new BasicHttpBinding(), "address");
h.Open();
ChannelDispatcher d = h.ChannelDispatchers [0] as ChannelDispatcher;
EndpointDispatcher ed = d.Endpoints [0] as EndpointDispatcher;
ActionMessageFilter actionFilter = ed.ContractFilter as ActionMessageFilter;
Assert.IsNotNull(actionFilter, "#1");
Assert.IsTrue(actionFilter.Actions.Count == 1, "#2");
h.Close();
}
public void TestReceiveCancelation()
{
var uri = "http://localhost:" + NetworkHelpers.FindFreePort() + "/";
HttpListener listener = new HttpListener();
listener.Prefixes.Add(uri);
listener.Start();
try {
for (var i = 0; i < 10; i++)
{
var request = WebRequest.CreateHttp(uri);
request.Method = "GET";
var tokenSource = new CancellationTokenSource();
tokenSource.Token.Register(() => request.Abort());
var responseTask = request.GetResponseAsync();
var context = listener.GetContext();
byte[] outBuffer = new byte[8 * 1024];
context.Response.OutputStream.WriteAsync(outBuffer, 0, outBuffer.Length);
Assert.IsTrue(responseTask.Wait(1000), "Timeout #1");
WebResponse response = responseTask.Result;
var stream = response.GetResponseStream();
byte[] buffer = new byte[8 * 1024];
var taskRead = stream.ReadAsync(buffer, 0, buffer.Length, tokenSource.Token);
tokenSource.Cancel();
Assert.IsTrue(taskRead.Wait(1000), "Timeout #2");
var byteRead = taskRead.Result;
}
} catch (AggregateException ex) {
var webEx = ex.InnerException as WebException;
Assert.IsNotNull(webEx, "Inner exception is not a WebException");
Assert.AreEqual(webEx.Status, WebExceptionStatus.RequestCanceled);
}
listener.Close();
}
public void AddServiceEndpointOnlyMex()
{
var ep = NetworkHelpers.LocalEphemeralEndPoint().ToString();
var host = new ServiceHost(typeof(AllActions),
new Uri("http://" + ep));
host.Description.Behaviors.Add(new ServiceMetadataBehavior());
host.AddServiceEndpoint("IMetadataExchange",
new BasicHttpBinding(), "/wsdl");
host.Open();
try {
// to make sure that throwing IOE from here does not count.
host.Close();
} catch {
}
Assert.Fail("should not open");
}
public void ServiceMetadataExtension1()
{
int port = NetworkHelpers.FindFreePort();
using (ServiceHost host = new ServiceHost(typeof(MyService), CreateUri("http://localhost:" + port))) {
host.AddServiceEndpoint(typeof(IMyContract), new BasicHttpBinding(), "");
host.Description.Behaviors.Find <ServiceDebugBehavior> ().HttpHelpPageUrl = new Uri("http://localhost:" + port + "/help");
try {
host.Open();
Assert.IsNotNull(host.Extensions.Find <ServiceMetadataExtension> (), "ServiceMetadataExtension #1");
Assert.AreEqual(1, host.Extensions.FindAll <ServiceMetadataExtension> ().Count, "ServiceMetadataExtension #2");
} finally {
host.Close();
}
}
}
public void SetObjectUriForMarshal()
{
var port = NetworkHelpers.FindFreePort();
TcpChannel chn = new TcpChannel(port);
ChannelServices.RegisterChannel(chn);
try {
MarshalObject objRem = NewMarshalObject();
RemotingServices.SetObjectUriForMarshal(objRem, objRem.Uri);
RemotingServices.Marshal(objRem);
objRem = (MarshalObject)Activator.GetObject(typeof(MarshalObject), $"tcp://localhost:{port}/" + objRem.Uri);
Assert.IsNotNull(objRem, "#A14");
} finally {
ChannelServices.UnregisterChannel(chn);
}
}
public static void threadpool_io()
{
// Start a threadpool task that blocks on I/O.
// Regression test for #42625
const int nbytes = 16;
var bsOut = new byte[nbytes];
for (int i = 0; i < nbytes; i++)
{
bsOut[i] = (byte)i;
}
var endPoint = NetworkHelpers.LocalEphemeralEndPoint();
var l = new TcpListener(endPoint);
l.Start();
Task <byte[]> t = Task.Run(async() => {
var c = new TcpClient();
await c.ConnectAsync(endPoint.Address, endPoint.Port);
var streamIn = c.GetStream();
var bs = new byte[nbytes];
int nread = 0;
int nremain = nbytes;
while (nread < nbytes)
{
int r = await streamIn.ReadAsync(bs, nread, nremain);
nread += r;
nremain -= r;
}
streamIn.Close();
return(bs);
});
var s = l.AcceptTcpClient();
l.Stop();
// write bytes in two groups so that the task blocks on the ReadAsync
var streamOut = s.GetStream();
var nbytesFirst = nbytes / 2;
var nbytesRest = nbytes - nbytesFirst;
streamOut.Write(bsOut, 0, nbytesFirst);
threadpool_bp();
streamOut.Write(bsOut, nbytesFirst, nbytesRest);
streamOut.Close();
var bsIn = t.Result;
}
public void GetServeurTypeForUri()
{
var port = NetworkHelpers.FindFreePort();
TcpChannel chn = new TcpChannel(port);
Type type = typeof(MarshalObject);
ChannelServices.RegisterChannel(chn);
try {
MarshalObject objRem = NewMarshalObject();
RemotingServices.SetObjectUriForMarshal(objRem, objRem.Uri);
RemotingServices.Marshal(objRem);
Type typeRem = RemotingServices.GetServerTypeForUri(RemotingServices.GetObjectUri(objRem));
Assert.AreEqual(type, typeRem, "#A15");
} finally {
ChannelServices.UnregisterChannel(chn);
}
}
public void EndAcceptTcpClient()
{
var port = NetworkHelpers.FindFreePort();
var listenerSocket = new TcpListener(IPAddress.Any, port);
listenerSocket.Start();
listenerSocket.BeginAcceptTcpClient(new AsyncCallback(l => {
listenerSocket.EndAcceptTcpClient(l);
}), null);
using (var outClient = new TcpClient("localhost", port)) {
using (var stream = outClient.GetStream()) {
stream.WriteByte(3);
}
}
}
public void TestTcpChannel()
{
var port = NetworkHelpers.FindFreePort();
IDictionary props = new Hashtable();
props ["name"] = Guid.NewGuid().ToString("N");
props ["port"] = port;
TcpChannel chan = new TcpChannel(props, null, null);
ChannelServices.RegisterChannel(chan);
try {
Register <Server <object> > ("gentcptest.rem");
RunTests(Connect <Server <object> > ($"tcp://localhost:{port}/gentcptest.rem"));
} finally {
ChannelServices.UnregisterChannel(chan);
}
}
public void AbortWhileBegin()
{
HttpListener listener = new HttpListener();
listener.Prefixes.Add("http://127.0.0.1:" + NetworkHelpers.FindFreePort() + "/abortwhilebegin/");
listener.Start();
CallMe cm = new CallMe();
listener.BeginGetContext(cm.Callback, listener);
listener.Abort();
if (false == cm.Event.WaitOne(3000, false))
{
Assert.Fail("This should not time out.");
}
Assert.IsNotNull(cm.Error);
Assert.AreEqual(typeof(ObjectDisposedException), cm.Error.GetType(), "Exception type");
cm.Dispose();
}
public void Main()
{
var port = NetworkHelpers.FindFreePort();
Hashtable props = new Hashtable();
props["port"] = port;
props["bindTo"] = "127.0.0.1";
channel = new HttpChannel(props, null, null);
ChannelServices.RegisterChannel(channel);
RemotingConfiguration.RegisterWellKnownServiceType
(typeof(Bug321420), "Server.soap", WellKnownObjectMode.Singleton);
Bug321420 s = (Bug321420)Activator.GetObject(typeof
(Bug321420), $"http://127.0.0.1:{port}/Server.soap");
// this works: s.Method ("a", "b");
s.Method("a", "a");
}
public void Test17()
{
var port = NetworkHelpers.FindFreePort();
_listener = CreateAndStartListener("http://127.0.0.1:" + port + "/test17/");
NetworkStream ns = CreateNS(port);
Send(ns, "RANDOM /test17/ HTTP/1.1\r\nHost: 127.0.0.1\r\nContent-Length: 3\r\n\r\n123");
HttpListenerContext ctx = _listener.GetContext();
Send(ctx.Response.OutputStream, "%%%OK%%%");
ctx.Response.Close();
string response = Receive(ns, 1024);
ns.Close();
Assert.IsTrue(response.StartsWith("HTTP/1.1 200"));
Assert.IsTrue(response.Contains("Transfer-Encoding: chunked"));
}
public static NetInfoPrintable Create(NetInfo netInfo)
{
var ipAndNetmask = netInfo.IP.ToString() + '/' + NetworkHelpers.NetmaskBits(netInfo.Netmask);
var sb = new StringBuilder();
foreach (var ip in netInfo.DNS)
{
sb.Append(ip.ToString());
sb.Append(' ');
}
return(new NetInfoPrintable {
IPandNetmask = ipAndNetmask,
Gateway = netInfo.Gateway.ToString(),
DNS = sb.ToString()
});
}
public async Task SmokeTest()
{
var message = new SongTransferMessage
{
Data = new byte[] { 0, 1, 0, 1 },
TransferId = Guid.NewGuid()
};
byte[] packedMessage = await NetworkHelpers.PackFileTransferMessageAsync(message);
using (var ms = new MemoryStream(packedMessage))
{
SongTransferMessage unpackedMessage = await ms.ReadNextFileTransferMessageAsync();
Assert.Equal(message.Data, unpackedMessage.Data);
Assert.Equal(message.TransferId, unpackedMessage.TransferId);
}
}
[Test] // TcpChannel (IDictionary, IClientChannelSinkProvider, IServerChannelSinkProvider)
public void Constructor3()
{
const string SERVICE_URI = "MarshalSvc";
string [] urls;
ChannelDataStore ds;
TcpChannel chn;
MarshalObject marshal = new MarshalObject();
var port = NetworkHelpers.FindFreePort();
IDictionary props = new Hashtable();
props ["name"] = "marshal channel";
props ["port"] = port;
props ["bindTo"] = IPAddress.Loopback.ToString();
chn = new TcpChannel(props, null, null);
ChannelServices.RegisterChannel(chn);
Assert.AreEqual("marshal channel", chn.ChannelName, "#A1");
urls = chn.GetUrlsForUri(SERVICE_URI);
Assert.IsNotNull(urls, "#A2");
Assert.AreEqual(1, urls.Length, "#A3");
Assert.AreEqual($"tcp://{IPAddress.Loopback.ToString ()}:{port}/{SERVICE_URI}", urls [0], "#A6");
ds = chn.ChannelData as ChannelDataStore;
Assert.IsNotNull(ds, "#A4");
Assert.AreEqual(1, ds.ChannelUris.Length, "#A5");
Assert.AreEqual($"tcp://{IPAddress.Loopback.ToString ()}:{port}", ds.ChannelUris [0], "#A6");
ChannelServices.UnregisterChannel(chn);
chn = new TcpChannel((IDictionary)null, null, null);
ChannelServices.RegisterChannel(chn);
Assert.AreEqual("tcp", chn.ChannelName, "#B1");
urls = chn.GetUrlsForUri(SERVICE_URI);
Assert.IsNull(urls, "#B1");
ds = chn.ChannelData as ChannelDataStore;
Assert.IsNull(ds, "#B2");
ChannelServices.UnregisterChannel(chn);
}
/// <summary>
/// Reads the chunk from a byte array.
/// </summary>
/// <param name="buffer">The byte array.</param>
/// <param name="offset">The offset at which to start reading the chunk.</param>
/// <param name="length">The number of bytes that make up the chunk..</param>
/// <returns>The number of bytes read.</returns>
protected override int FromBuffer(byte[] buffer, int offset, int length)
{
int start = offset;
this.CumulativeTSNAck = NetworkHelpers.ToUInt32(buffer, offset);
offset += 4;
this.AdvertisedReceiverWindowCredit = NetworkHelpers.ToUInt32(buffer, offset);
offset += 4;
int numberOfGapAckBlocks = (int)NetworkHelpers.ToUInt16(buffer, offset);
offset += 2;
int numberOfDuplicateTSNs = (int)NetworkHelpers.ToUInt16(buffer, offset);
offset += 2;
for (int i = 0; i < numberOfGapAckBlocks; i++)
{
if (this.GapAckBlocks == null)
{
this.GapAckBlocks = new List <GapAckBlock>(numberOfGapAckBlocks);
}
GapAckBlock block = new GapAckBlock();
block.GapAckBlockStart = NetworkHelpers.ToUInt16(buffer, offset);
offset += 2;
block.GapAckBlockEnd = NetworkHelpers.ToUInt16(buffer, offset);
offset += 2;
this.AddGapAckBlock(block);
}
for (int i = 0; i < numberOfDuplicateTSNs; i++)
{
if (this.DuplicateTSNs == null)
{
this.DuplicateTSNs = new List <uint>(numberOfDuplicateTSNs);
}
this.DuplicateTSNs.Add(NetworkHelpers.ToUInt32(buffer, offset));
offset += 4;
}
return(offset - start);
}
// Validating duplicate listen URI causes this regression.
// Since it is niche, I rather fixed ServiceHostBase to introduce validation.
// It is probably because this code doesn't use ServiceEndpoint to build IChannelListener i.e. built without Binding.
// We can add an extra field to ChannelDispatcher to indicate that it is from ServiceEndpoint (i.e. with Binding),
// but it makes little sense especially for checking duplicate listen URIs. Duplicate listen URIs should be rejected anyways.
public void EndpointDispatcherAddTest8()
{
var uri = new Uri("http://localhost:" + NetworkHelpers.FindFreePort());
ServiceHost h = new ServiceHost(typeof(TestContract), uri);
var listener = new MyChannelListener <IReplyChannel> (uri);
MyChannelDispatcher d = new MyChannelDispatcher(listener);
var ed = new EndpointDispatcher(new EndpointAddress(uri), "", "");
d.Endpoints.Add(ed);
ed.DispatchRuntime.Type = typeof(TestContract);
d.MessageVersion = MessageVersion.Default;
// add service endpoint to open the host (unlike all tests above).
h.AddServiceEndpoint(typeof(TestContract),
new BasicHttpBinding(), uri.ToString());
h.ChannelDispatchers.Clear();
h.ChannelDispatchers.Add(d);
Assert.AreEqual(h, d.Host, "#0");
try {
h.Open(TimeSpan.FromSeconds(10));
Assert.AreEqual(3, h.ChannelDispatchers.Count, "#0"); // TestContract, d, mex
Assert.IsTrue(listener.BeginAcceptChannelTried, "#1"); // while it throws NIE ...
Assert.IsFalse(listener.WaitForChannelTried, "#2");
Assert.IsNotNull(ed.DispatchRuntime, "#3");
Assert.IsNull(ed.DispatchRuntime.InstanceProvider, "#4");
Assert.IsNotNull(ed.DispatchRuntime.InstanceContextProvider, "#5"); // it was set after ServiceHost.Open().
Assert.IsNull(ed.DispatchRuntime.SingletonInstanceContext, "#6");
/*
* var l = new HttpListener ();
* l.Prefixes.Add (uri.ToString ());
* l.Start ();
* l.Stop ();
*/
} finally {
h.Close(TimeSpan.FromSeconds(10));
h.Abort();
}
}
public static void Main()
{
var networkHerlpers = new NetworkHelpers();
networkHerlpers.SetupAndConnectNetwork(true);
Console.WriteLine("Waiting for network up and IP address...");
NetworkHelpers.IpAddressAvailable.WaitOne();
//Console.WriteLine("Waiting for valid Date & Time...");
//NetworkHelpers.DateTimeAvailable.WaitOne();
// Create a listener.
HttpListener listener = new HttpListener("http");
listener.Start();
Console.WriteLine("Listening...");
// Note: The GetContext method blocks while waiting for a request.
HttpListenerContext context = listener.GetContext();
HttpListenerRequest request = context.Request;
// Obtain a response object.
HttpListenerResponse response = context.Response;
// Construct a response.
string responseString = "<HTML><BODY> Hello world!</BODY></HTML>";
byte[] buffer = System.Text.Encoding.UTF8.GetBytes(responseString);
// Get a response stream and write the response to it.
response.ContentLength64 = buffer.Length;
System.IO.Stream output = response.OutputStream;
output.Write(buffer, 0, buffer.Length);
// You must close the output stream.
output.Close();
listener.Stop();
Thread.Sleep(Timeout.Infinite);
}
public void Collection_Add_Remove()
{
Console.WriteLine("STart test Collection_Add_Remove");
var uri = new Uri("http://localhost:" + NetworkHelpers.FindFreePort());
ServiceHost h = new ServiceHost(typeof(TestContract), uri);
h.AddServiceEndpoint(typeof(TestContract).FullName, new BasicHttpBinding(), "address");
MyChannelDispatcher d = new MyChannelDispatcher(new MyChannelListener(uri));
h.ChannelDispatchers.Add(d);
Assert.IsTrue(d.Attached, "#1");
h.ChannelDispatchers.Remove(d);
Assert.IsFalse(d.Attached, "#2");
h.ChannelDispatchers.Insert(0, d);
Assert.IsTrue(d.Attached, "#3");
h.ChannelDispatchers.Add(new MyChannelDispatcher(new MyChannelListener(uri)));
h.ChannelDispatchers.Clear();
Assert.IsFalse(d.Attached, "#4");
}
public void Test8()
{
var port = NetworkHelpers.FindFreePort();
_listener = CreateAndStartListener("http://127.0.0.1:" + port + "/test8/");
NetworkStream ns = CreateNS(port);
// Just like Test7, but 1.0
Send(ns, "POST /test8/ HTTP/1.0\r\nHost: 127.0.0.1\r\nContent-Length: 3\r\n\r\n123");
HttpListenerContext ctx = _listener.GetContext();
Send(ctx.Response.OutputStream, "%%%OK%%%");
ctx.Response.Close();
string response = Receive(ns, 512);
ns.Close();
Assert.IsTrue(response.StartsWith("HTTP/1.1 200"));
Assert.IsTrue(-1 == response.IndexOf("Transfer-Encoding: chunked"));
}
private async Task PreRunConditions(WorkerRuntime workerRuntime)
{
if (workerRuntime == WorkerRuntime.python)
{
PythonHelpers.VerifyVirtualEnvironment();
}
else if (workerRuntime == WorkerRuntime.dotnet && Build)
{
const string outputPath = "bin/output";
await DotnetHelpers.BuildDotnetProject(outputPath, string.Empty);
Environment.CurrentDirectory = Path.Combine(Environment.CurrentDirectory, outputPath);
}
if (!NetworkHelpers.IsPortAvailable(Port))
{
throw new CliException($"Port {Port} is unavailable. Close the process using that port, or specify another port using --port [-p].");
}
}
public void HttpClientIsDisconnectedCheckForWriteException()
{
AutoResetEvent exceptionOccuredEvent = new AutoResetEvent(false);
HttpListener listener = NetworkHelpers.CreateAndStartHttpListener("http://localhost:", out var port, "/", out var uri,
initializer: (v) => v.IgnoreWriteExceptions = false);
listener.BeginGetContext(result =>
{
HttpListenerContext context = listener.EndGetContext(result);
context.Response.SendChunked = true;
context.Request.InputStream.Close();
var bytes = new byte [1024];
using (Stream outputStream = context.Response.OutputStream) {
try {
while (true)
{
outputStream.Write(bytes, 0, bytes.Length);
}
} catch {
exceptionOccuredEvent.Set();
}
}
}, null);
Task.Factory.StartNew(() =>
{
var webRequest = (HttpWebRequest)WebRequest.Create(uri);
webRequest.Method = "POST";
webRequest.KeepAlive = false;
Stream requestStream = webRequest.GetRequestStream();
requestStream.WriteByte(1);
requestStream.Close();
using (WebResponse response = webRequest.GetResponse())
using (Stream stream = response.GetResponseStream()) {
byte[] clientBytes = new byte [1024];
Assert.IsNotNull(stream, "#01");
stream.Read(clientBytes, 0, clientBytes.Length);
}
});
Assert.IsTrue(exceptionOccuredEvent.WaitOne(15 * 1000), "#02");
}
public void Bug652331_2() // test in one of the comment
{
// Init service
int port = NetworkHelpers.FindFreePort();
ServiceHost serviceHost = new ServiceHost(typeof(Service1), new Uri("http://localhost:" + port + "/Service1"));
serviceHost.AddServiceEndpoint(typeof(IService1), new BasicHttpBinding(), string.Empty);
// Enable metadata exchange (WSDL publishing)
var mexBehavior = new ServiceMetadataBehavior();
mexBehavior.HttpGetEnabled = true;
serviceHost.Description.Behaviors.Add(mexBehavior);
serviceHost.AddServiceEndpoint(typeof(IMetadataExchange), MetadataExchangeBindings.CreateMexHttpBinding(), "mex");
serviceHost.Open();
Thread.Sleep(2000); // let WCF spin up
try {
// client
var binding = new BasicHttpBinding();
var remoteAddress = new EndpointAddress("http://localhost:" + port + "/Service1");
var client = new Service1Client(binding, remoteAddress);
var wait = new ManualResetEvent(false);
client.GetDataCompleted += delegate(object o, GetDataCompletedEventArgs e) {
if (e.Error != null)
{
throw e.Error;
}
Assert.AreEqual("A", ((DataType1)e.Result).Id, "#1");
wait.Set();
};
client.GetDataAsync();
if (!wait.WaitOne(TimeSpan.FromSeconds(20)))
{
Assert.Fail("timeout");
}
} finally {
serviceHost.Close();
}
}
