}

    @Test
    @DisplayName("Test service cleanup")
    public void testServiceCleanup() throws CIFSException {
        String sessionId1 = "cleanup-test-1";
        String sessionId2 = "cleanup-test-2";
        byte[] salt = preauthService.generatePreauthSalt();

        preauthService.initializeSession(sessionId1, salt, PreauthIntegrityService.HASH_ALGO_SHA512);

    }

    private void addDom(Xpp3Dom parent, String childName, String childValue, InputLocation location) {
        if (StringUtils.isNotEmpty(childValue)) {
            parent.addChild(newDom(childName, childValue, location));
        }
    }

    private Xpp3Dom newDom(String name, String value, InputLocation location) {
        Xpp3Dom dom = new Xpp3Dom(name, location);
        dom.setValue(value);
        return dom;
    }

func filterReplicationStatusMetadata(metadata map[string]string) map[string]string {
	// Copy on write
	dst := metadata
	var copied bool
	delKey := func(key string) {
		if _, ok := metadata[key]; !ok {
			return
		}
		if !copied {
			dst = make(map[string]string, len(metadata))
			maps.Copy(dst, metadata)
			copied = true
		}
		delete(dst, key)

func healBucketLocal(ctx context.Context, bucket string, opts madmin.HealOpts) (res madmin.HealResultItem, err error) {
	globalLocalDrivesMu.RLock()
	localDrives := cloneDrives(globalLocalDrivesMap)
	globalLocalDrivesMu.RUnlock()

	// Initialize sync waitgroup.
	g := errgroup.WithNErrs(len(localDrives))

	// Disk states slices
	beforeState := make([]string, len(localDrives))
	afterState := make([]string, len(localDrives))

	}
	if r.contentHash.Type.Trailing() {
		return map[string]string{r.contentHash.Type.String(): r.trailer.Get(r.contentHash.Type.Key())}
	}
	return map[string]string{r.contentHash.Type.String(): r.contentHash.Encoded}
}

// Checksum returns the content checksum if set.
func (r *Reader) Checksum() *Checksum {
	if !r.contentHash.Type.IsSet() || !r.contentHash.Valid() {
		return nil
	}
	return &r.contentHash
}

        @DisplayName("Test getFileName method with mock")
        void testGetFileName() {
            // Setup mock behavior
            String expectedFileName = "test-file.txt";
            when(mockFileNotifyInfo.getFileName()).thenReturn(expectedFileName);

            // Test
            String fileName = mockFileNotifyInfo.getFileName();

            // Verify
            assertEquals(expectedFileName, fileName);

        void shouldDeterminePluginEnablementBasedOnOptions(
                Boolean all, Boolean plugins, String model, boolean expectedEnabled, String description) {
            UpgradeContext context =
                    createMockContext(tempDir, TestUtils.createOptions(all, null, null, plugins, model));

            boolean isEnabled = upgradeGoal.testIsPluginsEnabled(context);

func (secretKey) Status(context.Context) (map[string]madmin.ItemState, error) {
	return map[string]madmin.ItemState{
		"127.0.0.1": madmin.ItemOnline,
	}, nil
}

// ListKeys returns a list of keys with metadata. The builtin KMS consists of just a single key.
func (s secretKey) ListKeys(ctx context.Context, req *ListRequest) ([]madmin.KMSKeyInfo, string, error) {

		}
		if err != nil {
			t.Errorf("for length %d: got error = %v; want nil", l, err)
		}
		if b.String() != s {
			t.Errorf("got string %q; want %q", b.String(), s)
		}
		if r.Len() != 0 {
			t.Errorf("reader contains %v bytes; want 0", r.Len())
		}
	}
}

func TestReaderLen(t *testing.T) {
	const data = "hello world"
	r := NewReader([]byte(data))
	if got, want := r.Len(), 11; got != want {

        return problems;
    }

    public void setSource(String source) {
        this.source = source;
        this.sourceModel = null;
    }

    public void setSource(Model source) {
        this.sourceModel = source;
        this.source = null;

        if (rootModel == null) {
            rootModel = source;
        }
    }

    private String getSource() {
        if (source == null && sourceModel != null) {