<PackageReference Include="Microsoft.Extensions.TimeProvider.Testing" Version="9.*" />

public class TokenService
{
    private readonly TimeProvider _time;
    public TokenService(TimeProvider time) => _time = time;
    public bool IsExpired(DateTimeOffset expiresAt) => _time.GetUtcNow() > expiresAt;
}

services.AddSingleton(TimeProvider.System);   // production DI

var fakeTime = new FakeTimeProvider(
    new DateTimeOffset(2026, 5, 20, 12, 0, 0, TimeSpan.Zero));   // frozen start
var svc = new TokenService(fakeTime);
var expiresAt = fakeTime.GetUtcNow().AddHours(1);

fakeTime.Advance(TimeSpan.FromHours(2));      // move forward
Assert.True(svc.IsExpired(expiresAt));

fakeTime.AutoAdvanceAmount = TimeSpan.FromMilliseconds(100);
var t1 = fakeTime.GetUtcNow();
var t2 = fakeTime.GetUtcNow();
Assert.Equal(TimeSpan.FromMilliseconds(100), t2 - t1);

var delayTask = fakeTime.Delay(TimeSpan.FromSeconds(30));
var fired = false;
_ = delayTask.ContinueWith(_ => fired = true);

fakeTime.Advance(TimeSpan.FromSeconds(10));
await Task.Yield();                    // let continuations run
Assert.False(fired);

fakeTime.Advance(TimeSpan.FromSeconds(20));
await delayTask;
Assert.True(fired);

fakeTime.SetUtcNow(new DateTimeOffset(2026, 3, 8, 7, 0, 0, TimeSpan.Zero));
fakeTime.SetLocalTimeZone(TimeZoneInfo.FindSystemTimeZoneById("America/New_York"));
DateTimeOffset local = fakeTime.GetLocalNow();   // UTC-5 or UTC-4 depending on DST

beforeAll(() => {
  jest.useFakeTimers();
  jest.setSystemTime(new Date('2026-05-20T14:30:00Z'));
});
afterAll(() => jest.useRealTimers());

test('debounce fires after 300ms', () => {
  let fired = false;
  setTimeout(() => { fired = true; }, 300);

  jest.advanceTimersByTime(299);
  expect(fired).toBe(false);
  jest.advanceTimersByTime(1);
  expect(fired).toBe(true);
});

await jest.advanceTimersByTimeAsync(100);

import FakeTimers from '@sinonjs/fake-timers';   // npm i -D @sinonjs/fake-timers

const clock = FakeTimers.install({ now: new Date('2026-05-20T14:30:00Z').getTime() });

clock.tick(1000);                                // sync advance
await clock.tickAsync(300);                      // advance + drain microtasks
clock.setSystemTime(new Date('2027-01-01T00:00:00Z'));  // jump, no timers fire

clock.uninstall();                               // ALWAYS in afterEach

// Jest
jest.useFakeTimers({ doNotFake: ['nextTick', 'queueMicrotask'],
                     now: new Date('2026-05-20T14:30:00Z').getTime() });
// Sinon
const clock = FakeTimers.install({ toFake: ['setTimeout', 'setInterval', 'Date'] });

process.env.TZ = 'America/New_York';
jest.useFakeTimers();
jest.setSystemTime(new Date('2026-03-08T06:30:00Z'));  // 02:30 local - non-existent
expect(new Date().toString()).toMatch(/03:30/);        // Node normalises

test('debounce + fetch', async () => {
  global.fetch = jest.fn().mockResolvedValue({ json: () => ({ ok: true }) });
  myDebouncedFetch();
  await jest.advanceTimersByTimeAsync(300);
  expect(fetch).toHaveBeenCalled();
});

public class TaskScheduler {
    private final Clock clock;
    public TaskScheduler(Clock clock) { this.clock = clock; }
    public Task scheduleNext(Duration after) {
        return new Task(Instant.now(clock).plus(after));
    }
}
// production wiring
TaskScheduler prod = new TaskScheduler(Clock.systemDefaultZone());

@Test
void scheduleNext() {
    Clock fixed = Clock.fixed(Instant.parse("2026-05-20T14:30:00Z"),
                              ZoneId.of("America/New_York"));
    Task task = new TaskScheduler(fixed).scheduleNext(Duration.ofMinutes(5));
    assertEquals(Instant.parse("2026-05-20T14:35:00Z"), task.getScheduledAt());
}

Clock realPlus10 = Clock.offset(Clock.systemDefaultZone(), Duration.ofMinutes(10));

public class MutableClock extends Clock {
    private Instant instant;
    private final ZoneId zone;
    public MutableClock(Instant instant, ZoneId zone) { this.instant = instant; this.zone = zone; }
    public void setInstant(Instant i) { this.instant = i; }
    public void advance(Duration d) { instant = instant.plus(d); }
    @Override public Clock withZone(ZoneId z) { return new MutableClock(instant, z); }
    @Override public ZoneId getZone() { return zone; }
    @Override public Instant instant() { return instant; }
}

InstantSource fake = () -> Instant.parse("2026-05-20T14:30:00Z");

@Configuration
public class ClockConfig {
    @Bean public Clock clock() { return Clock.systemDefaultZone(); }
}

@TestConfiguration
public class TestClockConfig {
    @Bean public Clock clock() {
        return Clock.fixed(Instant.parse("2026-05-20T14:30:00Z"), ZoneOffset.UTC);
    }
}

Clock fixed = Clock.fixed(Instant.parse("2026-03-08T07:30:00Z"),  // 02:30 local - non-existent
                          ZoneId.of("America/New_York"));
ZonedDateTime zdt = ZonedDateTime.ofInstant(fixed.instant(), fixed.getZone());
// assert per the resolver rules documented in dst-transition-reference

sudo apt install faketime        # Debian/Ubuntu
brew install libfaketime         # macOS
# or from source: git clone https://github.com/wolfcw/libfaketime && make && sudo make install

faketime '2026-12-31 23:59:00' your_command
# equivalent raw form:
LD_PRELOAD=/usr/local/lib/faketime/libfaketime.so.1 \
  FAKETIME='2026-12-31 23:59:00' your_command

faketime '-1d' your_command                       # 1 day in the past
faketime '+2h30m' your_command                    # 2h30m ahead
faketime -f '@2026-12-31 23:59:00 x10' your_cmd   # start there, run at 10x speed

FAKETIME_NO_CACHE=1 faketime '2026-12-31 23:59:00' your_command

import subprocess

def test_cron_fires_at_midnight():
    result = subprocess.run(
        ["faketime", "2026-12-31 23:59:30", "./cron-runner"],
        capture_output=True, text=True, timeout=5,
    )
    assert "Fired at 2027-01-01 00:00:00" in result.stdout

TZ='America/New_York' faketime '2026-03-08 02:30:00' ./my-program

jobs:
  time-tests:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v5
      - run: sudo apt-get install -y faketime
      - run: pytest tests/time/

pip install freezegun

from freezegun import freeze_time
from datetime import datetime

@freeze_time("2026-05-20T14:30:00")
def test_today_is_may_20():
    assert datetime.now().strftime("%Y-%m-%d") == "2026-05-20"

with freeze_time("2026-05-20T14:30:00"):
    assert datetime.now().strftime("%Y-%m-%d") == "2026-05-20"

freezer = freeze_time("2026-05-20T14:30:00")
freezer.start()
try:
    ...
finally:
    freezer.stop()

@freeze_time("2026-05-20T14:30:00", tick=True)   # real time passes from the frozen start
def test_clock_advances():
    t1 = datetime.now()
    t2 = datetime.now()
    assert t2 > t1

@freeze_time("2026-05-20T14:30:00")
def test_advance_one_day(freezer):
    freezer.move_to("2026-05-21T14:30:00")       # or freezer.tick(delta=timedelta(hours=24))
    assert datetime.now().day == 21

@freeze_time("2026-05-20T14:30:00", tz_offset=-5)
def test_eastern_time():
    assert datetime.utcnow().hour == 19   # 14:30 + 5
    assert datetime.now().hour == 14      # wall clock

from zoneinfo import ZoneInfo

@freeze_time("2026-03-08T07:30:00")   # 02:30 EST or 03:30 EDT depending on resolution
def test_spring_forward_handling():
    ny = datetime.now(ZoneInfo("America/New_York"))
    # assert against the documented library behaviour per dst-transition-reference

@freeze_time("2026-05-20T14:30:00")
async def test_async_now():
    await asyncio.sleep(0)
    assert datetime.now().strftime("%Y") == "2026"

jobs:
  python-tests:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v5
      - uses: actions/setup-python@v5
      - run: pip install -e ".[test]" freezegun
      - run: pytest tests/

# Gemfile
group :test do
  gem 'timecop'
end

Timecop.freeze(Time.local(2026, 5, 20, 14, 30)) do
  expect(Time.now.strftime('%Y-%m-%d')).to eq('2026-05-20')
end  # auto-restored after the block

Timecop.travel(Time.local(2026, 12, 31, 23, 59, 0)) do
  sleep 5  # real sleep; travel keeps the clock ticking from the offset
  expect(Time.now).to be_within(6.seconds).of(Time.local(2026, 12, 31, 23, 59, 5))
end

Timecop.freeze(Time.local(2026, 5, 20, 14, 30))
# ... test code
Timecop.return    # restore; wrap in ensure when not using the block form

RSpec.configure do |config|
  config.after(:each) { Timecop.return }
end

Timecop.scale(3600) do            # 1 real second = 1 simulated hour
  start = Time.now
  sleep 1
  expect(Time.now - start).to be_within(60).of(3600)
end

require 'active_support/time'

Time.zone = 'America/New_York'
Timecop.freeze(Time.zone.local(2026, 3, 8, 2, 30, 0)) do
  # 02:30 local doesn't exist on this spring-forward date;
  # assert the documented behaviour per dst-transition-reference
end

RSpec.describe BookingController do
  it 'rejects past dates' do
    Timecop.freeze(Date.new(2026, 5, 20)) do
      post :create, params: { date: '2026-05-19' }
      expect(response.status).to eq(400)
    end
  end
end