@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();

    this.alternatingKeysAndValues = alternatingKeysAndValues;
    this.size = size;
    this.keyOffset = 0;
    int tableSize = (size >= 2) ? ImmutableSet.chooseTableSize(size) : 0;
    this.keyHashTable = createHashTableOrThrow(alternatingKeysAndValues, size, tableSize, 0);
    Object valueHashTable = createHashTableOrThrow(alternatingKeysAndValues, size, tableSize, 1);
    this.inverse =

        }

        @Test
        @DisplayName("Size should be consistent across multiple calls")
        void testSizeConsistency() {
            int size1 = echoRequest.size();
            int size2 = echoRequest.size();

            assertEquals(size1, size2);
        }

        @Test
        @DisplayName("Size should be 72 bytes (64 header + 4 body aligned to 8)")

	b.Run(" 00|X0 ", func(b *testing.B) { benchmarkErasureEncode(2, 2, 0, 1, size, b) })
	b.Run(" X0|00 ", func(b *testing.B) { benchmarkErasureEncode(2, 2, 1, 0, size, b) })
}

func BenchmarkErasureEncode_4_64KB(b *testing.B) {
	const size = 64 * 1024
	b.Run(" 00|00 ", func(b *testing.B) { benchmarkErasureEncode(2, 2, 0, 0, size, b) })
	b.Run(" 00|X0 ", func(b *testing.B) { benchmarkErasureEncode(2, 2, 0, 1, size, b) })

    }

    /**
     * Validate file size from server
     *
     * @param size file size
     * @throws SmbException if size is invalid
     */
    public void validateFileSize(long size) throws SmbException {
        totalValidations.incrementAndGet();

        if (size < 0) {
            failedValidations.incrementAndGet();
            log.warn("Negative file size: {}", size);

		t.Errorf("Expected the format to be \"%s\", but got \"%s\".", unMarshalXLMeta.Format, jsoniterXLMeta.Format)
	}
	if unMarshalXLMeta.Stat.Size != jsoniterXLMeta.Stat.Size {
		t.Errorf("Expected the stat size to be %v, but got %v.", unMarshalXLMeta.Stat.Size, jsoniterXLMeta.Stat.Size)
	}
	if !unMarshalXLMeta.Stat.ModTime.Equal(jsoniterXLMeta.Stat.ModTime) {

	b.Run(" X0|X0 ", func(b *testing.B) { benchmarkErasureDecode(2, 2, 1, 1, size, b) })
}

func BenchmarkErasureDecode_4_64KB(b *testing.B) {
	const size = 64 * 1024
	b.Run(" 00|00 ", func(b *testing.B) { benchmarkErasureDecode(2, 2, 0, 0, size, b) })
	b.Run(" 00|X0 ", func(b *testing.B) { benchmarkErasureDecode(2, 2, 0, 1, size, b) })
	b.Run(" X0|00 ", func(b *testing.B) { benchmarkErasureDecode(2, 2, 1, 0, size, b) })

	badDisks, badStaleDisks int

	blocksize, size int64
	algorithm       BitrotAlgorithm
	shouldFail      bool
}{
	{dataBlocks: 2, disks: 4, offDisks: 1, badDisks: 0, badStaleDisks: 0, blocksize: int64(blockSizeV2), size: oneMiByte, algorithm: SHA256, shouldFail: false},                   // 0

        assertEquals(0, result.getFailures().size());
    }

    @Test
    public void test_addFailure() throws Exception {
        SuggestWriterResult result = new SuggestWriterResult();

        Exception exception = new Exception("Test failure");
        result.addFailure(exception);

        assertTrue(result.hasFailure());
        assertEquals(1, result.getFailures().size());

        public String format(long size) {
            return format(size, null);
        }

        public String format(long size, ScaleUnit unit) {
            return format(size, unit, false);
        }

        public String format(long size, ScaleUnit unit, boolean omitSymbol) {
            if (size < 0L) {
                throw new IllegalArgumentException("file size cannot be negative: " + size);
            }