changeNotifier.stopWatching(path);
        }

        // Clear caches
        directoryCache.clear();
        leaseToPath.clear();
    }

    /**
     * Clean up expired cache entries
     */
    private void cleanupExpiredEntries() {
        List<String> expiredPaths = new ArrayList<>();

        for (Map.Entry<String, DirectoryCacheEntry> entry : directoryCache.entrySet()) {

        resetHandlerState();
        handler = new Handler(mockCifsContext);
    }

    @AfterEach
    void tearDown() throws Exception {
        // Restore system properties and clean up static state
        System.setProperties(originalSystemProperties);
        resetHandlerState();
    }

    /**
     * Resets the static state of the Handler class using reflection.

                                    + "(start: %d ns, middle: %d ns, end: %d ns)",
                            timingRatio, TIMING_TOLERANCE, timeStart, timeMiddle, timeEnd));
        } finally {
            // Clean up resources
            baseAuth.close();
            startAuth.close();
            middleAuth.close();
            endAuth.close();
        }
    }

    /**

		}

		if err := tx.Find(reflectResults.Addr().Interface()).Error; err != nil {
			return err
		}
	}

	fieldValues := make([]interface{}, len(relForeignFields))

	// clean up old values before preloading
	switch reflectValue.Kind() {
	case reflect.Struct:
		switch rel.Type {
		case schema.HasMany, schema.Many2Many:

        long currentCount = counter.incrementAndGet();

        // Clean up old windows periodically
        if (currentCount == 1) {
            cleanupOldRateLimitCounters(currentWindow);
        }

        return currentCount <= maxEventsPerWindow;
    }

    private void cleanupOldRateLimitCounters(long currentWindow) {
        // Clean up counters from previous windows to prevent memory leaks

    socketFactory[proxyServer2] = server2.socketAddress

    println("\n\nRequest to ${server2.socketAddress}")
    executeSynchronously(request)
      .apply {
        // We may have a single failed request if not clean shutdown
        if (cleanClose) {
          assertSuccessful()
          assertCode(200)

          assertThat(server2.requestCount).isEqualTo(1)
        } else {

// Cleans up tmp directory of the local disk.
func bgFormatErasureCleanupTmp(diskPath string) {
	// Need to move temporary objects left behind from previous run of minio
	// server to a unique directory under `minioMetaTmpBucket-old` to clean
	// up `minioMetaTmpBucket` for the current run.
	//
	// /disk1/.minio.sys/tmp-old/
	//  |__ 33a58b40-aecc-4c9f-a22f-ff17bfa33b62
	//  |__ e870a2c1-d09c-450c-a69c-6eaa54a89b3e
	//

        }
    }

    /**
     * Cleans up the crawled data for a given session.
     * Deletes URL queue data and access result data, and clears the URL filter.
     * @param sessionId The session ID to clean up.
     */
    public void cleanup(final String sessionId) {
        // TODO transaction?
        urlQueueService.delete(sessionId);
        dataService.delete(sessionId);
        urlFilter.clear();
    }

       "  Write-Error 'Error: Failed to validate Maven wrapper SHA-256, your Maven wrapper might be compromised.';"^
       "  Write-Error 'Investigate or delete %WRAPPER_JAR% to attempt a clean download.';"^
       "  Write-Error 'If you updated your Maven version, you need to update the specified wrapperSha256Sum property.';"^
       "  exit 1;"^
       "}"^
       "}"
    if ERRORLEVEL 1 goto error
)

        // Create SuggestJob after all components are registered
        suggestJob = new SuggestJob();
    }

    @Override
    public void tearDown() throws Exception {
        // Clean up temp directory
        if (tempDir != null && tempDir.exists()) {
            deleteDirectory(tempDir);
        }
        super.tearDown();
    }

    private void createRequiredDirectories() {