net/quic/quic_time_test.cc - Issue 2193073003: Move shared files in net/quic/ into net/quic/core/

Side by Side Diff: net/quic/quic_time_test.cc

Issue 2193073003: Move shared files in net/quic/ into net/quic/core/ (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master

Patch Set: io_thread_unittest.cc Created 4 years, 4 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/quic/quic_time.h"

6 #include "net/quic/test_tools/mock_clock.h"

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

8

9 namespace net {

10 namespace test {

11

12 TEST(QuicTimeDeltaTest, Zero) {

13 EXPECT_TRUE(QuicTime::Delta::Zero().IsZero());

14 EXPECT_FALSE(QuicTime::Delta::Zero().IsInfinite());

15 EXPECT_FALSE(QuicTime::Delta::FromMilliseconds(1).IsZero());

16 }

17

18 TEST(QuicTimeDeltaTest, Infinite) {

19 EXPECT_TRUE(QuicTime::Delta::Infinite().IsInfinite());

20 EXPECT_FALSE(QuicTime::Delta::Zero().IsInfinite());

21 EXPECT_FALSE(QuicTime::Delta::FromMilliseconds(1).IsInfinite());

22 }

23

24 TEST(QuicTimeDeltaTest, FromTo) {

25 EXPECT_EQ(QuicTime::Delta::FromMilliseconds(1),

26 QuicTime::Delta::FromMicroseconds(1000));

27 EXPECT_EQ(QuicTime::Delta::FromSeconds(1),

28 QuicTime::Delta::FromMilliseconds(1000));

29 EXPECT_EQ(QuicTime::Delta::FromSeconds(1),

30 QuicTime::Delta::FromMicroseconds(1000000));

31

32 EXPECT_EQ(1, QuicTime::Delta::FromMicroseconds(1000).ToMilliseconds());

33 EXPECT_EQ(2, QuicTime::Delta::FromMilliseconds(2000).ToSeconds());

34 EXPECT_EQ(1000, QuicTime::Delta::FromMilliseconds(1).ToMicroseconds());

35 EXPECT_EQ(1, QuicTime::Delta::FromMicroseconds(1000).ToMilliseconds());

36 EXPECT_EQ(QuicTime::Delta::FromMilliseconds(2000).ToMicroseconds(),

37 QuicTime::Delta::FromSeconds(2).ToMicroseconds());

38 }

39

40 TEST(QuicTimeDeltaTest, Add) {

41 EXPECT_EQ(QuicTime::Delta::FromMicroseconds(2000),

42 QuicTime::Delta::Zero() + QuicTime::Delta::FromMilliseconds(2));

43 }

44

45 TEST(QuicTimeDeltaTest, Subtract) {

46 EXPECT_EQ(QuicTime::Delta::FromMicroseconds(1000),

47 QuicTime::Delta::FromMilliseconds(2) -

48 QuicTime::Delta::FromMilliseconds(1));

49 }

50

51 TEST(QuicTimeDeltaTest, Multiply) {

52 int i = 2;

53 EXPECT_EQ(QuicTime::Delta::FromMicroseconds(4000),

54 QuicTime::Delta::FromMilliseconds(2) * i);

55 EXPECT_EQ(QuicTime::Delta::FromMicroseconds(4000),

56 i * QuicTime::Delta::FromMilliseconds(2));

57 double d = 2;

58 EXPECT_EQ(QuicTime::Delta::FromMicroseconds(4000),

59 QuicTime::Delta::FromMilliseconds(2) * d);

60 EXPECT_EQ(QuicTime::Delta::FromMicroseconds(4000),

61 d * QuicTime::Delta::FromMilliseconds(2));

62 }

63

64 TEST(QuicTimeDeltaTest, Max) {

65 EXPECT_EQ(QuicTime::Delta::FromMicroseconds(2000),

66 std::max(QuicTime::Delta::FromMicroseconds(1000),

67 QuicTime::Delta::FromMicroseconds(2000)));

68 }

69

70 TEST(QuicTimeDeltaTest, NotEqual) {

71 EXPECT_TRUE(QuicTime::Delta::FromSeconds(0) !=

72 QuicTime::Delta::FromSeconds(1));

73 EXPECT_FALSE(QuicTime::Delta::FromSeconds(0) !=

74 QuicTime::Delta::FromSeconds(0));

75 }

76

77 class QuicTimeTest : public ::testing::Test {

78 protected:

79 MockClock clock_;

80 };

81

82 TEST_F(QuicTimeTest, Initialized) {

83 EXPECT_FALSE(QuicTime::Zero().IsInitialized());

84 EXPECT_TRUE((QuicTime::Zero() + QuicTime::Delta::FromMicroseconds(1))

85 .IsInitialized());

86 }

87

88 TEST_F(QuicTimeTest, Add) {

89 QuicTime time_1 = QuicTime::Zero() + QuicTime::Delta::FromMilliseconds(1);

90 QuicTime time_2 = QuicTime::Zero() + QuicTime::Delta::FromMilliseconds(2);

91

92 QuicTime::Delta diff = time_2 - time_1;

93

94 EXPECT_EQ(QuicTime::Delta::FromMilliseconds(1), diff);

95 EXPECT_EQ(1000, diff.ToMicroseconds());

96 EXPECT_EQ(1, diff.ToMilliseconds());

97 }

98

99 TEST_F(QuicTimeTest, Subtract) {

100 QuicTime time_1 = QuicTime::Zero() + QuicTime::Delta::FromMilliseconds(1);

101 QuicTime time_2 = QuicTime::Zero() + QuicTime::Delta::FromMilliseconds(2);

102

103 EXPECT_EQ(QuicTime::Delta::FromMilliseconds(1), time_2 - time_1);

104 }

105

106 TEST_F(QuicTimeTest, SubtractDelta) {

107 QuicTime time = QuicTime::Zero() + QuicTime::Delta::FromMilliseconds(2);

108 EXPECT_EQ(QuicTime::Zero() + QuicTime::Delta::FromMilliseconds(1),

109 time - QuicTime::Delta::FromMilliseconds(1));

110 }

111

112 TEST_F(QuicTimeTest, Max) {

113 QuicTime time_1 = QuicTime::Zero() + QuicTime::Delta::FromMilliseconds(1);

114 QuicTime time_2 = QuicTime::Zero() + QuicTime::Delta::FromMilliseconds(2);

115

116 EXPECT_EQ(time_2, std::max(time_1, time_2));

117 }

118

119 TEST_F(QuicTimeTest, MockClock) {

120 clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(1));

121

122 QuicTime now = clock_.ApproximateNow();

123 QuicTime time = QuicTime::Zero() + QuicTime::Delta::FromMicroseconds(1000);

124

125 EXPECT_EQ(now, time);

126

127 clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(1));

128 now = clock_.ApproximateNow();

129

130 EXPECT_NE(now, time);

131

132 time = time + QuicTime::Delta::FromMilliseconds(1);

133 EXPECT_EQ(now, time);

134 }

135

136 TEST_F(QuicTimeTest, LE) {

137 const QuicTime zero = QuicTime::Zero();

138 const QuicTime one = zero + QuicTime::Delta::FromSeconds(1);

139 EXPECT_TRUE(zero <= zero);

140 EXPECT_TRUE(zero <= one);

141 EXPECT_TRUE(one <= one);

142 EXPECT_FALSE(one <= zero);

143 }

144

145 } // namespace test

146 } // namespace net

OLD	NEW

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