return (b0 shl 7) + b1
}

/**
 * An extremely generic binary search that doesn't know what data it's searching over. The caller
 * provides indexes and a comparison function, and this calls that function iteratively.
 *
 * @return the index of the match. If no match is found this is `(-1 - insertionPoint)`, where the
 *     inserting the element at `insertionPoint` will retain sorted order.
 */

    if (pooled1 != null) return pooled1

    // Attempt a deferred plan before new routes.
    if (deferredPlans.isNotEmpty()) return deferredPlans.removeFirst()

    // Do blocking calls to plan a route for a new connection.
    val connect = planConnect()

    // Now that we have a set of IP addresses, make another attempt at getting a connection from

        // When
        iterator.next(); // Move to first element
        iterator.remove();

        // Then
        verify(mockDelegate).remove();
    }

    /**
     * Test multiple calls to hasNext without calling next.
     */
    @Test
    void testMultipleHasNextCalls() {
        // Given
        when(mockDelegate.hasNext()).thenReturn(true, false);

	t.mu.RLock()
	defer t.mu.RUnlock()

	if t.requestsPool == nil {
		return nil
	}

	return t.requestsPool
}

// maxClients throttles the S3 API calls
func maxClients(f http.HandlerFunc) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		globalHTTPStats.incS3RequestsIncoming()

		if r.Header.Get(globalObjectPerfUserMetadata) == "" {

	if err != nil {
		t.Fatalf("MinIO %s: Failed to create an anonymous request for bucket \"%s\": <ERROR> %v",
			instanceType, bucketName, err)
	}

	// ExecObjectLayerAPIAnonTest - Calls the HTTP API handler using the anonymous request, validates the ErrAccessDeniedResponse,
	// sets the bucket policy using the policy statement generated from `getWriteOnlyObjectStatement` so that the

        result = createInfoMethod.invoke(response);
        assertNull(result);
    }

    @Test
    void testMultipleReadDataWireFormat() throws Exception {
        // Test multiple calls to readDataWireFormat
        response = new Trans2QueryFSInformationResponse(config, FileSystemInformation.SMB_INFO_ALLOCATION);

        // Prepare buffer
        byte[] buffer = prepareAllocationInfoBuffer();

        for (int i = 0; i < 24; i++) {
            assertEquals((byte) (i % 256), resumeKey[i], "Resume key byte " + i + " should match buffer");
        }
    }

    @Test
    @DisplayName("Test multiple decode calls on same instance")
    void testMultipleDecodeCalls() throws SMBProtocolDecodingException {
        // First decode
        byte[] buffer1 = new byte[28];
        Arrays.fill(buffer1, 0, 24, (byte) 0x11);

        // Verify
        assertEquals(3, includePatterns.size());
        assertEquals(3, excludePatterns.size());

        // Verify all calls were made
        verify(dataHelper).addIncludeUrlPattern(sessionId, "https://example.com/.*");
        verify(dataHelper).addIncludeUrlPattern(sessionId, "https://test.com/.*");

## Use it { #use-it }

Now you can declare your dependency using this class.

{* ../../docs_src/dependencies/tutorial002_an_py310.py hl[19] *}

**FastAPI** calls the `CommonQueryParams` class. This creates an "instance" of that class and the instance will be passed as the parameter `commons` to your function.

## Type annotation vs `Depends` { #type-annotation-vs-depends }

            buffer.putInt(4);
            buffer.putInt(1024);

            // When
            fileFsFullSizeInfo.decode(buffer.array(), 0, 32);

            // Then - multiple calls should return same values
            assertEquals(2000L * 4 * 1024, fileFsFullSizeInfo.getCapacity());
            assertEquals(2000L * 4 * 1024, fileFsFullSizeInfo.getCapacity());