*   <li>Supports a copy-free {@link #subArray} view, so methods that accept this type don't need to
 *       add overloads that accept start and end indexes.
 *   <li>Can be streamed without "breaking the chain": {@code foo.getBarLongs().stream()...}.
 *   <li>Access to all collection-based utilities via {@link #asList} (though at the cost of
 *       allocating garbage).
 * </ul>
 *
 * <p>Disadvantages compared to {@code long[]}:

 *   <li>Supports a copy-free {@link #subArray} view, so methods that accept this type don't need to
 *       add overloads that accept start and end indexes.
 *   <li>Can be streamed without "breaking the chain": {@code foo.getBarInts().stream()...}.
 *   <li>Access to all collection-based utilities via {@link #asList} (though at the cost of
 *       allocating garbage).
 * </ul>
 *
 * <p>Disadvantages compared to {@code int[]}:

HSPLokhttp3/internal/http/BridgeInterceptor;-><init>(Lokhttp3/CookieJar;)V
HSPLokhttp3/internal/http/BridgeInterceptor;->intercept(Lokhttp3/Interceptor$Chain;)Lokhttp3/Response;
HSPLokhttp3/internal/http/CallServerInterceptor;-><init>(Z)V
HSPLokhttp3/internal/http/CallServerInterceptor;->intercept(Lokhttp3/Interceptor$Chain;)Lokhttp3/Response;
HSPLokhttp3/internal/http/HttpHeaders;-><clinit>()V
HSPLokhttp3/internal/http/HttpHeaders;->promisesBody(Lokhttp3/Response;)Z

        // Test constructor with config and andx
        TestAndXServerMessageBlock block3 = new TestAndXServerMessageBlock(mockConfig) {
            {
                // Set andx via constructor chain
                super.setCommand((byte) 0x25);
            }
        };
        assertNotNull(block3);
    }

            for (int j = i + 1; j < rules.size(); j++) {
                assertNotSame(rules.get(i).getRuleId(), rules.get(j).getRuleId());
            }
        }
    }

    /**
     * Test rule processor chain behavior
     */
    public void test_ruleProcessorChain() {
        final List<String> executionOrder = new ArrayList<>();

        // Create custom processor that tracks execution

        response = spy(response);
        when(response.getHeaderStart()).thenReturn(0);

        // Due to bug in line 96, data must be written at bufferIndex=8
        // Write entries with proper nextEntryOffset chain starting at 8
        int currentOffset = 8;
        for (int i = 0; i < 3; i++) {
            // Set NextEntryOffset (104 bytes to next, 0 for last)
            SMBUtil.writeInt4(i < 2 ? 104 : 0, buffer, currentOffset);

 *  Fix: Enforce the max intermediates constraint when using pinned certificates with Conscrypt.
    This impacts Conscrypt when the server's presented certificates form both a trusted-but-unpinned
    chain and an untrusted-but-pinned chain.
 *  Upgrade: [Kotlin 1.6.10][kotlin_1_6_10].


## Version 5.0.0-alpha.3

_2021-11-22_

 *  Fix: Change `Headers.toString()` to redact authorization and cookie headers.

   * part of the smeared hash of the key not covered by the hashtable mask, whereas the low bits are
   * the "next" pointer (pointing to the next entry in the bucket chain), which will always be less
   * than or equal to the hashtable mask.
   *
   * <pre>
   * hash  = aaaaaaaa
   * mask  = 00000fff
   * next  = 00000bbb
   * entry = aaaaabbb
   * </pre>
   *

   * completing the returned {@code Future}.)
   *
   * <p>The returned {@code Future} attempts to keep its cancellation state in sync with that of the
   * input future and that of the future returned by the chain function. That is, if the returned
   * {@code Future} is cancelled, it will attempt to cancel the other two, and if either of the
   * other two is cancelled, the returned {@code Future} will receive a callback in which it will

  }

  /**
   * Returns a stream of this fluent iterable's contents (similar to calling {@link
   * Collection#stream} on a collection).
   *
   * <p><b>Note:</b> the earlier in the chain you can switch to {@code Stream} usage (ideally not
   * going through {@code FluentIterable} at all), the more performant and idiomatic your code will
   * be. This method is a transitional aid, to be used only when really necessary.