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;
    }

    assertThrows(
        IllegalArgumentException.class, () -> Chars.fromByteArray(new byte[Chars.BYTES - 1]));
  }

  @GwtIncompatible // Chars.fromBytes
  public void testFromBytes() {
    assertThat(Chars.fromBytes((byte) 0x23, (byte) 0x45)).isEqualTo('\u2345');
    assertThat(Chars.fromBytes((byte) 0xFE, (byte) 0xDC)).isEqualTo('\uFEDC');
  }

  @GwtIncompatible // Chars.fromByteArray, Chars.toByteArray

    assertThrows(IllegalArgumentException.class, () -> Shorts.fromByteArray(new byte[] {0x01}));
  }

  @GwtIncompatible // Shorts.fromBytes
  public void testFromBytes() {
    assertThat(Shorts.fromBytes((byte) 0x23, (byte) 0x45)).isEqualTo((short) 0x2345);
    assertThat(Shorts.fromBytes((byte) 0xFE, (byte) 0xDC)).isEqualTo((short) 0xFEDC);
  }

  @GwtIncompatible // Shorts.fromByteArray, Shorts.toByteArray