@BeforeEach
  fun setUp() {
    // Sockets on some platforms can have large buffers that mean writes do not block when
    // required. These socket factories explicitly set the buffer sizes on sockets created.
    server = MockWebServer()
    server.serverSocketFactory =
      object : DelegatingServerSocketFactory(getDefault()) {
        @Throws(SocketException::class)

    return new HashBasedTable<>(new LinkedHashMap<R, Map<C, V>>(), new Factory<C, V>(0));
  }

  /**
   * Creates an empty {@code HashBasedTable} with the specified map sizes.
   *
   * @param expectedRows the expected number of distinct row keys
   * @param expectedCellsPerRow the expected number of column key / value mappings in each row

    return new HashBasedTable<>(new LinkedHashMap<R, Map<C, V>>(), new Factory<C, V>(0));
  }

  /**
   * Creates an empty {@code HashBasedTable} with the specified map sizes.
   *
   * @param expectedRows the expected number of distinct row keys
   * @param expectedCellsPerRow the expected number of column key / value mappings in each row

                        "Should throw SMBProtocolDecodingException for invalid structure size");

        assertEquals("Expected structureSize = 9", exception.getMessage());
    }

    @ParameterizedTest
    @ValueSource(ints = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 11, 100, 255, 256, 65535 })
    @DisplayName("Test readBytesWireFormat with various invalid structure sizes")
    void testReadBytesWireFormatVariousInvalidSizes(int invalidSize) {

   */
  public static <E> Set<Set<E>> combinations(Set<E> set, int size) {
    ImmutableMap<E, Integer> index = Maps.indexMap(set);
    checkNonnegative(size, "size");
    checkArgument(size <= index.size(), "size (%s) must be <= set.size() (%s)", size, index.size());
    if (size == 0) {
      return ImmutableSet.<Set<E>>of(ImmutableSet.<E>of());
    } else if (size == index.size()) {
      return ImmutableSet.<Set<E>>of(index.keySet());

func BenchmarkPutObjectVerySmallErasure(b *testing.B) {
	benchmarkPutObject(b, "Erasure", 10)
}

// BenchmarkPutObject10KbFS - Benchmark FS.PutObject() for object size of 10KB.
func BenchmarkPutObject10KbFS(b *testing.B) {
	benchmarkPutObject(b, "FS", 10*humanize.KiByte)
}

// BenchmarkPutObject10KbErasure - Benchmark Erasure.PutObject() for object size of 10KB.

        assertEquals("Payload exceeds buffer size", exception.getMessage());
    }

    @ParameterizedTest
    @ValueSource(ints = { 1, 10, 100, 500, 1024 })
    void testReadDataWireFormatWithVariousSizes(int dataSize) throws SMBProtocolDecodingException {
        if (dataSize > outputBuffer.length) {
            return; // Skip sizes larger than buffer
        }

        assertEquals(data.hashCode(), blob.hashCode(), "hashCode should equal the array's hashCode");
    }

    // Validates equals() returns true for same-sized, equal-content blobs
    @Test
    @DisplayName("equals: identical content and size -> true")
    void equals_identicalContent_true() {
        // Arrange
        byte[] a = new byte[] { 1, 2, 3 };
        byte[] b = new byte[] { 1, 2, 3 };

    int size = random.nextInt(2048);
    byte[] bytes = new byte[size];
    random.nextBytes(bytes);
    assertEquals(
        hashFunction.hashBytes(bytes), hashFunction.newHasher(size).putBytes(bytes).hash());
    int off = random.nextInt(size);
    int len = random.nextInt(size - off);
    assertEquals(
        hashFunction.hashBytes(bytes, off, len),

        })
        @DisplayName("Should handle various file sizes correctly")
        void testVariousFileSizes(long size, long expectedSize) throws SMBProtocolDecodingException {
            // Given
            byte[] buffer = new byte[60];
            SMBUtil.writeInt2(60, buffer, 0);
            SMBUtil.writeInt8(size * 2, buffer, 40); // Allocation size
            SMBUtil.writeInt8(size, buffer, 48); // End of file

            // When