});
}
- private static string GetDefaultHttpResponse() => $"HTTP/1.1 200 OK\r\nDate: {DateTimeOffset.UtcNow:R}\r\nContent-Length: 0\r\n\r\n";
-
- public async Task<List<string>> AcceptConnectionSendResponseAndCloseAsync(string response)
- {
- List<string> lines = null;
-
- // Note, we assume there's no request body.
- // We'll close the connection after reading the request header and sending the response.
- await AcceptConnectionAsync(async connection =>
- {
- lines = await connection.ReadRequestHeaderAndSendResponseAsync(response);
- });
-
- return lines;
- }
-
- public Task<List<string>> AcceptConnectionSendDefaultResponseAndCloseAsync()
- {
- return AcceptConnectionSendResponseAndCloseAsync(GetDefaultHttpResponse());
- }
-
public async Task AcceptConnectionAsync(Func<Connection, Task> funcAsync)
{
using (Socket s = await _listenSocket.AcceptAsync().ConfigureAwait(false))
}
}
+ public async Task<List<string>> AcceptConnectionSendCustomResponseAndCloseAsync(string response)
+ {
+ List<string> lines = null;
+
+ // Note, we assume there's no request body.
+ // We'll close the connection after reading the request header and sending the response.
+ await AcceptConnectionAsync(async connection =>
+ {
+ lines = await connection.ReadRequestHeaderAndSendCustomResponseAsync(response);
+ });
+
+ return lines;
+ }
+
+ public async Task<List<string>> AcceptConnectionSendResponseAndCloseAsync(HttpStatusCode statusCode = HttpStatusCode.OK, string additionalHeaders = null, string content = null)
+ {
+ List<string> lines = null;
+
+ // Note, we assume there's no request body.
+ // We'll close the connection after reading the request header and sending the response.
+ await AcceptConnectionAsync(async connection =>
+ {
+ lines = await connection.ReadRequestHeaderAndSendResponseAsync(statusCode, additionalHeaders, content);
+ });
+
+ return lines;
+ }
+
+ // Stolen from HttpStatusDescription code in the product code
+ private static string GetStatusDescription(HttpStatusCode code)
+ {
+ switch ((int)code)
+ {
+ case 100: return "Continue";
+ case 101: return "Switching Protocols";
+ case 102: return "Processing";
+
+ case 200: return "OK";
+ case 201: return "Created";
+ case 202: return "Accepted";
+ case 203: return "Non-Authoritative Information";
+ case 204: return "No Content";
+ case 205: return "Reset Content";
+ case 206: return "Partial Content";
+ case 207: return "Multi-Status";
+
+ case 300: return "Multiple Choices";
+ case 301: return "Moved Permanently";
+ case 302: return "Found";
+ case 303: return "See Other";
+ case 304: return "Not Modified";
+ case 305: return "Use Proxy";
+ case 307: return "Temporary Redirect";
+
+ case 400: return "Bad Request";
+ case 401: return "Unauthorized";
+ case 402: return "Payment Required";
+ case 403: return "Forbidden";
+ case 404: return "Not Found";
+ case 405: return "Method Not Allowed";
+ case 406: return "Not Acceptable";
+ case 407: return "Proxy Authentication Required";
+ case 408: return "Request Timeout";
+ case 409: return "Conflict";
+ case 410: return "Gone";
+ case 411: return "Length Required";
+ case 412: return "Precondition Failed";
+ case 413: return "Request Entity Too Large";
+ case 414: return "Request-Uri Too Long";
+ case 415: return "Unsupported Media Type";
+ case 416: return "Requested Range Not Satisfiable";
+ case 417: return "Expectation Failed";
+ case 422: return "Unprocessable Entity";
+ case 423: return "Locked";
+ case 424: return "Failed Dependency";
+ case 426: return "Upgrade Required"; // RFC 2817
+
+ case 500: return "Internal Server Error";
+ case 501: return "Not Implemented";
+ case 502: return "Bad Gateway";
+ case 503: return "Service Unavailable";
+ case 504: return "Gateway Timeout";
+ case 505: return "Http Version Not Supported";
+ case 507: return "Insufficient Storage";
+ }
+ return null;
+ }
+
+ public static string GetHttpResponse(HttpStatusCode statusCode = HttpStatusCode.OK, string additionalHeaders = null, string content = null) =>
+ $"HTTP/1.1 {(int)statusCode} {GetStatusDescription(statusCode)}\r\n" +
+ $"Date: {DateTimeOffset.UtcNow:R}\r\n" +
+ $"Content-Length: {(content == null ? 0 : content.Length)}\r\n" +
+ additionalHeaders +
+ "\r\n" +
+ content;
+
public class Options
{
public IPAddress Address { get; set; } = IPAddress.Loopback;
return lines;
}
- public async Task<List<string>> ReadRequestHeaderAndSendResponseAsync(string response)
+ public async Task SendResponseAsync(HttpStatusCode statusCode = HttpStatusCode.OK, string additionalHeaders = null, string content = null)
{
- List<string> lines = await ReadRequestHeaderAsync().ConfigureAwait(false);
-
- await _writer.WriteAsync(response).ConfigureAwait(false);
+ await _writer.WriteAsync(GetHttpResponse(statusCode, additionalHeaders, content));
+ }
+ public async Task<List<string>> ReadRequestHeaderAndSendCustomResponseAsync(string response)
+ {
+ List<string> lines = await ReadRequestHeaderAsync().ConfigureAwait(false);
+ await _writer.WriteAsync(response);
return lines;
}
- public Task<List<string>> ReadRequestHeaderAndSendDefaultResponseAsync()
+ public async Task<List<string>> ReadRequestHeaderAndSendResponseAsync(HttpStatusCode statusCode = HttpStatusCode.OK, string additionalHeaders = null, string content = null)
{
- return ReadRequestHeaderAndSendResponseAsync(GetDefaultHttpResponse());
+ List<string> lines = await ReadRequestHeaderAsync().ConfigureAwait(false);
+ await SendResponseAsync(statusCode, additionalHeaders, content);
+ return lines;
}
}
}
{
LoopbackServer.CreateServerAsync(async (server, url) =>
{
- Task<List<string>> requestLines = server.AcceptConnectionSendDefaultResponseAndCloseAsync();
+ Task<List<string>> requestLines = server.AcceptConnectionSendResponseAndCloseAsync();
Task<HttpResponseMessage> response = client.GetAsync(url);
await Task.WhenAll(response, requestLines);
await LoopbackServer.CreateServerAsync(async (server, url) =>
{
await TestHelper.WhenAllCompletedOrAnyFailed(
- server.AcceptConnectionSendDefaultResponseAndCloseAsync(),
+ server.AcceptConnectionSendResponseAndCloseAsync(),
client.GetAsync(url));
});
Task request = server.AcceptConnectionAsync(connection =>
{
tcs.Cancel();
- return connection.ReadRequestHeaderAndSendDefaultResponseAsync();
+ return connection.ReadRequestHeaderAndSendResponseAsync();
});
Task response = client.GetAsync(url, tcs.Token);
await Assert.ThrowsAnyAsync<Exception>(() => TestHelper.WhenAllCompletedOrAnyFailed(response, request));
{
LoopbackServer.CreateServerAsync(async (server, url) =>
{
- Task<List<string>> requestLines = server.AcceptConnectionSendDefaultResponseAndCloseAsync();
+ Task<List<string>> requestLines = server.AcceptConnectionSendResponseAndCloseAsync();
Task<HttpResponseMessage> response = client.GetAsync(url);
await Task.WhenAll(response, requestLines);
Task request = server.AcceptConnectionAsync(connection =>
{
tcs.Cancel();
- return connection.ReadRequestHeaderAndSendDefaultResponseAsync();
+ return connection.ReadRequestHeaderAndSendResponseAsync();
});
Task response = client.GetAsync(url, tcs.Token);
await Assert.ThrowsAnyAsync<Exception>(() => TestHelper.WhenAllCompletedOrAnyFailed(response, request));
await LoopbackServer.CreateServerAsync(async (server, url) =>
{
await TestHelper.WhenAllCompletedOrAnyFailed(
- server.AcceptConnectionSendDefaultResponseAndCloseAsync(),
+ server.AcceptConnectionSendResponseAndCloseAsync(),
client.GetAsync(url));
}, options);
}
{
SslStream sslStream = Assert.IsType<SslStream>(connection.Stream);
Assert.Equal(cert, sslStream.RemoteCertificate);
- await connection.ReadRequestHeaderAndSendDefaultResponseAsync();
+ await connection.ReadRequestHeaderAndSendResponseAsync();
}));
};
var cts = new CancellationTokenSource();
Task serverTask = Task.Run(async delegate
{
- await connection.ReadRequestHeaderAndSendResponseAsync("HTTP/1.1 200 OK\r\nContent-Length: 0\r\nMyInfiniteHeader: ");
+ await connection.ReadRequestHeaderAndSendCustomResponseAsync("HTTP/1.1 200 OK\r\nContent-Length: 0\r\nMyInfiniteHeader: ");
try
{
while (!cts.IsCancellationRequested)
await server.AcceptConnectionAsync(async connection =>
{
- Task serverTask = connection.ReadRequestHeaderAndSendResponseAsync(responseHeaders);
+ Task serverTask = connection.ReadRequestHeaderAndSendCustomResponseAsync(responseHeaders);
if (shouldSucceed)
{
await LoopbackServer.CreateServerAsync(async (server, url) =>
{
await TestHelper.WhenAllCompletedOrAnyFailed(
- server.AcceptConnectionSendDefaultResponseAndCloseAsync(),
+ server.AcceptConnectionSendResponseAndCloseAsync(),
client.GetAsync(url));
});
Assert.Throws<InvalidOperationException>(() => handler.SslProtocols = SslProtocols.Tls12);
await LoopbackServer.CreateServerAsync(async (server, url) =>
{
await TestHelper.WhenAllCompletedOrAnyFailed(
- server.AcceptConnectionSendDefaultResponseAndCloseAsync(),
+ server.AcceptConnectionSendResponseAndCloseAsync(),
client.GetAsync(url));
}, options);
}
server.AcceptConnectionAsync(async connection =>
{
Assert.Equal(SslProtocols.Tls12, Assert.IsType<SslStream>(connection.Stream).SslProtocol);
- await connection.ReadRequestHeaderAndSendDefaultResponseAsync();
+ await connection.ReadRequestHeaderAndSendResponseAsync();
}));
}, options);
}
await LoopbackServer.CreateServerAsync(async (server, url) =>
{
await TestHelper.WhenAllCompletedOrAnyFailed(
- Assert.ThrowsAsync(exceptedServerException, () => server.AcceptConnectionSendDefaultResponseAndCloseAsync()),
+ Assert.ThrowsAsync(exceptedServerException, () => server.AcceptConnectionSendResponseAndCloseAsync()),
Assert.ThrowsAsync<HttpRequestException>(() => client.GetAsync(url)));
}, options);
}
await LoopbackServer.CreateServerAsync(async (server, url) =>
{
await TestHelper.WhenAllCompletedOrAnyFailed(
- Assert.ThrowsAsync<IOException>(() => server.AcceptConnectionSendDefaultResponseAndCloseAsync()),
+ Assert.ThrowsAsync<IOException>(() => server.AcceptConnectionSendResponseAndCloseAsync()),
Assert.ThrowsAsync<HttpRequestException>(() => client.GetAsync(url)));
}, options);
await LoopbackServer.CreateServerAsync(async (server, url) =>
{
await TestHelper.WhenAllCompletedOrAnyFailed(
- server.AcceptConnectionSendDefaultResponseAndCloseAsync(),
+ server.AcceptConnectionSendResponseAndCloseAsync(),
client.GetAsync(url));
}, options);
}
{
_output.WriteLine(url.ToString());
await TestHelper.WhenAllCompletedOrAnyFailed(
- server.AcceptConnectionSendDefaultResponseAndCloseAsync(),
+ server.AcceptConnectionSendResponseAndCloseAsync(),
client.GetAsync(url));
}, options);
}
{
_output.WriteLine(url.ToString());
await TestHelper.WhenAllCompletedOrAnyFailed(
- server.AcceptConnectionSendDefaultResponseAndCloseAsync(),
+ server.AcceptConnectionSendResponseAndCloseAsync(),
client.GetAsync(url));
}, options);
}
[InlineData("")] // RFC7235 requires servers to send this header with 401 but some servers don't.
public async Task GetAsync_ServerNeedsNonStandardAuthAndSetCredential_StatusCodeUnauthorized(string authHeaders)
{
- string responseHeaders =
- $"HTTP/1.1 401 Unauthorized\r\nDate: {DateTimeOffset.UtcNow:R}\r\n{authHeaders}Content-Length: 0\r\n\r\n";
- _output.WriteLine(responseHeaders);
await LoopbackServer.CreateServerAsync(async (server, url) =>
{
HttpClientHandler handler = CreateHttpClientHandler();
using (var client = new HttpClient(handler))
{
Task<HttpResponseMessage> getResponseTask = client.GetAsync(url);
- Task<List<string>> serverTask = server.AcceptConnectionSendResponseAndCloseAsync(responseHeaders);
+ Task<List<string>> serverTask = server.AcceptConnectionSendResponseAndCloseAsync(HttpStatusCode.Unauthorized);
await TestHelper.WhenAllCompletedOrAnyFailed(getResponseTask, serverTask);
using (HttpResponseMessage response = await getResponseTask)
await LoopbackServer.CreateServerAsync(async (redirServer, redirUrl) =>
{
// Original URL will redirect to a different URL
- Task<List<string>> serverTask = origServer.AcceptConnectionSendResponseAndCloseAsync(
- $"HTTP/1.1 {statusCode} OK\r\n" +
- $"Date: {DateTimeOffset.UtcNow:R}\r\n" +
- $"Location: {redirUrl}\r\n" +
- "\r\n");
+ Task<List<string>> serverTask = origServer.AcceptConnectionSendResponseAndCloseAsync((HttpStatusCode)statusCode, $"Location: {redirUrl}\r\n");
await Task.WhenAny(getResponseTask, serverTask);
Assert.False(getResponseTask.IsCompleted, $"{getResponseTask.Status}: {getResponseTask.Exception}");
await serverTask;
// Redirected URL answers with success
- serverTask = redirServer.AcceptConnectionSendDefaultResponseAndCloseAsync();
+ serverTask = redirServer.AcceptConnectionSendResponseAndCloseAsync();
await TestHelper.WhenAllCompletedOrAnyFailed(getResponseTask, serverTask);
List<string> receivedRequest = await serverTask;
await LoopbackServer.CreateServerAsync(async (server, url) =>
{
Task<HttpResponseMessage> getTask = client.GetAsync(url);
- Task<List<string>> serverTask = server.AcceptConnectionSendResponseAndCloseAsync(
- $"HTTP/1.1 302 OK\r\n" +
- $"Date: {DateTimeOffset.UtcNow:R}\r\n" +
- "\r\n");
+ Task<List<string>> serverTask = server.AcceptConnectionSendResponseAndCloseAsync(HttpStatusCode.Found);
await TestHelper.WhenAllCompletedOrAnyFailed(getTask, serverTask);
using (HttpResponseMessage response = await getTask)
{
Task<HttpResponseMessage> getResponseTask = client.GetAsync(origUrl);
- Task redirectTask = redirectServer.AcceptConnectionSendDefaultResponseAndCloseAsync();
+ Task redirectTask = redirectServer.AcceptConnectionSendResponseAndCloseAsync();
await TestHelper.WhenAllCompletedOrAnyFailed(
getResponseTask,
- origServer.AcceptConnectionSendResponseAndCloseAsync(
- $"HTTP/1.1 {statusCode} OK\r\n" +
- $"Date: {DateTimeOffset.UtcNow:R}\r\n" +
- $"Location: {redirectUrl}\r\n" +
- "Content-Length: 0\r\n" +
- "\r\n"));
+ origServer.AcceptConnectionSendResponseAndCloseAsync((HttpStatusCode)statusCode, $"Location: {redirectUrl}\r\n"));
using (HttpResponseMessage response = await getResponseTask)
{
Uri expectedUrl = new Uri(origUrl.ToString() + expectedFragment);
Task<HttpResponseMessage> getResponse = client.GetAsync(origUrl);
- Task firstRequest = origServer.AcceptConnectionSendResponseAndCloseAsync(
- $"HTTP/1.1 302 OK\r\n" +
- $"Date: {DateTimeOffset.UtcNow:R}\r\n" +
- $"Location: {redirectUrl}\r\n" +
- "\r\n");
+ Task firstRequest = origServer.AcceptConnectionSendResponseAndCloseAsync(HttpStatusCode.Found, $"Location: {redirectUrl}\r\n");
Assert.Equal(firstRequest, await Task.WhenAny(firstRequest, getResponse));
- Task secondRequest = origServer.AcceptConnectionSendDefaultResponseAndCloseAsync();
+ Task secondRequest = origServer.AcceptConnectionSendResponseAndCloseAsync();
await TestHelper.WhenAllCompletedOrAnyFailed(secondRequest, getResponse);
using (HttpResponseMessage response = await getResponse)
Task<HttpResponseMessage> getResponseTask = client.GetAsync(url);
await TestHelper.WhenAllCompletedOrAnyFailed(
getResponseTask,
- server.AcceptConnectionSendResponseAndCloseAsync(
+ server.AcceptConnectionSendCustomResponseAndCloseAsync(
"HTTP/1.1 200 OK\r\n" +
"Transfer-Encoding: chunked\r\n" +
(includeTrailerHeader ? "Trailer: MyCoolTrailerHeader\r\n" : "") +
Task<HttpResponseMessage> getResponseTask = client.GetAsync(url);
await TestHelper.WhenAllCompletedOrAnyFailed(
getResponseTask,
- server.AcceptConnectionSendResponseAndCloseAsync(
+ server.AcceptConnectionSendCustomResponseAndCloseAsync(
"HTTP/1.1 200 OK\r\n" +
"Transfer-Encoding: chunked\r\n" +
"\r\n" +
var tcs = new TaskCompletionSource<bool>();
Task serverTask = server.AcceptConnectionAsync(async connection =>
{
- await connection.ReadRequestHeaderAndSendResponseAsync(partialResponse);
+ await connection.ReadRequestHeaderAndSendCustomResponseAsync(partialResponse);
await tcs.Task;
});
var tcs = new TaskCompletionSource<bool>();
Task serverTask = server.AcceptConnectionAsync(async connection =>
{
- await connection.ReadRequestHeaderAndSendResponseAsync("HTTP/1.1 200 OK\r\nTransfer-Encoding: chunked\r\n\r\n");
+ await connection.ReadRequestHeaderAndSendCustomResponseAsync("HTTP/1.1 200 OK\r\nTransfer-Encoding: chunked\r\n\r\n");
TextWriter writer = connection.Writer;
try
{
await server.AcceptConnectionAsync(async connection =>
{
- await connection.ReadRequestHeaderAndSendResponseAsync(
+ await connection.ReadRequestHeaderAndSendCustomResponseAsync(
"HTTP/1.1 200 OK\r\n" +
$"Date: {DateTimeOffset.UtcNow:R}\r\n" +
"Content-Length: 16000\r\n" +
// Second server connects and sends some but not all headers
Task serverTask2 = server2.AcceptConnectionAsync(async connection2 =>
{
- await connection2.ReadRequestHeaderAndSendResponseAsync($"HTTP/1.1 200 OK\r\n");
+ await connection2.ReadRequestHeaderAndSendCustomResponseAsync($"HTTP/1.1 200 OK\r\n");
await unblockServers.Task;
});
// Third server connects and sends all headers and some but not all of the body
Task serverTask3 = server3.AcceptConnectionAsync(async connection3 =>
{
- await connection3.ReadRequestHeaderAndSendResponseAsync($"HTTP/1.1 200 OK\r\nDate: {DateTimeOffset.UtcNow:R}\r\nContent-Length: 20\r\n\r\n");
+ await connection3.ReadRequestHeaderAndSendCustomResponseAsync($"HTTP/1.1 200 OK\r\nDate: {DateTimeOffset.UtcNow:R}\r\nContent-Length: 20\r\n\r\n");
await connection3.Writer.WriteAsync("1234567890");
await unblockServers.Task;
await connection3.Writer.WriteAsync("1234567890");
using (HttpClient client = CreateHttpClient())
{
Task<HttpResponseMessage> getResponseTask = client.GetAsync(url);
- await server.AcceptConnectionSendResponseAndCloseAsync(
+ await server.AcceptConnectionSendCustomResponseAndCloseAsync(
$"HTTP/1.1 {statusCode}\r\n" +
$"Date: {DateTimeOffset.UtcNow:R}\r\n" +
"\r\n");
using (HttpClient client = CreateHttpClient())
{
Task<HttpResponseMessage> getResponse = client.SendAsync(request);
- Task<List<string>> serverTask = server.AcceptConnectionSendDefaultResponseAndCloseAsync();
+ Task<List<string>> serverTask = server.AcceptConnectionSendResponseAndCloseAsync();
await TestHelper.WhenAllCompletedOrAnyFailed(getResponse, serverTask);
List<string> receivedRequest = await serverTask;
using (HttpClient client = CreateHttpClient())
{
Task<HttpResponseMessage> getResponseTask = client.SendAsync(request);
- Task<List<string>> serverTask = server.AcceptConnectionSendDefaultResponseAndCloseAsync();
+ Task<List<string>> serverTask = server.AcceptConnectionSendResponseAndCloseAsync();
await TestHelper.WhenAllCompletedOrAnyFailed(getResponseTask, serverTask);
List<string> receivedRequest = await serverTask;
await LoopbackServer.CreateServerAsync(async (server, url) =>
{
Task<string> getTask = client.GetStringAsync(url);
- Task serverTask = server.AcceptConnectionSendResponseAndCloseAsync(
- $"HTTP/1.1 200 OK\r\n" +
- $"Date: {DateTimeOffset.UtcNow:R}\r\n" +
- $"Content-Length: {contentLength}\r\n" +
- "\r\n" +
- new string('s', contentLength));
+ Task serverTask = server.AcceptConnectionSendResponseAndCloseAsync(content: new string('s', contentLength));
Task bothTasks = TestHelper.WhenAllCompletedOrAnyFailed(getTask, serverTask);
if (exceptionExpected)
await Task.Delay(TimeSpan.FromSeconds(.5));
await TestHelper.WhenAllCompletedOrAnyFailed(
getTask,
- server.AcceptConnectionSendDefaultResponseAndCloseAsync());
+ server.AcceptConnectionSendResponseAndCloseAsync());
});
}
}
using (HttpClient client = CreateHttpClient())
{
Task<HttpResponseMessage> getResponseTask = client.GetAsync(url);
- Task<List<string>> serverTask = server.AcceptConnectionSendDefaultResponseAndCloseAsync();
+ Task<List<string>> serverTask = server.AcceptConnectionSendResponseAndCloseAsync();
await TestHelper.WhenAllCompletedOrAnyFailed(getResponseTask, serverTask);
List<string> requestLines = await serverTask;
using (HttpClient client = new HttpClient(handler))
{
Task<HttpResponseMessage> getResponseTask = client.GetAsync(url);
- Task<List<string>> serverTask = server.AcceptConnectionSendDefaultResponseAndCloseAsync();
+ Task<List<string>> serverTask = server.AcceptConnectionSendResponseAndCloseAsync();
await TestHelper.WhenAllCompletedOrAnyFailed(getResponseTask, serverTask);
List<string> requestLines = await serverTask;
using (HttpClient client = new HttpClient(handler))
{
Task<HttpResponseMessage> getResponseTask = client.GetAsync(url);
- Task<List<string>> serverTask = server.AcceptConnectionSendDefaultResponseAndCloseAsync();
+ Task<List<string>> serverTask = server.AcceptConnectionSendResponseAndCloseAsync();
await TestHelper.WhenAllCompletedOrAnyFailed(getResponseTask, serverTask);
List<string> requestLines = await serverTask;
requestMessage.Headers.Add("Cookie", s_customCookieHeaderValue);
Task<HttpResponseMessage> getResponseTask = client.SendAsync(requestMessage);
- Task<List<string>> serverTask = server.AcceptConnectionSendDefaultResponseAndCloseAsync();
+ Task<List<string>> serverTask = server.AcceptConnectionSendResponseAndCloseAsync();
List<string> requestLines = await serverTask;
requestMessage.Headers.Add("Cookie", "C=3");
Task<HttpResponseMessage> getResponseTask = client.SendAsync(requestMessage);
- Task<List<string>> serverTask = server.AcceptConnectionSendDefaultResponseAndCloseAsync();
+ Task<List<string>> serverTask = server.AcceptConnectionSendResponseAndCloseAsync();
List<string> requestLines = await serverTask;
requestMessage.Headers.Add("Cookie", s_customCookieHeaderValue);
Task<HttpResponseMessage> getResponseTask = client.SendAsync(requestMessage);
- Task<List<string>> serverTask = server.AcceptConnectionSendDefaultResponseAndCloseAsync();
+ Task<List<string>> serverTask = server.AcceptConnectionSendResponseAndCloseAsync();
await TestHelper.WhenAllCompletedOrAnyFailed(getResponseTask, serverTask);
List<string> requestLines = await serverTask;
requestMessage.Headers.Add("Cookie", "B=2");
Task<HttpResponseMessage> getResponseTask = client.SendAsync(requestMessage);
- Task<List<string>> serverTask = server.AcceptConnectionSendDefaultResponseAndCloseAsync();
+ Task<List<string>> serverTask = server.AcceptConnectionSendResponseAndCloseAsync();
await TestHelper.WhenAllCompletedOrAnyFailed(getResponseTask, serverTask);
List<string> requestLines = await serverTask;
},
async server =>
{
- List<string> request1Lines = await server.AcceptConnectionSendResponseAndCloseAsync(
- $"HTTP/1.1 302 Found\r\nContent-Length: 0\r\nLocation: {path2}\r\nConnection: close\r\n\r\n");
+ List<string> request1Lines = await server.AcceptConnectionSendResponseAndCloseAsync(HttpStatusCode.Found, $"Location: {path2}\r\n");
Assert.Contains($"Cookie: cookie1=value1", request1Lines);
Assert.Equal(1, request1Lines.Count(s => s.StartsWith("Cookie:")));
- List<string> request2Lines = await server.AcceptConnectionSendResponseAndCloseAsync(
- $"HTTP/1.1 200 OK\r\nContent-Length: {s_simpleContent.Length}\r\n\r\n{s_simpleContent}");
+ List<string> request2Lines = await server.AcceptConnectionSendResponseAndCloseAsync(content: s_simpleContent);
Assert.Contains($"Cookie: cookie2=value2", request2Lines);
Assert.Equal(1, request2Lines.Count(s => s.StartsWith("Cookie:")));
{
Task<HttpResponseMessage> getResponseTask = client.GetAsync(url);
Task<List<string>> serverTask = server.AcceptConnectionSendResponseAndCloseAsync(
- $"HTTP/1.1 200 Ok\r\nContent-Length: {s_simpleContent.Length}\r\nSet-Cookie: {GetCookieHeaderValue(cookieName, cookieValue)}\r\n\r\n{s_simpleContent}");
+ HttpStatusCode.OK, $"Set-Cookie: {GetCookieHeaderValue(cookieName, cookieValue)}\r\n", s_simpleContent);
await TestHelper.WhenAllCompletedOrAnyFailed(getResponseTask, serverTask);
CookieCollection collection = handler.CookieContainer.GetCookies(url);
{
Task<HttpResponseMessage> getResponseTask = client.GetAsync(url);
Task<List<string>> serverTask = server.AcceptConnectionSendResponseAndCloseAsync(
- $"HTTP/1.1 200 OK\r\n" +
- $"Date: {DateTimeOffset.UtcNow:R}\r\n" +
+ HttpStatusCode.OK,
$"Set-Cookie: A=1; Path=/\r\n" +
$"Set-Cookie : B=2; Path=/\r\n" + // space before colon to verify header is trimmed and recognized
- $"Set-Cookie: C=3; Path=/\r\n" +
- $"Content-Length: {s_simpleContent.Length}\r\n" +
- $"\r\n" +
- $"{s_simpleContent}");
+ $"Set-Cookie: C=3; Path=/\r\n",
+ s_simpleContent);
await TestHelper.WhenAllCompletedOrAnyFailed(getResponseTask, serverTask);
CookieCollection collection = handler.CookieContainer.GetCookies(url);
{
Task<HttpResponseMessage> getResponseTask = client.GetAsync(url);
Task<List<string>> serverTask = server.AcceptConnectionSendResponseAndCloseAsync(
- $"HTTP/1.1 200 Ok\r\nContent-Length: {s_simpleContent.Length}\r\nSet-Cookie: {s_cookieName}={newCookieValue}\r\n\r\n{s_simpleContent}");
+ HttpStatusCode.OK, $"Set-Cookie: {s_cookieName}={newCookieValue}\r\n", s_simpleContent);
await TestHelper.WhenAllCompletedOrAnyFailed(getResponseTask, serverTask);
CookieCollection collection = handler.CookieContainer.GetCookies(url);
{
Task<HttpResponseMessage> getResponseTask = client.GetAsync(url);
Task<List<string>> serverTask = server.AcceptConnectionSendResponseAndCloseAsync(
- $"HTTP/1.1 200 Ok\r\nContent-Length: {s_simpleContent.Length}\r\nSet-Cookie: {s_cookieName}=; Expires=Sun, 06 Nov 1994 08:49:37 GMT\r\n\r\n{s_simpleContent}");
+ HttpStatusCode.OK, $"Set-Cookie: {s_cookieName}=; Expires=Sun, 06 Nov 1994 08:49:37 GMT\r\n", s_simpleContent);
await TestHelper.WhenAllCompletedOrAnyFailed(getResponseTask, serverTask);
CookieCollection collection = handler.CookieContainer.GetCookies(url);
async server =>
{
List<string> request1Lines = await server.AcceptConnectionSendResponseAndCloseAsync(
- $"HTTP/1.1 302 Found\r\nContent-Length: 0\r\nLocation: {path2}\r\nSet-Cookie: A=1; Path=/\r\nConnection: close\r\n\r\n");
+ HttpStatusCode.Found, $"Location: {path2}\r\nSet-Cookie: A=1; Path=/\r\n");
Assert.Equal(0, request1Lines.Count(s => s.StartsWith("Cookie:")));
List<string> request2Lines = await server.AcceptConnectionSendResponseAndCloseAsync(
- $"HTTP/1.1 200 OK\r\nContent-Length: {s_simpleContent.Length}\r\nSet-Cookie: B=2; Path=/\r\n\r\n{s_simpleContent}");
+ HttpStatusCode.OK, $"Set-Cookie: B=2; Path=/\r\n", s_simpleContent);
Assert.Contains($"Cookie: A=1", request2Lines);
Assert.Equal(1, request2Lines.Count(s => s.StartsWith("Cookie:")));
{
await server.AcceptConnectionAsync(async connection =>
{
- List<string> request1Lines = await connection.ReadRequestHeaderAndSendResponseAsync($"HTTP/1.1 401 Unauthorized\r\nContent-Length: 0\r\nWWW-Authenticate: Basic realm=\"WallyWorld\"\r\nSet-Cookie: A=1; Path=/\r\n\r\n");
+ List<string> request1Lines = await connection.ReadRequestHeaderAndSendResponseAsync(
+ HttpStatusCode.Unauthorized,
+ $"WWW-Authenticate: Basic realm=\"WallyWorld\"\r\nSet-Cookie: A=1; Path=/\r\n");
Assert.Equal(0, request1Lines.Count(s => s.StartsWith("Cookie:")));
- List<string> request2Lines = await connection.ReadRequestHeaderAndSendResponseAsync($"HTTP/1.1 200 OK\r\nContent-Length: {s_simpleContent.Length}\r\nSet-Cookie: B=2; Path=/\r\n\r\n{s_simpleContent}");
+ List<string> request2Lines = await connection.ReadRequestHeaderAndSendResponseAsync(
+ HttpStatusCode.OK,
+ $"Set-Cookie: B=2; Path=/\r\n",
+ s_simpleContent);
Assert.Contains($"Cookie: A=1", request2Lines);
Assert.Equal(1, request2Lines.Count(s => s.StartsWith("Cookie:")));
request.Version = HttpVersion.Version10;
Task<HttpResponseMessage> getResponseTask = client.SendAsync(request);
- Task<List<string>> serverTask = server.AcceptConnectionSendDefaultResponseAndCloseAsync();
+ Task<List<string>> serverTask = server.AcceptConnectionSendResponseAndCloseAsync();
await TestHelper.WhenAllCompletedOrAnyFailed(getResponseTask, serverTask);
request.Version = HttpVersion.Version11;
Task<HttpResponseMessage> getResponseTask = client.SendAsync(request);
- Task<List<string>> serverTask = server.AcceptConnectionSendDefaultResponseAndCloseAsync();
+ Task<List<string>> serverTask = server.AcceptConnectionSendResponseAndCloseAsync();
await TestHelper.WhenAllCompletedOrAnyFailed(getResponseTask, serverTask);
request.Version = new Version(0, minorVersion);
Task<HttpResponseMessage> getResponseTask = client.SendAsync(request);
- Task<List<string>> serverTask = server.AcceptConnectionSendDefaultResponseAndCloseAsync();
+ Task<List<string>> serverTask = server.AcceptConnectionSendResponseAndCloseAsync();
if (exceptionType == null)
{
request.Version = new Version(majorVersion, minorVersion);
Task<HttpResponseMessage> getResponseTask = client.SendAsync(request);
- Task<List<string>> serverTask = server.AcceptConnectionSendDefaultResponseAndCloseAsync();
+ Task<List<string>> serverTask = server.AcceptConnectionSendResponseAndCloseAsync();
if (exceptionType == null)
{
Task<HttpResponseMessage> getResponseTask = client.SendAsync(request);
Task<List<string>> serverTask =
- server.AcceptConnectionSendResponseAndCloseAsync(
+ server.AcceptConnectionSendCustomResponseAndCloseAsync(
$"HTTP/1.{responseMinorVersion} 200 OK\r\nDate: {DateTimeOffset.UtcNow:R}\r\nContent-Length: 0\r\n\r\n");
await TestHelper.WhenAllCompletedOrAnyFailed(getResponseTask, serverTask);
Task<HttpResponseMessage> getResponseTask = client.SendAsync(request);
Task<List<string>> serverTask =
- server.AcceptConnectionSendResponseAndCloseAsync(
+ server.AcceptConnectionSendCustomResponseAndCloseAsync(
$"HTTP/1.{responseMinorVersion} 200 OK\r\nDate: {DateTimeOffset.UtcNow:R}\r\nContent-Length: 0\r\n\r\n");
await TestHelper.WhenAllCompletedOrAnyFailed(getResponseTask, serverTask);
Task<HttpResponseMessage> getResponseTask = client.SendAsync(request);
Task<List<string>> serverTask =
- server.AcceptConnectionSendResponseAndCloseAsync(
+ server.AcceptConnectionSendCustomResponseAndCloseAsync(
$"HTTP/0.{responseMinorVersion} 200 OK\r\nDate: {DateTimeOffset.UtcNow:R}\r\nContent-Length: 0\r\n\r\n");
if (reportAs10)
Task<HttpResponseMessage> getResponseTask = client.SendAsync(request);
Task<List<string>> serverTask =
- server.AcceptConnectionSendResponseAndCloseAsync(
+ server.AcceptConnectionSendCustomResponseAndCloseAsync(
$"HTTP/{responseMajorVersion}.{responseMinorVersion} 200 OK\r\nDate: {DateTimeOffset.UtcNow:R}\r\nContent-Length: 0\r\n\r\n");
if (reportAs00)
Task<HttpResponseMessage> getResponseTask = client.GetAsync(url);
await TestHelper.WhenAllCompletedOrAnyFailed(
getResponseTask,
- server.AcceptConnectionSendResponseAndCloseAsync(
+ server.AcceptConnectionSendCustomResponseAndCloseAsync(
$"{statusLine}\r\n" +
$"Date: {DateTimeOffset.UtcNow:R}\r\n" +
"Content-Length: 0\r\n" +
{
using (HttpClient client = CreateHttpClient())
{
- Task ignoredServerTask = server.AcceptConnectionSendResponseAndCloseAsync(
+ Task ignoredServerTask = server.AcceptConnectionSendCustomResponseAndCloseAsync(
responseString + "\r\nContent-Length: 0\r\n\r\n");
await Assert.ThrowsAsync<HttpRequestException>(() => client.GetAsync(url));
using (HttpClient client = CreateHttpClient())
{
Task<HttpResponseMessage> getResponseTask = client.GetAsync(url);
- Task<List<string>> serverTask = server.AcceptConnectionSendResponseAndCloseAsync(
+ Task<List<string>> serverTask = server.AcceptConnectionSendCustomResponseAndCloseAsync(
$"HTTP/1.1 200 OK{lineEnding}Date: {DateTimeOffset.UtcNow:R}{lineEnding}Server: TestServer{lineEnding}Content-Length: 0{lineEnding}{lineEnding}");
await TestHelper.WhenAllCompletedOrAnyFailed(getResponseTask, serverTask);
public class HttpRetryProtocolTests : HttpClientTestBase
{
private static readonly string s_simpleContent = "Hello World\r\n";
- private static readonly string s_simpleResponse =
- $"HTTP/1.1 200 OK\r\n" +
- $"Date: {DateTimeOffset.UtcNow:R}\r\n" +
- $"Content-Length: {s_simpleContent.Length}\r\n" +
- "\r\n" +
- s_simpleContent;
// Retry logic is supported by SocketsHttpHandler, CurlHandler, uap, and netfx. Only WinHttp does not support.
private bool IsRetrySupported => !IsWinHttpHandler;
await server.AcceptConnectionAsync(async connection =>
{
// Initial response
- await connection.ReadRequestHeaderAndSendResponseAsync(s_simpleResponse);
+ await connection.ReadRequestHeaderAndSendResponseAsync(content: s_simpleContent);
// Second response: Read request headers, then close connection
await connection.ReadRequestHeaderAsync();
});
// Client should reconnect. Accept that connection and send response.
- await server.AcceptConnectionSendResponseAndCloseAsync(s_simpleResponse);
+ await server.AcceptConnectionSendResponseAndCloseAsync(content: s_simpleContent);
});
}
await server.AcceptConnectionAsync(async connection =>
{
// Initial response
- await connection.ReadRequestHeaderAndSendResponseAsync(s_simpleResponse);
+ await connection.ReadRequestHeaderAndSendResponseAsync(content: s_simpleContent);
// Second response: Read request headers, then close connection
List<string> lines = await connection.ReadRequestHeaderAsync();
string contentLine = await connection.Reader.ReadLineAsync();
Assert.Equal(s_simpleContent, contentLine + "\r\n");
- await connection.Writer.WriteAsync(s_simpleResponse);
+ await connection.SendResponseAsync(content: s_simpleContent);
});
});
}
using (HttpClient client = new HttpClient(handler))
{
Task<HttpResponseMessage> getResponseTask = client.GetAsync(uri);
- Task<List<string>> serverTask = server.AcceptConnectionSendDefaultResponseAndCloseAsync();
+ Task<List<string>> serverTask = server.AcceptConnectionSendResponseAndCloseAsync();
await TestHelper.WhenAllCompletedOrAnyFailed(getResponseTask, serverTask);
request.Headers.Host = hostname;
request.Headers.Referrer = uri;
Task<HttpResponseMessage> getResponseTask = client.SendAsync(request);
- Task<List<string>> serverTask = server.AcceptConnectionSendDefaultResponseAndCloseAsync();
+ Task<List<string>> serverTask = server.AcceptConnectionSendResponseAndCloseAsync();
await TestHelper.WhenAllCompletedOrAnyFailed(getResponseTask, serverTask);
{
Task<HttpResponseMessage> getResponseTask = client.GetAsync(serverUrl);
Task<List<string>> serverTask = server.AcceptConnectionSendResponseAndCloseAsync(
- $"HTTP/1.1 302 Redirect\r\nLocation: http://{uri.IdnHost}/\r\n\r\n");
+ HttpStatusCode.Found, "Location: http://{uri.IdnHost}/\r\n");
await TestHelper.WhenAllCompletedOrAnyFailed(getResponseTask, serverTask);
Task<HttpResponseMessage> getResponseTask = client.GetAsync(url, HttpCompletionOption.ResponseHeadersRead);
await server.AcceptConnectionAsync(async connection =>
{
- Task<List<string>> serverTask = connection.ReadRequestHeaderAndSendResponseAsync($"HTTP/1.1 101 Switching Protocols\r\nDate: {DateTimeOffset.UtcNow:R}\r\n\r\n");
+ Task<List<string>> serverTask = connection.ReadRequestHeaderAndSendCustomResponseAsync($"HTTP/1.1 101 Switching Protocols\r\nDate: {DateTimeOffset.UtcNow:R}\r\n\r\n");
await TestHelper.WhenAllCompletedOrAnyFailed(getResponseTask, serverTask);
for (int i = 0; i < 2; i++)
{
Task<string> request = client.GetStringAsync(uri);
- await server.AcceptConnectionSendDefaultResponseAndCloseAsync();
+ await server.AcceptConnectionSendResponseAndCloseAsync();
await request;
if (i == 0)
Task<string> request1 = client.GetStringAsync(uri);
await server.AcceptConnectionAsync(async connection1 =>
{
- await connection1.ReadRequestHeaderAndSendResponseAsync(responseBody);
+ await connection1.ReadRequestHeaderAndSendCustomResponseAsync(responseBody);
await request1;
// Make second request and expect it to be served from a different connection.
Task<string> request2 = client.GetStringAsync(uri);
await server.AcceptConnectionAsync(async connection2 =>
{
- await connection2.ReadRequestHeaderAndSendResponseAsync(responseBody);
+ await connection2.ReadRequestHeaderAndSendCustomResponseAsync(responseBody);
await request2;
});
});
Task<string> request1 = client.GetStringAsync(uri);
await server.AcceptConnectionAsync(async connection =>
{
- await connection.ReadRequestHeaderAndSendDefaultResponseAsync();
+ await connection.ReadRequestHeaderAndSendResponseAsync();
await request1;
// Wait a small amount of time before making the second request, to give the first request time to timeout.
Task<string> request2 = client.GetStringAsync(uri);
await server.AcceptConnectionAsync(async connection2 =>
{
- await connection2.ReadRequestHeaderAndSendDefaultResponseAsync();
+ await connection2.ReadRequestHeaderAndSendResponseAsync();
await request2;
});
});
{
HttpWebRequest request = WebRequest.CreateHttp(uri);
Task<WebResponse> getResponse = request.GetResponseAsync();
- await server.AcceptConnectionSendDefaultResponseAndCloseAsync();
+ await server.AcceptConnectionSendResponseAndCloseAsync();
using (WebResponse response = await getResponse)
{
Assert.Throws<InvalidOperationException>(() => request.AutomaticDecompression = DecompressionMethods.Deflate);
request.ProtocolVersion = requestVersion;
Task<WebResponse> getResponse = request.GetResponseAsync();
- Task<List<string>> serverTask = server.AcceptConnectionSendDefaultResponseAndCloseAsync();
+ Task<List<string>> serverTask = server.AcceptConnectionSendResponseAndCloseAsync();
using (HttpWebResponse response = (HttpWebResponse) await getResponse)
{
request.ContinueDelegate = continueDelegate;
Task<WebResponse> getResponse = request.GetResponseAsync();
DateTimeOffset utcNow = DateTimeOffset.UtcNow;
- await server.AcceptConnectionSendResponseAndCloseAsync(
- $"HTTP/1.1 200 OK\r\n" +
- $"Date: {utcNow:R}\r\n" +
- "Content-Type: application/json;charset=UTF-8\r\n" +
- "Content-Length: 5\r\n" +
- "\r\n" +
- "12345");
+ await server.AcceptConnectionSendResponseAndCloseAsync(HttpStatusCode.OK, "Content-Type: application/json;charset=UTF-8\r\n", "12345");
Assert.Equal(continueDelegate, request.ContinueDelegate);
});
}
request.Method = HttpMethod.Get.Method;
Task<WebResponse> getResponse = request.GetResponseAsync();
DateTimeOffset utcNow = DateTimeOffset.UtcNow;
- await server.AcceptConnectionSendResponseAndCloseAsync(
- $"HTTP/1.1 200 OK\r\n" +
- $"Date: {utcNow:R}\r\n" +
- "Content-Type: application/json;charset=UTF-8\r\n" +
- "Content-Length: 5\r\n" +
- "\r\n" +
- "12345");
+ await server.AcceptConnectionSendResponseAndCloseAsync(HttpStatusCode.OK, "Content-Type: application/json;charset=UTF-8\r\n", "12345");
using (WebResponse response = await getResponse)
{
request.Method = HttpMethod.Get.Method;
Task<WebResponse> getResponse = request.GetResponseAsync();
DateTimeOffset utcNow = DateTimeOffset.UtcNow;
- await server.AcceptConnectionSendResponseAndCloseAsync(
- $"HTTP/1.1 200 OK\r\n" +
- $"Date: {utcNow:R}\r\n" +
- "Content-Type: application/json;charset=UTF-8\r\n" +
- "Content-Length: 5\r\n" +
- "\r\n" +
- "12345");
+ await server.AcceptConnectionSendResponseAndCloseAsync(HttpStatusCode.OK, "Content-Type: application/json;charset=UTF-8\r\n", "12345");
WebResponse response = await getResponse;
HttpWebResponse httpResponse = (HttpWebResponse)response;
httpResponse.Close();
request.Method = HttpMethod.Get.Method;
Task<WebResponse> getResponse = request.GetResponseAsync();
DateTimeOffset utcNow = DateTimeOffset.UtcNow;
- await server.AcceptConnectionSendResponseAndCloseAsync(
- $"HTTP/1.1 200 OK\r\n" +
- $"Date: {utcNow:R}\r\n" +
- "Content-Length: 0\r\n" +
- "\r\n");
+ await server.AcceptConnectionSendResponseAndCloseAsync();
using (WebResponse response = await getResponse)
{
HttpWebRequest request = WebRequest.CreateHttp(url);
request.Method = HttpMethod.Get.Method;
Task<WebResponse> getResponse = request.GetResponseAsync();
- await server.AcceptConnectionSendResponseAndCloseAsync(
- $"HTTP/1.1 200 OK\r\n" +
- $"Date: {DateTimeOffset.UtcNow:R}\r\n" +
- $"Content-Type: {expectedContentType}\r\n" +
- "Content-Length: 5\r\n" +
- "\r\n" +
- "12345");
+ await server.AcceptConnectionSendResponseAndCloseAsync(HttpStatusCode.OK, $"Content-Type: {expectedContentType}\r\n", "12345");
using (WebResponse response = await getResponse)
{
HttpWebRequest request = WebRequest.CreateHttp(url);
request.Method = HttpMethod.Get.Method;
Task<WebResponse> getResponse = request.GetResponseAsync();
- await server.AcceptConnectionSendResponseAndCloseAsync(
- $"HTTP/1.1 200 OK\r\n" +
- $"Date: {DateTimeOffset.UtcNow:R}\r\n" +
- "Content-Length: 5\r\n" +
- "\r\n" +
- "12345");
+ await server.AcceptConnectionSendResponseAndCloseAsync(content: "12345");
using (WebResponse response = await getResponse)
{
{
Task<string> download = wc.DownloadStringTaskAsync(url.ToString());
Assert.Null(wc.ResponseHeaders);
- await server.AcceptConnectionSendResponseAndCloseAsync(
- "HTTP/1.1 200 OK\r\n" +
- $"Date: {DateTimeOffset.UtcNow:R}\r\n" +
- $"Content-Length: 0\r\n" +
- "ArbitraryHeader: ArbitraryValue\r\n" +
- "\r\n");
+ await server.AcceptConnectionSendResponseAndCloseAsync(additionalHeaders: "ArbitraryHeader: ArbitraryValue\r\n");
await download;
});
{
Task<string> download = wc.DownloadStringTaskAsync(url.ToString());
Assert.Null(wc.ResponseHeaders);
- await server.AcceptConnectionSendDefaultResponseAndCloseAsync();
+ await server.AcceptConnectionSendResponseAndCloseAsync();
await download;
});
}
}
Task<string> download = DownloadStringAsync(wc, url.ToString());
- await server.AcceptConnectionSendResponseAndCloseAsync(
- "HTTP/1.1 200 OK\r\n" +
- $"Date: {DateTimeOffset.UtcNow:R}\r\n" +
- $"Content-Length: {ExpectedText.Length}\r\n" +
- "\r\n" +
- $"{ExpectedText}");
+ await server.AcceptConnectionSendResponseAndCloseAsync(content: ExpectedText);
Assert.Equal(ExpectedText, await download);
});
}
wc.DownloadProgressChanged += (s, e) => downloadProgressInvoked.TrySetResult(true);
Task<byte[]> download = DownloadDataAsync(wc, url.ToString());
- await server.AcceptConnectionSendResponseAndCloseAsync(
- "HTTP/1.1 200 OK\r\n" +
- $"Date: {DateTimeOffset.UtcNow:R}\r\n" +
- $"Content-Length: {ExpectedText.Length}\r\n" +
- "\r\n" +
- $"{ExpectedText}");
+ await server.AcceptConnectionSendResponseAndCloseAsync(content: ExpectedText);
Assert.Equal(ExpectedText, Encoding.ASCII.GetString(await download));
if (IsAsync)
};
Task<byte[]> download = DownloadDataAsync(wc, url.ToString());
- await server.AcceptConnectionSendResponseAndCloseAsync(
- "HTTP/1.1 200 OK\r\n" +
- $"Date: {DateTimeOffset.UtcNow:R}\r\n" +
- $"Content-Length: {largeText.Length}\r\n" +
- "\r\n" +
- $"{largeText}");
+ await server.AcceptConnectionSendResponseAndCloseAsync(content: largeText);
Assert.Equal(largeText, Encoding.ASCII.GetString(await download));
if (IsAsync)
{
var wc = new WebClient();
Task download = DownloadFileAsync(wc, url.ToString(), tempPath);
- await server.AcceptConnectionSendResponseAndCloseAsync(
- "HTTP/1.1 200 OK\r\n" +
- $"Date: {DateTimeOffset.UtcNow:R}\r\n" +
- $"Content-Length: {ExpectedText.Length}\r\n" +
- "\r\n" +
- $"{ExpectedText}");
+ await server.AcceptConnectionSendResponseAndCloseAsync(content: ExpectedText);
await download;
Assert.Equal(ExpectedText, File.ReadAllText(tempPath));
{
var wc = new WebClient();
Task<Stream> download = OpenReadAsync(wc, url.ToString());
- await server.AcceptConnectionSendResponseAndCloseAsync(
- "HTTP/1.1 200 OK\r\n" +
- $"Date: {DateTimeOffset.UtcNow:R}\r\n" +
- $"Content-Length: {ExpectedText.Length}\r\n" +
- "\r\n" +
- $"{ExpectedText}");
+ await server.AcceptConnectionSendResponseAndCloseAsync(content: ExpectedText);
using (var reader = new StreamReader(await download))
{
projects / platform / upstream / dotnet / runtime.git / commitdiff