// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// All of the actual test files have limited build constraints. This file
// ensures there's at least one test file on every platform.

	CheckRedirect func(req *Request, via []*Request) error

	// Jar specifies the cookie jar.
	//
	// The Jar is used to insert relevant cookies into every
	// outbound Request and is updated with the cookie values
	// of every inbound Response. The Jar is consulted for every
	// redirect that the Client follows.
	//
	// If Jar is nil, cookies are only sent if they are explicitly
	// set on the Request.
	Jar CookieJar

	"runtime"
	"testing"
)

func testSetgidStress(t *testing.T) {
	const N = 50
	ch := make(chan int, N)
	for i := 0; i < N; i++ {
		go func() {
			C.setgid(0)
			ch <- 1
			runtime.LockOSThread() // so every goroutine uses a new thread
		}()
	}
	for i := 0; i < N; i++ {
		<-ch
	}

        assert deps.contains("/very-cool-model")
        assert deps.contains("/root-util")
        assert deps.contains("/shared-api")
        assert deps.contains("/services-util")
    }

    def assertApiProjectContainsCorrectDependencies() {
        def deps = parseEclipseProjectDependencies(project: 'api')

        assert deps.contains("/very-cool-model")
        assert deps.contains("/shared-api")

		return
	}
	// A sender who sends one byte per chunk will send 5 bytes of overhead
	// for every byte of data. ("1\r\nX\r\n" to send "X".)
	// We want to allow this, since streaming a byte at a time can be legitimate.
	//
	// A sender can use chunk extensions to add arbitrary amounts of additional
	// data per byte read. ("1;very long extension\r\nX\r\n" to send "X".)
	// We don't want to disallow extensions (although we discard them),

	// spans, and one of unswept in-use spans. These two trade
	// roles on each GC cycle. The unswept set is drained either by
	// allocation or by the background sweeper in every GC cycle,
	// so only two roles are necessary.
	//
	// sweepgen is increased by 2 on each GC cycle, so the swept
	// spans are in partial[sweepgen/2%2] and the unswept spans are in

@needs_py310
@needs_pydanticv2
def test_post_body_example(client: TestClient):
    response = client.put(
        "/items/5",
        json={
            "name": "Foo",
            "description": "A very nice Item",
            "price": 35.4,
            "tax": 3.2,
        },
    )
    assert response.status_code == 200


@needs_py310
@needs_pydanticv2
def test_openapi_schema(client: TestClient):

   *
   * <p>The returned set isn't threadsafe or serializable, even if {@code unfiltered} is.
   *
   * <p>Many of the filtered set's methods, such as {@code size()}, iterate across every element in
   * the underlying set and determine which elements satisfy the filter. When a live view is
   * <i>not</i> needed, it may be faster to copy {@code Iterables.filter(unfiltered, predicate)} and
   * use the copy.

        when:
        map.put(key1, "Foo")
        map.put(key2, "Bar")

        then:
        map.keySet().every { it.get() != null }

        when:
        key1 = null
        key2 = null

        then:
        waitForConditionAfterGC { map.keySet().every { it.get() == null } }
    }

    def "weakKey is doesn't keep strong reference at referent"() {
        Thing referent = new Thing("thing")

# Middleware

You can add middleware to **FastAPI** applications.

A "middleware" is a function that works with every **request** before it is processed by any specific *path operation*. And also with every **response** before returning it.

* It takes each **request** that comes to your application.
* It can then do something to that **request** or run any needed code.