import (
	"bytes"
	"testing"

	"github.com/tinylib/msgp/msgp"
)

func TestMarshalUnmarshalhealingTracker(t *testing.T) {
	v := healingTracker{}
	bts, err := v.MarshalMsg(nil)
	if err != nil {
		t.Fatal(err)
	}
	left, err := v.UnmarshalMsg(bts)
	if err != nil {
		t.Fatal(err)
	}
	if len(left) > 0 {
		t.Errorf("%d bytes left over after UnmarshalMsg(): %q", len(left), left)
	}

			}

			_, err = obj.PutObject(ctx, bucket, object,
				mustGetPutObjReader(t, bytes.NewReader(data), int64(len(data)), "", ""), opts)
			if err != nil {
				t.Fatal(err)
			}

			actualH := sha256.New()
			_, err = io.Copy(actualH, bytes.NewReader(data))
			if err != nil {
				return
			}
			actualSha256 := actualH.Sum(nil)

					}
				}
			}

			decodedData := new(bytes.Buffer)
			if _, err = writeDataBlocks(t.Context(), decodedData, decoded, test.dataBlocks, 0, int64(len(data))); err != nil {
				t.Errorf("Test %d: failed to write data blocks: %v", i, err)
			}
			if !bytes.Equal(decodedData.Bytes(), data) {
				t.Errorf("Test %d: Decoded data does not match original data: got: %v want: %v", i, decodedData.Bytes(), data)
			}
		}
	}
}

        byte[] dst = new byte[6];

        // When
        int bytesWritten = smbComClose.writeParameterWordsWireFormat(dst, 0);

        // Then
        assertEquals(6, bytesWritten);
        assertEquals(fid, SMBUtil.readInt2(dst, 0));
        // With a digest, the lastWriteTime should be written.
        // We can't verify the exact bytes without a real implementation of writeUTime,

        this.timeout100Ns = SMBUtil.readInt4(buffer, bufferIndex) & 0xFFFFFFFFL; // Timeout (4 bytes, 100-ns intervals, unsigned)
        this.flags = SMBUtil.readInt4(buffer, bufferIndex + 4); // Flags (4 bytes)
        return 8;
    }

    /**
     * Get the timeout value in 100-nanosecond intervals (raw wire format)
     * @return the timeout in 100-nanosecond intervals
     */
    public long getTimeout100Ns() {

        void testWriteBytesWireFormatNoModification() {
            byte[] buffer = new byte[1024];
            byte[] originalBuffer = buffer.clone();

            echoResponse.writeBytesWireFormat(buffer, 0);

            assertArrayEquals(originalBuffer, buffer);
        }
    }

    @Nested
    @DisplayName("Read Bytes Wire Format Tests")
    class ReadBytesWireFormatTests {

        @Test

    @Test
    @DisplayName("Test FileBasicInfo decode method")
    void testFileBasicInfoDecode() throws SMBProtocolDecodingException {
        // Given
        byte[] buffer = new byte[64];
        int bufferIndex = 8;

        // Prepare test data in buffer (40 bytes of data)
        // Use SMBUtil to properly encode times in Windows FILETIME format
        SMBUtil.writeTime(TEST_CREATE_TIME, buffer, bufferIndex);

func init() {
	interval := fmt.Sprintf("%ds", int(resourceMetricsCollectionInterval.Seconds()))
	resourceMetricsHelpMap = map[MetricName]string{
		interfaceRxBytes:  "Bytes received on the interface in " + interval,
		interfaceRxErrors: "Receive errors in " + interval,
		interfaceTxBytes:  "Bytes transmitted in " + interval,
		interfaceTxErrors: "Transmit errors in " + interval,
		total:             "Total memory on the node",

	if err != nil {
		return 0, err
	}
	b.h.Write(buf)
	if !bytes.Equal(b.h.Sum(nil), b.hashBytes) {
		return 0, errFileCorrupt
	}
	b.currOffset += int64(len(buf))
	return len(buf), nil
}

// Returns streaming bitrot reader implementation.
func newStreamingBitrotReader(disk StorageAPI, data []byte, volume, filePath string, tillOffset int64, algo BitrotAlgorithm, shardSize int64) *streamingBitrotReader {

	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z dataUsageHash) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	o = msgp.AppendString(o, string(z))
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *dataUsageHash) UnmarshalMsg(bts []byte) (o []byte, err error) {
	{
		var zb0001 string
		zb0001, bts, err = msgp.ReadStringBytes(bts)