"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
	}

  size_t i = 0;
  for (auto dummy : state) {
    sum = *callable.Call<Integer>(sum, Integer(i));
    i++;
  }
}

// Add numbers in a loop by calling a callable, looking up method every
// time by tokenized string.
void CallFunctionsIndirect(::testing::benchmark::State& state) {
  Integer sum(0);
  Callable callable((impl::TaggedValue(impl::Func(AddTagged))));
  Object o;
  String name("f");

        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")

	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

primary responsibility for any HTTP client is to efficiently manage network connections. Creating and establishing new connections require a fair amount of overhead and added latency. OkHttp will make every effort to reuse existing connections to avoid this overhead and added latency.

Every OkHttpClient uses a connection pool. Its job is to maintain a reference to all open connections. When an HTTP request is started, OkHttp will attempt to reuse an existing connection from the pool. If there...

@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):

		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

	tm "time"

	r "golang.org/x/time/rate"
)

func Example() {
	fmt.Println("Hello, world!")
	// Output: Hello, world!
}

func ExampleLimiter() {
	// Uses fmt, time and rate.
	l := r.NewLimiter(r.Every(tm.Second), 1)
	fmt.Println(l)

        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")