byte[] outputBytes, int ioctlFlags) {
        final int headerLen = 64; // SMB2 header is 64 bytes
        final int bodyFixed = 48; // body size minus 1 for structure size field overlap
        final int payloadStart = headerLen + bodyFixed;
        final int bodyLen = bodyFixed + inputCount + outputCount;

        byte[] buf = new byte[bodyLen];
        int pos = 0;

 *
 * Mappings Data (4,719 bytes)
 * ===========================
 *
 * This is UTF-8 character data. It is indexed into by b2b3 in the ranges dataset.
 *
 * Mappings may overlap.
 *
 * ASCII-Only
 * ==========
 *
 * Neither the section index nor the ranges data use bit 0x80 anywhere. That means the data is

            assertEquals(0x0002, Smb2Constants.SMB2_NEGOTIATE_SIGNING_REQUIRED, "Signing required flag must be 0x0002");
        }

        @Test
        @DisplayName("Signing flags should not overlap")
        void testSigningFlagsNoOverlap() {
            assertNotEquals(Smb2Constants.SMB2_NEGOTIATE_SIGNING_ENABLED, Smb2Constants.SMB2_NEGOTIATE_SIGNING_REQUIRED,
                    "Signing flags must be distinct");

	}

	if cap(t.requestsPool) != apiRequestsMaxPerNode {
		// Only replace if needed.
		// Existing requests will use the previous limit,
		// but new requests will use the new limit.
		// There will be a short overlap window,
		// but this shouldn't last long.
		t.requestsPool = make(chan struct{}, apiRequestsMaxPerNode)
	}
	listQuorum := cfg.ListQuorum
	if listQuorum == "" {
		listQuorum = "strict"
	}

	}

	ahs.Lock()
	defer ahs.Unlock()

	// Check if new heal sequence to be started overlaps with any
	// existing, running sequence
	hpath := pathJoin(h.bucket, h.object)
	for k, hSeq := range ahs.healSeqMap {
		if !hSeq.hasEnded() && (HasPrefix(k, hpath) || HasPrefix(hpath, k)) {
			errMsg = "The provided heal sequence path overlaps with an existing " +
				fmt.Sprintf("heal path: %s", k)

        assertEquals(2, resolvedFirst.length);
        assertEquals("user1", ((SID) resolvedFirst[0]).acctName);
        assertEquals("user2", ((SID) resolvedFirst[1]).acctName);

        // Second call with overlap should use cache for s2 and s3, requiring only s3 if not cached
        // Mark s3 unresolved to force resolve of one element
        doAnswer(inv -> {
            SID[] toResolve = inv.getArgument(2);

Where the spec is ambiguous, OkHttp follows modern user agents such as popular Browsers or common HTTP Libraries.

OkHttp is principled and avoids being overly configurable, especially when such configuration is
to workaround a buggy server, test invalid scenarios or that contradict the relevant RFC.

    assertLockHeld()

    // If this connection is not accepting new exchanges, we're done.
    if (calls.size >= allocationLimit || noNewExchanges) return false

    // If the non-host fields of the address don't overlap, we're done.
    if (!this.route.address.equalsNonHost(address)) return false

    // If the host exactly matches, we're done: this connection can carry the address.
    if (address.url.host ==
      this

     * Wrapper<Number>, Wrapper<Integer>, Wrapper<@Nullable Integer>, etc. If we used just
     * Equivalence<? super T> below, no type could satisfy both that bound and T's own
     * bound. With this type, they have some overlap: in our example, Equivalence<Number>
     * and Equivalence<Object>.
     */
    private final Equivalence<? super @NonNull T> equivalence;

    @ParametricNullness private final T reference;

	objInfo.VersionPurgeStatusInternal = fi.ReplicationState.VersionPurgeStatusInternal
	objInfo.ReplicationStatus = fi.ReplicationStatus()
	if objInfo.ReplicationStatus.Empty() { // overlay x-amx-replication-status if present for replicas
		if st, ok := fi.Metadata[xhttp.AmzBucketReplicationStatus]; ok && st == string(replication.Replica) {
			objInfo.ReplicationStatus = replication.StatusType(st)
		}
	}