}

  /**
   * Asserts that the current response was redirected and returns the prior response.
   */
  fun priorResponse(): RecordedResponse {
    val priorResponse = response!!.priorResponse!!
    return RecordedResponse(priorResponse.request, priorResponse, null, null, null)
  }

  /**
   * Asserts that the current response used the network and returns the network response.
   */

        this.manager = manager;
        this.strategy = LoadBalancingStrategy.ADAPTIVE;
        this.roundRobinCounter = new AtomicInteger(0);
    }

    /**
     * Get current load balancing strategy
     *
     * @return current strategy
     */
    public LoadBalancingStrategy getStrategy() {
        return strategy;
    }

    /**
     * Set load balancing strategy
     *

    }

    /**
     * Filters JVM options based on the current Java version.
     * Options can be prefixed with version numbers to specify compatibility.
     * Format: "version:option" or "version-:option" (for version and above).
     *
     * @param values the array of JVM options to filter
     * @return the filtered array of JVM options applicable to the current Java version
     */

    }

    /**
     * Sets an object in the current request attributes.
     *
     * @param name The attribute name
     * @param value The attribute value
     */
    public static void setObject(final String name, final Object value) {
        LaRequestUtil.getOptionalRequest().ifPresent(req -> req.setAttribute(name, value));
    }

    /**
     * Gets an object from the current request attributes.
     *

     * @param parentKey the parent key path
     * @param textBuilder the string builder for text content
     * @param metadataMap the map for metadata extraction
     * @param depth the current depth in the JSON structure
     */
    protected void extractContent(final JsonNode node, final String parentKey, final StringBuilder textBuilder,
            final Map<String, List<String>> metadataMap, final int depth) {

            .toString()
            .contains("java.util.Map.java.util.Map")) {
          CURRENT = JAVA8;
        } else {
          CURRENT = JAVA9;
        }
      } else if (new TypeCapture<int[]>() {}.capture() instanceof Class) {
        CURRENT = JAVA7;
      } else {
        CURRENT = JAVA6;
      }
    }

    abstract Type newArrayType(Type componentType);

  // operating systems or architectures.
  api(variantOf(libs.amazonCorretto) {
    classifier(
      when {
        OperatingSystem.current().isMacOsX -> "osx-aarch_64"
        OperatingSystem.current().isLinux -> "linux-x86_64"
        else -> "linux-x86_64" // Code that references Corretto will build but not run.
      }
    )
  })

  api(libs.hamcrestLibrary)

        int count = 0;
        int prev = -1;
        Map<String, Object> source;
        while ((source = reader.read()) != null) {
            int current = Integer.parseInt(source.get("field2").toString());
            assertTrue(prev < current);
            prev = current;
            count++;
        }
        assertEquals(num, count);

        reader = new ESSourceReader(client, settings, indexName);

        /**
         * The number of milliseconds from the start of the current second.
         */
        public int msecs;
        /**
         * The current hour (0-23).
         */
        public int hours;
        /**
         * The current minute (0-59).
         */
        public int mins;
        /**
         * The current second (0-59).
         */
        public int secs;
        /**

        byte[] data = new byte[] { 1, 2, 3 };
        t.setMechanismToken(data);
        assertArrayEquals(data, t.getMechanismToken(), "mechanismToken should round-trip");

        // Document current behavior: no defensive copy (reference exposed)
        data[0] = 9;
        assertEquals(9, t.getMechanismToken()[0], "no defensive copy; reflects external mutation");
    }

    @Test