content/browser/media/capture/feedback_signal_accumulator_unittest.cc - Issue 1162863003: Move ContentVideoCaptureDeviceCore from src/content to src/media

Side by Side Diff: content/browser/media/capture/feedback_signal_accumulator_unittest.cc

Issue 1162863003: Move ContentVideoCaptureDeviceCore from src/content to src/media (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master

Patch Set: rebase Created 5 years, 6 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) 2015 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 "content/browser/media/capture/feedback_signal_accumulator.h"

6

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

8

9 namespace content {

10

11 class FeedbackSignalAccumulatorTest : public ::testing::Test {

12 public:

13 FeedbackSignalAccumulatorTest()

14 : half_life_(base::TimeDelta::FromSeconds(1)),

15 acc_(half_life_),

16 t_(base::TimeTicks() + base::TimeDelta::FromSeconds(120)) {

17 acc_.Reset(0.0, t_);

18 }

19

20 protected:

21 const base::TimeDelta half_life_;

22 FeedbackSignalAccumulator acc_;

23 base::TimeTicks t_;

24 };

25

26 TEST_F(FeedbackSignalAccumulatorTest, HasCorrectStartingValueAfterReset) {

27 ASSERT_EQ(0.0, acc_.current());

28 ASSERT_EQ(t_, acc_.reset_time());

29 ASSERT_EQ(t_, acc_.update_time());

30

31 acc_.Reset(1.0, t_);

32 ASSERT_EQ(1.0, acc_.current());

33 ASSERT_EQ(t_, acc_.reset_time());

34 ASSERT_EQ(t_, acc_.update_time());

35

36 t_ += half_life_;

37 acc_.Reset(2.0, t_);

38 ASSERT_EQ(2.0, acc_.current());

39 ASSERT_EQ(t_, acc_.reset_time());

40 ASSERT_EQ(t_, acc_.update_time());

41 }

42

43 TEST_F(FeedbackSignalAccumulatorTest, DoesNotUpdateIfBeforeResetTime) {

44 acc_.Reset(0.0, t_);

45 ASSERT_EQ(0.0, acc_.current());

46 ASSERT_EQ(t_, acc_.update_time());

47

48 const base::TimeTicks one_usec_before =

49 t_ - base::TimeDelta::FromMicroseconds(1);

50 ASSERT_FALSE(acc_.Update(1.0, one_usec_before));

51 ASSERT_EQ(0.0, acc_.current());

52 ASSERT_EQ(t_, acc_.update_time());

53

54 const base::TimeTicks one_usec_after =

55 t_ + base::TimeDelta::FromMicroseconds(1);

56 ASSERT_TRUE(acc_.Update(1.0, one_usec_after));

57 ASSERT_LT(0.0, acc_.current());

58 ASSERT_EQ(one_usec_after, acc_.update_time());

59 }

60

61 TEST_F(FeedbackSignalAccumulatorTest, TakesMaxOfUpdatesAtResetTime) {

62 acc_.Reset(0.0, t_);

63 ASSERT_EQ(0.0, acc_.current());

64 ASSERT_EQ(t_, acc_.update_time());

65

66 ASSERT_TRUE(acc_.Update(1.0, t_));

67 ASSERT_EQ(1.0, acc_.current());

68 ASSERT_EQ(t_, acc_.update_time());

69

70 ASSERT_TRUE(acc_.Update(2.0, t_));

71 ASSERT_EQ(2.0, acc_.current());

72 ASSERT_EQ(t_, acc_.update_time());

73

74 ASSERT_TRUE(acc_.Update(1.0, t_));

75 ASSERT_EQ(2.0, acc_.current());

76 ASSERT_EQ(t_, acc_.update_time());

77 }

78

79 TEST_F(FeedbackSignalAccumulatorTest, AppliesMaxOfUpdatesWithSameTimestamp) {

80 acc_.Reset(0.0, t_);

81 ASSERT_EQ(0.0, acc_.current());

82 ASSERT_EQ(t_, acc_.update_time());

83 t_ += 1 * half_life_;

84

85 // Update with an identical value at the same timestamp.

86 for (int i = 0; i < 3; ++i) {

87 ASSERT_TRUE(acc_.Update(1.0, t_));

88 ASSERT_EQ(0.5, acc_.current());

89 ASSERT_EQ(t_, acc_.update_time());

90 }

91

92 // Now continue updating with different values at the same timestamp.

93 ASSERT_TRUE(acc_.Update(2.0, t_));

94 ASSERT_EQ(1.0, acc_.current());

95 ASSERT_EQ(t_, acc_.update_time());

96 ASSERT_TRUE(acc_.Update(3.0, t_));

97 ASSERT_EQ(1.5, acc_.current());

98 ASSERT_EQ(t_, acc_.update_time());

99 ASSERT_TRUE(acc_.Update(1.0, t_));

100 ASSERT_EQ(1.5, acc_.current());

101 ASSERT_EQ(t_, acc_.update_time());

102 }

103

104 TEST_F(FeedbackSignalAccumulatorTest, ProvidesExpectedHoldResponse) {

105 // Step one half-life interval per update.

106 acc_.Reset(0.0, t_);

107 ASSERT_EQ(0.0, acc_.current());

108 ASSERT_EQ(t_, acc_.update_time());

109 t_ += 1 * half_life_;

110 ASSERT_TRUE(acc_.Update(1.0, t_));

111 ASSERT_EQ(0.5, acc_.current());

112 ASSERT_EQ(t_, acc_.update_time());

113 t_ += 1 * half_life_;

114 ASSERT_TRUE(acc_.Update(1.0, t_));

115 ASSERT_EQ(0.75, acc_.current());

116 ASSERT_EQ(t_, acc_.update_time());

117 t_ += 1 * half_life_;

118 ASSERT_TRUE(acc_.Update(1.0, t_));

119 ASSERT_EQ(0.875, acc_.current());

120 ASSERT_EQ(t_, acc_.update_time());

121 t_ += 1 * half_life_;

122 ASSERT_TRUE(acc_.Update(1.0, t_));

123 ASSERT_EQ(0.9375, acc_.current());

124 ASSERT_EQ(t_, acc_.update_time());

125

126 // Step two half-life intervals per update.

127 acc_.Reset(0.0, t_);

128 ASSERT_EQ(0.0, acc_.current());

129 ASSERT_EQ(t_, acc_.update_time());

130 t_ += 2 * half_life_;

131 ASSERT_TRUE(acc_.Update(1.0, t_));

132 ASSERT_NEAR(0.666666667, acc_.current(), 0.000000001);

133 ASSERT_EQ(t_, acc_.update_time());

134 t_ += 2 * half_life_;

135 ASSERT_TRUE(acc_.Update(1.0, t_));

136 ASSERT_NEAR(0.888888889, acc_.current(), 0.000000001);

137 ASSERT_EQ(t_, acc_.update_time());

138 t_ += 2 * half_life_;

139 ASSERT_TRUE(acc_.Update(1.0, t_));

140 ASSERT_NEAR(0.962962963, acc_.current(), 0.000000001);

141 ASSERT_EQ(t_, acc_.update_time());

142 t_ += 2 * half_life_;

143 ASSERT_TRUE(acc_.Update(1.0, t_));

144 ASSERT_NEAR(0.987654321, acc_.current(), 0.000000001);

145 ASSERT_EQ(t_, acc_.update_time());

146

147 // Step three half-life intervals per update.

148 acc_.Reset(0.0, t_);

149 ASSERT_EQ(0.0, acc_.current());

150 ASSERT_EQ(t_, acc_.update_time());

151 t_ += 3 * half_life_;

152 ASSERT_TRUE(acc_.Update(1.0, t_));

153 ASSERT_EQ(0.75, acc_.current());

154 ASSERT_EQ(t_, acc_.update_time());

155 t_ += 3 * half_life_;

156 ASSERT_TRUE(acc_.Update(1.0, t_));

157 ASSERT_EQ(0.9375, acc_.current());

158 ASSERT_EQ(t_, acc_.update_time());

159 t_ += 3 * half_life_;

160 ASSERT_TRUE(acc_.Update(1.0, t_));

161 ASSERT_EQ(0.984375, acc_.current());

162 ASSERT_EQ(t_, acc_.update_time());

163 t_ += 3 * half_life_;

164 ASSERT_TRUE(acc_.Update(1.0, t_));

165 ASSERT_EQ(0.99609375, acc_.current());

166 ASSERT_EQ(t_, acc_.update_time());

167 }

168

169 TEST_F(FeedbackSignalAccumulatorTest, IgnoresUpdatesThatAreOutOfOrder) {

170 // First, go forward several steps, in order.

171 acc_.Reset(0.0, t_);

172 ASSERT_EQ(0.0, acc_.current());

173 ASSERT_EQ(t_, acc_.update_time());

174 t_ += 1 * half_life_;

175 ASSERT_TRUE(acc_.Update(2.0, t_));

176 ASSERT_EQ(1.0, acc_.current());

177 ASSERT_EQ(t_, acc_.update_time());

178 t_ += 1 * half_life_;

179 ASSERT_TRUE(acc_.Update(2.0, t_));

180 ASSERT_EQ(1.5, acc_.current());

181 ASSERT_EQ(t_, acc_.update_time());

182 t_ += 1 * half_life_;

183 ASSERT_TRUE(acc_.Update(2.0, t_));

184 ASSERT_EQ(1.75, acc_.current());

185 ASSERT_EQ(t_, acc_.update_time());

186 t_ += 1 * half_life_;

187 ASSERT_TRUE(acc_.Update(2.0, t_));

188 ASSERT_EQ(1.875, acc_.current());

189 ASSERT_EQ(t_, acc_.update_time());

190

191 // Go back 1 steps, then 1.5, then 2, then 2.5, etc. and expect the update to

192 // fail each time.

193 base::TimeTicks earlier = t_ - 1 * half_life_;

194 for (int i = 0; i < 5; ++i) {

195 ASSERT_FALSE(acc_.Update(999.0, earlier));

196 ASSERT_EQ(1.875, acc_.current());

197 ASSERT_EQ(t_, acc_.update_time());

198 earlier -= half_life_ / 2;

199 }

200 }

201

202 } // namespace content

OLD	NEW