Source code
Revision control
Copy as Markdown
Other Tools
/*
* Copyright 2012 The WebRTC project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#ifndef PC_TEST_INTEGRATION_TEST_HELPERS_H_
#define PC_TEST_INTEGRATION_TEST_HELPERS_H_
#include <limits.h>
#include <stdint.h>
#include <stdio.h>
#include <functional>
#include <limits>
#include <map>
#include <memory>
#include <optional>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
#include "absl/functional/any_invocable.h"
#include "absl/strings/string_view.h"
#include "api/candidate.h"
#include "api/data_channel_interface.h"
#include "api/dtls_transport_interface.h"
#include "api/environment/environment.h"
#include "api/ice_transport_interface.h"
#include "api/jsep.h"
#include "api/make_ref_counted.h"
#include "api/media_stream_interface.h"
#include "api/media_types.h"
#include "api/metronome/metronome.h"
#include "api/peer_connection_interface.h"
#include "api/rtc_error.h"
#include "api/rtc_event_log_output.h"
#include "api/rtp_header_extension_id.h"
#include "api/rtp_receiver_interface.h"
#include "api/rtp_sender_interface.h"
#include "api/rtp_transceiver_interface.h"
#include "api/scoped_refptr.h"
#include "api/sequence_checker.h"
#include "api/stats/rtc_stats_report.h"
#include "api/stats/rtcstats_objects.h"
#include "api/task_queue/pending_task_safety_flag.h"
#include "api/task_queue/task_queue_base.h"
#include "api/test/mock_async_dns_resolver.h"
#include "api/test/time_controller.h"
#include "api/units/time_delta.h"
#include "api/video/video_rotation.h"
#include "logging/rtc_event_log/fake_rtc_event_log_factory.h"
#include "media/base/stream_params.h"
#include "p2p/base/ice_transport_internal.h"
#include "p2p/base/port.h"
#include "p2p/base/port_allocator.h"
#include "p2p/test/fake_ice_transport.h"
#include "p2p/test/test_stun_server.h"
#include "p2p/test/test_turn_customizer.h"
#include "p2p/test/test_turn_server.h"
#include "pc/peer_connection.h"
#include "pc/peer_connection_factory.h"
#include "pc/session_description.h"
#include "pc/test/fake_audio_capture_module.h"
#include "pc/test/fake_periodic_video_source.h"
#include "pc/test/fake_video_track_renderer.h"
#include "pc/test/mock_peer_connection_observers.h"
#include "pc/video_track_source.h"
#include "rtc_base/fake_mdns_responder.h"
#include "rtc_base/fake_network.h"
#include "rtc_base/firewall_socket_server.h"
#include "rtc_base/logging.h"
#include "rtc_base/net_helper.h"
#include "rtc_base/socket_address.h"
#include "rtc_base/socket_server.h"
#include "rtc_base/ssl_stream_adapter.h"
#include "rtc_base/system/plan_b_only.h"
#include "rtc_base/thread.h"
#include "rtc_base/virtual_socket_server.h"
#include "test/gmock.h"
#include "test/gtest.h"
#include "test/run_loop.h"
#include "test/time_controller/simulated_time_controller.h"
#include "test/wait_until.h"
namespace webrtc {
namespace internal {
class PeerConnectionIntegrationTestBase;
} // namespace internal
using ::testing::_;
using ::testing::Combine;
using ::testing::Contains;
using ::testing::DoAll;
using ::testing::ElementsAre;
using ::testing::InvokeArgument;
using ::testing::NiceMock;
using ::testing::Return;
using ::testing::SetArgPointee;
using ::testing::UnorderedElementsAreArray;
using ::testing::Values;
using RTCConfiguration = PeerConnectionInterface::RTCConfiguration;
constexpr TimeDelta kDefaultTimeout = TimeDelta::Millis(10000);
constexpr TimeDelta kLongTimeout = TimeDelta::Millis(60000);
constexpr TimeDelta kMaxWaitForStats = TimeDelta::Millis(3000);
constexpr TimeDelta kMaxWaitForActivation = TimeDelta::Millis(5000);
constexpr TimeDelta kMaxWaitForFrames = TimeDelta::Millis(10000);
// Default number of audio/video frames to wait for before considering a test
// successful.
static const int kDefaultExpectedAudioFrameCount = 3;
static const int kDefaultExpectedVideoFrameCount = 3;
static const char kDataChannelLabel[] = "data_channel";
// SRTP cipher name negotiated by the tests. This must be updated if the
// default changes.
static const int kDefaultSrtpCryptoSuite = kSrtpAes128CmSha1_80;
static const int kDefaultSrtpCryptoSuiteGcm = kSrtpAeadAes256Gcm;
static const SocketAddress kDefaultLocalAddress("192.168.1.1", 0);
// Helper function for constructing offer/answer options to initiate an ICE
// restart.
PeerConnectionInterface::RTCOfferAnswerOptions IceRestartOfferAnswerOptions();
// Remove all stream information (SSRCs, track IDs, etc.) and "msid-semantic"
// attribute from received SDP, simulating a legacy endpoint.
void RemoveSsrcsAndMsids(std::unique_ptr<SessionDescriptionInterface>& desc);
// Removes all stream information besides the stream ids, simulating an
// endpoint that only signals a=msid lines to convey stream_ids.
void RemoveSsrcsAndKeepMsids(
std::unique_ptr<SessionDescriptionInterface>& desc);
// Set SdpType.
void SetSdpType(std::unique_ptr<SessionDescriptionInterface>& sdp,
SdpType sdpType);
// Replaces the stream's primary SSRC and updates the first SSRC of all
// ssrc-groups.
void ReplaceFirstSsrc(StreamParams& stream, uint32_t ssrc);
int FindFirstMediaStatsIndexByKind(
const std::string& kind,
const std::vector<const RTCInboundRtpStreamStats*>& inbound_rtps);
// Tests whether a session description contains conflicting descriptions
// for a payload type within a bundle.
RTCError ValidateBundledPayloadTypes(const SessionDescription& description);
class TaskQueueMetronome : public Metronome {
public:
explicit TaskQueueMetronome(TimeDelta tick_period);
~TaskQueueMetronome() override;
// Metronome implementation.
void RequestCallOnNextTick(absl::AnyInvocable<void() &&> callback) override;
TimeDelta TickPeriod() const override;
private:
const TimeDelta tick_period_;
SequenceChecker sequence_checker_{SequenceChecker::kDetached};
std::vector<absl::AnyInvocable<void() &&>> callbacks_;
ScopedTaskSafetyDetached safety_;
};
class SignalingMessageReceiver {
public:
virtual void ReceiveSdpMessage(SdpType type, const std::string& msg) = 0;
virtual void ReceiveIceMessage(const std::string& sdp_mid,
int sdp_mline_index,
const std::string& msg) = 0;
protected:
SignalingMessageReceiver() {}
virtual ~SignalingMessageReceiver() {}
};
class MockRtpReceiverObserver : public RtpReceiverObserverInterface {
public:
explicit MockRtpReceiverObserver(webrtc::MediaType media_type)
: expected_media_type_(media_type) {}
void OnFirstPacketReceived(webrtc::MediaType media_type) override {
ASSERT_EQ(expected_media_type_, media_type);
first_packet_received_ = true;
}
void OnFirstPacketReceivedAfterReceptiveChange(
webrtc::MediaType media_type) override {
ASSERT_EQ(expected_media_type_, media_type);
first_packet_received_after_receptive_change_ = true;
}
bool first_packet_received() const { return first_packet_received_; }
bool first_packet_received_after_receptive_change() const {
return first_packet_received_after_receptive_change_;
}
~MockRtpReceiverObserver() override {}
private:
bool first_packet_received_ = false;
bool first_packet_received_after_receptive_change_ = false;
webrtc::MediaType expected_media_type_;
};
class MockRtpSenderObserver : public RtpSenderObserverInterface {
public:
explicit MockRtpSenderObserver(webrtc::MediaType media_type)
: expected_media_type_(media_type) {}
void OnFirstPacketSent(webrtc::MediaType media_type) override {
ASSERT_EQ(expected_media_type_, media_type);
first_packet_sent_ = true;
}
bool first_packet_sent() const { return first_packet_sent_; }
~MockRtpSenderObserver() override {}
private:
bool first_packet_sent_ = false;
webrtc::MediaType expected_media_type_;
};
// Helper class that wraps a peer connection, observes it, and can accept
// signaling messages from another wrapper.
//
// Uses a fake network, fake A/V capture, and optionally fake
// encoders/decoders, though they aren't used by default since they don't
// advertise support of any codecs.
// TODO(steveanton): See how this could become a subclass of
// PeerConnectionWrapper defined in peerconnectionwrapper.h.
class PeerConnectionIntegrationWrapper : public PeerConnectionObserver,
public SignalingMessageReceiver {
public:
explicit PeerConnectionIntegrationWrapper(
const std::string& debug_name,
Environment env,
internal::PeerConnectionIntegrationTestBase* test);
PeerConnectionFactoryInterface* pc_factory() const {
return peer_connection_factory_.get();
}
PeerConnectionInterface* pc() const { return peer_connection_.get(); }
// Return the PC implementation, so that non-public interfaces
// can be used in tests.
PeerConnection* pc_internal() const;
// If a signaling message receiver is set (via ConnectFakeSignaling), this
// will set the whole offer/answer exchange in motion. Just need to wait for
// the signaling state to reach "stable".
void CreateAndSetAndSignalOffer();
// Sets the options to be used when CreateAndSetAndSignalOffer is called, or
// when a remote offer is received (via fake signaling) and an answer is
// generated. By default, uses default options.
void SetOfferAnswerOptions(
const PeerConnectionInterface::RTCOfferAnswerOptions& options) {
offer_answer_options_ = options;
}
// Set a callback to be invoked when SDP is received via the fake signaling
// channel, which provides an opportunity to munge (modify) the SDP. This is
// used to test SDP being applied that a PeerConnection would normally not
// generate, but a non-JSEP endpoint might.
void SetReceivedSdpMunger(
std::function<void(std::unique_ptr<SessionDescriptionInterface>&)>
munger) {
received_sdp_munger_ = std::move(munger);
}
// Similar to the above, but this is run on SDP immediately after it's
// generated.
void SetGeneratedSdpMunger(
std::function<void(std::unique_ptr<SessionDescriptionInterface>&)>
munger) {
generated_sdp_munger_ = std::move(munger);
}
// Set a callback to be invoked when a remote offer is received via the fake
// signaling channel. This provides an opportunity to change the
// PeerConnection state before an answer is created and sent to the caller.
void SetRemoteOfferHandler(std::function<void()> handler) {
remote_offer_handler_ = std::move(handler);
}
void SetRemoteAsyncResolver(MockAsyncDnsResolver* resolver) {
remote_async_dns_resolver_ = resolver;
}
// Every ICE connection state in order that has been seen by the observer.
std::vector<PeerConnectionInterface::IceConnectionState>
ice_connection_state_history() const {
return ice_connection_state_history_;
}
void clear_ice_connection_state_history() {
ice_connection_state_history_.clear();
}
// Every standardized ICE connection state in order that has been seen by the
// observer.
std::vector<PeerConnectionInterface::IceConnectionState>
standardized_ice_connection_state_history() const {
return standardized_ice_connection_state_history_;
}
// Every PeerConnection state in order that has been seen by the observer.
std::vector<PeerConnectionInterface::PeerConnectionState>
peer_connection_state_history() const {
return peer_connection_state_history_;
}
// Every ICE gathering state in order that has been seen by the observer.
std::vector<PeerConnectionInterface::IceGatheringState>
ice_gathering_state_history() const {
return ice_gathering_state_history_;
}
std::vector<CandidatePairChangeEvent> ice_candidate_pair_change_history()
const {
return ice_candidate_pair_change_history_;
}
// Every PeerConnection signaling state in order that has been seen by the
// observer.
std::vector<PeerConnectionInterface::SignalingState>
peer_connection_signaling_state_history() const {
return peer_connection_signaling_state_history_;
}
void AddAudioVideoTracks();
scoped_refptr<RtpSenderInterface> AddAudioTrack() {
return AddTrack(CreateLocalAudioTrack());
}
scoped_refptr<RtpSenderInterface> AddVideoTrack() {
return AddTrack(CreateLocalVideoTrack());
}
scoped_refptr<AudioTrackInterface> CreateLocalAudioTrack();
scoped_refptr<VideoTrackInterface> CreateLocalVideoTrack();
scoped_refptr<VideoTrackInterface> CreateLocalVideoTrackWithConfig(
FakePeriodicVideoSource::Config config);
scoped_refptr<VideoTrackInterface> CreateLocalVideoTrackWithRotation(
VideoRotation rotation);
scoped_refptr<RtpSenderInterface> AddTrack(
scoped_refptr<MediaStreamTrackInterface> track,
const std::vector<std::string>& stream_ids = {});
std::vector<scoped_refptr<RtpReceiverInterface>> GetReceiversOfType(
webrtc::MediaType media_type);
scoped_refptr<RtpTransceiverInterface> GetFirstTransceiverOfType(
webrtc::MediaType media_type);
bool SignalingStateStable();
bool IceGatheringStateComplete();
void CreateDataChannel();
void CreateDataChannel(const DataChannelInit* init);
void CreateDataChannel(const std::string& label, const DataChannelInit* init);
// Return the last observed data channel.
DataChannelInterface* data_channel();
// Return all data channels.
std::vector<scoped_refptr<DataChannelInterface>>& data_channels() {
return data_channels_;
}
MockDataChannelObserver* data_observer() const;
std::vector<std::unique_ptr<MockDataChannelObserver>>& data_observers() {
return data_observers_;
}
std::unique_ptr<SessionDescriptionInterface> CreateAnswerForTest();
int audio_frames_received() const;
// Takes minimum of video frames received for each track.
//
// Can be used like:
// EXPECT_GE(expected_frames, min_video_frames_received_per_track());
//
// To ensure that all video tracks received at least a certain number of
// frames.
int min_video_frames_received_per_track() const;
// Returns a MockStatsObserver in a state after stats gathering finished,
// which can be used to access the gathered stats.
scoped_refptr<MockStatsObserver> OldGetStatsForTrack(
MediaStreamTrackInterface* track);
// Version that doesn't take a track "filter", and gathers all stats.
scoped_refptr<MockStatsObserver> OldGetStats();
// Synchronously gets stats and returns them. If it times out, fails the test
// and returns null.
// TODO(bugs.webrtc.org/501310910): Unify NewGetStats implementations by
// making RunLoop an interface that can be implemented for simulated time too.
// TODO(tommi) - Remove this method in favor of the one that supports RunLoop.
scoped_refptr<const RTCStatsReport> NewGetStats(
WaitUntilSettings settings = {});
scoped_refptr<const RTCStatsReport> NewGetStats(test::RunLoop& run_loop);
std::string DtlsCipher();
std::string SrtpCipher();
int rendered_width();
int rendered_height();
double rendered_aspect_ratio();
VideoRotation rendered_rotation();
int local_rendered_width();
int local_rendered_height();
double local_rendered_aspect_ratio();
PLAN_B_ONLY size_t number_of_remote_streams();
PLAN_B_ONLY StreamCollectionInterface* remote_streams() const;
PLAN_B_ONLY StreamCollectionInterface* local_streams();
PeerConnectionInterface::SignalingState signaling_state();
PeerConnectionInterface::IceConnectionState ice_connection_state();
PeerConnectionInterface::IceConnectionState
standardized_ice_connection_state();
PeerConnectionInterface::IceGatheringState ice_gathering_state();
// Returns a MockRtpReceiverObserver for each RtpReceiver returned by
// GetReceivers. They're updated automatically when a remote offer/answer
// from the fake signaling channel is applied, or when
// ResetRtpReceiverObservers below is called.
const std::vector<std::unique_ptr<MockRtpReceiverObserver>>&
rtp_receiver_observers() {
return rtp_receiver_observers_;
}
void ResetRtpReceiverObservers();
const std::vector<std::unique_ptr<MockRtpSenderObserver>>&
rtp_sender_observers() {
return rtp_sender_observers_;
}
void ResetRtpSenderObservers();
FakeNetworkManager* network_manager() const { return fake_network_manager_; }
FakeRtcEventLogFactory* event_log_factory() const {
return event_log_factory_;
}
Candidate last_candidate_gathered() const;
const IceCandidate* last_gathered_ice_candidate() const {
return last_gathered_ice_candidate_.get();
}
const IceCandidateErrorEvent& error_event() const { return error_event_; }
// Sets the mDNS responder for the owned fake network manager and keeps a
// reference to the responder.
void SetMdnsResponder(std::unique_ptr<FakeMdnsResponder> mdns_responder);
// Returns null on failure.
std::unique_ptr<SessionDescriptionInterface> CreateOfferAndWait();
bool Rollback();
// Functions for querying stats.
void StartWatchingDelayStats();
void UpdateDelayStats(std::string tag, int desc_size);
bool AudioDelayStatsPercentageChecked() const {
return audio_delay_stats_percentage_checked_;
}
// Sets number of candidates expected
void ExpectCandidates(int candidate_count) {
candidates_expected_ = candidate_count;
}
bool SetRemoteDescription(std::unique_ptr<SessionDescriptionInterface> desc);
void NegotiateCorruptionDetectionHeader();
uint32_t GetCorruptionScoreCount();
uint32_t GetReceivedFrameCount();
void set_connection_change_callback(
std::function<void(PeerConnectionInterface::PeerConnectionState)> func) {
connection_change_callback_ = std::move(func);
}
std::optional<int> tls_version();
std::optional<DtlsTransportTlsRole> dtls_transport_role();
DtlsTransportInformation dtls_transport_information();
// Setting the local description and sending the SDP message over the fake
// signaling channel are combined into the same method because the SDP
// message needs to be sent as soon as SetLocalDescription finishes, without
// waiting for the observer to be called. This ensures that ICE candidates
// don't outrace the description.
bool SetLocalDescriptionAndSendSdpMessage(
std::unique_ptr<SessionDescriptionInterface> desc);
public:
bool Init(const PeerConnectionFactory::Options* options,
const PeerConnectionInterface::RTCConfiguration* config,
PeerConnectionDependencies dependencies,
SocketServer* socket_server,
Thread* network_thread,
Thread* worker_thread,
std::unique_ptr<FakeRtcEventLogFactory> event_log_factory,
bool reset_encoder_factory,
bool reset_decoder_factory,
bool create_media_engine);
scoped_refptr<PeerConnectionInterface> CreatePeerConnection(
const PeerConnectionInterface::RTCConfiguration* config,
PeerConnectionDependencies dependencies);
void set_signaling_delay_ms(int delay_ms) { signaling_delay_ms_ = delay_ms; }
void set_signal_ice_candidates(bool signal) {
signal_ice_candidates_ = signal;
}
scoped_refptr<VideoTrackInterface> CreateLocalVideoTrackInternal(
FakePeriodicVideoSource::Config config);
void HandleIncomingOffer(const std::string& msg);
void HandleIncomingAnswer(SdpType type, const std::string& msg);
// Returns null on failure.
std::unique_ptr<SessionDescriptionInterface> CreateAnswer();
// This is a work around to remove unused fake_video_renderers from
// transceivers that have either stopped or are no longer receiving.
void RemoveUnusedVideoRenderers();
// Simulate sending a blob of SDP with delay `signaling_delay_ms_` (0 by
// default).
void SendSdpMessage(SdpType type, const std::string& msg);
void RelaySdpMessageIfReceiverExists(SdpType type, const std::string& msg);
// Simulate trickling an ICE candidate with delay `signaling_delay_ms_` (0 by
// default).
void SendIceMessage(const std::string& sdp_mid,
int sdp_mline_index,
const std::string& msg);
void RelayIceMessageIfReceiverExists(const std::string& sdp_mid,
int sdp_mline_index,
const std::string& msg);
// SignalingMessageReceiver callbacks.
public:
void set_signaling_message_receiver(
SignalingMessageReceiver* signaling_message_receiver) {
signaling_message_receiver_ = signaling_message_receiver;
}
void ReceiveSdpMessage(SdpType type, const std::string& msg) override;
void ReceiveIceMessage(const std::string& sdp_mid,
int sdp_mline_index,
const std::string& msg) override;
private:
// PeerConnectionObserver callbacks.
void OnSignalingChange(
PeerConnectionInterface::SignalingState new_state) override;
void OnAddTrack(
scoped_refptr<RtpReceiverInterface> receiver,
const std::vector<scoped_refptr<MediaStreamInterface>>& streams) override;
void OnRemoveTrack(scoped_refptr<RtpReceiverInterface> receiver) override;
void OnRenegotiationNeeded() override;
void OnIceConnectionChange(
PeerConnectionInterface::IceConnectionState new_state) override;
void OnStandardizedIceConnectionChange(
PeerConnectionInterface::IceConnectionState new_state) override;
void OnConnectionChange(
PeerConnectionInterface::PeerConnectionState new_state) override;
void OnIceGatheringChange(
PeerConnectionInterface::IceGatheringState new_state) override;
void OnIceSelectedCandidatePairChanged(
const CandidatePairChangeEvent& event) override {
ice_candidate_pair_change_history_.push_back(event);
}
void OnIceCandidate(const IceCandidate* candidate) override;
void OnIceCandidateError(const std::string& address,
int port,
const std::string& url,
int error_code,
const std::string& error_text) override;
void OnIceCandidateRemoved(const IceCandidate* candidate) override {}
void OnDataChannel(scoped_refptr<DataChannelInterface> data_channel) override;
bool IdExists(const RtpHeaderExtensions& extensions, RtpHeaderExtensionId id);
private:
std::string debug_name_;
const Environment env_;
// Network manager is owned by the `peer_connection_factory_`.
FakeNetworkManager* fake_network_manager_ = nullptr;
Thread* network_thread_;
// Reference to the mDNS responder owned by `fake_network_manager_` after set.
FakeMdnsResponder* mdns_responder_ = nullptr;
scoped_refptr<PeerConnectionInterface> peer_connection_;
scoped_refptr<PeerConnectionFactoryInterface> peer_connection_factory_;
// Needed to keep track of number of frames sent.
scoped_refptr<FakeAudioCaptureModule> fake_audio_capture_module_;
// Needed to keep track of number of frames received.
std::map<std::string, std::unique_ptr<FakeVideoTrackRenderer>>
fake_video_renderers_;
// Needed to ensure frames aren't received for removed tracks.
std::vector<std::unique_ptr<FakeVideoTrackRenderer>>
removed_fake_video_renderers_;
// For remote peer communication.
SignalingMessageReceiver* signaling_message_receiver_ = nullptr;
int signaling_delay_ms_ = 0;
bool signal_ice_candidates_ = true;
std::unique_ptr<IceCandidate> last_gathered_ice_candidate_;
IceCandidateErrorEvent error_event_;
// Store references to the video sources we've created, so that we can stop
// them, if required.
std::vector<scoped_refptr<VideoTrackSource>> video_track_sources_;
// `local_video_renderer_` attached to the first created local video track.
std::unique_ptr<FakeVideoTrackRenderer> local_video_renderer_;
SdpSemantics sdp_semantics_;
PeerConnectionInterface::RTCOfferAnswerOptions offer_answer_options_;
std::function<void(std::unique_ptr<SessionDescriptionInterface>&)>
received_sdp_munger_;
std::function<void(std::unique_ptr<SessionDescriptionInterface>&)>
generated_sdp_munger_;
std::function<void()> remote_offer_handler_;
MockAsyncDnsResolver* remote_async_dns_resolver_ = nullptr;
// Result variables for the mock DNS resolver
NiceMock<MockAsyncDnsResolverResult> remote_async_dns_resolver_result_;
SocketAddress remote_async_dns_resolved_addr_;
// All data channels either created or observed on this peerconnection
std::vector<scoped_refptr<DataChannelInterface>> data_channels_;
std::vector<std::unique_ptr<MockDataChannelObserver>> data_observers_;
std::vector<std::unique_ptr<MockRtpReceiverObserver>> rtp_receiver_observers_;
std::vector<std::unique_ptr<MockRtpSenderObserver>> rtp_sender_observers_;
std::vector<PeerConnectionInterface::IceConnectionState>
ice_connection_state_history_;
std::vector<PeerConnectionInterface::IceConnectionState>
standardized_ice_connection_state_history_;
std::vector<PeerConnectionInterface::PeerConnectionState>
peer_connection_state_history_;
std::vector<PeerConnectionInterface::IceGatheringState>
ice_gathering_state_history_;
std::vector<CandidatePairChangeEvent> ice_candidate_pair_change_history_;
std::vector<PeerConnectionInterface::SignalingState>
peer_connection_signaling_state_history_;
FakeRtcEventLogFactory* event_log_factory_;
// Number of ICE candidates expected. The default is no limit.
int candidates_expected_ = std::numeric_limits<int>::max();
// Variables for tracking delay stats on an audio track
int audio_packets_stat_ = 0;
double audio_delay_stat_ = 0.0;
uint64_t audio_samples_stat_ = 0;
uint64_t audio_concealed_stat_ = 0;
std::string rtp_stats_id_;
bool audio_delay_stats_percentage_checked_ = false;
std::function<void(PeerConnectionInterface::PeerConnectionState)>
connection_change_callback_ = nullptr;
ScopedTaskSafety task_safety_;
internal::PeerConnectionIntegrationTestBase* test_ = nullptr;
};
class MockRtcEventLogOutput : public RtcEventLogOutput {
public:
~MockRtcEventLogOutput() override = default;
MOCK_METHOD(bool, IsActive, (), (const, override));
MOCK_METHOD(bool, Write, (absl::string_view), (override));
};
// This helper object is used for both specifying how many audio/video frames
// are expected to be received for a caller/callee. It provides helper functions
// to specify these expectations. The object initially starts in a state of no
// expectations.
class MediaExpectations {
public:
enum ExpectFrames {
kExpectSomeFrames,
kExpectNoFrames,
kNoExpectation,
};
void ExpectBidirectionalAudioAndVideo() {
ExpectBidirectionalAudio();
ExpectBidirectionalVideo();
}
void ExpectBidirectionalAudio() {
CallerExpectsSomeAudio();
CalleeExpectsSomeAudio();
}
void ExpectNoAudio() {
CallerExpectsNoAudio();
CalleeExpectsNoAudio();
}
void ExpectBidirectionalVideo() {
CallerExpectsSomeVideo();
CalleeExpectsSomeVideo();
}
void ExpectNoVideo() {
CallerExpectsNoVideo();
CalleeExpectsNoVideo();
}
void CallerExpectsSomeAudioAndVideo() {
CallerExpectsSomeAudio();
CallerExpectsSomeVideo();
}
void CalleeExpectsSomeAudioAndVideo() {
CalleeExpectsSomeAudio();
CalleeExpectsSomeVideo();
}
// Caller's audio functions.
void CallerExpectsSomeAudio(
int expected_audio_frames = kDefaultExpectedAudioFrameCount) {
caller_audio_expectation_ = kExpectSomeFrames;
caller_audio_frames_expected_ = expected_audio_frames;
}
void CallerExpectsNoAudio() {
caller_audio_expectation_ = kExpectNoFrames;
caller_audio_frames_expected_ = 0;
}
// Caller's video functions.
void CallerExpectsSomeVideo(
int expected_video_frames = kDefaultExpectedVideoFrameCount) {
caller_video_expectation_ = kExpectSomeFrames;
caller_video_frames_expected_ = expected_video_frames;
}
void CallerExpectsNoVideo() {
caller_video_expectation_ = kExpectNoFrames;
caller_video_frames_expected_ = 0;
}
// Callee's audio functions.
void CalleeExpectsSomeAudio(
int expected_audio_frames = kDefaultExpectedAudioFrameCount) {
callee_audio_expectation_ = kExpectSomeFrames;
callee_audio_frames_expected_ = expected_audio_frames;
}
void CalleeExpectsNoAudio() {
callee_audio_expectation_ = kExpectNoFrames;
callee_audio_frames_expected_ = 0;
}
// Callee's video functions.
void CalleeExpectsSomeVideo(
int expected_video_frames = kDefaultExpectedVideoFrameCount) {
callee_video_expectation_ = kExpectSomeFrames;
callee_video_frames_expected_ = expected_video_frames;
}
void CalleeExpectsNoVideo() {
callee_video_expectation_ = kExpectNoFrames;
callee_video_frames_expected_ = 0;
}
ExpectFrames caller_audio_expectation_ = kNoExpectation;
ExpectFrames caller_video_expectation_ = kNoExpectation;
ExpectFrames callee_audio_expectation_ = kNoExpectation;
ExpectFrames callee_video_expectation_ = kNoExpectation;
int caller_audio_frames_expected_ = 0;
int caller_video_frames_expected_ = 0;
int callee_audio_frames_expected_ = 0;
int callee_video_frames_expected_ = 0;
};
class MockIceTransport : public IceTransportInterface {
public:
MockIceTransport(const std::string& name, int component)
: internal_(std::make_unique<FakeIceTransportInternal>(name,
component,
nullptr)) {}
~MockIceTransport() override = default;
IceTransportInternal* internal() override { return internal_.get(); }
private:
std::unique_ptr<FakeIceTransportInternal> internal_;
};
class MockIceTransportFactory : public IceTransportFactory {
public:
~MockIceTransportFactory() override = default;
scoped_refptr<IceTransportInterface> CreateIceTransport(
const std::string& transport_name,
int component,
IceTransportInit init) override {
RecordIceTransportCreated();
return make_ref_counted<MockIceTransport>(transport_name, component);
}
MOCK_METHOD(void, RecordIceTransportCreated, ());
};
// Tests two PeerConnections connecting to each other end-to-end, using a
// virtual network, fake A/V capture and fake encoder/decoders. The
// PeerConnections share the threads/socket servers, but use separate versions
// of everything else (including "PeerConnectionFactory"s).
namespace internal {
class PeerConnectionIntegrationTestBase : public ::testing::Test {
public:
static constexpr char kCallerName[] = "Caller";
static constexpr char kCalleeName[] = "Callee";
explicit PeerConnectionIntegrationTestBase(Environment env,
SdpSemantics sdp_semantics);
PeerConnectionIntegrationTestBase(Environment env,
SdpSemantics sdp_semantics,
TimeController* time_controller);
~PeerConnectionIntegrationTestBase() override;
virtual std::unique_ptr<PeerConnectionIntegrationWrapper>
CreatePeerConnectionWrapperInternal(const std::string& debug_name,
Environment env);
virtual Waiter GetWaiter(WaitUntilSettings overrides = {}) = 0;
virtual TimeController* time_controller() { return nullptr; }
virtual std::unique_ptr<Thread> CreateThread(absl::string_view name) = 0;
bool SignalingStateStable() {
return caller_->SignalingStateStable() && callee_->SignalingStateStable();
}
bool PeerConnectionStateIs(
PeerConnectionInterface::PeerConnectionState state) {
return caller_->pc()->peer_connection_state() == state &&
callee_->pc()->peer_connection_state() == state;
}
bool DtlsConnected();
// Sets field trials to pass to created PeerConnectionWrapper.
// Must be called before PeerConnectionWrappers are created.
void SetFieldTrials(absl::string_view field_trials);
// Sets field trials to pass to created PeerConnectionWrapper key:ed on
// debug_name. Must be called before PeerConnectionWrappers are created.
void SetFieldTrials(absl::string_view debug_name,
absl::string_view field_trials);
// When `event_log_factory` is null, the default implementation of the event
// log factory will be used.
std::unique_ptr<PeerConnectionIntegrationWrapper> CreatePeerConnectionWrapper(
const std::string& debug_name,
const PeerConnectionFactory::Options* options,
const RTCConfiguration* config,
PeerConnectionDependencies dependencies,
std::unique_ptr<FakeRtcEventLogFactory> event_log_factory,
bool reset_encoder_factory,
bool reset_decoder_factory,
bool create_media_engine = true);
std::unique_ptr<PeerConnectionIntegrationWrapper>
CreatePeerConnectionWrapperWithFakeRtcEventLog(
const std::string& debug_name,
const PeerConnectionFactory::Options* options,
const RTCConfiguration* config,
PeerConnectionDependencies dependencies);
bool CreatePeerConnectionWrappers() {
return CreatePeerConnectionWrappersWithConfig(
PeerConnectionInterface::RTCConfiguration(),
PeerConnectionInterface::RTCConfiguration());
}
bool CreatePeerConnectionWrappersWithSdpSemantics(
SdpSemantics caller_semantics,
SdpSemantics callee_semantics);
bool CreatePeerConnectionWrappersWithConfig(
const PeerConnectionInterface::RTCConfiguration& caller_config,
const PeerConnectionInterface::RTCConfiguration& callee_config,
bool create_media_engine = true);
bool CreatePeerConnectionWrappersWithConfigAndDeps(
const PeerConnectionInterface::RTCConfiguration& caller_config,
PeerConnectionDependencies caller_dependencies,
const PeerConnectionInterface::RTCConfiguration& callee_config,
PeerConnectionDependencies callee_dependencies);
bool CreatePeerConnectionWrappersWithOptions(
const PeerConnectionFactory::Options& caller_options,
const PeerConnectionFactory::Options& callee_options);
bool CreatePeerConnectionWrappersWithFakeRtcEventLog();
std::unique_ptr<PeerConnectionIntegrationWrapper>
CreatePeerConnectionWrapperWithAlternateKey();
bool CreateOneDirectionalPeerConnectionWrappers(bool caller_to_callee);
bool CreatePeerConnectionWrappersWithoutMediaEngine();
TestTurnServer* CreateTurnServer(
SocketAddress internal_address,
SocketAddress external_address,
ProtocolType type = ProtocolType::PROTO_UDP,
const std::string& common_name = "test turn server");
TestTurnCustomizer* CreateTurnCustomizer();
// Checks that the function counters for a TestTurnCustomizer are greater than
// 0.
void ExpectTurnCustomizerCountersIncremented(
TestTurnCustomizer* turn_customizer);
// Once called, SDP blobs and ICE candidates will be automatically signaled
// between PeerConnections.
void ConnectFakeSignaling();
// Once called, SDP blobs will be automatically signaled between
// PeerConnections. Note that ICE candidates will not be signaled unless they
// are in the exchanged SDP blobs.
void ConnectFakeSignalingForSdpOnly();
void SetSignalingDelayMs(int delay_ms);
void SetSignalIceCandidates(bool signal);
// Messages may get lost on the unreliable DataChannel, so we send multiple
// times to avoid test flakiness.
void SendRtpDataWithRetries(DataChannelInterface* dc,
const std::string& data,
int retries);
Thread* network_thread() { return network_thread_.get(); }
VirtualSocketServer* virtual_socket_server() { return ss_.get(); }
PeerConnectionIntegrationWrapper* caller() { return caller_.get(); }
// Destroy peer connections.
// This can be used to ensure that all pointers to on-stack mocks
// get dropped before exit.
void DestroyPeerConnections();
void DestroyTurnServers();
void DestroyThreads();
// Set the `caller_` to the `wrapper` passed in and return the
// original `caller_`.
PeerConnectionIntegrationWrapper* SetCallerPcWrapperAndReturnCurrent(
std::unique_ptr<PeerConnectionIntegrationWrapper> wrapper);
PeerConnectionIntegrationWrapper* callee() { return callee_.get(); }
// Set the `callee_` to the `wrapper` passed in and return the
// original `callee_`.
PeerConnectionIntegrationWrapper* SetCalleePcWrapperAndReturnCurrent(
std::unique_ptr<PeerConnectionIntegrationWrapper> wrapper);
FirewallSocketServer* firewall() const { return fss_.get(); }
// Expects the provided number of new frames to be received within
// kMaxWaitForFramesMs. The new expected frames are specified in
// `media_expectations`. Returns false if any of the expectations were
// not met.
bool ExpectNewFrames(const MediaExpectations& media_expectations);
void ClosePeerConnections();
void TestNegotiatedCipherSuite(const RTCConfiguration& caller_config,
const RTCConfiguration& callee_config,
int expected_cipher_suite);
void TestGcmNegotiationUsesCipherSuite(bool local_gcm_enabled,
bool remote_gcm_enabled,
bool aes_ctr_enabled,
int expected_cipher_suite);
protected:
void OverrideLoggingLevelForTest(LoggingSeverity new_severity);
SdpSemantics sdp_semantics_;
const Environment env_;
virtual void ExecuteTask(TaskQueueBase& task_queue,
absl::AnyInvocable<void()> task) = 0;
private:
// Support for optionally changing the default logging level for the duration
// of the test. Scoped wider than other member variables to also affect
// logging that's done in destructors.
class ScopedSetLoggingLevel;
std::unique_ptr<ScopedSetLoggingLevel> overridden_logging_level_;
// `ss_` is used by `network_thread_` so it must be destroyed later.
std::unique_ptr<VirtualSocketServer> ss_;
std::unique_ptr<FirewallSocketServer> fss_;
// `network_thread_` and `worker_thread_` are used by both
// `caller_` and `callee_` so they must be destroyed
// later.
std::unique_ptr<Thread> network_thread_;
std::unique_ptr<Thread> worker_thread_;
// The turn servers and turn customizers should be accessed & deleted on the
// network thread to avoid a race with the socket read/write that occurs
// on the network thread.
std::vector<std::unique_ptr<TestTurnServer>> turn_servers_;
std::vector<std::unique_ptr<TestTurnCustomizer>> turn_customizers_;
std::unique_ptr<PeerConnectionIntegrationWrapper> caller_;
std::unique_ptr<PeerConnectionIntegrationWrapper> callee_;
std::string field_trials_;
std::map<std::string, std::string> field_trials_overrides_;
};
} // namespace internal
class PeerConnectionIntegrationBaseTest
: public internal::PeerConnectionIntegrationTestBase {
public:
explicit PeerConnectionIntegrationBaseTest(SdpSemantics sdp_semantics);
~PeerConnectionIntegrationBaseTest() override;
test::RunLoop& run_loop() { return run_loop_; }
void ExecuteTask(TaskQueueBase& task_queue,
absl::AnyInvocable<void()> task) override;
Waiter GetWaiter(WaitUntilSettings overrides = {}) override;
std::unique_ptr<Thread> CreateThread(absl::string_view name) override;
protected:
test::RunLoop run_loop_;
};
class PeerConnectionIntegrationTestWithSimulatedTime
: public internal::PeerConnectionIntegrationTestBase {
public:
explicit PeerConnectionIntegrationTestWithSimulatedTime(
SdpSemantics sdp_semantics);
void ExecuteTask(TaskQueueBase& task_queue,
absl::AnyInvocable<void()> task) override;
Waiter GetWaiter(WaitUntilSettings overrides = {}) override;
TimeController* time_controller() { return time_controller_.get(); }
std::unique_ptr<Thread> CreateThread(absl::string_view name) override;
~PeerConnectionIntegrationTestWithSimulatedTime() override;
private:
PeerConnectionIntegrationTestWithSimulatedTime(
SdpSemantics sdp_semantics,
std::unique_ptr<GlobalSimulatedTimeController> time_controller);
protected:
std::unique_ptr<GlobalSimulatedTimeController> time_controller_;
};
template <typename Base>
class PeerConnectionIntegrationIceStatesTestBase
: public Base,
public ::testing::WithParamInterface<
std::tuple<SdpSemantics, std::tuple<std::string, uint32_t>>> {
protected:
PeerConnectionIntegrationIceStatesTestBase()
: Base(std::get<0>(this->GetParam())) {
port_allocator_flags_ = std::get<1>(std::get<1>(this->GetParam()));
}
void StartStunServer(const SocketAddress& server_address) {
stun_server_ = TestStunServer::Create(
this->env_, server_address, *this->firewall(), *this->network_thread());
}
bool TestIPv6() {
return (port_allocator_flags_ & PORTALLOCATOR_ENABLE_IPV6);
}
std::vector<SocketAddress> CallerAddresses() {
std::vector<SocketAddress> addresses;
addresses.push_back(SocketAddress("1.1.1.1", 0));
if (TestIPv6()) {
addresses.push_back(SocketAddress("1111:0:a:b:c:d:e:f", 0));
}
return addresses;
}
std::vector<SocketAddress> CalleeAddresses() {
std::vector<SocketAddress> addresses;
addresses.push_back(SocketAddress("2.2.2.2", 0));
if (TestIPv6()) {
addresses.push_back(SocketAddress("2222:0:a:b:c:d:e:f", 0));
}
return addresses;
}
void SetUpNetworkInterfaces() {
// Remove the default interfaces added by the test infrastructure.
this->caller()->network_manager()->RemoveInterface(kDefaultLocalAddress);
this->callee()->network_manager()->RemoveInterface(kDefaultLocalAddress);
// Add network addresses for test.
for (const auto& caller_address : CallerAddresses()) {
this->caller()->network_manager()->AddInterface(caller_address);
}
for (const auto& callee_address : CalleeAddresses()) {
this->callee()->network_manager()->AddInterface(callee_address);
}
}
uint32_t port_allocator_flags() const { return port_allocator_flags_; }
private:
uint32_t port_allocator_flags_;
TestStunServer::StunServerPtr stun_server_;
};
} // namespace webrtc
#endif // PC_TEST_INTEGRATION_TEST_HELPERS_H_