stoleBlob = false;
// Some things we need right away. Lift them out now while it's convenient.
- string verb = Interop.HttpApi.GetVerb(memoryBlob.RequestBlob);
string authorizationHeader = Interop.HttpApi.GetKnownHeader(memoryBlob.RequestBlob, (int)HttpRequestHeader.Authorization);
ulong connectionId = memoryBlob.RequestBlob->ConnectionId;
ulong requestId = memoryBlob.RequestBlob->RequestId;
ThrowOnError(errorCode);
- Interop.WebSocket.HttpHeader[] responseHeaders = MarshalHttpHeaders(responseHeadersPtr, (int)responseHeaderCount);
errorCode = Interop.WebSocket.WebSocketEndServerHandshake(webSocketHandle);
ThrowOnError(errorCode);
public async Task<HttpListenerResponse> GetResponse()
{
// We need to create a mock request to give the HttpListener a context.
- Task<string> clientTask = _client.GetStringAsync(_listeningUrl);
+ _ = _client.GetStringAsync(_listeningUrl);
HttpListenerContext context = await _listener.GetContextAsync();
return context.Response;
}
using (var client = new HttpClient())
{
- HttpResponseMessage response = await AuthenticationFailure(client, HttpStatusCode.InternalServerError);
+ await AuthenticationFailure(client, HttpStatusCode.InternalServerError);
}
}
using (var client = new HttpClient())
{
- Task<string> clientTask = client.GetStringAsync(_factory.ListeningUrl);
+ _ = client.GetStringAsync(_factory.ListeningUrl);
Assert.Throws<OutOfMemoryException>(() => _listener.GetContext());
}
}
Basic,
Convert.ToBase64String(Encoding.ASCII.GetBytes(string.Format("{0}:{1}", TestUser, TestPassword))));
- Task<string> clientTask = client.GetStringAsync(_factory.ListeningUrl);
+ _ = client.GetStringAsync(_factory.ListeningUrl);
HttpListenerContext listenerContext = await serverContextTask;
Assert.Null(listenerContext.User);
Basic,
Convert.ToBase64String(Encoding.ASCII.GetBytes(authHeader)));
- Task <string> clientTask = client.GetStringAsync(_factory.ListeningUrl);
+ _ = client.GetStringAsync(_factory.ListeningUrl);
HttpListenerContext listenerContext = await serverContextTask;
Assert.Equal(expectedUsername, listenerContext.User.Identity.Name);
Assert.Equal("user", context.User.Identity.Name);
HttpListenerWebSocketContext webSocketContext = await context.AcceptWebSocketAsync(null);
- IPrincipal user = webSocketContext.User;
// Should be copied as User gets disposed when HttpListenerContext is closed.
Assert.NotSame(context.User, webSocketContext.User);
{
using (var factory1 = new HttpListenerFactory(host, path: string.Empty))
{
- HttpListener listener1 = factory1.GetListener();
using (var listener2 = new HttpListener())
{
string prefixWithSubPath = $"{factory1.ListeningUrl}sub_path/";
public async Task CloseResponseEntity_SendToClosedConnection_DoesNotThrow(bool willBlock)
{
const string Text = "Some-String";
- byte[] buffer = Encoding.UTF8.GetBytes(Text);
using (HttpListenerFactory factory = new HttpListenerFactory())
using (Socket client = factory.GetConnectedSocket())
HttpListener listener = listenerFactory.GetListener();
listener.Start();
- Task<string> clientTask = client.GetStringAsync(listenerFactory.ListeningUrl);
+ _ = client.GetStringAsync(listenerFactory.ListeningUrl);
IAsyncResult beginGetContextResult = listener.BeginGetContext(null, null);
listener.EndGetContext(beginGetContextResult);
private unsafe void GetUrlGroupProperty(ulong urlGroupId, HTTP_SERVER_PROPERTY property, IntPtr info, uint infosize)
{
- uint statusCode = 0;
-
- statusCode = HttpQueryUrlGroupProperty(urlGroupId, HTTP_SERVER_PROPERTY.HttpServerTimeoutsProperty, info, infosize, IntPtr.Zero);
-
+ uint statusCode = HttpQueryUrlGroupProperty(urlGroupId, HTTP_SERVER_PROPERTY.HttpServerTimeoutsProperty, info, infosize, IntPtr.Zero);
if (statusCode != 0)
{
throw new Exception("HttpQueryUrlGroupProperty failed with " + (int)statusCode);
{
using (HttpClient client = new HttpClient())
{
- Task<string> clientTask = client.GetStringAsync(_factory.ListeningUrl);
+ _ = client.GetStringAsync(_factory.ListeningUrl);
HttpListenerContext serverContext = await _listener.GetContextAsync();
using (HttpListenerResponse response = serverContext.Response)
{
using (HttpClient client = new HttpClient())
{
- Task<string> clientTask = client.GetStringAsync(_factory.ListeningUrl);
+ _ = client.GetStringAsync(_factory.ListeningUrl);
HttpListenerContext serverContext = await _listener.GetContextAsync();
using (HttpListenerResponse response = serverContext.Response)
{
using (HttpClient client = new HttpClient())
{
- Task<string> clientTask = client.GetStringAsync(_factory.ListeningUrl);
+ _ = client.GetStringAsync(_factory.ListeningUrl);
HttpListenerContext serverContext = await _listener.GetContextAsync();
using (HttpListenerResponse response = serverContext.Response)
string path = Path.GetTempFileName();
try
{
- var data = new byte[1024];
WebRequest request = WebRequest.Create("file://" + path);
request.Method = WebRequestMethods.File.UploadFile;
using (WebResponse response = await GetResponseAsync(request))
{
string serverUrl = string.Format("ftp://www.{0}.com/", Guid.NewGuid().ToString());
FtpWebRequest request = (FtpWebRequest)WebRequest.Create(serverUrl);
- WebException ex = Assert.Throws<WebException>(() => request.GetResponse());
+ Assert.Throws<WebException>(() => request.GetResponse());
}
[OuterLoop]
HttpWebRequest request = HttpWebRequest.CreateHttp(remoteServer);
request.Method = "POST";
- IAsyncResult asyncResult = request.BeginGetRequestStream(null, null);
+ request.BeginGetRequestStream(null, null);
Assert.Throws<InvalidOperationException>(() =>
{
request.BeginGetRequestStream(null, null);
{
HttpWebRequest request = HttpWebRequest.CreateHttp(url);
- IAsyncResult asyncResult = request.BeginGetResponse(null, null);
+ request.BeginGetResponse(null, null);
Assert.Throws<ProtocolViolationException>(() =>
{
request.BeginGetRequestStream(null, null);
await LoopbackServer.CreateServerAsync((server, url) =>
{
HttpWebRequest request = WebRequest.CreateHttp(url);
- IAsyncResult asyncResult = request.BeginGetResponse(null, null);
+ request.BeginGetResponse(null, null);
Assert.Throws<InvalidOperationException>(() => request.BeginGetResponse(null, null));
return Task.FromResult<object>(null);
});
public void CookieContainer_Count_Add(Uri remoteServer)
{
HttpWebRequest request = WebRequest.CreateHttp(remoteServer);
- DateTime now = DateTime.UtcNow;
request.CookieContainer = new CookieContainer();
request.CookieContainer.Add(remoteServer, new Cookie("1", "cookie1"));
request.CookieContainer.Add(remoteServer, new Cookie("2", "cookie2"));
request.ContentType = HeadersPartialContent;
using WebResponse response = await GetResponseAsync(request);
- string headersString = response.Headers.ToString();
Assert.Equal(HeadersPartialContent, response.Headers[HttpResponseHeader.ContentType]);
}, async server =>
{
request.Method = HttpMethod.Get.Method;
HttpContinueDelegate continueDelegate = new HttpContinueDelegate(HttpContinueMethod);
request.ContinueDelegate = continueDelegate;
- Task<WebResponse> getResponse = request.GetResponseAsync();
- DateTimeOffset utcNow = DateTimeOffset.UtcNow;
+ _ = request.GetResponseAsync();
await server.AcceptConnectionSendResponseAndCloseAsync(HttpStatusCode.OK, "Content-Type: application/json;charset=UTF-8\r\n", "12345");
Assert.Equal(continueDelegate, request.ContinueDelegate);
});
HttpWebRequest request = WebRequest.CreateHttp(url);
request.Method = HttpMethod.Get.Method;
Task<WebResponse> getResponse = request.GetResponseAsync();
- DateTimeOffset utcNow = DateTimeOffset.UtcNow;
await server.AcceptConnectionSendResponseAndCloseAsync(HttpStatusCode.OK, "Content-Type: application/json;charset=UTF-8\r\n", "12345");
using (WebResponse response = await getResponse)
HttpWebRequest request = WebRequest.CreateHttp(url);
request.Method = HttpMethod.Get.Method;
Task<WebResponse> getResponse = request.GetResponseAsync();
- DateTimeOffset utcNow = DateTimeOffset.UtcNow;
await server.AcceptConnectionSendResponseAndCloseAsync(HttpStatusCode.OK, "Content-Type: application/json;charset=UTF-8\r\n", "12345");
WebResponse response = await getResponse;
HttpWebResponse httpResponse = (HttpWebResponse)response;
[Fact]
public async Task LastModified_InvalidDate_Throws()
{
- DateTime expected = TimeZoneInfo.ConvertTimeFromUtc(new DateTime(2018, 4, 10, 3, 4, 5, DateTimeKind.Utc), TimeZoneInfo.Local);
await LoopbackServer.CreateServerAsync(async (server, url) =>
{
HttpWebRequest request = WebRequest.CreateHttp(url);
HttpWebRequest request = WebRequest.CreateHttp(url);
request.Method = HttpMethod.Get.Method;
Task<WebResponse> getResponse = request.GetResponseAsync();
- DateTimeOffset utcNow = DateTimeOffset.UtcNow;
await server.AcceptConnectionSendResponseAndCloseAsync();
using (WebResponse response = await getResponse)
{
- HttpWebResponse httpResponse = (HttpWebResponse)response;
using (MemoryStream fs = new MemoryStream())
{
BinaryFormatter formatter = new BinaryFormatter();
{
await GetRequestStream((stream) =>
{
- AssertExtensions.Throws<ArgumentNullException>("buffer", () => { Task t = stream.WriteAsync(null, 0, 1); });
+ AssertExtensions.Throws<ArgumentNullException>("buffer", () => { stream.WriteAsync(null, 0, 1); });
});
}
{
await GetRequestStream((stream) =>
{
- AssertExtensions.Throws<ArgumentOutOfRangeException>("offset", () => { Task t = stream.WriteAsync(buffer, -1, buffer.Length); });
+ AssertExtensions.Throws<ArgumentOutOfRangeException>("offset", () => { stream.WriteAsync(buffer, -1, buffer.Length); });
});
}
{
await GetRequestStream((stream) =>
{
- AssertExtensions.Throws<ArgumentOutOfRangeException>("count", "size", () => { Task t = stream.WriteAsync(buffer, 0, -1); });
+ AssertExtensions.Throws<ArgumentOutOfRangeException>("count", "size", () => { stream.WriteAsync(buffer, 0, -1); });
});
}
{
await GetRequestStream((stream) =>
{
- AssertExtensions.Throws<ArgumentOutOfRangeException>("count", "size", () => { Task t = stream.WriteAsync(buffer, 0, buffer.Length + 1); });
+ AssertExtensions.Throws<ArgumentOutOfRangeException>("count", "size", () => { stream.WriteAsync(buffer, 0, buffer.Length + 1); });
});
}
{
await GetRequestStream((stream) =>
{
- AssertExtensions.Throws<ArgumentOutOfRangeException>("offset", () => { Task t = stream.WriteAsync(buffer, int.MaxValue, int.MaxValue); });
+ AssertExtensions.Throws<ArgumentOutOfRangeException>("offset", () => { stream.WriteAsync(buffer, int.MaxValue, int.MaxValue); });
});
}
public void Create_ValidWebRequestUriScheme_Success(string scheme)
{
var uri = new Uri($"{scheme}://example.com/folder/resource.txt");
- WebRequest request = WebRequest.Create(uri);
+ WebRequest.Create(uri);
}
[Theory]
SafeFreeCertContext? remoteContext = null;
try
{
- int errorCode = QueryContextRemoteCertificate(securityContext, out remoteContext);
+ QueryContextRemoteCertificate(securityContext, out remoteContext);
if (remoteContext != null && !remoteContext.IsInvalid)
{
}
// Following can underflow but it is ok due to equality check below
- int hostNameStructLength = BinaryPrimitives.ReadUInt16BigEndian(serverName) - sizeof(NameType);
NameType nameType = (NameType)serverName[NameTypeOffset];
ReadOnlySpan<byte> hostNameStruct = serverName.Slice(HostNameStructOffset);
if (nameType != NameType.HostName)
private ValueTask<int> ReadAsyncInternal<TReadAdapter>(TReadAdapter adapter, Memory<byte> buffer) => default;
- private Task CheckEnqueueWriteAsync() => default;
-
- private void CheckEnqueueWrite()
- {
- }
-
- private ValueTask<int> CheckEnqueueReadAsync(Memory<byte> buffer) => default;
-
- private int CheckEnqueueRead(Memory<byte> buffer) => default;
-
private bool RemoteCertRequired => default;
- private void CheckThrow(bool authSuccessCheck, bool shutdownCheck = false)
- {
- }
-
private void CloseInternal()
{
}
projects / platform / upstream / dotnet / runtime.git / commitdiff