142public override HttpRequest Request => _request;

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") && !ctx.Request.Path.StartsWithSegments("/_framework/blazor.server.js") && !ctx.Request.Path.StartsWithSegments("/_framework/blazor.web.js")) 40string fileExtension = Path.GetExtension(ctx.Request.Path); 89if (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)

152receivedHost = context.Request.Headers.Host; 193await context.Request.Body.ReadAsync(new byte[1], 0, 1); 348await using (var server = new TestServer(context => context.Request.Body.DrainAsync(default), new TestServiceContext(LoggerFactory) { DiagnosticSource = diagListener })) 409await using (var server = new TestServer(context => context.Request.Body.DrainAsync(default), new TestServiceContext(LoggerFactory) { DiagnosticSource = diagListener })) 479await using (var server = new TestServer(context => context.Request.Body.DrainAsync(default), new TestServiceContext(LoggerFactory) { DiagnosticSource = diagListener }))

26var request = httpContext.Request; 43var request = httpContext.Request; 62var request = httpContext.Request; 180var request = httpContext.Request; 236var request = httpContext.Request; 364var request = httpContext.Request; 501while (await context.Request.Body.ReadAsync(buffer, 0, buffer.Length) != 0) 545while (await context.Request.Body.ReadAsync(buffer, 0, buffer.Length) != 0) 586var request = httpContext.Request; 667var request = httpContext.Request; 711var request = httpContext.Request; 863var readTask = httpContext.Request.Body.CopyToAsync(Stream.Null); 912var request = httpContext.Request; 919var requestTask = httpContext.Request.BodyReader.ReadAsync(); 921httpContext.Request.BodyReader.CancelPendingRead(); 968var request = httpContext.Request; 975httpContext.Request.BodyReader.Complete(); 1017var request = httpContext.Request; 1081var request = httpContext.Request; 1088httpContext.Request.BodyReader.Complete(new Exception());

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

1147var read = await context.Request.Body.ReadAsync(new byte[10], 0, 10); 1362var readResult = await context.Request.BodyReader.ReadAsync(); 1365context.Request.BodyReader.AdvanceTo(readResult.Buffer.Start, readResult.Buffer.End); 1366readResult = await context.Request.BodyReader.ReadAsync(); 1369context.Request.BodyReader.AdvanceTo(readResult.Buffer.Start, readResult.Buffer.End); 1371readResult = await context.Request.BodyReader.ReadAsync(); 1376context.Request.BodyReader.AdvanceTo(readResult.Buffer.End); 5322var result = await context.Request.BodyReader.ReadAsync().DefaultTimeout(); 5325context.Request.BodyReader.AdvanceTo(result.Buffer.Start, result.Buffer.End);

268await c.Request.Body.FlushAsync(); 321await c.Request.Body.FlushAsync();

183Assert.True(HttpMethods.Equals(method, context.Request.Method)); 184Assert.True(context.Request.CanHaveBody()); 185Assert.Equal(11, context.Request.ContentLength); 186Assert.False(context.Request.Headers.ContainsKey(HeaderNames.TransferEncoding)); 187return context.Request.BodyReader.CopyToAsync(context.Response.BodyWriter); 234Assert.True(HttpMethods.Equals(method, context.Request.Method)); 235Assert.True(context.Request.CanHaveBody()); 236Assert.Null(context.Request.ContentLength); 237Assert.False(context.Request.Headers.ContainsKey(HeaderNames.TransferEncoding)); 238return context.Request.BodyReader.CopyToAsync(context.Response.BodyWriter); 358context.Response.Headers["path"] = context.Request.Path.Value; 359context.Response.Headers["query"] = context.Request.QueryString.Value; 404Assert.Equal(expected, context.Request.Path.Value); 477Assert.Equal(scheme, context.Request.Scheme); 478Assert.False(context.Request.Headers.ContainsKey(InternalHeaderNames.Scheme)); 876var read = await context.Request.Body.ReadAsync(buffer, 0, buffer.Length); 878read = await context.Request.Body.ReadAsync(buffer, 0, buffer.Length); 906var read = await context.Request.Body.ReadAsync(buffer, 0, buffer.Length); 908read = await context.Request.Body.ReadAsync(buffer, 0, buffer.Length); 954var read = await context.Request.Body.ReadAsync(buffer, 0, buffer.Length); 958read = await context.Request.Body.ReadAsync(buffer, total, buffer.Length - total); 996var readResult = await context.Request.BodyReader.ReadAsync(); 999context.Request.BodyReader.AdvanceTo(readResult.Buffer.Start, readResult.Buffer.End); 1000readResult = await context.Request.BodyReader.ReadAsync(); 1004context.Request.BodyReader.AdvanceTo(readResult.Buffer.End); 1040var readResult = await context.Request.BodyReader.ReadAsync(); 1042context.Request.BodyReader.AdvanceTo(readResult.Buffer.End); 1048var read = await context.Request.Body.ReadAsync(buffer, 0, buffer.Length); 1052read = await context.Request.Body.ReadAsync(buffer, total, buffer.Length - total); 1149while (await context.Request.Body.ReadAsync(buffer, 0, buffer.Length) > 0) { } 1184while (await context.Request.Body.ReadAsync(buffer, 0, buffer.Length) > 0) { } 1219while (await context.Request.Body.ReadAsync(buffer, 0, buffer.Length) > 0) { } 1255while (await context.Request.Body.ReadAsync(buffer, 0, buffer.Length) > 0) { } 1279var readResult = await context.Request.BodyReader.ReadAsync(); 1282context.Request.BodyReader.AdvanceTo(readResult.Buffer.Start, readResult.Buffer.End); 1283readResult = await context.Request.BodyReader.ReadAsync(); 1287context.Request.BodyReader.AdvanceTo(readResult.Buffer.End); 1289readResult = await context.Request.BodyReader.ReadAsync(); 1865var read = await context.Request.Body.ReadAsync(buffer, 0, buffer.Length); 1867read = await context.Request.Body.ReadAsync(buffer, 0, buffer.Length); 1910while (await context.Request.Body.ReadAsync(buffer, 0, buffer.Length) > 0) { } 1951var read = await context.Request.Body.ReadAsync(buffer, 0, buffer.Length); 1953read = await context.Request.Body.ReadAsync(buffer, 0, buffer.Length); 1995while (await context.Request.Body.ReadAsync(buffer, 0, buffer.Length) > 0) { } 2056while (await context.Request.Body.ReadAsync(buffer, 0, buffer.Length) > 0) { } 2112var read = await context.Request.Body.ReadAsync(buffer, 0, buffer.Length); 2115read = await context.Request.Body.ReadAsync(buffer, 0, buffer.Length); 3247var readTask = context.Request.Body.ReadAsync(new byte[100], 0, 100).DefaultTimeout(); 3289var read = await context.Request.Body.ReadAsync(new byte[100], 0, 100).DefaultTimeout(); 3290var readTask = context.Request.Body.ReadAsync(new byte[100], 0, 100).DefaultTimeout(); 3425var thrownExTask = Assert.ThrowsAnyAsync<OperationCanceledException>(() => context.Request.Body.ReadAsync(buffer, 0, buffer.Length)); 3450var thrownExTask = Assert.ThrowsAnyAsync<OperationCanceledException>(() => context.Request.Body.ReadAsync(buffer, 0, buffer.Length)); 5522var requestBodyTask = context.Request.BodyReader.ReadAsync(); 5541await Assert.ThrowsAsync<ConnectionAbortedException>(async () => await context.Request.BodyReader.ReadAsync()); 5688var requestBodyTask = context.Request.BodyReader.ReadAsync(); 5709await Assert.ThrowsAsync<ConnectionAbortedException>(async () => await context.Request.BodyReader.ReadAsync()); 5777Assert.Equal("£", context.Request.Headers["X-Test"]); 5821Assert.Equal("£", context.Request.Headers["X-Test"]);

185_receivedRequestFields.Method = context.Request.Method; 186_receivedRequestFields.Scheme = context.Request.Scheme; 187_receivedRequestFields.Path = context.Request.Path.Value; 189_receivedRequestFields.Authority = context.Request.Host.Value; 190foreach (var header in context.Request.Headers) 200Assert.True(context.Request.SupportsTrailers(), "SupportsTrailers"); 201Assert.False(context.Request.CheckTrailersAvailable(), "SupportsTrailers"); 206await context.Request.Body.CopyToAsync(ms); 209Assert.True(context.Request.SupportsTrailers(), "SupportsTrailers"); 210Assert.True(context.Request.CheckTrailersAvailable(), "SupportsTrailers"); 212_receivedRequestFields.Method = context.Request.Method; 213_receivedRequestFields.Scheme = context.Request.Scheme; 214_receivedRequestFields.Path = context.Request.Path.Value; 216foreach (var header in context.Request.Headers) 235while ((received = await context.Request.Body.ReadAsync(buffer, 0, buffer.Length)) > 0) 248while ((received = await context.Request.Body.ReadAsync(buffer, 0, buffer.Length)) > 0) 259while ((received = await context.Request.Body.ReadAsync(buffer, 0, buffer.Length)) > 0) 328var expectedBytes = int.Parse(context.Request.Path.Value.Substring(1), CultureInfo.InvariantCulture); 335received += await context.Request.Body.ReadAsync(buffer, 0, buffer.Length); 338var stalledReadTask = context.Request.Body.ReadAsync(buffer, 0, buffer.Length); 348Assert.False(context.Request.CanHaveBody()); 349Assert.False(context.Request.Headers.ContainsKey(InternalHeaderNames.Method)); 350context.Response.Headers["Method"] = context.Request.Method; 357Assert.False(context.Request.Headers.ContainsKey(InternalHeaderNames.Authority)); 358context.Response.Headers.Host = context.Request.Headers.Host; 365Assert.False(context.Request.Headers.ContainsKey(InternalHeaderNames.Path)); 366context.Response.Headers["path"] = context.Request.Path.ToString();

320while ((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])); 592Assert.Equal(HttpMethods.Connect, context.Request.Method);

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

46while ((received = await context.Request.Body.ReadAsync(buffer, 0, buffer.Length)) > 0) 86while ((received = await context.Request.Body.ReadAsync(buffer, 0, buffer.Length)) > 0) 147receivedHeaders = context.Request.Headers[HeaderNames.Cookie]; 149while ((received = await context.Request.Body.ReadAsync(buffer, 0, buffer.Length)) > 0) 420contentType = context.Request.ContentType; 421authority = context.Request.Host.Value;

213context.Response.Headers["path"] = context.Request.Path.Value; 214context.Response.Headers["query"] = context.Request.QueryString.Value; 248Assert.Equal(expected, context.Request.Path.Value); 308Assert.Equal(scheme, context.Request.Scheme); 564var read = await context.Request.Body.ReadAsync(buffer, 0, buffer.Length); 566read = await context.Request.Body.ReadAsync(buffer, 0, buffer.Length); 593var read = await context.Request.Body.ReadAsync(buffer, 0, buffer.Length); 597read = await context.Request.Body.ReadAsync(buffer, total, buffer.Length - total); 627var readResult = await context.Request.BodyReader.ReadAsync(); 630context.Request.BodyReader.AdvanceTo(readResult.Buffer.Start, readResult.Buffer.End); 631readResult = await context.Request.BodyReader.ReadAsync(); 635context.Request.BodyReader.AdvanceTo(readResult.Buffer.End); 1774var requestBodyTask = context.Request.BodyReader.ReadAsync(); 1793await Assert.ThrowsAsync<ConnectionAbortedException>(async () => await context.Request.BodyReader.ReadAsync()); 1901var requestBodyTask = context.Request.BodyReader.ReadAsync(); 1922await Assert.ThrowsAsync<ConnectionAbortedException>(async () => await context.Request.BodyReader.ReadAsync()); 1988await c.Request.Body.DrainAsync(default); 1990testValue = c.Request.GetTrailer("TestName"); 2055await c.Request.Body.ReadAsync(data); 2061c.Request.GetTrailer("TestName"); 2484var read = await context.Request.Body.ReadAsync(buffer, 0, buffer.Length); 2486read = await context.Request.Body.ReadAsync(buffer, 0, buffer.Length); 2522while (await context.Request.Body.ReadAsync(buffer, 0, buffer.Length) > 0) { } 2557var read = await context.Request.Body.ReadAsync(buffer, 0, buffer.Length); 2559read = await context.Request.Body.ReadAsync(buffer, 0, buffer.Length); 2594while (await context.Request.Body.ReadAsync(buffer, 0, buffer.Length) > 0) { } 2647while (await context.Request.Body.ReadAsync(buffer, 0, buffer.Length) > 0) { } 2695var read = await context.Request.Body.ReadAsync(buffer, 0, buffer.Length); 2698read = await context.Request.Body.ReadAsync(buffer, 0, buffer.Length); 2810readCount += 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;

428while ((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;

234if (httpContext.Request.Path == "/longrunning") 238else if (httpContext.Request.Path == "/upgrade") 247else if (httpContext.Request.Path == "/consume") 250while (await httpContext.Request.Body.ReadAsync(buffer, 0, buffer.Length) > 0)

421var request = httpContext.Request; 423var buffer = new byte[httpContext.Request.ContentLength ?? 0];

31Assert.True(context.Request.CanHaveBody()); 36async () => await context.Request.Body.ReadAsync(buffer, 0, 1)); 77using (var stream = new StreamReader(context.Request.Body)) 121using (var stream = new StreamReader(context.Request.Body)) 174async () => await context.Request.Body.ReadAsync(buffer, 0, 1)); 214Assert.Equal(1, await context.Request.Body.ReadAsync(buffer, 0, 1)); 216Assert.Equal(0, await context.Request.Body.ReadAsync(buffer, 0, 1)); 244await using (var server = new TestServer(context => context.Request.Body.CopyToAsync(Stream.Null), 284Assert.Equal(1, await context.Request.Body.ReadAsync(buffer, 0, 1)); 368async () => await context.Request.Body.ReadAsync(buffer, 0, 1)); 370async () => await context.Request.Body.ReadAsync(buffer, 0, 1)); 419count = await context.Request.Body.ReadAsync(buffer, 0, 11); 464count = await context.Request.Body.ReadAsync(buffer, offset, 11 - offset); 469Assert.Equal("trailing-value", context.Request.GetTrailer("Trailing-Header").ToString()); 516count = await context.Request.Body.ReadAsync(buffer, 0, 11); 527count = await context.Request.Body.ReadAsync(buffer, 0, 11); 579async () => await context.Request.Body.ReadAsync(buffer, 0, 1)); 581async () => await context.Request.Body.ReadAsync(buffer, 0, 1));

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

137await 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);

31if (context.Request.Body is MemoryStream) 41context.Request.Body = new MemoryStream(); 94context.Request.Body = mockStream.Object; 95var data = await context.Request.BodyReader.ReadAsync(); 120await context.Request.Body.FillEntireBufferAsync(data, cts.Token).DefaultTimeout(); 134var task = context.Request.Body.ReadAsync(data, 0, data.Length, cts.Token); 236pathTcs.TrySetResult(context.Request.Path); 237queryTcs.TrySetResult(context.Request.Query); 924Assert.Equal(0, await httpContext.Request.Body.ReadAsync(new byte[1], 0, 1).DefaultTimeout()); 969var readResult = await httpContext.Request.BodyReader.ReadAsync().AsTask().DefaultTimeout(); 1016var readResult = await httpContext.Request.BodyReader.ReadAsync(); 1019httpContext.Request.BodyReader.AdvanceTo(readResult.Buffer.End); 1048var readResult = await httpContext.Request.BodyReader.ReadAsync(); 1051httpContext.Request.BodyReader.AdvanceTo(readResult.Buffer.Start, readResult.Buffer.End); 1052readResult = await httpContext.Request.BodyReader.ReadAsync(); 1083var readResult = await httpContext.Request.BodyReader.ReadAsync(); 1086httpContext.Request.BodyReader.AdvanceTo(readResult.Buffer.Start, readResult.Buffer.End); 1090readResult = await httpContext.Request.BodyReader.ReadAsync(); 1092httpContext.Request.BodyReader.AdvanceTo(readResult.Buffer.Start, readResult.Buffer.End); 1126await httpContext.Request.BodyReader.CopyToAsync(ms1); 1127await httpContext.Request.BodyReader.CopyToAsync(ms2); 1180var readResult = await ReadAtLeastAsync(httpContext.Request.BodyReader, numBytes: 3); 1184httpContext.Request.BodyReader.AdvanceTo(readResult.Buffer.Start, readResult.Buffer.End); 1187readResult = await httpContext.Request.BodyReader.ReadAsync(); 1188httpContext.Request.BodyReader.AdvanceTo(readResult.Buffer.Start, readResult.Buffer.End); 1192readResult = await httpContext.Request.BodyReader.ReadAsync(); 1196httpContext.Request.BodyReader.AdvanceTo(readResult.Buffer.Start, readResult.Buffer.End); 1197readResult = await httpContext.Request.BodyReader.ReadAsync(); 1232var readResult = await httpContext.Request.BodyReader.ReadAsync(); 1234httpContext.Request.BodyReader.AdvanceTo(readResult.Buffer.Start, readResult.Buffer.End); 1236readResult = await httpContext.Request.BodyReader.ReadAsync(); 1237httpContext.Request.BodyReader.AdvanceTo(readResult.Buffer.Slice(1).Start, readResult.Buffer.End); 1392if (context.Request.Body != lastStream) 1394lastStream = context.Request.Body; 1397if (context.Request.Headers != lastRequestHeaders) 1399lastRequestHeaders = context.Request.Headers; 1409await context.Request.Body.CopyToAsync(ms); 1692var ioEx = Assert.Throws<InvalidOperationException>(() => context.Request.Body.Read(new byte[1], 0, 1)); 1695var ioEx2 = Assert.Throws<InvalidOperationException>(() => context.Request.Body.CopyTo(Stream.Null)); 1700offset += await context.Request.Body.ReadAsync(buffer, offset, 5 - offset); 1703Assert.Equal(0, await context.Request.Body.ReadAsync(new byte[1], 0, 1)); 1743offset += context.Request.Body.Read(buffer, offset, 5 - offset); 1746Assert.Equal(0, await context.Request.Body.ReadAsync(new byte[1], 0, 1)); 1785var ioEx = Assert.Throws<InvalidOperationException>(() => context.Request.Body.Read(new byte[1], 0, 1)); 1788var ioEx2 = Assert.Throws<InvalidOperationException>(() => context.Request.Body.CopyTo(Stream.Null)); 1792var length = await context.Request.Body.FillBufferUntilEndAsync(buffer).DefaultTimeout(); 1833offset += context.Request.Body.Read(buffer, offset, 5 - offset); 1836Assert.Equal(0, await context.Request.Body.ReadAsync(new byte[1], 0, 1)); 1867await httpContext.Request.Body.ReadAsync(new byte[1], 0, 1); 1900var request = httpContext.Request; 1907var requestTask = httpContext.Request.BodyReader.ReadAsync(); 1909httpContext.Request.BodyReader.CancelPendingRead(); 1950var request = httpContext.Request; 1957httpContext.Request.BodyReader.Complete(); 1994var request = httpContext.Request; 1999httpContext.Request.BodyReader.Complete(); 2035var request = httpContext.Request; 2042httpContext.Request.BodyReader.Complete(new Exception()); 2078customHeaderValue = context.Request.Headers["X-CustomHeader"]; 2079contentTypeHeaderValue = context.Request.ContentType; 2195Assert.Equal("£", context.Request.Headers["X-Test"]); 2258Assert.Equal("£", context.Request.Headers["X-Test"]);

338await context.Request.Body.ReadAsync(new byte[1], 0, 1); 355await context.Request.Body.ReadAsync(new byte[1], 0, 1); 481async () => await httpContext.Request.Body.ReadAsync(new byte[1], 0, 1)); 1521await httpContext.Request.Body.ReadAsync(new byte[1], 0, 1); 2019return httpContext.Request.Body.ReadAsync(new byte[1], 0, 1); 2089return httpContext.Request.Body.ReadAsync(new byte[1], 0, 1); 2135await httpContext.Request.Body.ReadAsync(new byte[1], 0, 1); 2240Assert.Equal(0, await httpContext.Request.Body.ReadAsync(new byte[1], 0, 1).DefaultTimeout()); 2307var request = httpContext.Request; 2356var 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;

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

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

327contentType = context.Request.ContentType; 328authority = context.Request.Host.Value; 330var data = await context.Request.Body.ReadUntilEndAsync(); 402var body = context.Request.Body; 465var body = context.Request.Body; 548readAsyncTask.SetResult(context.Request.Body.ReadAsync(new byte[1024]).AsTask()); 708var body = context.Request.Body; 891requestHeaders.Add(context.Request.Headers.ToDictionary(k => k.Key, k => k.Value, StringComparer.OrdinalIgnoreCase)); 979var requestBody = context.Request.Body; 1072var requestBody = context.Request.Body; 1220await context.Request.BodyReader.ReadAtLeastAsync(TestData.Length); 1335request1HeaderValue = context.Request.Headers.UserAgent; 1339request2HeaderValue = context.Request.Headers.UserAgent; 1623switch (context.Request.Path.ToString()) 1872var readTask = context.Request.Body.ReadUntilEndAsync(); 1983var 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"))

1206if (context.Request.Path == new PathString("/checkforerrors")) 1215else if (context.Request.Path == new PathString("/oauth")) 1236else if (context.Request.Path == new PathString("/token")) 1241else if (context.Request.Path == new PathString("/unauthorized")) 1247else if (context.Request.Path == new PathString("/forbidden")) 1252else if (context.Request.Path == new PathString("/signIn")) 1256else if (context.Request.Path == new PathString("/signOut")) 1260else 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() };

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

79form: result.HandlerName != null && context.Request.HasFormContentType ? await context.Request.ReadFormAsync() : null); 160var processPost = HttpMethods.IsPost(context.Request.Method) && 168if (context.Request.ContentType is not null && MediaTypeHeaderValue.TryParse(context.Request.ContentType, out var type)) 231await context.Request.ReadFormAsync(); 243if (context.Request.Form.TryGetValue("_handler", out var value))

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

203else if (IsPossibleExternalDestination(httpContext.Request, navigationException.Location) 204&& IsProgressivelyEnhancedNavigation(httpContext.Request))

28if (IsProgressivelyEnhancedNavigation(httpContext.Request)) 90!IsProgressivelyEnhancedNavigation(httpContext.Request)) 144var isEnhancedNavigation = IsProgressivelyEnhancedNavigation(_httpContext.Request); 223if (string.Equals(httpContext.Request.Method, "POST", StringComparison.OrdinalIgnoreCase)) 228if (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") && 108var 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(), 182var headers = httpContext.Request.GetTypedHeaders(); 222foreach (var pair in httpContext.Request.Headers) 245headers: httpContext.Request.Headers, 246path: httpContext.Request.Path.ToString(), 342var 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;

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>

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;

63context.MetricsTagsFeature.Method = httpContext.Request.Method; 64context.MetricsTagsFeature.Protocol = httpContext.Request.Protocol; 65context.MetricsTagsFeature.Scheme = httpContext.Request.Scheme; 328[DynamicDependency(nameof(HttpContext.Request), typeof(HttpContext))] 349[DynamicDependency(nameof(HttpContext.Request), typeof(HttpContext))] 372_eventSource.RequestStart(httpContext.Request.Method, httpContext.Request.Path); 378_metrics.RequestStart(httpContext.Request.Scheme, httpContext.Request.Method); 386var headers = httpContext.Request.Headers; 489[DynamicDependency(nameof(HttpContext.Request), typeof(HttpContext))] 564_path = (httpContext.Request.PathBase.HasValue 565? httpContext.Request.PathBase + httpContext.Request.Path 566: 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);

216context.Items["test.Path"] = context.Request.Path; 217context.Items["test.PathBase"] = context.Request.PathBase; 227Assert.Equal(pathBase, requestContext.Request.PathBase.Value); 228Assert.Equal(requestPath, requestContext.Request.Path.Value); 234context.Request.PathBase = new PathString(pathBase); 235context.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);

94private static readonly MemberExpression HttpRequestExpr = Expression.Property(HttpContextExpr, typeof(HttpContext).GetProperty(nameof(HttpContext.Request))!); 1361if (!httpContext.Request.HasJsonContentType()) 1363Log.UnexpectedJsonContentType(httpContext, httpContext.Request.ContentType, throwOnBadRequest); 1369bodyValue = await httpContext.Request.ReadFromJsonAsync(jsonTypeInfo); 1492if (!httpContext.Request.HasFormContentType) 1494Log.UnexpectedNonFormContentType(httpContext, httpContext.Request.ContentType, throwOnBadRequest); 1501formValue = 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)) 3539var body = await JsonSerializer.DeserializeAsync<JsonTodo>(context.Request.Body); 3540context.Request.Body.Position = 0;

145httpContext.Request.RouteValues["id"] = i.ToString(CultureInfo.InvariantCulture); 408httpContext.Request.QueryString = QueryString.Create("value", endpoint.DisplayName); 523httpContext.Request.QueryString = httpContext.Request.QueryString.Add(QueryString.Create(value, value)); 526httpContext.Request.Headers[value] = value; 529httpContext.Request.RouteValues[value] = value;

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

35httpContext.Request.QueryString = new QueryString("?p=1&p=1"); 56httpContext.Request.Headers.Add("p", new StringValues(new string[] { "1", "1" })); 77httpContext.Request.Headers.Add("p", new StringValues(new string[] { "1", "1" })); 98httpContext.Request.Headers.Add("p", new StringValues(new string[] { "1", "1" })); 171httpContext.Request.Query = new QueryCollection(new Dictionary<string, StringValues> 196httpContext.Request.QueryString = new QueryString("?p=1&p=1"); 217httpContext.Request.QueryString = new QueryString("?p=Item1&p=Item2"); 238httpContext.Request.QueryString = new QueryString("?p=Item1&p=Item2"); 279httpContext.Request.QueryString = new QueryString("?p=&p="); 300httpContext.Request.QueryString = new QueryString("?p=Item1&p=Item2"); 321httpContext.Request.QueryString = new QueryString("?p=Item1&p=Item2"); 342httpContext.Request.QueryString = new QueryString("?p=Item1&p=Item2"); 364httpContext.Request.Headers["Content-Type"] = "application/json"; 367httpContext.Request.Body = stream; 368httpContext.Request.Headers["Content-Length"] = stream.Length.ToString(CultureInfo.InvariantCulture); 369httpContext.Request.QueryString = new QueryString("?p=ValueFromQueryString"); 391httpContext.Request.Headers["Content-Type"] = "application/json"; 394httpContext.Request.Body = stream; 395httpContext.Request.Headers["Content-Length"] = stream.Length.ToString(CultureInfo.InvariantCulture); 396httpContext.Request.QueryString = new QueryString("?p=ValueFromQueryString"); 418httpContext.Request.Headers["Content-Type"] = "application/json"; 421httpContext.Request.Body = stream; 422httpContext.Request.Headers["Content-Length"] = stream.Length.ToString(CultureInfo.InvariantCulture); 423httpContext.Request.QueryString = new QueryString("?p=ValueFromQueryString"); 445httpContext.Request.Headers["Content-Type"] = "application/json"; 448httpContext.Request.Body = stream; 449httpContext.Request.Headers["Content-Length"] = stream.Length.ToString(CultureInfo.InvariantCulture); 450httpContext.Request.QueryString = new QueryString("?p=ValueFromQueryString"); 472httpContext.Request.Headers["Content-Type"] = "application/json"; 475httpContext.Request.Body = stream; 476httpContext.Request.Headers["Content-Length"] = stream.Length.ToString(CultureInfo.InvariantCulture); 477httpContext.Request.QueryString = new QueryString("?p=ValueFromQueryString"); 501httpContext.Request.Query = new QueryCollection(new Dictionary<string, StringValues> 506httpContext.Request.Headers["Custom"] = new(new[] { "4", "5", "6" }); 508httpContext.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;

127output.Attributes.SetAttribute(SrcAttributeName, FileVersionProvider.AddFileVersionToPath(ViewContext.HttpContext.Request.PathBase, Src));

283FileVersionProvider.AddFileVersionToPath(ViewContext.HttpContext.Request.PathBase, Href), 455valueToWrite = FileVersionProvider.AddFileVersionToPath(ViewContext.HttpContext.Request.PathBase, fallbackHrefs[i]); 476ViewContext.HttpContext.Request.PathBase); 525hrefValue = FileVersionProvider.AddFileVersionToPath(ViewContext.HttpContext.Request.PathBase, hrefValue);

250FileVersionProvider.AddFileVersionToPath(ViewContext.HttpContext.Request.PathBase, Src), 369srcValue = FileVersionProvider.AddFileVersionToPath(ViewContext.HttpContext.Request.PathBase, srcValue); 408ViewContext.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";

232actionContext.HttpContext.Request.PathBase = new Http.PathString(requestPathBase);

954actionContext.HttpContext.Request.PathBase = new PathString(requestPathBase);

829actionContext.HttpContext.Request.PathBase = new Http.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 = "/"; 946context1.HttpContext.Request.Method = "GET"; 947context1.HttpContext.Request.Path = "/"; 950context2.HttpContext.Request.Method = "GET"; 951context2.HttpContext.Request.Path = "/"; 972context.HttpContext.Request.Method = "GET"; 994context.AllowCacheLookup = !context.HttpContext.Request.Headers.ContainsKey("X-Refresh"); 1042requestContext.HttpContext.Request.Method = "GET"; 1043requestContext.HttpContext.Request.Path = "/"; 1049requestContext.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;

142httpContext.Request.RouteValues = null!; 377var 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);

88var form = await context.Request.ReadFormAsync(); 350var form = await context.Request.ReadFormAsync(); 364var form = context.Request.Form; 452context.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";