@Execute
    @Secured({ ROLE })
    public HtmlResponse reindexOnly(final ActionForm form) {
        validate(form, messages -> {}, this::asIndexHtml);
        verifyToken(this::asIndexHtml);
        if (startReindex(isCheckboxEnabled(form.replaceAliases), isCheckboxEnabled(form.resetDictionaries), form.numberOfShardsForDoc,
                form.autoExpandReplicasForDoc)) {

            // When
            int bytesWritten = chunk.encode(buffer, startIndex);

            // Then
            assertEquals(EXPECTED_SIZE, bytesWritten);
            assertEquals(0L, SMBUtil.readInt8(buffer, startIndex));
            assertEquals(0L, SMBUtil.readInt8(buffer, startIndex + 8));
            assertEquals(0, SMBUtil.readInt4(buffer, startIndex + 16));
        }

        @Test

        byte[] buffer = new byte[100];
        int startIndex = 10;
        buffer[startIndex] = 1; // replaceIfExists = true
        SMBUtil.writeInt4(nameBytes.length, buffer, startIndex + 16);
        System.arraycopy(nameBytes, 0, buffer, startIndex + 20, nameBytes.length);

        FileRenameInformation2 info = new FileRenameInformation2();
        int bytesRead = info.decode(buffer, startIndex, buffer.length - startIndex);

            // When
            int bytesWritten = copy.encode(buffer, startIndex);

            // Then
            assertEquals(HEADER_SIZE + (3 * CHUNK_SIZE), bytesWritten);

            // Verify chunk count
            assertEquals(3, SMBUtil.readInt4(buffer, startIndex + SOURCE_KEY_SIZE));

            // Verify first chunk
            int chunkStart = startIndex + HEADER_SIZE;

}


private
fun <T> List<T>.indexOfFirst(startIndex: Int, predicate: (T) -> Boolean): Int {
    require(startIndex in indices) {
        "startIndex must be in range [0, $size): $startIndex"
    }
    return this.subList(startIndex, size).indexOfFirst(predicate).let {
        if (it == -1) -1 else it + startIndex
    }
}


private
fun File.asClickableFileUrl(): String {

        byte[] buffer = new byte[100];
        int startIndex = 5;
        original.encode(buffer, startIndex);

        // Now decode into a new instance
        int bytesRead = fileBasicInfo.decode(buffer, startIndex, 36);

        // Verify bytes read
        assertEquals(36, bytesRead);

        // Verify decoded values match original

        for (int i = 0; i < dst.length; i++) {
            dst[i] = (byte) (i & 0xFF);
        }

        int startIndex = 5;
        int bytesWritten = querySecurityDesc.writeParametersWireFormat(dst, startIndex);

        // Check that bytes before startIndex are unchanged
        for (int i = 0; i < startIndex; i++) {
            assertEquals((byte) (i & 0xFF), dst[i]);
        }

            byte[] buffer = new byte[100];
            int startIndex = 10;

            int bytesWritten = echoRequest.writeBytesWireFormat(buffer, startIndex);

            // Should write 4 bytes
            assertEquals(4, bytesWritten);

            // Should write structure size of 4
            assertEquals(4, SMBUtil.readInt2(buffer, startIndex));
        }

        @Test

        int startIndex = 10;

        // Prepare buffer with offset
        byte[] fullBuffer = new byte[buffer.length + startIndex];
        System.arraycopy(buffer, 0, fullBuffer, startIndex, buffer.length);

        setErrorCode(response, 0);

        int bytesRead = response.readDataWireFormat(fullBuffer, startIndex, buffer.length);

                  : Lists.reverse(distinctCandidatesByAscendingSize));
      for (int startIndex = 0;
          startIndex < distinctCandidatesByAscendingSize.size();
          startIndex++) {
        Iterable<ImmutableSet<String>> infiniteSetsFromStartIndex =
            Iterables.skip(infiniteSets, startIndex);
        for (boolean inputIsSet : new boolean[] {true, false}) {
          Collection<String> input =