net/tools/quic/quic_epoll_connection_helper_test.cc - Issue 992733002: Remove //net (except for Android test stuff) and sdch

Side by Side Diff: net/tools/quic/quic_epoll_connection_helper_test.cc

Issue 992733002: Remove //net (except for Android test stuff) and sdch (Closed) Base URL: git@github.com:domokit/mojo.git@master

Patch Set: Created 5 years, 9 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View unified diff | Download patch

OLD	NEW
	(Empty)
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.

2 // Use of this source code is governed by a BSD-style license that can be

3 // found in the LICENSE file.

4

5 #include "net/tools/quic/quic_epoll_connection_helper.h"

6

7 #include "net/quic/crypto/quic_random.h"

8 #include "net/tools/quic/test_tools/mock_epoll_server.h"

9 #include "testing/gtest/include/gtest/gtest.h"

10

11 using net::tools::test::MockEpollServer;

12

13 namespace net {

14 namespace tools {

15 namespace test {

16 namespace {

17

18 class TestDelegate : public QuicAlarm::Delegate {

19 public:

20 TestDelegate() : fired_(false) {}

21

22 QuicTime OnAlarm() override {

23 fired_ = true;

24 return QuicTime::Zero();

25 }

26

27 bool fired() const { return fired_; }

28

29 private:

30 bool fired_;

31 };

32

33 class QuicEpollConnectionHelperTest : public ::testing::Test {

34 protected:

35 QuicEpollConnectionHelperTest() : helper_(&epoll_server_) {}

36

37 MockEpollServer epoll_server_;

38 QuicEpollConnectionHelper helper_;

39 };

40

41 TEST_F(QuicEpollConnectionHelperTest, GetClock) {

42 const QuicClock* clock = helper_.GetClock();

43 QuicTime start = clock->Now();

44

45 QuicTime::Delta delta = QuicTime::Delta::FromMilliseconds(5);

46 epoll_server_.AdvanceBy(delta.ToMicroseconds());

47

48 EXPECT_EQ(start.Add(delta), clock->Now());

49 }

50

51 TEST_F(QuicEpollConnectionHelperTest, GetRandomGenerator) {

52 QuicRandom* random = helper_.GetRandomGenerator();

53 EXPECT_EQ(QuicRandom::GetInstance(), random);

54 }

55

56 TEST_F(QuicEpollConnectionHelperTest, CreateAlarm) {

57 TestDelegate* delegate = new TestDelegate();

58 scoped_ptr<QuicAlarm> alarm(helper_.CreateAlarm(delegate));

59

60 const QuicClock* clock = helper_.GetClock();

61 QuicTime start = clock->Now();

62 QuicTime::Delta delta = QuicTime::Delta::FromMicroseconds(1);

63 alarm->Set(start.Add(delta));

64

65 epoll_server_.AdvanceByAndCallCallbacks(delta.ToMicroseconds());

66 EXPECT_EQ(start.Add(delta), clock->Now());

67 }

68

69 TEST_F(QuicEpollConnectionHelperTest, CreateAlarmAndCancel) {

70 TestDelegate* delegate = new TestDelegate();

71 scoped_ptr<QuicAlarm> alarm(helper_.CreateAlarm(delegate));

72

73 const QuicClock* clock = helper_.GetClock();

74 QuicTime start = clock->Now();

75 QuicTime::Delta delta = QuicTime::Delta::FromMicroseconds(1);

76 alarm->Set(start.Add(delta));

77 alarm->Cancel();

78

79 epoll_server_.AdvanceByExactlyAndCallCallbacks(delta.ToMicroseconds());

80 EXPECT_EQ(start.Add(delta), clock->Now());

81 EXPECT_FALSE(delegate->fired());

82 }

83

84 TEST_F(QuicEpollConnectionHelperTest, CreateAlarmAndReset) {

85 TestDelegate* delegate = new TestDelegate();

86 scoped_ptr<QuicAlarm> alarm(helper_.CreateAlarm(delegate));

87

88 const QuicClock* clock = helper_.GetClock();

89 QuicTime start = clock->Now();

90 QuicTime::Delta delta = QuicTime::Delta::FromMicroseconds(1);

91 alarm->Set(clock->Now().Add(delta));

92 alarm->Cancel();

93 QuicTime::Delta new_delta = QuicTime::Delta::FromMicroseconds(3);

94 alarm->Set(clock->Now().Add(new_delta));

95

96 epoll_server_.AdvanceByExactlyAndCallCallbacks(delta.ToMicroseconds());

97 EXPECT_EQ(start.Add(delta), clock->Now());

98 EXPECT_FALSE(delegate->fired());

99

100 epoll_server_.AdvanceByExactlyAndCallCallbacks(

101 new_delta.Subtract(delta).ToMicroseconds());

102 EXPECT_EQ(start.Add(new_delta), clock->Now());

103 EXPECT_TRUE(delegate->fired());

104 }

105

106 TEST_F(QuicEpollConnectionHelperTest, CreateAlarmAndUpdate) {

107 TestDelegate* delegate = new TestDelegate();

108 scoped_ptr<QuicAlarm> alarm(helper_.CreateAlarm(delegate));

109

110 const QuicClock* clock = helper_.GetClock();

111 QuicTime start = clock->Now();

112 QuicTime::Delta delta = QuicTime::Delta::FromMicroseconds(1);

113 alarm->Set(clock->Now().Add(delta));

114 QuicTime::Delta new_delta = QuicTime::Delta::FromMicroseconds(3);

115 alarm->Update(clock->Now().Add(new_delta),

116 QuicTime::Delta::FromMicroseconds(1));

117

118 epoll_server_.AdvanceByExactlyAndCallCallbacks(delta.ToMicroseconds());

119 EXPECT_EQ(start.Add(delta), clock->Now());

120 EXPECT_FALSE(delegate->fired());

121

122 // Move the alarm forward 1us and ensure it doesn't move forward.

123 alarm->Update(clock->Now().Add(new_delta),

124 QuicTime::Delta::FromMicroseconds(2));

125

126 epoll_server_.AdvanceByExactlyAndCallCallbacks(

127 new_delta.Subtract(delta).ToMicroseconds());

128 EXPECT_EQ(start.Add(new_delta), clock->Now());

129 EXPECT_TRUE(delegate->fired());

130

131 // Set the alarm via an update call.

132 new_delta = QuicTime::Delta::FromMicroseconds(5);

133 alarm->Update(clock->Now().Add(new_delta),

134 QuicTime::Delta::FromMicroseconds(1));

135 EXPECT_TRUE(alarm->IsSet());

136

137 // Update it with an uninitialized time and ensure it's cancelled.

138 alarm->Update(QuicTime::Zero(), QuicTime::Delta::FromMicroseconds(1));

139 EXPECT_FALSE(alarm->IsSet());

140 }

141

142 } // namespace

143 } // namespace test

144 } // namespace tools

145 } // namespace net

OLD	NEW

« no previous file with comments | « net/tools/quic/quic_epoll_connection_helper.cc ('k') | net/tools/quic/quic_in_memory_cache.h » ('j') | no next file with comments »