public static final String WEB_FS_CRAWLER_START_TIME = "WebFsCrawlStartTime";

    /** Info map key for web/file system crawler end time. */
    public static final String WEB_FS_CRAWLER_END_TIME = "WebFsCrawlEndTime";

    /** Info map key for data crawler start time. */
    public static final String DATA_CRAWLER_START_TIME = "DataCrawlStartTime";

    /** Info map key for data crawler end time. */

        this.state = state;
    }

    /**
     * Get the time when channel was established
     *
     * @return establishment time in milliseconds
     */
    public long getEstablishedTime() {
        return establishedTime;
    }

    /**
     * Get the last activity time
     *
     * @return last activity time in milliseconds
     */
    public long getLastActivityTime() {

            });
            jobLogBhv.batchUpdate(list);
        }
    }

    /**
     * Sets the time interval after which jobs are considered expired.
     *
     * @param expiredJobInterval the time interval in milliseconds
     */
    public void setExpiredJobInterval(final long expiredJobInterval) {
        this.expiredJobInterval = expiredJobInterval;
    }

     * Calculates the document expiration date based on crawling configuration.
     * If the config has a timeToLive value, calculates expiration from current time.
     * Otherwise, returns the stored document expiration time.
     *
     * @param config the crawling configuration containing time-to-live settings
     * @return the document expiration date, or null if no expiration is set
     */

package kms

import (
	"context"
	"net/http"
	"slices"
	"sync/atomic"
	"time"

	"github.com/minio/madmin-go/v3"
	"github.com/minio/pkg/v3/wildcard"
)

var (
	// StubCreatedAt is a constant timestamp for testing
	StubCreatedAt = time.Date(2024, time.January, 1, 15, 0, 0, 0, time.UTC)
	// StubCreatedBy is a constant created identity for testing
	StubCreatedBy = "MinIO"
)

import (
	"context"
	"net"
	"net/http"
	"net/http/httptest"
	"testing"
	"time"

	"github.com/minio/minio/internal/logger/target/testlogger"
)

func TestDisconnect(t *testing.T) {
	defer testlogger.T.SetLogTB(t)()
	defer timeout(10 * time.Second)()
	hosts, listeners, _ := getHosts(2)
	dialer := &net.Dialer{
		Timeout: 1 * time.Second,
	}
	errFatal := func(err error) {
		t.Helper()
		if err != nil {

        decoded.decode(buffer, 0, 36); // decode reads 36 bytes

        // Note: When encoding time 0, SMBUtil.writeTime writes 0 directly,
        // but SMBUtil.readTime interprets 0 as Jan 1, 1601 in Unix time (-11644473600000)
        // This is the expected behavior for Windows FILETIME
        long expectedTime = -11644473600000L; // Jan 1, 1601 in Unix time
        assertEquals(expectedTime, decoded.getCreateTime());

func Test_metaCacheEntries_resolve(t *testing.T) {
	baseTime, err := time.Parse("2006/01/02", "2015/02/25")
	if err != nil {
		t.Fatal(err)
	}
	inputs := []xlMetaV2{
		0: {
			versions: []xlMetaV2ShallowVersion{
				{header: xlMetaV2VersionHeader{
					VersionID: [16]byte{1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1},
					ModTime:   baseTime.Add(30 * time.Minute).UnixNano(),
					Signature: [4]byte{1, 1, 1, 1},

        }
    }

    /**
     * Encrypt using AES-GCM with constant-time operations
     */
    private EncryptionResult encryptWithGCM(byte[] message, byte[] nonce, byte[] associatedData) throws Exception {
        final Cipher cipher = createGCMCipher(true, nonce);
        cipher.updateAAD(associatedData);

        // Use constant-time encryption
        final byte[] encrypted = performConstantTimeEncryption(cipher, message);

		retryInterval, err := time.ParseDuration(retryIntervalCfgVal)
		if err != nil {
			return cfg, err
		}
		if retryInterval > time.Minute {
			return cfg, fmt.Errorf("maximum allowed value for retry interval is '1m': %s", retryIntervalCfgVal)
		}

		httpTimeoutCfgVal := getCfgVal(EnvLoggerWebhookHTTPTimeout, k, kv.Get(httpTimeout))
		httpTimeout, err := time.ParseDuration(httpTimeoutCfgVal)
		if err != nil {