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>(16));
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 std::map<std::string, uint64_t> map_string_uint64{{"seven", 8}};
102 std::map<std::string, double> map_string_double{{"nine", 10.0}};
103
104 stats.m_sequence_bool = sequence_bool;
105 stats.m_sequence_int32 = sequence_int32;
106 stats.m_sequence_uint32 = sequence_uint32;
107 EXPECT_FALSE(stats.m_sequence_int64.is_defined());
108 stats.m_sequence_int64 = sequence_int64;
109 stats.m_sequence_uint64 = sequence_uint64;
110 stats.m_sequence_double = sequence_double;
111 stats.m_sequence_string = sequence_string;
112 stats.m_map_string_uint64 = map_string_uint64;
113 stats.m_map_string_double = map_string_double;
114 for (const RTCStatsMemberInterface* member : members) {
115 EXPECT_TRUE(member->is_defined());
116 }
117 EXPECT_EQ(*stats.m_bool, true);
118 EXPECT_EQ(*stats.m_int32, static_cast<int32_t>(123));
119 EXPECT_EQ(*stats.m_uint32, static_cast<uint32_t>(123));
120 EXPECT_EQ(*stats.m_int64, static_cast<int64_t>(123));
121 EXPECT_EQ(*stats.m_uint64, static_cast<uint64_t>(123));
122 EXPECT_EQ(*stats.m_double, 123.0);
123 EXPECT_EQ(*stats.m_string, std::string("123"));
124 EXPECT_EQ(*stats.m_sequence_bool, sequence_bool);
125 EXPECT_EQ(*stats.m_sequence_int32, sequence_int32);
126 EXPECT_EQ(*stats.m_sequence_uint32, sequence_uint32);
127 EXPECT_EQ(*stats.m_sequence_int64, sequence_int64);
128 EXPECT_EQ(*stats.m_sequence_uint64, sequence_uint64);
129 EXPECT_EQ(*stats.m_sequence_double, sequence_double);
130 EXPECT_EQ(*stats.m_sequence_string, sequence_string);
131 EXPECT_EQ(*stats.m_map_string_uint64, map_string_uint64);
132 EXPECT_EQ(*stats.m_map_string_double, map_string_double);
133
134 int32_t numbers[] = {4, 8, 15, 16, 23, 42};
135 std::vector<int32_t> numbers_sequence(&numbers[0], &numbers[6]);
136 stats.m_sequence_int32->clear();
137 stats.m_sequence_int32->insert(stats.m_sequence_int32->end(),
138 numbers_sequence.begin(),
139 numbers_sequence.end());
140 EXPECT_EQ(*stats.m_sequence_int32, numbers_sequence);
141 }
142
TEST(RTCStatsTest,EqualityOperator)143 TEST(RTCStatsTest, EqualityOperator) {
144 RTCTestStats empty_stats("testId", 123);
145 EXPECT_EQ(empty_stats, empty_stats);
146
147 RTCTestStats stats_with_all_values = empty_stats;
148 stats_with_all_values.m_bool = true;
149 stats_with_all_values.m_int32 = 123;
150 stats_with_all_values.m_uint32 = 123;
151 stats_with_all_values.m_int64 = 123;
152 stats_with_all_values.m_uint64 = 123;
153 stats_with_all_values.m_double = 123.0;
154 stats_with_all_values.m_string = "123";
155 stats_with_all_values.m_sequence_bool = std::vector<bool>();
156 stats_with_all_values.m_sequence_int32 = std::vector<int32_t>();
157 stats_with_all_values.m_sequence_uint32 = std::vector<uint32_t>();
158 stats_with_all_values.m_sequence_int64 = std::vector<int64_t>();
159 stats_with_all_values.m_sequence_uint64 = std::vector<uint64_t>();
160 stats_with_all_values.m_sequence_double = std::vector<double>();
161 stats_with_all_values.m_sequence_string = std::vector<std::string>();
162 stats_with_all_values.m_map_string_uint64 = std::map<std::string, uint64_t>();
163 stats_with_all_values.m_map_string_double = std::map<std::string, double>();
164 EXPECT_NE(stats_with_all_values, empty_stats);
165 EXPECT_EQ(stats_with_all_values, stats_with_all_values);
166 EXPECT_NE(stats_with_all_values.m_int32, stats_with_all_values.m_uint32);
167
168 RTCTestStats one_member_different[] = {
169 stats_with_all_values, stats_with_all_values, stats_with_all_values,
170 stats_with_all_values, stats_with_all_values, stats_with_all_values,
171 stats_with_all_values, stats_with_all_values, stats_with_all_values,
172 stats_with_all_values, stats_with_all_values, stats_with_all_values,
173 stats_with_all_values, stats_with_all_values,
174 };
175 for (size_t i = 0; i < 14; ++i) {
176 EXPECT_EQ(stats_with_all_values, one_member_different[i]);
177 }
178 one_member_different[0].m_bool = false;
179 one_member_different[1].m_int32 = 321;
180 one_member_different[2].m_uint32 = 321;
181 one_member_different[3].m_int64 = 321;
182 one_member_different[4].m_uint64 = 321;
183 one_member_different[5].m_double = 321.0;
184 one_member_different[6].m_string = "321";
185 one_member_different[7].m_sequence_bool->push_back(false);
186 one_member_different[8].m_sequence_int32->push_back(321);
187 one_member_different[9].m_sequence_uint32->push_back(321);
188 one_member_different[10].m_sequence_int64->push_back(321);
189 one_member_different[11].m_sequence_uint64->push_back(321);
190 one_member_different[12].m_sequence_double->push_back(321.0);
191 one_member_different[13].m_sequence_string->push_back("321");
192 (*one_member_different[13].m_map_string_uint64)["321"] = 321;
193 (*one_member_different[13].m_map_string_double)["321"] = 321.0;
194 for (size_t i = 0; i < 14; ++i) {
195 EXPECT_NE(stats_with_all_values, one_member_different[i]);
196 }
197
198 RTCTestStats empty_stats_different_id("testId2", 123);
199 EXPECT_NE(empty_stats, empty_stats_different_id);
200 RTCTestStats empty_stats_different_timestamp("testId", 321);
201 EXPECT_EQ(empty_stats, empty_stats_different_timestamp);
202
203 RTCChildStats child("childId", 42);
204 RTCGrandChildStats grandchild("grandchildId", 42);
205 EXPECT_NE(child, grandchild);
206
207 RTCChildStats stats_with_defined_member("leId", 0);
208 stats_with_defined_member.child_int = 0;
209 RTCChildStats stats_with_undefined_member("leId", 0);
210 EXPECT_NE(stats_with_defined_member, stats_with_undefined_member);
211 EXPECT_NE(stats_with_undefined_member, stats_with_defined_member);
212 }
213
TEST(RTCStatsTest,RTCStatsGrandChild)214 TEST(RTCStatsTest, RTCStatsGrandChild) {
215 RTCGrandChildStats stats("grandchild", 0.0);
216 stats.child_int = 1;
217 stats.grandchild_int = 2;
218 int32_t sum = 0;
219 for (const RTCStatsMemberInterface* member : stats.Members()) {
220 sum += *member->cast_to<const RTCStatsMember<int32_t>>();
221 }
222 EXPECT_EQ(sum, static_cast<int32_t>(3));
223
224 std::unique_ptr<RTCStats> copy_ptr = stats.copy();
225 const RTCGrandChildStats& copy = copy_ptr->cast_to<RTCGrandChildStats>();
226 EXPECT_EQ(*copy.child_int, *stats.child_int);
227 EXPECT_EQ(*copy.grandchild_int, *stats.grandchild_int);
228 }
229
TEST(RTCStatsTest,RTCStatsPrintsValidJson)230 TEST(RTCStatsTest, RTCStatsPrintsValidJson) {
231 std::string id = "statsId";
232 int timestamp = 42;
233 bool m_bool = true;
234 int m_int32 = 123;
235 int64_t m_int64 = 1234567890123456499L;
236 double m_double = 123.4567890123456499;
237 std::string m_string = "123";
238
239 std::vector<bool> sequence_bool;
240 std::vector<int32_t> sequence_int32;
241 sequence_int32.push_back(static_cast<int32_t>(1));
242 std::vector<int64_t> sequence_int64;
243 sequence_int64.push_back(static_cast<int64_t>(-1234567890123456499L));
244 sequence_int64.push_back(static_cast<int64_t>(1));
245 sequence_int64.push_back(static_cast<int64_t>(1234567890123456499L));
246 std::vector<double> sequence_double;
247 sequence_double.push_back(123.4567890123456499);
248 sequence_double.push_back(1234567890123.456499);
249 std::vector<std::string> sequence_string;
250 sequence_string.push_back(std::string("four"));
251
252 std::map<std::string, uint64_t> map_string_uint64{
253 {"long", static_cast<uint64_t>(1234567890123456499L)}};
254 std::map<std::string, double> map_string_double{
255 {"three", 123.4567890123456499}, {"thirteen", 123.4567890123456499}};
256
257 RTCTestStats stats(id, timestamp);
258 stats.m_bool = m_bool;
259 stats.m_int32 = m_int32;
260 stats.m_int64 = m_int64;
261 stats.m_double = m_double;
262 stats.m_string = m_string;
263 stats.m_sequence_bool = sequence_bool;
264 stats.m_sequence_int32 = sequence_int32;
265 stats.m_sequence_int64 = sequence_int64;
266 stats.m_sequence_double = sequence_double;
267 stats.m_sequence_string = sequence_string;
268 stats.m_map_string_uint64 = map_string_uint64;
269 stats.m_map_string_double = map_string_double;
270 std::string json_stats = stats.ToJson();
271
272 Json::CharReaderBuilder builder;
273 Json::Value json_output;
274 std::unique_ptr<Json::CharReader> json_reader(builder.newCharReader());
275 EXPECT_TRUE(json_reader->parse(json_stats.c_str(),
276 json_stats.c_str() + json_stats.size(),
277 &json_output, nullptr));
278
279 EXPECT_TRUE(rtc::GetStringFromJsonObject(json_output, "id", &id));
280 EXPECT_TRUE(rtc::GetIntFromJsonObject(json_output, "timestamp", ×tamp));
281 EXPECT_TRUE(rtc::GetBoolFromJsonObject(json_output, "mBool", &m_bool));
282 EXPECT_TRUE(rtc::GetIntFromJsonObject(json_output, "mInt32", &m_int32));
283 EXPECT_TRUE(rtc::GetDoubleFromJsonObject(json_output, "mDouble", &m_double));
284 EXPECT_TRUE(rtc::GetStringFromJsonObject(json_output, "mString", &m_string));
285
286 Json::Value json_array;
287
288 EXPECT_TRUE(
289 rtc::GetValueFromJsonObject(json_output, "mSequenceBool", &json_array));
290 EXPECT_TRUE(rtc::JsonArrayToBoolVector(json_array, &sequence_bool));
291
292 EXPECT_TRUE(
293 rtc::GetValueFromJsonObject(json_output, "mSequenceInt32", &json_array));
294 EXPECT_TRUE(rtc::JsonArrayToIntVector(json_array, &sequence_int32));
295
296 EXPECT_TRUE(
297 rtc::GetValueFromJsonObject(json_output, "mSequenceDouble", &json_array));
298 EXPECT_TRUE(rtc::JsonArrayToDoubleVector(json_array, &sequence_double));
299
300 EXPECT_TRUE(
301 rtc::GetValueFromJsonObject(json_output, "mSequenceString", &json_array));
302 EXPECT_TRUE(rtc::JsonArrayToStringVector(json_array, &sequence_string));
303
304 Json::Value json_map;
305 EXPECT_TRUE(
306 rtc::GetValueFromJsonObject(json_output, "mMapStringDouble", &json_map));
307 for (const auto& entry : map_string_double) {
308 double double_output = 0.0;
309 EXPECT_TRUE(
310 rtc::GetDoubleFromJsonObject(json_map, entry.first, &double_output));
311 EXPECT_NEAR(double_output, entry.second, GetExpectedError(entry.second));
312 }
313
314 EXPECT_EQ(id, stats.id());
315 EXPECT_EQ(timestamp, stats.timestamp_us());
316 EXPECT_EQ(m_bool, *stats.m_bool);
317 EXPECT_EQ(m_int32, *stats.m_int32);
318 EXPECT_EQ(m_string, *stats.m_string);
319 EXPECT_EQ(sequence_bool, *stats.m_sequence_bool);
320 EXPECT_EQ(sequence_int32, *stats.m_sequence_int32);
321 EXPECT_EQ(sequence_string, *stats.m_sequence_string);
322 EXPECT_EQ(map_string_double, *stats.m_map_string_double);
323
324 EXPECT_NEAR(m_double, *stats.m_double, GetExpectedError(*stats.m_double));
325
326 EXPECT_EQ(sequence_double.size(), stats.m_sequence_double->size());
327 for (size_t i = 0; i < stats.m_sequence_double->size(); ++i) {
328 EXPECT_NEAR(sequence_double[i], stats.m_sequence_double->at(i),
329 GetExpectedError(stats.m_sequence_double->at(i)));
330 }
331
332 EXPECT_EQ(map_string_double.size(), stats.m_map_string_double->size());
333 for (const auto& entry : map_string_double) {
334 auto it = stats.m_map_string_double->find(entry.first);
335 EXPECT_NE(it, stats.m_map_string_double->end());
336 EXPECT_NEAR(entry.second, it->second, GetExpectedError(it->second));
337 }
338
339 // We read mInt64 as double since JSON stores all numbers as doubles, so there
340 // is not enough precision to represent large numbers.
341 double m_int64_as_double;
342 std::vector<double> sequence_int64_as_double;
343
344 EXPECT_TRUE(
345 rtc::GetDoubleFromJsonObject(json_output, "mInt64", &m_int64_as_double));
346
347 EXPECT_TRUE(
348 rtc::GetValueFromJsonObject(json_output, "mSequenceInt64", &json_array));
349 EXPECT_TRUE(
350 rtc::JsonArrayToDoubleVector(json_array, &sequence_int64_as_double));
351
352 double stats_m_int64_as_double = static_cast<double>(*stats.m_int64);
353 EXPECT_NEAR(m_int64_as_double, stats_m_int64_as_double,
354 GetExpectedError(stats_m_int64_as_double));
355
356 EXPECT_EQ(sequence_int64_as_double.size(), stats.m_sequence_int64->size());
357 for (size_t i = 0; i < stats.m_sequence_int64->size(); ++i) {
358 const double stats_value_as_double =
359 static_cast<double>((*stats.m_sequence_int64)[i]);
360 EXPECT_NEAR(sequence_int64_as_double[i], stats_value_as_double,
361 GetExpectedError(stats_value_as_double));
362 }
363
364 // Similarly, read Uint64 as double
365 EXPECT_TRUE(
366 rtc::GetValueFromJsonObject(json_output, "mMapStringUint64", &json_map));
367 for (const auto& entry : map_string_uint64) {
368 const double stats_value_as_double =
369 static_cast<double>((*stats.m_map_string_uint64)[entry.first]);
370 double double_output = 0.0;
371 EXPECT_TRUE(
372 rtc::GetDoubleFromJsonObject(json_map, entry.first, &double_output));
373 EXPECT_NEAR(double_output, stats_value_as_double,
374 GetExpectedError(stats_value_as_double));
375 }
376
377 // Neither stats.m_uint32 nor stats.m_uint64 are defined, so "mUint64" and
378 // "mUint32" should not be part of the generated JSON object.
379 int m_uint32;
380 int m_uint64;
381 EXPECT_FALSE(stats.m_uint32.is_defined());
382 EXPECT_FALSE(stats.m_uint64.is_defined());
383 EXPECT_FALSE(rtc::GetIntFromJsonObject(json_output, "mUint32", &m_uint32));
384 EXPECT_FALSE(rtc::GetIntFromJsonObject(json_output, "mUint64", &m_uint64));
385
386 std::cout << stats.ToJson() << std::endl;
387 }
388
TEST(RTCStatsTest,IsStandardized)389 TEST(RTCStatsTest, IsStandardized) {
390 RTCStatsMember<int32_t> standardized("standardized");
391 RTCNonStandardStatsMember<int32_t> unstandardized("unstandardized");
392 EXPECT_TRUE(standardized.is_standardized());
393 EXPECT_FALSE(unstandardized.is_standardized());
394 }
395
TEST(RTCStatsTest,IsSequence)396 TEST(RTCStatsTest, IsSequence) {
397 RTCTestStats stats("statsId", 42);
398 EXPECT_FALSE(stats.m_bool.is_sequence());
399 EXPECT_FALSE(stats.m_int32.is_sequence());
400 EXPECT_FALSE(stats.m_uint32.is_sequence());
401 EXPECT_FALSE(stats.m_int64.is_sequence());
402 EXPECT_FALSE(stats.m_uint64.is_sequence());
403 EXPECT_FALSE(stats.m_double.is_sequence());
404 EXPECT_FALSE(stats.m_string.is_sequence());
405 EXPECT_TRUE(stats.m_sequence_bool.is_sequence());
406 EXPECT_TRUE(stats.m_sequence_int32.is_sequence());
407 EXPECT_TRUE(stats.m_sequence_uint32.is_sequence());
408 EXPECT_TRUE(stats.m_sequence_int64.is_sequence());
409 EXPECT_TRUE(stats.m_sequence_uint64.is_sequence());
410 EXPECT_TRUE(stats.m_sequence_double.is_sequence());
411 EXPECT_TRUE(stats.m_sequence_string.is_sequence());
412 EXPECT_FALSE(stats.m_map_string_uint64.is_sequence());
413 EXPECT_FALSE(stats.m_map_string_double.is_sequence());
414 }
415
TEST(RTCStatsTest,Type)416 TEST(RTCStatsTest, Type) {
417 RTCTestStats stats("statsId", 42);
418 EXPECT_EQ(RTCStatsMemberInterface::kBool, stats.m_bool.type());
419 EXPECT_EQ(RTCStatsMemberInterface::kInt32, stats.m_int32.type());
420 EXPECT_EQ(RTCStatsMemberInterface::kUint32, stats.m_uint32.type());
421 EXPECT_EQ(RTCStatsMemberInterface::kInt64, stats.m_int64.type());
422 EXPECT_EQ(RTCStatsMemberInterface::kUint64, stats.m_uint64.type());
423 EXPECT_EQ(RTCStatsMemberInterface::kDouble, stats.m_double.type());
424 EXPECT_EQ(RTCStatsMemberInterface::kString, stats.m_string.type());
425 EXPECT_EQ(RTCStatsMemberInterface::kSequenceBool,
426 stats.m_sequence_bool.type());
427 EXPECT_EQ(RTCStatsMemberInterface::kSequenceInt32,
428 stats.m_sequence_int32.type());
429 EXPECT_EQ(RTCStatsMemberInterface::kSequenceUint32,
430 stats.m_sequence_uint32.type());
431 EXPECT_EQ(RTCStatsMemberInterface::kSequenceInt64,
432 stats.m_sequence_int64.type());
433 EXPECT_EQ(RTCStatsMemberInterface::kSequenceUint64,
434 stats.m_sequence_uint64.type());
435 EXPECT_EQ(RTCStatsMemberInterface::kSequenceDouble,
436 stats.m_sequence_double.type());
437 EXPECT_EQ(RTCStatsMemberInterface::kSequenceString,
438 stats.m_sequence_string.type());
439 EXPECT_EQ(RTCStatsMemberInterface::kMapStringUint64,
440 stats.m_map_string_uint64.type());
441 EXPECT_EQ(RTCStatsMemberInterface::kMapStringDouble,
442 stats.m_map_string_double.type());
443 }
444
TEST(RTCStatsTest,IsString)445 TEST(RTCStatsTest, IsString) {
446 RTCTestStats stats("statsId", 42);
447 EXPECT_TRUE(stats.m_string.is_string());
448 EXPECT_FALSE(stats.m_bool.is_string());
449 EXPECT_FALSE(stats.m_int32.is_string());
450 EXPECT_FALSE(stats.m_uint32.is_string());
451 EXPECT_FALSE(stats.m_int64.is_string());
452 EXPECT_FALSE(stats.m_uint64.is_string());
453 EXPECT_FALSE(stats.m_double.is_string());
454 EXPECT_FALSE(stats.m_sequence_bool.is_string());
455 EXPECT_FALSE(stats.m_sequence_int32.is_string());
456 EXPECT_FALSE(stats.m_sequence_uint32.is_string());
457 EXPECT_FALSE(stats.m_sequence_int64.is_string());
458 EXPECT_FALSE(stats.m_sequence_uint64.is_string());
459 EXPECT_FALSE(stats.m_sequence_double.is_string());
460 EXPECT_FALSE(stats.m_sequence_string.is_string());
461 EXPECT_FALSE(stats.m_map_string_uint64.is_string());
462 EXPECT_FALSE(stats.m_map_string_double.is_string());
463 }
464
TEST(RTCStatsTest,ValueToString)465 TEST(RTCStatsTest, ValueToString) {
466 RTCTestStats stats("statsId", 42);
467 stats.m_bool = true;
468 EXPECT_EQ("true", stats.m_bool.ValueToString());
469
470 stats.m_string = "foo";
471 EXPECT_EQ("foo", stats.m_string.ValueToString());
472 stats.m_int32 = -32;
473 EXPECT_EQ("-32", stats.m_int32.ValueToString());
474 stats.m_uint32 = 32;
475 EXPECT_EQ("32", stats.m_uint32.ValueToString());
476 stats.m_int64 = -64;
477 EXPECT_EQ("-64", stats.m_int64.ValueToString());
478 stats.m_uint64 = 64;
479 EXPECT_EQ("64", stats.m_uint64.ValueToString());
480 stats.m_double = 0.5;
481 EXPECT_EQ("0.5", stats.m_double.ValueToString());
482 stats.m_sequence_bool = {true, false};
483 EXPECT_EQ("[true,false]", stats.m_sequence_bool.ValueToString());
484 stats.m_sequence_int32 = {-32, 32};
485 EXPECT_EQ("[-32,32]", stats.m_sequence_int32.ValueToString());
486 stats.m_sequence_uint32 = {64, 32};
487 EXPECT_EQ("[64,32]", stats.m_sequence_uint32.ValueToString());
488 stats.m_sequence_int64 = {-64, 32};
489 EXPECT_EQ("[-64,32]", stats.m_sequence_int64.ValueToString());
490 stats.m_sequence_uint64 = {16, 32};
491 EXPECT_EQ("[16,32]", stats.m_sequence_uint64.ValueToString());
492 stats.m_sequence_double = {0.5, 0.25};
493 EXPECT_EQ("[0.5,0.25]", stats.m_sequence_double.ValueToString());
494 stats.m_sequence_string = {"foo", "bar"};
495 EXPECT_EQ("[\"foo\",\"bar\"]", stats.m_sequence_string.ValueToString());
496 stats.m_map_string_uint64 = std::map<std::string, uint64_t>();
497 stats.m_map_string_uint64->emplace("foo", 32);
498 stats.m_map_string_uint64->emplace("bar", 64);
499 EXPECT_EQ("{bar:64,foo:32}", stats.m_map_string_uint64.ValueToString());
500 stats.m_map_string_double = std::map<std::string, double>();
501 stats.m_map_string_double->emplace("foo", 0.5);
502 stats.m_map_string_double->emplace("bar", 0.25);
503 EXPECT_EQ("{bar:0.25,foo:0.5}", stats.m_map_string_double.ValueToString());
504 }
505
TEST(RTCStatsTest,RestrictedStatsTest)506 TEST(RTCStatsTest, RestrictedStatsTest) {
507 RTCStatsMember<bool> unrestricted("unrestricted");
508 EXPECT_EQ(unrestricted.exposure_criteria(), StatExposureCriteria::kAlways);
509 RTCRestrictedStatsMember<bool, StatExposureCriteria::kHardwareCapability>
510 restricted("restricted");
511 EXPECT_EQ(restricted.exposure_criteria(),
512 StatExposureCriteria::kHardwareCapability);
513
514 unrestricted = true;
515 restricted = true;
516 EXPECT_NE(unrestricted, restricted)
517 << "These can not be equal as they have different exposure criteria.";
518 }
519
TEST(RTCStatsTest,NonStandardGroupId)520 TEST(RTCStatsTest, NonStandardGroupId) {
521 auto group_id = NonStandardGroupId::kGroupIdForTesting;
522 RTCNonStandardStatsMember<int32_t> with_group_id("stat", {group_id});
523 std::vector<NonStandardGroupId> expected_ids({group_id});
524 EXPECT_EQ(expected_ids, with_group_id.group_ids());
525
526 RTCNonStandardStatsMember<int32_t> without_group_id("stat");
527 EXPECT_TRUE(without_group_id.group_ids().empty());
528 }
529
530 // Death tests.
531 // Disabled on Android because death tests misbehave on Android, see
532 // base/test/gtest_util.h.
533 #if RTC_DCHECK_IS_ON && GTEST_HAS_DEATH_TEST && !defined(WEBRTC_ANDROID)
534
TEST(RTCStatsDeathTest,ValueOfUndefinedMember)535 TEST(RTCStatsDeathTest, ValueOfUndefinedMember) {
536 RTCTestStats stats("testId", 0.0);
537 EXPECT_FALSE(stats.m_int32.is_defined());
538 EXPECT_DEATH(*stats.m_int32, "");
539 }
540
TEST(RTCStatsDeathTest,InvalidCasting)541 TEST(RTCStatsDeathTest, InvalidCasting) {
542 RTCGrandChildStats stats("grandchild", 0.0);
543 EXPECT_DEATH(stats.cast_to<RTCChildStats>(), "");
544 }
545
546 #endif // RTC_DCHECK_IS_ON && GTEST_HAS_DEATH_TEST && !defined(WEBRTC_ANDROID)
547
548 } // namespace webrtc
549