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(); } }