henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 1 | /* |
kjellander | b24317b | 2016-02-10 15:54:43 | [diff] [blame] | 2 | * Copyright 2014 The WebRTC project authors. All Rights Reserved. |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 3 | * |
kjellander | b24317b | 2016-02-10 15:54:43 | [diff] [blame] | 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. |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 9 | */ |
| 10 | |
Jonas Olsson | a4d8737 | 2019-07-05 17:08:33 | [diff] [blame] | 11 | #include "pc/stats_collector.h" |
| 12 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 13 | #include <stdio.h> |
Jonas Olsson | a4d8737 | 2019-07-05 17:08:33 | [diff] [blame] | 14 | |
Harald Alvestrand | c24a218 | 2022-02-23 13:44:59 | [diff] [blame^] | 15 | #include <cstdint> |
deadbeef | cbecd35 | 2015-09-23 18:50:27 | [diff] [blame] | 16 | |
Steve Anton | 64b626b | 2019-01-29 01:25:26 | [diff] [blame] | 17 | #include "absl/algorithm/container.h" |
Yves Gerey | 3e70781 | 2018-11-28 15:47:49 | [diff] [blame] | 18 | #include "absl/types/optional.h" |
| 19 | #include "api/audio_codecs/audio_encoder.h" |
| 20 | #include "api/candidate.h" |
Steve Anton | 10542f2 | 2019-01-11 17:11:00 | [diff] [blame] | 21 | #include "api/data_channel_interface.h" |
Harald Alvestrand | 9cb42c8 | 2020-10-11 13:03:47 | [diff] [blame] | 22 | #include "api/media_stream_track.h" |
Harald Alvestrand | c24a218 | 2022-02-23 13:44:59 | [diff] [blame^] | 23 | #include "api/media_types.h" |
| 24 | #include "api/rtp_sender_interface.h" |
Mirko Bonadei | d970807 | 2019-01-25 19:26:48 | [diff] [blame] | 25 | #include "api/scoped_refptr.h" |
Yves Gerey | 3e70781 | 2018-11-28 15:47:49 | [diff] [blame] | 26 | #include "call/call.h" |
Steve Anton | 10542f2 | 2019-01-11 17:11:00 | [diff] [blame] | 27 | #include "media/base/media_channel.h" |
Yves Gerey | 3e70781 | 2018-11-28 15:47:49 | [diff] [blame] | 28 | #include "modules/audio_processing/include/audio_processing_statistics.h" |
Harald Alvestrand | c24a218 | 2022-02-23 13:44:59 | [diff] [blame^] | 29 | #include "p2p/base/ice_transport_internal.h" |
Steve Anton | 10542f2 | 2019-01-11 17:11:00 | [diff] [blame] | 30 | #include "pc/media_stream.h" |
Harald Alvestrand | c24a218 | 2022-02-23 13:44:59 | [diff] [blame^] | 31 | #include "pc/rtp_receiver.h" |
| 32 | #include "pc/rtp_sender.h" |
Taylor Brandstetter | 3a034e1 | 2020-07-09 22:32:34 | [diff] [blame] | 33 | #include "pc/sctp_data_channel.h" |
Steve Anton | 10542f2 | 2019-01-11 17:11:00 | [diff] [blame] | 34 | #include "pc/test/fake_peer_connection_for_stats.h" |
| 35 | #include "pc/test/fake_video_track_source.h" |
Steve Anton | efe4c92 | 2019-03-27 17:26:06 | [diff] [blame] | 36 | #include "pc/test/mock_rtp_receiver_internal.h" |
| 37 | #include "pc/test/mock_rtp_sender_internal.h" |
Steve Anton | 10542f2 | 2019-01-11 17:11:00 | [diff] [blame] | 38 | #include "pc/transport_stats.h" |
| 39 | #include "pc/video_track.h" |
| 40 | #include "rtc_base/fake_ssl_identity.h" |
| 41 | #include "rtc_base/message_digest.h" |
| 42 | #include "rtc_base/net_helper.h" |
| 43 | #include "rtc_base/ref_counted_object.h" |
| 44 | #include "rtc_base/rtc_certificate.h" |
Steve Anton | 10542f2 | 2019-01-11 17:11:00 | [diff] [blame] | 45 | #include "rtc_base/socket_address.h" |
| 46 | #include "rtc_base/ssl_identity.h" |
| 47 | #include "rtc_base/ssl_stream_adapter.h" |
| 48 | #include "rtc_base/string_encode.h" |
Artem Titov | a76af0c | 2018-07-23 15:38:12 | [diff] [blame] | 49 | #include "rtc_base/third_party/base64/base64.h" |
Yves Gerey | 3e70781 | 2018-11-28 15:47:49 | [diff] [blame] | 50 | #include "rtc_base/thread.h" |
Harald Alvestrand | c24a218 | 2022-02-23 13:44:59 | [diff] [blame^] | 51 | #include "test/gmock.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 04:47:31 | [diff] [blame] | 52 | #include "test/gtest.h" |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 53 | |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 54 | using cricket::ConnectionInfo; |
| 55 | using cricket::SsrcReceiverInfo; |
| 56 | using cricket::TransportChannelStats; |
| 57 | using cricket::VideoMediaInfo; |
| 58 | using cricket::VideoReceiverInfo; |
| 59 | using cricket::VideoSenderInfo; |
| 60 | using cricket::VoiceMediaInfo; |
| 61 | using cricket::VoiceReceiverInfo; |
| 62 | using cricket::VoiceSenderInfo; |
Tomas Gunnarsson | 16de216 | 2022-01-26 09:21:57 | [diff] [blame] | 63 | using ::testing::_; |
| 64 | using ::testing::AtMost; |
Steve Anton | efe4c92 | 2019-03-27 17:26:06 | [diff] [blame] | 65 | using ::testing::Return; |
| 66 | using ::testing::UnorderedElementsAre; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 67 | |
guoweis@webrtc.org | 950c518 | 2014-12-16 23:01:31 | [diff] [blame] | 68 | namespace webrtc { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 69 | |
tkchin | 7d06a8c | 2016-04-04 21:10:43 | [diff] [blame] | 70 | namespace internal { |
| 71 | // This value comes from openssl/tls1.h |
| 72 | static const int TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA = 0xC014; |
| 73 | } // namespace internal |
| 74 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 75 | // Error return values |
| 76 | const char kNotFound[] = "NOT FOUND"; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 77 | |
wu@webrtc.org | 97077a3 | 2013-10-25 21:18:33 | [diff] [blame] | 78 | // Constant names for track identification. |
xians@webrtc.org | 4cb0128 | 2014-06-12 14:57:05 | [diff] [blame] | 79 | const char kLocalTrackId[] = "local_track_id"; |
| 80 | const char kRemoteTrackId[] = "remote_track_id"; |
Peter Boström | 0c4e06b | 2015-10-07 10:23:21 | [diff] [blame] | 81 | const uint32_t kSsrcOfTrack = 1234; |
wu@webrtc.org | 97077a3 | 2013-10-25 21:18:33 | [diff] [blame] | 82 | |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 83 | class FakeAudioProcessor : public AudioProcessorInterface { |
henrike@webrtc.org | 40b3b68 | 2014-03-03 18:30:11 | [diff] [blame] | 84 | public: |
| 85 | FakeAudioProcessor() {} |
| 86 | ~FakeAudioProcessor() {} |
| 87 | |
| 88 | private: |
Ivo Creusen | ae026096 | 2017-11-20 12:07:16 | [diff] [blame] | 89 | AudioProcessorInterface::AudioProcessorStatistics GetStats( |
Ivo Creusen | 56d46090 | 2017-11-24 16:29:59 | [diff] [blame] | 90 | bool has_recv_streams) override { |
Ivo Creusen | ae026096 | 2017-11-20 12:07:16 | [diff] [blame] | 91 | AudioProcessorStatistics stats; |
| 92 | stats.typing_noise_detected = true; |
Ivo Creusen | 56d46090 | 2017-11-24 16:29:59 | [diff] [blame] | 93 | if (has_recv_streams) { |
| 94 | stats.apm_statistics.echo_return_loss = 2.0; |
| 95 | stats.apm_statistics.echo_return_loss_enhancement = 3.0; |
| 96 | stats.apm_statistics.delay_median_ms = 4; |
| 97 | stats.apm_statistics.delay_standard_deviation_ms = 5; |
| 98 | } |
Ivo Creusen | ae026096 | 2017-11-20 12:07:16 | [diff] [blame] | 99 | return stats; |
| 100 | } |
henrike@webrtc.org | 40b3b68 | 2014-03-03 18:30:11 | [diff] [blame] | 101 | }; |
| 102 | |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 103 | class FakeAudioTrack : public MediaStreamTrack<AudioTrackInterface> { |
henrike@webrtc.org | 40b3b68 | 2014-03-03 18:30:11 | [diff] [blame] | 104 | public: |
xians@webrtc.org | 4cb0128 | 2014-06-12 14:57:05 | [diff] [blame] | 105 | explicit FakeAudioTrack(const std::string& id) |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 106 | : MediaStreamTrack<AudioTrackInterface>(id), |
Tommi | 87f7090 | 2021-04-27 12:43:08 | [diff] [blame] | 107 | processor_(rtc::make_ref_counted<FakeAudioProcessor>()) {} |
kjellander@webrtc.org | 14665ff | 2015-03-04 12:58:35 | [diff] [blame] | 108 | std::string kind() const override { return "audio"; } |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 109 | AudioSourceInterface* GetSource() const override { return NULL; } |
| 110 | void AddSink(AudioTrackSinkInterface* sink) override {} |
| 111 | void RemoveSink(AudioTrackSinkInterface* sink) override {} |
kjellander@webrtc.org | 14665ff | 2015-03-04 12:58:35 | [diff] [blame] | 112 | bool GetSignalLevel(int* level) override { |
henrike@webrtc.org | 40b3b68 | 2014-03-03 18:30:11 | [diff] [blame] | 113 | *level = 1; |
| 114 | return true; |
| 115 | } |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 116 | rtc::scoped_refptr<AudioProcessorInterface> GetAudioProcessor() override { |
henrike@webrtc.org | b90991d | 2014-03-04 19:54:57 | [diff] [blame] | 117 | return processor_; |
henrike@webrtc.org | 40b3b68 | 2014-03-03 18:30:11 | [diff] [blame] | 118 | } |
| 119 | |
| 120 | private: |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 | [diff] [blame] | 121 | rtc::scoped_refptr<FakeAudioProcessor> processor_; |
henrike@webrtc.org | 40b3b68 | 2014-03-03 18:30:11 | [diff] [blame] | 122 | }; |
| 123 | |
zhihuang | 6ba3b19 | 2016-05-13 18:46:35 | [diff] [blame] | 124 | // This fake audio processor is used to verify that the undesired initial values |
| 125 | // (-1) will be filtered out. |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 126 | class FakeAudioProcessorWithInitValue : public AudioProcessorInterface { |
zhihuang | 6ba3b19 | 2016-05-13 18:46:35 | [diff] [blame] | 127 | public: |
| 128 | FakeAudioProcessorWithInitValue() {} |
| 129 | ~FakeAudioProcessorWithInitValue() {} |
| 130 | |
| 131 | private: |
Ivo Creusen | ae026096 | 2017-11-20 12:07:16 | [diff] [blame] | 132 | AudioProcessorInterface::AudioProcessorStatistics GetStats( |
| 133 | bool /*has_recv_streams*/) override { |
| 134 | AudioProcessorStatistics stats; |
| 135 | stats.typing_noise_detected = false; |
| 136 | return stats; |
| 137 | } |
zhihuang | 6ba3b19 | 2016-05-13 18:46:35 | [diff] [blame] | 138 | }; |
| 139 | |
| 140 | class FakeAudioTrackWithInitValue |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 141 | : public MediaStreamTrack<AudioTrackInterface> { |
zhihuang | 6ba3b19 | 2016-05-13 18:46:35 | [diff] [blame] | 142 | public: |
| 143 | explicit FakeAudioTrackWithInitValue(const std::string& id) |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 144 | : MediaStreamTrack<AudioTrackInterface>(id), |
Tommi | 87f7090 | 2021-04-27 12:43:08 | [diff] [blame] | 145 | processor_(rtc::make_ref_counted<FakeAudioProcessorWithInitValue>()) {} |
zhihuang | 6ba3b19 | 2016-05-13 18:46:35 | [diff] [blame] | 146 | std::string kind() const override { return "audio"; } |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 147 | AudioSourceInterface* GetSource() const override { return NULL; } |
| 148 | void AddSink(AudioTrackSinkInterface* sink) override {} |
| 149 | void RemoveSink(AudioTrackSinkInterface* sink) override {} |
zhihuang | 6ba3b19 | 2016-05-13 18:46:35 | [diff] [blame] | 150 | bool GetSignalLevel(int* level) override { |
| 151 | *level = 1; |
| 152 | return true; |
| 153 | } |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 154 | rtc::scoped_refptr<AudioProcessorInterface> GetAudioProcessor() override { |
zhihuang | 6ba3b19 | 2016-05-13 18:46:35 | [diff] [blame] | 155 | return processor_; |
| 156 | } |
| 157 | |
| 158 | private: |
| 159 | rtc::scoped_refptr<FakeAudioProcessorWithInitValue> processor_; |
| 160 | }; |
| 161 | |
henrike@webrtc.org | 40b3b68 | 2014-03-03 18:30:11 | [diff] [blame] | 162 | bool GetValue(const StatsReport* report, |
tommi@webrtc.org | 242068d | 2014-07-14 20:19:56 | [diff] [blame] | 163 | StatsReport::StatsValueName name, |
wu@webrtc.org | 4551b79 | 2013-10-09 15:37:36 | [diff] [blame] | 164 | std::string* value) { |
tommi@webrtc.org | 92f4018 | 2015-03-04 15:25:19 | [diff] [blame] | 165 | const StatsReport::Value* v = report->FindValue(name); |
| 166 | if (!v) |
| 167 | return false; |
| 168 | *value = v->ToString(); |
| 169 | return true; |
wu@webrtc.org | 4551b79 | 2013-10-09 15:37:36 | [diff] [blame] | 170 | } |
| 171 | |
tommi@webrtc.org | 4fb7e25 | 2015-01-21 11:36:18 | [diff] [blame] | 172 | std::string ExtractStatsValue(const StatsReport::StatsType& type, |
henrike@webrtc.org | 40b3b68 | 2014-03-03 18:30:11 | [diff] [blame] | 173 | const StatsReports& reports, |
tommi@webrtc.org | 242068d | 2014-07-14 20:19:56 | [diff] [blame] | 174 | StatsReport::StatsValueName name) { |
tommi@webrtc.org | 4fb7e25 | 2015-01-21 11:36:18 | [diff] [blame] | 175 | for (const auto* r : reports) { |
wu@webrtc.org | 4551b79 | 2013-10-09 15:37:36 | [diff] [blame] | 176 | std::string ret; |
tommi@webrtc.org | 4fb7e25 | 2015-01-21 11:36:18 | [diff] [blame] | 177 | if (r->type() == type && GetValue(r, name, &ret)) |
wu@webrtc.org | 4551b79 | 2013-10-09 15:37:36 | [diff] [blame] | 178 | return ret; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 179 | } |
| 180 | |
| 181 | return kNotFound; |
| 182 | } |
| 183 | |
tommi@webrtc.org | d390029 | 2015-03-12 16:35:55 | [diff] [blame] | 184 | StatsReport::Id TypedIdFromIdString(StatsReport::StatsType type, |
| 185 | const std::string& value) { |
tommi@webrtc.org | 4fb7e25 | 2015-01-21 11:36:18 | [diff] [blame] | 186 | EXPECT_FALSE(value.empty()); |
tommi@webrtc.org | d390029 | 2015-03-12 16:35:55 | [diff] [blame] | 187 | StatsReport::Id id; |
tommi@webrtc.org | 4fb7e25 | 2015-01-21 11:36:18 | [diff] [blame] | 188 | if (value.empty()) |
tommi@webrtc.org | d390029 | 2015-03-12 16:35:55 | [diff] [blame] | 189 | return id; |
tommi@webrtc.org | 4fb7e25 | 2015-01-21 11:36:18 | [diff] [blame] | 190 | |
| 191 | // This has assumptions about how the ID is constructed. As is, this is |
| 192 | // OK since this is for testing purposes only, but if we ever need this |
| 193 | // in production, we should add a generic method that does this. |
| 194 | size_t index = value.find('_'); |
| 195 | EXPECT_NE(index, std::string::npos); |
| 196 | if (index == std::string::npos || index == (value.length() - 1)) |
tommi@webrtc.org | d390029 | 2015-03-12 16:35:55 | [diff] [blame] | 197 | return id; |
tommi@webrtc.org | 4fb7e25 | 2015-01-21 11:36:18 | [diff] [blame] | 198 | |
| 199 | id = StatsReport::NewTypedId(type, value.substr(index + 1)); |
| 200 | EXPECT_EQ(id->ToString(), value); |
tommi@webrtc.org | d390029 | 2015-03-12 16:35:55 | [diff] [blame] | 201 | return id; |
tommi@webrtc.org | 4fb7e25 | 2015-01-21 11:36:18 | [diff] [blame] | 202 | } |
| 203 | |
tommi@webrtc.org | d390029 | 2015-03-12 16:35:55 | [diff] [blame] | 204 | StatsReport::Id IdFromCertIdString(const std::string& cert_id) { |
| 205 | return TypedIdFromIdString(StatsReport::kStatsReportTypeCertificate, cert_id); |
tommi@webrtc.org | 4fb7e25 | 2015-01-21 11:36:18 | [diff] [blame] | 206 | } |
| 207 | |
Artem Titov | 880fa81 | 2021-07-30 20:30:23 | [diff] [blame] | 208 | // Finds the `n`-th report of type `type` in `reports`. |
| 209 | // `n` starts from 1 for finding the first report. |
Yves Gerey | 665174f | 2018-06-19 13:03:05 | [diff] [blame] | 210 | const StatsReport* FindNthReportByType(const StatsReports& reports, |
| 211 | const StatsReport::StatsType& type, |
| 212 | int n) { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 213 | for (size_t i = 0; i < reports.size(); ++i) { |
tommi@webrtc.org | 4fb7e25 | 2015-01-21 11:36:18 | [diff] [blame] | 214 | if (reports[i]->type() == type) { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 215 | n--; |
| 216 | if (n == 0) |
tommi@webrtc.org | 5b06b06 | 2014-08-15 08:38:30 | [diff] [blame] | 217 | return reports[i]; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 218 | } |
| 219 | } |
tommi@webrtc.org | 4fb7e25 | 2015-01-21 11:36:18 | [diff] [blame] | 220 | return nullptr; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 221 | } |
| 222 | |
Artem Titov | 880fa81 | 2021-07-30 20:30:23 | [diff] [blame] | 223 | // Returns the value of the stat identified by `name` in the `n`-th report of |
| 224 | // type `type` in `reports`. |
| 225 | // `n` starts from 1 for finding the first report. |
| 226 | // If either the `n`-th report is not found, or the stat is not present in that |
Steve Anton | efe4c92 | 2019-03-27 17:26:06 | [diff] [blame] | 227 | // report, then nullopt is returned. |
| 228 | absl::optional<std::string> GetValueInNthReportByType( |
| 229 | const StatsReports& reports, |
| 230 | StatsReport::StatsType type, |
| 231 | StatsReport::StatsValueName name, |
| 232 | int n) { |
| 233 | const StatsReport* report = FindNthReportByType(reports, type, n); |
| 234 | if (!report) { |
| 235 | return absl::nullopt; |
| 236 | } |
| 237 | std::string value; |
| 238 | if (!GetValue(report, name, &value)) { |
| 239 | return absl::nullopt; |
| 240 | } |
| 241 | return value; |
| 242 | } |
| 243 | |
| 244 | std::vector<const StatsReport*> GetReportsByType(const StatsReports& reports, |
| 245 | StatsReport::StatsType type) { |
| 246 | std::vector<const StatsReport*> filtered_reports; |
| 247 | for (const StatsReport* report : reports) { |
| 248 | if (report->type() == type) { |
| 249 | filtered_reports.push_back(report); |
| 250 | } |
| 251 | } |
| 252 | return filtered_reports; |
| 253 | } |
| 254 | |
henrike@webrtc.org | 40b3b68 | 2014-03-03 18:30:11 | [diff] [blame] | 255 | const StatsReport* FindReportById(const StatsReports& reports, |
tommi@webrtc.org | 4fb7e25 | 2015-01-21 11:36:18 | [diff] [blame] | 256 | const StatsReport::Id& id) { |
tommi@webrtc.org | 8e327c4 | 2015-01-19 20:41:26 | [diff] [blame] | 257 | for (const auto* r : reports) { |
tommi@webrtc.org | d390029 | 2015-03-12 16:35:55 | [diff] [blame] | 258 | if (r->id()->Equals(id)) |
tommi@webrtc.org | 8e327c4 | 2015-01-19 20:41:26 | [diff] [blame] | 259 | return r; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 260 | } |
tommi@webrtc.org | 8e327c4 | 2015-01-19 20:41:26 | [diff] [blame] | 261 | return nullptr; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 262 | } |
| 263 | |
Mirko Bonadei | c61ce0d | 2017-11-21 16:04:20 | [diff] [blame] | 264 | std::string ExtractSsrcStatsValue(const StatsReports& reports, |
tommi@webrtc.org | 242068d | 2014-07-14 20:19:56 | [diff] [blame] | 265 | StatsReport::StatsValueName name) { |
tommi@webrtc.org | 4fb7e25 | 2015-01-21 11:36:18 | [diff] [blame] | 266 | return ExtractStatsValue(StatsReport::kStatsReportTypeSsrc, reports, name); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 267 | } |
| 268 | |
Mirko Bonadei | c61ce0d | 2017-11-21 16:04:20 | [diff] [blame] | 269 | std::string ExtractBweStatsValue(const StatsReports& reports, |
tommi@webrtc.org | 242068d | 2014-07-14 20:19:56 | [diff] [blame] | 270 | StatsReport::StatsValueName name) { |
Yves Gerey | 665174f | 2018-06-19 13:03:05 | [diff] [blame] | 271 | return ExtractStatsValue(StatsReport::kStatsReportTypeBwe, reports, name); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 272 | } |
| 273 | |
wu@webrtc.org | 4551b79 | 2013-10-09 15:37:36 | [diff] [blame] | 274 | std::string DerToPem(const std::string& der) { |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 | [diff] [blame] | 275 | return rtc::SSLIdentity::DerToPem( |
Yves Gerey | 665174f | 2018-06-19 13:03:05 | [diff] [blame] | 276 | rtc::kPemTypeCertificate, |
| 277 | reinterpret_cast<const unsigned char*>(der.c_str()), der.length()); |
wu@webrtc.org | 4551b79 | 2013-10-09 15:37:36 | [diff] [blame] | 278 | } |
| 279 | |
Yves Gerey | 665174f | 2018-06-19 13:03:05 | [diff] [blame] | 280 | std::vector<std::string> DersToPems(const std::vector<std::string>& ders) { |
wu@webrtc.org | 4551b79 | 2013-10-09 15:37:36 | [diff] [blame] | 281 | std::vector<std::string> pems(ders.size()); |
Steve Anton | 64b626b | 2019-01-29 01:25:26 | [diff] [blame] | 282 | absl::c_transform(ders, pems.begin(), DerToPem); |
wu@webrtc.org | 4551b79 | 2013-10-09 15:37:36 | [diff] [blame] | 283 | return pems; |
| 284 | } |
| 285 | |
henrike@webrtc.org | 40b3b68 | 2014-03-03 18:30:11 | [diff] [blame] | 286 | void CheckCertChainReports(const StatsReports& reports, |
wu@webrtc.org | 4551b79 | 2013-10-09 15:37:36 | [diff] [blame] | 287 | const std::vector<std::string>& ders, |
tommi@webrtc.org | 4fb7e25 | 2015-01-21 11:36:18 | [diff] [blame] | 288 | const StatsReport::Id& start_id) { |
tommi@webrtc.org | d390029 | 2015-03-12 16:35:55 | [diff] [blame] | 289 | StatsReport::Id cert_id; |
tommi@webrtc.org | 4fb7e25 | 2015-01-21 11:36:18 | [diff] [blame] | 290 | const StatsReport::Id* certificate_id = &start_id; |
wu@webrtc.org | 4551b79 | 2013-10-09 15:37:36 | [diff] [blame] | 291 | size_t i = 0; |
| 292 | while (true) { |
tommi@webrtc.org | 4fb7e25 | 2015-01-21 11:36:18 | [diff] [blame] | 293 | const StatsReport* report = FindReportById(reports, *certificate_id); |
wu@webrtc.org | 4551b79 | 2013-10-09 15:37:36 | [diff] [blame] | 294 | ASSERT_TRUE(report != NULL); |
mallinath@webrtc.org | 19f27e6 | 2013-10-13 17:18:27 | [diff] [blame] | 295 | |
wu@webrtc.org | 4551b79 | 2013-10-09 15:37:36 | [diff] [blame] | 296 | std::string der_base64; |
Yves Gerey | 665174f | 2018-06-19 13:03:05 | [diff] [blame] | 297 | EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameDer, &der_base64)); |
tommi@webrtc.org | 4fb7e25 | 2015-01-21 11:36:18 | [diff] [blame] | 298 | std::string der = rtc::Base64::Decode(der_base64, rtc::Base64::DO_STRICT); |
wu@webrtc.org | 4551b79 | 2013-10-09 15:37:36 | [diff] [blame] | 299 | EXPECT_EQ(ders[i], der); |
mallinath@webrtc.org | 19f27e6 | 2013-10-13 17:18:27 | [diff] [blame] | 300 | |
| 301 | std::string fingerprint_algorithm; |
Yves Gerey | 665174f | 2018-06-19 13:03:05 | [diff] [blame] | 302 | EXPECT_TRUE(GetValue(report, |
| 303 | StatsReport::kStatsValueNameFingerprintAlgorithm, |
| 304 | &fingerprint_algorithm)); |
mallinath@webrtc.org | 19f27e6 | 2013-10-13 17:18:27 | [diff] [blame] | 305 | // The digest algorithm for a FakeSSLCertificate is always SHA-1. |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 | [diff] [blame] | 306 | std::string sha_1_str = rtc::DIGEST_SHA_1; |
mallinath@webrtc.org | 19f27e6 | 2013-10-13 17:18:27 | [diff] [blame] | 307 | EXPECT_EQ(sha_1_str, fingerprint_algorithm); |
| 308 | |
tommi@webrtc.org | 4fb7e25 | 2015-01-21 11:36:18 | [diff] [blame] | 309 | std::string fingerprint; |
| 310 | EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameFingerprint, |
| 311 | &fingerprint)); |
| 312 | EXPECT_FALSE(fingerprint.empty()); |
mallinath@webrtc.org | 19f27e6 | 2013-10-13 17:18:27 | [diff] [blame] | 313 | |
wu@webrtc.org | 4551b79 | 2013-10-09 15:37:36 | [diff] [blame] | 314 | ++i; |
tommi@webrtc.org | 4fb7e25 | 2015-01-21 11:36:18 | [diff] [blame] | 315 | std::string issuer_id; |
Yves Gerey | 665174f | 2018-06-19 13:03:05 | [diff] [blame] | 316 | if (!GetValue(report, StatsReport::kStatsValueNameIssuerId, &issuer_id)) { |
wu@webrtc.org | 4551b79 | 2013-10-09 15:37:36 | [diff] [blame] | 317 | break; |
tommi@webrtc.org | 4fb7e25 | 2015-01-21 11:36:18 | [diff] [blame] | 318 | } |
| 319 | |
tommi@webrtc.org | d390029 | 2015-03-12 16:35:55 | [diff] [blame] | 320 | cert_id = IdFromCertIdString(issuer_id); |
| 321 | certificate_id = &cert_id; |
wu@webrtc.org | 4551b79 | 2013-10-09 15:37:36 | [diff] [blame] | 322 | } |
| 323 | EXPECT_EQ(ders.size(), i); |
| 324 | } |
| 325 | |
Yves Gerey | 665174f | 2018-06-19 13:03:05 | [diff] [blame] | 326 | void VerifyVoiceReceiverInfoReport(const StatsReport* report, |
| 327 | const cricket::VoiceReceiverInfo& info) { |
buildbot@webrtc.org | 3e01e0b | 2014-05-13 17:54:10 | [diff] [blame] | 328 | std::string value_in_report; |
Yves Gerey | 665174f | 2018-06-19 13:03:05 | [diff] [blame] | 329 | EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameAudioOutputLevel, |
| 330 | &value_in_report)); |
Jonas Olsson | 6b1985d | 2018-07-05 09:59:48 | [diff] [blame] | 331 | EXPECT_EQ(rtc::ToString(info.audio_level), value_in_report); |
Yves Gerey | 665174f | 2018-06-19 13:03:05 | [diff] [blame] | 332 | EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameBytesReceived, |
| 333 | &value_in_report)); |
Niels Möller | ac0a4cb | 2019-10-09 13:01:33 | [diff] [blame] | 334 | EXPECT_EQ(rtc::ToString(info.payload_bytes_rcvd + |
| 335 | info.header_and_padding_bytes_rcvd), |
| 336 | value_in_report); |
Yves Gerey | 665174f | 2018-06-19 13:03:05 | [diff] [blame] | 337 | EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameJitterReceived, |
| 338 | &value_in_report)); |
Jonas Olsson | 6b1985d | 2018-07-05 09:59:48 | [diff] [blame] | 339 | EXPECT_EQ(rtc::ToString(info.jitter_ms), value_in_report); |
Yves Gerey | 665174f | 2018-06-19 13:03:05 | [diff] [blame] | 340 | EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameJitterBufferMs, |
| 341 | &value_in_report)); |
Jonas Olsson | 6b1985d | 2018-07-05 09:59:48 | [diff] [blame] | 342 | EXPECT_EQ(rtc::ToString(info.jitter_buffer_ms), value_in_report); |
Yves Gerey | 665174f | 2018-06-19 13:03:05 | [diff] [blame] | 343 | EXPECT_TRUE(GetValue(report, |
| 344 | StatsReport::kStatsValueNamePreferredJitterBufferMs, |
| 345 | &value_in_report)); |
Jonas Olsson | 6b1985d | 2018-07-05 09:59:48 | [diff] [blame] | 346 | EXPECT_EQ(rtc::ToString(info.jitter_buffer_preferred_ms), value_in_report); |
Yves Gerey | 665174f | 2018-06-19 13:03:05 | [diff] [blame] | 347 | EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameCurrentDelayMs, |
| 348 | &value_in_report)); |
Jonas Olsson | 6b1985d | 2018-07-05 09:59:48 | [diff] [blame] | 349 | EXPECT_EQ(rtc::ToString(info.delay_estimate_ms), value_in_report); |
Yves Gerey | 665174f | 2018-06-19 13:03:05 | [diff] [blame] | 350 | EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameExpandRate, |
| 351 | &value_in_report)); |
Jonas Olsson | 6b1985d | 2018-07-05 09:59:48 | [diff] [blame] | 352 | EXPECT_EQ(rtc::ToString(info.expand_rate), value_in_report); |
Yves Gerey | 665174f | 2018-06-19 13:03:05 | [diff] [blame] | 353 | EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameSpeechExpandRate, |
| 354 | &value_in_report)); |
Jonas Olsson | 6b1985d | 2018-07-05 09:59:48 | [diff] [blame] | 355 | EXPECT_EQ(rtc::ToString(info.speech_expand_rate), value_in_report); |
Henrik Lundin | 8e6fd46 | 2015-06-02 07:24:52 | [diff] [blame] | 356 | EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameAccelerateRate, |
| 357 | &value_in_report)); |
Jonas Olsson | 6b1985d | 2018-07-05 09:59:48 | [diff] [blame] | 358 | EXPECT_EQ(rtc::ToString(info.accelerate_rate), value_in_report); |
Henrik Lundin | 8e6fd46 | 2015-06-02 07:24:52 | [diff] [blame] | 359 | EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNamePreemptiveExpandRate, |
| 360 | &value_in_report)); |
Jonas Olsson | 6b1985d | 2018-07-05 09:59:48 | [diff] [blame] | 361 | EXPECT_EQ(rtc::ToString(info.preemptive_expand_rate), value_in_report); |
minyue@webrtc.org | 652bc37 | 2015-02-18 23:50:46 | [diff] [blame] | 362 | EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameSecondaryDecodedRate, |
| 363 | &value_in_report)); |
Jonas Olsson | 6b1985d | 2018-07-05 09:59:48 | [diff] [blame] | 364 | EXPECT_EQ(rtc::ToString(info.secondary_decoded_rate), value_in_report); |
minyue-webrtc | 0e320ec | 2017-08-28 11:51:27 | [diff] [blame] | 365 | EXPECT_TRUE(GetValue(report, |
| 366 | StatsReport::kStatsValueNameSecondaryDiscardedRate, |
| 367 | &value_in_report)); |
Jonas Olsson | 6b1985d | 2018-07-05 09:59:48 | [diff] [blame] | 368 | EXPECT_EQ(rtc::ToString(info.secondary_discarded_rate), value_in_report); |
Yves Gerey | 665174f | 2018-06-19 13:03:05 | [diff] [blame] | 369 | EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNamePacketsReceived, |
| 370 | &value_in_report)); |
Jonas Olsson | 6b1985d | 2018-07-05 09:59:48 | [diff] [blame] | 371 | EXPECT_EQ(rtc::ToString(info.packets_rcvd), value_in_report); |
Yves Gerey | 665174f | 2018-06-19 13:03:05 | [diff] [blame] | 372 | EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameDecodingCTSG, |
| 373 | &value_in_report)); |
Jonas Olsson | 6b1985d | 2018-07-05 09:59:48 | [diff] [blame] | 374 | EXPECT_EQ(rtc::ToString(info.decoding_calls_to_silence_generator), |
Yves Gerey | 665174f | 2018-06-19 13:03:05 | [diff] [blame] | 375 | value_in_report); |
| 376 | EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameDecodingCTN, |
| 377 | &value_in_report)); |
Jonas Olsson | 6b1985d | 2018-07-05 09:59:48 | [diff] [blame] | 378 | EXPECT_EQ(rtc::ToString(info.decoding_calls_to_neteq), value_in_report); |
Yves Gerey | 665174f | 2018-06-19 13:03:05 | [diff] [blame] | 379 | EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameDecodingNormal, |
| 380 | &value_in_report)); |
Jonas Olsson | 6b1985d | 2018-07-05 09:59:48 | [diff] [blame] | 381 | EXPECT_EQ(rtc::ToString(info.decoding_normal), value_in_report); |
Yves Gerey | 665174f | 2018-06-19 13:03:05 | [diff] [blame] | 382 | EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameDecodingPLC, |
| 383 | &value_in_report)); |
Jonas Olsson | 6b1985d | 2018-07-05 09:59:48 | [diff] [blame] | 384 | EXPECT_EQ(rtc::ToString(info.decoding_plc), value_in_report); |
Alex Narest | 5b5d97c | 2019-08-07 16:15:08 | [diff] [blame] | 385 | EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameDecodingCodecPLC, |
| 386 | &value_in_report)); |
| 387 | EXPECT_EQ(rtc::ToString(info.decoding_codec_plc), value_in_report); |
Yves Gerey | 665174f | 2018-06-19 13:03:05 | [diff] [blame] | 388 | EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameDecodingCNG, |
| 389 | &value_in_report)); |
Jonas Olsson | 6b1985d | 2018-07-05 09:59:48 | [diff] [blame] | 390 | EXPECT_EQ(rtc::ToString(info.decoding_cng), value_in_report); |
Yves Gerey | 665174f | 2018-06-19 13:03:05 | [diff] [blame] | 391 | EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameDecodingPLCCNG, |
| 392 | &value_in_report)); |
Jonas Olsson | 6b1985d | 2018-07-05 09:59:48 | [diff] [blame] | 393 | EXPECT_EQ(rtc::ToString(info.decoding_plc_cng), value_in_report); |
henrik.lundin | 6348978 | 2016-09-20 08:47:12 | [diff] [blame] | 394 | EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameDecodingMutedOutput, |
| 395 | &value_in_report)); |
Jonas Olsson | 6b1985d | 2018-07-05 09:59:48 | [diff] [blame] | 396 | EXPECT_EQ(rtc::ToString(info.decoding_muted_output), value_in_report); |
henrik.lundin | 6348978 | 2016-09-20 08:47:12 | [diff] [blame] | 397 | EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameCodecName, |
| 398 | &value_in_report)); |
buildbot@webrtc.org | 3e01e0b | 2014-05-13 17:54:10 | [diff] [blame] | 399 | } |
| 400 | |
henrike@webrtc.org | 40b3b68 | 2014-03-03 18:30:11 | [diff] [blame] | 401 | void VerifyVoiceSenderInfoReport(const StatsReport* report, |
| 402 | const cricket::VoiceSenderInfo& sinfo) { |
| 403 | std::string value_in_report; |
Yves Gerey | 665174f | 2018-06-19 13:03:05 | [diff] [blame] | 404 | EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameCodecName, |
| 405 | &value_in_report)); |
henrike@webrtc.org | 40b3b68 | 2014-03-03 18:30:11 | [diff] [blame] | 406 | EXPECT_EQ(sinfo.codec_name, value_in_report); |
Yves Gerey | 665174f | 2018-06-19 13:03:05 | [diff] [blame] | 407 | EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameBytesSent, |
| 408 | &value_in_report)); |
Niels Möller | ac0a4cb | 2019-10-09 13:01:33 | [diff] [blame] | 409 | EXPECT_EQ(rtc::ToString(sinfo.payload_bytes_sent + |
| 410 | sinfo.header_and_padding_bytes_sent), |
| 411 | value_in_report); |
Yves Gerey | 665174f | 2018-06-19 13:03:05 | [diff] [blame] | 412 | EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNamePacketsSent, |
| 413 | &value_in_report)); |
Jonas Olsson | 6b1985d | 2018-07-05 09:59:48 | [diff] [blame] | 414 | EXPECT_EQ(rtc::ToString(sinfo.packets_sent), value_in_report); |
Yves Gerey | 665174f | 2018-06-19 13:03:05 | [diff] [blame] | 415 | EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNamePacketsLost, |
| 416 | &value_in_report)); |
Jonas Olsson | 6b1985d | 2018-07-05 09:59:48 | [diff] [blame] | 417 | EXPECT_EQ(rtc::ToString(sinfo.packets_lost), value_in_report); |
Yves Gerey | 665174f | 2018-06-19 13:03:05 | [diff] [blame] | 418 | EXPECT_TRUE( |
| 419 | GetValue(report, StatsReport::kStatsValueNameRtt, &value_in_report)); |
Jonas Olsson | 6b1985d | 2018-07-05 09:59:48 | [diff] [blame] | 420 | EXPECT_EQ(rtc::ToString(sinfo.rtt_ms), value_in_report); |
Yves Gerey | 665174f | 2018-06-19 13:03:05 | [diff] [blame] | 421 | EXPECT_TRUE( |
| 422 | GetValue(report, StatsReport::kStatsValueNameRtt, &value_in_report)); |
Jonas Olsson | 6b1985d | 2018-07-05 09:59:48 | [diff] [blame] | 423 | EXPECT_EQ(rtc::ToString(sinfo.rtt_ms), value_in_report); |
Yves Gerey | 665174f | 2018-06-19 13:03:05 | [diff] [blame] | 424 | EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameJitterReceived, |
| 425 | &value_in_report)); |
Jonas Olsson | 6b1985d | 2018-07-05 09:59:48 | [diff] [blame] | 426 | EXPECT_EQ(rtc::ToString(sinfo.jitter_ms), value_in_report); |
Ivo Creusen | 56d46090 | 2017-11-24 16:29:59 | [diff] [blame] | 427 | if (sinfo.apm_statistics.delay_median_ms) { |
| 428 | EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameEchoDelayMedian, |
| 429 | &value_in_report)); |
Jonas Olsson | 6b1985d | 2018-07-05 09:59:48 | [diff] [blame] | 430 | EXPECT_EQ(rtc::ToString(*sinfo.apm_statistics.delay_median_ms), |
Ivo Creusen | 56d46090 | 2017-11-24 16:29:59 | [diff] [blame] | 431 | value_in_report); |
| 432 | } else { |
| 433 | EXPECT_FALSE(GetValue(report, StatsReport::kStatsValueNameEchoDelayMedian, |
| 434 | &value_in_report)); |
| 435 | } |
| 436 | if (sinfo.apm_statistics.delay_standard_deviation_ms) { |
| 437 | EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameEchoDelayStdDev, |
| 438 | &value_in_report)); |
Jonas Olsson | 6b1985d | 2018-07-05 09:59:48 | [diff] [blame] | 439 | EXPECT_EQ(rtc::ToString(*sinfo.apm_statistics.delay_standard_deviation_ms), |
| 440 | value_in_report); |
Ivo Creusen | 56d46090 | 2017-11-24 16:29:59 | [diff] [blame] | 441 | } else { |
| 442 | EXPECT_FALSE(GetValue(report, StatsReport::kStatsValueNameEchoDelayStdDev, |
| 443 | &value_in_report)); |
| 444 | } |
| 445 | if (sinfo.apm_statistics.echo_return_loss) { |
| 446 | EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameEchoReturnLoss, |
| 447 | &value_in_report)); |
Jonas Olsson | 6b1985d | 2018-07-05 09:59:48 | [diff] [blame] | 448 | EXPECT_EQ(rtc::ToString(*sinfo.apm_statistics.echo_return_loss), |
Ivo Creusen | 56d46090 | 2017-11-24 16:29:59 | [diff] [blame] | 449 | value_in_report); |
| 450 | } else { |
| 451 | EXPECT_FALSE(GetValue(report, StatsReport::kStatsValueNameEchoReturnLoss, |
| 452 | &value_in_report)); |
| 453 | } |
| 454 | if (sinfo.apm_statistics.echo_return_loss_enhancement) { |
| 455 | EXPECT_TRUE(GetValue(report, |
| 456 | StatsReport::kStatsValueNameEchoReturnLossEnhancement, |
| 457 | &value_in_report)); |
Jonas Olsson | 6b1985d | 2018-07-05 09:59:48 | [diff] [blame] | 458 | EXPECT_EQ(rtc::ToString(*sinfo.apm_statistics.echo_return_loss_enhancement), |
| 459 | value_in_report); |
Ivo Creusen | 56d46090 | 2017-11-24 16:29:59 | [diff] [blame] | 460 | } else { |
| 461 | EXPECT_FALSE(GetValue(report, |
| 462 | StatsReport::kStatsValueNameEchoReturnLossEnhancement, |
| 463 | &value_in_report)); |
| 464 | } |
| 465 | if (sinfo.apm_statistics.residual_echo_likelihood) { |
| 466 | EXPECT_TRUE(GetValue(report, |
| 467 | StatsReport::kStatsValueNameResidualEchoLikelihood, |
| 468 | &value_in_report)); |
Jonas Olsson | 6b1985d | 2018-07-05 09:59:48 | [diff] [blame] | 469 | EXPECT_EQ(rtc::ToString(*sinfo.apm_statistics.residual_echo_likelihood), |
| 470 | value_in_report); |
Ivo Creusen | 56d46090 | 2017-11-24 16:29:59 | [diff] [blame] | 471 | } else { |
| 472 | EXPECT_FALSE(GetValue(report, |
| 473 | StatsReport::kStatsValueNameResidualEchoLikelihood, |
| 474 | &value_in_report)); |
| 475 | } |
| 476 | if (sinfo.apm_statistics.residual_echo_likelihood_recent_max) { |
| 477 | EXPECT_TRUE(GetValue( |
| 478 | report, StatsReport::kStatsValueNameResidualEchoLikelihoodRecentMax, |
| 479 | &value_in_report)); |
Jonas Olsson | 6b1985d | 2018-07-05 09:59:48 | [diff] [blame] | 480 | EXPECT_EQ(rtc::ToString( |
Ivo Creusen | 56d46090 | 2017-11-24 16:29:59 | [diff] [blame] | 481 | *sinfo.apm_statistics.residual_echo_likelihood_recent_max), |
| 482 | value_in_report); |
| 483 | } else { |
| 484 | EXPECT_FALSE(GetValue( |
| 485 | report, StatsReport::kStatsValueNameResidualEchoLikelihoodRecentMax, |
| 486 | &value_in_report)); |
| 487 | } |
ivoc | 8c63a82 | 2016-10-21 11:10:03 | [diff] [blame] | 488 | EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameAudioInputLevel, |
| 489 | &value_in_report)); |
Jonas Olsson | 6b1985d | 2018-07-05 09:59:48 | [diff] [blame] | 490 | EXPECT_EQ(rtc::ToString(sinfo.audio_level), value_in_report); |
Yves Gerey | 665174f | 2018-06-19 13:03:05 | [diff] [blame] | 491 | EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameTypingNoiseState, |
| 492 | &value_in_report)); |
henrike@webrtc.org | 40b3b68 | 2014-03-03 18:30:11 | [diff] [blame] | 493 | std::string typing_detected = sinfo.typing_noise_detected ? "true" : "false"; |
| 494 | EXPECT_EQ(typing_detected, value_in_report); |
ivoc | e1198e0 | 2017-09-08 15:13:19 | [diff] [blame] | 495 | EXPECT_TRUE(GetValue(report, |
| 496 | StatsReport::kStatsValueNameAnaBitrateActionCounter, |
| 497 | &value_in_report)); |
| 498 | ASSERT_TRUE(sinfo.ana_statistics.bitrate_action_counter); |
Jonas Olsson | 6b1985d | 2018-07-05 09:59:48 | [diff] [blame] | 499 | EXPECT_EQ(rtc::ToString(*sinfo.ana_statistics.bitrate_action_counter), |
| 500 | value_in_report); |
ivoc | e1198e0 | 2017-09-08 15:13:19 | [diff] [blame] | 501 | EXPECT_TRUE(GetValue(report, |
| 502 | StatsReport::kStatsValueNameAnaChannelActionCounter, |
| 503 | &value_in_report)); |
| 504 | ASSERT_TRUE(sinfo.ana_statistics.channel_action_counter); |
Jonas Olsson | 6b1985d | 2018-07-05 09:59:48 | [diff] [blame] | 505 | EXPECT_EQ(rtc::ToString(*sinfo.ana_statistics.channel_action_counter), |
| 506 | value_in_report); |
ivoc | e1198e0 | 2017-09-08 15:13:19 | [diff] [blame] | 507 | EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameAnaDtxActionCounter, |
| 508 | &value_in_report)); |
| 509 | ASSERT_TRUE(sinfo.ana_statistics.dtx_action_counter); |
Jonas Olsson | 6b1985d | 2018-07-05 09:59:48 | [diff] [blame] | 510 | EXPECT_EQ(rtc::ToString(*sinfo.ana_statistics.dtx_action_counter), |
ivoc | e1198e0 | 2017-09-08 15:13:19 | [diff] [blame] | 511 | value_in_report); |
| 512 | EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameAnaFecActionCounter, |
| 513 | &value_in_report)); |
| 514 | ASSERT_TRUE(sinfo.ana_statistics.fec_action_counter); |
Jonas Olsson | 6b1985d | 2018-07-05 09:59:48 | [diff] [blame] | 515 | EXPECT_EQ(rtc::ToString(*sinfo.ana_statistics.fec_action_counter), |
ivoc | e1198e0 | 2017-09-08 15:13:19 | [diff] [blame] | 516 | value_in_report); |
ivoc | 0d0b912 | 2017-09-08 20:24:21 | [diff] [blame] | 517 | EXPECT_TRUE(GetValue( |
| 518 | report, StatsReport::kStatsValueNameAnaFrameLengthIncreaseCounter, |
| 519 | &value_in_report)); |
| 520 | ASSERT_TRUE(sinfo.ana_statistics.frame_length_increase_counter); |
Jonas Olsson | 6b1985d | 2018-07-05 09:59:48 | [diff] [blame] | 521 | EXPECT_EQ(rtc::ToString(*sinfo.ana_statistics.frame_length_increase_counter), |
ivoc | e1198e0 | 2017-09-08 15:13:19 | [diff] [blame] | 522 | value_in_report); |
ivoc | 0d0b912 | 2017-09-08 20:24:21 | [diff] [blame] | 523 | EXPECT_TRUE(GetValue( |
| 524 | report, StatsReport::kStatsValueNameAnaFrameLengthDecreaseCounter, |
| 525 | &value_in_report)); |
| 526 | ASSERT_TRUE(sinfo.ana_statistics.frame_length_decrease_counter); |
Jonas Olsson | 6b1985d | 2018-07-05 09:59:48 | [diff] [blame] | 527 | EXPECT_EQ(rtc::ToString(*sinfo.ana_statistics.frame_length_decrease_counter), |
ivoc | 0d0b912 | 2017-09-08 20:24:21 | [diff] [blame] | 528 | value_in_report); |
| 529 | EXPECT_TRUE(GetValue(report, |
| 530 | StatsReport::kStatsValueNameAnaUplinkPacketLossFraction, |
| 531 | &value_in_report)); |
| 532 | ASSERT_TRUE(sinfo.ana_statistics.uplink_packet_loss_fraction); |
Jonas Olsson | 6b1985d | 2018-07-05 09:59:48 | [diff] [blame] | 533 | EXPECT_EQ(rtc::ToString(*sinfo.ana_statistics.uplink_packet_loss_fraction), |
| 534 | value_in_report); |
henrike@webrtc.org | 40b3b68 | 2014-03-03 18:30:11 | [diff] [blame] | 535 | } |
| 536 | |
xians@webrtc.org | 4cb0128 | 2014-06-12 14:57:05 | [diff] [blame] | 537 | // Helper methods to avoid duplication of code. |
Steve Anton | efe4c92 | 2019-03-27 17:26:06 | [diff] [blame] | 538 | void InitVoiceSenderInfo(cricket::VoiceSenderInfo* voice_sender_info, |
| 539 | uint32_t ssrc = kSsrcOfTrack) { |
| 540 | voice_sender_info->add_ssrc(ssrc); |
xians@webrtc.org | 4cb0128 | 2014-06-12 14:57:05 | [diff] [blame] | 541 | voice_sender_info->codec_name = "fake_codec"; |
Niels Möller | ac0a4cb | 2019-10-09 13:01:33 | [diff] [blame] | 542 | voice_sender_info->payload_bytes_sent = 88; |
| 543 | voice_sender_info->header_and_padding_bytes_sent = 12; |
xians@webrtc.org | 4cb0128 | 2014-06-12 14:57:05 | [diff] [blame] | 544 | voice_sender_info->packets_sent = 101; |
| 545 | voice_sender_info->rtt_ms = 102; |
| 546 | voice_sender_info->fraction_lost = 103; |
| 547 | voice_sender_info->jitter_ms = 104; |
| 548 | voice_sender_info->packets_lost = 105; |
xians@webrtc.org | 4cb0128 | 2014-06-12 14:57:05 | [diff] [blame] | 549 | voice_sender_info->audio_level = 107; |
Sam Zackrisson | 5f2ffee | 2018-11-01 12:51:24 | [diff] [blame] | 550 | voice_sender_info->apm_statistics.echo_return_loss = 108; |
| 551 | voice_sender_info->apm_statistics.echo_return_loss_enhancement = 109; |
| 552 | voice_sender_info->apm_statistics.delay_median_ms = 110; |
| 553 | voice_sender_info->apm_statistics.delay_standard_deviation_ms = 111; |
xians@webrtc.org | 4cb0128 | 2014-06-12 14:57:05 | [diff] [blame] | 554 | voice_sender_info->typing_noise_detected = false; |
Ivo Creusen | 56d46090 | 2017-11-24 16:29:59 | [diff] [blame] | 555 | voice_sender_info->ana_statistics.bitrate_action_counter = 112; |
| 556 | voice_sender_info->ana_statistics.channel_action_counter = 113; |
| 557 | voice_sender_info->ana_statistics.dtx_action_counter = 114; |
| 558 | voice_sender_info->ana_statistics.fec_action_counter = 115; |
| 559 | voice_sender_info->ana_statistics.frame_length_increase_counter = 116; |
| 560 | voice_sender_info->ana_statistics.frame_length_decrease_counter = 117; |
| 561 | voice_sender_info->ana_statistics.uplink_packet_loss_fraction = 118.0; |
xians@webrtc.org | 4cb0128 | 2014-06-12 14:57:05 | [diff] [blame] | 562 | } |
| 563 | |
| 564 | void UpdateVoiceSenderInfoFromAudioTrack( |
zhihuang | 6ba3b19 | 2016-05-13 18:46:35 | [diff] [blame] | 565 | AudioTrackInterface* audio_track, |
Ivo Creusen | 56d46090 | 2017-11-24 16:29:59 | [diff] [blame] | 566 | cricket::VoiceSenderInfo* voice_sender_info, |
| 567 | bool has_remote_tracks) { |
xians@webrtc.org | 4cb0128 | 2014-06-12 14:57:05 | [diff] [blame] | 568 | audio_track->GetSignalLevel(&voice_sender_info->audio_level); |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 569 | AudioProcessorInterface::AudioProcessorStatistics audio_processor_stats = |
| 570 | audio_track->GetAudioProcessor()->GetStats(has_remote_tracks); |
xians@webrtc.org | 4cb0128 | 2014-06-12 14:57:05 | [diff] [blame] | 571 | voice_sender_info->typing_noise_detected = |
| 572 | audio_processor_stats.typing_noise_detected; |
Ivo Creusen | 56d46090 | 2017-11-24 16:29:59 | [diff] [blame] | 573 | voice_sender_info->apm_statistics = audio_processor_stats.apm_statistics; |
xians@webrtc.org | 4cb0128 | 2014-06-12 14:57:05 | [diff] [blame] | 574 | } |
| 575 | |
| 576 | void InitVoiceReceiverInfo(cricket::VoiceReceiverInfo* voice_receiver_info) { |
| 577 | voice_receiver_info->add_ssrc(kSsrcOfTrack); |
Niels Möller | ac0a4cb | 2019-10-09 13:01:33 | [diff] [blame] | 578 | voice_receiver_info->payload_bytes_rcvd = 98; |
| 579 | voice_receiver_info->header_and_padding_bytes_rcvd = 12; |
xians@webrtc.org | 4cb0128 | 2014-06-12 14:57:05 | [diff] [blame] | 580 | voice_receiver_info->packets_rcvd = 111; |
xians@webrtc.org | 4cb0128 | 2014-06-12 14:57:05 | [diff] [blame] | 581 | voice_receiver_info->packets_lost = 114; |
xians@webrtc.org | 4cb0128 | 2014-06-12 14:57:05 | [diff] [blame] | 582 | voice_receiver_info->jitter_ms = 116; |
| 583 | voice_receiver_info->jitter_buffer_ms = 117; |
| 584 | voice_receiver_info->jitter_buffer_preferred_ms = 118; |
| 585 | voice_receiver_info->delay_estimate_ms = 119; |
| 586 | voice_receiver_info->audio_level = 120; |
| 587 | voice_receiver_info->expand_rate = 121; |
minyue@webrtc.org | 652bc37 | 2015-02-18 23:50:46 | [diff] [blame] | 588 | voice_receiver_info->speech_expand_rate = 122; |
| 589 | voice_receiver_info->secondary_decoded_rate = 123; |
Henrik Lundin | 8e6fd46 | 2015-06-02 07:24:52 | [diff] [blame] | 590 | voice_receiver_info->accelerate_rate = 124; |
| 591 | voice_receiver_info->preemptive_expand_rate = 125; |
minyue-webrtc | 0e320ec | 2017-08-28 11:51:27 | [diff] [blame] | 592 | voice_receiver_info->secondary_discarded_rate = 126; |
Alex Narest | 5b5d97c | 2019-08-07 16:15:08 | [diff] [blame] | 593 | voice_receiver_info->decoding_codec_plc = 127; |
xians@webrtc.org | 4cb0128 | 2014-06-12 14:57:05 | [diff] [blame] | 594 | } |
| 595 | |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 596 | class StatsCollectorForTest : public StatsCollector { |
decurtis@webrtc.org | 322a564 | 2015-02-03 22:09:37 | [diff] [blame] | 597 | public: |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 598 | explicit StatsCollectorForTest(PeerConnectionInternal* pc) |
deadbeef | ab9b2d1 | 2015-10-14 18:33:11 | [diff] [blame] | 599 | : StatsCollector(pc), time_now_(19477) {} |
decurtis@webrtc.org | 322a564 | 2015-02-03 22:09:37 | [diff] [blame] | 600 | |
Yves Gerey | 665174f | 2018-06-19 13:03:05 | [diff] [blame] | 601 | double GetTimeNow() override { return time_now_; } |
decurtis@webrtc.org | 322a564 | 2015-02-03 22:09:37 | [diff] [blame] | 602 | |
| 603 | private: |
| 604 | double time_now_; |
| 605 | }; |
| 606 | |
Mirko Bonadei | 6a489f2 | 2019-04-09 13:11:12 | [diff] [blame] | 607 | class StatsCollectorTest : public ::testing::Test { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 608 | protected: |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 609 | rtc::scoped_refptr<FakePeerConnectionForStats> CreatePeerConnection() { |
Tommi | 87f7090 | 2021-04-27 12:43:08 | [diff] [blame] | 610 | return rtc::make_ref_counted<FakePeerConnectionForStats>(); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 611 | } |
| 612 | |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 613 | std::unique_ptr<StatsCollectorForTest> CreateStatsCollector( |
| 614 | PeerConnectionInternal* pc) { |
Mirko Bonadei | 317a1f0 | 2019-09-17 15:06:18 | [diff] [blame] | 615 | return std::make_unique<StatsCollectorForTest>(pc); |
wu@webrtc.org | 97077a3 | 2013-10-25 21:18:33 | [diff] [blame] | 616 | } |
| 617 | |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 618 | void VerifyAudioTrackStats(FakeAudioTrack* audio_track, |
| 619 | StatsCollectorForTest* stats, |
| 620 | const VoiceMediaInfo& voice_info, |
| 621 | StatsReports* reports) { |
xians@webrtc.org | 01bda20 | 2014-07-09 07:38:38 | [diff] [blame] | 622 | stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard); |
Tommi | c811ab5 | 2022-01-11 15:33:23 | [diff] [blame] | 623 | stats->InvalidateCache(); |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 624 | stats->GetStats(nullptr, reports); |
xians@webrtc.org | 01bda20 | 2014-07-09 07:38:38 | [diff] [blame] | 625 | |
| 626 | // Verify the existence of the track report. |
Yves Gerey | 665174f | 2018-06-19 13:03:05 | [diff] [blame] | 627 | const StatsReport* report = |
| 628 | FindNthReportByType(*reports, StatsReport::kStatsReportTypeSsrc, 1); |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 629 | ASSERT_TRUE(report); |
jbauch | be24c94 | 2015-06-22 22:06:43 | [diff] [blame] | 630 | EXPECT_EQ(stats->GetTimeNow(), report->timestamp()); |
Yves Gerey | 665174f | 2018-06-19 13:03:05 | [diff] [blame] | 631 | std::string track_id = |
| 632 | ExtractSsrcStatsValue(*reports, StatsReport::kStatsValueNameTrackId); |
xians@webrtc.org | 01bda20 | 2014-07-09 07:38:38 | [diff] [blame] | 633 | EXPECT_EQ(audio_track->id(), track_id); |
Yves Gerey | 665174f | 2018-06-19 13:03:05 | [diff] [blame] | 634 | std::string ssrc_id = |
| 635 | ExtractSsrcStatsValue(*reports, StatsReport::kStatsValueNameSsrc); |
Jonas Olsson | 6b1985d | 2018-07-05 09:59:48 | [diff] [blame] | 636 | EXPECT_EQ(rtc::ToString(kSsrcOfTrack), ssrc_id); |
xians@webrtc.org | 01bda20 | 2014-07-09 07:38:38 | [diff] [blame] | 637 | |
Yves Gerey | 665174f | 2018-06-19 13:03:05 | [diff] [blame] | 638 | std::string media_type = |
| 639 | ExtractSsrcStatsValue(*reports, StatsReport::kStatsValueNameMediaType); |
fippo | bec70ab | 2016-01-28 09:27:15 | [diff] [blame] | 640 | EXPECT_EQ("audio", media_type); |
| 641 | |
xians@webrtc.org | 01bda20 | 2014-07-09 07:38:38 | [diff] [blame] | 642 | // Verifies the values in the track report. |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 643 | if (!voice_info.senders.empty()) { |
| 644 | VerifyVoiceSenderInfoReport(report, voice_info.senders[0]); |
xians@webrtc.org | 01bda20 | 2014-07-09 07:38:38 | [diff] [blame] | 645 | } |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 646 | if (!voice_info.receivers.empty()) { |
| 647 | VerifyVoiceReceiverInfoReport(report, voice_info.receivers[0]); |
xians@webrtc.org | 01bda20 | 2014-07-09 07:38:38 | [diff] [blame] | 648 | } |
| 649 | |
| 650 | // Verify we get the same result by passing a track to GetStats(). |
| 651 | StatsReports track_reports; // returned values. |
| 652 | stats->GetStats(audio_track, &track_reports); |
| 653 | const StatsReport* track_report = FindNthReportByType( |
| 654 | track_reports, StatsReport::kStatsReportTypeSsrc, 1); |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 655 | ASSERT_TRUE(track_report); |
jbauch | be24c94 | 2015-06-22 22:06:43 | [diff] [blame] | 656 | EXPECT_EQ(stats->GetTimeNow(), track_report->timestamp()); |
xians@webrtc.org | 01bda20 | 2014-07-09 07:38:38 | [diff] [blame] | 657 | track_id = ExtractSsrcStatsValue(track_reports, |
| 658 | StatsReport::kStatsValueNameTrackId); |
| 659 | EXPECT_EQ(audio_track->id(), track_id); |
Yves Gerey | 665174f | 2018-06-19 13:03:05 | [diff] [blame] | 660 | ssrc_id = |
| 661 | ExtractSsrcStatsValue(track_reports, StatsReport::kStatsValueNameSsrc); |
Jonas Olsson | 6b1985d | 2018-07-05 09:59:48 | [diff] [blame] | 662 | EXPECT_EQ(rtc::ToString(kSsrcOfTrack), ssrc_id); |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 663 | if (!voice_info.senders.empty()) { |
| 664 | VerifyVoiceSenderInfoReport(track_report, voice_info.senders[0]); |
| 665 | } |
| 666 | if (!voice_info.receivers.empty()) { |
| 667 | VerifyVoiceReceiverInfoReport(track_report, voice_info.receivers[0]); |
| 668 | } |
henrike@webrtc.org | 40b3b68 | 2014-03-03 18:30:11 | [diff] [blame] | 669 | } |
| 670 | |
Taylor Brandstetter | c392866 | 2018-02-23 21:04:51 | [diff] [blame] | 671 | void TestCertificateReports(const rtc::FakeSSLIdentity& local_identity, |
| 672 | const std::vector<std::string>& local_ders, |
| 673 | const rtc::FakeSSLIdentity& remote_identity, |
| 674 | const std::vector<std::string>& remote_ders) { |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 675 | const std::string kTransportName = "transport"; |
decurtis@webrtc.org | 487a444 | 2015-01-15 22:55:07 | [diff] [blame] | 676 | |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 677 | auto pc = CreatePeerConnection(); |
| 678 | auto stats = CreateStatsCollector(pc); |
| 679 | |
Steve Anton | 5b38731 | 2018-02-03 00:00:20 | [diff] [blame] | 680 | pc->AddVoiceChannel("audio", kTransportName); |
wu@webrtc.org | 4551b79 | 2013-10-09 15:37:36 | [diff] [blame] | 681 | |
| 682 | // Fake stats to process. |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 683 | TransportChannelStats channel_stats; |
wu@webrtc.org | 4551b79 | 2013-10-09 15:37:36 | [diff] [blame] | 684 | channel_stats.component = 1; |
Mirko Bonadei | 7750d80 | 2021-07-26 15:27:42 | [diff] [blame] | 685 | channel_stats.srtp_crypto_suite = rtc::kSrtpAes128CmSha1_80; |
tkchin | 7d06a8c | 2016-04-04 21:10:43 | [diff] [blame] | 686 | channel_stats.ssl_cipher_suite = |
| 687 | internal::TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA; |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 688 | pc->SetTransportStats(kTransportName, channel_stats); |
wu@webrtc.org | 4551b79 | 2013-10-09 15:37:36 | [diff] [blame] | 689 | |
Taylor Brandstetter | c392866 | 2018-02-23 21:04:51 | [diff] [blame] | 690 | // Fake certificate to report. |
Henrik Boström | d828198 | 2015-08-27 08:12:24 | [diff] [blame] | 691 | rtc::scoped_refptr<rtc::RTCCertificate> local_certificate( |
Harald Alvestrand | b33a0ca | 2020-04-16 12:59:40 | [diff] [blame] | 692 | rtc::RTCCertificate::Create(local_identity.Clone())); |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 693 | pc->SetLocalCertificate(kTransportName, local_certificate); |
Taylor Brandstetter | c392866 | 2018-02-23 21:04:51 | [diff] [blame] | 694 | pc->SetRemoteCertChain(kTransportName, |
Steve Anton | f25303e | 2018-10-16 22:23:31 | [diff] [blame] | 695 | remote_identity.cert_chain().Clone()); |
wu@webrtc.org | 4551b79 | 2013-10-09 15:37:36 | [diff] [blame] | 696 | |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 697 | stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard); |
wu@webrtc.org | 4551b79 | 2013-10-09 15:37:36 | [diff] [blame] | 698 | |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 699 | StatsReports reports; |
| 700 | stats->GetStats(nullptr, &reports); |
wu@webrtc.org | 4551b79 | 2013-10-09 15:37:36 | [diff] [blame] | 701 | |
Yves Gerey | 665174f | 2018-06-19 13:03:05 | [diff] [blame] | 702 | const StatsReport* channel_report = |
| 703 | FindNthReportByType(reports, StatsReport::kStatsReportTypeComponent, 1); |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 704 | EXPECT_TRUE(channel_report); |
wu@webrtc.org | 4551b79 | 2013-10-09 15:37:36 | [diff] [blame] | 705 | |
| 706 | // Check local certificate chain. |
Yves Gerey | 665174f | 2018-06-19 13:03:05 | [diff] [blame] | 707 | std::string local_certificate_id = |
| 708 | ExtractStatsValue(StatsReport::kStatsReportTypeComponent, reports, |
| 709 | StatsReport::kStatsValueNameLocalCertificateId); |
wu@webrtc.org | b9a088b | 2014-02-13 23:18:49 | [diff] [blame] | 710 | if (local_ders.size() > 0) { |
| 711 | EXPECT_NE(kNotFound, local_certificate_id); |
tommi@webrtc.org | d390029 | 2015-03-12 16:35:55 | [diff] [blame] | 712 | StatsReport::Id id(IdFromCertIdString(local_certificate_id)); |
| 713 | CheckCertChainReports(reports, local_ders, id); |
wu@webrtc.org | b9a088b | 2014-02-13 23:18:49 | [diff] [blame] | 714 | } else { |
| 715 | EXPECT_EQ(kNotFound, local_certificate_id); |
| 716 | } |
wu@webrtc.org | 4551b79 | 2013-10-09 15:37:36 | [diff] [blame] | 717 | |
| 718 | // Check remote certificate chain. |
Yves Gerey | 665174f | 2018-06-19 13:03:05 | [diff] [blame] | 719 | std::string remote_certificate_id = |
| 720 | ExtractStatsValue(StatsReport::kStatsReportTypeComponent, reports, |
| 721 | StatsReport::kStatsValueNameRemoteCertificateId); |
wu@webrtc.org | b9a088b | 2014-02-13 23:18:49 | [diff] [blame] | 722 | if (remote_ders.size() > 0) { |
| 723 | EXPECT_NE(kNotFound, remote_certificate_id); |
tommi@webrtc.org | d390029 | 2015-03-12 16:35:55 | [diff] [blame] | 724 | StatsReport::Id id(IdFromCertIdString(remote_certificate_id)); |
| 725 | CheckCertChainReports(reports, remote_ders, id); |
wu@webrtc.org | b9a088b | 2014-02-13 23:18:49 | [diff] [blame] | 726 | } else { |
| 727 | EXPECT_EQ(kNotFound, remote_certificate_id); |
| 728 | } |
pthatcher@webrtc.org | 7bea1ff | 2015-03-04 01:38:30 | [diff] [blame] | 729 | |
| 730 | // Check negotiated ciphers. |
Guo-wei Shieh | 521ed7b | 2015-11-19 03:41:53 | [diff] [blame] | 731 | std::string dtls_cipher_suite = |
| 732 | ExtractStatsValue(StatsReport::kStatsReportTypeComponent, reports, |
| 733 | StatsReport::kStatsValueNameDtlsCipher); |
| 734 | EXPECT_EQ(rtc::SSLStreamAdapter::SslCipherSuiteToName( |
tkchin | 7d06a8c | 2016-04-04 21:10:43 | [diff] [blame] | 735 | internal::TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA), |
Guo-wei Shieh | 521ed7b | 2015-11-19 03:41:53 | [diff] [blame] | 736 | dtls_cipher_suite); |
| 737 | std::string srtp_crypto_suite = |
| 738 | ExtractStatsValue(StatsReport::kStatsReportTypeComponent, reports, |
| 739 | StatsReport::kStatsValueNameSrtpCipher); |
Mirko Bonadei | 7750d80 | 2021-07-26 15:27:42 | [diff] [blame] | 740 | EXPECT_EQ(rtc::SrtpCryptoSuiteToName(rtc::kSrtpAes128CmSha1_80), |
Guo-wei Shieh | 521ed7b | 2015-11-19 03:41:53 | [diff] [blame] | 741 | srtp_crypto_suite); |
wu@webrtc.org | 4551b79 | 2013-10-09 15:37:36 | [diff] [blame] | 742 | } |
Harald Alvestrand | 75ceef2 | 2018-01-04 14:26:13 | [diff] [blame] | 743 | }; |
| 744 | |
Steve Anton | efe4c92 | 2019-03-27 17:26:06 | [diff] [blame] | 745 | static rtc::scoped_refptr<MockRtpSenderInternal> CreateMockSender( |
| 746 | rtc::scoped_refptr<MediaStreamTrackInterface> track, |
| 747 | uint32_t ssrc) { |
Tommi | 87f7090 | 2021-04-27 12:43:08 | [diff] [blame] | 748 | auto sender = rtc::make_ref_counted<MockRtpSenderInternal>(); |
Steve Anton | efe4c92 | 2019-03-27 17:26:06 | [diff] [blame] | 749 | EXPECT_CALL(*sender, track()).WillRepeatedly(Return(track)); |
| 750 | EXPECT_CALL(*sender, ssrc()).WillRepeatedly(Return(ssrc)); |
| 751 | EXPECT_CALL(*sender, media_type()) |
| 752 | .WillRepeatedly( |
| 753 | Return(track->kind() == MediaStreamTrackInterface::kAudioKind |
| 754 | ? cricket::MEDIA_TYPE_AUDIO |
| 755 | : cricket::MEDIA_TYPE_VIDEO)); |
Tomas Gunnarsson | 16de216 | 2022-01-26 09:21:57 | [diff] [blame] | 756 | EXPECT_CALL(*sender, SetMediaChannel(_)).Times(AtMost(2)); |
| 757 | EXPECT_CALL(*sender, SetTransceiverAsStopped()).Times(AtMost(1)); |
| 758 | EXPECT_CALL(*sender, Stop()); |
Steve Anton | efe4c92 | 2019-03-27 17:26:06 | [diff] [blame] | 759 | return sender; |
| 760 | } |
| 761 | |
| 762 | static rtc::scoped_refptr<MockRtpReceiverInternal> CreateMockReceiver( |
| 763 | rtc::scoped_refptr<MediaStreamTrackInterface> track, |
| 764 | uint32_t ssrc) { |
Tommi | 87f7090 | 2021-04-27 12:43:08 | [diff] [blame] | 765 | auto receiver = rtc::make_ref_counted<MockRtpReceiverInternal>(); |
Steve Anton | efe4c92 | 2019-03-27 17:26:06 | [diff] [blame] | 766 | EXPECT_CALL(*receiver, track()).WillRepeatedly(Return(track)); |
| 767 | EXPECT_CALL(*receiver, ssrc()).WillRepeatedly(Return(ssrc)); |
| 768 | EXPECT_CALL(*receiver, media_type()) |
| 769 | .WillRepeatedly( |
| 770 | Return(track->kind() == MediaStreamTrackInterface::kAudioKind |
| 771 | ? cricket::MEDIA_TYPE_AUDIO |
| 772 | : cricket::MEDIA_TYPE_VIDEO)); |
Tommi | 6589def | 2022-02-17 22:36:47 | [diff] [blame] | 773 | EXPECT_CALL(*receiver, SetMediaChannel(_)).WillRepeatedly(Return()); |
| 774 | EXPECT_CALL(*receiver, Stop()).WillRepeatedly(Return()); |
Steve Anton | efe4c92 | 2019-03-27 17:26:06 | [diff] [blame] | 775 | return receiver; |
| 776 | } |
| 777 | |
Harald Alvestrand | 75ceef2 | 2018-01-04 14:26:13 | [diff] [blame] | 778 | class StatsCollectorTrackTest : public StatsCollectorTest, |
| 779 | public ::testing::WithParamInterface<bool> { |
| 780 | public: |
| 781 | // Adds a outgoing video track with a given SSRC into the stats. |
| 782 | // If GetParam() returns true, the track is also inserted into the local |
| 783 | // stream, which is created if necessary. |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 784 | void AddOutgoingVideoTrack(FakePeerConnectionForStats* pc, |
| 785 | StatsCollectorForTest* stats) { |
| 786 | track_ = VideoTrack::Create(kLocalTrackId, FakeVideoTrackSource::Create(), |
| 787 | rtc::Thread::Current()); |
Harald Alvestrand | 75ceef2 | 2018-01-04 14:26:13 | [diff] [blame] | 788 | if (GetParam()) { |
| 789 | if (!stream_) |
Seth Hampson | 845e878 | 2018-03-02 19:34:10 | [diff] [blame] | 790 | stream_ = MediaStream::Create("streamid"); |
Harald Alvestrand | 75ceef2 | 2018-01-04 14:26:13 | [diff] [blame] | 791 | stream_->AddTrack(track_); |
| 792 | stats->AddStream(stream_); |
| 793 | } else { |
| 794 | stats->AddTrack(track_); |
| 795 | } |
Steve Anton | efe4c92 | 2019-03-27 17:26:06 | [diff] [blame] | 796 | pc->AddSender(CreateMockSender(track_, kSsrcOfTrack)); |
Harald Alvestrand | 75ceef2 | 2018-01-04 14:26:13 | [diff] [blame] | 797 | } |
| 798 | |
| 799 | // Adds a incoming video track with a given SSRC into the stats. |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 800 | void AddIncomingVideoTrack(FakePeerConnectionForStats* pc, |
| 801 | StatsCollectorForTest* stats) { |
| 802 | track_ = VideoTrack::Create(kRemoteTrackId, FakeVideoTrackSource::Create(), |
| 803 | rtc::Thread::Current()); |
Harald Alvestrand | 75ceef2 | 2018-01-04 14:26:13 | [diff] [blame] | 804 | if (GetParam()) { |
Seth Hampson | 845e878 | 2018-03-02 19:34:10 | [diff] [blame] | 805 | stream_ = MediaStream::Create("streamid"); |
Harald Alvestrand | 75ceef2 | 2018-01-04 14:26:13 | [diff] [blame] | 806 | stream_->AddTrack(track_); |
| 807 | stats->AddStream(stream_); |
| 808 | } else { |
| 809 | stats->AddTrack(track_); |
| 810 | } |
Steve Anton | efe4c92 | 2019-03-27 17:26:06 | [diff] [blame] | 811 | pc->AddReceiver(CreateMockReceiver(track_, kSsrcOfTrack)); |
Harald Alvestrand | 75ceef2 | 2018-01-04 14:26:13 | [diff] [blame] | 812 | } |
| 813 | |
| 814 | // Adds a outgoing audio track with a given SSRC into the stats, |
| 815 | // and register it into the stats object. |
| 816 | // If GetParam() returns true, the track is also inserted into the local |
| 817 | // stream, which is created if necessary. |
Steve Anton | efe4c92 | 2019-03-27 17:26:06 | [diff] [blame] | 818 | rtc::scoped_refptr<RtpSenderInterface> AddOutgoingAudioTrack( |
| 819 | FakePeerConnectionForStats* pc, |
| 820 | StatsCollectorForTest* stats) { |
Tommi | 87f7090 | 2021-04-27 12:43:08 | [diff] [blame] | 821 | audio_track_ = rtc::make_ref_counted<FakeAudioTrack>(kLocalTrackId); |
Harald Alvestrand | 75ceef2 | 2018-01-04 14:26:13 | [diff] [blame] | 822 | if (GetParam()) { |
| 823 | if (!stream_) |
Seth Hampson | 845e878 | 2018-03-02 19:34:10 | [diff] [blame] | 824 | stream_ = MediaStream::Create("streamid"); |
Harald Alvestrand | 75ceef2 | 2018-01-04 14:26:13 | [diff] [blame] | 825 | stream_->AddTrack(audio_track_); |
| 826 | stats->AddStream(stream_); |
| 827 | } else { |
| 828 | stats->AddTrack(audio_track_); |
| 829 | } |
Steve Anton | efe4c92 | 2019-03-27 17:26:06 | [diff] [blame] | 830 | return pc->AddSender(CreateMockSender(audio_track_, kSsrcOfTrack)); |
Harald Alvestrand | 75ceef2 | 2018-01-04 14:26:13 | [diff] [blame] | 831 | } |
| 832 | |
| 833 | // Adds a incoming audio track with a given SSRC into the stats. |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 834 | void AddIncomingAudioTrack(FakePeerConnectionForStats* pc, |
| 835 | StatsCollectorForTest* stats) { |
Tommi | 87f7090 | 2021-04-27 12:43:08 | [diff] [blame] | 836 | audio_track_ = rtc::make_ref_counted<FakeAudioTrack>(kRemoteTrackId); |
Harald Alvestrand | 75ceef2 | 2018-01-04 14:26:13 | [diff] [blame] | 837 | if (GetParam()) { |
| 838 | if (stream_ == NULL) |
Seth Hampson | 845e878 | 2018-03-02 19:34:10 | [diff] [blame] | 839 | stream_ = MediaStream::Create("streamid"); |
Harald Alvestrand | 75ceef2 | 2018-01-04 14:26:13 | [diff] [blame] | 840 | stream_->AddTrack(audio_track_); |
| 841 | stats->AddStream(stream_); |
| 842 | } else { |
| 843 | stats->AddTrack(audio_track_); |
| 844 | } |
Steve Anton | efe4c92 | 2019-03-27 17:26:06 | [diff] [blame] | 845 | pc->AddReceiver(CreateMockReceiver(audio_track_, kSsrcOfTrack)); |
Harald Alvestrand | 75ceef2 | 2018-01-04 14:26:13 | [diff] [blame] | 846 | } |
| 847 | |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 848 | rtc::scoped_refptr<MediaStream> stream_; |
| 849 | rtc::scoped_refptr<VideoTrack> track_; |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 | [diff] [blame] | 850 | rtc::scoped_refptr<FakeAudioTrack> audio_track_; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 851 | }; |
| 852 | |
zhihuang | 6ba3b19 | 2016-05-13 18:46:35 | [diff] [blame] | 853 | TEST_F(StatsCollectorTest, FilterOutNegativeDataChannelId) { |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 854 | auto pc = CreatePeerConnection(); |
| 855 | auto stats = CreateStatsCollector(pc); |
zhihuang | 6ba3b19 | 2016-05-13 18:46:35 | [diff] [blame] | 856 | |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 857 | pc->AddSctpDataChannel("hacks"); |
zhihuang | 6ba3b19 | 2016-05-13 18:46:35 | [diff] [blame] | 858 | |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 859 | stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard); |
zhihuang | 6ba3b19 | 2016-05-13 18:46:35 | [diff] [blame] | 860 | StatsReports reports; |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 861 | stats->GetStats(nullptr, &reports); |
zhihuang | 6ba3b19 | 2016-05-13 18:46:35 | [diff] [blame] | 862 | |
| 863 | const StatsReport* report = |
| 864 | FindNthReportByType(reports, StatsReport::kStatsReportTypeDataChannel, 1); |
| 865 | |
| 866 | std::string value_in_report; |
| 867 | EXPECT_FALSE(GetValue(report, StatsReport::kStatsValueNameDataChannelId, |
| 868 | &value_in_report)); |
| 869 | } |
| 870 | |
decurtis@webrtc.org | 487a444 | 2015-01-15 22:55:07 | [diff] [blame] | 871 | // Verify that ExtractDataInfo populates reports. |
| 872 | TEST_F(StatsCollectorTest, ExtractDataInfo) { |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 873 | const std::string kDataChannelLabel = "hacks"; |
| 874 | constexpr int kDataChannelId = 31337; |
| 875 | const std::string kConnectingString = DataChannelInterface::DataStateString( |
decurtis@webrtc.org | 487a444 | 2015-01-15 22:55:07 | [diff] [blame] | 876 | DataChannelInterface::DataState::kConnecting); |
| 877 | |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 878 | auto pc = CreatePeerConnection(); |
| 879 | auto stats = CreateStatsCollector(pc); |
decurtis@webrtc.org | 487a444 | 2015-01-15 22:55:07 | [diff] [blame] | 880 | |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 881 | InternalDataChannelInit init; |
| 882 | init.id = kDataChannelId; |
| 883 | pc->AddSctpDataChannel(kDataChannelLabel, init); |
decurtis@webrtc.org | 487a444 | 2015-01-15 22:55:07 | [diff] [blame] | 884 | |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 885 | stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard); |
decurtis@webrtc.org | 487a444 | 2015-01-15 22:55:07 | [diff] [blame] | 886 | StatsReports reports; |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 887 | stats->GetStats(nullptr, &reports); |
decurtis@webrtc.org | 322a564 | 2015-02-03 22:09:37 | [diff] [blame] | 888 | |
| 889 | const StatsReport* report = |
| 890 | FindNthReportByType(reports, StatsReport::kStatsReportTypeDataChannel, 1); |
| 891 | |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 892 | StatsReport::Id report_id = StatsReport::NewTypedIntId( |
| 893 | StatsReport::kStatsReportTypeDataChannel, kDataChannelId); |
decurtis@webrtc.org | 322a564 | 2015-02-03 22:09:37 | [diff] [blame] | 894 | |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 895 | EXPECT_TRUE(report_id->Equals(report->id())); |
decurtis@webrtc.org | 322a564 | 2015-02-03 22:09:37 | [diff] [blame] | 896 | |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 897 | EXPECT_EQ(stats->GetTimeNow(), report->timestamp()); |
| 898 | EXPECT_EQ(kDataChannelLabel, |
| 899 | ExtractStatsValue(StatsReport::kStatsReportTypeDataChannel, reports, |
| 900 | StatsReport::kStatsValueNameLabel)); |
Jonas Olsson | 6b1985d | 2018-07-05 09:59:48 | [diff] [blame] | 901 | EXPECT_EQ(rtc::ToString(kDataChannelId), |
Peter Boström | 0c4e06b | 2015-10-07 10:23:21 | [diff] [blame] | 902 | ExtractStatsValue(StatsReport::kStatsReportTypeDataChannel, reports, |
decurtis@webrtc.org | 487a444 | 2015-01-15 22:55:07 | [diff] [blame] | 903 | StatsReport::kStatsValueNameDataChannelId)); |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 904 | EXPECT_EQ(kConnectingString, |
| 905 | ExtractStatsValue(StatsReport::kStatsReportTypeDataChannel, reports, |
| 906 | StatsReport::kStatsValueNameState)); |
Yves Gerey | 665174f | 2018-06-19 13:03:05 | [diff] [blame] | 907 | EXPECT_EQ("", |
| 908 | ExtractStatsValue(StatsReport::kStatsReportTypeDataChannel, reports, |
| 909 | StatsReport::kStatsValueNameProtocol)); |
decurtis@webrtc.org | 487a444 | 2015-01-15 22:55:07 | [diff] [blame] | 910 | } |
| 911 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 912 | // This test verifies that 64-bit counters are passed successfully. |
Harald Alvestrand | 75ceef2 | 2018-01-04 14:26:13 | [diff] [blame] | 913 | TEST_P(StatsCollectorTrackTest, BytesCounterHandles64Bits) { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 914 | // The number of bytes must be larger than 0xFFFFFFFF for this test. |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 915 | constexpr int64_t kBytesSent = 12345678901234LL; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 916 | |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 917 | auto pc = CreatePeerConnection(); |
| 918 | auto stats = CreateStatsCollector(pc); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 919 | |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 920 | VideoSenderInfo video_sender_info; |
sergeyu@chromium.org | 5bc25c4 | 2013-12-05 00:24:06 | [diff] [blame] | 921 | video_sender_info.add_ssrc(1234); |
Niels Möller | ac0a4cb | 2019-10-09 13:01:33 | [diff] [blame] | 922 | video_sender_info.payload_bytes_sent = kBytesSent; |
| 923 | video_sender_info.header_and_padding_bytes_sent = 0; |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 924 | VideoMediaInfo video_info; |
Henrik Boström | a0ff50c | 2020-05-05 13:54:46 | [diff] [blame] | 925 | video_info.aggregated_senders.push_back(video_sender_info); |
Steve Anton | 5b38731 | 2018-02-03 00:00:20 | [diff] [blame] | 926 | |
Tommi | 1901551 | 2022-02-02 10:49:35 | [diff] [blame] | 927 | pc->AddVideoChannel("video", "transport", video_info); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 928 | |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 929 | AddOutgoingVideoTrack(pc, stats.get()); |
| 930 | |
| 931 | stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard); |
| 932 | StatsReports reports; |
| 933 | stats->GetStats(nullptr, &reports); |
| 934 | |
| 935 | EXPECT_EQ( |
| 936 | rtc::ToString(kBytesSent), |
| 937 | ExtractSsrcStatsValue(reports, StatsReport::kStatsValueNameBytesSent)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 938 | } |
| 939 | |
Alex Narest | 42308f6 | 2017-06-19 15:58:12 | [diff] [blame] | 940 | // Test that audio BWE information is reported via stats. |
Harald Alvestrand | 75ceef2 | 2018-01-04 14:26:13 | [diff] [blame] | 941 | TEST_P(StatsCollectorTrackTest, AudioBandwidthEstimationInfoIsReported) { |
Alex Narest | 42308f6 | 2017-06-19 15:58:12 | [diff] [blame] | 942 | // Set up an SSRC just to test that we get both kinds of stats back: SSRC and |
| 943 | // BWE. |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 944 | constexpr int64_t kBytesSent = 12345678901234LL; |
| 945 | constexpr int kSendBandwidth = 1234567; |
| 946 | constexpr int kRecvBandwidth = 12345678; |
| 947 | constexpr int kPacerDelay = 123; |
Alex Narest | 42308f6 | 2017-06-19 15:58:12 | [diff] [blame] | 948 | |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 949 | auto pc = CreatePeerConnection(); |
| 950 | auto stats = CreateStatsCollector(pc); |
Alex Narest | 42308f6 | 2017-06-19 15:58:12 | [diff] [blame] | 951 | |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 952 | VoiceSenderInfo voice_sender_info; |
Alex Narest | 42308f6 | 2017-06-19 15:58:12 | [diff] [blame] | 953 | voice_sender_info.add_ssrc(1234); |
Niels Möller | ac0a4cb | 2019-10-09 13:01:33 | [diff] [blame] | 954 | voice_sender_info.payload_bytes_sent = kBytesSent - 12; |
| 955 | voice_sender_info.header_and_padding_bytes_sent = 12; |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 956 | VoiceMediaInfo voice_info; |
| 957 | voice_info.senders.push_back(voice_sender_info); |
Steve Anton | 5b38731 | 2018-02-03 00:00:20 | [diff] [blame] | 958 | |
| 959 | auto* voice_media_channel = pc->AddVoiceChannel("audio", "transport"); |
| 960 | voice_media_channel->SetStats(voice_info); |
Alex Narest | 42308f6 | 2017-06-19 15:58:12 | [diff] [blame] | 961 | |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 962 | AddOutgoingAudioTrack(pc, stats.get()); |
| 963 | |
| 964 | Call::Stats call_stats; |
Alex Narest | 42308f6 | 2017-06-19 15:58:12 | [diff] [blame] | 965 | call_stats.send_bandwidth_bps = kSendBandwidth; |
| 966 | call_stats.recv_bandwidth_bps = kRecvBandwidth; |
| 967 | call_stats.pacer_delay_ms = kPacerDelay; |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 968 | pc->SetCallStats(call_stats); |
Alex Narest | 42308f6 | 2017-06-19 15:58:12 | [diff] [blame] | 969 | |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 970 | stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard); |
| 971 | StatsReports reports; |
| 972 | stats->GetStats(nullptr, &reports); |
| 973 | |
| 974 | EXPECT_EQ( |
| 975 | rtc::ToString(kBytesSent), |
| 976 | ExtractSsrcStatsValue(reports, StatsReport::kStatsValueNameBytesSent)); |
| 977 | EXPECT_EQ(rtc::ToString(kSendBandwidth), |
| 978 | ExtractBweStatsValue( |
| 979 | reports, StatsReport::kStatsValueNameAvailableSendBandwidth)); |
| 980 | EXPECT_EQ( |
| 981 | rtc::ToString(kRecvBandwidth), |
| 982 | ExtractBweStatsValue( |
| 983 | reports, StatsReport::kStatsValueNameAvailableReceiveBandwidth)); |
| 984 | EXPECT_EQ( |
| 985 | rtc::ToString(kPacerDelay), |
| 986 | ExtractBweStatsValue(reports, StatsReport::kStatsValueNameBucketDelay)); |
Alex Narest | 42308f6 | 2017-06-19 15:58:12 | [diff] [blame] | 987 | } |
| 988 | |
| 989 | // Test that video BWE information is reported via stats. |
Harald Alvestrand | 75ceef2 | 2018-01-04 14:26:13 | [diff] [blame] | 990 | TEST_P(StatsCollectorTrackTest, VideoBandwidthEstimationInfoIsReported) { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 991 | // Set up an SSRC just to test that we get both kinds of stats back: SSRC and |
| 992 | // BWE. |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 993 | constexpr int64_t kBytesSent = 12345678901234LL; |
| 994 | constexpr int kSendBandwidth = 1234567; |
| 995 | constexpr int kRecvBandwidth = 12345678; |
| 996 | constexpr int kPacerDelay = 123; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 997 | |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 998 | auto pc = CreatePeerConnection(); |
| 999 | auto stats = CreateStatsCollector(pc); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 1000 | |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1001 | VideoSenderInfo video_sender_info; |
sergeyu@chromium.org | 5bc25c4 | 2013-12-05 00:24:06 | [diff] [blame] | 1002 | video_sender_info.add_ssrc(1234); |
Niels Möller | ac0a4cb | 2019-10-09 13:01:33 | [diff] [blame] | 1003 | video_sender_info.payload_bytes_sent = kBytesSent - 12; |
| 1004 | video_sender_info.header_and_padding_bytes_sent = 12; |
| 1005 | |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1006 | VideoMediaInfo video_info; |
Henrik Boström | a0ff50c | 2020-05-05 13:54:46 | [diff] [blame] | 1007 | video_info.aggregated_senders.push_back(video_sender_info); |
Steve Anton | 5b38731 | 2018-02-03 00:00:20 | [diff] [blame] | 1008 | |
Tommi | 1901551 | 2022-02-02 10:49:35 | [diff] [blame] | 1009 | pc->AddVideoChannel("video", "transport", video_info); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 1010 | |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1011 | AddOutgoingVideoTrack(pc, stats.get()); |
| 1012 | |
| 1013 | Call::Stats call_stats; |
stefan | f79ade1 | 2017-06-02 13:44:03 | [diff] [blame] | 1014 | call_stats.send_bandwidth_bps = kSendBandwidth; |
| 1015 | call_stats.recv_bandwidth_bps = kRecvBandwidth; |
| 1016 | call_stats.pacer_delay_ms = kPacerDelay; |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1017 | pc->SetCallStats(call_stats); |
wu@webrtc.org | 97077a3 | 2013-10-25 21:18:33 | [diff] [blame] | 1018 | |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1019 | stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard); |
| 1020 | StatsReports reports; |
| 1021 | stats->GetStats(nullptr, &reports); |
| 1022 | |
| 1023 | EXPECT_EQ( |
| 1024 | rtc::ToString(kBytesSent), |
| 1025 | ExtractSsrcStatsValue(reports, StatsReport::kStatsValueNameBytesSent)); |
| 1026 | EXPECT_EQ(rtc::ToString(kSendBandwidth), |
| 1027 | ExtractBweStatsValue( |
| 1028 | reports, StatsReport::kStatsValueNameAvailableSendBandwidth)); |
| 1029 | EXPECT_EQ( |
| 1030 | rtc::ToString(kRecvBandwidth), |
| 1031 | ExtractBweStatsValue( |
| 1032 | reports, StatsReport::kStatsValueNameAvailableReceiveBandwidth)); |
| 1033 | EXPECT_EQ( |
| 1034 | rtc::ToString(kPacerDelay), |
| 1035 | ExtractBweStatsValue(reports, StatsReport::kStatsValueNameBucketDelay)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 1036 | } |
| 1037 | |
| 1038 | // This test verifies that an object of type "googSession" always |
| 1039 | // exists in the returned stats. |
| 1040 | TEST_F(StatsCollectorTest, SessionObjectExists) { |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1041 | auto pc = CreatePeerConnection(); |
| 1042 | auto stats = CreateStatsCollector(pc); |
decurtis@webrtc.org | 487a444 | 2015-01-15 22:55:07 | [diff] [blame] | 1043 | |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1044 | stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard); |
| 1045 | StatsReports reports; |
| 1046 | stats->GetStats(nullptr, &reports); |
| 1047 | |
| 1048 | EXPECT_TRUE( |
| 1049 | FindNthReportByType(reports, StatsReport::kStatsReportTypeSession, 1)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 1050 | } |
| 1051 | |
| 1052 | // This test verifies that only one object of type "googSession" exists |
| 1053 | // in the returned stats. |
| 1054 | TEST_F(StatsCollectorTest, OnlyOneSessionObjectExists) { |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1055 | auto pc = CreatePeerConnection(); |
| 1056 | auto stats = CreateStatsCollector(pc); |
decurtis@webrtc.org | 487a444 | 2015-01-15 22:55:07 | [diff] [blame] | 1057 | |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1058 | stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard); |
| 1059 | stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard); |
| 1060 | StatsReports reports; |
| 1061 | stats->GetStats(nullptr, &reports); |
| 1062 | |
| 1063 | EXPECT_TRUE( |
| 1064 | FindNthReportByType(reports, StatsReport::kStatsReportTypeSession, 1)); |
| 1065 | EXPECT_FALSE( |
| 1066 | FindNthReportByType(reports, StatsReport::kStatsReportTypeSession, 2)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 1067 | } |
| 1068 | |
| 1069 | // This test verifies that the empty track report exists in the returned stats |
| 1070 | // without calling StatsCollector::UpdateStats. |
Harald Alvestrand | 75ceef2 | 2018-01-04 14:26:13 | [diff] [blame] | 1071 | TEST_P(StatsCollectorTrackTest, TrackObjectExistsWithoutUpdateStats) { |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1072 | auto pc = CreatePeerConnection(); |
| 1073 | auto stats = CreateStatsCollector(pc); |
decurtis@webrtc.org | 487a444 | 2015-01-15 22:55:07 | [diff] [blame] | 1074 | |
Steve Anton | 5b38731 | 2018-02-03 00:00:20 | [diff] [blame] | 1075 | pc->AddVideoChannel("video", "transport"); |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1076 | AddOutgoingVideoTrack(pc, stats.get()); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 1077 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 1078 | // Verfies the existence of the track report. |
tommi@webrtc.org | 03505bc | 2014-07-14 20:15:26 | [diff] [blame] | 1079 | StatsReports reports; |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1080 | stats->GetStats(nullptr, &reports); |
| 1081 | ASSERT_EQ(1u, reports.size()); |
tommi@webrtc.org | 4fb7e25 | 2015-01-21 11:36:18 | [diff] [blame] | 1082 | EXPECT_EQ(StatsReport::kStatsReportTypeTrack, reports[0]->type()); |
jbauch | be24c94 | 2015-06-22 22:06:43 | [diff] [blame] | 1083 | EXPECT_EQ(0, reports[0]->timestamp()); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 1084 | |
| 1085 | std::string trackValue = |
Yves Gerey | 665174f | 2018-06-19 13:03:05 | [diff] [blame] | 1086 | ExtractStatsValue(StatsReport::kStatsReportTypeTrack, reports, |
henrike@webrtc.org | 40b3b68 | 2014-03-03 18:30:11 | [diff] [blame] | 1087 | StatsReport::kStatsValueNameTrackId); |
xians@webrtc.org | 4cb0128 | 2014-06-12 14:57:05 | [diff] [blame] | 1088 | EXPECT_EQ(kLocalTrackId, trackValue); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 1089 | } |
| 1090 | |
| 1091 | // This test verifies that the empty track report exists in the returned stats |
| 1092 | // when StatsCollector::UpdateStats is called with ssrc stats. |
Harald Alvestrand | 75ceef2 | 2018-01-04 14:26:13 | [diff] [blame] | 1093 | TEST_P(StatsCollectorTrackTest, TrackAndSsrcObjectExistAfterUpdateSsrcStats) { |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1094 | constexpr int64_t kBytesSent = 12345678901234LL; |
decurtis@webrtc.org | 487a444 | 2015-01-15 22:55:07 | [diff] [blame] | 1095 | |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1096 | auto pc = CreatePeerConnection(); |
| 1097 | auto stats = CreateStatsCollector(pc); |
deadbeef | cbecd35 | 2015-09-23 18:50:27 | [diff] [blame] | 1098 | |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1099 | VideoSenderInfo video_sender_info; |
sergeyu@chromium.org | 5bc25c4 | 2013-12-05 00:24:06 | [diff] [blame] | 1100 | video_sender_info.add_ssrc(1234); |
Niels Möller | ac0a4cb | 2019-10-09 13:01:33 | [diff] [blame] | 1101 | video_sender_info.payload_bytes_sent = kBytesSent - 12; |
| 1102 | video_sender_info.header_and_padding_bytes_sent = 12; |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1103 | VideoMediaInfo video_info; |
Henrik Boström | a0ff50c | 2020-05-05 13:54:46 | [diff] [blame] | 1104 | video_info.aggregated_senders.push_back(video_sender_info); |
Steve Anton | 5b38731 | 2018-02-03 00:00:20 | [diff] [blame] | 1105 | |
Tommi | 1901551 | 2022-02-02 10:49:35 | [diff] [blame] | 1106 | pc->AddVideoChannel("video", "transport", video_info); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 1107 | |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1108 | AddOutgoingVideoTrack(pc, stats.get()); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 1109 | |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1110 | stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard); |
tommi@webrtc.org | 03505bc | 2014-07-14 20:15:26 | [diff] [blame] | 1111 | StatsReports reports; |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1112 | stats->GetStats(nullptr, &reports); |
| 1113 | |
Artem Titov | 880fa81 | 2021-07-30 20:30:23 | [diff] [blame] | 1114 | // `reports` should contain at least one session report, one track report, |
wu@webrtc.org | 97077a3 | 2013-10-25 21:18:33 | [diff] [blame] | 1115 | // and one ssrc report. |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1116 | EXPECT_LE(3u, reports.size()); |
Yves Gerey | 665174f | 2018-06-19 13:03:05 | [diff] [blame] | 1117 | const StatsReport* track_report = |
| 1118 | FindNthReportByType(reports, StatsReport::kStatsReportTypeTrack, 1); |
xians@webrtc.org | 4cb0128 | 2014-06-12 14:57:05 | [diff] [blame] | 1119 | EXPECT_TRUE(track_report); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 1120 | |
Artem Titov | 880fa81 | 2021-07-30 20:30:23 | [diff] [blame] | 1121 | // Get report for the specific `track`. |
tommi@webrtc.org | 5b06b06 | 2014-08-15 08:38:30 | [diff] [blame] | 1122 | reports.clear(); |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1123 | stats->GetStats(track_, &reports); |
Artem Titov | 880fa81 | 2021-07-30 20:30:23 | [diff] [blame] | 1124 | // `reports` should contain at least one session report, one track report, |
wu@webrtc.org | 97077a3 | 2013-10-25 21:18:33 | [diff] [blame] | 1125 | // and one ssrc report. |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1126 | EXPECT_LE(3u, reports.size()); |
Yves Gerey | 665174f | 2018-06-19 13:03:05 | [diff] [blame] | 1127 | track_report = |
| 1128 | FindNthReportByType(reports, StatsReport::kStatsReportTypeTrack, 1); |
Harald Alvestrand | 75ceef2 | 2018-01-04 14:26:13 | [diff] [blame] | 1129 | ASSERT_TRUE(track_report); |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1130 | EXPECT_EQ(stats->GetTimeNow(), track_report->timestamp()); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 1131 | |
Yves Gerey | 665174f | 2018-06-19 13:03:05 | [diff] [blame] | 1132 | std::string ssrc_id = |
| 1133 | ExtractSsrcStatsValue(reports, StatsReport::kStatsValueNameSsrc); |
Jonas Olsson | 6b1985d | 2018-07-05 09:59:48 | [diff] [blame] | 1134 | EXPECT_EQ(rtc::ToString(kSsrcOfTrack), ssrc_id); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 1135 | |
Yves Gerey | 665174f | 2018-06-19 13:03:05 | [diff] [blame] | 1136 | std::string track_id = |
| 1137 | ExtractSsrcStatsValue(reports, StatsReport::kStatsValueNameTrackId); |
xians@webrtc.org | 4cb0128 | 2014-06-12 14:57:05 | [diff] [blame] | 1138 | EXPECT_EQ(kLocalTrackId, track_id); |
fippo | bec70ab | 2016-01-28 09:27:15 | [diff] [blame] | 1139 | |
Yves Gerey | 665174f | 2018-06-19 13:03:05 | [diff] [blame] | 1140 | std::string media_type = |
| 1141 | ExtractSsrcStatsValue(reports, StatsReport::kStatsValueNameMediaType); |
fippo | bec70ab | 2016-01-28 09:27:15 | [diff] [blame] | 1142 | EXPECT_EQ("video", media_type); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 1143 | } |
| 1144 | |
| 1145 | // This test verifies that an SSRC object has the identifier of a Transport |
| 1146 | // stats object, and that this transport stats object exists in stats. |
Harald Alvestrand | 75ceef2 | 2018-01-04 14:26:13 | [diff] [blame] | 1147 | TEST_P(StatsCollectorTrackTest, TransportObjectLinkedFromSsrcObject) { |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1148 | constexpr int64_t kBytesSent = 12345678901234LL; |
decurtis@webrtc.org | 487a444 | 2015-01-15 22:55:07 | [diff] [blame] | 1149 | |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1150 | auto pc = CreatePeerConnection(); |
| 1151 | auto stats = CreateStatsCollector(pc); |
deadbeef | cbecd35 | 2015-09-23 18:50:27 | [diff] [blame] | 1152 | |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1153 | VideoSenderInfo video_sender_info; |
sergeyu@chromium.org | 5bc25c4 | 2013-12-05 00:24:06 | [diff] [blame] | 1154 | video_sender_info.add_ssrc(1234); |
Niels Möller | ac0a4cb | 2019-10-09 13:01:33 | [diff] [blame] | 1155 | video_sender_info.payload_bytes_sent = kBytesSent - 12; |
| 1156 | video_sender_info.header_and_padding_bytes_sent = 12; |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1157 | VideoMediaInfo video_info; |
Henrik Boström | a0ff50c | 2020-05-05 13:54:46 | [diff] [blame] | 1158 | video_info.aggregated_senders.push_back(video_sender_info); |
Steve Anton | 5b38731 | 2018-02-03 00:00:20 | [diff] [blame] | 1159 | |
Tommi | 1901551 | 2022-02-02 10:49:35 | [diff] [blame] | 1160 | pc->AddVideoChannel("video", "transport", video_info); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 1161 | |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1162 | AddOutgoingVideoTrack(pc, stats.get()); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 1163 | |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1164 | stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard); |
tommi@webrtc.org | 03505bc | 2014-07-14 20:15:26 | [diff] [blame] | 1165 | StatsReports reports; |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1166 | stats->GetStats(nullptr, &reports); |
| 1167 | |
Yves Gerey | 665174f | 2018-06-19 13:03:05 | [diff] [blame] | 1168 | std::string transport_id = |
| 1169 | ExtractStatsValue(StatsReport::kStatsReportTypeSsrc, reports, |
| 1170 | StatsReport::kStatsValueNameTransportId); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 1171 | ASSERT_NE(kNotFound, transport_id); |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1172 | |
tommi@webrtc.org | 4fb7e25 | 2015-01-21 11:36:18 | [diff] [blame] | 1173 | // Transport id component ID will always be 1. |
| 1174 | // This has assumptions about how the ID is constructed. As is, this is |
| 1175 | // OK since this is for testing purposes only, but if we ever need this |
| 1176 | // in production, we should add a generic method that does this. |
| 1177 | size_t index = transport_id.find('-'); |
| 1178 | ASSERT_NE(std::string::npos, index); |
| 1179 | std::string content = transport_id.substr(index + 1); |
| 1180 | index = content.rfind('-'); |
| 1181 | ASSERT_NE(std::string::npos, index); |
| 1182 | content = content.substr(0, index); |
tommi@webrtc.org | d390029 | 2015-03-12 16:35:55 | [diff] [blame] | 1183 | StatsReport::Id id(StatsReport::NewComponentId(content, 1)); |
tommi@webrtc.org | 4fb7e25 | 2015-01-21 11:36:18 | [diff] [blame] | 1184 | ASSERT_EQ(transport_id, id->ToString()); |
tommi@webrtc.org | d390029 | 2015-03-12 16:35:55 | [diff] [blame] | 1185 | const StatsReport* transport_report = FindReportById(reports, id); |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1186 | ASSERT_TRUE(transport_report); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 1187 | } |
| 1188 | |
wu@webrtc.org | 97077a3 | 2013-10-25 21:18:33 | [diff] [blame] | 1189 | // This test verifies that a remote stats object will not be created for |
| 1190 | // an outgoing SSRC where remote stats are not returned. |
Harald Alvestrand | 75ceef2 | 2018-01-04 14:26:13 | [diff] [blame] | 1191 | TEST_P(StatsCollectorTrackTest, RemoteSsrcInfoIsAbsent) { |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1192 | auto pc = CreatePeerConnection(); |
| 1193 | auto stats = CreateStatsCollector(pc); |
decurtis@webrtc.org | 487a444 | 2015-01-15 22:55:07 | [diff] [blame] | 1194 | |
Steve Anton | 5b38731 | 2018-02-03 00:00:20 | [diff] [blame] | 1195 | pc->AddVideoChannel("video", "transport"); |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1196 | AddOutgoingVideoTrack(pc, stats.get()); |
wu@webrtc.org | 97077a3 | 2013-10-25 21:18:33 | [diff] [blame] | 1197 | |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1198 | stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard); |
henrike@webrtc.org | 40b3b68 | 2014-03-03 18:30:11 | [diff] [blame] | 1199 | StatsReports reports; |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1200 | stats->GetStats(nullptr, &reports); |
| 1201 | |
Yves Gerey | 665174f | 2018-06-19 13:03:05 | [diff] [blame] | 1202 | const StatsReport* remote_report = |
| 1203 | FindNthReportByType(reports, StatsReport::kStatsReportTypeRemoteSsrc, 1); |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1204 | EXPECT_FALSE(remote_report); |
wu@webrtc.org | 97077a3 | 2013-10-25 21:18:33 | [diff] [blame] | 1205 | } |
| 1206 | |
| 1207 | // This test verifies that a remote stats object will be created for |
| 1208 | // an outgoing SSRC where stats are returned. |
Harald Alvestrand | 75ceef2 | 2018-01-04 14:26:13 | [diff] [blame] | 1209 | TEST_P(StatsCollectorTrackTest, RemoteSsrcInfoIsPresent) { |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1210 | auto pc = CreatePeerConnection(); |
| 1211 | auto stats = CreateStatsCollector(pc); |
decurtis@webrtc.org | 487a444 | 2015-01-15 22:55:07 | [diff] [blame] | 1212 | |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1213 | SsrcReceiverInfo remote_ssrc_stats; |
wu@webrtc.org | 97077a3 | 2013-10-25 21:18:33 | [diff] [blame] | 1214 | remote_ssrc_stats.timestamp = 12345.678; |
| 1215 | remote_ssrc_stats.ssrc = kSsrcOfTrack; |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1216 | VideoSenderInfo video_sender_info; |
sergeyu@chromium.org | 5bc25c4 | 2013-12-05 00:24:06 | [diff] [blame] | 1217 | video_sender_info.add_ssrc(kSsrcOfTrack); |
wu@webrtc.org | 97077a3 | 2013-10-25 21:18:33 | [diff] [blame] | 1218 | video_sender_info.remote_stats.push_back(remote_ssrc_stats); |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1219 | VideoMediaInfo video_info; |
Henrik Boström | a0ff50c | 2020-05-05 13:54:46 | [diff] [blame] | 1220 | video_info.aggregated_senders.push_back(video_sender_info); |
Steve Anton | 5b38731 | 2018-02-03 00:00:20 | [diff] [blame] | 1221 | |
Tommi | 1901551 | 2022-02-02 10:49:35 | [diff] [blame] | 1222 | pc->AddVideoChannel("video", "transport", video_info); |
wu@webrtc.org | 97077a3 | 2013-10-25 21:18:33 | [diff] [blame] | 1223 | |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1224 | AddOutgoingVideoTrack(pc, stats.get()); |
wu@webrtc.org | 97077a3 | 2013-10-25 21:18:33 | [diff] [blame] | 1225 | |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1226 | stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard); |
tommi@webrtc.org | 03505bc | 2014-07-14 20:15:26 | [diff] [blame] | 1227 | StatsReports reports; |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1228 | stats->GetStats(nullptr, &reports); |
xians@webrtc.org | 4cb0128 | 2014-06-12 14:57:05 | [diff] [blame] | 1229 | |
Yves Gerey | 665174f | 2018-06-19 13:03:05 | [diff] [blame] | 1230 | const StatsReport* remote_report = |
| 1231 | FindNthReportByType(reports, StatsReport::kStatsReportTypeRemoteSsrc, 1); |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1232 | ASSERT_TRUE(remote_report); |
decurtis@webrtc.org | 322a564 | 2015-02-03 22:09:37 | [diff] [blame] | 1233 | EXPECT_EQ(12345.678, remote_report->timestamp()); |
wu@webrtc.org | 97077a3 | 2013-10-25 21:18:33 | [diff] [blame] | 1234 | } |
| 1235 | |
xians@webrtc.org | 4cb0128 | 2014-06-12 14:57:05 | [diff] [blame] | 1236 | // This test verifies that the empty track report exists in the returned stats |
| 1237 | // when StatsCollector::UpdateStats is called with ssrc stats. |
Harald Alvestrand | 75ceef2 | 2018-01-04 14:26:13 | [diff] [blame] | 1238 | TEST_P(StatsCollectorTrackTest, ReportsFromRemoteTrack) { |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1239 | constexpr int64_t kNumOfPacketsConcealed = 54321; |
decurtis@webrtc.org | 487a444 | 2015-01-15 22:55:07 | [diff] [blame] | 1240 | |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1241 | auto pc = CreatePeerConnection(); |
| 1242 | auto stats = CreateStatsCollector(pc); |
deadbeef | cbecd35 | 2015-09-23 18:50:27 | [diff] [blame] | 1243 | |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1244 | VideoReceiverInfo video_receiver_info; |
xians@webrtc.org | 4cb0128 | 2014-06-12 14:57:05 | [diff] [blame] | 1245 | video_receiver_info.add_ssrc(1234); |
pbos@webrtc.org | 1ed6224 | 2015-02-19 13:57:03 | [diff] [blame] | 1246 | video_receiver_info.packets_concealed = kNumOfPacketsConcealed; |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1247 | VideoMediaInfo video_info; |
| 1248 | video_info.receivers.push_back(video_receiver_info); |
Steve Anton | 5b38731 | 2018-02-03 00:00:20 | [diff] [blame] | 1249 | |
Tommi | 1901551 | 2022-02-02 10:49:35 | [diff] [blame] | 1250 | pc->AddVideoChannel("video", "transport", video_info); |
xians@webrtc.org | 4cb0128 | 2014-06-12 14:57:05 | [diff] [blame] | 1251 | |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1252 | AddIncomingVideoTrack(pc, stats.get()); |
xians@webrtc.org | 4cb0128 | 2014-06-12 14:57:05 | [diff] [blame] | 1253 | |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1254 | stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard); |
tommi@webrtc.org | 03505bc | 2014-07-14 20:15:26 | [diff] [blame] | 1255 | StatsReports reports; |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1256 | stats->GetStats(nullptr, &reports); |
| 1257 | |
Artem Titov | 880fa81 | 2021-07-30 20:30:23 | [diff] [blame] | 1258 | // `reports` should contain at least one session report, one track report, |
xians@webrtc.org | 4cb0128 | 2014-06-12 14:57:05 | [diff] [blame] | 1259 | // and one ssrc report. |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1260 | EXPECT_LE(3u, reports.size()); |
Yves Gerey | 665174f | 2018-06-19 13:03:05 | [diff] [blame] | 1261 | const StatsReport* track_report = |
| 1262 | FindNthReportByType(reports, StatsReport::kStatsReportTypeTrack, 1); |
Harald Alvestrand | 75ceef2 | 2018-01-04 14:26:13 | [diff] [blame] | 1263 | ASSERT_TRUE(track_report); |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1264 | EXPECT_EQ(stats->GetTimeNow(), track_report->timestamp()); |
xians@webrtc.org | 4cb0128 | 2014-06-12 14:57:05 | [diff] [blame] | 1265 | |
Yves Gerey | 665174f | 2018-06-19 13:03:05 | [diff] [blame] | 1266 | std::string ssrc_id = |
| 1267 | ExtractSsrcStatsValue(reports, StatsReport::kStatsValueNameSsrc); |
Jonas Olsson | 6b1985d | 2018-07-05 09:59:48 | [diff] [blame] | 1268 | EXPECT_EQ(rtc::ToString(kSsrcOfTrack), ssrc_id); |
xians@webrtc.org | 4cb0128 | 2014-06-12 14:57:05 | [diff] [blame] | 1269 | |
Yves Gerey | 665174f | 2018-06-19 13:03:05 | [diff] [blame] | 1270 | std::string track_id = |
| 1271 | ExtractSsrcStatsValue(reports, StatsReport::kStatsValueNameTrackId); |
xians@webrtc.org | 4cb0128 | 2014-06-12 14:57:05 | [diff] [blame] | 1272 | EXPECT_EQ(kRemoteTrackId, track_id); |
| 1273 | } |
| 1274 | |
guoweis@webrtc.org | 950c518 | 2014-12-16 23:01:31 | [diff] [blame] | 1275 | // This test verifies the Ice Candidate report should contain the correct |
| 1276 | // information from local/remote candidates. |
| 1277 | TEST_F(StatsCollectorTest, IceCandidateReport) { |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1278 | const std::string kTransportName = "transport"; |
| 1279 | const rtc::AdapterType kNetworkType = rtc::ADAPTER_TYPE_ETHERNET; |
| 1280 | constexpr uint32_t kPriority = 1000; |
decurtis@webrtc.org | 487a444 | 2015-01-15 22:55:07 | [diff] [blame] | 1281 | |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1282 | constexpr int kLocalPort = 2000; |
| 1283 | const std::string kLocalIp = "192.168.0.1"; |
| 1284 | const rtc::SocketAddress kLocalAddress(kLocalIp, kLocalPort); |
guoweis@webrtc.org | 950c518 | 2014-12-16 23:01:31 | [diff] [blame] | 1285 | |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1286 | constexpr int kRemotePort = 2001; |
| 1287 | const std::string kRemoteIp = "192.168.0.2"; |
| 1288 | const rtc::SocketAddress kRemoteAddress(kRemoteIp, kRemotePort); |
guoweis@webrtc.org | 950c518 | 2014-12-16 23:01:31 | [diff] [blame] | 1289 | |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1290 | auto pc = CreatePeerConnection(); |
| 1291 | auto stats = CreateStatsCollector(pc); |
guoweis@webrtc.org | 950c518 | 2014-12-16 23:01:31 | [diff] [blame] | 1292 | |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1293 | cricket::Candidate local; |
| 1294 | EXPECT_GT(local.id().length(), 0u); |
| 1295 | local.set_type(cricket::LOCAL_PORT_TYPE); |
| 1296 | local.set_protocol(cricket::UDP_PROTOCOL_NAME); |
| 1297 | local.set_address(kLocalAddress); |
| 1298 | local.set_priority(kPriority); |
| 1299 | local.set_network_type(kNetworkType); |
guoweis@webrtc.org | 950c518 | 2014-12-16 23:01:31 | [diff] [blame] | 1300 | |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1301 | cricket::Candidate remote; |
| 1302 | EXPECT_GT(remote.id().length(), 0u); |
| 1303 | remote.set_type(cricket::PRFLX_PORT_TYPE); |
| 1304 | remote.set_protocol(cricket::UDP_PROTOCOL_NAME); |
| 1305 | remote.set_address(kRemoteAddress); |
| 1306 | remote.set_priority(kPriority); |
| 1307 | remote.set_network_type(kNetworkType); |
guoweis@webrtc.org | 950c518 | 2014-12-16 23:01:31 | [diff] [blame] | 1308 | |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1309 | ConnectionInfo connection_info; |
| 1310 | connection_info.local_candidate = local; |
| 1311 | connection_info.remote_candidate = remote; |
| 1312 | TransportChannelStats channel_stats; |
Jonas Oreland | 149dc72 | 2019-08-28 06:10:27 | [diff] [blame] | 1313 | channel_stats.ice_transport_stats.connection_infos.push_back(connection_info); |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1314 | |
Steve Anton | 5b38731 | 2018-02-03 00:00:20 | [diff] [blame] | 1315 | pc->AddVoiceChannel("audio", kTransportName); |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1316 | pc->SetTransportStats(kTransportName, channel_stats); |
| 1317 | |
| 1318 | stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard); |
| 1319 | StatsReports reports; |
| 1320 | stats->GetStats(nullptr, &reports); |
guoweis@webrtc.org | 950c518 | 2014-12-16 23:01:31 | [diff] [blame] | 1321 | |
| 1322 | // Verify the local candidate report is populated correctly. |
| 1323 | EXPECT_EQ( |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1324 | "Cand-" + local.id(), |
| 1325 | ExtractStatsValue(StatsReport::kStatsReportTypeCandidatePair, reports, |
| 1326 | StatsReport::kStatsValueNameLocalCandidateId)); |
| 1327 | EXPECT_EQ( |
| 1328 | kLocalIp, |
guoweis@webrtc.org | 950c518 | 2014-12-16 23:01:31 | [diff] [blame] | 1329 | ExtractStatsValue(StatsReport::kStatsReportTypeIceLocalCandidate, reports, |
| 1330 | StatsReport::kStatsValueNameCandidateIPAddress)); |
| 1331 | EXPECT_EQ( |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1332 | rtc::ToString(kLocalPort), |
guoweis@webrtc.org | 950c518 | 2014-12-16 23:01:31 | [diff] [blame] | 1333 | ExtractStatsValue(StatsReport::kStatsReportTypeIceLocalCandidate, reports, |
| 1334 | StatsReport::kStatsValueNameCandidatePortNumber)); |
| 1335 | EXPECT_EQ( |
| 1336 | cricket::UDP_PROTOCOL_NAME, |
| 1337 | ExtractStatsValue(StatsReport::kStatsReportTypeIceLocalCandidate, reports, |
| 1338 | StatsReport::kStatsValueNameCandidateTransportType)); |
| 1339 | EXPECT_EQ( |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1340 | rtc::ToString(kPriority), |
guoweis@webrtc.org | 950c518 | 2014-12-16 23:01:31 | [diff] [blame] | 1341 | ExtractStatsValue(StatsReport::kStatsReportTypeIceLocalCandidate, reports, |
| 1342 | StatsReport::kStatsValueNameCandidatePriority)); |
| 1343 | EXPECT_EQ( |
| 1344 | IceCandidateTypeToStatsType(cricket::LOCAL_PORT_TYPE), |
| 1345 | ExtractStatsValue(StatsReport::kStatsReportTypeIceLocalCandidate, reports, |
| 1346 | StatsReport::kStatsValueNameCandidateType)); |
| 1347 | EXPECT_EQ( |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1348 | AdapterTypeToStatsType(kNetworkType), |
guoweis@webrtc.org | 950c518 | 2014-12-16 23:01:31 | [diff] [blame] | 1349 | ExtractStatsValue(StatsReport::kStatsReportTypeIceLocalCandidate, reports, |
| 1350 | StatsReport::kStatsValueNameCandidateNetworkType)); |
| 1351 | |
| 1352 | // Verify the remote candidate report is populated correctly. |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1353 | EXPECT_EQ( |
| 1354 | "Cand-" + remote.id(), |
| 1355 | ExtractStatsValue(StatsReport::kStatsReportTypeCandidatePair, reports, |
| 1356 | StatsReport::kStatsValueNameRemoteCandidateId)); |
| 1357 | EXPECT_EQ(kRemoteIp, |
guoweis@webrtc.org | 950c518 | 2014-12-16 23:01:31 | [diff] [blame] | 1358 | ExtractStatsValue(StatsReport::kStatsReportTypeIceRemoteCandidate, |
| 1359 | reports, |
| 1360 | StatsReport::kStatsValueNameCandidateIPAddress)); |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1361 | EXPECT_EQ(rtc::ToString(kRemotePort), |
guoweis@webrtc.org | 950c518 | 2014-12-16 23:01:31 | [diff] [blame] | 1362 | ExtractStatsValue(StatsReport::kStatsReportTypeIceRemoteCandidate, |
| 1363 | reports, |
| 1364 | StatsReport::kStatsValueNameCandidatePortNumber)); |
| 1365 | EXPECT_EQ(cricket::UDP_PROTOCOL_NAME, |
| 1366 | ExtractStatsValue( |
| 1367 | StatsReport::kStatsReportTypeIceRemoteCandidate, reports, |
| 1368 | StatsReport::kStatsValueNameCandidateTransportType)); |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1369 | EXPECT_EQ(rtc::ToString(kPriority), |
guoweis@webrtc.org | 950c518 | 2014-12-16 23:01:31 | [diff] [blame] | 1370 | ExtractStatsValue(StatsReport::kStatsReportTypeIceRemoteCandidate, |
| 1371 | reports, |
| 1372 | StatsReport::kStatsValueNameCandidatePriority)); |
| 1373 | EXPECT_EQ( |
| 1374 | IceCandidateTypeToStatsType(cricket::PRFLX_PORT_TYPE), |
| 1375 | ExtractStatsValue(StatsReport::kStatsReportTypeIceRemoteCandidate, |
| 1376 | reports, StatsReport::kStatsValueNameCandidateType)); |
| 1377 | EXPECT_EQ(kNotFound, |
| 1378 | ExtractStatsValue( |
| 1379 | StatsReport::kStatsReportTypeIceRemoteCandidate, reports, |
| 1380 | StatsReport::kStatsValueNameCandidateNetworkType)); |
| 1381 | } |
| 1382 | |
wu@webrtc.org | 4551b79 | 2013-10-09 15:37:36 | [diff] [blame] | 1383 | // This test verifies that all chained certificates are correctly |
| 1384 | // reported |
mallinath@webrtc.org | 19f27e6 | 2013-10-13 17:18:27 | [diff] [blame] | 1385 | TEST_F(StatsCollectorTest, ChainedCertificateReportsCreated) { |
wu@webrtc.org | 4551b79 | 2013-10-09 15:37:36 | [diff] [blame] | 1386 | // Build local certificate chain. |
| 1387 | std::vector<std::string> local_ders(5); |
| 1388 | local_ders[0] = "These"; |
| 1389 | local_ders[1] = "are"; |
| 1390 | local_ders[2] = "some"; |
| 1391 | local_ders[3] = "der"; |
| 1392 | local_ders[4] = "values"; |
Taylor Brandstetter | c392866 | 2018-02-23 21:04:51 | [diff] [blame] | 1393 | rtc::FakeSSLIdentity local_identity(DersToPems(local_ders)); |
wu@webrtc.org | 4551b79 | 2013-10-09 15:37:36 | [diff] [blame] | 1394 | |
| 1395 | // Build remote certificate chain |
| 1396 | std::vector<std::string> remote_ders(4); |
| 1397 | remote_ders[0] = "A"; |
| 1398 | remote_ders[1] = "non-"; |
| 1399 | remote_ders[2] = "intersecting"; |
| 1400 | remote_ders[3] = "set"; |
Taylor Brandstetter | c392866 | 2018-02-23 21:04:51 | [diff] [blame] | 1401 | rtc::FakeSSLIdentity remote_identity(DersToPems(remote_ders)); |
wu@webrtc.org | 4551b79 | 2013-10-09 15:37:36 | [diff] [blame] | 1402 | |
Taylor Brandstetter | c392866 | 2018-02-23 21:04:51 | [diff] [blame] | 1403 | TestCertificateReports(local_identity, local_ders, remote_identity, |
kwiberg | b4d01c4 | 2016-04-06 12:15:06 | [diff] [blame] | 1404 | remote_ders); |
wu@webrtc.org | 4551b79 | 2013-10-09 15:37:36 | [diff] [blame] | 1405 | } |
| 1406 | |
| 1407 | // This test verifies that all certificates without chains are correctly |
| 1408 | // reported. |
mallinath@webrtc.org | 19f27e6 | 2013-10-13 17:18:27 | [diff] [blame] | 1409 | TEST_F(StatsCollectorTest, ChainlessCertificateReportsCreated) { |
wu@webrtc.org | 4551b79 | 2013-10-09 15:37:36 | [diff] [blame] | 1410 | // Build local certificate. |
| 1411 | std::string local_der = "This is the local der."; |
Taylor Brandstetter | c392866 | 2018-02-23 21:04:51 | [diff] [blame] | 1412 | rtc::FakeSSLIdentity local_identity(DerToPem(local_der)); |
wu@webrtc.org | 4551b79 | 2013-10-09 15:37:36 | [diff] [blame] | 1413 | |
| 1414 | // Build remote certificate. |
| 1415 | std::string remote_der = "This is somebody else's der."; |
Taylor Brandstetter | c392866 | 2018-02-23 21:04:51 | [diff] [blame] | 1416 | rtc::FakeSSLIdentity remote_identity(DerToPem(remote_der)); |
wu@webrtc.org | 4551b79 | 2013-10-09 15:37:36 | [diff] [blame] | 1417 | |
Taylor Brandstetter | c392866 | 2018-02-23 21:04:51 | [diff] [blame] | 1418 | TestCertificateReports(local_identity, std::vector<std::string>(1, local_der), |
| 1419 | remote_identity, |
kwiberg | b4d01c4 | 2016-04-06 12:15:06 | [diff] [blame] | 1420 | std::vector<std::string>(1, remote_der)); |
wu@webrtc.org | 4551b79 | 2013-10-09 15:37:36 | [diff] [blame] | 1421 | } |
| 1422 | |
| 1423 | // This test verifies that the stats are generated correctly when no |
| 1424 | // transport is present. |
mallinath@webrtc.org | 19f27e6 | 2013-10-13 17:18:27 | [diff] [blame] | 1425 | TEST_F(StatsCollectorTest, NoTransport) { |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1426 | auto pc = CreatePeerConnection(); |
| 1427 | auto stats = CreateStatsCollector(pc); |
decurtis@webrtc.org | 487a444 | 2015-01-15 22:55:07 | [diff] [blame] | 1428 | |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1429 | // This will cause the fake PeerConnection to generate a TransportStats entry |
| 1430 | // but with only a single dummy TransportChannelStats. |
Steve Anton | 5b38731 | 2018-02-03 00:00:20 | [diff] [blame] | 1431 | pc->AddVoiceChannel("audio", "transport"); |
deadbeef | cbecd35 | 2015-09-23 18:50:27 | [diff] [blame] | 1432 | |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1433 | stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard); |
| 1434 | StatsReports reports; |
| 1435 | stats->GetStats(nullptr, &reports); |
wu@webrtc.org | 4551b79 | 2013-10-09 15:37:36 | [diff] [blame] | 1436 | |
| 1437 | // Check that the local certificate is absent. |
Yves Gerey | 665174f | 2018-06-19 13:03:05 | [diff] [blame] | 1438 | std::string local_certificate_id = |
| 1439 | ExtractStatsValue(StatsReport::kStatsReportTypeComponent, reports, |
| 1440 | StatsReport::kStatsValueNameLocalCertificateId); |
wu@webrtc.org | 4551b79 | 2013-10-09 15:37:36 | [diff] [blame] | 1441 | ASSERT_EQ(kNotFound, local_certificate_id); |
| 1442 | |
| 1443 | // Check that the remote certificate is absent. |
Yves Gerey | 665174f | 2018-06-19 13:03:05 | [diff] [blame] | 1444 | std::string remote_certificate_id = |
| 1445 | ExtractStatsValue(StatsReport::kStatsReportTypeComponent, reports, |
| 1446 | StatsReport::kStatsValueNameRemoteCertificateId); |
wu@webrtc.org | 4551b79 | 2013-10-09 15:37:36 | [diff] [blame] | 1447 | ASSERT_EQ(kNotFound, remote_certificate_id); |
pthatcher@webrtc.org | 7bea1ff | 2015-03-04 01:38:30 | [diff] [blame] | 1448 | |
| 1449 | // Check that the negotiated ciphers are absent. |
Guo-wei Shieh | 521ed7b | 2015-11-19 03:41:53 | [diff] [blame] | 1450 | std::string dtls_cipher_suite = |
| 1451 | ExtractStatsValue(StatsReport::kStatsReportTypeComponent, reports, |
| 1452 | StatsReport::kStatsValueNameDtlsCipher); |
| 1453 | ASSERT_EQ(kNotFound, dtls_cipher_suite); |
| 1454 | std::string srtp_crypto_suite = |
| 1455 | ExtractStatsValue(StatsReport::kStatsReportTypeComponent, reports, |
| 1456 | StatsReport::kStatsValueNameSrtpCipher); |
| 1457 | ASSERT_EQ(kNotFound, srtp_crypto_suite); |
wu@webrtc.org | 4551b79 | 2013-10-09 15:37:36 | [diff] [blame] | 1458 | } |
| 1459 | |
wu@webrtc.org | b9a088b | 2014-02-13 23:18:49 | [diff] [blame] | 1460 | // This test verifies that a remote certificate with an unsupported digest |
| 1461 | // algorithm is correctly ignored. |
| 1462 | TEST_F(StatsCollectorTest, UnsupportedDigestIgnored) { |
| 1463 | // Build a local certificate. |
| 1464 | std::string local_der = "This is the local der."; |
Taylor Brandstetter | c392866 | 2018-02-23 21:04:51 | [diff] [blame] | 1465 | rtc::FakeSSLIdentity local_identity(DerToPem(local_der)); |
wu@webrtc.org | b9a088b | 2014-02-13 23:18:49 | [diff] [blame] | 1466 | |
| 1467 | // Build a remote certificate with an unsupported digest algorithm. |
| 1468 | std::string remote_der = "This is somebody else's der."; |
Taylor Brandstetter | c392866 | 2018-02-23 21:04:51 | [diff] [blame] | 1469 | rtc::FakeSSLCertificate remote_cert(DerToPem(remote_der)); |
| 1470 | remote_cert.set_digest_algorithm("foobar"); |
| 1471 | rtc::FakeSSLIdentity remote_identity(remote_cert); |
wu@webrtc.org | b9a088b | 2014-02-13 23:18:49 | [diff] [blame] | 1472 | |
Taylor Brandstetter | c392866 | 2018-02-23 21:04:51 | [diff] [blame] | 1473 | TestCertificateReports(local_identity, std::vector<std::string>(1, local_der), |
| 1474 | remote_identity, std::vector<std::string>()); |
wu@webrtc.org | b9a088b | 2014-02-13 23:18:49 | [diff] [blame] | 1475 | } |
| 1476 | |
zhihuang | 6ba3b19 | 2016-05-13 18:46:35 | [diff] [blame] | 1477 | // This test verifies that the audio/video related stats which are -1 initially |
| 1478 | // will be filtered out. |
Harald Alvestrand | 75ceef2 | 2018-01-04 14:26:13 | [diff] [blame] | 1479 | TEST_P(StatsCollectorTrackTest, FilterOutNegativeInitialValues) { |
Harald Alvestrand | 75ceef2 | 2018-01-04 14:26:13 | [diff] [blame] | 1480 | // This test uses streams, but only works for the stream case. |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1481 | if (!GetParam()) { |
Harald Alvestrand | 75ceef2 | 2018-01-04 14:26:13 | [diff] [blame] | 1482 | return; |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1483 | } |
zhihuang | 6ba3b19 | 2016-05-13 18:46:35 | [diff] [blame] | 1484 | |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1485 | auto pc = CreatePeerConnection(); |
| 1486 | auto stats = CreateStatsCollector(pc); |
zhihuang | 6ba3b19 | 2016-05-13 18:46:35 | [diff] [blame] | 1487 | |
| 1488 | // Create a local stream with a local audio track and adds it to the stats. |
Seth Hampson | 845e878 | 2018-03-02 19:34:10 | [diff] [blame] | 1489 | stream_ = MediaStream::Create("streamid"); |
Tommi | 87f7090 | 2021-04-27 12:43:08 | [diff] [blame] | 1490 | auto local_track = |
| 1491 | rtc::make_ref_counted<FakeAudioTrackWithInitValue>(kLocalTrackId); |
zhihuang | 6ba3b19 | 2016-05-13 18:46:35 | [diff] [blame] | 1492 | stream_->AddTrack(local_track); |
Steve Anton | efe4c92 | 2019-03-27 17:26:06 | [diff] [blame] | 1493 | pc->AddSender(CreateMockSender(local_track, kSsrcOfTrack)); |
Harald Alvestrand | 75ceef2 | 2018-01-04 14:26:13 | [diff] [blame] | 1494 | if (GetParam()) { |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1495 | stats->AddStream(stream_); |
Harald Alvestrand | 75ceef2 | 2018-01-04 14:26:13 | [diff] [blame] | 1496 | } |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1497 | stats->AddLocalAudioTrack(local_track.get(), kSsrcOfTrack); |
zhihuang | 6ba3b19 | 2016-05-13 18:46:35 | [diff] [blame] | 1498 | |
| 1499 | // Create a remote stream with a remote audio track and adds it to the stats. |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1500 | rtc::scoped_refptr<MediaStream> remote_stream( |
Seth Hampson | 845e878 | 2018-03-02 19:34:10 | [diff] [blame] | 1501 | MediaStream::Create("remotestreamid")); |
Tommi | 87f7090 | 2021-04-27 12:43:08 | [diff] [blame] | 1502 | auto remote_track = |
| 1503 | rtc::make_ref_counted<FakeAudioTrackWithInitValue>(kRemoteTrackId); |
zhihuang | 6ba3b19 | 2016-05-13 18:46:35 | [diff] [blame] | 1504 | remote_stream->AddTrack(remote_track); |
Steve Anton | efe4c92 | 2019-03-27 17:26:06 | [diff] [blame] | 1505 | pc->AddReceiver(CreateMockReceiver(remote_track, kSsrcOfTrack)); |
Harald Alvestrand | 75ceef2 | 2018-01-04 14:26:13 | [diff] [blame] | 1506 | if (GetParam()) { |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1507 | stats->AddStream(remote_stream); |
Harald Alvestrand | 75ceef2 | 2018-01-04 14:26:13 | [diff] [blame] | 1508 | } |
zhihuang | 6ba3b19 | 2016-05-13 18:46:35 | [diff] [blame] | 1509 | |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1510 | VoiceSenderInfo voice_sender_info; |
zhihuang | 6ba3b19 | 2016-05-13 18:46:35 | [diff] [blame] | 1511 | voice_sender_info.add_ssrc(kSsrcOfTrack); |
| 1512 | // These values are set to -1 initially in audio_send_stream. |
| 1513 | // The voice_sender_info will read the values from audio_send_stream. |
| 1514 | voice_sender_info.rtt_ms = -1; |
| 1515 | voice_sender_info.packets_lost = -1; |
| 1516 | voice_sender_info.jitter_ms = -1; |
| 1517 | |
Artem Titov | 880fa81 | 2021-07-30 20:30:23 | [diff] [blame] | 1518 | // Some of the contents in `voice_sender_info` needs to be updated from the |
| 1519 | // `audio_track_`. |
Ivo Creusen | 56d46090 | 2017-11-24 16:29:59 | [diff] [blame] | 1520 | UpdateVoiceSenderInfoFromAudioTrack(local_track.get(), &voice_sender_info, |
| 1521 | true); |
zhihuang | 6ba3b19 | 2016-05-13 18:46:35 | [diff] [blame] | 1522 | |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1523 | VoiceReceiverInfo voice_receiver_info; |
zhihuang | 6ba3b19 | 2016-05-13 18:46:35 | [diff] [blame] | 1524 | voice_receiver_info.add_ssrc(kSsrcOfTrack); |
| 1525 | voice_receiver_info.capture_start_ntp_time_ms = -1; |
| 1526 | voice_receiver_info.audio_level = -1; |
| 1527 | |
| 1528 | // Constructs an ssrc stats update. |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1529 | VoiceMediaInfo voice_info; |
| 1530 | voice_info.senders.push_back(voice_sender_info); |
| 1531 | voice_info.receivers.push_back(voice_receiver_info); |
zhihuang | 6ba3b19 | 2016-05-13 18:46:35 | [diff] [blame] | 1532 | |
Steve Anton | 5b38731 | 2018-02-03 00:00:20 | [diff] [blame] | 1533 | auto* voice_media_channel = pc->AddVoiceChannel("voice", "transport"); |
| 1534 | voice_media_channel->SetStats(voice_info); |
zhihuang | 6ba3b19 | 2016-05-13 18:46:35 | [diff] [blame] | 1535 | |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1536 | stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard); |
zhihuang | 6ba3b19 | 2016-05-13 18:46:35 | [diff] [blame] | 1537 | |
| 1538 | // Get stats for the local track. |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1539 | StatsReports reports; |
| 1540 | stats->GetStats(local_track.get(), &reports); |
zhihuang | 6ba3b19 | 2016-05-13 18:46:35 | [diff] [blame] | 1541 | const StatsReport* report = |
| 1542 | FindNthReportByType(reports, StatsReport::kStatsReportTypeSsrc, 1); |
Harald Alvestrand | 75ceef2 | 2018-01-04 14:26:13 | [diff] [blame] | 1543 | ASSERT_TRUE(report); |
zhihuang | 6ba3b19 | 2016-05-13 18:46:35 | [diff] [blame] | 1544 | // The -1 will not be added to the stats report. |
| 1545 | std::string value_in_report; |
| 1546 | EXPECT_FALSE( |
| 1547 | GetValue(report, StatsReport::kStatsValueNameRtt, &value_in_report)); |
| 1548 | EXPECT_FALSE(GetValue(report, StatsReport::kStatsValueNamePacketsLost, |
| 1549 | &value_in_report)); |
| 1550 | EXPECT_FALSE(GetValue(report, StatsReport::kStatsValueNameJitterReceived, |
| 1551 | &value_in_report)); |
zhihuang | 6ba3b19 | 2016-05-13 18:46:35 | [diff] [blame] | 1552 | EXPECT_FALSE(GetValue(report, StatsReport::kStatsValueNameEchoDelayMedian, |
| 1553 | &value_in_report)); |
| 1554 | EXPECT_FALSE(GetValue(report, StatsReport::kStatsValueNameEchoDelayStdDev, |
| 1555 | &value_in_report)); |
| 1556 | |
| 1557 | // Get stats for the remote track. |
| 1558 | reports.clear(); |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1559 | stats->GetStats(remote_track.get(), &reports); |
zhihuang | 6ba3b19 | 2016-05-13 18:46:35 | [diff] [blame] | 1560 | report = FindNthReportByType(reports, StatsReport::kStatsReportTypeSsrc, 1); |
Harald Alvestrand | 75ceef2 | 2018-01-04 14:26:13 | [diff] [blame] | 1561 | ASSERT_TRUE(report); |
zhihuang | 6ba3b19 | 2016-05-13 18:46:35 | [diff] [blame] | 1562 | EXPECT_FALSE(GetValue(report, |
| 1563 | StatsReport::kStatsValueNameCaptureStartNtpTimeMs, |
| 1564 | &value_in_report)); |
| 1565 | EXPECT_FALSE(GetValue(report, StatsReport::kStatsValueNameAudioInputLevel, |
| 1566 | &value_in_report)); |
| 1567 | } |
| 1568 | |
henrike@webrtc.org | 40b3b68 | 2014-03-03 18:30:11 | [diff] [blame] | 1569 | // This test verifies that a local stats object can get statistics via |
| 1570 | // AudioTrackInterface::GetStats() method. |
Harald Alvestrand | 75ceef2 | 2018-01-04 14:26:13 | [diff] [blame] | 1571 | TEST_P(StatsCollectorTrackTest, GetStatsFromLocalAudioTrack) { |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1572 | auto pc = CreatePeerConnection(); |
| 1573 | auto stats = CreateStatsCollector(pc); |
decurtis@webrtc.org | 487a444 | 2015-01-15 22:55:07 | [diff] [blame] | 1574 | |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1575 | AddOutgoingAudioTrack(pc, stats.get()); |
| 1576 | stats->AddLocalAudioTrack(audio_track_, kSsrcOfTrack); |
tommi@webrtc.org | 242068d | 2014-07-14 20:19:56 | [diff] [blame] | 1577 | |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1578 | VoiceSenderInfo voice_sender_info; |
xians@webrtc.org | 4cb0128 | 2014-06-12 14:57:05 | [diff] [blame] | 1579 | InitVoiceSenderInfo(&voice_sender_info); |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1580 | UpdateVoiceSenderInfoFromAudioTrack(audio_track_, &voice_sender_info, false); |
| 1581 | VoiceMediaInfo voice_info; |
| 1582 | voice_info.senders.push_back(voice_sender_info); |
Steve Anton | 5b38731 | 2018-02-03 00:00:20 | [diff] [blame] | 1583 | |
| 1584 | auto* voice_media_channel = pc->AddVoiceChannel("audio", "transport"); |
| 1585 | voice_media_channel->SetStats(voice_info); |
henrike@webrtc.org | 40b3b68 | 2014-03-03 18:30:11 | [diff] [blame] | 1586 | |
henrike@webrtc.org | 40b3b68 | 2014-03-03 18:30:11 | [diff] [blame] | 1587 | StatsReports reports; // returned values. |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1588 | VerifyAudioTrackStats(audio_track_, stats.get(), voice_info, &reports); |
henrike@webrtc.org | 40b3b68 | 2014-03-03 18:30:11 | [diff] [blame] | 1589 | |
xians@webrtc.org | 4cb0128 | 2014-06-12 14:57:05 | [diff] [blame] | 1590 | // Verify that there is no remote report for the local audio track because |
| 1591 | // we did not set it up. |
Yves Gerey | 665174f | 2018-06-19 13:03:05 | [diff] [blame] | 1592 | const StatsReport* remote_report = |
| 1593 | FindNthReportByType(reports, StatsReport::kStatsReportTypeRemoteSsrc, 1); |
xians@webrtc.org | 4cb0128 | 2014-06-12 14:57:05 | [diff] [blame] | 1594 | EXPECT_TRUE(remote_report == NULL); |
| 1595 | } |
buildbot@webrtc.org | 3e01e0b | 2014-05-13 17:54:10 | [diff] [blame] | 1596 | |
| 1597 | // This test verifies that audio receive streams populate stats reports |
| 1598 | // correctly. |
Harald Alvestrand | 75ceef2 | 2018-01-04 14:26:13 | [diff] [blame] | 1599 | TEST_P(StatsCollectorTrackTest, GetStatsFromRemoteStream) { |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1600 | auto pc = CreatePeerConnection(); |
| 1601 | auto stats = CreateStatsCollector(pc); |
decurtis@webrtc.org | 487a444 | 2015-01-15 22:55:07 | [diff] [blame] | 1602 | |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1603 | AddIncomingAudioTrack(pc, stats.get()); |
deadbeef | cbecd35 | 2015-09-23 18:50:27 | [diff] [blame] | 1604 | |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1605 | VoiceReceiverInfo voice_receiver_info; |
xians@webrtc.org | 4cb0128 | 2014-06-12 14:57:05 | [diff] [blame] | 1606 | InitVoiceReceiverInfo(&voice_receiver_info); |
buildbot@webrtc.org | 7e71b77 | 2014-06-13 01:14:01 | [diff] [blame] | 1607 | voice_receiver_info.codec_name = "fake_codec"; |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1608 | VoiceMediaInfo voice_info; |
| 1609 | voice_info.receivers.push_back(voice_receiver_info); |
Steve Anton | 5b38731 | 2018-02-03 00:00:20 | [diff] [blame] | 1610 | |
| 1611 | auto* voice_media_channel = pc->AddVoiceChannel("audio", "transport"); |
| 1612 | voice_media_channel->SetStats(voice_info); |
buildbot@webrtc.org | 3e01e0b | 2014-05-13 17:54:10 | [diff] [blame] | 1613 | |
buildbot@webrtc.org | 3e01e0b | 2014-05-13 17:54:10 | [diff] [blame] | 1614 | StatsReports reports; // returned values. |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1615 | VerifyAudioTrackStats(audio_track_, stats.get(), voice_info, &reports); |
buildbot@webrtc.org | 3e01e0b | 2014-05-13 17:54:10 | [diff] [blame] | 1616 | } |
| 1617 | |
henrike@webrtc.org | 40b3b68 | 2014-03-03 18:30:11 | [diff] [blame] | 1618 | // This test verifies that a local stats object won't update its statistics |
| 1619 | // after a RemoveLocalAudioTrack() call. |
Harald Alvestrand | 75ceef2 | 2018-01-04 14:26:13 | [diff] [blame] | 1620 | TEST_P(StatsCollectorTrackTest, GetStatsAfterRemoveAudioStream) { |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1621 | auto pc = CreatePeerConnection(); |
| 1622 | auto stats = CreateStatsCollector(pc); |
decurtis@webrtc.org | 487a444 | 2015-01-15 22:55:07 | [diff] [blame] | 1623 | |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1624 | AddOutgoingAudioTrack(pc, stats.get()); |
| 1625 | stats->AddLocalAudioTrack(audio_track_.get(), kSsrcOfTrack); |
deadbeef | cbecd35 | 2015-09-23 18:50:27 | [diff] [blame] | 1626 | |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1627 | VoiceSenderInfo voice_sender_info; |
xians@webrtc.org | 4cb0128 | 2014-06-12 14:57:05 | [diff] [blame] | 1628 | InitVoiceSenderInfo(&voice_sender_info); |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1629 | VoiceMediaInfo voice_info; |
| 1630 | voice_info.senders.push_back(voice_sender_info); |
henrike@webrtc.org | 40b3b68 | 2014-03-03 18:30:11 | [diff] [blame] | 1631 | |
Steve Anton | 5b38731 | 2018-02-03 00:00:20 | [diff] [blame] | 1632 | auto* voice_media_channel = pc->AddVoiceChannel("audio", "transport"); |
| 1633 | voice_media_channel->SetStats(voice_info); |
henrike@webrtc.org | 40b3b68 | 2014-03-03 18:30:11 | [diff] [blame] | 1634 | |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1635 | stats->RemoveLocalAudioTrack(audio_track_.get(), kSsrcOfTrack); |
henrike@webrtc.org | 40b3b68 | 2014-03-03 18:30:11 | [diff] [blame] | 1636 | |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1637 | stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard); |
| 1638 | StatsReports reports; |
| 1639 | stats->GetStats(nullptr, &reports); |
henrike@webrtc.org | 40b3b68 | 2014-03-03 18:30:11 | [diff] [blame] | 1640 | |
| 1641 | // The report will exist since we don't remove them in RemoveStream(). |
Yves Gerey | 665174f | 2018-06-19 13:03:05 | [diff] [blame] | 1642 | const StatsReport* report = |
| 1643 | FindNthReportByType(reports, StatsReport::kStatsReportTypeSsrc, 1); |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1644 | ASSERT_TRUE(report); |
| 1645 | EXPECT_EQ(stats->GetTimeNow(), report->timestamp()); |
Yves Gerey | 665174f | 2018-06-19 13:03:05 | [diff] [blame] | 1646 | std::string track_id = |
| 1647 | ExtractSsrcStatsValue(reports, StatsReport::kStatsValueNameTrackId); |
xians@webrtc.org | 4cb0128 | 2014-06-12 14:57:05 | [diff] [blame] | 1648 | EXPECT_EQ(kLocalTrackId, track_id); |
Yves Gerey | 665174f | 2018-06-19 13:03:05 | [diff] [blame] | 1649 | std::string ssrc_id = |
| 1650 | ExtractSsrcStatsValue(reports, StatsReport::kStatsValueNameSsrc); |
Jonas Olsson | 6b1985d | 2018-07-05 09:59:48 | [diff] [blame] | 1651 | EXPECT_EQ(rtc::ToString(kSsrcOfTrack), ssrc_id); |
henrike@webrtc.org | 40b3b68 | 2014-03-03 18:30:11 | [diff] [blame] | 1652 | |
| 1653 | // Verifies the values in the track report, no value will be changed by the |
| 1654 | // AudioTrackInterface::GetSignalValue() and |
Sam Zackrisson | 2812763 | 2018-11-01 10:37:15 | [diff] [blame] | 1655 | // AudioProcessorInterface::GetStats(); |
henrike@webrtc.org | 40b3b68 | 2014-03-03 18:30:11 | [diff] [blame] | 1656 | VerifyVoiceSenderInfoReport(report, voice_sender_info); |
| 1657 | } |
| 1658 | |
xians@webrtc.org | 4cb0128 | 2014-06-12 14:57:05 | [diff] [blame] | 1659 | // This test verifies that when ongoing and incoming audio tracks are using |
| 1660 | // the same ssrc, they populate stats reports correctly. |
Harald Alvestrand | 75ceef2 | 2018-01-04 14:26:13 | [diff] [blame] | 1661 | TEST_P(StatsCollectorTrackTest, LocalAndRemoteTracksWithSameSsrc) { |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1662 | auto pc = CreatePeerConnection(); |
| 1663 | auto stats = CreateStatsCollector(pc); |
xians@webrtc.org | 4cb0128 | 2014-06-12 14:57:05 | [diff] [blame] | 1664 | |
| 1665 | // Create a local stream with a local audio track and adds it to the stats. |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1666 | AddOutgoingAudioTrack(pc, stats.get()); |
| 1667 | stats->AddLocalAudioTrack(audio_track_.get(), kSsrcOfTrack); |
xians@webrtc.org | 4cb0128 | 2014-06-12 14:57:05 | [diff] [blame] | 1668 | |
| 1669 | // Create a remote stream with a remote audio track and adds it to the stats. |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1670 | rtc::scoped_refptr<MediaStream> remote_stream( |
Seth Hampson | 845e878 | 2018-03-02 19:34:10 | [diff] [blame] | 1671 | MediaStream::Create("remotestreamid")); |
Tommi | 87f7090 | 2021-04-27 12:43:08 | [diff] [blame] | 1672 | auto remote_track = rtc::make_ref_counted<FakeAudioTrack>(kRemoteTrackId); |
Steve Anton | efe4c92 | 2019-03-27 17:26:06 | [diff] [blame] | 1673 | pc->AddReceiver(CreateMockReceiver(remote_track, kSsrcOfTrack)); |
xians@webrtc.org | 4cb0128 | 2014-06-12 14:57:05 | [diff] [blame] | 1674 | remote_stream->AddTrack(remote_track); |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1675 | stats->AddStream(remote_stream); |
xians@webrtc.org | 4cb0128 | 2014-06-12 14:57:05 | [diff] [blame] | 1676 | |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1677 | VoiceSenderInfo voice_sender_info; |
xians@webrtc.org | 4cb0128 | 2014-06-12 14:57:05 | [diff] [blame] | 1678 | InitVoiceSenderInfo(&voice_sender_info); |
Artem Titov | 880fa81 | 2021-07-30 20:30:23 | [diff] [blame] | 1679 | // Some of the contents in `voice_sender_info` needs to be updated from the |
| 1680 | // `audio_track_`. |
Ivo Creusen | 56d46090 | 2017-11-24 16:29:59 | [diff] [blame] | 1681 | UpdateVoiceSenderInfoFromAudioTrack(audio_track_.get(), &voice_sender_info, |
| 1682 | true); |
xians@webrtc.org | 4cb0128 | 2014-06-12 14:57:05 | [diff] [blame] | 1683 | |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1684 | VoiceReceiverInfo voice_receiver_info; |
xians@webrtc.org | 4cb0128 | 2014-06-12 14:57:05 | [diff] [blame] | 1685 | InitVoiceReceiverInfo(&voice_receiver_info); |
| 1686 | |
| 1687 | // Constructs an ssrc stats update. |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1688 | VoiceMediaInfo voice_info; |
| 1689 | voice_info.senders.push_back(voice_sender_info); |
| 1690 | voice_info.receivers.push_back(voice_receiver_info); |
xians@webrtc.org | 4cb0128 | 2014-06-12 14:57:05 | [diff] [blame] | 1691 | |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1692 | // Instruct the session to return stats containing the transport channel. |
Steve Anton | 5b38731 | 2018-02-03 00:00:20 | [diff] [blame] | 1693 | auto* voice_media_channel = pc->AddVoiceChannel("audio", "transport"); |
| 1694 | voice_media_channel->SetStats(voice_info); |
xians@webrtc.org | 4cb0128 | 2014-06-12 14:57:05 | [diff] [blame] | 1695 | |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1696 | stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard); |
xians@webrtc.org | 4cb0128 | 2014-06-12 14:57:05 | [diff] [blame] | 1697 | |
| 1698 | // Get stats for the local track. |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1699 | StatsReports reports; // returned values. |
| 1700 | stats->GetStats(audio_track_.get(), &reports); |
| 1701 | |
Yves Gerey | 665174f | 2018-06-19 13:03:05 | [diff] [blame] | 1702 | const StatsReport* track_report = |
| 1703 | FindNthReportByType(reports, StatsReport::kStatsReportTypeSsrc, 1); |
Harald Alvestrand | 75ceef2 | 2018-01-04 14:26:13 | [diff] [blame] | 1704 | ASSERT_TRUE(track_report); |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1705 | EXPECT_EQ(stats->GetTimeNow(), track_report->timestamp()); |
Yves Gerey | 665174f | 2018-06-19 13:03:05 | [diff] [blame] | 1706 | std::string track_id = |
| 1707 | ExtractSsrcStatsValue(reports, StatsReport::kStatsValueNameTrackId); |
xians@webrtc.org | 4cb0128 | 2014-06-12 14:57:05 | [diff] [blame] | 1708 | EXPECT_EQ(kLocalTrackId, track_id); |
| 1709 | VerifyVoiceSenderInfoReport(track_report, voice_sender_info); |
| 1710 | |
| 1711 | // Get stats for the remote track. |
tommi@webrtc.org | 5b06b06 | 2014-08-15 08:38:30 | [diff] [blame] | 1712 | reports.clear(); |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1713 | stats->GetStats(remote_track.get(), &reports); |
Yves Gerey | 665174f | 2018-06-19 13:03:05 | [diff] [blame] | 1714 | track_report = |
| 1715 | FindNthReportByType(reports, StatsReport::kStatsReportTypeSsrc, 1); |
Harald Alvestrand | 75ceef2 | 2018-01-04 14:26:13 | [diff] [blame] | 1716 | ASSERT_TRUE(track_report); |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1717 | EXPECT_EQ(stats->GetTimeNow(), track_report->timestamp()); |
Yves Gerey | 665174f | 2018-06-19 13:03:05 | [diff] [blame] | 1718 | track_id = |
| 1719 | ExtractSsrcStatsValue(reports, StatsReport::kStatsValueNameTrackId); |
xians@webrtc.org | 4cb0128 | 2014-06-12 14:57:05 | [diff] [blame] | 1720 | EXPECT_EQ(kRemoteTrackId, track_id); |
| 1721 | VerifyVoiceReceiverInfoReport(track_report, voice_receiver_info); |
| 1722 | } |
| 1723 | |
xians@webrtc.org | 01bda20 | 2014-07-09 07:38:38 | [diff] [blame] | 1724 | // This test verifies that when two outgoing audio tracks are using the same |
| 1725 | // ssrc at different times, they populate stats reports correctly. |
| 1726 | // TODO(xians): Figure out if it is possible to encapsulate the setup and |
| 1727 | // avoid duplication of code in test cases. |
Harald Alvestrand | 75ceef2 | 2018-01-04 14:26:13 | [diff] [blame] | 1728 | TEST_P(StatsCollectorTrackTest, TwoLocalTracksWithSameSsrc) { |
Harald Alvestrand | 75ceef2 | 2018-01-04 14:26:13 | [diff] [blame] | 1729 | // This test only makes sense when we're using streams. |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1730 | if (!GetParam()) { |
Harald Alvestrand | 75ceef2 | 2018-01-04 14:26:13 | [diff] [blame] | 1731 | return; |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1732 | } |
Harald Alvestrand | 75ceef2 | 2018-01-04 14:26:13 | [diff] [blame] | 1733 | |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1734 | auto pc = CreatePeerConnection(); |
| 1735 | auto stats = CreateStatsCollector(pc); |
xians@webrtc.org | 01bda20 | 2014-07-09 07:38:38 | [diff] [blame] | 1736 | |
| 1737 | // Create a local stream with a local audio track and adds it to the stats. |
Steve Anton | efe4c92 | 2019-03-27 17:26:06 | [diff] [blame] | 1738 | auto sender = AddOutgoingAudioTrack(pc, stats.get()); |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1739 | stats->AddLocalAudioTrack(audio_track_, kSsrcOfTrack); |
xians@webrtc.org | 01bda20 | 2014-07-09 07:38:38 | [diff] [blame] | 1740 | |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1741 | VoiceSenderInfo voice_sender_info; |
ivoc | e1198e0 | 2017-09-08 15:13:19 | [diff] [blame] | 1742 | InitVoiceSenderInfo(&voice_sender_info); |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1743 | UpdateVoiceSenderInfoFromAudioTrack(audio_track_, &voice_sender_info, false); |
xians@webrtc.org | 01bda20 | 2014-07-09 07:38:38 | [diff] [blame] | 1744 | voice_sender_info.add_ssrc(kSsrcOfTrack); |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1745 | VoiceMediaInfo voice_info; |
| 1746 | voice_info.senders.push_back(voice_sender_info); |
Steve Anton | 5b38731 | 2018-02-03 00:00:20 | [diff] [blame] | 1747 | |
| 1748 | auto* voice_media_channel = pc->AddVoiceChannel("voice", "transport"); |
| 1749 | voice_media_channel->SetStats(voice_info); |
xians@webrtc.org | 01bda20 | 2014-07-09 07:38:38 | [diff] [blame] | 1750 | |
xians@webrtc.org | 01bda20 | 2014-07-09 07:38:38 | [diff] [blame] | 1751 | StatsReports reports; // returned values. |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1752 | VerifyAudioTrackStats(audio_track_, stats.get(), voice_info, &reports); |
xians@webrtc.org | 01bda20 | 2014-07-09 07:38:38 | [diff] [blame] | 1753 | |
| 1754 | // Remove the previous audio track from the stream. |
| 1755 | stream_->RemoveTrack(audio_track_.get()); |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1756 | stats->RemoveLocalAudioTrack(audio_track_.get(), kSsrcOfTrack); |
Steve Anton | efe4c92 | 2019-03-27 17:26:06 | [diff] [blame] | 1757 | pc->RemoveSender(sender); |
xians@webrtc.org | 01bda20 | 2014-07-09 07:38:38 | [diff] [blame] | 1758 | |
| 1759 | // Create a new audio track and adds it to the stream and stats. |
| 1760 | static const std::string kNewTrackId = "new_track_id"; |
Tommi | 87f7090 | 2021-04-27 12:43:08 | [diff] [blame] | 1761 | auto new_audio_track = rtc::make_ref_counted<FakeAudioTrack>(kNewTrackId); |
Steve Anton | efe4c92 | 2019-03-27 17:26:06 | [diff] [blame] | 1762 | pc->AddSender(CreateMockSender(new_audio_track, kSsrcOfTrack)); |
xians@webrtc.org | 01bda20 | 2014-07-09 07:38:38 | [diff] [blame] | 1763 | stream_->AddTrack(new_audio_track); |
| 1764 | |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1765 | stats->AddLocalAudioTrack(new_audio_track, kSsrcOfTrack); |
Tommi | c811ab5 | 2022-01-11 15:33:23 | [diff] [blame] | 1766 | stats->InvalidateCache(); |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1767 | |
| 1768 | VoiceSenderInfo new_voice_sender_info; |
xians@webrtc.org | 01bda20 | 2014-07-09 07:38:38 | [diff] [blame] | 1769 | InitVoiceSenderInfo(&new_voice_sender_info); |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1770 | UpdateVoiceSenderInfoFromAudioTrack(new_audio_track, &new_voice_sender_info, |
| 1771 | false); |
| 1772 | VoiceMediaInfo new_voice_info; |
| 1773 | new_voice_info.senders.push_back(new_voice_sender_info); |
Steve Anton | 5b38731 | 2018-02-03 00:00:20 | [diff] [blame] | 1774 | voice_media_channel->SetStats(new_voice_info); |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1775 | |
tommi@webrtc.org | 5b06b06 | 2014-08-15 08:38:30 | [diff] [blame] | 1776 | reports.clear(); |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1777 | VerifyAudioTrackStats(new_audio_track, stats.get(), new_voice_info, &reports); |
xians@webrtc.org | 01bda20 | 2014-07-09 07:38:38 | [diff] [blame] | 1778 | } |
| 1779 | |
Steve Anton | efe4c92 | 2019-03-27 17:26:06 | [diff] [blame] | 1780 | // Test that if there are two local senders with the same track then two SSRC |
| 1781 | // reports will be created, one for each sender, with the same track ID and one |
| 1782 | // track report will be created for the shared track. |
| 1783 | TEST_P(StatsCollectorTrackTest, TwoLocalSendersWithSameTrack) { |
| 1784 | constexpr uint32_t kFirstSsrc = 22; |
| 1785 | constexpr uint32_t kSecondSsrc = 33; |
| 1786 | |
| 1787 | auto pc = CreatePeerConnection(); |
| 1788 | auto stats = CreateStatsCollector(pc); |
| 1789 | |
Tommi | 87f7090 | 2021-04-27 12:43:08 | [diff] [blame] | 1790 | auto local_track = |
| 1791 | rtc::make_ref_counted<FakeAudioTrackWithInitValue>(kLocalTrackId); |
Steve Anton | efe4c92 | 2019-03-27 17:26:06 | [diff] [blame] | 1792 | pc->AddSender(CreateMockSender(local_track, kFirstSsrc)); |
| 1793 | stats->AddLocalAudioTrack(local_track.get(), kFirstSsrc); |
| 1794 | pc->AddSender(CreateMockSender(local_track, kSecondSsrc)); |
| 1795 | stats->AddLocalAudioTrack(local_track.get(), kSecondSsrc); |
| 1796 | |
| 1797 | VoiceSenderInfo first_sender_info; |
| 1798 | InitVoiceSenderInfo(&first_sender_info, kFirstSsrc); |
| 1799 | UpdateVoiceSenderInfoFromAudioTrack(local_track.get(), &first_sender_info, |
| 1800 | false); |
| 1801 | |
| 1802 | VoiceSenderInfo second_sender_info; |
| 1803 | InitVoiceSenderInfo(&second_sender_info, kSecondSsrc); |
| 1804 | UpdateVoiceSenderInfoFromAudioTrack(local_track.get(), &second_sender_info, |
| 1805 | false); |
| 1806 | |
| 1807 | VoiceMediaInfo voice_info; |
| 1808 | voice_info.senders.push_back(first_sender_info); |
| 1809 | voice_info.senders.push_back(second_sender_info); |
| 1810 | |
| 1811 | auto* voice_media_channel = pc->AddVoiceChannel("voice", "transport"); |
| 1812 | voice_media_channel->SetStats(voice_info); |
| 1813 | |
| 1814 | stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard); |
| 1815 | |
| 1816 | StatsReports reports; |
| 1817 | stats->GetStats(local_track.get(), &reports); |
Steve Anton | efe4c92 | 2019-03-27 17:26:06 | [diff] [blame] | 1818 | |
| 1819 | // Both SSRC reports have the same track ID. |
| 1820 | EXPECT_EQ(kLocalTrackId, GetValueInNthReportByType( |
| 1821 | reports, StatsReport::kStatsReportTypeSsrc, |
| 1822 | StatsReport::kStatsValueNameTrackId, 1)); |
| 1823 | EXPECT_EQ(kLocalTrackId, GetValueInNthReportByType( |
| 1824 | reports, StatsReport::kStatsReportTypeSsrc, |
| 1825 | StatsReport::kStatsValueNameTrackId, 2)); |
| 1826 | |
| 1827 | // The SSRC in each SSRC report is different and correspond to the sender |
| 1828 | // SSRC. |
| 1829 | std::vector<absl::optional<std::string>> ssrcs = { |
| 1830 | GetValueInNthReportByType(reports, StatsReport::kStatsReportTypeSsrc, |
| 1831 | StatsReport::kStatsValueNameSsrc, 1), |
| 1832 | GetValueInNthReportByType(reports, StatsReport::kStatsReportTypeSsrc, |
| 1833 | StatsReport::kStatsValueNameSsrc, 2)}; |
| 1834 | EXPECT_THAT(ssrcs, UnorderedElementsAre(rtc::ToString(kFirstSsrc), |
| 1835 | rtc::ToString(kSecondSsrc))); |
| 1836 | |
| 1837 | // There is one track report with the same track ID as the SSRC reports. |
| 1838 | EXPECT_EQ( |
| 1839 | 1u, GetReportsByType(reports, StatsReport::kStatsReportTypeTrack).size()); |
| 1840 | EXPECT_EQ(kLocalTrackId, GetValueInNthReportByType( |
| 1841 | reports, StatsReport::kStatsReportTypeTrack, |
| 1842 | StatsReport::kStatsValueNameTrackId, 1)); |
| 1843 | } |
| 1844 | |
sakal | 43536c3 | 2016-10-24 08:46:43 | [diff] [blame] | 1845 | // This test verifies that stats are correctly set in video send ssrc stats. |
Harald Alvestrand | 75ceef2 | 2018-01-04 14:26:13 | [diff] [blame] | 1846 | TEST_P(StatsCollectorTrackTest, VerifyVideoSendSsrcStats) { |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1847 | auto pc = CreatePeerConnection(); |
| 1848 | auto stats = CreateStatsCollector(pc); |
sakal | 43536c3 | 2016-10-24 08:46:43 | [diff] [blame] | 1849 | |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1850 | AddOutgoingVideoTrack(pc, stats.get()); |
sakal | 43536c3 | 2016-10-24 08:46:43 | [diff] [blame] | 1851 | |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1852 | VideoSenderInfo video_sender_info; |
sakal | 43536c3 | 2016-10-24 08:46:43 | [diff] [blame] | 1853 | video_sender_info.add_ssrc(1234); |
| 1854 | video_sender_info.frames_encoded = 10; |
Oskar Sundbom | 36f8f3e | 2017-11-16 09:54:27 | [diff] [blame] | 1855 | video_sender_info.qp_sum = 11; |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1856 | VideoMediaInfo video_info; |
Henrik Boström | a0ff50c | 2020-05-05 13:54:46 | [diff] [blame] | 1857 | video_info.aggregated_senders.push_back(video_sender_info); |
Steve Anton | 5b38731 | 2018-02-03 00:00:20 | [diff] [blame] | 1858 | |
Tommi | 1901551 | 2022-02-02 10:49:35 | [diff] [blame] | 1859 | pc->AddVideoChannel("video", "transport", video_info); |
sakal | 43536c3 | 2016-10-24 08:46:43 | [diff] [blame] | 1860 | |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1861 | stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard); |
| 1862 | StatsReports reports; |
| 1863 | stats->GetStats(nullptr, &reports); |
| 1864 | |
sakal | 43536c3 | 2016-10-24 08:46:43 | [diff] [blame] | 1865 | EXPECT_EQ(rtc::ToString(video_sender_info.frames_encoded), |
| 1866 | ExtractSsrcStatsValue(reports, |
| 1867 | StatsReport::kStatsValueNameFramesEncoded)); |
sakal | 87da404 | 2016-10-31 13:53:47 | [diff] [blame] | 1868 | EXPECT_EQ(rtc::ToString(*video_sender_info.qp_sum), |
| 1869 | ExtractSsrcStatsValue(reports, StatsReport::kStatsValueNameQpSum)); |
sakal | 43536c3 | 2016-10-24 08:46:43 | [diff] [blame] | 1870 | } |
| 1871 | |
sakal | e5ba44e | 2016-10-26 14:09:24 | [diff] [blame] | 1872 | // This test verifies that stats are correctly set in video receive ssrc stats. |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1873 | TEST_P(StatsCollectorTrackTest, VerifyVideoReceiveSsrcStatsNew) { |
| 1874 | auto pc = CreatePeerConnection(); |
| 1875 | auto stats = CreateStatsCollector(pc); |
sakal | e5ba44e | 2016-10-26 14:09:24 | [diff] [blame] | 1876 | |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1877 | AddIncomingVideoTrack(pc, stats.get()); |
sakal | e5ba44e | 2016-10-26 14:09:24 | [diff] [blame] | 1878 | |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1879 | VideoReceiverInfo video_receiver_info; |
sakal | e5ba44e | 2016-10-26 14:09:24 | [diff] [blame] | 1880 | video_receiver_info.add_ssrc(1234); |
| 1881 | video_receiver_info.frames_decoded = 10; |
Artem Titov | 8a3ab0e | 2018-07-27 14:52:57 | [diff] [blame] | 1882 | video_receiver_info.qp_sum = 11; |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1883 | VideoMediaInfo video_info; |
| 1884 | video_info.receivers.push_back(video_receiver_info); |
Steve Anton | 5b38731 | 2018-02-03 00:00:20 | [diff] [blame] | 1885 | |
Tommi | 1901551 | 2022-02-02 10:49:35 | [diff] [blame] | 1886 | pc->AddVideoChannel("video", "transport", video_info); |
sakal | e5ba44e | 2016-10-26 14:09:24 | [diff] [blame] | 1887 | |
Steve Anton | 3871f6f | 2018-01-26 18:25:53 | [diff] [blame] | 1888 | stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard); |
| 1889 | StatsReports reports; |
| 1890 | stats->GetStats(nullptr, &reports); |
| 1891 | |
sakal | e5ba44e | 2016-10-26 14:09:24 | [diff] [blame] | 1892 | EXPECT_EQ(rtc::ToString(video_receiver_info.frames_decoded), |
| 1893 | ExtractSsrcStatsValue(reports, |
| 1894 | StatsReport::kStatsValueNameFramesDecoded)); |
sakal | cc452e1 | 2017-02-09 12:53:45 | [diff] [blame] | 1895 | EXPECT_EQ(rtc::ToString(*video_receiver_info.qp_sum), |
| 1896 | ExtractSsrcStatsValue(reports, StatsReport::kStatsValueNameQpSum)); |
sakal | e5ba44e | 2016-10-26 14:09:24 | [diff] [blame] | 1897 | } |
| 1898 | |
Mirko Bonadei | c84f661 | 2019-01-31 11:20:57 | [diff] [blame] | 1899 | INSTANTIATE_TEST_SUITE_P(HasStream, StatsCollectorTrackTest, ::testing::Bool()); |
Harald Alvestrand | 75ceef2 | 2018-01-04 14:26:13 | [diff] [blame] | 1900 | |
guoweis@webrtc.org | 950c518 | 2014-12-16 23:01:31 | [diff] [blame] | 1901 | } // namespace webrtc |