quic/core/quic_epoll_clock_test.cc

// Copyright 2022 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "quic/core/quic_epoll_clock.h"

#include "quic/platform/api/quic_test.h"
#include "common/platform/api/quiche_epoll_test_tools.h"

namespace quic {
namespace test {

class QuicEpollClockTest : public QuicTest {};

TEST_F(QuicEpollClockTest, ApproximateNowInUsec) {
  quiche::QuicheFakeEpollServer epoll_server;
  QuicEpollClock clock(&epoll_server);

  epoll_server.set_now_in_usec(1000000);
  EXPECT_EQ(1000000,
            (clock.ApproximateNow() - QuicTime::Zero()).ToMicroseconds());
  EXPECT_EQ(1u, clock.WallNow().ToUNIXSeconds());
  EXPECT_EQ(1000000u, clock.WallNow().ToUNIXMicroseconds());

  epoll_server.AdvanceBy(5);
  EXPECT_EQ(1000005,
            (clock.ApproximateNow() - QuicTime::Zero()).ToMicroseconds());
  EXPECT_EQ(1u, clock.WallNow().ToUNIXSeconds());
  EXPECT_EQ(1000005u, clock.WallNow().ToUNIXMicroseconds());

  epoll_server.AdvanceBy(10 * 1000000);
  EXPECT_EQ(11u, clock.WallNow().ToUNIXSeconds());
  EXPECT_EQ(11000005u, clock.WallNow().ToUNIXMicroseconds());
}

TEST_F(QuicEpollClockTest, NowInUsec) {
  quiche::QuicheFakeEpollServer epoll_server;
  QuicEpollClock clock(&epoll_server);

  epoll_server.set_now_in_usec(1000000);
  EXPECT_EQ(1000000, (clock.Now() - QuicTime::Zero()).ToMicroseconds());

  epoll_server.AdvanceBy(5);
  EXPECT_EQ(1000005, (clock.Now() - QuicTime::Zero()).ToMicroseconds());
}

TEST_F(QuicEpollClockTest, CalibrateRealEpollClock) {
  QuicEpollServer epoll_server;

  QuicEpollClock uncalibrated_clock(&epoll_server);
  QuicEpollClock calibrated_clock(&epoll_server);
  EXPECT_TRUE(calibrated_clock.ComputeCalibrationOffset().IsZero());

  for (int i = 0; i < 100; ++i) {
    QuicWallTime wallnow = uncalibrated_clock.WallNow();
    EXPECT_EQ(uncalibrated_clock.ConvertWallTimeToQuicTime(wallnow),
              calibrated_clock.ConvertWallTimeToQuicTime(wallnow));
  }
}

// ClockWithOffset is a clock whose offset(WallNow() - Now() at any instant) is
// given at construction time.
class ClockWithOffset : public QuicEpollClock {
 public:
  ClockWithOffset(QuicEpollServer* epoll_server, QuicTime::Delta offset)
      : QuicEpollClock(epoll_server), offset_(offset) {}

  QuicTime Now() const override { return QuicEpollClock::Now() - offset_; }

  // QuicEpollClock disables ConvertWallTimeToQuicTime since it always have a
  // zero offset. We need to re-enable it here in order to test the calibration
  // and conversion code in QuicClock.
  QuicTime ConvertWallTimeToQuicTime(
      const QuicWallTime& walltime) const override {
    return QuicClock::ConvertWallTimeToQuicTime(walltime);
  }

 private:
  QuicTime::Delta offset_;
};

TEST_F(QuicEpollClockTest, CalibrateClockWithOffset) {
  QuicEpollServer epoll_server;

  for (const QuicTime::Delta& offset : {QuicTime::Delta::FromSeconds(5000),
                                        QuicTime::Delta::FromSeconds(-8000)}) {
    ClockWithOffset clock(&epoll_server, offset);
    ASSERT_EQ(offset, clock.ComputeCalibrationOffset())
        << "offset (us): " << offset.ToMicroseconds();
    // Test fails without this.
    clock.SetCalibrationOffset(offset);

    QuicWallTime last_walltime = clock.WallNow();
    QuicTime last_time = clock.ConvertWallTimeToQuicTime(last_walltime);

    for (int i = 0; i < 1e5; ++i) {
      QuicWallTime wallnow = clock.WallNow();
      QuicTime now = clock.ConvertWallTimeToQuicTime(wallnow);

      if (wallnow.IsAfter(last_walltime)) {
        ASSERT_LT(0, (now - last_time).ToMicroseconds())
            << "offset (us): " << offset.ToMicroseconds();

        last_walltime = wallnow;
        last_time = now;
      }
    }
  }
}

TEST_F(QuicEpollClockTest, MonotonicityWithRealEpollClock) {
  QuicEpollServer epoll_server;
  QuicEpollClock clock(&epoll_server);

  QuicTime last_now = clock.Now();
  for (int i = 0; i < 1e5; ++i) {
    QuicTime now = clock.Now();

    ASSERT_LE(last_now, now);

    last_now = now;
  }
}

TEST_F(QuicEpollClockTest, MonotonicityWithFakeEpollClock) {
  quiche::QuicheFakeEpollServer epoll_server;
  QuicEpollClock clock(&epoll_server);

  epoll_server.set_now_in_usec(100);
  QuicTime last_now = clock.Now();

  epoll_server.set_now_in_usec(90);
  QuicTime now = clock.Now();

  ASSERT_EQ(last_now, now);
}

}  // namespace test
}  // namespace quic