1 /*
2  *  Copyright 2016 The WebRTC project authors. All Rights Reserved.
3  *
4  *  Use of this source code is governed by a BSD-style license
5  *  that can be found in the LICENSE file in the root of the source
6  *  tree. An additional intellectual property rights grant can be found
7  *  in the file PATENTS.  All contributing project authors may
8  *  be found in the AUTHORS file in the root of the source tree.
9  */
10 
11 #include "api/stats/rtc_stats.h"
12 
13 #include <cmath>
14 #include <cstdint>
15 #include <cstring>
16 #include <iostream>
17 
18 #include "rtc_base/checks.h"
19 #include "rtc_base/strings/json.h"
20 #include "stats/test/rtc_test_stats.h"
21 #include "test/gtest.h"
22 
23 namespace webrtc {
24 
25 namespace {
26 
27 // JSON stores numbers as floating point numbers with 53 significant bits, which
28 // amounts to about 15.95 decimal digits. Thus, when comparing large numbers
29 // processed by JSON, that's all the precision we should expect.
30 const double JSON_EPSILON = 1e-15;
31 
32 // We do this since Google Test doesn't support relative error.
33 // This is computed as follows:
34 // If |a - b| / |a| < EPS, then |a - b| < |a| * EPS, so |a| * EPS is the
35 // maximum expected error.
GetExpectedError(const double expected_value)36 double GetExpectedError(const double expected_value) {
37   return JSON_EPSILON * fabs(expected_value);
38 }
39 
40 }  // namespace
41 
42 class RTCChildStats : public RTCStats {
43  public:
44   WEBRTC_RTCSTATS_DECL();
45 
RTCChildStats(const std::string & id,int64_t timestamp_us)46   RTCChildStats(const std::string& id, int64_t timestamp_us)
47       : RTCStats(id, timestamp_us), child_int("childInt") {}
48 
49   RTCStatsMember<int32_t> child_int;
50 };
51 
52 WEBRTC_RTCSTATS_IMPL(RTCChildStats, RTCStats, "child-stats", &child_int)
53 
54 class RTCGrandChildStats : public RTCChildStats {
55  public:
56   WEBRTC_RTCSTATS_DECL();
57 
RTCGrandChildStats(const std::string & id,int64_t timestamp_us)58   RTCGrandChildStats(const std::string& id, int64_t timestamp_us)
59       : RTCChildStats(id, timestamp_us), grandchild_int("grandchildInt") {}
60 
61   RTCStatsMember<int32_t> grandchild_int;
62 };
63 
64 WEBRTC_RTCSTATS_IMPL(RTCGrandChildStats,
65                      RTCChildStats,
66                      "grandchild-stats",
67                      &grandchild_int)
68 
TEST(RTCStatsTest,RTCStatsAndMembers)69 TEST(RTCStatsTest, RTCStatsAndMembers) {
70   RTCTestStats stats("testId", 42);
71   EXPECT_EQ(stats.id(), "testId");
72   EXPECT_EQ(stats.timestamp_us(), static_cast<int64_t>(42));
73   std::vector<const RTCStatsMemberInterface*> members = stats.Members();
74   EXPECT_EQ(members.size(), static_cast<size_t>(14));
75   for (const RTCStatsMemberInterface* member : members) {
76     EXPECT_FALSE(member->is_defined());
77   }
78   stats.m_bool = true;
79   stats.m_int32 = 123;
80   stats.m_uint32 = 123;
81   stats.m_int64 = 123;
82   stats.m_uint64 = 123;
83   stats.m_double = 123.0;
84   stats.m_string = std::string("123");
85 
86   std::vector<bool> sequence_bool;
87   sequence_bool.push_back(true);
88   std::vector<int32_t> sequence_int32;
89   sequence_int32.push_back(static_cast<int32_t>(1));
90   std::vector<uint32_t> sequence_uint32;
91   sequence_uint32.push_back(static_cast<uint32_t>(2));
92   std::vector<int64_t> sequence_int64;
93   sequence_int64.push_back(static_cast<int64_t>(3));
94   std::vector<uint64_t> sequence_uint64;
95   sequence_uint64.push_back(static_cast<uint64_t>(4));
96   std::vector<double> sequence_double;
97   sequence_double.push_back(5.0);
98   std::vector<std::string> sequence_string;
99   sequence_string.push_back(std::string("six"));
100 
101   stats.m_sequence_bool = sequence_bool;
102   stats.m_sequence_int32 = sequence_int32;
103   stats.m_sequence_uint32 = sequence_uint32;
104   EXPECT_FALSE(stats.m_sequence_int64.is_defined());
105   stats.m_sequence_int64 = sequence_int64;
106   stats.m_sequence_uint64 = sequence_uint64;
107   stats.m_sequence_double = sequence_double;
108   stats.m_sequence_string = sequence_string;
109   for (const RTCStatsMemberInterface* member : members) {
110     EXPECT_TRUE(member->is_defined());
111   }
112   EXPECT_EQ(*stats.m_bool, true);
113   EXPECT_EQ(*stats.m_int32, static_cast<int32_t>(123));
114   EXPECT_EQ(*stats.m_uint32, static_cast<uint32_t>(123));
115   EXPECT_EQ(*stats.m_int64, static_cast<int64_t>(123));
116   EXPECT_EQ(*stats.m_uint64, static_cast<uint64_t>(123));
117   EXPECT_EQ(*stats.m_double, 123.0);
118   EXPECT_EQ(*stats.m_string, std::string("123"));
119   EXPECT_EQ(*stats.m_sequence_bool, sequence_bool);
120   EXPECT_EQ(*stats.m_sequence_int32, sequence_int32);
121   EXPECT_EQ(*stats.m_sequence_uint32, sequence_uint32);
122   EXPECT_EQ(*stats.m_sequence_int64, sequence_int64);
123   EXPECT_EQ(*stats.m_sequence_uint64, sequence_uint64);
124   EXPECT_EQ(*stats.m_sequence_double, sequence_double);
125   EXPECT_EQ(*stats.m_sequence_string, sequence_string);
126 
127   int32_t numbers[] = {4, 8, 15, 16, 23, 42};
128   std::vector<int32_t> numbers_sequence(&numbers[0], &numbers[6]);
129   stats.m_sequence_int32->clear();
130   stats.m_sequence_int32->insert(stats.m_sequence_int32->end(),
131                                  numbers_sequence.begin(),
132                                  numbers_sequence.end());
133   EXPECT_EQ(*stats.m_sequence_int32, numbers_sequence);
134 }
135 
TEST(RTCStatsTest,EqualityOperator)136 TEST(RTCStatsTest, EqualityOperator) {
137   RTCTestStats empty_stats("testId", 123);
138   EXPECT_EQ(empty_stats, empty_stats);
139 
140   RTCTestStats stats_with_all_values = empty_stats;
141   stats_with_all_values.m_bool = true;
142   stats_with_all_values.m_int32 = 123;
143   stats_with_all_values.m_uint32 = 123;
144   stats_with_all_values.m_int64 = 123;
145   stats_with_all_values.m_uint64 = 123;
146   stats_with_all_values.m_double = 123.0;
147   stats_with_all_values.m_string = "123";
148   stats_with_all_values.m_sequence_bool = std::vector<bool>();
149   stats_with_all_values.m_sequence_int32 = std::vector<int32_t>();
150   stats_with_all_values.m_sequence_uint32 = std::vector<uint32_t>();
151   stats_with_all_values.m_sequence_int64 = std::vector<int64_t>();
152   stats_with_all_values.m_sequence_uint64 = std::vector<uint64_t>();
153   stats_with_all_values.m_sequence_double = std::vector<double>();
154   stats_with_all_values.m_sequence_string = std::vector<std::string>();
155   EXPECT_NE(stats_with_all_values, empty_stats);
156   EXPECT_EQ(stats_with_all_values, stats_with_all_values);
157   EXPECT_NE(stats_with_all_values.m_int32, stats_with_all_values.m_uint32);
158 
159   RTCTestStats one_member_different[] = {
160       stats_with_all_values, stats_with_all_values, stats_with_all_values,
161       stats_with_all_values, stats_with_all_values, stats_with_all_values,
162       stats_with_all_values, stats_with_all_values, stats_with_all_values,
163       stats_with_all_values, stats_with_all_values, stats_with_all_values,
164       stats_with_all_values, stats_with_all_values,
165   };
166   for (size_t i = 0; i < 14; ++i) {
167     EXPECT_EQ(stats_with_all_values, one_member_different[i]);
168   }
169   one_member_different[0].m_bool = false;
170   one_member_different[1].m_int32 = 321;
171   one_member_different[2].m_uint32 = 321;
172   one_member_different[3].m_int64 = 321;
173   one_member_different[4].m_uint64 = 321;
174   one_member_different[5].m_double = 321.0;
175   one_member_different[6].m_string = "321";
176   one_member_different[7].m_sequence_bool->push_back(false);
177   one_member_different[8].m_sequence_int32->push_back(321);
178   one_member_different[9].m_sequence_uint32->push_back(321);
179   one_member_different[10].m_sequence_int64->push_back(321);
180   one_member_different[11].m_sequence_uint64->push_back(321);
181   one_member_different[12].m_sequence_double->push_back(321.0);
182   one_member_different[13].m_sequence_string->push_back("321");
183   for (size_t i = 0; i < 14; ++i) {
184     EXPECT_NE(stats_with_all_values, one_member_different[i]);
185   }
186 
187   RTCTestStats empty_stats_different_id("testId2", 123);
188   EXPECT_NE(empty_stats, empty_stats_different_id);
189   RTCTestStats empty_stats_different_timestamp("testId", 321);
190   EXPECT_EQ(empty_stats, empty_stats_different_timestamp);
191 
192   RTCChildStats child("childId", 42);
193   RTCGrandChildStats grandchild("grandchildId", 42);
194   EXPECT_NE(child, grandchild);
195 
196   RTCChildStats stats_with_defined_member("leId", 0);
197   stats_with_defined_member.child_int = 0;
198   RTCChildStats stats_with_undefined_member("leId", 0);
199   EXPECT_NE(stats_with_defined_member, stats_with_undefined_member);
200   EXPECT_NE(stats_with_undefined_member, stats_with_defined_member);
201 }
202 
TEST(RTCStatsTest,RTCStatsGrandChild)203 TEST(RTCStatsTest, RTCStatsGrandChild) {
204   RTCGrandChildStats stats("grandchild", 0.0);
205   stats.child_int = 1;
206   stats.grandchild_int = 2;
207   int32_t sum = 0;
208   for (const RTCStatsMemberInterface* member : stats.Members()) {
209     sum += *member->cast_to<const RTCStatsMember<int32_t>>();
210   }
211   EXPECT_EQ(sum, static_cast<int32_t>(3));
212 
213   std::unique_ptr<RTCStats> copy_ptr = stats.copy();
214   const RTCGrandChildStats& copy = copy_ptr->cast_to<RTCGrandChildStats>();
215   EXPECT_EQ(*copy.child_int, *stats.child_int);
216   EXPECT_EQ(*copy.grandchild_int, *stats.grandchild_int);
217 }
218 
TEST(RTCStatsTest,RTCStatsPrintsValidJson)219 TEST(RTCStatsTest, RTCStatsPrintsValidJson) {
220   std::string id = "statsId";
221   int timestamp = 42;
222   bool m_bool = true;
223   int m_int32 = 123;
224   int64_t m_int64 = 1234567890123456499L;
225   double m_double = 123.4567890123456499;
226   std::string m_string = "123";
227 
228   std::vector<bool> sequence_bool;
229   std::vector<int32_t> sequence_int32;
230   sequence_int32.push_back(static_cast<int32_t>(1));
231   std::vector<int64_t> sequence_int64;
232   sequence_int64.push_back(static_cast<int64_t>(-1234567890123456499L));
233   sequence_int64.push_back(static_cast<int64_t>(1));
234   sequence_int64.push_back(static_cast<int64_t>(1234567890123456499L));
235   std::vector<double> sequence_double;
236   sequence_double.push_back(123.4567890123456499);
237   sequence_double.push_back(1234567890123.456499);
238   std::vector<std::string> sequence_string;
239   sequence_string.push_back(std::string("four"));
240 
241   RTCTestStats stats(id, timestamp);
242   stats.m_bool = m_bool;
243   stats.m_int32 = m_int32;
244   stats.m_int64 = m_int64;
245   stats.m_double = m_double;
246   stats.m_string = m_string;
247   stats.m_sequence_bool = sequence_bool;
248   stats.m_sequence_int32 = sequence_int32;
249   stats.m_sequence_int64 = sequence_int64;
250   stats.m_sequence_double = sequence_double;
251   stats.m_sequence_string = sequence_string;
252 
253   Json::Value json_output;
254   EXPECT_TRUE(Json::Reader().parse(stats.ToJson(), json_output));
255 
256   EXPECT_TRUE(rtc::GetStringFromJsonObject(json_output, "id", &id));
257   EXPECT_TRUE(rtc::GetIntFromJsonObject(json_output, "timestamp", &timestamp));
258   EXPECT_TRUE(rtc::GetBoolFromJsonObject(json_output, "mBool", &m_bool));
259   EXPECT_TRUE(rtc::GetIntFromJsonObject(json_output, "mInt32", &m_int32));
260   EXPECT_TRUE(rtc::GetDoubleFromJsonObject(json_output, "mDouble", &m_double));
261   EXPECT_TRUE(rtc::GetStringFromJsonObject(json_output, "mString", &m_string));
262 
263   Json::Value json_array;
264 
265   EXPECT_TRUE(
266       rtc::GetValueFromJsonObject(json_output, "mSequenceBool", &json_array));
267   EXPECT_TRUE(rtc::JsonArrayToBoolVector(json_array, &sequence_bool));
268 
269   EXPECT_TRUE(
270       rtc::GetValueFromJsonObject(json_output, "mSequenceInt32", &json_array));
271   EXPECT_TRUE(rtc::JsonArrayToIntVector(json_array, &sequence_int32));
272 
273   EXPECT_TRUE(
274       rtc::GetValueFromJsonObject(json_output, "mSequenceDouble", &json_array));
275   EXPECT_TRUE(rtc::JsonArrayToDoubleVector(json_array, &sequence_double));
276 
277   EXPECT_TRUE(
278       rtc::GetValueFromJsonObject(json_output, "mSequenceString", &json_array));
279   EXPECT_TRUE(rtc::JsonArrayToStringVector(json_array, &sequence_string));
280 
281   EXPECT_EQ(id, stats.id());
282   EXPECT_EQ(timestamp, stats.timestamp_us());
283   EXPECT_EQ(m_bool, *stats.m_bool);
284   EXPECT_EQ(m_int32, *stats.m_int32);
285   EXPECT_EQ(m_string, *stats.m_string);
286   EXPECT_EQ(sequence_bool, *stats.m_sequence_bool);
287   EXPECT_EQ(sequence_int32, *stats.m_sequence_int32);
288   EXPECT_EQ(sequence_string, *stats.m_sequence_string);
289 
290   EXPECT_NEAR(m_double, *stats.m_double, GetExpectedError(*stats.m_double));
291 
292   EXPECT_EQ(sequence_double.size(), stats.m_sequence_double->size());
293   for (size_t i = 0; i < stats.m_sequence_double->size(); ++i) {
294     EXPECT_NEAR(sequence_double[i], stats.m_sequence_double->at(i),
295                 GetExpectedError(stats.m_sequence_double->at(i)));
296   }
297 
298   // We read mInt64 as double since JSON stores all numbers as doubles, so there
299   // is not enough precision to represent large numbers.
300   double m_int64_as_double;
301   std::vector<double> sequence_int64_as_double;
302 
303   EXPECT_TRUE(
304       rtc::GetDoubleFromJsonObject(json_output, "mInt64", &m_int64_as_double));
305 
306   EXPECT_TRUE(
307       rtc::GetValueFromJsonObject(json_output, "mSequenceInt64", &json_array));
308   EXPECT_TRUE(
309       rtc::JsonArrayToDoubleVector(json_array, &sequence_int64_as_double));
310 
311   double stats_m_int64_as_double = static_cast<double>(*stats.m_int64);
312   EXPECT_NEAR(m_int64_as_double, stats_m_int64_as_double,
313               GetExpectedError(stats_m_int64_as_double));
314 
315   EXPECT_EQ(sequence_int64_as_double.size(), stats.m_sequence_int64->size());
316   for (size_t i = 0; i < stats.m_sequence_int64->size(); ++i) {
317     const double stats_value_as_double =
318         static_cast<double>((*stats.m_sequence_int64)[i]);
319     EXPECT_NEAR(sequence_int64_as_double[i], stats_value_as_double,
320                 GetExpectedError(stats_value_as_double));
321   }
322 
323   // Neither stats.m_uint32 nor stats.m_uint64 are defined, so "mUint64" and
324   // "mUint32" should not be part of the generated JSON object.
325   int m_uint32;
326   int m_uint64;
327   EXPECT_FALSE(stats.m_uint32.is_defined());
328   EXPECT_FALSE(stats.m_uint64.is_defined());
329   EXPECT_FALSE(rtc::GetIntFromJsonObject(json_output, "mUint32", &m_uint32));
330   EXPECT_FALSE(rtc::GetIntFromJsonObject(json_output, "mUint64", &m_uint64));
331 
332   std::cout << stats.ToJson() << std::endl;
333 }
334 
TEST(RTCStatsTest,IsStandardized)335 TEST(RTCStatsTest, IsStandardized) {
336   RTCStatsMember<int32_t> standardized("standardized");
337   RTCNonStandardStatsMember<int32_t> unstandardized("unstandardized");
338   EXPECT_TRUE(standardized.is_standardized());
339   EXPECT_FALSE(unstandardized.is_standardized());
340 }
341 
TEST(RTCStatsTest,NonStandardGroupId)342 TEST(RTCStatsTest, NonStandardGroupId) {
343   auto group_id = NonStandardGroupId::kGroupIdForTesting;
344   RTCNonStandardStatsMember<int32_t> with_group_id("stat", {group_id});
345   std::vector<NonStandardGroupId> expected_ids({group_id});
346   EXPECT_EQ(expected_ids, with_group_id.group_ids());
347 
348   RTCNonStandardStatsMember<int32_t> without_group_id("stat");
349   EXPECT_TRUE(without_group_id.group_ids().empty());
350 }
351 
352 // Death tests.
353 // Disabled on Android because death tests misbehave on Android, see
354 // base/test/gtest_util.h.
355 #if RTC_DCHECK_IS_ON && GTEST_HAS_DEATH_TEST && !defined(WEBRTC_ANDROID)
356 
TEST(RTCStatsDeathTest,ValueOfUndefinedMember)357 TEST(RTCStatsDeathTest, ValueOfUndefinedMember) {
358   RTCTestStats stats("testId", 0.0);
359   EXPECT_FALSE(stats.m_int32.is_defined());
360   EXPECT_DEATH(*stats.m_int32, "");
361 }
362 
TEST(RTCStatsDeathTest,InvalidCasting)363 TEST(RTCStatsDeathTest, InvalidCasting) {
364   RTCGrandChildStats stats("grandchild", 0.0);
365   EXPECT_DEATH(stats.cast_to<RTCChildStats>(), "");
366 }
367 
368 #endif  // RTC_DCHECK_IS_ON && GTEST_HAS_DEATH_TEST && !defined(WEBRTC_ANDROID)
369 
370 }  // namespace webrtc
371