func (r *Reader) ActualSize() int64 { return r.actualSize }

// ETag returns the ETag computed by an underlying etag.Tagger.
// If the underlying io.Reader does not implement etag.Tagger
// it returns nil.
func (r *Reader) ETag() etag.ETag {
	if t, ok := r.src.(etag.Tagger); ok {
		return t.ETag()
	}
	return nil
}

// MD5Current returns the MD5 checksum of the content

import java.util.Map;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

import io.restassured.mapper.ObjectMapperType;
import io.restassured.specification.RequestSpecification;

public class ITBase {
    private static final Logger logger = LogManager.getLogger(ITBase.class);
    public static final String DEFAULT_FESS_URL = "http://localhost:8080";

import java.util.concurrent.TimeUnit;
import java.util.logging.Logger;
import org.jspecify.annotations.NullUnmarked;

/**
 * Utilities for performing thread interruption in tests
 *
 * @author Kevin Bourrillion
 * @author Chris Povirk
 */
@NullUnmarked
@GwtIncompatible
@J2ktIncompatible
final class InterruptionUtil {
  private static final Logger logger = Logger.getLogger(InterruptionUtil.class.getName());

import org.mockito.junit.jupiter.MockitoExtension;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * Base test class providing common test infrastructure and utilities.
 * All test classes should extend this to ensure consistent test setup.
 */
@ExtendWith(MockitoExtension.class)
public abstract class BaseTest {

    protected final Logger logger = LoggerFactory.getLogger(getClass());

    @BeforeEach

import com.google.cloud.storage.StorageOptions;

/**
 * Google Cloud Storage client implementation.
 */
public class GcsStorageClient implements StorageClient {

    private static final Logger logger = LogManager.getLogger(GcsStorageClient.class);

    private final Storage storage;
    private final String bucket;

    /**
     * Creates a new GcsStorageClient instance.
     *

    }

    /**
     * Prints thread dump information to the logger at INFO level.
     */
    public static void printThreadDump() {
        processThreadDump(logger::info);
    }

    /**
     * Prints thread dump information to the logger at WARN level.
     */
    public static void printThreadDumpAsWarn() {
        processThreadDump(logger::warn);
    }

    /**

                }
            }
        }

        return false;
    }

    @Override
    public void enableLogging(Logger logger) {
        this.logger = logger;
    }

 *   <li>Old document deletion after successful crawling</li>
 *   <li>Crawling execution monitoring and timing</li>
 * </ul>
 */
public class DataIndexHelper {

    /** Logger instance for this class */
    private static final Logger logger = LogManager.getLogger(DataIndexHelper.class);

    /** Parameter key for controlling deletion of old documents */
    private static final String DELETE_OLD_DOCS = "delete_old_docs";

            if (logger.isDebugEnabled()) {
                logger.debug("Updating scheduled jobs: time={}", schedulerTime);
            }
            final long now = systemHelper.getCurrentTimeAsLong();
            scheduledJobService.getScheduledJobListAfter(schedulerTime).forEach(scheduledJob -> {
                if (logger.isDebugEnabled()) {

        if (httpClient == null) {
            return;
        }
        if (logger.isDebugEnabled()) {
            logger.debug("Closing HTTP client...");
        }
        if (connectionMonitorTask != null) {
            connectionMonitorTask.cancel();
            if (logger.isDebugEnabled()) {
                logger.debug("Connection monitor task cancelled");
            }
        }