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