1 // Copyright 2017 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 "services/network/network_usage_accumulator.h"
6 #include "testing/gtest/include/gtest/gtest.h"
7
8 namespace network {
9
10 namespace {
11
12 struct BytesTransferredKey {
13 int32_t process_id;
14 int32_t routing_id;
15 };
16
17 } // namespace
18
19 class NetworkUsageAccumulatorTest : public testing::Test {
20 public:
NetworkUsageAccumulatorTest()21 NetworkUsageAccumulatorTest() {}
~NetworkUsageAccumulatorTest()22 ~NetworkUsageAccumulatorTest() override {}
23
SimulateRawBytesTransferred(const BytesTransferredKey & key,int64_t bytes_received,int64_t bytes_sent)24 void SimulateRawBytesTransferred(const BytesTransferredKey& key,
25 int64_t bytes_received,
26 int64_t bytes_sent) {
27 network_usage_accumulator_.OnBytesTransferred(
28 key.process_id, key.routing_id, bytes_received, bytes_sent);
29 }
30
GetUsageForKey(const std::vector<mojom::NetworkUsagePtr> & usages,const BytesTransferredKey & key)31 mojom::NetworkUsage* GetUsageForKey(
32 const std::vector<mojom::NetworkUsagePtr>& usages,
33 const BytesTransferredKey& key) {
34 for (const auto& usage : usages) {
35 if (key.process_id == usage->process_id &&
36 key.routing_id == usage->routing_id)
37 return usage.get();
38 }
39 return nullptr;
40 }
41
ClearBytesTransferredForProcess(int32_t process_id)42 void ClearBytesTransferredForProcess(int32_t process_id) {
43 network_usage_accumulator_.ClearBytesTransferredForProcess(process_id);
44 }
45
GetTotalNetworkUsages() const46 std::vector<mojom::NetworkUsagePtr> GetTotalNetworkUsages() const {
47 return network_usage_accumulator_.GetTotalNetworkUsages();
48 }
49
50 private:
51 NetworkUsageAccumulator network_usage_accumulator_;
52
53 DISALLOW_COPY_AND_ASSIGN(NetworkUsageAccumulatorTest);
54 };
55
56 // Tests that the |process_id| and |routing_id| are used in the map correctly.
TEST_F(NetworkUsageAccumulatorTest,ChildRouteData)57 TEST_F(NetworkUsageAccumulatorTest, ChildRouteData) {
58 BytesTransferredKey key = {100, 190};
59
60 int64_t correct_read_bytes = 0;
61 int64_t correct_sent_bytes = 0;
62
63 int read_bytes_array[] = {900, 300, 100};
64 int sent_bytes_array[] = {130, 153, 934};
65
66 for (int i : read_bytes_array) {
67 SimulateRawBytesTransferred(key, i, 0);
68 correct_read_bytes += i;
69 }
70 for (int i : sent_bytes_array) {
71 SimulateRawBytesTransferred(key, 0, i);
72 correct_sent_bytes += i;
73 }
74
75 auto returned_usages = GetTotalNetworkUsages();
76 EXPECT_EQ(1U, returned_usages.size());
77 EXPECT_EQ(correct_sent_bytes,
78 GetUsageForKey(returned_usages, key)->total_bytes_sent);
79 EXPECT_EQ(correct_read_bytes,
80 GetUsageForKey(returned_usages, key)->total_bytes_received);
81 }
82
83 // Tests that two distinct |process_id| and |routing_id| pairs are tracked
84 // separately in the unordered map.
TEST_F(NetworkUsageAccumulatorTest,TwoChildRouteData)85 TEST_F(NetworkUsageAccumulatorTest, TwoChildRouteData) {
86 BytesTransferredKey key1 = {32, 1};
87 BytesTransferredKey key2 = {17, 2};
88
89 int64_t correct_read_bytes1 = 0;
90 int64_t correct_sent_bytes1 = 0;
91
92 int64_t correct_read_bytes2 = 0;
93 int64_t correct_sent_bytes2 = 0;
94
95 int read_bytes_array1[] = {453, 987654, 946650};
96 int sent_bytes_array1[] = {138450, 1556473, 954434};
97
98 int read_bytes_array2[] = {905643, 324340, 654150};
99 int sent_bytes_array2[] = {1232138, 157312, 965464};
100
101 for (int i : read_bytes_array1) {
102 SimulateRawBytesTransferred(key1, i, 0);
103 correct_read_bytes1 += i;
104 }
105 for (int i : sent_bytes_array1) {
106 SimulateRawBytesTransferred(key1, 0, i);
107 correct_sent_bytes1 += i;
108 }
109
110 for (int i : read_bytes_array2) {
111 SimulateRawBytesTransferred(key2, i, 0);
112 correct_read_bytes2 += i;
113 }
114 for (int i : sent_bytes_array2) {
115 SimulateRawBytesTransferred(key2, 0, i);
116 correct_sent_bytes2 += i;
117 }
118
119 auto returned_usages = GetTotalNetworkUsages();
120 EXPECT_EQ(2U, returned_usages.size());
121 EXPECT_EQ(correct_sent_bytes1,
122 GetUsageForKey(returned_usages, key1)->total_bytes_sent);
123 EXPECT_EQ(correct_read_bytes1,
124 GetUsageForKey(returned_usages, key1)->total_bytes_received);
125 EXPECT_EQ(correct_sent_bytes2,
126 GetUsageForKey(returned_usages, key2)->total_bytes_sent);
127 EXPECT_EQ(correct_read_bytes2,
128 GetUsageForKey(returned_usages, key2)->total_bytes_received);
129 }
130
131 // Tests that two keys with the same |process_id| and |routing_id| are tracked
132 // together in the accumulator.
TEST_F(NetworkUsageAccumulatorTest,TwoSameChildRouteData)133 TEST_F(NetworkUsageAccumulatorTest, TwoSameChildRouteData) {
134 BytesTransferredKey key1 = {123, 456};
135 BytesTransferredKey key2 = {123, 456};
136
137 int64_t correct_read_bytes = 0;
138 int64_t correct_sent_bytes = 0;
139
140 int read_bytes_array[] = {90440, 12300, 103420};
141 int sent_bytes_array[] = {44130, 12353, 93234};
142
143 for (int i : read_bytes_array) {
144 SimulateRawBytesTransferred(key1, i, 0);
145 correct_read_bytes += i;
146 }
147 for (int i : sent_bytes_array) {
148 SimulateRawBytesTransferred(key1, 0, i);
149 correct_sent_bytes += i;
150 }
151
152 for (int i : read_bytes_array) {
153 SimulateRawBytesTransferred(key2, i, 0);
154 correct_read_bytes += i;
155 }
156 for (int i : sent_bytes_array) {
157 SimulateRawBytesTransferred(key2, 0, i);
158 correct_sent_bytes += i;
159 }
160
161 auto returned_usages = GetTotalNetworkUsages();
162 EXPECT_EQ(1U, returned_usages.size());
163 EXPECT_EQ(correct_sent_bytes,
164 GetUsageForKey(returned_usages, key1)->total_bytes_sent);
165 EXPECT_EQ(correct_read_bytes,
166 GetUsageForKey(returned_usages, key1)->total_bytes_received);
167 EXPECT_EQ(correct_sent_bytes,
168 GetUsageForKey(returned_usages, key2)->total_bytes_sent);
169 EXPECT_EQ(correct_read_bytes,
170 GetUsageForKey(returned_usages, key2)->total_bytes_received);
171 }
172
173 // Tests that the map can handle two process_ids with the same routing_id.
TEST_F(NetworkUsageAccumulatorTest,SameRouteDifferentProcesses)174 TEST_F(NetworkUsageAccumulatorTest, SameRouteDifferentProcesses) {
175 BytesTransferredKey key1 = {12, 143};
176 BytesTransferredKey key2 = {13, 143};
177
178 int64_t correct_read_bytes1 = 0;
179 int64_t correct_sent_bytes1 = 0;
180
181 int64_t correct_read_bytes2 = 0;
182 int64_t correct_sent_bytes2 = 0;
183
184 int read_bytes_array1[] = {453, 98754, 94650};
185 int sent_bytes_array1[] = {1350, 15643, 95434};
186
187 int read_bytes_array2[] = {905643, 3243, 654150};
188 int sent_bytes_array2[] = {12338, 157312, 9664};
189
190 for (int i : read_bytes_array1) {
191 SimulateRawBytesTransferred(key1, i, 0);
192 correct_read_bytes1 += i;
193 }
194 for (int i : sent_bytes_array1) {
195 SimulateRawBytesTransferred(key1, 0, i);
196 correct_sent_bytes1 += i;
197 }
198
199 for (int i : read_bytes_array2) {
200 SimulateRawBytesTransferred(key2, i, 0);
201 correct_read_bytes2 += i;
202 }
203 for (int i : sent_bytes_array2) {
204 SimulateRawBytesTransferred(key2, 0, i);
205 correct_sent_bytes2 += i;
206 }
207
208 auto returned_usages = GetTotalNetworkUsages();
209 EXPECT_EQ(2U, returned_usages.size());
210 EXPECT_EQ(correct_sent_bytes1,
211 GetUsageForKey(returned_usages, key1)->total_bytes_sent);
212 EXPECT_EQ(correct_read_bytes1,
213 GetUsageForKey(returned_usages, key1)->total_bytes_received);
214 EXPECT_EQ(correct_sent_bytes2,
215 GetUsageForKey(returned_usages, key2)->total_bytes_sent);
216 EXPECT_EQ(correct_read_bytes2,
217 GetUsageForKey(returned_usages, key2)->total_bytes_received);
218 }
219
220 // Tests that process data is cleared after termination.
TEST_F(NetworkUsageAccumulatorTest,ClearAfterTermination)221 TEST_F(NetworkUsageAccumulatorTest, ClearAfterTermination) {
222 // |key1| and |key2| belongs to the same process.
223 BytesTransferredKey key1 = {100, 190};
224 BytesTransferredKey key2 = {100, 191};
225 BytesTransferredKey key3 = {101, 191};
226
227 // No data has been transferred yet.
228 auto returned_usages = GetTotalNetworkUsages();
229 EXPECT_EQ(0U, returned_usages.size());
230 EXPECT_EQ(nullptr, GetUsageForKey(returned_usages, key1));
231 EXPECT_EQ(nullptr, GetUsageForKey(returned_usages, key2));
232 EXPECT_EQ(nullptr, GetUsageForKey(returned_usages, key3));
233
234 // Simulate data transfer on all three keys.
235 SimulateRawBytesTransferred(key1, 100, 1);
236 SimulateRawBytesTransferred(key2, 2, 200);
237 SimulateRawBytesTransferred(key3, 33, 333);
238 returned_usages = GetTotalNetworkUsages();
239 // Should have data observed on all three keys.
240 EXPECT_EQ(3U, returned_usages.size());
241 EXPECT_NE(nullptr, GetUsageForKey(returned_usages, key1));
242 EXPECT_NE(nullptr, GetUsageForKey(returned_usages, key2));
243 EXPECT_NE(nullptr, GetUsageForKey(returned_usages, key3));
244
245 // Simulate process termination on the first process.
246 ClearBytesTransferredForProcess(key1.process_id);
247
248 // |key1| and |key2| should both be cleared.
249 returned_usages = GetTotalNetworkUsages();
250 EXPECT_EQ(1U, returned_usages.size());
251 EXPECT_EQ(nullptr, GetUsageForKey(returned_usages, key1));
252 EXPECT_EQ(nullptr, GetUsageForKey(returned_usages, key2));
253 // |key3| shouldn't be affected.
254 EXPECT_NE(nullptr, GetUsageForKey(returned_usages, key3));
255 }
256
257 // Tests that the map can store both types of keys and that it does update after
258 // a process has gone.
TEST_F(NetworkUsageAccumulatorTest,MultipleWavesMixedData)259 TEST_F(NetworkUsageAccumulatorTest, MultipleWavesMixedData) {
260 BytesTransferredKey key1 = {12, 143};
261 BytesTransferredKey key2 = {0, 0};
262
263 int64_t correct_read_bytes1 = 0;
264 int64_t correct_sent_bytes1 = 0;
265
266 int read_bytes_array1[] = {453, 98754, 94650};
267 int sent_bytes_array1[] = {1350, 15643, 95434};
268
269 for (int i : read_bytes_array1) {
270 SimulateRawBytesTransferred(key1, i, 0);
271 correct_read_bytes1 += i;
272 }
273 for (int i : sent_bytes_array1) {
274 SimulateRawBytesTransferred(key1, 0, i);
275 correct_sent_bytes1 += i;
276 }
277
278 auto returned_usages = GetTotalNetworkUsages();
279 EXPECT_NE(nullptr, GetUsageForKey(returned_usages, key1));
280 // |key2| has not been used yet so it shouldn't exist in the returned usages.
281 EXPECT_EQ(nullptr, GetUsageForKey(returned_usages, key2));
282
283 SimulateRawBytesTransferred(key2, 0, 10);
284 returned_usages = GetTotalNetworkUsages();
285 EXPECT_NE(nullptr, GetUsageForKey(returned_usages, key2));
286
287 ClearBytesTransferredForProcess(key1.process_id);
288 ClearBytesTransferredForProcess(key2.process_id);
289
290 correct_sent_bytes1 = 0;
291 correct_read_bytes1 = 0;
292
293 SimulateRawBytesTransferred(key1, 0, 10);
294 correct_sent_bytes1 += 10;
295
296 returned_usages = GetTotalNetworkUsages();
297 EXPECT_EQ(1U, returned_usages.size());
298 EXPECT_EQ(correct_sent_bytes1,
299 GetUsageForKey(returned_usages, key1)->total_bytes_sent);
300 EXPECT_EQ(correct_read_bytes1,
301 GetUsageForKey(returned_usages, key1)->total_bytes_received);
302 // |key2| has been cleared.
303 EXPECT_EQ(nullptr, GetUsageForKey(returned_usages, key2));
304 ClearBytesTransferredForProcess(key1.process_id);
305
306 correct_read_bytes1 = 0;
307 correct_sent_bytes1 = 0;
308
309 int correct_read_bytes2 = 0;
310 int correct_sent_bytes2 = 0;
311
312 int read_bytes_array_second_1[] = {4153, 987154, 946501};
313 int sent_bytes_array_second_1[] = {13510, 115643, 954134};
314
315 int read_bytes_array2[] = {9056243, 32243, 6541250};
316 int sent_bytes_array2[] = {123238, 1527312, 96624};
317
318 for (int i : read_bytes_array_second_1) {
319 SimulateRawBytesTransferred(key1, i, 0);
320 correct_read_bytes1 += i;
321 }
322 for (int i : sent_bytes_array_second_1) {
323 SimulateRawBytesTransferred(key1, 0, i);
324 correct_sent_bytes1 += i;
325 }
326
327 for (int i : read_bytes_array2) {
328 SimulateRawBytesTransferred(key2, i, 0);
329 correct_read_bytes2 += i;
330 }
331 for (int i : sent_bytes_array2) {
332 SimulateRawBytesTransferred(key2, 0, i);
333 correct_sent_bytes2 += i;
334 }
335
336 returned_usages = GetTotalNetworkUsages();
337 EXPECT_EQ(2U, returned_usages.size());
338 EXPECT_EQ(correct_sent_bytes1,
339 GetUsageForKey(returned_usages, key1)->total_bytes_sent);
340 EXPECT_EQ(correct_read_bytes1,
341 GetUsageForKey(returned_usages, key1)->total_bytes_received);
342 EXPECT_EQ(correct_sent_bytes2,
343 GetUsageForKey(returned_usages, key2)->total_bytes_sent);
344 EXPECT_EQ(correct_read_bytes2,
345 GetUsageForKey(returned_usages, key2)->total_bytes_received);
346 }
347
348 } // namespace network
349