142public override HttpRequest Request => _request;

26if (Context.Request.Headers.TryGetValue(ApiKeyHeaderName, out var apiKey))

342if (context.Request.Path.Equals(TargetLocationInterceptor.ResourcesPath, StringComparisons.UrlPath))

69context.Response.Headers.ContentSecurityPolicy = context.Request.IsHttps

29if (context.Request.Path.Equals("/login", StringComparisons.UrlPath)) 37else if (context.Request.Query.TryGetValue("t", out var value) && _options.CurrentValue.Frontend.AuthMode == FrontendAuthMode.BrowserToken) 50var qs = HttpUtility.ParseQueryString(context.Request.QueryString.ToString()); 59context.Response.Redirect($"{context.Request.Path}{newQuerystring}"); 71if (context.Request.Query.TryGetValue("returnUrl", out var returnUrl))

113switch (GetKnownContentType(context.Request.ContentType, out var charSet)) 148switch (GetKnownContentType(httpContext.Request.ContentType, out _)) 184result = await httpContext.Request.BodyReader.ReadAsync().ConfigureAwait(false); 205httpContext.Request.BodyReader.AdvanceTo(result.Buffer.Start, result.Buffer.End); 215httpContext.Request.BodyReader.AdvanceTo(result.Buffer.End);

31var wsScheme = context.Request.IsHttps ? "wss" : "ws"; 32var wsUrl = $"{wsScheme}://{context.Request.Host.Host}:{context.Request.Host.Port}{context.Request.Path}";

14logger.LogDebug("Received request: " + context.Request.Method + " " + context.Request.Path); 21await context.Response.WriteAsync("Scheme: " + context.Request.Scheme + Environment.NewLine); 22await context.Response.WriteAsync("Host: " + context.Request.Headers.Host + Environment.NewLine); 23await context.Response.WriteAsync("PathBase: " + context.Request.PathBase.Value + Environment.NewLine); 24await context.Response.WriteAsync("Path: " + context.Request.Path.Value + Environment.NewLine); 25await context.Response.WriteAsync("Query: " + context.Request.QueryString.Value + Environment.NewLine); 40foreach (var header in context.Request.Headers)

25logger.LogDebug("Received request: " + context.Request.Method + " " + context.Request.Path); 32await context.Response.WriteAsync("Scheme: " + context.Request.Scheme + Environment.NewLine); 33await context.Response.WriteAsync("Host: " + context.Request.Headers.Host + Environment.NewLine); 34await context.Response.WriteAsync("PathBase: " + context.Request.PathBase.Value + Environment.NewLine); 35await context.Response.WriteAsync("Path: " + context.Request.Path.Value + Environment.NewLine); 36await context.Response.WriteAsync("Query: " + context.Request.QueryString.Value + Environment.NewLine); 51foreach (var header in context.Request.Headers)

13if (context.HttpContext.Request.Query.TryGetValue("handleException", out var handleException))

24var requestId = context.Request.Headers.RequestId;

27var query = _actionContext.HttpContext.Request.Query; 43actualUrl = _actionContext.HttpContext.Request.Path.Value,

27httpContext.Request.Body = new RequestBodySizeCheckingStream( 28httpContext.Request.Body,

23context.Request.Body = new ThrowingStream();

67client.BaseAddress = new Uri($"{httpContext.Request.Scheme}://{httpContext.Request.Host}");

56while (await context.Request.Body.ReadAsync(buffer, 0, 8192) != 0) { }

38if (ctx.Request.Path.StartsWithSegments("/_framework/blazor.boot.json")) 42else if (applyCopHeaders && ctx.Request.Path.StartsWithSegments("/_framework") && !ctx.Request.Path.StartsWithSegments("/_framework/blazor.server.js") && !ctx.Request.Path.StartsWithSegments("/_framework/blazor.web.js")) 44var fileExtension = Path.GetExtension(ctx.Request.Path); 93if (context.Request.PathBase == pathBase)

49return context.Response.WriteAsync($"Hello {context.User.Identity.Name} at {context.Request.Host}"); 54return context.Response.WriteAsync($"Hello {context.User.Identity.Name} at {context.Request.Host}. Try /auth");

33ActionContext.HttpContext.Request.Headers["Test-Header"]);

19return _context.Request.Query["value"];

19options.CheckConsentNeeded = context => context.Request.PathBase.Equals("/NeedsConsent"); 39var path = context.Request.Path; 80var cookies = context.Request.Cookies; 84await response.WriteAsync($"<a href=\"{context.Request.PathBase}/\">Home</a><br>\r\n"); 85await response.WriteAsync($"<a href=\"{context.Request.PathBase}/Login\">Login</a><br>\r\n"); 86await response.WriteAsync($"<a href=\"{context.Request.PathBase}/Logout\">Logout</a><br>\r\n"); 87await response.WriteAsync($"<a href=\"{context.Request.PathBase}/CreateTempCookie\">Create Temp Cookie</a><br>\r\n"); 88await response.WriteAsync($"<a href=\"{context.Request.PathBase}/RemoveTempCookie\">Remove Temp Cookie</a><br>\r\n"); 89await response.WriteAsync($"<a href=\"{context.Request.PathBase}/CreateEssentialCookie\">Create Essential Cookie</a><br>\r\n"); 90await response.WriteAsync($"<a href=\"{context.Request.PathBase}/RemoveEssentialCookie\">Remove Essential Cookie</a><br>\r\n"); 91await response.WriteAsync($"<a href=\"{context.Request.PathBase}/GrantConsent\">Grant Consent</a><br>\r\n"); 92await response.WriteAsync($"<a href=\"{context.Request.PathBase}/WithdrawConsent\">Withdraw Consent</a><br>\r\n"); 94await response.WriteAsync($"<a href=\"/NeedsConsent{context.Request.Path}\">Needs Consent</a><br>\r\n"); 95await response.WriteAsync($"<a href=\"/NeedsNoConsent{context.Request.Path}\">Needs No Consent</a><br>\r\n");

28var path = context.Request.PathBase + context.Request.Path + context.Request.QueryString;

19await context.Response.WriteAsync($"Hello from {context.Request.GetDisplayUrl()}\r\n"); 23foreach (var header in context.Request.Headers)

19context.Request.RouteValues = new RouteValueDictionary(new

22var request = context.HttpContext.Request;

27var query = _actionContext.HttpContext.Request.Query; 43actualUrl = _actionContext.HttpContext.Request.Path.Value,

65foreach (var header in context.Request.Headers) 75var uri = UriHelper.BuildAbsolute(context.Request.Scheme, context.Request.Host, context.Request.PathBase, "/forwarded"); 91foreach (var header in context.Request.Headers)

46return context.Response.WriteAsync("Hello World! " + context.Request.Host);

39var toAdd = context.Request.Query["add"]; 54await context.Response.WriteAsync("<br><a href=\"" + context.Request.PathBase.ToUriComponent() + "\">back</a>"); 65var toRemove = context.Request.Query["remove"]; 78await context.Response.WriteAsync("<br><a href=\"" + context.Request.PathBase.ToUriComponent() + "\">back</a>"); 95await context.Response.WriteAsync("<form action=\"" + context.Request.PathBase.ToUriComponent() + "\" method=\"GET\">");

23return context.Response.WriteAsync("Hello World! " + context.Request.Protocol);

23var length = await context.Request.Body.ReadAsync(memory); 26await context.Response.WriteAsync($"Hello World! {context.Request.Protocol} {context.Connection.ClientCertificate?.Subject}");

13if (!logContext.HttpContext.Request.Path.StartsWithSegments("/api")) 41foreach (var header in logContext.HttpContext.Request.Headers) 85logContext.AddParameter(nameof(logContext.HttpContext.Request.Path), "RedactedPath");

21foreach (var header in context.Request.Headers) 25await context.Response.WriteAsync($"Method: {context.Request.Method}\r\n"); 26await context.Response.WriteAsync($"Scheme: {context.Request.Scheme}\r\n");

474await context.Request.Body.CopyToAsync(s); 481await context.Request.Body.CopyToAsync(context.Response.Body); 487while ((await context.Request.Body.ReadAsync(buffer)) != 0) 501await context.Request.Body.CopyToAsync(Stream.Null);

56if (httpContext.Request.Path.StartsWithSegments(_path, StringComparison.Ordinal))

115await ctx.Request.Body.ReadAsync(data); 196var task = ctx.Request.Body.ReadAsync(data, cancellationTokenSource.Token); 243await ctx.Request.Body.ReadAsync(data); 293var task = ctx.Request.Body.ReadAsync(data);

39ctx.Request.Body.Read(new byte[10]);

36await ctx.Request.Body.ReadAsync(new byte[2000]); 78await ctx.Request.Body.ReadAsync(new byte[2000]); 114await ctx.Request.Body.ReadAsync(new byte[2000]); 141await ctx.Request.Body.ReadAsync(new byte[2000]); 167await ctx.Request.Body.ReadAsync(new byte[2000]); 190await ctx.Request.Body.ReadAsync(new byte[2000]); 214await ctx.Request.Body.ReadAsync(new byte[2000]); 246Assert.Equal(1, await ctx.Request.Body.ReadAsync(buffer, 0, 1)); 284var num = await ctx.Request.Body.ReadAsync(new byte[2000]); 325async () => await ctx.Request.Body.ReadAsync(buffer, 0, 1)); 327async () => await ctx.Request.Body.ReadAsync(buffer, 0, 1));

78await ctx.Request.Body.ReadAsync(a);

26path = ctx.Request.Path.ToString();

39logger.LogDebug("Received request: " + context.Request.Method + " " + context.Request.Path); 46await context.Response.WriteAsync("Scheme: " + context.Request.Scheme + Environment.NewLine); 47await context.Response.WriteAsync("Host: " + context.Request.Headers["Host"] + Environment.NewLine); 48await context.Response.WriteAsync("PathBase: " + context.Request.PathBase.Value + Environment.NewLine); 49await context.Response.WriteAsync("Path: " + context.Request.Path.Value + Environment.NewLine); 50await context.Response.WriteAsync("Query: " + context.Request.QueryString.Value + Environment.NewLine); 67foreach (var header in context.Request.Headers)

166receivedHost = context.Request.Headers.Host; 214await context.Request.Body.ReadAsync(new byte[1], 0, 1); 390await using (var server = new TestServer(context => context.Request.Body.DrainAsync(default), new TestServiceContext(LoggerFactory, metrics: new KestrelMetrics(testMeterFactory)) { DiagnosticSource = diagListener })) 456await using (var server = new TestServer(context => context.Request.Body.DrainAsync(default), new TestServiceContext(LoggerFactory, metrics: new KestrelMetrics(testMeterFactory)) { DiagnosticSource = diagListener })) 531await using (var server = new TestServer(context => context.Request.Body.DrainAsync(default), new TestServiceContext(LoggerFactory, metrics: new KestrelMetrics(testMeterFactory)) { DiagnosticSource = diagListener }))

23var request = httpContext.Request; 40var request = httpContext.Request; 59var request = httpContext.Request; 177var request = httpContext.Request; 233var request = httpContext.Request; 361var request = httpContext.Request; 498while (await context.Request.Body.ReadAsync(buffer, 0, buffer.Length) != 0) 542while (await context.Request.Body.ReadAsync(buffer, 0, buffer.Length) != 0) 583var request = httpContext.Request; 664var request = httpContext.Request; 708var request = httpContext.Request; 863var readTask = httpContext.Request.Body.CopyToAsync(Stream.Null); 914var request = httpContext.Request; 921var requestTask = httpContext.Request.BodyReader.ReadAsync(); 923httpContext.Request.BodyReader.CancelPendingRead(); 970var request = httpContext.Request; 977httpContext.Request.BodyReader.Complete(); 1019var request = httpContext.Request; 1083var request = httpContext.Request; 1090httpContext.Request.BodyReader.Complete(new Exception());

89httpContext.Request.Protocol = "HTTP/2"; // Doesn't support chunking. This change should be ignored.

1168var read = await context.Request.Body.ReadAsync(new byte[10], 0, 10); 1387var readResult = await context.Request.BodyReader.ReadAsync(); 1390context.Request.BodyReader.AdvanceTo(readResult.Buffer.Start, readResult.Buffer.End); 1391readResult = await context.Request.BodyReader.ReadAsync(); 1394context.Request.BodyReader.AdvanceTo(readResult.Buffer.Start, readResult.Buffer.End); 1396readResult = await context.Request.BodyReader.ReadAsync(); 1401context.Request.BodyReader.AdvanceTo(readResult.Buffer.End); 5660var result = await context.Request.BodyReader.ReadAsync().DefaultTimeout(); 5663context.Request.BodyReader.AdvanceTo(result.Buffer.Start, result.Buffer.End);

279await c.Request.Body.FlushAsync(); 333await c.Request.Body.FlushAsync();

185Assert.True(HttpMethods.Equals(method, context.Request.Method)); 186Assert.True(context.Request.CanHaveBody()); 187Assert.Equal(11, context.Request.ContentLength); 188Assert.False(context.Request.Headers.ContainsKey(HeaderNames.TransferEncoding)); 189return context.Request.BodyReader.CopyToAsync(context.Response.BodyWriter); 236Assert.True(HttpMethods.Equals(method, context.Request.Method)); 237Assert.True(context.Request.CanHaveBody()); 238Assert.Null(context.Request.ContentLength); 239Assert.False(context.Request.Headers.ContainsKey(HeaderNames.TransferEncoding)); 240return context.Request.BodyReader.CopyToAsync(context.Response.BodyWriter); 360context.Response.Headers["path"] = context.Request.Path.Value; 361context.Response.Headers["query"] = context.Request.QueryString.Value; 406Assert.Equal(expected, context.Request.Path.Value); 479Assert.Equal(scheme, context.Request.Scheme); 480Assert.False(context.Request.Headers.ContainsKey(InternalHeaderNames.Scheme)); 878var read = await context.Request.Body.ReadAsync(buffer, 0, buffer.Length); 880read = await context.Request.Body.ReadAsync(buffer, 0, buffer.Length); 908var read = await context.Request.Body.ReadAsync(buffer, 0, buffer.Length); 910read = await context.Request.Body.ReadAsync(buffer, 0, buffer.Length); 956var read = await context.Request.Body.ReadAsync(buffer, 0, buffer.Length); 960read = await context.Request.Body.ReadAsync(buffer, total, buffer.Length - total); 998var readResult = await context.Request.BodyReader.ReadAsync(); 1001context.Request.BodyReader.AdvanceTo(readResult.Buffer.Start, readResult.Buffer.End); 1002readResult = await context.Request.BodyReader.ReadAsync(); 1006context.Request.BodyReader.AdvanceTo(readResult.Buffer.End); 1042var readResult = await context.Request.BodyReader.ReadAsync(); 1044context.Request.BodyReader.AdvanceTo(readResult.Buffer.End); 1050var read = await context.Request.Body.ReadAsync(buffer, 0, buffer.Length); 1054read = await context.Request.Body.ReadAsync(buffer, total, buffer.Length - total); 1151while (await context.Request.Body.ReadAsync(buffer, 0, buffer.Length) > 0) { } 1186while (await context.Request.Body.ReadAsync(buffer, 0, buffer.Length) > 0) { } 1221while (await context.Request.Body.ReadAsync(buffer, 0, buffer.Length) > 0) { } 1257while (await context.Request.Body.ReadAsync(buffer, 0, buffer.Length) > 0) { } 1281var readResult = await context.Request.BodyReader.ReadAsync(); 1284context.Request.BodyReader.AdvanceTo(readResult.Buffer.Start, readResult.Buffer.End); 1285readResult = await context.Request.BodyReader.ReadAsync(); 1289context.Request.BodyReader.AdvanceTo(readResult.Buffer.End); 1291readResult = await context.Request.BodyReader.ReadAsync(); 1867var read = await context.Request.Body.ReadAsync(buffer, 0, buffer.Length); 1869read = await context.Request.Body.ReadAsync(buffer, 0, buffer.Length); 1912while (await context.Request.Body.ReadAsync(buffer, 0, buffer.Length) > 0) { } 1953var read = await context.Request.Body.ReadAsync(buffer, 0, buffer.Length); 1955read = await context.Request.Body.ReadAsync(buffer, 0, buffer.Length); 1997while (await context.Request.Body.ReadAsync(buffer, 0, buffer.Length) > 0) { } 2058while (await context.Request.Body.ReadAsync(buffer, 0, buffer.Length) > 0) { } 2114var read = await context.Request.Body.ReadAsync(buffer, 0, buffer.Length); 2117read = await context.Request.Body.ReadAsync(buffer, 0, buffer.Length); 3251var readTask = context.Request.Body.ReadAsync(new byte[100], 0, 100).DefaultTimeout(); 3293var read = await context.Request.Body.ReadAsync(new byte[100], 0, 100).DefaultTimeout(); 3294var readTask = context.Request.Body.ReadAsync(new byte[100], 0, 100).DefaultTimeout(); 3429var thrownExTask = Assert.ThrowsAnyAsync<OperationCanceledException>(() => context.Request.Body.ReadAsync(buffer, 0, buffer.Length)); 3454var thrownExTask = Assert.ThrowsAnyAsync<OperationCanceledException>(() => context.Request.Body.ReadAsync(buffer, 0, buffer.Length)); 5527var requestBodyTask = context.Request.BodyReader.ReadAsync(); 5546await Assert.ThrowsAsync<ConnectionAbortedException>(async () => await context.Request.BodyReader.ReadAsync()); 5693var requestBodyTask = context.Request.BodyReader.ReadAsync(); 5714await Assert.ThrowsAsync<ConnectionAbortedException>(async () => await context.Request.BodyReader.ReadAsync()); 5782Assert.Equal("£", context.Request.Headers["X-Test"]); 5827Assert.Equal("£", context.Request.Headers["X-Test"]);

191_receivedRequestFields.Method = context.Request.Method; 192_receivedRequestFields.Scheme = context.Request.Scheme; 193_receivedRequestFields.Path = context.Request.Path.Value; 195_receivedRequestFields.Authority = context.Request.Host.Value; 196foreach (var header in context.Request.Headers) 206Assert.True(context.Request.SupportsTrailers(), "SupportsTrailers"); 207Assert.False(context.Request.CheckTrailersAvailable(), "SupportsTrailers"); 212await context.Request.Body.CopyToAsync(ms); 215Assert.True(context.Request.SupportsTrailers(), "SupportsTrailers"); 216Assert.True(context.Request.CheckTrailersAvailable(), "SupportsTrailers"); 218_receivedRequestFields.Method = context.Request.Method; 219_receivedRequestFields.Scheme = context.Request.Scheme; 220_receivedRequestFields.Path = context.Request.Path.Value; 222foreach (var header in context.Request.Headers) 241while ((received = await context.Request.Body.ReadAsync(buffer, 0, buffer.Length)) > 0) 254while ((received = await context.Request.Body.ReadAsync(buffer, 0, buffer.Length)) > 0) 265while ((received = await context.Request.Body.ReadAsync(buffer, 0, buffer.Length)) > 0) 334var expectedBytes = int.Parse(context.Request.Path.Value.Substring(1), CultureInfo.InvariantCulture); 341received += await context.Request.Body.ReadAsync(buffer, 0, buffer.Length); 344var stalledReadTask = context.Request.Body.ReadAsync(buffer, 0, buffer.Length); 354Assert.False(context.Request.CanHaveBody()); 355Assert.False(context.Request.Headers.ContainsKey(InternalHeaderNames.Method)); 356context.Response.Headers["Method"] = context.Request.Method; 363Assert.False(context.Request.Headers.ContainsKey(InternalHeaderNames.Authority)); 364context.Response.Headers.Host = context.Request.Headers.Host; 371Assert.False(context.Request.Headers.ContainsKey(InternalHeaderNames.Path)); 372context.Response.Headers["path"] = context.Request.Path.ToString();

337while ((received = await context.Request.Body.ReadAsync(buffer, 0, buffer.Length)) > 0)

24Assert.Equal(HttpMethods.Connect, context.Request.Method); 26Assert.False(context.Request.Headers.TryGetValue(":protocol", out var _)); 27Assert.Equal("http", context.Request.Scheme); 28Assert.Equal("/chat", context.Request.Path.Value); 29Assert.Equal("server.example.com", context.Request.Host.Value); 30Assert.Equal("chat, superchat", context.Request.Headers.WebSocketSubProtocols); 31Assert.Equal("permessage-deflate", context.Request.Headers.SecWebSocketExtensions); 32Assert.Equal("13", context.Request.Headers.SecWebSocketVersion); 33Assert.Equal("http://www.example.com", context.Request.Headers.Origin); 35Assert.Equal(0, await context.Request.Body.ReadAsync(new byte[1])); 86Assert.Equal(HttpMethods.Connect, context.Request.Method); 88Assert.False(context.Request.Headers.TryGetValue(":protocol", out var _)); 89Assert.Equal("http", context.Request.Scheme); 90Assert.Equal("/chat", context.Request.Path.Value); 91Assert.Equal("server.example.com", context.Request.Host.Value); 92Assert.Equal("chat, superchat", context.Request.Headers.WebSocketSubProtocols); 93Assert.Equal("permessage-deflate", context.Request.Headers.SecWebSocketExtensions); 94Assert.Equal("13", context.Request.Headers.SecWebSocketVersion); 95Assert.Equal("http://www.example.com", context.Request.Headers.Origin); 97Assert.Equal(0, await context.Request.Body.ReadAsync(new byte[1])); 162Assert.Equal(HttpMethods.Connect, context.Request.Method); 164Assert.False(context.Request.Headers.TryGetValue(":protocol", out var _)); 165Assert.Equal("http", context.Request.Scheme); 166Assert.Equal("/chat", context.Request.Path.Value); 167Assert.Equal("server.example.com", context.Request.Host.Value); 168Assert.Equal("chat, superchat", context.Request.Headers.WebSocketSubProtocols); 169Assert.Equal("permessage-deflate", context.Request.Headers.SecWebSocketExtensions); 170Assert.Equal("13", context.Request.Headers.SecWebSocketVersion); 171Assert.Equal("http://www.example.com", context.Request.Headers.Origin); 173Assert.Equal(0, await context.Request.Body.ReadAsync(new byte[1])); 455Assert.Equal(0, await context.Request.Body.ReadAsync(new byte[1])); 464Assert.Equal(0, await context.Request.Body.ReadAsync(new byte[1])); 601Assert.Equal(HttpMethods.Connect, context.Request.Method);

47return context.Response.WriteAsync("hello world " + context.Request.Protocol);

44while ((received = await context.Request.Body.ReadAsync(buffer, 0, buffer.Length)) > 0) 84while ((received = await context.Request.Body.ReadAsync(buffer, 0, buffer.Length)) > 0) 145receivedHeaders = context.Request.Headers[HeaderNames.Cookie]; 147while ((received = await context.Request.Body.ReadAsync(buffer, 0, buffer.Length)) > 0) 426contentType = context.Request.ContentType; 427authority = context.Request.Host.Value;

208context.Response.Headers["path"] = context.Request.Path.Value; 209context.Response.Headers["query"] = context.Request.QueryString.Value; 243Assert.Equal(expected, context.Request.Path.Value); 303Assert.Equal(scheme, context.Request.Scheme); 559var read = await context.Request.Body.ReadAsync(buffer, 0, buffer.Length); 561read = await context.Request.Body.ReadAsync(buffer, 0, buffer.Length); 588var read = await context.Request.Body.ReadAsync(buffer, 0, buffer.Length); 592read = await context.Request.Body.ReadAsync(buffer, total, buffer.Length - total); 622var readResult = await context.Request.BodyReader.ReadAsync(); 625context.Request.BodyReader.AdvanceTo(readResult.Buffer.Start, readResult.Buffer.End); 626readResult = await context.Request.BodyReader.ReadAsync(); 630context.Request.BodyReader.AdvanceTo(readResult.Buffer.End); 1769var requestBodyTask = context.Request.BodyReader.ReadAsync(); 1788await Assert.ThrowsAsync<ConnectionAbortedException>(async () => await context.Request.BodyReader.ReadAsync()); 1896var requestBodyTask = context.Request.BodyReader.ReadAsync(); 1917await Assert.ThrowsAsync<ConnectionAbortedException>(async () => await context.Request.BodyReader.ReadAsync()); 1983await c.Request.Body.DrainAsync(default); 1985testValue = c.Request.GetTrailer("TestName"); 2057await c.Request.Body.ReadAsync(data); 2063c.Request.GetTrailer("TestName"); 2508var read = await context.Request.Body.ReadAsync(buffer, 0, buffer.Length); 2510read = await context.Request.Body.ReadAsync(buffer, 0, buffer.Length); 2546while (await context.Request.Body.ReadAsync(buffer, 0, buffer.Length) > 0) { } 2581var read = await context.Request.Body.ReadAsync(buffer, 0, buffer.Length); 2583read = await context.Request.Body.ReadAsync(buffer, 0, buffer.Length); 2618while (await context.Request.Body.ReadAsync(buffer, 0, buffer.Length) > 0) { } 2671while (await context.Request.Body.ReadAsync(buffer, 0, buffer.Length) > 0) { } 2719var read = await context.Request.Body.ReadAsync(buffer, 0, buffer.Length); 2722read = await context.Request.Body.ReadAsync(buffer, 0, buffer.Length); 2834readCount += await context.Request.Body.ReadAsync(buffer.AsMemory(readCount, 100 - readCount));

68while ((received = await context.Request.Body.ReadAsync(buffer, 0, buffer.Length)) > 0) 76var expectedBytes = int.Parse(context.Request.Path.Value.Substring(1), CultureInfo.InvariantCulture); 83received += await context.Request.Body.ReadAsync(buffer, 0, buffer.Length); 86var stalledReadTask = context.Request.Body.ReadAsync(buffer, 0, buffer.Length); 96context.Response.Headers["Method"] = context.Request.Method; 103context.Response.Headers["path"] = context.Request.Path.ToString(); 111context.Response.Headers.Host = context.Request.Headers.Host;

434while ((received = await context.Request.Body.ReadAsync(buffer, 0, buffer.Length)) > 0)

1035var body = await new StreamReader(context.Request.Body).ReadToEndAsync(); 1118await using (var server = new TestServer(context => context.Response.WriteAsync(context.Request.Scheme), new TestServiceContext(LoggerFactory), ConfigureListenOptions)) 1486var request = httpContext.Request;

266if (httpContext.Request.Path == "/longrunning") 270else if (httpContext.Request.Path == "/upgrade") 279else if (httpContext.Request.Path == "/consume") 282while (await httpContext.Request.Body.ReadAsync(buffer, 0, buffer.Length) > 0)

174var result = await context.Request.BodyReader.ReadAsync(); 407await c.Request.Body.ReadUntilEndAsync(); 921var request = httpContext.Request; 923var buffer = new byte[httpContext.Request.ContentLength ?? 0];

33Assert.True(context.Request.CanHaveBody()); 38async () => await context.Request.Body.ReadAsync(buffer, 0, 1)); 79using (var stream = new StreamReader(context.Request.Body)) 126using (var stream = new StreamReader(context.Request.Body)) 181async () => await context.Request.Body.ReadAsync(buffer, 0, 1)); 221Assert.Equal(1, await context.Request.Body.ReadAsync(buffer, 0, 1)); 223Assert.Equal(0, await context.Request.Body.ReadAsync(buffer, 0, 1)); 251await using (var server = new TestServer(context => context.Request.Body.CopyToAsync(Stream.Null), 291Assert.Equal(1, await context.Request.Body.ReadAsync(buffer, 0, 1)); 378async () => await context.Request.Body.ReadAsync(buffer, 0, 1)); 380async () => await context.Request.Body.ReadAsync(buffer, 0, 1)); 431count = await context.Request.Body.ReadAsync(buffer, 0, 11); 476count = await context.Request.Body.ReadAsync(buffer, offset, 11 - offset); 481Assert.Equal("trailing-value", context.Request.GetTrailer("Trailing-Header").ToString()); 528count = await context.Request.Body.ReadAsync(buffer, 0, 11); 539count = await context.Request.Body.ReadAsync(buffer, 0, 11); 591async () => await context.Request.Body.ReadAsync(buffer, 0, 1)); 593async () => await context.Request.Body.ReadAsync(buffer, 0, 1));

58var readTask = context.Request.Body.ReadAsync(new byte[1], 0, 1); 168var readTask = context.Request.Body.ReadAsync(new byte[1], 0, 1);

160await httpContext.Request.Body.ReadAsync(new byte[1], 0, 1);

24Assert.Equal("/\u0041\u030A/B/\u0041\u030A", context.Request.Path.Value); 102Assert.Empty(context.Request.Path.Value); 103Assert.Empty(context.Request.PathBase.Value); 104Assert.Empty(context.Request.QueryString.Value);

32if (context.Request.Body is MemoryStream) 42context.Request.Body = new MemoryStream(); 95context.Request.Body = mockStream.Object; 96var data = await context.Request.BodyReader.ReadAsync(); 121await context.Request.Body.FillEntireBufferAsync(data, cts.Token).DefaultTimeout(); 135var task = context.Request.Body.ReadAsync(data, 0, data.Length, cts.Token); 237pathTcs.TrySetResult(context.Request.Path); 238queryTcs.TrySetResult(context.Request.Query); 925Assert.Equal(0, await httpContext.Request.Body.ReadAsync(new byte[1], 0, 1).DefaultTimeout()); 970var readResult = await httpContext.Request.BodyReader.ReadAsync().AsTask().DefaultTimeout(); 1017var readResult = await httpContext.Request.BodyReader.ReadAsync(); 1020httpContext.Request.BodyReader.AdvanceTo(readResult.Buffer.End); 1049var readResult = await httpContext.Request.BodyReader.ReadAsync(); 1052httpContext.Request.BodyReader.AdvanceTo(readResult.Buffer.Start, readResult.Buffer.End); 1053readResult = await httpContext.Request.BodyReader.ReadAsync(); 1055httpContext.Request.BodyReader.AdvanceTo(readResult.Buffer.Start, readResult.Buffer.End); 1084var readResult = await httpContext.Request.BodyReader.ReadAsync(); 1087httpContext.Request.BodyReader.AdvanceTo(readResult.Buffer.Start, readResult.Buffer.End); 1091readResult = await httpContext.Request.BodyReader.ReadAsync(); 1093httpContext.Request.BodyReader.AdvanceTo(readResult.Buffer.Start, readResult.Buffer.End); 1127await httpContext.Request.BodyReader.CopyToAsync(ms1); 1128await httpContext.Request.BodyReader.CopyToAsync(ms2); 1184var readResult = await ReadAtLeastAsync(httpContext.Request.BodyReader, numBytes: 3); 1188httpContext.Request.BodyReader.AdvanceTo(readResult.Buffer.Start, readResult.Buffer.End); 1191readResult = await httpContext.Request.BodyReader.ReadAsync(); 1192httpContext.Request.BodyReader.AdvanceTo(readResult.Buffer.Start, readResult.Buffer.End); 1196readResult = await httpContext.Request.BodyReader.ReadAsync(); 1200httpContext.Request.BodyReader.AdvanceTo(readResult.Buffer.Start, readResult.Buffer.End); 1201readResult = await httpContext.Request.BodyReader.ReadAsync(); 1238var readResult = await httpContext.Request.BodyReader.ReadAsync(); 1240httpContext.Request.BodyReader.AdvanceTo(readResult.Buffer.Start, readResult.Buffer.End); 1242readResult = await httpContext.Request.BodyReader.ReadAsync(); 1243httpContext.Request.BodyReader.AdvanceTo(readResult.Buffer.Slice(1).Start, readResult.Buffer.End); 1398if (context.Request.Body != lastStream) 1400lastStream = context.Request.Body; 1403if (context.Request.Headers != lastRequestHeaders) 1405lastRequestHeaders = context.Request.Headers; 1415await context.Request.Body.CopyToAsync(ms); 1698var ioEx = Assert.Throws<InvalidOperationException>(() => context.Request.Body.Read(new byte[1], 0, 1)); 1701var ioEx2 = Assert.Throws<InvalidOperationException>(() => context.Request.Body.CopyTo(Stream.Null)); 1706offset += await context.Request.Body.ReadAsync(buffer, offset, 5 - offset); 1709Assert.Equal(0, await context.Request.Body.ReadAsync(new byte[1], 0, 1)); 1749offset += context.Request.Body.Read(buffer, offset, 5 - offset); 1752Assert.Equal(0, await context.Request.Body.ReadAsync(new byte[1], 0, 1)); 1791var ioEx = Assert.Throws<InvalidOperationException>(() => context.Request.Body.Read(new byte[1], 0, 1)); 1794var ioEx2 = Assert.Throws<InvalidOperationException>(() => context.Request.Body.CopyTo(Stream.Null)); 1798var length = await context.Request.Body.FillBufferUntilEndAsync(buffer).DefaultTimeout(); 1839offset += context.Request.Body.Read(buffer, offset, 5 - offset); 1842Assert.Equal(0, await context.Request.Body.ReadAsync(new byte[1], 0, 1)); 1873await httpContext.Request.Body.ReadAsync(new byte[1], 0, 1); 1906var request = httpContext.Request; 1913var requestTask = httpContext.Request.BodyReader.ReadAsync(); 1915httpContext.Request.BodyReader.CancelPendingRead(); 1956var request = httpContext.Request; 1963httpContext.Request.BodyReader.Complete(); 2000var request = httpContext.Request; 2005httpContext.Request.BodyReader.Complete(); 2041var request = httpContext.Request; 2048httpContext.Request.BodyReader.Complete(new Exception()); 2084customHeaderValue = context.Request.Headers["X-CustomHeader"]; 2085contentTypeHeaderValue = context.Request.ContentType; 2201Assert.Equal("£", context.Request.Headers["X-Test"]); 2294Assert.Equal("£", context.Request.Headers["X-Test"]);

344await context.Request.Body.ReadAsync(new byte[1], 0, 1); 361await context.Request.Body.ReadAsync(new byte[1], 0, 1); 487async () => await httpContext.Request.Body.ReadAsync(new byte[1], 0, 1)); 1541await httpContext.Request.Body.ReadAsync(new byte[1], 0, 1); 2039return httpContext.Request.Body.ReadAsync(new byte[1], 0, 1); 2109return httpContext.Request.Body.ReadAsync(new byte[1], 0, 1); 2155await httpContext.Request.Body.ReadAsync(new byte[1], 0, 1); 2260Assert.Equal(0, await httpContext.Request.Body.ReadAsync(new byte[1], 0, 1).DefaultTimeout()); 2327var request = httpContext.Request; 2376var request = httpContext.Request;

16var request = httpContext.Request; 18var buffer = new byte[httpContext.Request.ContentLength ?? 0]; 29var request = httpContext.Request; 46var request = httpContext.Request; 48var buffer = new byte[httpContext.Request.ContentLength ?? 0]; 63var request = httpContext.Request;

77var read = await context.Request.Body.ReadAsync(buffer, 0, 128).DefaultTimeout(); 165if (HttpMethods.IsPost(context.Request.Method)) 168Assert.Equal(1, context.Request.ContentLength); 169Assert.Equal(1, await context.Request.Body.ReadAsync(new byte[10], 0, 10)); 200if (HttpMethods.IsPost(context.Request.Method)) 202Assert.Equal(0, context.Request.ContentLength); 204Assert.Equal(0, await context.Request.Body.ReadAsync(new byte[10], 0, 10)); 234Assert.Null(context.Request.ContentLength); 236if (HttpMethods.IsPost(context.Request.Method)) 239Assert.Equal("chunked", context.Request.Headers.TransferEncoding); 241var length = await context.Request.Body.FillBufferUntilEndAsync(new byte[100]);

112await ctx.Response.WriteAsync(ctx.Request.Protocol); 217await ctx.Response.WriteAsync(Environment.GetEnvironmentVariable(ctx.Request.Query["name"].ToString())); 222var varName = ctx.Request.Query["q"]; 223var newValue = ctx.Request.Query["v"]; 268return ctx.Response.WriteAsync($"PathBase: {ctx.Request.PathBase.Value}; Path: {ctx.Request.Path.Value}"); 275Assert.Equal("GET", ctx.Request.Method); 276ctx.Request.Method = "test"; 277Assert.Equal("test", ctx.Request.Method); 279Assert.Equal("http", ctx.Request.Scheme); 280ctx.Request.Scheme = "test"; 281Assert.Equal("test", ctx.Request.Scheme); 283Assert.Equal("/FeatureCollectionSetRequestFeatures", ctx.Request.PathBase); 284ctx.Request.PathBase = "/base"; 285Assert.Equal("/base", ctx.Request.PathBase); 287Assert.Equal("/path", ctx.Request.Path); 288ctx.Request.Path = "/path"; 289Assert.Equal("/path", ctx.Request.Path); 291Assert.Equal("?query", ctx.Request.QueryString.Value); 292ctx.Request.QueryString = QueryString.Empty; 293Assert.Equal("", ctx.Request.QueryString.Value); 295Assert.Equal("HTTP/1.1", ctx.Request.Protocol); 296ctx.Request.Protocol = "HTTP/1.0"; 297Assert.Equal("HTTP/1.0", ctx.Request.Protocol); 299Assert.NotNull(ctx.Request.Headers); 304Assert.NotNull(ctx.Request.Body); 306ctx.Request.Body = body; 307Assert.Same(body, ctx.Request.Body); 392feature.ReasonPhrase = ctx.Request.Query["reason"]; 393feature.StatusCode = int.Parse(ctx.Request.Query["code"], CultureInfo.InvariantCulture); 394if (ctx.Request.Query["writeBody"] == "True") 396await ctx.Response.WriteAsync(ctx.Request.Query["body"]); 402if (ctx.Request.Path.Value.StartsWith("/Path", StringComparison.Ordinal)) 404await ctx.Response.WriteAsync(ctx.Request.Path.Value); 407if (ctx.Request.Path.Value.StartsWith("/Query", StringComparison.Ordinal)) 409await ctx.Response.WriteAsync(ctx.Request.QueryString.Value); 418if (int.TryParse(ctx.Request.Query["length"], out var length)) 467if ((string[])ctx.Request.Headers[headerName] != Array.Empty<string>()) 471if (ctx.Request.Headers.TryGetValue(headerName, out var headerValue) || (string[])headerValue is not null) 478ctx.Request.Headers.Add(headerName, "test"); 479ctx.Request.Headers[headerName] = default; 480ctx.Request.Headers.Add(headerName, "test"); 481ctx.Request.Headers[headerName] = StringValues.Empty; 482ctx.Request.Headers.Add(headerName, "test"); 487ctx.Request.Headers.Add(headerName, "test"); 492ctx.Request.Headers[headerName] = default; 519if (ctx.Request.Path.Equals("/SetStatusCodeAfterWrite")) 533else if (ctx.Request.Path.Equals("/SetHeaderAfterWrite")) 562var result = await ctx.Request.Body.ReadAsync(readBuffer, 0, 1); 565result = await ctx.Request.Body.ReadAsync(readBuffer, 0, 1); 575var result = await ctx.Request.Body.ReadAsync(readBuffer, 0, 4096); 578result = await ctx.Request.Body.ReadAsync(readBuffer, 0, 4096); 589await ctx.Request.Body.ReadAsync(readBuffer, 0, 1); 631var result = await ctx.Request.Body.ReadAsync(readBuffer, 0, readBuffer.Length); 635result = await ctx.Request.Body.ReadAsync(readBuffer, 0, readBuffer.Length); 644var result = await ctx.Request.Body.ReadAsync(readBuffer, 0, readBuffer.Length); 649result = await ctx.Request.Body.ReadAsync(readBuffer, 0, readBuffer.Length); 658if (ctx.Request.Headers.TryGetValue("Response-Content-Type", out var contentType)) 666var reader = new StreamReader(ctx.Request.Body); 690if (ctx.Request.Headers.TryGetValue("Response-Content-Type", out var contentType)) 698var reader = new StreamReader(ctx.Request.Body); 719count += await ctx.Request.Body.ReadAsync(data, count, data.Length - count); 726using (var reader = new StreamReader(ctx.Request.Body)) 737var result = await ctx.Request.Body.ReadAsync(readBuffer, 0, readBuffer.Length); 744result = await ctx.Request.Body.ReadAsync(readBuffer, 0, readBuffer.Length); 768await ctx.Request.Body.CopyToAsync(ctx.Response.Body); 774await ctx.Request.Body.ReadAsync(buffer, 0, 6); 775await ctx.Request.Body.ReadAsync(buffer, 6, 5); 783if (ctx.Request.Path.StartsWithSegments("/NullBuffer")) 787await ctx.Request.Body.ReadAsync(null, 0, 0); 794else if (ctx.Request.Path.StartsWithSegments("/InvalidOffsetSmall")) 798await ctx.Request.Body.ReadAsync(new byte[1], -1, 0); 805else if (ctx.Request.Path.StartsWithSegments("/InvalidOffsetLarge")) 809await ctx.Request.Body.ReadAsync(new byte[1], 2, 0); 816else if (ctx.Request.Path.StartsWithSegments("/InvalidCountSmall")) 820await ctx.Request.Body.ReadAsync(new byte[1], 0, -1); 827else if (ctx.Request.Path.StartsWithSegments("/InvalidCountLarge")) 831await ctx.Request.Body.ReadAsync(new byte[1], 0, -1); 838else if (ctx.Request.Path.StartsWithSegments("/InvalidCountWithOffset")) 842await ctx.Request.Body.ReadAsync(new byte[3], 1, 3); 857if (ctx.Request.Path.StartsWithSegments("/NullBuffer")) 859count = await ctx.Request.Body.ReadAsync(null, 0, 0); 861else if (ctx.Request.Path.StartsWithSegments("/NullBufferPost")) 863count = await ctx.Request.Body.ReadAsync(null, 0, 0); 865else if (ctx.Request.Path.StartsWithSegments("/InvalidCountZeroRead")) 867count = await ctx.Request.Body.ReadAsync(new byte[1], 0, 0); 869else if (ctx.Request.Path.StartsWithSegments("/InvalidCountZeroReadPost")) 871count = await ctx.Request.Body.ReadAsync(new byte[1], 0, 0); 881if (ctx.Request.Path.StartsWithSegments("/InvalidOffsetSmall")) 892else if (ctx.Request.Path.StartsWithSegments("/InvalidOffsetLarge")) 903else if (ctx.Request.Path.StartsWithSegments("/InvalidCountSmall")) 914else if (ctx.Request.Path.StartsWithSegments("/InvalidCountLarge")) 925else if (ctx.Request.Path.StartsWithSegments("/InvalidCountWithOffset")) 942if (ctx.Request.Path.StartsWithSegments("/NullBuffer")) 946else if (ctx.Request.Path.StartsWithSegments("/NullBufferPost")) 987ctx.Request.Headers.ContentLength = ctx.Request.Path.Value.Length; 988return ctx.Response.WriteAsync(ctx.Request.Path.Value); 1067ctx.Response.WriteAsync("Scheme:" + ctx.Request.Scheme + "; Original:" + ctx.Request.Headers["x-original-proto"]); 1069public Task Path(HttpContext ctx) => ctx.Response.WriteAsync(ctx.Request.Path.Value); 1071public Task Query(HttpContext ctx) => ctx.Response.WriteAsync(ctx.Request.QueryString.Value); 1114File.Delete(context.Request.Headers["ANCMRHPath"]); 1122return context.Response.WriteAsync(context.Request.Headers["ANCMRHPath"]); 1146var value = context.Request.Headers["foo"]; 1153var value = context.Request.Headers["foo"]; 1165Assert.True(ctx.Request.Headers.ContainsKey("Transfer-Encoding")); 1166Assert.Equal("gzip, chunked", ctx.Request.Headers["Transfer-Encoding"]); 1183Assert.True(ctx.Request.Headers.ContainsKey("Transfer-Encoding")); 1184Assert.Equal("gzip, chunked", ctx.Request.Headers["Transfer-Encoding"]); 1185Assert.False(ctx.Request.Headers.ContainsKey("Content-Length")); 1186Assert.True(ctx.Request.Headers.ContainsKey("X-Content-Length")); 1187Assert.Equal("5", ctx.Request.Headers["X-Content-Length"]);

49Assert.Equal(0, await context.Request.Body.ReadAsync(singleByteArray, 0, 1)); 114string key = context.Request.Headers[Constants.Headers.SecWebSocketKey].ToString();

52if (context.Request.Path.StartsWithSegments(requestDelegate.Key, out var matchedPath, out var remainingPath)) 54var pathBase = context.Request.PathBase; 55context.Request.PathBase = pathBase.Add(matchedPath); 56context.Request.Path = remainingPath;

152await context.Request.Body.CopyToAsync(Stream.Null);

61Assert.Equal(expectedVersion, context.Request.Protocol);

328contentType = context.Request.ContentType; 329authority = context.Request.Host.Value; 331var data = await context.Request.Body.ReadUntilEndAsync(); 403var body = context.Request.Body; 466var body = context.Request.Body; 549readAsyncTask.SetResult(context.Request.Body.ReadAsync(new byte[1024]).AsTask()); 710var body = context.Request.Body; 893requestHeaders.Add(context.Request.Headers.ToDictionary(k => k.Key, k => k.Value, StringComparer.OrdinalIgnoreCase)); 982var requestBody = context.Request.Body; 1075var requestBody = context.Request.Body; 1173var requestBody = context.Request.Body; 1353await context.Request.BodyReader.ReadAtLeastAsync(TestData.Length); 1468request1HeaderValue = context.Request.Headers.UserAgent; 1472request2HeaderValue = context.Request.Headers.UserAgent; 1756switch (context.Request.Path.ToString()) 2005var readTask = context.Request.Body.ReadUntilEndAsync(); 2116var data = await context.Request.Body.ReadUntilEndAsync();

81await context.Request.BodyReader.CopyToAsync(context.Response.BodyWriter).DefaultTimeout(); 167await context.Request.BodyReader.CopyToAsync(context.Response.BodyWriter).DefaultTimeout(); 269var reader = context.Request.BodyReader; 328var reader = context.Request.BodyReader; 416using var streamReader = new StreamReader(context.Request.Body); 715using var streamReader = new StreamReader(context.Request.Body); 763var count = await context.Request.Body.ReadAsync(new byte[11], 0, 11); 774using var streamReader = new StreamReader(context.Request.Body); 823var readTask = context.Request.Body.ReadAsync(new byte[11], 0, 11); 869await ReadStreamHelloWorld(context.Request.Body); 870var readTask = context.Request.Body.ReadAsync(new byte[11], 0, 11); 1039Assert.Equal(oneKbString + i, context.Request.Headers["header" + i]); 1148Assert.Equal(oneKbString + i, context.Request.Headers["header" + i]); 1505read = await context.Request.Body.ReadAsync(buffer, 0, buffer.Length).DefaultTimeout(); 1558Assert.Equal("點.看", context.Request.Host.Host); 1559return context.Response.WriteAsync(context.Request.Host.Host); 1583.Configure(app => app.Run(context => context.Response.WriteAsync(context.Request.Path.Value)));

137var encoding = context.GetHttpContext().Request.Headers.SingleOrDefault(h => string.Equals(h.Key, "grpc-encoding", StringComparison.OrdinalIgnoreCase)).Value.SingleOrDefault();

73if (HttpMethods.IsPost(context.Request.Method)) 75var reader = new StreamReader(context.Request.Body);

79var claims = new[] { new Claim(ClaimTypes.NameIdentifier, httpContext.Request.Query["user"]) };

61if (!_context.Request.Body.CanSeek) 63_context.Request.EnableBuffering(); 66var body = _context.Request.Body;

25var path = context.Request.Path;

34if (context.Request.Path.Value.EndsWith("favicon.ico", StringComparison.Ordinal))

25var method = context.Request.Method;

94var method = httpContext.Request.Method; 163else if (!httpContext.Request.HasFormContentType) 258if (_options.Cookie.SecurePolicy == CookieSecurePolicy.Always && !context.Request.IsHttps)

26var requestCookie = httpContext.Request.Cookies[_options.Cookie.Name!]; 40var cookieToken = httpContext.Request.Cookies[_options.Cookie.Name!]; 47requestToken = httpContext.Request.Headers[_options.HeaderName]; 51if (requestToken.Count == 0 && httpContext.Request.HasFormContentType && !_options.SuppressReadingTokenFromFormBody) 58form = await httpContext.Request.ReadFormAsync(); 92var pathBase = httpContext.Request.PathBase.ToString();

637context.HttpContext.Request.Method = "POST"; 677context.HttpContext.Request.Method = "POST"; 716context.HttpContext.Request.Method = httpMethod; 753context.HttpContext.Request.Method = httpMethod; 898context.HttpContext.Request.ContentType = "application/json"; 924context.HttpContext.Request.ContentType = "application/x-www-form-urlencoded";

78httpContext.Request.Form = FormCollection.Empty; 101httpContext.Request.ContentType = "application/x-www-form-urlencoded"; 102httpContext.Request.Form = new FormCollection(new Dictionary<string, StringValues> 106httpContext.Request.Headers.Add("header-name", "header-value"); 130httpContext.Request.ContentType = "application/x-www-form-urlencoded"; 131httpContext.Request.Form = new FormCollection(new Dictionary<string, StringValues> 159httpContext.Request.ContentType = "application/x-www-form-urlencoded"; 160httpContext.Request.Form = new FormCollection(new Dictionary<string, StringValues> 164httpContext.Request.Headers.Add("header-name", "header-value"); 189httpContext.Request.ContentType = "application/x-www-form-urlencoded"; 190httpContext.Request.Form = new FormCollection(new Dictionary<string, StringValues> 217httpContext.Request.ContentType = "application/json"; 218httpContext.Request.Headers.Add("header-name", "header-value"); 221httpContext.Request.Form = null!; 245httpContext.Request.ContentType = "application/json"; 248httpContext.Request.Form = null!; 272httpContext.Request.ContentType = "application/x-www-form-urlencoded"; 273httpContext.Request.Form = FormCollection.Empty; 299httpContext.Setup(r => r.Request.Cookies).Returns(Mock.Of<IRequestCookieCollection>()); 300httpContext.SetupGet(r => r.Request.HasFormContentType).Returns(true); 301httpContext.Setup(r => r.Request.ReadFormAsync(It.IsAny<CancellationToken>())).Throws(ioException); 324httpContext.Setup(r => r.Request.Cookies).Returns(Mock.Of<IRequestCookieCollection>()); 325httpContext.SetupGet(r => r.Request.HasFormContentType).Returns(true); 326httpContext.Setup(r => r.Request.ReadFormAsync(It.IsAny<CancellationToken>())).Throws(exception); 361.Setup(hc => hc.Request.IsHttps) 367.SetupGet(hc => hc.Request.PathBase) 409.SetupGet(hc => hc.Request.PathBase) 412.SetupGet(hc => hc.Request.Path) 445.SetupGet(hc => hc.Request.PathBase) 448.SetupGet(hc => hc.Request.Path) 484.SetupGet(hc => hc.Request.PathBase) 487.SetupGet(hc => hc.Request.Path) 515context.Request.Headers.Cookie = $"{cookieName}={cookieValue}";

40get => Context.Request;

44OriginalPath = context.Request.Path, 45OriginalPathBase = context.Request.PathBase

48public HttpRequest Request => HttpContext.Request;

28var originalPathBase = context.Features.Get<IAuthenticationFeature>()?.OriginalPathBase ?? context.Request.PathBase;

51if (!Context.Request.IsHttps)

95var requestCookies = context.Request.Cookies; 161var requestCookies = context.Request.Cookies; 236var requestCookies = context.Request.Cookies;

444Assert.Equal("HTTP/1.1", context.Request.Protocol); // Not HTTP/2 461context.Request.Path = path; 464context.Request.Headers.Authorization = authorizationHeader;

273if (context.Request.Path.Equals("/error")) 409Assert.Equal("HTTP/1.1", context.Request.Protocol); 416Assert.Equal("HTTP/2", context.Request.Protocol); 429Assert.Equal("HTTP/1.1", context.Request.Protocol); // Not HTTP/2 443Assert.Equal("HTTP/1.1", context.Request.Protocol); // Not HTTP/2 455Assert.Equal("HTTP/1.1", context.Request.Protocol); // Not HTTP/2 484context.Request.Protocol = http2 ? "HTTP/2" : "HTTP/1.1"; 485context.Request.Path = path; 488context.Request.Headers.Authorization = authorizationHeader;

820var request = context.Request;

1158Assert.Equal(new PathString("/base"), context.Request.PathBase); 1710if (context.Request.Path == "/signin") 1817var req = context.Request;

139var req = context.Request;

168var req = context.Request; 220var req = context.Request; 272var req = context.Request; 349var req = context.Request; 1154var req = context.Request;

1174if (context.Request.Path == new PathString("/checkforerrors")) 1183else if (context.Request.Path == new PathString("/oauth")) 1204else if (context.Request.Path == new PathString("/token")) 1209else if (context.Request.Path == new PathString("/unauthorized")) 1215else if (context.Request.Path == new PathString("/forbidden")) 1220else if (context.Request.Path == new PathString("/signIn")) 1224else if (context.Request.Path == new PathString("/signOut")) 1228else if (context.Request.Path == new PathString("/expiration"))

1233if (context.Request.Path == new PathString("/checkforerrors")) 1242else if (context.Request.Path == new PathString("/oauth")) 1263else if (context.Request.Path == new PathString("/token")) 1268else if (context.Request.Path == new PathString("/unauthorized")) 1274else if (context.Request.Path == new PathString("/forbidden")) 1279else if (context.Request.Path == new PathString("/signIn")) 1283else if (context.Request.Path == new PathString("/signOut")) 1287else if (context.Request.Path == new PathString("/expiration"))

365var req = context.Request;

28private readonly RequestDelegate AppWritePath = context => context.Response.WriteAsync(context.Request.Path);

28private readonly RequestDelegate AppWritePath = context => context.Response.WriteAsync(context.Request.Path);

72var req = context.Request;

349p.ForwardDefaultSelector = c => c.Request.QueryString.Value.Substring(1); 472var req = context.Request;

545var req = context.Request;

346context.HttpContext.Request.Path = new PathString("/AuthenticationFailed"); 384var authProperties = new AuthenticationProperties() { RedirectUri = context.Request.GetEncodedUrl() };

342context.HttpContext.Request.Path = new PathString("/AuthenticationFailed"); 380var authProperties = new AuthenticationProperties() { RedirectUri = context.Request.GetEncodedUrl() };

68if (!httpContext.Request.Query.TryGetValue("url", out var protectedUrl))

81form: result.HandlerName != null && context.Request.HasFormContentType ? await context.Request.ReadFormAsync() : null); 162var processPost = HttpMethods.IsPost(context.Request.Method) && 170if (context.Request.ContentType is not null && MediaTypeHeaderValue.TryParse(context.Request.ContentType, out var type)) 233await context.Request.ReadFormAsync(); 245if (context.Request.Form.TryGetValue("_handler", out var value))

80navigationManager?.Initialize(GetContextBaseUri(httpContext.Request), GetFullUri(httpContext.Request));

209else if (IsPossibleExternalDestination(httpContext.Request, navigationException.Location) 210&& IsProgressivelyEnhancedNavigation(httpContext.Request))

29if (IsProgressivelyEnhancedNavigation(httpContext.Request)) 97!IsProgressivelyEnhancedNavigation(httpContext.Request)) 151var isEnhancedNavigation = IsProgressivelyEnhancedNavigation(_httpContext.Request); 230if (string.Equals(httpContext.Request.Method, "POST", StringComparison.OrdinalIgnoreCase)) 235if (IsProgressivelyEnhancedNavigation(httpContext.Request))

1657context.Request.Scheme = "http"; 1658context.Request.Host = new HostString("localhost"); 1659context.Request.PathBase = "/base"; 1660context.Request.Path = "/path"; 1661context.Request.QueryString = QueryString.FromUriComponent("?query=value");

34if (!HttpMethods.IsPost(context.Request.Method)) 56if (!context.Request.HasFormContentType) 61var form = await context.Request.ReadFormAsync();

42builder.MapWhen(ctx => ctx.Request.Path.StartsWithSegments(pathPrefix, out var rest) && rest.StartsWithSegments("/_framework") && 109var requestPath = fileContext.Context.Request.Path;

41var accept = context.Request.Headers.AcceptEncoding; 90context.Request.Path = context.Request.Path + extension; 117_webHostEnvironment.WebRootFileProvider.GetFileInfo(context.Request.Path + extension).Exists;

114var request = context.Request; 267var request = context.Request;

25var queryParams = HttpUtility.ParseQueryString(context.Request.QueryString.Value!); 40var requestPath = context.Request.Path.ToString();

56var cookie = Context.Request.Cookies[Options.ConsentCookie.Name!]; 240if (Context.Request.IsHttps && !options.Secure)

87context.Request.Headers["Cookie"] = new[] 118context.Request.Headers["Cookie"] = new[] 149context.Request.Headers["Cookie"] = new[] 170context.Request.Headers["Cookie"] = new[] 190context.Request.Headers["Cookie"] = new[] 211context.Request.Headers.Append("Cookie", "TestCookie=chunks-7;TestCookieC1=1;TestCookieC2=2;TestCookieC3=3;TestCookieC4=4;TestCookieC5=5;TestCookieC6=6;TestCookieC7=7"); 233context.Request.Headers.Append("Cookie", "TestCookie=chunks-7;TestCookieC1=1;TestCookieC2=2"); 251context.Request.Headers.Append("Cookie", "TestCookie=chunks-7;TestCookieC1=1;TestCookieC2=2;TestCookieC4=4"); 270httpContext.Request.Headers["Cookie"] = new[]

132requestContext.Request.Headers.Cookie = ".AspNet.Consent=yes"; 155requestContext.Request.Headers.Cookie = ".AspNet.Consent=yes"; 178requestContext.Request.Headers.Cookie = ".AspNet.Consent=IAmATeapot"; 286requestContext.Request.Headers.Cookie = ".AspNet.Consent=yes"; 378requestContext.Request.Headers.Cookie = ".AspNet.Consent=yes"; 427requestContext.Request.Headers.Cookie = ".AspNet.Consent=yes"; 463requestContext.Request.Headers.Cookie = ".AspNet.Consent=yes";

95var requestCookies = context.Request.Cookies; 161var requestCookies = context.Request.Cookies; 236var requestCookies = context.Request.Cookies;

107if (!context.Request.Headers.ContainsKey(CorsConstants.Origin)) 118var isOptionsRequest = HttpMethods.IsOptions(context.Request.Method); 120var isCorsPreflightRequest = isOptionsRequest && context.Request.Headers.ContainsKey(CorsConstants.AccessControlRequestMethod);

68var requestHeaders = context.Request.Headers; 71var isOptionsRequest = HttpMethods.IsOptions(context.Request.Method); 99var headers = context.Request.Headers; 119new[] { result.IsPreflightRequest ? headers.AccessControlRequestMethod.ToString() : context.Request.Method } :

91Path = httpContext.Request.Path.ToString(), 202var headers = httpContext.Request.GetTypedHeaders(); 242foreach (var pair in httpContext.Request.Headers) 265headers: httpContext.Request.Headers, 266path: httpContext.Request.Path.ToString(), 362var request = context.Request;

141var originalPath = context.Request.Path; 144context.Request.Path = _options.ExceptionHandlingPath; 228context.Request.Path = originalPath;

64Request = Context.Request;

83Request = Context.Request;

102context.HttpContext.Response.Redirect(context.HttpContext.Request.PathBase + location); 175var originalPath = context.HttpContext.Request.Path; 176var originalQueryString = context.HttpContext.Request.QueryString; 183OriginalPathBase = context.HttpContext.Request.PathBase.Value!, 195context.HttpContext.Request.Path = newPath; 196context.HttpContext.Request.QueryString = newQueryString; 210context.HttpContext.Request.QueryString = originalQueryString; 211context.HttpContext.Request.Path = originalPath;

40HttpRequest request = context.Request;

81Model = new DatabaseErrorPageModel(dbException, contextDetails, _options, errorContext.HttpContext.Request.PathBase)

104Model = new DatabaseErrorPageModel(exception, new DatabaseContextDetails[] { details }, _options, httpContext.Request.PathBase)

55if (context.Request.Path.Equals(_options.Path)) 65_logger.RequestPathMatched(context.Request.Path); 97var form = await context.Request.ReadFormAsync();

64Request = Context.Request;

83Request = Context.Request;

225(c.Request.Path.StartsWithSegments(path, out var remaining) &&

713context.Connection.LocalPort = context.Request.Host.Port.Value; 751context.Connection.LocalPort = context.Request.Host.Port.Value; 789context.Connection.LocalPort = context.Request.Host.Port.Value; 825context.Connection.LocalPort = context.Request.Host.Port.Value; 869context.Connection.LocalPort = context.Request.Host.Port.Value;

67var request = context.Request; 68if (_excludePathStartsWith.Length != 0 && ShouldExcludePath(context.Request.Path.Value!)) 81logContext.AddParameter(HttpLoggingTagNames.Host, context.Request.Host.Value); 129_requestHeadersReader.Read(context.Request.Headers, logContext.Parameters);

51if (_httpContextAccessor.HttpContext?.Request == null) 56var request = _httpContextAccessor.HttpContext.Request;

61await context.Request.Body.DrainAsync(default); 63if (context.Request.QueryString.HasValue) 65if (context.Request.QueryString.Value!.Contains("status")) 70if (context.Request.QueryString.Value!.Contains("body")) 87await context.Request.Body.DrainAsync(default).ConfigureAwait(false);

47httpContextMock.SetupGet(c => c.Request.Headers).Returns(headers); 48httpContextMock.SetupGet(c => c.Request.HttpContext).Returns(httpContextMock.Object); 233httpContextMock.SetupGet(c => c.Request).Returns((HttpRequest)null!); 256httpContextMock.SetupGet(c => c.Request.Headers).Throws(new ObjectDisposedException("")); 257httpContextMock.SetupGet(c => c.Request.HttpContext).Returns(httpContextMock.Object);

86httpContext.Request.RouteValues["John"] = "Doe"; 91Assert.Empty(context.Request.RouteValues); 108httpContext.Request.RouteValues["John"] = "Doe";

44await httpContext.Response.WriteAsync(httpContext.Request.QueryString.Value); 50throw new InvalidOperationException($"Invalid input provided. {context.Request.Path}"); 85var beforeNext = context.Request.QueryString; 87var afterNext = context.Request.QueryString; 108httpContext.Request.QueryString.Value 148Assert.Empty(context.Request.RouteValues); 158httpContext.Request.RouteValues["John"] = "Doe"; 170httpContext.Request.QueryString.Value 214httpContext.Request.RouteValues["John"] = "Doe";

205GrpcServerLog.UnsupportedRequestContentType(serverCallContext.Logger, serverCallContext.HttpContext.Request.ContentType); 206throw new InvalidOperationException($"Unable to read the request as JSON because the request content type '{serverCallContext.HttpContext.Request.ContentType}' is not a known JSON content type."); 209var (stream, usesTranscodingStream) = GetStream(serverCallContext.HttpContext.Request.Body, serverCallContext.RequestEncoding); 282var routeValue = serverCallContext.HttpContext.Request.RouteValues[parameterDescriptor.Key]; 289foreach (var item in serverCallContext.HttpContext.Request.Query) 322var contentType = serverCallContext.HttpContext.Request.ContentType; 341var contentLength = serverCallContext.HttpContext.Request.ContentLength.GetValueOrDefault(); 348using var fs = new FileBufferingReadStream(serverCallContext.HttpContext.Request.Body, memoryThreshold);

149values[i] = context.Request.RouteValues[variableParts[i]]; 160context.Request.RouteValues[fullPath] = finalValue;

51IsJsonRequestContent = JsonRequestHelpers.HasJsonContentType(HttpContext.Request, out var charset); 64protected override string HostCore => HttpContext.Request.Host.Value ?? string.Empty; 147foreach (var header in HttpContext.Request.Headers)

1603httpContext.Request.Query = new QueryCollection(new Dictionary<string, StringValues> 1620httpContext.Request.Query = new QueryCollection(new Dictionary<string, StringValues>

139if (feature.Context!.Request.Headers.TryGetValue(header.Name, out var values))

96var feature = context.Request.GetHeaderParsing(); 100Assert.Equal(feature, context.Request.GetHeaderParsing()); 110context.Request.Headers["Date"] = date; 112Assert.True(context.Request.TryGetHeaderValue(dateHeaderKey, out var parsedDate, out var result)); 116Assert.True(context.Request.TryGetHeaderValue(dateHeaderKey, out parsedDate));

49Context.Request.Headers["Date"] = date; 67Context.Request.Headers["Date"] = currentDate; 68Context.Request.Headers["Test"] = futureDate; 90Context.Request.Headers["Date"] = date; 139Context.Request.Headers["Date"] = "Not a date."; 178Context.Request.Headers[firstHeaderKey.Name] = DateTimeOffset.Now.ToString("R", CultureInfo.InvariantCulture); 179Context.Request.Headers[thirdHeaderKey.Name] = DateTimeOffset.Now.ToString("R", CultureInfo.InvariantCulture); 196Context.Request.Headers[HeaderNames.CacheControl] = "max-age=604800";

71context.Request.Headers.TryGetValue(entry.InboundHeaderName, out var value);

84var host = context.Request.Headers.Host.ToString(); 121_logger.RequestRejectedMissingHost(context.Request.Protocol); 125_logger.RequestAllowedMissingHost(context.Request.Protocol);

59ctx.Request.Headers.Remove(HeaderNames.Host); 65Assert.False(c.Request.Headers.TryGetValue(HeaderNames.Host, out var host)); 100ctx.Request.Headers.Host = ""; 106Assert.True(c.Request.Headers.TryGetValue(HeaderNames.Host, out var host)); 157ctx.Request.Headers.Host = hosturl; 209ctx.Request.Headers.Host = hosturl; 248ctx.Request.Headers.Host = currentHost;

64context.MetricsTagsFeature.Method = httpContext.Request.Method; 65context.MetricsTagsFeature.Protocol = httpContext.Request.Protocol; 66context.MetricsTagsFeature.Scheme = httpContext.Request.Scheme; 334[DynamicDependency(nameof(HttpContext.Request), typeof(HttpContext))] 355[DynamicDependency(nameof(HttpContext.Request), typeof(HttpContext))] 378_eventSource.RequestStart(httpContext.Request.Method, httpContext.Request.Path); 384_metrics.RequestStart(httpContext.Request.Scheme, httpContext.Request.Method); 392var headers = httpContext.Request.Headers; 444[DynamicDependency(nameof(HttpContext.Request), typeof(HttpContext))] 519_path = (httpContext.Request.PathBase.HasValue 520? httpContext.Request.PathBase + httpContext.Request.Path 521: httpContext.Request.Path).ToString();

30var request = _context.HttpContext.Request; 64var request = _context.HttpContext.Request;

40_request = httpContext.Request;

230 => new KeyValuePair<string, object?>(nameof(_httpContext.Request.Method), _httpContext.Request.Method), 241 => new KeyValuePair<string, object?>(nameof(_httpContext.Request.Scheme), _httpContext.Request.Scheme), 252 => new KeyValuePair<string, object?>(nameof(_httpContext.Request.Host), _httpContext.Request.Host), 263 => new KeyValuePair<string, object?>(nameof(_httpContext.Request.PathBase), _httpContext.Request.PathBase), 274 => new KeyValuePair<string, object?>(nameof(_httpContext.Request.Path), _httpContext.Request.Path), 42var request = _httpContext.Request;

83Request = Context.Request;

28mockContext.Setup(context => context.Request).Returns(mockRequest.Object);

946capturedRequest = httpContext.Request;

36!ReferenceEquals(_streamInstanceWhenWrapped, _context.Request.Body)) 38_streamInstanceWhenWrapped = _context.Request.Body; 39_internalPipeReader = PipeReader.Create(_context.Request.Body, _defaultReaderOptions);

56if (!string.IsNullOrEmpty(context.Request.Method)) 58sb.Append(context.Request.Method); 61GetRequestUrl(sb, context.Request, includeQueryString: false); 62if (!string.IsNullOrEmpty(context.Request.Protocol)) 65sb.Append(context.Request.Protocol); 67if (!string.IsNullOrEmpty(context.Request.ContentType)) 70sb.Append(context.Request.ContentType);

15context.Items["test.PathBase"] = context.Request.PathBase.Value; 16context.Items["test.Path"] = context.Request.Path.Value; 63Assert.Equal(basePath, context.Request.PathBase.Value); 64Assert.Equal(requestPath, context.Request.Path.Value); 152Assert.Equal(basePath, context.Request.PathBase.Value); 153Assert.Equal(requestPath, context.Request.Path.Value); 174Assert.Equal(basePath, context.Request.PathBase.Value); 175Assert.Equal(requestPath, context.Request.Path.Value); 196Assert.Equal(string.Empty, context.Request.PathBase.Value); 197Assert.Equal("/route1/subroute1", context.Request.Path.Value); 202Assert.Equal(string.Empty, context.Request.PathBase.Value); 203Assert.Equal("/route2", context.Request.Path.Value); 208Assert.Equal(string.Empty, context.Request.PathBase.Value); 209Assert.Equal("/route2/subroute2", context.Request.Path.Value); 214Assert.Equal(string.Empty, context.Request.PathBase.Value); 215Assert.Equal("/route2/subroute2/subsub2", context.Request.Path.Value); 241context.Request.PathBase = new PathString(basePath); 242context.Request.Path = new PathString(requestPath);

215context.Items["test.Path"] = context.Request.Path; 216context.Items["test.PathBase"] = context.Request.PathBase; 226Assert.Equal(pathBase, requestContext.Request.PathBase.Value); 227Assert.Equal(requestPath, requestContext.Request.Path.Value); 233context.Request.PathBase = new PathString(pathBase); 234context.Request.Path = new PathString(requestPath);

79if (HttpMethods.IsPost(context.Request.Method)) 84else if (HttpMethods.IsGet(context.Request.Method) || HttpMethods.IsConnect(context.Request.Method)) 89else if (HttpMethods.IsDelete(context.Request.Method)) 108if (HttpMethods.IsPost(context.Request.Method)) 131var headers = context.Request.GetTypedHeaders(); 341if (context.Request.Query.TryGetValue("NegotiateVersion", out var queryStringVersion)) 368if (options.AllowStatefulReconnects == true && context.Request.Query.TryGetValue("UseStatefulReconnect", out var useStatefulReconnectValue)) 447private static StringValues GetConnectionToken(HttpContext context) => context.Request.Query["id"]; 488await context.Request.Body.CopyToAsync(connection.ApplicationStream, bufferSize);

816Assert.Equal(3, connectionHttpContext.Request.Query.Count); 817Assert.Equal("value", connectionHttpContext.Request.Query["another"]); 819Assert.Equal(3, connectionHttpContext.Request.Headers.Count); 820Assert.Equal("h1", connectionHttpContext.Request.Headers["header1"]); 821Assert.Equal("h2", connectionHttpContext.Request.Headers["header2"]); 822Assert.Equal("h3", connectionHttpContext.Request.Headers["header3"]); 3242var claims = new[] { new Claim(ClaimTypes.NameIdentifier, httpContext.Request.Query["user"]) }; 3306new Claim(ClaimTypes.NameIdentifier, context.Request.Query["user"]) 3404var claims = new[] { new Claim(ClaimTypes.NameIdentifier, httpContext.Request.Query["user"]) }; 3758context.Request.Headers["Accept"] = "text/event-stream";

29var acceptHeader = httpContext.Request.Headers.Accept.GetList<MediaTypeHeaderValue>();

319return (httpContext.Request.Body, false); 322var inputStream = Encoding.CreateTranscodingStream(httpContext.Request.Body, encoding, Encoding.UTF8, leaveOpen: true);

92private static readonly MemberExpression HttpRequestExpr = Expression.Property(HttpContextExpr, typeof(HttpContext).GetProperty(nameof(HttpContext.Request))!); 1387if (!httpContext.Request.HasJsonContentType()) 1389Log.UnexpectedJsonContentType(httpContext, httpContext.Request.ContentType, throwOnBadRequest); 1395bodyValue = await httpContext.Request.ReadFromJsonAsync(jsonTypeInfo); 1518if (!httpContext.Request.HasFormContentType) 1520Log.UnexpectedNonFormContentType(httpContext, httpContext.Request.ContentType, throwOnBadRequest); 1527formValue = await httpContext.Request.ReadFormAsync();

1082if (!int.TryParse(context.Request.Headers.ETag, out var val)) 1098if (!int.TryParse(context.Request.Headers.ETag, out var val)) 1117if (!int.TryParse(context.Request.Headers.ETag, out var val)) 1130if (!int.TryParse(context.Request.Headers.ETag, out var val))

420if (!Uri.TryCreate(context.Request.Headers.Referer, UriKind.Absolute, out var uri)) 441if (!Uri.TryCreate(context.Request.Headers.Referer, UriKind.Absolute, out var uri)) 457if (!Uri.TryCreate(context.Request.Headers.Referer, UriKind.Absolute, out var uri)) 480if (!Uri.TryCreate(context.Request.Headers.Referer, UriKind.Absolute, out var uri)) 498if (!Uri.TryCreate(context.Request.Headers.Referer, UriKind.Absolute, out var uri)) 514if (!Uri.TryCreate(context.Request.Headers.Referer, UriKind.Absolute, out var uri)) 533if (!Uri.TryCreate(context.Request.Headers.Referer, UriKind.Absolute, out var uri)) 546if (!Uri.TryCreate(context.Request.Headers.Referer, UriKind.Absolute, out var uri)) 564if (!Uri.TryCreate(context.Request.Headers.Referer, UriKind.Absolute, out var uri)) 3545var body = await JsonSerializer.DeserializeAsync<JsonTodo>(context.Request.Body); 3546context.Request.Body.Position = 0;

147httpContext.Request.RouteValues["id"] = i.ToString(CultureInfo.InvariantCulture); 410httpContext.Request.QueryString = QueryString.Create("value", endpoint.DisplayName); 525httpContext.Request.QueryString = httpContext.Request.QueryString.Add(QueryString.Create(value, value)); 528httpContext.Request.Headers[value] = value; 531httpContext.Request.RouteValues[value] = value; 780httpContext.Request.Form = new FormCollection(new Dictionary<string, StringValues>

223httpContext.Request.Headers["Content-Type"] = "application/json"; 227httpContext.Request.Body = stream; 228httpContext.Request.Headers["Content-Length"] = stream.Length.ToString(CultureInfo.InvariantCulture);

36httpContext.Request.QueryString = new QueryString("?p=1&p=1"); 57httpContext.Request.Headers.Add("p", new StringValues(new string[] { "1", "1" })); 78httpContext.Request.Headers.Add("p", new StringValues(new string[] { "1", "1" })); 99httpContext.Request.Headers.Add("p", new StringValues(new string[] { "1", "1" })); 172httpContext.Request.Query = new QueryCollection(new Dictionary<string, StringValues> 197httpContext.Request.QueryString = new QueryString("?p=1&p=1"); 218httpContext.Request.QueryString = new QueryString("?p=Item1&p=Item2"); 239httpContext.Request.QueryString = new QueryString("?p=Item1&p=Item2"); 280httpContext.Request.QueryString = new QueryString("?p=&p="); 301httpContext.Request.QueryString = new QueryString("?p=Item1&p=Item2"); 322httpContext.Request.QueryString = new QueryString("?p=Item1&p=Item2"); 344httpContext.Request.QueryString = new QueryString("?p=a&p=b&p=c"); 387httpContext.Request.QueryString = new QueryString("?p=a&p=b&p=c"); 430httpContext.Request.QueryString = new QueryString("?p=0&p=1&p=2"); 473httpContext.Request.QueryString = new QueryString("?p=0&p=1&p=2"); 516httpContext.Request.QueryString = new QueryString("?p=0&p=1&p=2"); 559httpContext.Request.QueryString = new QueryString("?p=0&p=1&p=2"); 601httpContext.Request.QueryString = new QueryString("?p=Item1&p=Item2"); 623httpContext.Request.Headers["Content-Type"] = "application/json"; 626httpContext.Request.Body = stream; 627httpContext.Request.Headers["Content-Length"] = stream.Length.ToString(CultureInfo.InvariantCulture); 628httpContext.Request.QueryString = new QueryString("?p=ValueFromQueryString"); 650httpContext.Request.Headers["Content-Type"] = "application/json"; 653httpContext.Request.Body = stream; 654httpContext.Request.Headers["Content-Length"] = stream.Length.ToString(CultureInfo.InvariantCulture); 655httpContext.Request.QueryString = new QueryString("?p=ValueFromQueryString"); 677httpContext.Request.Headers["Content-Type"] = "application/json"; 680httpContext.Request.Body = stream; 681httpContext.Request.Headers["Content-Length"] = stream.Length.ToString(CultureInfo.InvariantCulture); 682httpContext.Request.QueryString = new QueryString("?p=ValueFromQueryString"); 704httpContext.Request.Headers["Content-Type"] = "application/json"; 707httpContext.Request.Body = stream; 708httpContext.Request.Headers["Content-Length"] = stream.Length.ToString(CultureInfo.InvariantCulture); 709httpContext.Request.QueryString = new QueryString("?p=ValueFromQueryString"); 731httpContext.Request.Headers["Content-Type"] = "application/json"; 734httpContext.Request.Body = stream; 735httpContext.Request.Headers["Content-Length"] = stream.Length.ToString(CultureInfo.InvariantCulture); 736httpContext.Request.QueryString = new QueryString("?p=ValueFromQueryString"); 760httpContext.Request.Query = new QueryCollection(new Dictionary<string, StringValues> 765httpContext.Request.Headers["Custom"] = new(new[] { "4", "5", "6" }); 767httpContext.Request.Form = new FormCollection(new Dictionary<string, StringValues>

28httpContext.Request.RouteValues["value"] = originalRouteParam.ToString(NumberFormatInfo.InvariantInfo); 68httpContext.Request.Query = query; 96httpContext.Request.Headers[customHeaderName] = originalHeaderParam.ToString(NumberFormatInfo.InvariantInfo); 200httpContext.Request.RouteValues[paramName] = originalRouteParam.ToString(NumberFormatInfo.InvariantInfo); 280httpContext.Request.RouteValues[nameof(ParameterListWithReadOnlyProperties.Value)] = routeParamValue.ToString(NumberFormatInfo.InvariantInfo); 281httpContext.Request.RouteValues[nameof(ParameterListWithReadOnlyProperties.ConstantValue)] = routeParamValue.ToString(NumberFormatInfo.InvariantInfo); 282httpContext.Request.RouteValues[nameof(ParameterListWithReadOnlyProperties.ReadOnlyValue)] = routeParamValue.ToString(NumberFormatInfo.InvariantInfo); 283httpContext.Request.RouteValues[nameof(ParameterListWithReadOnlyProperties.PrivateSetValue)] = routeParamValue.ToString(NumberFormatInfo.InvariantInfo); 313httpContext.Request.RouteValues[nameof(SampleParameterList.Foo)] = foo.ToString(NumberFormatInfo.InvariantInfo); 314httpContext.Request.RouteValues[nameof(AdditionalSampleParameterList.Bar)] = bar.ToString(NumberFormatInfo.InvariantInfo); 340httpContext.Request.Headers.Referer = uriValue;

57httpContext.Request.Headers.Referer = "https://example.org"; 78httpContext.Request.Headers.Referer = "https://example.org"; 178httpContext.Request.Headers.Referer = "https://example.org"; 195httpContext.Request.Headers.Referer = "https://example.org"; 213httpContext.Request.Body = stream; 215httpContext.Request.Headers["Content-Type"] = "application/json"; 216httpContext.Request.Headers["Content-Length"] = stream.Length.ToString(CultureInfo.InvariantCulture); 233httpContext.Request.Headers.Referer = "https://example.org"; 269httpContext.Request.Body = stream; 271httpContext.Request.Headers["Content-Type"] = "application/json"; 272httpContext.Request.Headers["Content-Length"] = stream.Length.ToString(CultureInfo.InvariantCulture); 289httpContext.Request.Headers.Referer = "https://example.org";

213httpContext.Request.Headers["headerValue"] = requestData; 431httpContext.Request.Query = new QueryCollection(new Dictionary<string, StringValues> 436httpContext.Request.Headers.Referer = "https://example.org"; 457httpContext.Request.Query = new QueryCollection(new Dictionary<string, StringValues> 462httpContext.Request.Headers.Referer = "https://example.org"; 483httpContext.Request.Method = "GET"; 504httpContext.Request.Query = new QueryCollection(new Dictionary<string, StringValues> 509httpContext.Request.Headers.Referer = "https://example.org"; 529httpContext.Request.Query = new QueryCollection(new Dictionary<string, StringValues> 534httpContext.Request.Headers.Referer = "https://example.org"; 554httpContext.Request.Query = new QueryCollection(new Dictionary<string, StringValues> 559httpContext.Request.Headers.Referer = "https://example.org"; 584httpContext.Request.Query = new QueryCollection(new Dictionary<string, StringValues> 589httpContext.Request.Headers["Custom"] = new(new[] { "4", "5", "6" }); 591httpContext.Request.Form = new FormCollection(new Dictionary<string, StringValues>

62httpContext.Request.Query = new QueryCollection(new Dictionary<string, StringValues> 141httpContext.Request.Query = new QueryCollection(new Dictionary<string, StringValues> 183httpContext.Request.Query = new QueryCollection(new Dictionary<string, StringValues> 234httpContext.Request.Body = stream; 235httpContext.Request.Headers["Content-Type"] = "multipart/form-data;boundary=some-boundary"; 299httpContext.Request.Query = new QueryCollection(new Dictionary<string, StringValues> 340httpContext.Request.Query = new QueryCollection(new Dictionary<string, StringValues>

35httpContext.Request.Body = stream; 36httpContext.Request.Headers["Content-Type"] = "multipart/form-data;boundary=some-boundary"; 41Assert.Equal(httpContext.Request.Form.Files, httpContext.Items["formFiles"]); 70httpContext.Request.Body = stream; 71httpContext.Request.Headers["Content-Type"] = "multipart/form-data;boundary=some-boundary"; 76Assert.Equal(httpContext.Request.Form.Files, httpContext.Items["formFiles"]); 105httpContext.Request.Body = stream; 106httpContext.Request.Headers["Content-Type"] = "multipart/form-data;boundary=some-boundary"; 111Assert.Equal(httpContext.Request.Form.Files["file"], httpContext.Items["formFiles"]); 143httpContext.Request.Body = stream; 144httpContext.Request.Headers["Content-Type"] = "multipart/form-data;boundary=some-boundary"; 149Assert.Equal(httpContext.Request.Form.Files["file"], httpContext.Items["formFiles"]); 181httpContext.Request.Body = stream; 182httpContext.Request.Headers["Content-Type"] = "multipart/form-data;boundary=some-boundary"; 187Assert.Equal(httpContext.Request.Form.Files["file1"], httpContext.Items["file1"]); 192Assert.Equal(httpContext.Request.Form.Files["file2"], httpContext.Items["file2"]); 222httpContext.Request.Body = stream; 223httpContext.Request.Headers["Content-Type"] = "multipart/form-data;boundary=some-boundary"; 228Assert.Equal(httpContext.Request.Form.Files["file1"], httpContext.Items["file1"]); 231Assert.Equal(httpContext.Request.Form.Files["file2"], httpContext.Items["file2"]); 259httpContext.Request.Body = stream; 260httpContext.Request.Headers["Content-Type"] = "multipart/form-data;boundary=some-boundary"; 265Assert.Equal(httpContext.Request.Form.Files["my_file"], httpContext.Items["formFiles"]); 295httpContext.Request.Body = stream; 296httpContext.Request.Headers["Content-Type"] = "multipart/form-data;boundary=some-boundary"; 302Assert.Equal(httpContext.Request.Form.Files["file"], httpContext.Items["formFiles"]); 322httpContext.Request.Headers["Content-Type"] = "application/xml"; 323httpContext.Request.Headers["Content-Length"] = "1"; 369httpContext.Request.Body = stream; 370httpContext.Request.Headers["Content-Type"] = "multipart/form-data;boundary=some-boundary"; 402httpContext.Request.Body = stream; 403httpContext.Request.Headers["Content-Type"] = "multipart/form-data;boundary=some-boundary"; 408Assert.Equal(httpContext.Request.Form.Files, httpContext.Items["formFiles"]); 412Assert.Equal(httpContext.Request.Form.Files["file"], httpContext.Items["file"]); 451httpContext.Request.Body = stream; 452httpContext.Request.Headers[headerName] = headerValue; 453httpContext.Request.Headers["Content-Type"] = "multipart/form-data;boundary=some-boundary"; 459Assert.Equal(httpContext.Request.Form.Files["file"], httpContext.Items["file"]); 491httpContext.Request.Body = stream; 492httpContext.Request.Headers["Content-Type"] = "multipart/form-data;boundary=some-boundary"; 504Assert.Equal(httpContext.Request.Form.Files["file"], httpContext.Items["file"]); 550httpContext.Request.Body = stream; 551httpContext.Request.Headers["Content-Type"] = contentType; 556Assert.Equal(httpContext.Request.Form, httpContext.Items["formFiles"]); 597httpContext.Request.Body = stream; 598httpContext.Request.Headers["Content-Type"] = contentType; 603Assert.Equal(httpContext.Request.Form, httpContext.Items["formFiles"]); 644httpContext.Request.Body = stream; 645httpContext.Request.Headers["Content-Type"] = contentType; 650Assert.Equal(httpContext.Request.Form["message"][0], httpContext.Items["message"]); 673httpContext.Request.Body = stream; 674httpContext.Request.Headers["Content-Type"] = contentType; 679Assert.Equal(httpContext.Request.Form["message"][0], httpContext.Items["message"]); 682Assert.Equal(httpContext.Request.Form["name"][0], httpContext.Items["name"]); 706httpContext.Request.Body = stream; 707httpContext.Request.Headers["Content-Type"] = contentType; 712Assert.Equal(httpContext.Request.Form["message"][0], httpContext.Items["message"]); 736httpContext.Request.Body = stream; 737httpContext.Request.Headers["Content-Type"] = contentType; 742Assert.Equal(httpContext.Request.Form["message"][0], httpContext.Items["message"]); 766httpContext.Request.Body = stream; 767httpContext.Request.Headers["Content-Type"] = contentType; 772Assert.Equal(httpContext.Request.Form["message"][0], httpContext.Items["message"]); 829httpContext.Request.Body = stream; 830httpContext.Request.Headers["Content-Type"] = "multipart/form-data;boundary=some-boundary"; 838Assert.Equal(httpContext.Request.Form.Files, formFilesArgument); 842Assert.Equal(httpContext.Request.Form, formArgument); 873httpContext.Request.Body = stream; 874httpContext.Request.Headers["Content-Type"] = contentType; 897httpContext.Request.Form = new FormCollection(new Dictionary<string, StringValues> 930httpContext.Request.Headers["Content-Type"] = "application/x-www-form-urlencoded"; 931httpContext.Request.Headers["Content-Length"] = "1"; 932httpContext.Request.Body = new ExceptionThrowingRequestBodyStream(ioException); 962httpContext.Request.Headers["Content-Type"] = "application/x-www-form-urlencoded"; 963httpContext.Request.Headers["Content-Length"] = "2049"; 964httpContext.Request.Body = new MemoryStream(Encoding.UTF8.GetBytes(new string('x', 2049))); 999httpContext.Request.Headers["Content-Type"] = "application/x-www-form-urlencoded"; 1000httpContext.Request.Headers["Content-Length"] = "2049"; 1001httpContext.Request.Body = new MemoryStream(Encoding.UTF8.GetBytes(new string('x', 2049)));

86httpContext.Request.Headers["Content-Type"] = "application/json"; 90httpContext.Request.Body = stream; 91httpContext.Request.Headers["Content-Length"] = stream.Length.ToString(CultureInfo.InvariantCulture); 106httpContext.Request.Headers["Content-Type"] = "application/json"; 107httpContext.Request.Headers["Content-Length"] = "0"; 233httpContext.Request.Body = stream; 234httpContext.Request.Headers["Content-Length"] = stream.Length.ToString(CultureInfo.InvariantCulture); 239Assert.Same(httpContext.Request.Body, stream); 242httpContext.Request.Body.Position = 0; 244int read = await httpContext.Request.Body.ReadAsync(data.AsMemory()); 248httpContext.Request.Body.Position = 0; 249var result = await httpContext.Request.BodyReader.ReadAsync(); 252httpContext.Request.BodyReader.AdvanceTo(result.Buffer.End); 274httpContext.Request.Body = stream; 275httpContext.Request.Headers["Content-Length"] = stream.Length.ToString(CultureInfo.InvariantCulture); 280Assert.Same(httpContext.Request.Body, stream); 283httpContext.Request.Body.Position = 0; 285int read = await httpContext.Request.Body.ReadAsync(data.AsMemory()); 289httpContext.Request.Body.Position = 0; 290var result = await httpContext.Request.BodyReader.ReadAsync(); 293httpContext.Request.BodyReader.AdvanceTo(result.Buffer.End); 317httpContext.Request.Body = stream; 319httpContext.Request.Headers["Content-Length"] = requestBodyBytes.Length.ToString(CultureInfo.InvariantCulture); 324Assert.Same(httpContext.Request.Body, stream); 325Assert.Same(httpContext.Request.BodyReader, pipeReader); 328int read = await httpContext.Request.Body.ReadAsync(new byte[requestBodyBytes.Length].AsMemory()); 331var result = await httpContext.Request.BodyReader.ReadAsync(); 334httpContext.Request.BodyReader.AdvanceTo(result.Buffer.End); 358httpContext.Request.Body = stream; 360httpContext.Request.Headers["Content-Length"] = requestBodyBytes.Length.ToString(CultureInfo.InvariantCulture); 365Assert.Same(httpContext.Request.Body, stream); 366Assert.Same(httpContext.Request.BodyReader, pipeReader); 369int read = await httpContext.Request.Body.ReadAsync(new byte[requestBodyBytes.Length].AsMemory()); 372var result = await httpContext.Request.BodyReader.ReadAsync(); 375httpContext.Request.BodyReader.AdvanceTo(result.Buffer.End); 398httpContext.Request.Headers["Content-Type"] = "application/json"; 399httpContext.Request.Headers["Content-Length"] = "0"; 427httpContext.Request.Headers["Content-Type"] = "application/json"; 431httpContext.Request.Body = stream; 432httpContext.Request.Headers["Content-Length"] = stream.Length.ToString(CultureInfo.InvariantCulture);

198httpContext.Request.Headers["Content-Type"] = "application/json"; 199httpContext.Request.Headers["Content-Length"] = "0";

36httpContext.Request.Form = new FormCollection(null); 98httpContext.Request.RouteValues["tryParsable"] = "invalid!"; 99httpContext.Request.RouteValues["tryParsable2"] = "invalid again!"; 149httpContext.Request.RouteValues["tryParsable"] = "invalid!"; 150httpContext.Request.RouteValues["tryParsable2"] = "invalid again!"; 186httpContext.Request.Query = new QueryCollection(new Dictionary<string, StringValues>() 384httpContext.Request.Headers["Content-Type"] = "application/xml"; 385httpContext.Request.Headers["Content-Length"] = "1"; 435httpContext.Request.Headers["Content-Type"] = "application/xml"; 481httpContext.Request.Headers["Content-Type"] = "application/json"; 482httpContext.Request.Headers["Content-Length"] = "1"; 483httpContext.Request.Body = new ExceptionThrowingRequestBodyStream(ioException); 517httpContext.Request.Headers["Content-Type"] = "application/json"; 518httpContext.Request.Headers["Content-Length"] = "1"; 519httpContext.Request.Body = new ExceptionThrowingRequestBodyStream(jsonException); 558httpContext.Request.Headers["Content-Type"] = "application/json"; 559httpContext.Request.Headers["Content-Length"] = "1"; 560httpContext.Request.Body = new ExceptionThrowingRequestBodyStream(jsonException); 597httpContext.Request.Headers["Content-Type"] = "application/json"; 598httpContext.Request.Headers["Content-Length"] = "1"; 599httpContext.Request.Body = new MemoryStream(Encoding.UTF8.GetBytes("{")); 637httpContext.Request.Headers["Content-Type"] = "application/json"; 638httpContext.Request.Headers["Content-Length"] = "1"; 639httpContext.Request.Body = new MemoryStream(Encoding.UTF8.GetBytes("{"));

54httpContext.Request.Query = new QueryCollection(new Dictionary<string, StringValues> 100httpContext.Request.QueryString = new QueryString("?p="); 121httpContext.Request.QueryString = new QueryString("?p1=Hello&p2=world!"); 178httpContext.Request.QueryString = new QueryString($"?{name}=test");

53httpContext.Request.RouteValues["routeValue"] = requestData; 113httpContext.Request.RouteValues["value"] = expectedBody; 118httpContext.Request.QueryString = new QueryString($"?value={expectedBody}"); 135httpContext.Request.RouteValues["value"] = "fromRoute"; 136httpContext.Request.QueryString = new QueryString($"?value=fromQuery"); 152httpContext.Request.RouteValues["value"] = "fromRoute"; 153httpContext.Request.QueryString = new QueryString($"?value=fromQuery"); 186httpContext.Request.RouteValues[routeParameterName] = "test"; 202httpContext.Request.RouteValues[unmatchedName] = unmatchedRouteParam.ToString(NumberFormatInfo.InvariantInfo); 226httpContext.Request.RouteValues[paramName] = originalRouteParam.ToString(NumberFormatInfo.InvariantInfo);

103Assert.Equal(httpContext.Request, httpContext.Items["arg"]); 149Assert.Same(httpContext.Request, httpContext.Items["request"]);

78httpContext.Request.QueryString = new QueryString($"?p={UrlEncoder.Default.Encode(queryStringInput)}"); 116httpContext.Request.QueryString = new QueryString($"?time={UrlEncoder.Default.Encode(queryStringInput)}"); 148httpContext.Request.QueryString = new QueryString($"?time={UrlEncoder.Default.Encode(queryStringInput)}"); 173httpContext.Request.QueryString = new QueryString("?p=1"); 196httpContext.Request.QueryString = new QueryString("?p=1"); 212httpContext.Request.QueryString = new QueryString("?p=1"); 237httpContext.Request.QueryString = new QueryString("?p=Done"); 257httpContext.Request.RouteValues["tryParsable"] = routeValue; 277httpContext.Request.RouteValues["myBindAsyncRecord"] = "foo"; 278httpContext.Request.Query = new QueryCollection(new Dictionary<string, StringValues>

30httpContext.Request.Body = stream; 31httpContext.Request.Headers["Content-Type"] = "application/x-www-form-urlencoded"; 66httpContext.Request.Body = stream; 67httpContext.Request.Headers["Content-Type"] = "multipart/form-data;boundary=some-boundary"; 98httpContext.Request.Body = stream; 99httpContext.Request.Headers["Content-Type"] = "application/x-www-form-urlencoded"; 135httpContext.Request.Body = stream; 136httpContext.Request.Headers["Content-Type"] = "multipart/form-data;boundary=some-boundary"; 172httpContext.Request.Body = stream; 173httpContext.Request.Headers["Content-Type"] = "multipart/form-data;boundary=some-boundary"; 207httpContext.Request.Body = stream; 208httpContext.Request.Headers["Content-Type"] = "application/x-www-form-urlencoded"; 244httpContext.Request.Body = stream; 245httpContext.Request.Headers["Content-Type"] = "multipart/form-data;boundary=some-boundary";

92var body = await JsonSerializer.DeserializeAsync<JsonTodo>(context.Request.Body); 93context.Request.Body.Position = 0; 207var body = await context.Request.ReadFromJsonAsync<CustomTodo>(); 208context.Request.Body.Position = 0; 226if (!Uri.TryCreate(context.Request.Headers.Referer, UriKind.Absolute, out var uri)) 253if (!Uri.TryCreate(context.Request.Headers.Referer, UriKind.Absolute, out var uri)) 278if (!Uri.TryCreate(context.Request.Headers.Referer, UriKind.Absolute, out var uri)) 305if (!Uri.TryCreate(context.Request.Headers.Referer, UriKind.Absolute, out var uri)) 322if (!Uri.TryCreate(context.Request.Headers.Referer, UriKind.Absolute, out var uri)) 338if (!Uri.TryCreate(context.Request.Headers.Referer, UriKind.Absolute, out var uri)) 359if (!Uri.TryCreate(context.Request.Headers.Referer, UriKind.Absolute, out var uri)) 392if (!Uri.TryCreate(context.Request.Headers.Referer, UriKind.Absolute, out var uri)) 426if (!Uri.TryCreate(context.Request.Headers.Referer, UriKind.Absolute, out var uri)) 450if (!Uri.TryCreate(context.Request.Headers.Referer, UriKind.Absolute, out var uri)) 1107return new BindableStruct(httpContext.Request.Query["value"].ToString());

223httpContext.Request.Headers["Content-Type"] = "application/json"; 227httpContext.Request.Body = stream; 228httpContext.Request.Headers["Content-Length"] = stream.Length.ToString(CultureInfo.InvariantCulture);

92var body = await JsonSerializer.DeserializeAsync<JsonTodo>(context.Request.Body); 93context.Request.Body.Position = 0; 207var body = await context.Request.ReadFromJsonAsync<CustomTodo>(); 208context.Request.Body.Position = 0; 226if (!Uri.TryCreate(context.Request.Headers.Referer, UriKind.Absolute, out var uri)) 253if (!Uri.TryCreate(context.Request.Headers.Referer, UriKind.Absolute, out var uri)) 278if (!Uri.TryCreate(context.Request.Headers.Referer, UriKind.Absolute, out var uri)) 305if (!Uri.TryCreate(context.Request.Headers.Referer, UriKind.Absolute, out var uri)) 322if (!Uri.TryCreate(context.Request.Headers.Referer, UriKind.Absolute, out var uri)) 338if (!Uri.TryCreate(context.Request.Headers.Referer, UriKind.Absolute, out var uri)) 359if (!Uri.TryCreate(context.Request.Headers.Referer, UriKind.Absolute, out var uri)) 392if (!Uri.TryCreate(context.Request.Headers.Referer, UriKind.Absolute, out var uri)) 426if (!Uri.TryCreate(context.Request.Headers.Referer, UriKind.Absolute, out var uri)) 450if (!Uri.TryCreate(context.Request.Headers.Referer, UriKind.Absolute, out var uri)) 1107return new BindableStruct(httpContext.Request.Query["value"].ToString());

18/// Provides a parser for the Range Header in an <see cref="HttpContext.Request"/>. 23/// Returns the normalized form of the requested range if the Range Header in the <see cref="HttpContext.Request"/> is valid. 40var rawRangeHeader = context.Request.Headers.Range;

99var request = httpContext.Request; 294var serveBody = !HttpMethods.IsHead(httpContext.Request.Method);

23var applicationPath = httpContext.Request.PathBase;

62var requestHeaders = httpContext.Request.GetTypedHeaders(); 68httpContext.Request.Method = HttpMethods.Get; 101var requestHeaders = httpContext.Request.GetTypedHeaders(); 108httpContext.Request.Method = HttpMethods.Get; 140var requestHeaders = httpContext.Request.GetTypedHeaders(); 147httpContext.Request.Method = HttpMethods.Get; 174var requestHeaders = httpContext.Request.GetTypedHeaders(); 181httpContext.Request.Method = HttpMethods.Get; 211httpContext.Request.Headers.Range = rangeString; 212httpContext.Request.Method = HttpMethods.Get; 242httpContext.Request.Headers.Range = rangeString; 243httpContext.Request.Method = HttpMethods.Get; 274var requestHeaders = httpContext.Request.GetTypedHeaders(); 279httpContext.Request.Headers.Range = "bytes = 0-6"; 280httpContext.Request.Method = HttpMethods.Get; 308var requestHeaders = httpContext.Request.GetTypedHeaders(); 313httpContext.Request.Headers.Range = "bytes = 0-6"; 314httpContext.Request.Method = HttpMethods.Get;

40var requestHeaders = httpContext.Request.GetTypedHeaders(); 46httpContext.Request.Method = HttpMethods.Get; 82var requestHeaders = httpContext.Request.GetTypedHeaders(); 89httpContext.Request.Method = HttpMethods.Get; 123var requestHeaders = httpContext.Request.GetTypedHeaders(); 130httpContext.Request.Method = HttpMethods.Get; 160var requestHeaders = httpContext.Request.GetTypedHeaders(); 167httpContext.Request.Method = HttpMethods.Get; 199httpContext.Request.Headers.Range = rangeString; 200httpContext.Request.Method = HttpMethods.Get; 232httpContext.Request.Headers.Range = rangeString; 233httpContext.Request.Method = HttpMethods.Get; 266var requestHeaders = httpContext.Request.GetTypedHeaders(); 271httpContext.Request.Headers.Range = "bytes = 0-6"; 272httpContext.Request.Method = HttpMethods.Get; 302var requestHeaders = httpContext.Request.GetTypedHeaders(); 307httpContext.Request.Headers.Range = "bytes = 0-6"; 308httpContext.Request.Method = HttpMethods.Get; 343var requestHeaders = httpContext.Request.GetTypedHeaders(); 349httpContext.Request.Method = HttpMethods.Get; 428httpContext.Request.Method = "HEAD";

42var requestHeaders = httpContext.Request.GetTypedHeaders(); 45httpContext.Request.Method = HttpMethods.Get; 74var requestHeaders = httpContext.Request.GetTypedHeaders(); 78httpContext.Request.Method = HttpMethods.Get; 106var requestHeaders = httpContext.Request.GetTypedHeaders(); 110httpContext.Request.Method = HttpMethods.Get; 133var requestHeaders = httpContext.Request.GetTypedHeaders(); 137httpContext.Request.Method = HttpMethods.Get; 162var requestHeaders = httpContext.Request.GetTypedHeaders(); 164httpContext.Request.Headers.Range = rangeString; 165httpContext.Request.Method = HttpMethods.Get; 188var requestHeaders = httpContext.Request.GetTypedHeaders(); 190httpContext.Request.Headers.Range = rangeString; 191httpContext.Request.Method = HttpMethods.Get; 217var requestHeaders = httpContext.Request.GetTypedHeaders(); 219httpContext.Request.Headers.Range = "bytes = 0-6"; 220httpContext.Request.Method = HttpMethods.Get; 244var requestHeaders = httpContext.Request.GetTypedHeaders(); 246httpContext.Request.Headers.Range = "bytes = 0-6"; 247httpContext.Request.Method = HttpMethods.Get; 298var requestHeaders = httpContext.Request.GetTypedHeaders(); 301httpContext.Request.Method = HttpMethods.Get;

54var requestHeaders = httpContext.Request.GetTypedHeaders(); 57httpContext.Request.Method = HttpMethods.Get; 92var requestHeaders = httpContext.Request.GetTypedHeaders(); 96httpContext.Request.Method = HttpMethods.Get; 129var requestHeaders = httpContext.Request.GetTypedHeaders(); 133httpContext.Request.Method = HttpMethods.Get; 162var requestHeaders = httpContext.Request.GetTypedHeaders(); 166httpContext.Request.Method = HttpMethods.Get; 197var requestHeaders = httpContext.Request.GetTypedHeaders(); 198httpContext.Request.Headers.Range = rangeString; 200httpContext.Request.Method = HttpMethods.Get; 230var requestHeaders = httpContext.Request.GetTypedHeaders(); 231httpContext.Request.Headers.Range = rangeString; 233httpContext.Request.Method = HttpMethods.Get; 267var requestHeaders = httpContext.Request.GetTypedHeaders(); 269httpContext.Request.Headers.Range = "bytes = 0-6"; 270httpContext.Request.Method = HttpMethods.Get; 298var requestHeaders = httpContext.Request.GetTypedHeaders(); 300httpContext.Request.Headers.Range = "bytes = 0-6"; 301httpContext.Request.Method = HttpMethods.Get; 333var requestHeaders = httpContext.Request.GetTypedHeaders(); 336httpContext.Request.Method = HttpMethods.Get;

327TestCachedFeaturesAreNull(context.Request, features); 355TestCachedFeaturesAreSet(context.Request, features);

109var request = context.Request; 279context.Request.Body = originalBody;

118var request = context.Request;

124var res = await c.Request.Body.ReadAsync(arr); 155var res = await c.Request.Body.ReadAsync(arr); 187var res = await c.Request.Body.ReadAsync(arr); 219var res = await c.Request.Body.ReadAsync(arr); 250var res = await c.Request.Body.ReadAsync(arr); 319var res = await c.Request.Body.ReadAsync(arr); 348c.Request.Body.CopyTo(ms); 376await c.Request.Body.CopyToAsync(ms); 408var res = await c.Request.Body.ReadAsync(arr); 444var res = await c.Request.Body.ReadAsync(arr); 477var res = await c.Request.Body.ReadAsync(arr); 502_ = await c.Request.Body.ReadAsync(new byte[0]); 503var res = await c.Request.Body.ReadAsync(arr); 537var res = await c.Request.Body.ReadAsync(arr); 574var res = await c.Request.Body.ReadAsync(arr); 613var res = await c.Request.Body.ReadAsync(arr); 651var res = await c.Request.Body.ReadAsync(arr); 690var res = await c.Request.Body.ReadAsync(arr); 1510await c.Request.Body.DrainAsync(default); 1579await c.Request.Body.DrainAsync(default); 1927await c.Request.Body.ReadAsync(new byte[100]); 1993var res = await context.Request.Body.ReadAsync(arr); 2033await c.Request.Body.ReadAsync(new byte[100]); 2039await c.Request.Body.ReadAsync(new byte[100]); 2045await c.Request.Body.ReadAsync(new byte[100]); 2052await c.Request.Body.ReadAsync(new byte[100]); 2058await c.Request.Body.ReadAsync(new byte[100]); 2064await c.Request.Body.ReadAsync(new byte[100]); 2070await c.Request.Body.ReadAsync(new byte[100]); 2076await c.Request.Body.ReadAsync(new byte[100]);

49var header = httpContext.Request.Headers[_options.CertificateHeader];

127var request = context.Request; 128var requestHeaders = context.Request.Headers;

38if (HttpMethods.IsPost(context.Request.Method)) 42if (context.Request.HasFormContentType) 49var xHttpMethodOverrideValue = context.Request.Headers[xHttpMethodOverride]; 52context.Request.Method = xHttpMethodOverrideValue.ToString(); 61var form = await context.Request.ReadFormAsync(); 65context.Request.Method = methodType.ToString();

71c.Request.Headers["X-Client-Cert"] = Convert.ToBase64String(Certificates.SelfSignedValidWithNoEku.RawData); 110c.Request.Headers["X-Client-Cert"] = Convert.ToBase64String(Certificates.SelfSignedValidWithNoEku.RawData); 148c.Request.Headers["X-ARR-ClientCert"] = Convert.ToBase64String(Certificates.SelfSignedValidWithNoEku.RawData); 186c.Request.Headers["not-the-right-header"] = Convert.ToBase64String(Certificates.SelfSignedValidWithNoEku.RawData); 224c.Request.Headers["X-Client-Cert"] = "OOPS" + Convert.ToBase64String(Certificates.SelfSignedValidWithNoEku.RawData);

40c.Request.Headers["X-Forwarded-For"] = "11.111.111.11:9090"; 46Assert.False(context.Request.Headers.ContainsKey("X-Original-For")); 48Assert.False(context.Request.Headers.ContainsKey("X-Forwarded-For")); 76c.Request.Headers["X-Forwarded-For"] = header; 83Assert.False(context.Request.Headers.ContainsKey("X-Original-For")); 84Assert.True(context.Request.Headers.ContainsKey("X-Forwarded-For")); 85Assert.Equal(header, context.Request.Headers["X-Forwarded-For"]); 134c.Request.Headers["X-Forwarded-For"] = header; 141Assert.Equal(remainingHeader, context.Request.Headers["X-Forwarded-For"].ToString()); 172c.Request.Headers["X-Forwarded-For"] = "10.0.0.1:1234"; 181Assert.True(context.Request.Headers.ContainsKey("X-Original-For")); 183context.Request.Headers["X-Original-For"]); 189Assert.False(context.Request.Headers.ContainsKey("X-Original-For")); 245c.Request.Headers["X-Forwarded-For"] = header; 277c.Request.Headers["X-Forwarded-For"] = "BAD-IP"; 306c.Request.Headers["X-Forwarded-Host"] = "testhost"; 309Assert.Equal("testhost", context.Request.Host.ToString()); 365Assert.Equal(hostHeader, context.Request.Host.ToString()); 378c.Request.Headers["X-Forwarded-Host"] = hostHeader; 450Assert.NotEqual(hostHeader, context.Request.Host.Value); 463c.Request.Headers["X-Forwarded-Host"] = hostHeader; 501Assert.Equal(hostHeader, context.Request.Headers.Host); 513ctx.Request.Headers["X-forwarded-Host"] = hostHeader; 552Assert.NotEqual<string>(hostHeader, context.Request.Headers.Host); 564ctx.Request.Headers["X-forwarded-Host"] = hostHeader; 588Assert.Equal("bar.foo.com:432", context.Request.Headers.Host); 600ctx.Request.Headers["X-forwarded-Host"] = "stuff:523, bar.foo.com:432, bar.com:80"; 636c.Request.Headers["X-Forwarded-Proto"] = header; 639Assert.Equal(expected, context.Request.Scheme); 677Assert.Equal(scheme, context.Request.Scheme); 690c.Request.Headers["X-Forwarded-Proto"] = scheme; 734Assert.Equal("http", context.Request.Scheme); 747c.Request.Headers["X-Forwarded-Proto"] = scheme; 785c.Request.Headers["X-Forwarded-Proto"] = protoHeader; 786c.Request.Headers["X-Forwarded-For"] = forHeader; 789Assert.Equal(expected, context.Request.Scheme); 827c.Request.Headers["X-Forwarded-Proto"] = protoHeader; 828c.Request.Headers["X-Forwarded-For"] = forHeader; 831Assert.Equal(expected, context.Request.Scheme); 877c.Request.Headers["X-Forwarded-Proto"] = protoHeader; 878c.Request.Headers["X-Forwarded-For"] = forHeader; 882Assert.Equal(expected, context.Request.Scheme); 918c.Request.Headers["X-Forwarded-Proto"] = "Protocol"; 919c.Request.Headers["X-Forwarded-For"] = "11.111.111.11"; 920c.Request.Headers["X-Forwarded-Host"] = "testhost"; 921c.Request.Headers["X-Forwarded-Prefix"] = "/pathbase"; 925Assert.Equal("testhost", context.Request.Host.ToString()); 926Assert.Equal("Protocol", context.Request.Scheme); 927Assert.Equal("/pathbase", context.Request.PathBase); 953c.Request.Headers["X-Forwarded-Proto"] = "Protocol"; 954c.Request.Headers["X-Forwarded-For"] = "11.111.111.11"; 955c.Request.Headers["X-Forwarded-Host"] = "otherhost"; 956c.Request.Headers["X-Forwarded-Prefix"] = "/pathbase"; 960Assert.Equal("localhost", context.Request.Host.ToString()); 961Assert.Equal("http", context.Request.Scheme); 962Assert.Equal(PathString.Empty, context.Request.PathBase); 988c.Request.Headers["X-Forwarded-Proto"] = "Protocol"; 989c.Request.Headers["X-Forwarded-For"] = "11.111.111.11"; 993Assert.Equal("localhost", context.Request.Host.ToString()); 994Assert.Equal("Protocol", context.Request.Scheme); 1042c.Request.Headers["X-Forwarded-For"] = forHeader; 1081c.Request.Headers["X-Forwarded-Proto"] = header; 1084Assert.Equal(expectedScheme, context.Request.Scheme); 1085Assert.Equal(remainingHeader, context.Request.Headers["X-Forwarded-Proto"].ToString()); 1118c.Request.Headers["X-Forwarded-Proto"] = header; 1121Assert.Equal(expectedScheme, context.Request.Scheme); 1122Assert.Equal(remainingHeader, context.Request.Headers["X-Forwarded-Proto"].ToString()); 1157c.Request.Headers["X-Forwarded-Prefix"] = forwardedPrefix; 1160Assert.Equal(expectedUnescapedPathBase, context.Request.PathBase.Value); 1162Assert.False(context.Request.Headers.ContainsKey("X-Original-Prefix")); 1164Assert.False(context.Request.Headers.ContainsKey("X-Forwarded-Prefix")); 1199c.Request.PathBase = new PathString(pathBase); 1200c.Request.Headers["X-Forwarded-Prefix"] = forwardedPrefix; 1203Assert.Equal(expectedUnescapedPathBase, context.Request.PathBase.Value); 1204Assert.Equal(expectedOriginalPrefix, context.Request.Headers["X-Original-Prefix"]); 1206Assert.False(context.Request.Headers.ContainsKey("X-Forwarded-Prefix")); 1235c.Request.Headers["X-Forwarded-Prefix"] = forwardedPrefix; 1238Assert.Equal(PathString.Empty, context.Request.PathBase); 1239Assert.False(context.Request.Headers.ContainsKey("X-Original-Prefix")); 1240Assert.True(context.Request.Headers.ContainsKey("X-Forwarded-Prefix")); 1279c.Request.Headers["X-Forwarded-For"] = forwardedFor; 1280c.Request.Headers["X-Forwarded-Host"] = forwardedHost; 1281c.Request.Headers["X-Forwarded-Proto"] = forwardedProto; 1282c.Request.Headers["X-Forwarded-Prefix"] = forwardedPrefix; 1285Assert.Equal(PathString.Empty, context.Request.PathBase); 1286Assert.False(context.Request.Headers.ContainsKey("X-Original-For")); 1287Assert.False(context.Request.Headers.ContainsKey("X-Original-Host")); 1288Assert.False(context.Request.Headers.ContainsKey("X-Original-Proto")); 1289Assert.False(context.Request.Headers.ContainsKey("X-Original-Prefix")); 1290Assert.True(context.Request.Headers.ContainsKey("X-Forwarded-For")); 1291Assert.True(context.Request.Headers.ContainsKey("X-Forwarded-Host")); 1292Assert.True(context.Request.Headers.ContainsKey("X-Forwarded-Proto")); 1293Assert.True(context.Request.Headers.ContainsKey("X-Forwarded-Prefix")); 1325c.Request.Headers["X-Forwarded-Prefix"] = forwardedPrefix; 1328Assert.Equal(expectedforwardedPrefix, context.Request.Headers["X-Forwarded-Prefix"].ToString());

29Assert.Equal("DELETE", context.Request.Method); 59Assert.Equal("POST", context.Request.Method); 89Assert.Equal("GET", context.Request.Method); 122Assert.Equal("DELETE", context.Request.Method); 160Assert.Equal("POST", context.Request.Method); 197Assert.Equal("POST", context.Request.Method);

64if (!context.Request.IsHttps) 70if (IsHostExcluded(context.Request.Host.Host)) 72_logger.SkippingExcludedHost(context.Request.Host.Host);

80if (context.Request.IsHttps) 91var host = context.Request.Host; 101var request = context.Request;

300var req = context.Request;

27var acceptLanguageHeader = httpContext.Request.GetTypedHeaders().AcceptLanguage;

33var cookie = httpContext.Request.Cookies[CookieName];

31var request = httpContext.Request;

67var segments = context.Request.Path.Value.Split(new char[] { '/' }, StringSplitOptions.RemoveEmptyEntries);

69var request = context.HttpContext.Request;

68var request = context.RouteContext.HttpContext.Request;

35_supportsNonGetRequests = context => !HttpMethods.IsGet(context.HttpContext.Request.Method);

86return !HttpMethods.IsGet(context.HttpContext.Request.Method);

114var requestContentType = context.HttpContext.Request.ContentType; 160var requestContentType = context.RouteContext.HttpContext.Request.ContentType;

42public HttpRequest Request => HttpContext?.Request!;

69var request = context.HttpContext.Request;

40features.Set<IFormFeature>(new FormFeature(context.HttpContext.Request, FormOptions));

46var query = context.HttpContext.Request.Query["format"];

55var contentType = context.HttpContext.Request.ContentType; 98canHaveBody ??= context.HttpContext.Request.ContentLength != 0;

130return (httpContext.Request.Body, false); 133var inputStream = Encoding.CreateTranscodingStream(httpContext.Request.Body, encoding, Encoding.UTF8, leaveOpen: true);

43context.HttpContext.Request.ContentType); 84var requestContentType = context.HttpContext.Request.ContentType;

172var request = context.HttpContext.Request;

72var request = context.HttpContext.Request;

136hasBody ??= httpContext.Request.ContentLength is not null && httpContext.Request.ContentLength == 0; 146var message = Resources.FormatUnsupportedContentType(httpContext.Request.ContentType); 206var contentType = formatterContext.HttpContext.Request.ContentType; 218var contentType = formatterContext.HttpContext.Request.ContentType; 230var contentType = formatterContext.HttpContext.Request.ContentType; 232if (formatterContext.HttpContext.Request.HasFormContentType)

40var request = bindingContext.HttpContext.Request;

140var request = bindingContext.HttpContext.Request;

62var request = bindingContext.HttpContext.Request; 102var request = bindingContext.HttpContext.Request; 125var request = bindingContext.HttpContext.Request;

21var request = context.ActionContext.HttpContext.Request;

22var request = context.ActionContext.HttpContext.Request; 34var request = context.ActionContext.HttpContext.Request;

22var request = context.ActionContext.HttpContext.Request; 34var request = context.ActionContext.HttpContext.Request;

20var query = context.ActionContext.HttpContext.Request.Query;

21var query = context.ActionContext.HttpContext.Request.Query;

45if (!filterContext.HttpContext.Request.IsHttps) 66if (!HttpMethods.IsGet(filterContext.HttpContext.Request.Method)) 74var request = filterContext.HttpContext.Request;

531routeData.PushState(router: null, context.Request.RouteValues, new RouteValueDictionary(dataTokens?.DataTokens));

74routeData = new RouteData(context.Request.RouteValues); 79routeData.PushState(router: null, context.Request.RouteValues, dataTokens);

60Protocol = ActionContext.HttpContext.Request.Scheme, 61Host = ActionContext.HttpContext.Request.Host.ToUriComponent() 131var pathBase = ActionContext.HttpContext.Request.PathBase; 149host = string.IsNullOrEmpty(host) ? ActionContext.HttpContext.Request.Host.Value : host; 211host = string.IsNullOrEmpty(host) ? ActionContext.HttpContext.Request.Host.Value : host; 305var applicationPath = httpContext.Request.PathBase; 470var pathBase = ActionContext.HttpContext.Request.PathBase;

95var requestCookies = context.Request.Cookies; 161var requestCookies = context.Request.Cookies; 236var requestCookies = context.Request.Cookies;

18/// Provides a parser for the Range Header in an <see cref="HttpContext.Request"/>. 23/// Returns the normalized form of the requested range if the Range Header in the <see cref="HttpContext.Request"/> is valid. 40var rawRangeHeader = context.Request.Headers.Range;

99var request = httpContext.Request; 294var serveBody = !HttpMethods.IsHead(httpContext.Request.Method);

23var applicationPath = httpContext.Request.PathBase;

529protocol = httpContext.Request.Scheme; 534host = httpContext.Request.Host.ToUriComponent(); 578protocol = httpContext.Request.Scheme; 583host = httpContext.Request.Host.ToUriComponent();

3015httpContext.Setup(c => c.Request)

808controllerContext.HttpContext.Request.Method = "GET"; 871controllerContext.HttpContext.Request.Method = "POST";

405httpContext.Request.Headers.IfModifiedSince = HeaderUtilities.FormatDate(ifModifiedSince); 443httpContext.Request.Headers.IfUnmodifiedSince = HeaderUtilities.FormatDate(ifUnmodifiedSince);

43var oldFormFeature = new FormFeature(authorizationFilterContext.HttpContext.Request); 66authorizationFilterContext.HttpContext.Request.Form = new FormCollection(null); 117new FormFeature(authorizationFilterContext.HttpContext.Request));

69httpContext.Setup(c => c.Request.Query.ContainsKey("format")).Returns(true); 70httpContext.Setup(c => c.Request.Query["format"]).Returns("xml"); 329httpContext.Setup(c => c.Request.Query["format"]).Returns("json"); 366httpContext.Setup(c => c.Request.Query["format"]).Returns("json"); 401httpContext.Setup(c => c.Request.Query.ContainsKey("format")).Returns(false); 436httpContext.Setup(c => c.Request.Query.ContainsKey("format")).Returns(false); 441httpContext.Setup(c => c.Request.Query.ContainsKey("format")).Returns(true); 442httpContext.Setup(c => c.Request.Query["format"]).Returns(format); 446httpContext.Setup(c => c.Request.Query.ContainsKey("format")).Returns(false);

421context.HttpContext.Request.ContentLength = 0;

124Assert.True(httpContext.Request.Body.CanRead, "Verify that the request stream hasn't been disposed"); 546var testBufferedReadStream = new VerifyDisposeFileBufferingReadStream(httpContext.Request.Body, 1024); 547httpContext.Request.Body = testBufferedReadStream; 569httpContext.Request.EnableBuffering(); 579var requestBody = httpContext.Request.Body; 593httpContext.Request.EnableBuffering(); 594var requestBody = httpContext.Request.Body;

26context.HttpContext.Request.ContentType = "application/json;charset=utf-8"; 27context.HttpContext.Request.ContentLength = 1; 54context.HttpContext.Request.ContentLength = 1; 76context.HttpContext.Request.ContentType = "application/json;charset=" + charset; 100context.HttpContext.Request.ContentType = "application/json;charset=utf-8"; 126context.HttpContext.Request.ContentType = "application/json;charset=" + charset; 160context.HttpContext.Request.ContentType = "application/json;charset=\"" + charset + "\""; 194context.HttpContext.Request.ContentType = contentType;

45httpContext.SetupGet(o => o.Request).Returns(httpRequest);

1110httpContext.SetupGet(c => c.Request).Returns(request.Object);

33context.HttpContext.Request.Headers.Accept = "application/xml"; // This will not be used 63context.HttpContext.Request.Headers.Accept = "application/xml"; // This will not be used 92context.HttpContext.Request.Headers.Accept = "application/xml"; // This will not be used 163context.HttpContext.Request.Headers.Accept = acceptHeader; 222context.HttpContext.Request.Headers.Accept = "text/custom,application/custom"; 257context.HttpContext.Request.Headers.Accept = "text/custom,application/custom"; 286context.HttpContext.Request.Headers.Accept = "text/custom"; 315context.HttpContext.Request.Headers.Accept = "text/custom, text/custom2";

99httpContext.Request.Headers.Accept = "application/xml"; // This will not be used 389actionContext.HttpContext.Request.Headers.Accept = acceptHeader; 426actionContext.HttpContext.Request.Headers.Accept = acceptHeader;

604bindingContext.HttpContext.Request.ContentType = "application/json"; 633bindingContext.HttpContext.Request.ContentType = "multipart/form-data";

60httpContext.Setup(h => h.Request.ReadFormAsync(It.IsAny<CancellationToken>())) 62httpContext.Setup(h => h.Request.HasFormContentType).Returns(hasForm);

475httpContext.Setup(h => h.Request.ReadFormAsync(It.IsAny<CancellationToken>())) 477httpContext.Setup(h => h.Request.HasFormContentType).Returns(true);

28bindingContext.HttpContext.Request.Headers.Add(header, new[] { headerValue }); 50bindingContext.HttpContext.Request.Headers.Add(header, new[] { headerValue }); 77bindingContext.HttpContext.Request.Headers.Add(header, new[] { headerValue }); 96bindingContext.HttpContext.Request.Headers.Add("Header", new[] { headerValue }); 146bindingContext.HttpContext.Request.Headers.Add("Header", headerValue); 206bindingContext.HttpContext.Request.Headers.Add("Header", new[] { headerValue }); 223bindingContext.HttpContext.Request.Headers.Add("Header", "application/json,text/json"); 240bindingContext.HttpContext.Request.Headers.Add("Header", "application/json,text/json"); 264bindingContext.HttpContext.Request.Headers.Add("Header", "application/json,text/json"); 286bindingContext.HttpContext.Request.Headers.Add("Header", headerValue); 310bindingContext.HttpContext.Request.Headers.Add("Header", headerValue);

48var files = (FormFileCollection)context.ActionContext.HttpContext.Request.Form.Files; 105context.Setup(c => c.Request.ContentType).Returns("application/x-www-form-urlencoded"); 106context.Setup(c => c.Request.HasFormContentType).Returns(true); 107context.Setup(c => c.Request.ReadFormAsync(It.IsAny<CancellationToken>())).ThrowsAsync(exception);

93context.Setup(c => c.Request.ContentType).Returns("application/x-www-form-urlencoded"); 94context.Setup(c => c.Request.HasFormContentType).Returns(true); 95context.Setup(c => c.Request.ReadFormAsync(It.IsAny<CancellationToken>())).ThrowsAsync(exception);

178context.Setup(c => c.Request.ContentType).Returns("application/x-www-form-urlencoded"); 179context.Setup(c => c.Request.HasFormContentType).Returns(true); 180context.Setup(c => c.Request.ReadFormAsync(It.IsAny<CancellationToken>())).ThrowsAsync(exception);

58httpContext.Request.PathBase = new PathString("/Foo/Bar?encodeme?"); 116httpContext.Request.PathBase = new PathString("/Foo/Bar?encodeme?"); 177httpContext.Request.Scheme = "http"; 178httpContext.Request.Host = new HostString("example.com"); 179httpContext.Request.PathBase = new PathString("/Foo/Bar?encodeme?");

56urlHelper.ActionContext.HttpContext.Request.RouteValues = new RouteValueDictionary

30httpContext.Request.PathBase = new PathString("/Foo/Bar?encodeme?"); 87httpContext.Request.PathBase = new PathString("/Foo/Bar?encodeme?"); 147httpContext.Request.Scheme = "http"; 148httpContext.Request.Host = new HostString("example.com"); 149httpContext.Request.PathBase = new PathString("/Foo/Bar?encodeme?");

47UrlHelperBase.AppendPathAndFragment(builder, httpContext.Request.PathBase, virtualPath, string.Empty); 68UrlHelperBase.AppendPathAndFragment(builder, httpContext.Request.PathBase, virtualPath, fragmentValue);

62var requestHeaders = httpContext.Request.GetTypedHeaders(); 68httpContext.Request.Method = HttpMethods.Get; 101var requestHeaders = httpContext.Request.GetTypedHeaders(); 108httpContext.Request.Method = HttpMethods.Get; 140var requestHeaders = httpContext.Request.GetTypedHeaders(); 147httpContext.Request.Method = HttpMethods.Get; 174var requestHeaders = httpContext.Request.GetTypedHeaders(); 181httpContext.Request.Method = HttpMethods.Get; 211httpContext.Request.Headers.Range = rangeString; 212httpContext.Request.Method = HttpMethods.Get; 242httpContext.Request.Headers.Range = rangeString; 243httpContext.Request.Method = HttpMethods.Get; 274var requestHeaders = httpContext.Request.GetTypedHeaders(); 279httpContext.Request.Headers.Range = "bytes = 0-6"; 280httpContext.Request.Method = HttpMethods.Get; 308var requestHeaders = httpContext.Request.GetTypedHeaders(); 313httpContext.Request.Headers.Range = "bytes = 0-6"; 314httpContext.Request.Method = HttpMethods.Get;

40var requestHeaders = httpContext.Request.GetTypedHeaders(); 46httpContext.Request.Method = HttpMethods.Get; 82var requestHeaders = httpContext.Request.GetTypedHeaders(); 89httpContext.Request.Method = HttpMethods.Get; 123var requestHeaders = httpContext.Request.GetTypedHeaders(); 130httpContext.Request.Method = HttpMethods.Get; 160var requestHeaders = httpContext.Request.GetTypedHeaders(); 167httpContext.Request.Method = HttpMethods.Get; 199httpContext.Request.Headers.Range = rangeString; 200httpContext.Request.Method = HttpMethods.Get; 232httpContext.Request.Headers.Range = rangeString; 233httpContext.Request.Method = HttpMethods.Get; 266var requestHeaders = httpContext.Request.GetTypedHeaders(); 271httpContext.Request.Headers.Range = "bytes = 0-6"; 272httpContext.Request.Method = HttpMethods.Get; 302var requestHeaders = httpContext.Request.GetTypedHeaders(); 307httpContext.Request.Headers.Range = "bytes = 0-6"; 308httpContext.Request.Method = HttpMethods.Get; 343var requestHeaders = httpContext.Request.GetTypedHeaders(); 349httpContext.Request.Method = HttpMethods.Get; 428httpContext.Request.Method = "HEAD";

42var requestHeaders = httpContext.Request.GetTypedHeaders(); 45httpContext.Request.Method = HttpMethods.Get; 74var requestHeaders = httpContext.Request.GetTypedHeaders(); 78httpContext.Request.Method = HttpMethods.Get; 106var requestHeaders = httpContext.Request.GetTypedHeaders(); 110httpContext.Request.Method = HttpMethods.Get; 133var requestHeaders = httpContext.Request.GetTypedHeaders(); 137httpContext.Request.Method = HttpMethods.Get; 162var requestHeaders = httpContext.Request.GetTypedHeaders(); 164httpContext.Request.Headers.Range = rangeString; 165httpContext.Request.Method = HttpMethods.Get; 188var requestHeaders = httpContext.Request.GetTypedHeaders(); 190httpContext.Request.Headers.Range = rangeString; 191httpContext.Request.Method = HttpMethods.Get; 217var requestHeaders = httpContext.Request.GetTypedHeaders(); 219httpContext.Request.Headers.Range = "bytes = 0-6"; 220httpContext.Request.Method = HttpMethods.Get; 244var requestHeaders = httpContext.Request.GetTypedHeaders(); 246httpContext.Request.Headers.Range = "bytes = 0-6"; 247httpContext.Request.Method = HttpMethods.Get; 298var requestHeaders = httpContext.Request.GetTypedHeaders(); 301httpContext.Request.Method = HttpMethods.Get;

54var requestHeaders = httpContext.Request.GetTypedHeaders(); 57httpContext.Request.Method = HttpMethods.Get; 92var requestHeaders = httpContext.Request.GetTypedHeaders(); 96httpContext.Request.Method = HttpMethods.Get; 129var requestHeaders = httpContext.Request.GetTypedHeaders(); 133httpContext.Request.Method = HttpMethods.Get; 162var requestHeaders = httpContext.Request.GetTypedHeaders(); 166httpContext.Request.Method = HttpMethods.Get; 197var requestHeaders = httpContext.Request.GetTypedHeaders(); 198httpContext.Request.Headers.Range = rangeString; 200httpContext.Request.Method = HttpMethods.Get; 230var requestHeaders = httpContext.Request.GetTypedHeaders(); 231httpContext.Request.Headers.Range = rangeString; 233httpContext.Request.Method = HttpMethods.Get; 267var requestHeaders = httpContext.Request.GetTypedHeaders(); 269httpContext.Request.Headers.Range = "bytes = 0-6"; 270httpContext.Request.Method = HttpMethods.Get; 298var requestHeaders = httpContext.Request.GetTypedHeaders(); 300httpContext.Request.Headers.Range = "bytes = 0-6"; 301httpContext.Request.Method = HttpMethods.Get; 333var requestHeaders = httpContext.Request.GetTypedHeaders(); 336httpContext.Request.Method = HttpMethods.Get;

75var request = httpContext.Request; 90httpContext.Request.Headers[CorsConstants.AccessControlRequestMethod];

30var request = context.RouteContext.HttpContext.Request;

27context.HttpContext.Request.Headers[CorsConstants.AccessControlRequestMethod]; 29context.HttpContext.Request.Method,

33authorizationContext.HttpContext.Request.Method = preflightRequestMethod;

104var request = context.HttpContext.Request;

88var request = context.HttpContext.Request;

472Assert.True(context.HttpContext.Request.Body.CanRead); 747httpContext.SetupGet(c => c.Request).Returns(request.Object); 748httpContext.SetupGet(c => c.Request).Returns(request.Object);

708outputFormatterContext.HttpContext.Request.QueryString = new QueryString("?indent=" + indent); 831var request = context.HttpContext.Request;

489Assert.True(context.HttpContext.Request.Body.CanRead); 683httpContext.SetupGet(c => c.Request).Returns(request.Object);

92outputFormatterContext.HttpContext.Request.QueryString = new QueryString("?indent=" + indent); 621var request = context.HttpContext.Request;

111context.Request.Body = new SizeLimitedStream(context.Request.Body, context.Features.Get<IHttpMaxRequestBodySizeFeature>()?.MaxRequestBodySize);

229public bool CanHaveBody => _context.Request.ContentLength != 0;

102var request = httpContext.Request;

453httpContext.Setup(h => h.Request.Body).Returns(new NonSeekableReadStream(content, allowSyncReads: false)); 454httpContext.Setup(h => h.Request.ContentType).Returns("application/json"); 455httpContext.Setup(h => h.Request.ContentLength).Returns(content.Length);

267httpContext.SetupGet(c => c.Request).Returns(request.Object);

124Assert.True(httpContext.Request.Body.CanRead, "Verify that the request stream hasn't been disposed"); 546var testBufferedReadStream = new VerifyDisposeFileBufferingReadStream(httpContext.Request.Body, 1024); 547httpContext.Request.Body = testBufferedReadStream; 569httpContext.Request.EnableBuffering(); 579var requestBody = httpContext.Request.Body; 593httpContext.Request.EnableBuffering(); 594var requestBody = httpContext.Request.Body;

25_supportsNonGetRequests = context => !HttpMethods.IsGet(context.HttpContext.Request.Method);

88var httpMethod = context.HttpContext.Request.Method; 155if (context.HttpContext.Request.Query.TryGetValue(Handler, out var queryValues)) 166return HttpMethods.IsHead(context.HttpContext.Request.Method) ? HttpMethods.Get : null;

41HttpMethods.IsOptions(context.HttpContext.Request.Method))

86routeData = new RouteData(context.Request.RouteValues); 91routeData.PushState(router: null, context.Request.RouteValues, dataTokens);

47public HttpRequest Request => HttpContext?.Request!;

66public HttpRequest Request => HttpContext?.Request!;

47context.HttpContext.Request.Method = "PUT"; 63context.HttpContext.Request.Method = "DELETE"; 80context.HttpContext.Request.Method = "Options"; 98context.HttpContext.Request.Method = "Options"; 114context.HttpContext.Request.Method = "Options";

457page.HttpContext.Request.Method = "Post";

82var request = httpContext.Request;

144var pathBase = ViewContext.HttpContext.Request.PathBase;

477ViewContext.HttpContext.Request.PathBase); 536var pathBase = ViewContext.HttpContext.Request.PathBase;

14var pathBase = viewContext.HttpContext.Request.PathBase;

416var pathBase = ViewContext.HttpContext.Request.PathBase; 465ViewContext.HttpContext.Request.PathBase);

105cacheTagHelper1.ViewContext.HttpContext.Request.QueryString = new QueryString( 127cacheTagHelper2.ViewContext.HttpContext.Request.QueryString = new QueryString( 156cacheTagHelper1.ViewContext.HttpContext.Request.Headers["Cookie"] = "cookie1=value1;cookie2=value2"; 178cacheTagHelper2.ViewContext.HttpContext.Request.Headers["Cookie"] = "cookie1=value1;cookie2=not-value2";

211cacheTagHelper.ViewContext.HttpContext.Request.Headers["Cookie"] = 237var headers = cacheTagHelper.ViewContext.HttpContext.Request.Headers; 265cacheTagHelper.ViewContext.HttpContext.Request.QueryString = 404cacheTagHelper.ViewContext.HttpContext.Request.Headers["Content-Type"] = "text/html"; 431cacheTagHelper.ViewContext.HttpContext.Request.Headers["Content-Type"] = "text/html";

148cacheTagHelper1.ViewContext.HttpContext.Request.QueryString = new QueryString( 173cacheTagHelper2.ViewContext.HttpContext.Request.QueryString = new QueryString( 208cacheTagHelper1.ViewContext.HttpContext.Request.Headers["Cookie"] = "cookie1=value1;cookie2=value2"; 232cacheTagHelper2.ViewContext.HttpContext.Request.Headers["Cookie"] = "cookie1=value1;cookie2=not-value2";

154viewContext.HttpContext.Request.Path = "/home/index";

200helper.ViewContext.HttpContext.Request.PathBase = new PathString(pathBase); 296actionContext.HttpContext.Request.PathBase = new Http.PathString(requestPathBase);

792helper.ViewContext.HttpContext.Request.PathBase = "/approot"; 1127actionContext.HttpContext.Request.PathBase = new PathString(requestPathBase);

697helper.ViewContext.HttpContext.Request.PathBase = "/approot"; 1052helper.ViewContext.HttpContext.Request.PathBase = "/approot"; 1108actionContext.HttpContext.Request.PathBase = new PathString(requestPathBase);

60if (context.Request.Cookies.ContainsKey(_options.Cookie.Name)) 131var pathBase = httpContext.Request.PathBase.ToString();

281var request = viewContext.HttpContext.Request;

22var method = context.HttpContext.Request.Method;

39public HttpRequest Request => ViewContext?.HttpContext?.Request!;

335httpContext.Request.Headers.Cookie = stringBuilder.ToString();

32actionContext.HttpContext.Request.Method = httpMethod; 60actionContext.HttpContext.Request.Method = httpMethod; 84actionContext.HttpContext.Request.Method = "POST";

36actionContext.HttpContext.Request.Method = httpMethod; 60actionContext.HttpContext.Request.Method = "POST"; 88actionContext.HttpContext.Request.Method = "POST";

135var request = htmlHelper.ViewContext.HttpContext.Request; 185var request = htmlHelper.ViewContext.HttpContext.Request;

78context.HttpContext.Request.Headers["HeaderA"] = "ValueA"; 79context.HttpContext.Request.Headers["HeaderB"] = "ValueB"; 94context.HttpContext.Request.QueryString = new QueryString("?QueryA=ValueA&QueryB=ValueB"); 109context.HttpContext.Request.RouteValues = new Routing.RouteValueDictionary()

20context.HttpContext.Request.Method = "head"; 21context.HttpContext.Request.Path = "/path/subpath"; 22context.HttpContext.Request.Scheme = "https"; 23context.HttpContext.Request.Host = new HostString("example.com", 80); 24context.HttpContext.Request.PathBase = "/pathBase"; 25context.HttpContext.Request.QueryString = new QueryString("?query.Key=a&query.Value=b"); 37context.HttpContext.Request.Method = "head"; 38context.HttpContext.Request.Path = "/path/subpath"; 39context.HttpContext.Request.Scheme = "https"; 40context.HttpContext.Request.Host = new HostString("example.com", 80); 41context.HttpContext.Request.PathBase = "/pathBase"; 42context.HttpContext.Request.QueryString = new QueryString("?query.Key=a&query.Value=b"); 56context.HttpContext.Request.Method = HttpMethods.Get; 57context.HttpContext.Request.Path = "/Path"; 70context.HttpContext.Request.Method = HttpMethods.Get; 71context.HttpContext.Request.Path = "/Path"; 99context.HttpContext.Request.RouteValues["RouteA"] = "ValueA"; 100context.HttpContext.Request.RouteValues["RouteB"] = "ValueB"; 112context.HttpContext.Request.RouteValues["RouteA"] = 123.456; 145context.HttpContext.Request.Headers["HeaderA"] = "ValueA"; 146context.HttpContext.Request.Headers["HeaderB"] = "ValueB"; 158context.HttpContext.Request.Headers["HeaderA"] = "ValueA"; 170context.HttpContext.Request.Headers["HeaderA"] = "ValueB"; 171context.HttpContext.Request.Headers.Append("HeaderA", "ValueA"); 183context.HttpContext.Request.QueryString = new QueryString("?QueryA=ValueA&QueryB=ValueB"); 196context.HttpContext.Request.QueryString = new QueryString("?queryA=ValueA&queryB=ValueB"); 209context.HttpContext.Request.QueryString = new QueryString("?queryA=ValueA"); 222context.HttpContext.Request.QueryString = new QueryString("?QueryA=ValueA&QueryB=ValueB"); 237context.HttpContext.Request.QueryString = new QueryString("?QueryA=ValueA&QueryA=ValueB"); 252context.HttpContext.Request.QueryString = new QueryString("?QueryA=ValueB&QueryA=ValueA"); 267context.HttpContext.Request.Headers["HeaderA"] = "ValueA"; 268context.HttpContext.Request.Headers["HeaderB"] = "ValueB"; 269context.HttpContext.Request.QueryString = new QueryString("?QueryA=ValueA&QueryB=ValueB"); 270context.HttpContext.Request.RouteValues["RouteA"] = "ValueA"; 271context.HttpContext.Request.RouteValues["RouteB"] = "ValueB"; 286context.HttpContext.Request.Path = "/path" + KeyDelimiter; 301context.HttpContext.Request.Host = new HostString("example.com" + KeyDelimiter, 80); 311context.HttpContext.Request.PathBase = "/pathBase" + KeyDelimiter; 323context.HttpContext.Request.Headers["HeaderA"] = "ValueA" + KeyDelimiter; 324context.HttpContext.Request.Headers["HeaderB"] = "ValueB"; 337context.HttpContext.Request.Headers["HeaderA"] = "ValueA"; 338context.HttpContext.Request.Headers["HeaderB"] = "ValueB" + KeyDelimiter; 351context.HttpContext.Request.QueryString = new QueryString($"?QueryA=ValueA{KeyDelimiter}&QueryB=ValueB"); 364context.HttpContext.Request.QueryString = new QueryString($"?QueryA{KeyDelimiter}=ValueA&QueryB=ValueB"); 377context.HttpContext.Request.QueryString = new QueryString($"?QueryA=ValueA&QueryB=ValueB{KeyDelimiter}"); 390context.HttpContext.Request.RouteValues["RouteA"] = "ValueA" + KeyDelimiter; 391context.HttpContext.Request.RouteValues["RouteB"] = "ValueB"; 404context.HttpContext.Request.RouteValues["RouteA"] = "ValueA"; 405context.HttpContext.Request.RouteValues["RouteB"] = "ValueB" + KeyDelimiter; 419context.HttpContext.Request.RouteValues["RouteA"] = "ValueA";

39context.HttpContext.Request.Headers.CacheControl = new CacheControlHeaderValue() 133context.HttpContext.Request.Headers.IfNoneMatch = "*"; 179context.HttpContext.Request.Headers.IfModifiedSince = HeaderUtilities.FormatDate(utcNow); 217context.HttpContext.Request.Headers.IfModifiedSince = HeaderUtilities.FormatDate(utcNow); 260context.HttpContext.Request.Headers.IfModifiedSince = HeaderUtilities.FormatDate(utcNow); 263context.HttpContext.Request.Headers.IfNoneMatch = EntityTagHeaderValue.Any.ToString(); 281context.HttpContext.Request.Headers.IfModifiedSince = HeaderUtilities.FormatDate(utcNow); 284context.HttpContext.Request.Headers.IfNoneMatch = "\"E1\""; 297context.HttpContext.Request.Headers.IfNoneMatch = "\"E1\""; 327context.HttpContext.Request.Headers.IfNoneMatch = requestETag.ToString(); 344context.HttpContext.Request.Headers.IfNoneMatch = "\"E1\""; 359context.HttpContext.Request.Headers.IfNoneMatch = new string[] { "\"E0\", \"E1\"", "\"E1\", \"E2\"" }; 640context.HttpContext.Request.Method = method; 669context.HttpContext.Request.Method = "HEAD"; 832context1.HttpContext.Request.Method = "GET"; 833context1.HttpContext.Request.Path = "/"; 836context2.HttpContext.Request.Method = "GET"; 837context2.HttpContext.Request.Path = "/"; 883context1.HttpContext.Request.Method = "GET"; 884context1.HttpContext.Request.Path = "/"; 888context2.HttpContext.Request.Method = "GET"; 889context2.HttpContext.Request.Path = "/"; 947context1.HttpContext.Request.Method = "GET"; 948context1.HttpContext.Request.Path = "/"; 951context2.HttpContext.Request.Method = "GET"; 952context2.HttpContext.Request.Path = "/"; 973context.HttpContext.Request.Method = "GET"; 995context.AllowCacheLookup = !context.HttpContext.Request.Headers.ContainsKey("X-Refresh"); 1043requestContext.HttpContext.Request.Method = "GET"; 1044requestContext.HttpContext.Request.Path = "/"; 1050requestContext.HttpContext.Request.Headers.Add("X-Refresh", "randomvalue");

107context.HttpContext.Request.Headers["HeaderA"] = "ValueA"; 108context.HttpContext.Request.Headers["HeaderB"] = "ValueB"; 124context.HttpContext.Request.QueryString = new QueryString("?QueryA=ValueA&QueryB=ValueB"); 140context.HttpContext.Request.RouteValues = new Routing.RouteValueDictionary() 160context.HttpContext.Request.RouteValues = new Routing.RouteValueDictionary() 180context.HttpContext.Request.RouteValues = new Routing.RouteValueDictionary()

49context.HttpContext.Request.Method = method; 68context.HttpContext.Request.Method = method; 81context.HttpContext.Request.Method = HttpMethods.Get; 82context.HttpContext.Request.Headers.Authorization = "Placeholder"; 97context.HttpContext.Request.Method = HttpMethods.Get; 98context.HttpContext.Request.Headers.CacheControl = new CacheControlHeaderValue() 115context.HttpContext.Request.Method = HttpMethods.Get; 116context.HttpContext.Request.Headers.Pragma = "no-cache"; 117context.HttpContext.Request.Headers.CacheControl = "max-age=10";

889var builders = TestUtils.CreateBuildersWithOutputCaching(contextAction: context => context.Response.Headers.Vary = context.Request.Headers.Pragma);

39if (context.Request.Method != "HEAD")

119if (context.Request.IsHttps)

22context.Request.Method = "SomeMethod"; 24context.Request.Body = Stream.Null; 25context.Request.Headers["CustomRequestHeader"] = "CustomRequestValue"; 26context.Request.Path = new PathString("/path"); 27context.Request.PathBase = new PathString("/pathBase"); 28context.Request.Protocol = "http/1.0"; 29context.Request.QueryString = new QueryString("?key=value"); 30context.Request.Scheme = "http"; 84Assert.Equal("SomeMethod", context.Request.Method); 85Assert.Same(Stream.Null, context.Request.Body); 86Assert.Equal("CustomRequestValue", context.Request.Headers["CustomRequestHeader"]); 87Assert.Equal("/path", context.Request.Path.Value); 88Assert.Equal("/pathBase", context.Request.PathBase.Value); 89Assert.Equal("http/1.0", context.Request.Protocol); 90Assert.Equal("?key=value", context.Request.QueryString.Value); 91Assert.Equal("http", context.Request.Scheme);

32var encodings = context.Request.Headers.ContentEncoding; 52context.Request.Headers.Remove(HeaderNames.ContentEncoding); 54return matchingProvider.GetDecompressionStream(context.Request.Body);

58var request = context.Request.Body; 65context.Request.Body = new SizeLimitedStream(decompressionStream, sizeLimit); 70context.Request.Body = request;

228await context.Request.Body.CopyToAsync(ms, context.RequestAborted); 296contentEncodingHeader = context.Request.Headers.ContentEncoding; 299await context.Request.Body.CopyToAsync(ms, context.RequestAborted); 375await context.Request.Body.CopyToAsync(ms, context.RequestAborted); 474await context.Request.Body.CopyToAsync(ms, context.RequestAborted); 558await context.Request.Body.CopyToAsync(ms, context.RequestAborted); 712await context.Request.Body.CopyToAsync(ms, context.RequestAborted);

41var request = context.HttpContext.Request; 90var request = context.HttpContext.Request; 106var requestHeaders = context.HttpContext.Request.Headers; 135var queryArray = context.HttpContext.Request.Query.ToArray(); 164var queryKeyValues = context.HttpContext.Request.Query[queryKey];

230if (HeaderUtilities.ContainsCacheDirective(context.HttpContext.Request.Headers.CacheControl, CacheControlHeaderValue.OnlyIfCachedString)) 343&& HttpMethods.IsHead(context.HttpContext.Request.Method))) 431var ifNoneMatchHeader = context.HttpContext.Request.Headers.IfNoneMatch; 459var ifModifiedSince = context.HttpContext.Request.Headers.IfModifiedSince;

14var request = context.HttpContext.Request; 35var requestHeaders = context.HttpContext.Request.Headers; 63return !HeaderUtilities.ContainsCacheDirective(context.HttpContext.Request.Headers.CacheControl, CacheControlHeaderValue.NoStoreString); 170var requestCacheControlHeaders = context.HttpContext.Request.Headers.CacheControl;

848var builders = TestUtils.CreateBuildersWithResponseCaching(contextAction: context => context.Response.Headers.Vary = context.Request.Headers.Pragma); 883var builders = TestUtils.CreateBuildersWithResponseCaching(contextAction: context => context.Response.Headers.Vary = context.Request.Headers.Pragma);

36var expires = context.Request.Query["Expires"]; 58var contentLength = context.Request.Query["ContentLength"]; 64if (context.Request.Method != "HEAD")

59if (!_compressionChecked && HttpMethods.IsHead(_context.Request.Method))

78var accept = context.Request.Headers.AcceptEncoding; 168if (context.Request.IsHttps 221if (string.IsNullOrEmpty(context.Request.Headers.AcceptEncoding))

1261if (HttpMethods.IsHead(context.Request.Method))

24var initMatchRes = InitialMatch.Evaluate(context.HttpContext.Request.Path, context);

42var path = context.HttpContext.Request.Path;

17return context.HttpContext.Request.Headers[_header];

12return context.HttpContext.Request.IsHttps ? "on" : "off";

12return context.HttpContext.Request.IsHttps ? "ON" : "OFF";

10var queryString = context.HttpContext.Request.QueryString.ToString();

10return context.HttpContext.Request.Path;

10return context.HttpContext.Request.Method;

10return context.HttpContext.Request.Scheme;

12return context.HttpContext.Request.Host.Host.ToString(CultureInfo.InvariantCulture);

25return _uriMatchPart == UriMatchPart.Full ? context.HttpContext.Request.GetEncodedUrl() : (string)context.HttpContext.Request.Path;

29var request = context.HttpContext.Request;

17if (!context.HttpContext.Request.IsHttps) 19var host = context.HttpContext.Request.Host; 32var req = context.HttpContext.Request;

36var request = context.HttpContext.Request;

44var request = context.HttpContext.Request;

36var req = context.HttpContext.Request; 54new HostString($"www.{context.HttpContext.Request.Host.Value}"),

64var originalPath = context.Request.Path; 73if (originalPath != context.Request.Path) 100logger.RewriteMiddlewareRequestContinueResults(httpContext.Request.GetEncodedUrl()); 108logger.RewriteMiddlewareRequestStopRules(httpContext.Request.GetEncodedUrl());

29var path = context.HttpContext.Request.Path; 43var request = context.HttpContext.Request;

14context.Logger.AbortedRequest(context.HttpContext.Request.Path + context.HttpContext.Request.QueryString);

47context.Logger.CustomResponse(context.HttpContext.Request.GetEncodedUrl());

33var pathBase = context.HttpContext.Request.PathBase; 59var query = context.HttpContext.Request.QueryString.Add( 76response.Headers.Location = pathBase + pattern + context.HttpContext.Request.QueryString;

48var request = context.HttpContext.Request;

27app.Run(context => context.Response.WriteAsync(context.Request.Path)); 53app.Run(context => context.Response.WriteAsync(context.Request.Path)); 79app.Run(context => context.Response.WriteAsync(context.Request.Path)); 104app.Run(context => context.Response.WriteAsync(context.Request.Path)); 129app.Run(context => context.Response.WriteAsync(context.Request.Path)); 154app.Run(context => context.Response.WriteAsync(context.Request.Path)); 179app.Run(context => context.Response.WriteAsync(context.Request.Path)); 206app.Run(context => context.Response.WriteAsync(context.Request.Path)); 237app.Run(context => context.Response.WriteAsync(context.Request.Path)); 263app.Run(context => context.Response.WriteAsync(context.Request.Path)); 289app.Run(context => context.Response.WriteAsync(context.Request.Scheme + "://" + context.Request.Host.Host + context.Request.Path + context.Request.QueryString)); 315app.Run(context => context.Response.WriteAsync(context.Request.Scheme + "://" + context.Request.Host.Host + context.Request.Path + context.Request.QueryString)); 342app.Run(context => context.Response.WriteAsync(context.Request.Scheme + "://" + context.Request.Host.Host + context.Request.Path + context.Request.QueryString)); 370app.Run(context => context.Response.WriteAsync(context.Request.Scheme + "://" + context.Request.Host.Host + context.Request.Path + context.Request.QueryString)); 398app.Run(context => context.Response.WriteAsync(context.Request.Path + context.Request.QueryString)); 423context.Request.Path + 424context.Request.QueryString)); 453context.Request.Path + 454context.Request.QueryString));

69app.Run(context => context.Response.WriteAsync(context.Request.Path + context.Request.QueryString)); 105app.Run(context => context.Response.WriteAsync(context.Request.Path + context.Request.QueryString)); 277context.Request.Scheme + 279context.Request.Host + 280context.Request.Path + 281context.Request.QueryString)); 314context.Request.Scheme + 316context.Request.Host + 317context.Request.Path + 318context.Request.QueryString)); 351context.Request.Scheme + 353context.Request.Host + 354context.Request.Path + 355context.Request.QueryString)); 388context.Request.Path + 389context.Request.QueryString)); 422context.Request.Path + 423context.Request.QueryString)); 608app.Run(context => context.Response.WriteAsync(context.Request.GetEncodedUrl())); 653app.Run(context => context.Response.WriteAsync(context.Request.GetEncodedUrl())); 740app.Run(context => context.Response.WriteAsync(context.Request.GetEncodedUrl()));

29context.Request.Scheme + 31context.Request.Host + 32context.Request.Path + 33context.Request.QueryString)); 59context.Request.Scheme + 61context.Request.Host + 62context.Request.Path + 63context.Request.QueryString)); 91context.Request.Scheme + 93context.Request.Host + 94context.Request.Path + 95context.Request.QueryString)); 123context.Request.Scheme + 125context.Request.Host + 126context.Request.Path + 127context.Request.QueryString)); 660endpoints.MapGet("/foo", context => context.Response.WriteAsync($"{context.GetEndpoint()?.DisplayName} from {context.Request.Path}")); 687context.Request.Path + 688context.Request.QueryString)); 714context.Request.Path + 715context.Request.QueryString)); 861context.Request.Scheme + 863context.Request.Host + 864context.Request.Path + 865context.Request.QueryString)); 899context.Request.Scheme + 901context.Request.Host + 902context.Request.Path + 903context.Request.QueryString)); 935context.Request.Scheme + 937context.Request.Host + 938context.Request.Path + 939context.Request.QueryString)); 972context.Request.Scheme + 974context.Request.Host + 975context.Request.Path + 976context.Request.QueryString)); 1009context.Request.Scheme + 1011context.Request.Host + 1012context.Request.Path + 1013context.Request.QueryString)); 1042context.Request.Scheme + 1044context.Request.Host + 1045context.Request.Path + 1046context.Request.QueryString));

18context.HttpContext.Request.Headers.Location = "foo";

19context.HttpContext.Request.Scheme = input;

19context.HttpContext.Request.Scheme = input;

16context.HttpContext.Request.QueryString = new QueryString("?hey=1");

17context.HttpContext.Request.Path = new PathString("/foo/bar");

17context.HttpContext.Request.Method = HttpMethods.Get;

17context.HttpContext.Request.Scheme = "http";

49return AllowedMethods.Contains(httpContext.Request.Method, StringComparer.OrdinalIgnoreCase);

91pathBase ?? httpContext.Request.PathBase, 142scheme ?? httpContext.Request.Scheme, 143host ?? httpContext.Request.Host, 144pathBase ?? httpContext.Request.PathBase,

174httpContext.Request.Method is {} method &&

92var contentType = httpContext.Request.ContentType; 358var contentType = httpContext.Request.ContentType;

17private protected override StringValues GetNegotiationHeader(HttpContext httpContext) => httpContext.Request.Headers[HeaderName];

40httpContext.Request.RouteValues = state.Values!; 103httpContext.Request.RouteValues = values!;

42var path = httpContext.Request.Path.Value!; 308Log.CandidateRejectedByConstraint(_logger, httpContext.Request.Path, endpoint, constraint.Key, constraint.Value, values[constraint.Key]);

335var hostString = httpContext.Request.Host; 340else if (string.Equals("https", httpContext.Request.Scheme, StringComparison.OrdinalIgnoreCase)) 344else if (string.Equals("http", httpContext.Request.Scheme, StringComparison.OrdinalIgnoreCase))

23var httpMethod = httpContext.Request.Method;

115var httpMethod = httpContext.Request.Method; 116var headers = httpContext.Request.Headers; 153httpContext.Request.RouteValues = null!; 422var headers = httpContext.Request.Headers;

36var httpMethod = httpContext.Request.Method;

141httpContext.Request.RouteValues = null!; 402var header = httpContext.Request.Headers[_negotiationHeader];

239return handler(httpContext.Request, httpContext.Response, httpContext.GetRouteData());

113var requestPath = context.HttpContext.Request.Path;

61httpContext.Request.RouteValues = context.RouteData.Values;

179var tokenizer = new PathTokenizer(context.HttpContext.Request.Path); 196if (!matcher.TryMatch(context.HttpContext.Request.Path, context.RouteData.Values))

26return routingFeature?.RouteData ?? new RouteData(httpContext.Request.RouteValues);

87var form = await context.Request.ReadFormAsync(); 349var form = await context.Request.ReadFormAsync(); 363var form = context.Request.Form; 451context.Request.Body = new SizeLimitedStream(context.Request.Body, context.Features.Get<IHttpMaxRequestBodySizeFeature>()?.MaxRequestBodySize);

74message.AppendLine(FormattableString.Invariant($"{httpContext.Request.Method} {httpContext.Request.Path}"));

268Requests[0].Request.Method = "GET"; 269Requests[0].Request.Path = "/emojis"; 272Requests[1].Request.Method = "GET"; 273Requests[1].Request.Path = "/events"; 276Requests[2].Request.Method = "GET"; 277Requests[2].Request.Path = "/feeds"; 280Requests[3].Request.Method = "GET"; 281Requests[3].Request.Path = "/gists"; 284Requests[4].Request.Method = "POST"; 285Requests[4].Request.Path = "/gists"; 288Requests[5].Request.Method = "GET"; 289Requests[5].Request.Path = "/issues"; 292Requests[6].Request.Method = "POST"; 293Requests[6].Request.Path = "/markdown"; 296Requests[7].Request.Method = "GET"; 297Requests[7].Request.Path = "/meta"; 300Requests[8].Request.Method = "GET"; 301Requests[8].Request.Path = "/notifications"; 304Requests[9].Request.Method = "PUT"; 305Requests[9].Request.Path = "/notifications"; 308Requests[10].Request.Method = "GET"; 309Requests[10].Request.Path = "/rate_limit"; 312Requests[11].Request.Method = "GET"; 313Requests[11].Request.Path = "/repositories"; 316Requests[12].Request.Method = "GET"; 317Requests[12].Request.Path = "/user"; 320Requests[13].Request.Method = "PATCH"; 321Requests[13].Request.Path = "/user"; 324Requests[14].Request.Method = "GET"; 325Requests[14].Request.Path = "/users"; 328Requests[15].Request.Method = "GET"; 329Requests[15].Request.Path = "/gists/public"; 332Requests[16].Request.Method = "GET"; 333Requests[16].Request.Path = "/gists/starred"; 336Requests[17].Request.Method = "GET"; 337Requests[17].Request.Path = "/gitignore/templates"; 340Requests[18].Request.Method = "POST"; 341Requests[18].Request.Path = "/markdown/raw"; 344Requests[19].Request.Method = "GET"; 345Requests[19].Request.Path = "/search/code"; 348Requests[20].Request.Method = "GET"; 349Requests[20].Request.Path = "/search/issues"; 352Requests[21].Request.Method = "GET"; 353Requests[21].Request.Path = "/search/repositories"; 356Requests[22].Request.Method = "GET"; 357Requests[22].Request.Path = "/search/users"; 360Requests[23].Request.Method = "GET"; 361Requests[23].Request.Path = "/user/emails"; 364Requests[24].Request.Method = "DELETE"; 365Requests[24].Request.Path = "/user/emails"; 368Requests[25].Request.Method = "POST"; 369Requests[25].Request.Path = "/user/emails"; 372Requests[26].Request.Method = "GET"; 373Requests[26].Request.Path = "/user/followers"; 376Requests[27].Request.Method = "GET"; 377Requests[27].Request.Path = "/user/following"; 380Requests[28].Request.Method = "GET"; 381Requests[28].Request.Path = "/user/issues"; 384Requests[29].Request.Method = "POST"; 385Requests[29].Request.Path = "/user/keys"; 388Requests[30].Request.Method = "GET"; 389Requests[30].Request.Path = "/user/keys"; 392Requests[31].Request.Method = "GET"; 393Requests[31].Request.Path = "/user/orgs"; 396Requests[32].Request.Method = "GET"; 397Requests[32].Request.Path = "/user/repos"; 400Requests[33].Request.Method = "POST"; 401Requests[33].Request.Path = "/user/repos"; 404Requests[34].Request.Method = "GET"; 405Requests[34].Request.Path = "/user/starred"; 408Requests[35].Request.Method = "GET"; 409Requests[35].Request.Path = "/user/subscriptions"; 412Requests[36].Request.Method = "GET"; 413Requests[36].Request.Path = "/user/teams"; 416Requests[37].Request.Method = "GET"; 417Requests[37].Request.Path = "/legacy/repos/search/d50aacc"; 420Requests[38].Request.Method = "GET"; 421Requests[38].Request.Path = "/legacy/user/email/8341f"; 424Requests[39].Request.Method = "GET"; 425Requests[39].Request.Path = "/legacy/user/search/24fa852"; 428Requests[40].Request.Method = "GET"; 429Requests[40].Request.Path = "/legacy/issues/search/f8f51/b60908a1-4/7e0c7/30ea8fe"; 432Requests[41].Request.Method = "GET"; 433Requests[41].Request.Path = "/gitignore/templates/a2ba346f"; 436Requests[42].Request.Method = "GET"; 437Requests[42].Request.Path = "/notifications/threads/1df78"; 440Requests[43].Request.Method = "PATCH"; 441Requests[43].Request.Path = "/notifications/threads/24a82"; 444Requests[44].Request.Method = "DELETE"; 445Requests[44].Request.Path = "/user/following/770fc247"; 448Requests[45].Request.Method = "GET"; 449Requests[45].Request.Path = "/user/following/5ac246a4"; 452Requests[46].Request.Method = "PUT"; 453Requests[46].Request.Path = "/user/following/20904d4a"; 456Requests[47].Request.Method = "DELETE"; 457Requests[47].Request.Path = "/user/keys/2cb10"; 460Requests[48].Request.Method = "GET"; 461Requests[48].Request.Path = "/user/keys/37adb"; 464Requests[49].Request.Method = "DELETE"; 465Requests[49].Request.Path = "/notifications/threads/6d635/subscription"; 468Requests[50].Request.Method = "GET"; 469Requests[50].Request.Path = "/notifications/threads/8117f/subscription"; 472Requests[51].Request.Method = "PUT"; 473Requests[51].Request.Path = "/notifications/threads/6ca24/subscription"; 476Requests[52].Request.Method = "PUT"; 477Requests[52].Request.Path = "/user/starred/348ac/b0848"; 480Requests[53].Request.Method = "GET"; 481Requests[53].Request.Path = "/user/starred/92490/2ff1b"; 484Requests[54].Request.Method = "DELETE"; 485Requests[54].Request.Path = "/user/starred/0670e/5ca5b"; 488Requests[55].Request.Method = "PUT"; 489Requests[55].Request.Path = "/user/subscriptions/a7cee/6440a"; 492Requests[56].Request.Method = "GET"; 493Requests[56].Request.Path = "/user/subscriptions/0f395/79a07"; 496Requests[57].Request.Method = "DELETE"; 497Requests[57].Request.Path = "/user/subscriptions/6df5e/ee72b"; 500Requests[58].Request.Method = "GET"; 501Requests[58].Request.Path = "/gists/bc994"; 504Requests[59].Request.Method = "PATCH"; 505Requests[59].Request.Path = "/gists/16fd7"; 508Requests[60].Request.Method = "DELETE"; 509Requests[60].Request.Path = "/gists/26a18"; 512Requests[61].Request.Method = "PATCH"; 513Requests[61].Request.Path = "/orgs/0843c"; 516Requests[62].Request.Method = "GET"; 517Requests[62].Request.Path = "/orgs/58d34"; 520Requests[63].Request.Method = "PATCH"; 521Requests[63].Request.Path = "/teams/9daee4"; 524Requests[64].Request.Method = "GET"; 525Requests[64].Request.Path = "/teams/9814e3"; 528Requests[65].Request.Method = "DELETE"; 529Requests[65].Request.Path = "/teams/1b5067"; 532Requests[66].Request.Method = "GET"; 533Requests[66].Request.Path = "/users/16a15e92"; 536Requests[67].Request.Method = "GET"; 537Requests[67].Request.Path = "/gists/8bfc9/comments"; 540Requests[68].Request.Method = "POST"; 541Requests[68].Request.Path = "/gists/8a24e/comments"; 544Requests[69].Request.Method = "POST"; 545Requests[69].Request.Path = "/gists/b269a/forks"; 548Requests[70].Request.Method = "DELETE"; 549Requests[70].Request.Path = "/gists/6fa8c/star"; 552Requests[71].Request.Method = "GET"; 553Requests[71].Request.Path = "/gists/31eb2/star"; 556Requests[72].Request.Method = "PUT"; 557Requests[72].Request.Path = "/gists/cf969/star"; 560Requests[73].Request.Method = "GET"; 561Requests[73].Request.Path = "/orgs/b92c3/events"; 564Requests[74].Request.Method = "GET"; 565Requests[74].Request.Path = "/orgs/afa76/issues"; 568Requests[75].Request.Method = "GET"; 569Requests[75].Request.Path = "/orgs/81b06/members"; 572Requests[76].Request.Method = "GET"; 573Requests[76].Request.Path = "/orgs/e9b92/public_members"; 576Requests[77].Request.Method = "GET"; 577Requests[77].Request.Path = "/orgs/96108/repos"; 580Requests[78].Request.Method = "POST"; 581Requests[78].Request.Path = "/orgs/7ef10/repos"; 584Requests[79].Request.Method = "POST"; 585Requests[79].Request.Path = "/orgs/91838/teams"; 588Requests[80].Request.Method = "GET"; 589Requests[80].Request.Path = "/orgs/c1602/teams"; 592Requests[81].Request.Method = "GET"; 593Requests[81].Request.Path = "/teams/ae1fcf/members"; 596Requests[82].Request.Method = "GET"; 597Requests[82].Request.Path = "/teams/82e12b/repos"; 600Requests[83].Request.Method = "GET"; 601Requests[83].Request.Path = "/users/c5b5ee96/events"; 604Requests[84].Request.Method = "GET"; 605Requests[84].Request.Path = "/users/3ebe3c63/followers"; 608Requests[85].Request.Method = "GET"; 609Requests[85].Request.Path = "/users/7eb8ee04/gists"; 612Requests[86].Request.Method = "GET"; 613Requests[86].Request.Path = "/users/ce5247f6/keys"; 616Requests[87].Request.Method = "GET"; 617Requests[87].Request.Path = "/users/4e212684/orgs"; 620Requests[88].Request.Method = "GET"; 621Requests[88].Request.Path = "/users/25bd0823/received_events"; 624Requests[89].Request.Method = "GET"; 625Requests[89].Request.Path = "/users/b5cdb182/repos"; 628Requests[90].Request.Method = "GET"; 629Requests[90].Request.Path = "/users/0926f1ee/starred"; 632Requests[91].Request.Method = "GET"; 633Requests[91].Request.Path = "/users/52fd945f/subscriptions"; 636Requests[92].Request.Method = "GET"; 637Requests[92].Request.Path = "/users/c079f122/received_events/public"; 640Requests[93].Request.Method = "GET"; 641Requests[93].Request.Path = "/users/f3d3f90a/events/orgs/b877e"; 644Requests[94].Request.Method = "DELETE"; 645Requests[94].Request.Path = "/gists/1425f/comments/3a1b3cd3-"; 648Requests[95].Request.Method = "GET"; 649Requests[95].Request.Path = "/gists/f885b/comments/1f24dd6a-"; 652Requests[96].Request.Method = "PATCH"; 653Requests[96].Request.Path = "/gists/0b9be/comments/3f237cca-"; 656Requests[97].Request.Method = "DELETE"; 657Requests[97].Request.Path = "/orgs/97bbf/members/3b77a2e7"; 660Requests[98].Request.Method = "GET"; 661Requests[98].Request.Path = "/orgs/c7fdb/members/76a43729"; 664Requests[99].Request.Method = "PUT"; 665Requests[99].Request.Path = "/orgs/191ee/public_members/119c87f1"; 668Requests[100].Request.Method = "GET"; 669Requests[100].Request.Path = "/orgs/ee407/public_members/8ff12154"; 672Requests[101].Request.Method = "DELETE"; 673Requests[101].Request.Path = "/orgs/4d9da/public_members/446d97e9"; 676Requests[102].Request.Method = "GET"; 677Requests[102].Request.Path = "/teams/fa75fc/members/978bd8d5"; 680Requests[103].Request.Method = "PUT"; 681Requests[103].Request.Path = "/teams/cbcdd2/members/d55986df"; 684Requests[104].Request.Method = "DELETE"; 685Requests[104].Request.Path = "/teams/cade8a/members/f83610eb"; 688Requests[105].Request.Method = "DELETE"; 689Requests[105].Request.Path = "/teams/1d5e29/memberships/5f9d213c"; 692Requests[106].Request.Method = "PUT"; 693Requests[106].Request.Path = "/teams/17d43f/memberships/5a2f444c"; 696Requests[107].Request.Method = "GET"; 697Requests[107].Request.Path = "/teams/12e975/memberships/8bb2fd20"; 700Requests[108].Request.Method = "GET"; 701Requests[108].Request.Path = "/users/c2ccdc27/following/85519b02-f"; 704Requests[109].Request.Method = "PUT"; 705Requests[109].Request.Path = "/teams/0c0a5a/repos/1f88c/6b60f"; 708Requests[110].Request.Method = "DELETE"; 709Requests[110].Request.Path = "/teams/6529ef/repos/ac003/62dd8"; 712Requests[111].Request.Method = "GET"; 713Requests[111].Request.Path = "/teams/101239/repos/51df9/aa3f3"; 716Requests[112].Request.Method = "PATCH"; 717Requests[112].Request.Path = "/repos/df7c9/ffcbe"; 720Requests[113].Request.Method = "DELETE"; 721Requests[113].Request.Path = "/repos/1f316/0f4ec"; 724Requests[114].Request.Method = "GET"; 725Requests[114].Request.Path = "/repos/08c95/7adde"; 728Requests[115].Request.Method = "GET"; 729Requests[115].Request.Path = "/networks/468be/29a19/events"; 732Requests[116].Request.Method = "GET"; 733Requests[116].Request.Path = "/repos/db561/2d460/assignees"; 736Requests[117].Request.Method = "GET"; 737Requests[117].Request.Path = "/repos/0eb0c/ec96b/branches"; 740Requests[118].Request.Method = "GET"; 741Requests[118].Request.Path = "/repos/8d58d/a31da/collaborators"; 744Requests[119].Request.Method = "GET"; 745Requests[119].Request.Path = "/repos/9d638/100e1/comments"; 748Requests[120].Request.Method = "GET"; 749Requests[120].Request.Path = "/repos/2afda/40624/commits"; 752Requests[121].Request.Method = "GET"; 753Requests[121].Request.Path = "/repos/583f1/f2f56/contributors"; 756Requests[122].Request.Method = "GET"; 757Requests[122].Request.Path = "/repos/96246/cf112/deployments"; 760Requests[123].Request.Method = "POST"; 761Requests[123].Request.Path = "/repos/af325/068fe/deployments"; 764Requests[124].Request.Method = "GET"; 765Requests[124].Request.Path = "/repos/726c3/22a16/downloads"; 768Requests[125].Request.Method = "GET"; 769Requests[125].Request.Path = "/repos/bc0e4/44660/events"; 772Requests[126].Request.Method = "GET"; 773Requests[126].Request.Path = "/repos/e8481/456ae/forks"; 776Requests[127].Request.Method = "POST"; 777Requests[127].Request.Path = "/repos/fa493/a87f8/forks"; 780Requests[128].Request.Method = "POST"; 781Requests[128].Request.Path = "/repos/e5328/77db0/hooks"; 784Requests[129].Request.Method = "GET"; 785Requests[129].Request.Path = "/repos/d219e/a06cf/hooks"; 788Requests[130].Request.Method = "GET"; 789Requests[130].Request.Path = "/repos/7a830/48c99/issues"; 792Requests[131].Request.Method = "POST"; 793Requests[131].Request.Path = "/repos/62103/40680/issues"; 796Requests[132].Request.Method = "GET"; 797Requests[132].Request.Path = "/repos/6b1aa/de4d3/keys"; 800Requests[133].Request.Method = "POST"; 801Requests[133].Request.Path = "/repos/47645/65364/keys"; 804Requests[134].Request.Method = "GET"; 805Requests[134].Request.Path = "/repos/f252f/d0dc5/labels"; 808Requests[135].Request.Method = "POST"; 809Requests[135].Request.Path = "/repos/8436b/fea30/labels"; 812Requests[136].Request.Method = "GET"; 813Requests[136].Request.Path = "/repos/d5058/668a7/languages"; 816Requests[137].Request.Method = "POST"; 817Requests[137].Request.Path = "/repos/a9546/9b556/merges"; 820Requests[138].Request.Method = "GET"; 821Requests[138].Request.Path = "/repos/5258b/6f2cd/milestones"; 824Requests[139].Request.Method = "POST"; 825Requests[139].Request.Path = "/repos/5f70d/513b2/milestones"; 828Requests[140].Request.Method = "PUT"; 829Requests[140].Request.Path = "/repos/90aa5/bdde5/notifications"; 832Requests[141].Request.Method = "GET"; 833Requests[141].Request.Path = "/repos/5f672/af6ff/notifications"; 836Requests[142].Request.Method = "POST"; 837Requests[142].Request.Path = "/repos/9277e/8e49c/pulls"; 840Requests[143].Request.Method = "GET"; 841Requests[143].Request.Path = "/repos/a4973/6dbf0/pulls"; 844Requests[144].Request.Method = "GET"; 845Requests[144].Request.Path = "/repos/a53d8/0627b/readme"; 848Requests[145].Request.Method = "POST"; 849Requests[145].Request.Path = "/repos/2bc2b/0a7aa/releases"; 852Requests[146].Request.Method = "GET"; 853Requests[146].Request.Path = "/repos/4bb1f/8220c/releases"; 856Requests[147].Request.Method = "GET"; 857Requests[147].Request.Path = "/repos/7a4e8/d54f8/stargazers"; 860Requests[148].Request.Method = "GET"; 861Requests[148].Request.Path = "/repos/63547/0d37c/subscribers"; 864Requests[149].Request.Method = "PUT"; 865Requests[149].Request.Path = "/repos/6cdda/a402c/subscription"; 868Requests[150].Request.Method = "GET"; 869Requests[150].Request.Path = "/repos/60320/4381b/subscription"; 872Requests[151].Request.Method = "DELETE"; 873Requests[151].Request.Path = "/repos/ed808/292c1/subscription"; 876Requests[152].Request.Method = "GET"; 877Requests[152].Request.Path = "/repos/74160/84ba7/tags"; 880Requests[153].Request.Method = "GET"; 881Requests[153].Request.Path = "/repos/ef45e/30a80/teams"; 884Requests[154].Request.Method = "GET"; 885Requests[154].Request.Path = "/repos/02825/d5092/watchers"; 888Requests[155].Request.Method = "POST"; 889Requests[155].Request.Path = "/repos/be33a/5f87e/git/blobs"; 892Requests[156].Request.Method = "POST"; 893Requests[156].Request.Path = "/repos/1a46d/093a4/git/commits"; 896Requests[157].Request.Method = "GET"; 897Requests[157].Request.Path = "/repos/14024/d64d2/git/refs"; 900Requests[158].Request.Method = "POST"; 901Requests[158].Request.Path = "/repos/d361c/fea9a/git/refs"; 904Requests[159].Request.Method = "POST"; 905Requests[159].Request.Path = "/repos/9a774/6a8ce/git/tags"; 908Requests[160].Request.Method = "POST"; 909Requests[160].Request.Path = "/repos/630e1/6a452/git/trees"; 912Requests[161].Request.Method = "GET"; 913Requests[161].Request.Path = "/repos/27ccf/49922/issues/comments"; 916Requests[162].Request.Method = "GET"; 917Requests[162].Request.Path = "/repos/1e557/77fad/issues/events"; 920Requests[163].Request.Method = "GET"; 921Requests[163].Request.Path = "/repos/297e9/11542/pulls/comments"; 924Requests[164].Request.Method = "GET"; 925Requests[164].Request.Path = "/repos/3c261/5719e/stats/code_frequency"; 928Requests[165].Request.Method = "GET"; 929Requests[165].Request.Path = "/repos/74b31/45543/stats/commit_activity"; 932Requests[166].Request.Method = "GET"; 933Requests[166].Request.Path = "/repos/909d8/56712/stats/contributors"; 936Requests[167].Request.Method = "GET"; 937Requests[167].Request.Path = "/repos/b8ecd/2a142/stats/participation"; 940Requests[168].Request.Method = "GET"; 941Requests[168].Request.Path = "/repos/72fcd/e0d41/stats/punch_card"; 944Requests[169].Request.Method = "GET"; 945Requests[169].Request.Path = "/repos/f8e07/b0719/git/blobs/a82e41d"; 948Requests[170].Request.Method = "GET"; 949Requests[170].Request.Path = "/repos/22ba5/326c5/git/commits/9fd2dd7"; 952Requests[171].Request.Method = "DELETE"; 953Requests[171].Request.Path = "/repos/6052c/2b5e3/git/refs/f9a94"; 956Requests[172].Request.Method = "PATCH"; 957Requests[172].Request.Path = "/repos/2de37/f89e9/git/refs/cda61"; 960Requests[173].Request.Method = "GET"; 961Requests[173].Request.Path = "/repos/66069/dcb46/git/refs/f682e"; 964Requests[174].Request.Method = "GET"; 965Requests[174].Request.Path = "/repos/cab0e/a64fa/git/tags/507f4b6"; 968Requests[175].Request.Method = "GET"; 969Requests[175].Request.Path = "/repos/76633/6d2b3/git/trees/a45672d"; 972Requests[176].Request.Method = "GET"; 973Requests[176].Request.Path = "/repos/611e5/14e81/issues/comments/70d5316a-"; 976Requests[177].Request.Method = "PATCH"; 977Requests[177].Request.Path = "/repos/d4bb1/0e97d/issues/comments/f03032b3-"; 980Requests[178].Request.Method = "DELETE"; 981Requests[178].Request.Path = "/repos/221b6/f1cdb/issues/comments/a769f3b6-"; 984Requests[179].Request.Method = "GET"; 985Requests[179].Request.Path = "/repos/7ad51/f85f2/issues/events/cec2e88"; 988Requests[180].Request.Method = "PATCH"; 989Requests[180].Request.Path = "/repos/5ad14/2c490/pulls/comments/0ce89290-"; 992Requests[181].Request.Method = "GET"; 993Requests[181].Request.Path = "/repos/13ba8/30bb3/pulls/comments/e643400f-"; 996Requests[182].Request.Method = "DELETE"; 997Requests[182].Request.Path = "/repos/cd3a3/d6224/pulls/comments/c225e938-"; 1000Requests[183].Request.Method = "PATCH"; 1001Requests[183].Request.Path = "/repos/33c72/2f2bd/releases/assets/d06f4"; 1004Requests[184].Request.Method = "DELETE"; 1005Requests[184].Request.Path = "/repos/18b7c/c3d06/releases/assets/97762"; 1008Requests[185].Request.Method = "GET"; 1009Requests[185].Request.Path = "/repos/38549/7ae63/releases/assets/2498e"; 1012Requests[186].Request.Method = "GET"; 1013Requests[186].Request.Path = "/repos/2cd8e/bb684/assignees/04058a9c"; 1016Requests[187].Request.Method = "GET"; 1017Requests[187].Request.Path = "/repos/ab58d/4a13e/branches/c48dc6"; 1020Requests[188].Request.Method = "PUT"; 1021Requests[188].Request.Path = "/repos/a856e/bf188/collaborators/5af36"; 1024Requests[189].Request.Method = "DELETE"; 1025Requests[189].Request.Path = "/repos/b17c0/6051b/collaborators/0b415"; 1028Requests[190].Request.Method = "GET"; 1029Requests[190].Request.Path = "/repos/e4fc3/95a37/collaborators/9bd1b"; 1032Requests[191].Request.Method = "DELETE"; 1033Requests[191].Request.Path = "/repos/fa150/ca148/comments/02b69539-"; 1036Requests[192].Request.Method = "GET"; 1037Requests[192].Request.Path = "/repos/6d3cc/5ad75/comments/c6a0df3f-"; 1040Requests[193].Request.Method = "PATCH"; 1041Requests[193].Request.Path = "/repos/883ad/d79a0/comments/edac8612-"; 1044Requests[194].Request.Method = "GET"; 1045Requests[194].Request.Path = "/repos/59b5d/9ffbe/commits/d6d94ac"; 1048Requests[195].Request.Method = "GET"; 1049Requests[195].Request.Path = "/repos/19be8/61e28/contents/f4c5a"; 1052Requests[196].Request.Method = "DELETE"; 1053Requests[196].Request.Path = "/repos/6e29a/43f51/contents/52ffe"; 1056Requests[197].Request.Method = "PUT"; 1057Requests[197].Request.Path = "/repos/a3605/bf28b/contents/a8fe5"; 1060Requests[198].Request.Method = "GET"; 1061Requests[198].Request.Path = "/repos/a869c/dd5fa/downloads/f1808e48-0"; 1064Requests[199].Request.Method = "DELETE"; 1065Requests[199].Request.Path = "/repos/94d90/ae933/downloads/f9e25b5f-6"; 1068Requests[200].Request.Method = "DELETE"; 1069Requests[200].Request.Path = "/repos/0fe83/e2353/hooks/a83a19"; 1072Requests[201].Request.Method = "GET"; 1073Requests[201].Request.Path = "/repos/648c3/fc66e/hooks/04b461"; 1076Requests[202].Request.Method = "PATCH"; 1077Requests[202].Request.Path = "/repos/3ac61/92269/hooks/79e4df"; 1080Requests[203].Request.Method = "GET"; 1081Requests[203].Request.Path = "/repos/8d523/ba527/issues/9a222a"; 1084Requests[204].Request.Method = "PATCH"; 1085Requests[204].Request.Path = "/repos/9ed96/f6553/issues/4df9d5"; 1088Requests[205].Request.Method = "GET"; 1089Requests[205].Request.Path = "/repos/472ec/16a4a/keys/84edc"; 1092Requests[206].Request.Method = "DELETE"; 1093Requests[206].Request.Path = "/repos/1a88d/4c019/keys/b3e45"; 1096Requests[207].Request.Method = "GET"; 1097Requests[207].Request.Path = "/repos/334fe/0c9d7/labels/4c1ee"; 1100Requests[208].Request.Method = "PATCH"; 1101Requests[208].Request.Path = "/repos/5dcde/f973d/labels/80435"; 1104Requests[209].Request.Method = "DELETE"; 1105Requests[209].Request.Path = "/repos/00a37/12e4b/labels/d7158"; 1108Requests[210].Request.Method = "PATCH"; 1109Requests[210].Request.Path = "/repos/e24fa/a168e/milestones/a38b20"; 1112Requests[211].Request.Method = "GET"; 1113Requests[211].Request.Path = "/repos/24592/f8af1/milestones/8e871e"; 1116Requests[212].Request.Method = "DELETE"; 1117Requests[212].Request.Path = "/repos/c5ee0/38414/milestones/da7976"; 1120Requests[213].Request.Method = "GET"; 1121Requests[213].Request.Path = "/repos/912e9/c81d6/pulls/ce677a"; 1124Requests[214].Request.Method = "PATCH"; 1125Requests[214].Request.Path = "/repos/aef6c/5ec7e/pulls/633b87"; 1128Requests[215].Request.Method = "PATCH"; 1129Requests[215].Request.Path = "/repos/6085e/ff8aa/releases/dcda3"; 1132Requests[216].Request.Method = "GET"; 1133Requests[216].Request.Path = "/repos/4d7f4/ceafa/releases/97fd7"; 1136Requests[217].Request.Method = "DELETE"; 1137Requests[217].Request.Path = "/repos/1f81e/89e6a/releases/6b744"; 1140Requests[218].Request.Method = "GET"; 1141Requests[218].Request.Path = "/repos/8b417/ad4a5/statuses/08833"; 1144Requests[219].Request.Method = "POST"; 1145Requests[219].Request.Path = "/repos/b7600/1d17b/statuses/9de98"; 1148Requests[220].Request.Method = "GET"; 1149Requests[220].Request.Path = "/repos/ceff2/ff6ae/commits/ae429/status"; 1152Requests[221].Request.Method = "GET"; 1153Requests[221].Request.Path = "/repos/13588/5ba9b/commits/534a9aa/comments"; 1156Requests[222].Request.Method = "POST"; 1157Requests[222].Request.Path = "/repos/ba059/a94ca/commits/dfc6938/comments"; 1160Requests[223].Request.Method = "GET"; 1161Requests[223].Request.Path = "/repos/39532/6e5f6/deployments/f41d0/statuses"; 1164Requests[224].Request.Method = "POST"; 1165Requests[224].Request.Path = "/repos/18373/23ac8/deployments/392c1/statuses"; 1168Requests[225].Request.Method = "POST"; 1169Requests[225].Request.Path = "/repos/73148/9d526/hooks/59adb8/tests"; 1172Requests[226].Request.Method = "POST"; 1173Requests[226].Request.Path = "/repos/19a36/91f69/issues/765c82/comments"; 1176Requests[227].Request.Method = "GET"; 1177Requests[227].Request.Path = "/repos/ffa54/61a37/issues/710513/comments"; 1180Requests[228].Request.Method = "GET"; 1181Requests[228].Request.Path = "/repos/fcb0f/0c8e2/issues/de0d38/events"; 1184Requests[229].Request.Method = "POST"; 1185Requests[229].Request.Path = "/repos/158d7/00bed/issues/9bc6b6/labels"; 1188Requests[230].Request.Method = "GET"; 1189Requests[230].Request.Path = "/repos/67c56/41fd8/issues/6b6858/labels"; 1192Requests[231].Request.Method = "PUT"; 1193Requests[231].Request.Path = "/repos/b8194/06cc6/issues/effa3d/labels"; 1196Requests[232].Request.Method = "DELETE"; 1197Requests[232].Request.Path = "/repos/57423/979fd/issues/6d3fce/labels"; 1200Requests[233].Request.Method = "GET"; 1201Requests[233].Request.Path = "/repos/d799e/53e56/milestones/80ebe2/labels"; 1204Requests[234].Request.Method = "GET"; 1205Requests[234].Request.Path = "/repos/55311/56e4a/pulls/666fa7/comments"; 1208Requests[235].Request.Method = "POST"; 1209Requests[235].Request.Path = "/repos/c9cd2/f3e91/pulls/ae901f/comments"; 1212Requests[236].Request.Method = "GET"; 1213Requests[236].Request.Path = "/repos/3195c/e552e/pulls/6b6d2b/commits"; 1216Requests[237].Request.Method = "GET"; 1217Requests[237].Request.Path = "/repos/2d6b6/77639/pulls/3423c6/files"; 1220Requests[238].Request.Method = "PUT"; 1221Requests[238].Request.Path = "/repos/6c6d3/3a6b0/pulls/1da47f/merge"; 1224Requests[239].Request.Method = "GET"; 1225Requests[239].Request.Path = "/repos/b144c/c707e/pulls/a5fcb2/merge"; 1228Requests[240].Request.Method = "GET"; 1229Requests[240].Request.Path = "/repos/81459/8618d/releases/65289/assets"; 1232Requests[241].Request.Method = "DELETE"; 1233Requests[241].Request.Path = "/repos/3c5a4/a7525/issues/e93fff/labels/cd7b0"; 1236Requests[242].Request.Method = "GET"; 1237Requests[242].Request.Path = "/repos/85bd9/70da2/2dc44fe9-83b9-/01762";