rhubarb-lip-sync/rhubarb/lib/webrtc-8d2248ff/webrtc/p2p/quic/quicconnectionhelper_unitte...

126 lines
3.5 KiB
C++
Raw Normal View History

2016-06-21 20:13:05 +00:00
/*
* Copyright 2016 The WebRTC Project Authors. All rights reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#include <memory>
#include "webrtc/p2p/quic/quicconnectionhelper.h"
#include "net/quic/quic_time.h"
#include "webrtc/base/gunit.h"
using cricket::QuicAlarm;
using cricket::QuicConnectionHelper;
using net::QuicClock;
using net::QuicTime;
using net::QuicWallTime;
// Clock that can be set to arbitrary times.
class MockClock : public QuicClock {
public:
MockClock() : now_(QuicTime::Zero()) {}
void AdvanceTime(QuicTime::Delta delta) { now_ = now_.Add(delta); }
QuicTime Now() const override { return now_; }
QuicTime ApproximateNow() const override { return now_; }
QuicWallTime WallNow() const override {
return QuicWallTime::FromUNIXSeconds(
now_.Subtract(QuicTime::Zero()).ToSeconds());
}
base::TimeTicks NowInTicks() const {
base::TimeTicks ticks;
return ticks + base::TimeDelta::FromMicroseconds(
now_.Subtract(QuicTime::Zero()).ToMicroseconds());
}
private:
QuicTime now_;
};
// Implements OnAlarm() event which alarm triggers.
class MockAlarmDelegate : public QuicAlarm::Delegate {
public:
MockAlarmDelegate() : fired_(false) {}
void OnAlarm() override { fired_ = true; }
bool fired() const { return fired_; }
void Clear() { fired_ = false; }
private:
bool fired_;
};
class QuicAlarmTest : public ::testing::Test {
public:
QuicAlarmTest()
: delegate_(new MockAlarmDelegate()),
alarm_(new QuicAlarm(
&clock_,
rtc::Thread::Current(),
net::QuicArenaScopedPtr<net::QuicAlarm::Delegate>(delegate_))) {}
// Make the alarm fire after the given microseconds (us). Negative values
// imply the alarm should fire immediately.
void SetTime(int us) {
QuicTime::Delta delta = QuicTime::Delta::FromMicroseconds(us);
alarm_->Set(clock_.Now().Add(delta));
}
// Make rtc::Thread::Current() process the next message.
void ProcessNextMessage() { rtc::Thread::Current()->ProcessMessages(0); }
protected:
// Handles event that alarm fires.
MockAlarmDelegate* delegate_;
// Used for setting clock time relative to alarm.
MockClock clock_;
std::unique_ptr<QuicAlarm> alarm_;
};
// Test that the alarm is fired.
TEST_F(QuicAlarmTest, FireAlarm) {
SetTime(-1);
ProcessNextMessage();
ASSERT_TRUE(delegate_->fired());
ASSERT_EQ(QuicTime::Zero(), alarm_->deadline());
}
// Test cancellation of alarm when it is set to fire.
TEST_F(QuicAlarmTest, CancelAlarmAfterSet) {
// TODO(mikescarlett): Test will fail in the future if
// rtc::Thread::PostDelayed calls the delegate synchronously for times <= 0.
// Rewrite this when rtc::Thread is able to use a mock clock.
SetTime(-1);
alarm_->Cancel();
ProcessNextMessage();
ASSERT_FALSE(delegate_->fired());
}
// Test cancellation of alarm when it is not set to fire.
TEST_F(QuicAlarmTest, CancelAlarmBeforeSet) {
alarm_->Cancel();
ProcessNextMessage();
ASSERT_FALSE(delegate_->fired());
}
// Test that timing for posting task is accurate.
TEST_F(QuicAlarmTest, AlarmGetDelay) {
SetTime(1000000);
EXPECT_EQ(1000, alarm_->GetDelay());
clock_.AdvanceTime(QuicTime::Delta::FromMicroseconds(300000));
EXPECT_EQ(700, alarm_->GetDelay());
}