@DisplayName("Test getSendBufferSize returns standard size")
    void testGetSendBufferSizeStandard() {
        // Arrange
        int expectedSize = 65536;
        when(negotiationResponse.getSendBufferSize()).thenReturn(expectedSize);

        // Act
        int size = negotiationResponse.getSendBufferSize();

        // Assert
        assertEquals(expectedSize, size);
        verify(negotiationResponse).getSendBufferSize();

    // Split out all the specified sizes.
    Set<Feature<?>> sizesToTest = Helpers.copyToSet(CollectionSize.values());
    sizesToTest.retainAll(features);
    features.removeAll(sizesToTest);

    addImpliedFeatures(sizesToTest);
    sizesToTest.retainAll(asList(CollectionSize.ZERO, CollectionSize.ONE, CollectionSize.SEVERAL));

    logger.fine("   Sizes: " + formatFeatureSet(sizesToTest));

        // Then
        assertEquals(0, result);
    }

    /**
     * Test writeParameterWordsWireFormat with various buffer sizes
     */
    @Test
    @DisplayName("Test writeParameterWordsWireFormat with different buffer sizes")
    public void testWriteParameterWordsWireFormatWithDifferentBufferSizes() {
        // Given
        smbComTreeDisconnect = new SmbComTreeDisconnect(config);

    ImmutableSet.Builder<String> builder = ImmutableSet.builderWithExpectedSize(4);
    builder.add("a");
    assertEquals(1, builder.size);
    builder.add("a");
    assertEquals(1, builder.size);
    builder.add("b", "c", "d");
    assertEquals(4, builder.size);
    Object[] table = builder.hashTable;
    assertNotNull(table);
    assertSame(table, ((RegularImmutableSet<String>) builder.build()).table);
  }

    @CanIgnoreReturnValue
    public Builder addAll(LongStream stream) {
      Spliterator.OfLong spliterator = stream.spliterator();
      long size = spliterator.getExactSizeIfKnown();
      if (size > 0) { // known *and* nonempty
        ensureRoomFor(Ints.saturatedCast(size));
      }
      spliterator.forEachRemaining((LongConsumer) this::add);
      return this;
    }

    /**

        @Test
        @DisplayName("Should read valid structure with size 4")
        void testReadBytesWireFormatValidStructure() throws SMBProtocolDecodingException {
            // Given
            byte[] buffer = new byte[10];
            int bufferIndex = 0;
            SMBUtil.writeInt2(4, buffer, bufferIndex); // Write structure size = 4
            SMBUtil.writeInt2(0, buffer, bufferIndex + 2); // Reserved field

        // Then - should include context sizes
        assertTrue(size > 112); // Bigger than without contexts
        assertEquals(0, size % 8); // Should be 8-byte aligned
    }

    @Test
    @DisplayName("Should write bytes to wire format correctly")
    void testWriteBytesWireFormat() {
        // Given
        when(mockConfig.getMaximumVersion()).thenReturn(DialectVersion.SMB302);

    @DisplayName("Should handle various data sizes in hexdump")
    void testHexdumpVariousSizes(int size) {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        PrintStream ps = new PrintStream(baos);

        byte[] data = createTestData(size);
        Hexdump.hexdump(ps, data, 0, size);
        String output = baos.toString();

        assertNotNull(output);

  // Max size is halved due to indexing into double-sized alternatingKeysAndValues
  private static final int BYTE_MAX_SIZE = 1 << (Byte.SIZE - 1); // 2^7 = 128
  private static final int SHORT_MAX_SIZE = 1 << (Short.SIZE - 1); // 2^15 = 32_768

  private static final int BYTE_MASK = (1 << Byte.SIZE) - 1; // 2^8 - 1 = 255
  private static final int SHORT_MASK = (1 << Short.SIZE) - 1; // 2^16 - 1 = 65_535

    // When called at high frequency, boxing size generates too much garbage,
    // so avoid doing that if we can.
    checkArgument(size >= 0, "Invalid size: %s", size);
    return newDataOutput(new ByteArrayOutputStream(size));
  }

  /**
   * Returns a new {@link ByteArrayDataOutput} instance which writes to the given {@code