byte[] bytes = SID.toByteArray(st);

            // Act: construct from bytes and re-encode
            SID sid = new SID(bytes, 0);
            byte[] roundTrip = sid.toByteArray();

            // Assert
            assertArrayEquals(bytes, roundTrip);
            assertEquals("S-1-5-10-20", sid.toString());
        }

        @Test

		FileList: handler,
	}
}

type forwardForTransport struct {
	tr  http.RoundTripper
	fwd string
}

func (f forwardForTransport) RoundTrip(r *http.Request) (*http.Response, error) {
	r.Header.Set("X-Forwarded-For", f.fwd)
	return f.tr.RoundTrip(r)
}

func (f *sftpDriver) getMinIOClient() (*minio.Client, error) {
	mcreds := credentials.NewStaticV4(
		f.permissions.CriticalOptions["AccessKey"],

            assertTrue(result.length > 0, "Result should not be empty");

            // Verify round-trip conversion
            String roundTrip = new String(result, StandardCharsets.UTF_16LE);
            assertEquals(UNICODE_STRING, roundTrip, "Round-trip conversion should preserve Unicode");
        }

        @Test
        @DisplayName("getASCIIBytes should encode string as ASCII")

            assertTrue(ctx.isPreferredMech(mech1), "first supported is preferred");
            assertArrayEquals(new ASN1ObjectIdentifier[] { mech1, mech2 }, ctx.getSupportedMechs(), "supported mechs");

            // MIC roundtrip: calculate then verify
            byte[] data = new byte[] { 10, 20, 30 };
            byte[] mic = ctx.calculateMIC(data);
            assertNotNull(mic);
            ctx.verifyMIC(data, mic); // should not throw

            assertArrayEquals(new byte[] { (byte) 0xAA, (byte) 0xBB, (byte) 0xCC, (byte) 0xDD, (byte) 0xEE, (byte) 0xFF }, uuid.node);
        }

        @Test
        @DisplayName("Should handle encode-decode roundtrip correctly")
        void testUuidTEncodeDecodeRoundtrip() throws NdrException {
            // Given: An original UUID with specific values
            rpc.uuid_t originalUuid = new rpc.uuid_t();

}

// RoundTripper provides an interface for type roundtrip serialization.
type RoundTripper interface {
	msgp.Unmarshaler
	msgp.Marshaler
	msgp.Sizer

	comparable
}

// SingleHandler is a type safe handler for single roundtrip requests.
type SingleHandler[Req, Resp RoundTripper] struct {
	id            HandlerID
	sharedResp    bool

		}
		if actual != tc.expectedStatus {
			t.Fatalf("Test %d: got %v expected %v", i+1, actual, tc.expectedStatus)
		}
	}
}

// TestRestoreObjStatusRoundTrip restoreObjStatus roundtrip
func TestRestoreObjStatusRoundTrip(t *testing.T) {
	testCases := []restoreObjStatus{
		ongoingRestoreObj(),
		completedRestoreObj(time.Now().UTC()),
	}
	for i, tc := range testCases {

        assertEquals(TEST_LAST_WRITE_TIME, fileBasicInfo.getLastWriteTime());
        assertEquals(TEST_ATTRIBUTES, fileBasicInfo.getAttributes());
    }

    @Test
    @DisplayName("Test encode and decode roundtrip")
    void testEncodeDecodeRoundtrip() throws SMBProtocolDecodingException {
        // Create original instance
        FileBasicInfo original =

        assertEquals(TEST_LAST_WRITE_TIME, fileBasicInfo.getLastWriteTime());
        assertEquals(TEST_ATTRIBUTES, fileBasicInfo.getAttributes());
    }

    @Test
    @DisplayName("Test encode and decode roundtrip")
    void testEncodeDecodeRoundtrip() throws SMBProtocolDecodingException {
        // Given
        FileBasicInfo originalInfo =

        }
        for (int i = dstIndex + 8; i < destinationBuffer.length; i++) {
            assertEquals(0, destinationBuffer[i]);
        }
    }

    @Test
    @DisplayName("Test encode and decode roundtrip")
    void testEncodeDecodeRoundtrip() throws SMBProtocolDecodingException {
        // Setup first instance with test data
        long expectedIndexNumber = 0x1122334455667788L;
        byte[] originalBuffer = new byte[8];