#include <iostream>

namespace base {

class Clock {
 public:
  virtual int Now() = 0;
  virtual ~Clock() {}
};

class DefaultClock : public Clock {
 public:
  DefaultClock() {
    std::cout << "Constructed DefaultClock" << std::endl;
  }

  virtual ~DefaultClock() {
    std::cout << "Destroyed DefaultClock" << std::endl;
  }

  int Now() override {
    static int now = 42;
    return now++;
  };
};

class MockClock : public Clock {
 public:
  MockClock(int fixed) : fixed_(fixed), now_(fixed) {
    std::cout << "Constructed MockClock" << fixed_ << std::endl;
  }

  virtual ~MockClock() {
    std::cout << "Destroyed MockClock" << fixed_ << std::endl;
  }

  int Now() override { return now_; }

  void SetNow(int now) { now_ = now; }
 private:
  int fixed_;
  int now_;
};

}

// Example class allowing to inject custom Clock.
class Example {
 public:
  static void PrintNow() {
    std::cout << GetClock().Now() << std::endl;
  }

  static void SetClockForTesting(base::Clock* clock) {
    *GetClockPtr() = clock;
  }

 private:
  static base::Clock** GetClockPtr() {
    static base::Clock* clock = new base::DefaultClock();
    return &clock;
  }

  static base::Clock& GetClock() {
      return **GetClockPtr();
  }
};

// Test code.
void test() {
  base::MockClock* raw_mock = new base::MockClock(11);
  Example::SetClockForTesting(raw_mock);
  Example::PrintNow();
  raw_mock->SetNow(22);
}


int main() {
  std::cout << "Start: nothing should be constructed before" << std::endl;
  std::cout << "===========================================" << std::endl;
  Example::PrintNow();
  Example::PrintNow();
  test();
  Example::PrintNow();
  Example::SetClockForTesting(new base::MockClock(33));
  Example::PrintNow();
  std::cout << "======================================" << std::endl;
  std::cout << "End: nothing should be destroyed after" << std::endl;
}