// requireNonNull is safe because the cell exists in the table.
      cellColumnIndices[i++] = requireNonNull(columnKeyToIndex.get(cell.getColumnKey()));
    }
    return SerializedForm.create(this, cellRowIndices, cellColumnIndices);
  }

          .Builder()
          .url(server.url("/"))
          .build(),
      )
    warmUpCall.execute().use { warmUpResponse -> warmUpResponse.body.string() }
    listener.clearAllEvents()

    // Create a client with artificial delays.
    client =
      client
        .newBuilder()
        .addInterceptor(
          Interceptor { chain: Interceptor.Chain ->
            try {

      Response
        .Builder()
        .request(request)
        .code(200)
        .message("")
        .protocol(Protocol.HTTP_2)
        .build()
    val listener = loggingEventListenerFactory.create(call)
    listener.cacheConditionalHit(call, response)
    listener.cacheHit(call, response)
    listener.cacheMiss(call)
    listener.satisfactionFailure(call, response)
    logRecorder

          ImmutableSet.of(
              "java.lang.invoke.VarHandle",
              "sun.misc.Unsafe",
              AtomicReferenceFieldUpdater.class.getName()));

  public static TestSuite suite() {
    // we create a test suite containing a test for every AbstractFutureTest test method and we
    // set it as the name of the test.  Then in runTest we can reflectively load and invoke the

 * Supported on OpenJDK 9+ via SSLParameters and SSLSocket features.
 *
 * ### Trust Manager Extraction
 *
 * Supported on Android 2.3+ and OpenJDK 7+. There are no public APIs to recover the trust
 * manager that was used to create an [SSLSocketFactory].
 *
 * Not supported by choice on JDK9+ due to access checks.
 *
 * ### Android Cleartext Permit Detection
 *
 * Supported on Android 6.0+ via `NetworkSecurityPolicy`.
 */

            outputBufferLengthField.setAccessible(true);
            outputBufferLengthField.set(request, 0x8000);

            // Create a buffer and write
            byte[] buffer = new byte[256];
            int bytesWritten = request.writeBytesWireFormat(buffer, 64);

            // Verify structure size (should be 41)

  "durations" : [ {
    "testProject" : "archivePerformanceProject",
    "linux" : 753
  } ]
}, {
  "scenario" : "org.gradle.performance.regression.corefeature.DeprecationCreationPerformanceTest.create many deprecation warnings",
  "durations" : [ {
    "testProject" : "generateLotsOfDeprecationWarnings",
    "linux" : 127
  } ]
}, {

        // Decode
        fileBothDirectoryInfo.decode(buffer, 0, buffer.length);

        // Verify
        assertEquals(expectedFilename, fileBothDirectoryInfo.getFilename());
    }

    // Helper methods to create valid buffer data
    private byte[] createValidBuffer(String filename, String shortName, boolean unicode) {
        int filenameLength = unicode ? filename.length() * 2 : filename.length();

        assertFalse(rule.match(responseData2));
    }

    /**
     * Test rule ID uniqueness
     */
    public void test_ruleIdUniqueness() {
        List<Rule> rules = new ArrayList<>();

        // Create rules with unique IDs
        for (int i = 0; i < 100; i++) {
            TestRule rule = new TestRule("rule_" + i, new TestResponseProcessor("processor_" + i), true);
            rules.add(rule);
        }

    /**
     * Map of pending requests to their corresponding responses.
     */
    protected HashMap response_map = new HashMap(4);

    /**
     * Creates a key for the specified request for response matching.
     *
     * @param request the request to create a key for
     * @throws IOException if an I/O error occurs
     */
    protected abstract void makeKey(Request request) throws IOException;

    /**