byte[] src = new byte[16];

        // Test with zero time
        SMBUtil.writeInt8(0L, src, 0);
        long time = SMBUtil.readTime(src, 0);
        assertEquals(-SmbConstants.MILLISECONDS_BETWEEN_1970_AND_1601, time);

        // Test with specific time value
        long testTime = 131768928000000000L; // Example Windows file time
        SMBUtil.writeInt8(testTime, src, 8);

        });

        try {
            future.get(timeoutSeconds, TimeUnit.SECONDS);
        } catch (TimeoutException e) {
            // Force lease release if break handling times out
            LeaseEntry entry = leases.get(key);
            if (entry != null) {
                log.warn("Lease break timeout for key: {} on path: {}, falling back to no caching", key, entry.getPath());

	var mtime time.Time
	if mtimeStr != "" {
		mtime, err = time.Parse(time.RFC3339Nano, mtimeStr)
		if err != nil {
			return opts, fmt.Errorf("Unable to parse %s, failed with %w", xhttp.MinIOSourceMTime, err)
		}
	}
	retaintimeStr := strings.TrimSpace(hdr.Get(xhttp.MinIOSourceObjectRetentionTimestamp))
	var retaintimestmp time.Time
	if retaintimeStr != "" {

# Generate an overview page describing the build
if [[ "$TFCI_INDEX_HTML_ENABLE" == 1 ]]; then
  ./ci/official/utilities/generate_index_html.sh "$TFCI_OUTPUT_DIR/index.html"
fi

# Re-try `bazel --version` multiple times to get around
# Bazel download issues.
set +e
MAX_RETRIES=2
for ((i=1; i <= $MAX_RETRIES; i++)); do
  tfrun bazel --version
done
set -e

}

// forwardTo moves time to t, clearing entries between last update and t.
func (l *lastDayTierStats) forwardTo(t time.Time) {
	if t.IsZero() {
		t = time.Now()
	}

	since := t.Sub(l.UpdatedAt).Hours()
	// within the hour since l.UpdatedAt
	if since < 1 {
		return
	}

	idx, lastIdx := t.Hour(), l.UpdatedAt.Hour()

	l.UpdatedAt = t // update to the latest time index

	if since >= 24 {
		l.Bins = [24]tierStats{}

	InsecureSkipVerify bool `json:"skip_verify"`
}

const (
	defaultExpiry time.Duration = 1 * time.Hour
	minExpiry     time.Duration = 15 * time.Minute
	maxExpiry     time.Duration = 365 * 24 * time.Hour
)

// GetExpiryDuration - return parsed expiry duration.
func (l Config) GetExpiryDuration(dsecs string) (time.Duration, error) {
	if dsecs == "" {
		return defaultExpiry, nil
	}

import time

from fastapi import FastAPI, Request

app = FastAPI()


@app.middleware("http")
async def add_process_time_header(request: Request, call_next):
    start_time = time.perf_counter()
    response = await call_next(request)
    process_time = time.perf_counter() - start_time
    response.headers["X-Process-Time"] = str(process_time)

        raf.writeFloat(1.0f);
        raf.writeDouble(1.0);

        // Verify length counts - using times() to check exact counts
        verify(raf, times(2)).write(any(byte[].class), anyInt(), eq(2)); // short and char
        verify(raf, times(2)).write(any(byte[].class), anyInt(), eq(4)); // int and float
        verify(raf, times(2)).write(any(byte[].class), anyInt(), eq(8)); // long and double
    }

    @Test

package tests_test

import (
	"context"
	"time"

	"gorm.io/gorm/logger"
)

type Tracer struct {
	Logger logger.Interface
	Test   func(ctx context.Context, begin time.Time, fc func() (sql string, rowsAffected int64), err error)
}

func (S Tracer) LogMode(level logger.LogLevel) logger.Interface {
	return S.Logger.LogMode(level)
}

func (S Tracer) Info(ctx context.Context, s string, i ...interface{}) {

         *
         * @param name file name
         * @param size file size
         * @param lastModified last modified time
         * @param isDirectory true if directory
         * @param attributes file attributes
         * @param creationTime creation time
         * @param lastAccessTime last access time
         */
        public FileInfo(String name, long size, long lastModified, boolean isDirectory, long attributes, long creationTime,