final int size = docs.size();
        if (size == 0) {
            return docs; // empty
        }
        int fromIndex = startPosition;
        if (fromIndex >= size) {
            fromIndex = size - 1;
        }
        int toIndex = startPosition + pageSize;
        if (toIndex >= size) {

          + aggregateAboveRange(aggr, node.left);
    }
  }

  @Override
  public int size() {
    return Ints.saturatedCast(aggregateForEntries(Aggregate.SIZE));
  }

  @Override
  int distinctElements() {
    return Ints.saturatedCast(aggregateForEntries(Aggregate.DISTINCT));
  }

  private static int distinctElements(@Nullable AvlNode<?> node) {
    return (node == null) ? 0 : node.distinctElements;
  }

	}

	baseTestCases := []TestSuiteCommon{
		// Init and run test on ErasureSD backend with signature v4.
		{serverType: "ErasureSD", signer: signerV4},
		// Init and run test on ErasureSD backend, with tls enabled.
		{serverType: "ErasureSD", signer: signerV4, secure: true},
		// Init and run test on Erasure backend.
		{serverType: "Erasure", signer: signerV4},
		// Init and run test on ErasureSet backend.

  @CanIgnoreReturnValue
  @Override
  public int remove(@Nullable Object element, int occurrences) {
    if (occurrences == 0) {
      return count(element);
    }
    checkPositive(occurrences, "occurrences");

    AtomicInteger existingCounter = safeGet(countMap, element);
    if (existingCounter == null) {
      return 0;
    }
    while (true) {
      int oldValue = existingCounter.get();

        }

        @ParameterizedTest
        @ValueSource(ints = { 0, 1, 2, 3, 5, 6, 100, 255, 65535 })
        @DisplayName("Should throw exception for various invalid structure sizes")
        void testReadBytesWireFormatVariousInvalidSizes(int invalidSize) {
            // Given
            byte[] buffer = new byte[10];
            int bufferIndex = 0;
            SMBUtil.writeInt2(invalidSize, buffer, bufferIndex);

        @ValueSource(ints = { 0, 1, 15, 127, 255 })
        void testVariousPadding(int padding) {
            assertDoesNotThrow(() -> request.setPadding((byte) padding));
        }

        @ParameterizedTest
        @DisplayName("Should handle various read lengths")
        @ValueSource(ints = { 0, 1, 512, 1024, 4096, 65536, 1048576 })
        void testVariousReadLengths(int length) {

        // Given
        int offset = 100;
        byte[] largeOutputBuffer = new byte[1024];
        Smb2ReadResponse offsetResponse = new Smb2ReadResponse(mockConfig, largeOutputBuffer, offset);

        byte[] buffer = new byte[256];
        int bodyStart = 0;
        int dataLength = 50;
        int dataOffsetFromHeader = 80;

        // Write structure

import static junit.framework.Assert.fail;

import com.google.common.annotations.GwtCompatible;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Ordering;
import com.google.common.primitives.Ints;
import com.google.errorprone.annotations.CanIgnoreReturnValue;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;

import static junit.framework.Assert.fail;

import com.google.common.annotations.GwtCompatible;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Ordering;
import com.google.common.primitives.Ints;
import com.google.errorprone.annotations.CanIgnoreReturnValue;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;

    }
  }

  public void testCrc32cStrideTable() {
    int next = CRC32C_GENERATOR_FLIPPED;
    for (int i = 0; i < 12; i++) { // for 3 ints = 12 bytes in between each stride window
      next = (next >>> 8) ^ Crc32cHashFunction.Crc32cHasher.byteTable[next & 0xFF];
    }
    int[][] expected = new int[4][256];
    for (int b = 0; b < 4; ++b) {
      for (int bit = 128; bit != 0; bit >>= 1) {
        expected[b][bit] = next;