buffer.putInt(4096);
            byte[] bufferArray = buffer.array();

            // When
            int bytesConsumed = fileFsFullSizeInfo.decode(bufferArray, 10, 32);

            // Then
            assertEquals(32, bytesConsumed);
            assertEquals(2048L * 4 * 4096, fileFsFullSizeInfo.getCapacity());
            assertEquals(1024L * 4 * 4096, fileFsFullSizeInfo.getFree());
        }

    @Test
    public void testReturnFromReadParameterWordsWireFormatIs8() {
        // ensure the method returns 8 as claimed
        byte[] buf = new byte[12];
        buf[0] = 0x00;
        buf[1] = 0x10; // count = 4096 in little-endian (0x1000)
        int returned = resp.readParameterWordsWireFormat(buf, 0);
        assertEquals(8, returned, "Method should return 8 bytes processed");
    }

        this.maxReferralLevel = maxReferralLevel;
        this.request = new DfsReferralRequestBuffer(filename, maxReferralLevel);
        this.totalDataCount = 0;
        this.maxParameterCount = 0;
        this.maxDataCount = 4096;
        this.maxSetupCount = (byte) 0x00;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.internal.smb1.ServerMessageBlock#isForceUnicode()
     */
    @Override

        // Prepare buffer with invalid ACE count (> 4096)
        prepareSecurityDescriptorBufferWithInvalidAceCount(testBuffer, 0);

        assertThrows(SMBProtocolDecodingException.class, () -> securityDescriptor.decode(testBuffer, 0, testBuffer.length),
                "Should throw exception for ACE count > 4096");
    }

    @Test
    @DisplayName("Test getType returns correct value")

import okio.Buffer

/**
 * Tests Hpack implementation using https://github.com/http2jp/hpack-test-case/
 */
open class HpackDecodeTestBase {
  private val bytesIn = Buffer()
  private val hpackReader = Hpack.Reader(bytesIn, 4096)

  protected fun testDecoder(story: Story) {
    for (testCase in story.cases) {
      val encoded = testCase.wire ?: continue
      bytesIn.write(encoded)
      hpackReader.readHeaders()
      assertSetEquals(

user  nginx;
worker_processes  auto;

error_log  /var/log/nginx/error.log warn;
pid        /var/run/nginx.pid;

events {
    worker_connections  4096;
}

http {
    include       /etc/nginx/mime.types;
    default_type  application/octet-stream;

    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                      '$status $body_bytes_sent "$http_referer" '

        void testConstructorWithValidParameters() {
            // Given
            long sourceOffset = 1024L;
            long targetOffset = 2048L;
            int length = 4096;

            // When
            SrvCopychunk chunk = new SrvCopychunk(sourceOffset, targetOffset, length);

            // Then
            assertNotNull(chunk);
        }

        @ParameterizedTest

 */
public abstract class InputStreamUtil {

    /**
     * Do not instantiate.
     */
    protected InputStreamUtil() {
    }

    /** Default buffer size. */
    private static final int BUF_SIZE = 4096;

    /**
     * Creates a {@link FileInputStream}.
     *
     * @param file the file (must not be {@literal null})
     * @return a {@link FileInputStream} to read from the file

        // Arrange common constructor collaborators to avoid touching network/state
        when(handle.getPipe()).thenReturn(pipe);
        when(tree.isSMB2()).thenReturn(true);
        when(tree.getSendBufferSize()).thenReturn(4096);
        // Act
        return new SmbPipeOutputStream(handle, tree);
    }

    @ParameterizedTest
    @ValueSource(booleans = { true, false })
    @DisplayName("isOpen delegates to handle.isOpen")

			ModelName:       "\"MinIO " + ReleaseTag + "\"",
		}
		si.ProtocolCapabilities.CapacityInfo = true

		// Default recommended block size with MinIO
		si.SystemRecommendations.KBBlockSize = 4096

		buf = encodeResponse(&si)
	case capacityXMLObject:
		objAPI := newObjectLayerFn()
		if objAPI == nil {
			return nil, errServerNotInitialized
		}

		q, _ := globalBucketQuotaSys.Get(ctx, bucket)