t.Fatalf("part.1 not healed correctly")
	}

	// Test 2, Corrupt part.1
	err = firstDisk.WriteAll(t.Context(), bucket, pathJoin(object, fi.DataDir, "part.1"), []byte("foobytes"))
	if err != nil {
		t.Fatalf("Failed to write a file - %v", err)
	}

	_, err = objLayer.HealObject(ctx, bucket, object, "", madmin.HealOpts{ScanMode: madmin.HealNormalScan})
	if err != nil {

    private static final byte[] SIGNCONTEXT_300 = toCBytes("SmbSign");
    private static final byte[] SIGNLABEL_300 = toCBytes("SMB2AESCMAC");
    private static final byte[] SIGNLABEL_311 = toCBytes("SMBSigningKey");

    private static final byte[] APPCONTEXT_300 = toCBytes("SmbRpc");
    private static final byte[] APPLABEL_300 = toCBytes("SMB2APP");
    private static final byte[] APPLABEL_311 = toCBytes("SMBAppKey");

        } else {
            final byte[] fnBytes = this.fileName.getBytes(StandardCharsets.UTF_16LE);
            SMBUtil.writeInt2(dstIndex - getHeaderStart(), dst, fnOffsetOffset);
            SMBUtil.writeInt2(fnBytes.length, dst, fnLengthOffset);
            System.arraycopy(fnBytes, 0, dst, dstIndex, fnBytes.length);
            dstIndex += fnBytes.length;
        }
        return dstIndex - start;
    }

        assertNotEquals(guid1, guid2);
        assertEquals(16, guid1.toBytes().length);
        assertEquals(16, guid2.toBytes().length);
    }

    @Test
    public void testHandleGuidRoundTrip() {
        HandleGuid original = new HandleGuid();
        byte[] bytes = original.toBytes();
        HandleGuid reconstructed = new HandleGuid(bytes);

        assertEquals(original, reconstructed);

				}
				drive := pool.Endpoints[i*setDriveCount+j]
				fmtBytes, err := json.Marshal(newFormat)
				if err != nil {
					//nolint:gocritic
					log.Fatalf("failed to marshal format.json for %s: %v", drive.String(), err)
				}
				fmtJSON := filepath.Join(drive.Host, drive.Path, minioMetaBucket, "format.json")
				embedFileInZip(fmtZipW, fmtJSON, fmtBytes, 0o600)
			}
		}
	}

        HandleGuid guid2 = new HandleGuid();
        
        assertNotEquals(guid1, guid2);
        assertEquals(16, guid1.toBytes().length);
        
        // Test round-trip
        HandleGuid guid3 = new HandleGuid(guid1.toBytes());
        assertEquals(guid1, guid3);
    }
    
    @Test
    public void testHandleInfoExpiration() {
        HandleInfo info = new HandleInfo(

    void toString_containsExpected() {
        when(cfg.isTraceResourceUsage()).thenReturn(false);
        stubValidTree(1L, true, true);

        byte[] fidBytes = new byte[] { 0x01, 0x02 };
        SmbFileHandleImpl h1 = new SmbFileHandleImpl(cfg, fidBytes, tree, "//u/one", 0x10, 0x20, 0x30, 0x40, 0L);
        String s1 = h1.toString();
        assertTrue(s1.contains("//u/one"));

        dstIndex += 4;

        SMBUtil.writeInt8(0, dst, dstIndex); // Reserved (8 bytes)
        dstIndex += 8;

        System.arraycopy(createGuid.toBytes(), 0, dst, dstIndex, 16); // CreateGuid (16 bytes)
        dstIndex += 16;

        return dstIndex - start;
    }

   * immutability contract of {@code HashCode}. The array cannot be empty.
   *
   * @since 15.0 (since 12.0 in HashCodes)
   */
  public static HashCode fromBytes(byte[] bytes) {
    checkArgument(bytes.length >= 1, "A HashCode must contain at least 1 byte.");
    return fromBytesNoCopy(bytes.clone());
  }

  /**

    }

    /**
     * Convert the GUID to byte array for wire format (little-endian as per MS-SMB2)
     * @return 16-byte array representing the GUID in SMB wire format
     */
    public byte[] toBytes() {
        byte[] result = new byte[16];
        ByteBuffer bb = ByteBuffer.wrap(result).order(java.nio.ByteOrder.LITTLE_ENDIAN);

        long mostSig = guid.getMostSignificantBits();