final long now = System.currentTimeMillis();
        assertTrue(now + ">=" + current + " : " + (now - current), now >= current);
        assertTrue(now - 1000 + "<" + current + " : " + (current - now + 1000), now - 1000 < current);
    }

    @Test
    public void test_getLogFilePath() {

                "hostname", hostname, //
                "name", StringUtil.isNotBlank(targetName) ? targetName : hostname, //
                "status", STATUS_ACTIVE, //
                "createdTime", now, //
                "expiredTime", now + ttl));

        try (CurlResponse response = ComponentUtil.getCurlHelper() //
                .put("/" + getIndexName() + "/_doc/" + instanceId + "?refresh=true") //
                .body(body)

    ujson = None  # type: ignore


try:
    import orjson
except ImportError:  # pragma: nocover
    orjson = None  # type: ignore


@deprecated(
    "UJSONResponse is deprecated, FastAPI now serializes data directly to JSON "
    "bytes via Pydantic when a return type or response model is set, which is "
    "faster and doesn't need a custom response class. Read more in the FastAPI "

	// lock on all resources at once.
	now := UTCNow()
	for i, resource := range args.Resources {
		l.lockMap[resource] = []lockRequesterInfo{
			{
				Name:            resource,
				Writer:          true,
				Source:          args.Source,
				Owner:           args.Owner,
				UID:             args.UID,
				Timestamp:       now.UnixNano(),
				TimeLastRefresh: now.UnixNano(),

					if v, ok := selectColumns[field.DBName]; (ok && v) || !ok {
						now := stmt.DB.NowFunc()
						assignValue(field, now)

						if field.AutoUpdateTime == schema.UnixNanosecond {
							set = append(set, clause.Assignment{Column: clause.Column{Name: field.DBName}, Value: now.UnixNano()})
						} else if field.AutoUpdateTime == schema.UnixMillisecond {

const (
	foo          = "foo"
	foo2  string = "foo2"
	truth        = foo == "foo" || foo2 == "foo2"
)

func ellipsis(...string) {}

func Now() Time {
	var now Time
	return now
}

var x = &S{
	Public:     nil,
	private:    nil,
	PublicTime: Now(),
}

var parenExpr = (1 + 5)

var funcLit = func() {}

var m map[string]int

var chanVar chan int

var ifaceVar any = 5

     * @param path
     * @param now
     * @return
     */
    private DfsReferralDataInternal getStandaloneCached(final String domain, final String root, final String path, final long now) {
        if (log.isTraceEnabled()) {
            log.trace("No match for domain based root, checking standalone " + domain);
        }
        /*
         * We did not match a domain based root. Now try to match the

			case rebalErr := <-doneCh:
				quit = true
				notify = true
				now := time.Now()
				var status rebalStatus

				switch {
				case errors.Is(rebalErr, context.Canceled):
					status = rebalStopped
					traceMsg = fmt.Sprintf("stopped at %s", now)
				case rebalErr == nil:
					status = rebalCompleted
					traceMsg = fmt.Sprintf("completed at %s", now)
				default:
					status = rebalFailed

						<option value="[now-1d/d TO *]"
							<c:if test="${as.timestamp.contains('[now-1d/d TO *]')}">selected</c:if>
						><la:message key="labels.advance_search_timestamp_pastday" /></option>
						<option value="[now-1w/d TO *]"
							<c:if test="${as.timestamp.contains('[now-1w/d TO *]')}">selected</c:if>

	"math/rand"
	"sync"
	"time"
)

func (er erasureObjects) getOnlineDisks() (newDisks []StorageAPI) {
	disks := er.getDisks()
	var wg sync.WaitGroup
	var mu sync.Mutex
	r := rand.New(rand.NewSource(time.Now().UnixNano()))
	for _, i := range r.Perm(len(disks)) {
		wg.Add(1)
		go func() {
			defer wg.Done()
			if disks[i] == nil {
				return
			}
			di, err := disks[i].DiskInfo(context.Background(), DiskInfoOptions{})