OLD | NEW |
(Empty) | |
| 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 "webrtc/api/rtcstats.h" |
| 12 #include "webrtc/api/rtcstatsreport.h" |
| 13 |
| 14 #include "webrtc/base/checks.h" |
| 15 #include "webrtc/base/gunit.h" |
| 16 #include "webrtc/base/logging.h" |
| 17 |
| 18 namespace webrtc { |
| 19 |
| 20 class RTCTestStats : public RTCStats { |
| 21 public: |
| 22 RTCTestStats(const std::string& id, double timestamp) |
| 23 : RTCStats(id, timestamp), |
| 24 m_int32("mInt32"), |
| 25 m_uint32("mUint32"), |
| 26 m_int64("mInt64"), |
| 27 m_uint64("mUint64"), |
| 28 m_double("mDouble"), |
| 29 m_static_string("mStaticString"), |
| 30 m_string("mString"), |
| 31 m_sequence_int32("mSequenceInt32"), |
| 32 m_sequence_uint32("mSequenceUint32"), |
| 33 m_sequence_int64("mSequenceInt64"), |
| 34 m_sequence_uint64("mSequenceUint64"), |
| 35 m_sequence_double("mSequenceDouble"), |
| 36 m_sequence_static_string("mSequenceStaticString"), |
| 37 m_sequence_string("mSequenceString") { |
| 38 } |
| 39 |
| 40 WEBRTC_RTCSTATS_IMPL(RTCStats, RTCTestStats, |
| 41 &m_int32, |
| 42 &m_uint32, |
| 43 &m_int64, |
| 44 &m_uint64, |
| 45 &m_double, |
| 46 &m_static_string, |
| 47 &m_string, |
| 48 &m_sequence_int32, |
| 49 &m_sequence_uint32, |
| 50 &m_sequence_int64, |
| 51 &m_sequence_uint64, |
| 52 &m_sequence_double, |
| 53 &m_sequence_static_string, |
| 54 &m_sequence_string); |
| 55 |
| 56 RTCStatsMember<int32_t> m_int32; |
| 57 RTCStatsMember<uint32_t> m_uint32; |
| 58 RTCStatsMember<int64_t> m_int64; |
| 59 RTCStatsMember<uint64_t> m_uint64; |
| 60 RTCStatsMember<double> m_double; |
| 61 RTCStatsMember<const char*> m_static_string; |
| 62 RTCStatsMember<std::string> m_string; |
| 63 |
| 64 RTCStatsMember<std::vector<int32_t>> m_sequence_int32; |
| 65 RTCStatsMember<std::vector<uint32_t>> m_sequence_uint32; |
| 66 RTCStatsMember<std::vector<int64_t>> m_sequence_int64; |
| 67 RTCStatsMember<std::vector<uint64_t>> m_sequence_uint64; |
| 68 RTCStatsMember<std::vector<double>> m_sequence_double; |
| 69 RTCStatsMember<std::vector<const char*>> m_sequence_static_string; |
| 70 RTCStatsMember<std::vector<std::string>> m_sequence_string; |
| 71 }; |
| 72 |
| 73 const char RTCTestStats::kType[] = "test-stats"; |
| 74 |
| 75 class RTCChildStats : public RTCStats { |
| 76 public: |
| 77 RTCChildStats(const std::string& id, double timestamp) |
| 78 : RTCStats(id, timestamp), |
| 79 child_int("childInt") {} |
| 80 |
| 81 WEBRTC_RTCSTATS_IMPL(RTCStats, RTCChildStats, |
| 82 &child_int); |
| 83 |
| 84 RTCStatsMember<int32_t> child_int; |
| 85 }; |
| 86 |
| 87 const char RTCChildStats::kType[] = "child-stats"; |
| 88 |
| 89 class RTCGrandChildStats : public RTCChildStats { |
| 90 public: |
| 91 RTCGrandChildStats(const std::string& id, double timestamp) |
| 92 : RTCChildStats(id, timestamp), |
| 93 grandchild_int("grandchildInt") {} |
| 94 |
| 95 WEBRTC_RTCSTATS_IMPL(RTCChildStats, RTCGrandChildStats, |
| 96 &grandchild_int); |
| 97 |
| 98 RTCStatsMember<int32_t> grandchild_int; |
| 99 }; |
| 100 |
| 101 const char RTCGrandChildStats::kType[] = "grandchild-stats"; |
| 102 |
| 103 TEST(RTCStatsTest, RTCStatsAndMembers) { |
| 104 RTCTestStats stats("testId", 42.0); |
| 105 EXPECT_EQ(stats.id(), "testId"); |
| 106 EXPECT_EQ(stats.timestamp(), 42.0); |
| 107 std::vector<const RTCStatsMemberInterface*> members = stats.Members(); |
| 108 EXPECT_EQ(members.size(), static_cast<size_t>(14)); |
| 109 for (const RTCStatsMemberInterface* member : members) { |
| 110 EXPECT_FALSE(member->is_defined()); |
| 111 } |
| 112 stats.m_int32 = 123; |
| 113 stats.m_uint32 = 123; |
| 114 stats.m_int64 = 123; |
| 115 stats.m_uint64 = 123; |
| 116 stats.m_double = 123.0; |
| 117 stats.m_static_string = "123"; |
| 118 stats.m_string = std::string("123"); |
| 119 stats.m_sequence_int32 = std::vector<int32_t>(); |
| 120 stats.m_sequence_uint32 = std::vector<uint32_t>(); |
| 121 EXPECT_FALSE(stats.m_sequence_int64.is_defined()); |
| 122 stats.m_sequence_int64 = std::vector<int64_t>(); |
| 123 stats.m_sequence_uint64 = std::vector<uint64_t>(); |
| 124 stats.m_sequence_double = std::vector<double>(); |
| 125 stats.m_sequence_static_string = std::vector<const char*>(); |
| 126 stats.m_sequence_string = std::vector<std::string>(); |
| 127 for (const RTCStatsMemberInterface* member : members) { |
| 128 EXPECT_TRUE(member->is_defined()); |
| 129 } |
| 130 EXPECT_EQ(*stats.m_int32, static_cast<int32_t>(123)); |
| 131 EXPECT_EQ(*stats.m_uint32, static_cast<uint32_t>(123)); |
| 132 EXPECT_EQ(*stats.m_int64, static_cast<int64_t>(123)); |
| 133 EXPECT_EQ(*stats.m_uint64, static_cast<uint64_t>(123)); |
| 134 EXPECT_EQ(*stats.m_double, 123.0); |
| 135 EXPECT_EQ(*stats.m_static_string, "123"); |
| 136 EXPECT_EQ(*stats.m_string, std::string("123")); |
| 137 EXPECT_EQ(*stats.m_sequence_int32, std::vector<int32_t>()); |
| 138 EXPECT_EQ(*stats.m_sequence_uint32, std::vector<uint32_t>()); |
| 139 EXPECT_EQ(*stats.m_sequence_int64, std::vector<int64_t>()); |
| 140 EXPECT_EQ(*stats.m_sequence_uint64, std::vector<uint64_t>()); |
| 141 EXPECT_EQ(*stats.m_sequence_double, std::vector<double>()); |
| 142 EXPECT_EQ(*stats.m_sequence_static_string, std::vector<const char*>()); |
| 143 EXPECT_EQ(*stats.m_sequence_string, std::vector<std::string>()); |
| 144 int32_t numbers[] = { 4, 8, 15, 16, 23, 42 }; |
| 145 std::vector<int32_t> numbers_sequence(&numbers[0], &numbers[5]); |
| 146 stats.m_sequence_int32->insert(stats.m_sequence_int32->end(), |
| 147 numbers_sequence.begin(), |
| 148 numbers_sequence.end()); |
| 149 EXPECT_EQ(*stats.m_sequence_int32, numbers_sequence); |
| 150 } |
| 151 |
| 152 TEST(RTCStatsTest, RTCStatsGrandChild) { |
| 153 RTCGrandChildStats stats("grandchild", 0.0); |
| 154 stats.child_int = 1; |
| 155 stats.grandchild_int = 2; |
| 156 int32_t sum = 0; |
| 157 for (const RTCStatsMemberInterface* member : stats.Members()) { |
| 158 sum += *member->cast_to<const RTCStatsMember<int32_t>>(); |
| 159 } |
| 160 EXPECT_EQ(sum, static_cast<int32_t>(3)); |
| 161 |
| 162 std::unique_ptr<RTCStats> copy_ptr = stats.copy(); |
| 163 const RTCGrandChildStats& copy = copy_ptr->cast_to<RTCGrandChildStats>(); |
| 164 EXPECT_EQ(*copy.child_int, *stats.child_int); |
| 165 EXPECT_EQ(*copy.grandchild_int, *stats.grandchild_int); |
| 166 } |
| 167 |
| 168 TEST(RTCStatsTest, TestRTCStatsReport) { |
| 169 rtc::scoped_refptr<RTCStatsReport> report = RTCStatsReport::Create(); |
| 170 EXPECT_EQ(report->size(), static_cast<size_t>(0)); |
| 171 report->AddStats(std::unique_ptr<RTCStats>(new RTCTestStats("a0", 1.0))); |
| 172 report->AddStats(std::unique_ptr<RTCStats>(new RTCTestStats("a1", 2.0))); |
| 173 report->AddStats(std::unique_ptr<RTCStats>(new RTCChildStats("b0", 4.0))); |
| 174 report->AddStats(std::unique_ptr<RTCStats>(new RTCChildStats("b1", 8.0))); |
| 175 report->AddStats(std::unique_ptr<RTCStats>(new RTCTestStats("a2", 16.0))); |
| 176 report->AddStats(std::unique_ptr<RTCStats>(new RTCChildStats("b2", 32.0))); |
| 177 EXPECT_EQ(report->size(), static_cast<size_t>(6)); |
| 178 |
| 179 EXPECT_EQ((*report)["missing"], nullptr); |
| 180 EXPECT_EQ((*report)["a0"]->id(), "a0"); |
| 181 EXPECT_EQ((*report)["b2"]->id(), "b2"); |
| 182 |
| 183 std::vector<const RTCTestStats*> a = report->GetStatsOfType<RTCTestStats>(); |
| 184 EXPECT_EQ(a.size(), static_cast<size_t>(3)); |
| 185 uint32_t mask = 0; |
| 186 for (const RTCTestStats* stats : a) |
| 187 mask |= static_cast<uint32_t>(stats->timestamp()); |
| 188 EXPECT_EQ(mask, static_cast<uint32_t>(1 | 2 | 16)); |
| 189 |
| 190 std::vector<const RTCChildStats*> b = report->GetStatsOfType<RTCChildStats>(); |
| 191 EXPECT_EQ(b.size(), static_cast<size_t>(3)); |
| 192 mask = 0; |
| 193 for (const RTCChildStats* stats : b) |
| 194 mask |= static_cast<uint32_t>(stats->timestamp()); |
| 195 EXPECT_EQ(mask, static_cast<uint32_t>(4 | 8 | 32)); |
| 196 |
| 197 EXPECT_EQ(report->GetStatsOfType<RTCGrandChildStats>().size(), |
| 198 static_cast<size_t>(0)); |
| 199 } |
| 200 |
| 201 // Death tests. |
| 202 // Disabled on Android because death tests misbehave on Android, see |
| 203 // base/test/gtest_util.h. |
| 204 #if RTC_DCHECK_IS_ON && GTEST_HAS_DEATH_TEST && !defined(WEBRTC_ANDROID) |
| 205 |
| 206 TEST(RTCStatsDeathTest, ValueOfUndefinedMember) { |
| 207 RTCTestStats stats("testId", 0.0); |
| 208 EXPECT_FALSE(stats.m_int32.is_defined()); |
| 209 EXPECT_DEATH(*stats.m_int32, ""); |
| 210 } |
| 211 |
| 212 TEST(RTCStatsDeathTest, InvalidCasting) { |
| 213 RTCGrandChildStats stats("grandchild", 0.0); |
| 214 EXPECT_DEATH(stats.cast_to<RTCChildStats>(), ""); |
| 215 } |
| 216 |
| 217 #endif // RTC_DCHECK_IS_ON && GTEST_HAS_DEATH_TEST && !defined(WEBRTC_ANDROID) |
| 218 |
| 219 } // namespace webrtc |
OLD | NEW |