void testWriteBytesWireFormatHappy() throws UnsupportedEncodingException {
        byte[] buffer = new byte[50];
        int used = cmd.writeBytesWireFormat(buffer, 0);
        // Calculate expected size: 1 byte for command + string bytes + 1 null terminator
        byte[] expectedString = "testfile.txt".getBytes("windows-1252");

        final long totalBytes = runtime.totalMemory();
        return totalBytes - freeBytes;
    }

    /**
     * Estimates the size of an object in bytes.
     *
     * @param obj the object to calculate size for
     * @return estimated size in bytes
     */
    public static long sizeOf(final Object obj) {
        if (obj == null) {
            return 0L;
        }
        if (obj instanceof String) {

     * @return the quantile value
     */
    public double computeInPlace(double... dataset) {
      checkArgument(dataset.length > 0, "Cannot calculate quantiles of an empty dataset");
      if (containsNaN(dataset)) {
        return NaN;
      }

      // Calculate the quotient and remainder in the integer division x = k * (N-1) / q, i.e.

	// Split data into 3 parts
	partSize := len(dummyData) / 3
	part1Data := dummyData[0:partSize]
	part2Data := dummyData[partSize : 2*partSize]
	part3Data := dummyData[2*partSize:]

	// Calculate CRC32C checksum for each part using NewChecksumFromData
	checksumType := ChecksumCRC32C

	part1Checksum := NewChecksumFromData(checksumType, part1Data)
	part2Checksum := NewChecksumFromData(checksumType, part2Data)

	maxPartsCount             = 10000
	maxPartSize               = 1024 * 1024 * 1024 * 5
	minPartSize               = 1024 * 1024 * 128 // chosen by us to be optimal for HDDs
)

// optimalPartInfo - calculate the optimal part info for a given
// object size.
//
// NOTE: Assumption here is that for any object to be uploaded to any S3 compatible
// object storage it will have the following parameters as constants.
//

        // Prepare test data
        String shareName = "SHARE1";
        int shareType = 0x00000000; // Disk share
        String remark = "Test share";

        // Calculate buffer size
        int shareNameSize = 14; // 13 bytes + null terminator (fixed field)
        int typeSize = 2;
        int offsetSize = 4;
        int remarkSize = remark.length() + 1;

    }

    /**
     * Clear all pending operations
     */
    public void clearPendingOperations() {
        pendingOperations.clear();
    }

    /**
     * Calculate channel score for load balancing (higher is better)
     *
     * @return channel score
     */
    public int getScore() {
        int score = 100;

        // Adjust based on state

        dstIndex += 4;

        // WriteChannelInfo (Offset/Length for SMB2_RDMA_TRANSFORM)
        if (rdmaChannelInfo != null && channel == Smb2Constants.SMB2_CHANNEL_RDMA_V1) {
            // Calculate offset for SMB2_RDMA_TRANSFORM after data
            int transformOffset = 112 + this.dataLength; // After header (64) + write req (48) + data
            SMBUtil.writeInt2(transformOffset, dst, dstIndex); // writeChannelInfoOffset

		os.Exit(1)
	}
	for _, input := range inputs {
		processFile(input, privateKeys)
	}
}

func processFile(inputFileName string, privateKeys [][]byte) {
	// Calculate the output file name
	var outputFileName string
	switch {
	case strings.HasSuffix(inputFileName, ".enc"):
		outputFileName = strings.TrimSuffix(inputFileName, ".enc") + ".zip"

		}
		if !bytes.Equal(h.Sum(nil), want) {
			return errFileCorrupt
		}
		return nil
	}

	h := algo.New()
	hashBuf := make([]byte, h.Size())
	left := wantSize

	// Calculate the size of the bitrot file and compare
	// it with the actual file size.
	if left != bitrotShardFileSize(partSize, shardSize, algo) {
		return errFileCorrupt
	}

	bufp := xioutil.ODirectPoolSmall.Get()