setTree(c, tree);

        // Act: first acquire triggers tree.acquire()
        c.acquire();
        verify(tree, times(1)).acquire();

        // Act: second acquire does not call tree.acquire again
        c.acquire();
        verify(tree, times(1)).acquire();

        // Act: first release does not release yet (usage -> 1)
        c.release();
        verify(tree, never()).release();

        assertEquals(State.CLOSED, circuitBreaker.getState(), "Circuit should be CLOSED after success threshold");

        // Test max attempts in half-open with failure scenario
        circuitBreaker.trip(); // Open again
        Thread.sleep(1100); // Wait for reset

        // First attempt transitions to HALF_OPEN
        try {
            circuitBreaker.executeWithCircuitBreaker(() -> {
                // Verify we're in HALF_OPEN

    call.plansToCancel += this
    try {
      if (tunnelRequest != null) {
        val tunnelResult = connectTunnel()

        // Tunnel didn't work. Start it all again.
        if (tunnelResult.nextPlan != null || tunnelResult.throwable != null) {
          return tunnelResult
        }
      }

      if (route.address.sslSocketFactory != null) {

                         * with node status so we need to check to make sure that
                         * the record type matches the question type and if not,
                         * loop around and try again.
                         */
                        if (response.received && request.questionType == response.recordType) {
                            return;
                        }

            sid.initContext("srv", mockCtx);

            // First accessor triggers resolution
            int t1 = sid.getType();
            assertEquals(t1, sid.getType()); // second call should not trigger again
            verify(mockResolver, times(1)).resolveSids(eq(mockCtx), eq("srv"), any(jcifs.SID[].class));
        }

        @Test

                    }
                }

                // TODO should this be inside the above check?
                // touch file so that this is not checked again until interval has passed
                if (file.exists()) {
                    file.setLastModified(System.currentTimeMillis());
                }
            }
        }

        try {

And it generates OpenAPI schemas.

That's how it works in Flask, Starlette, Responder, etc.

But then, we have again the problem of having a micro-syntax, inside of a Python string (a big YAML).

        // Read the three data bytes
        assertEquals(1, sis.read());
        assertEquals(2, sis.read());
        assertEquals(3, sis.read());

        // After consuming all data, trying to read again will attempt to read
        // another packet header, but since there's no more data, it will throw IOException
        assertThrows(IOException.class, () -> sis.read());
    }

    @Test

	// sets the bucket policy using the policy statement generated from `getWriteOnlyObjectStatement` so that the
	// unsigned request goes through and its validated again.
	ExecObjectLayerAPIAnonTest(t, obj, "TestAPIHeadObjectHandler", bucketName, objectName, instanceType, apiRouter, anonReq, getAnonReadOnlyObjectPolicy(bucketName, objectName))

	tok := in.Stack.Next()
	if tok != scanner.Ident {
		in.expectText("expected identifier after '#'")
	}
	if !in.enabled() {
		// Can only start including again if we are at #else or #endif but also
		// need to keep track of nested #if[n]defs.
		// We let #line through because it might affect errors.
		switch in.Stack.Text() {
		case "else", "endif", "ifdef", "ifndef", "line":