zqz/platform-external-webrtc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Cleanup MultiStreamTester

Browse Source 
Instead of taking TaskQueue from outside create one internally.
Detach MultiStreamTests from test::CallTest since that inheritance
only used for constants and (now unneeded) task_queue object.

Bug: webrtc:10933
Change-Id: I7e30ddcf6faaa134ebcd9d53b578b40fdedf2a3c
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/159034
Reviewed-by: Ilya Nikolaevskiy <ilnik@webrtc.org>
Commit-Queue: Danil Chapovalov <danilchap@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#29744}
This commit is contained in:
Danil Chapovalov
2019-11-08 09:40:26 +01:00
committed by Commit Bot
parent 2bc811ea07
commit d6b9b0a1f4
4 changed files with 35 additions and 44 deletions
Download Patch File Download Diff File Expand all files Collapse all files

19
video/end_to_end_tests/multi_stream_tester.cc
View File

@ -31,23 +31,20 @@
namespace webrtc {
MultiStreamTester::MultiStreamTester(TaskQueueBase* task_queue)
: task_queue_(task_queue) {
MultiStreamTester::MultiStreamTester() {
// TODO(sprang): Cleanup when msvc supports explicit initializers for array.
codec_settings[0] = {1, 640, 480};
codec_settings[1] = {2, 320, 240};
codec_settings[2] = {3, 240, 160};
class multi_stream_test {
public:
multi_stream_test();
};
}
MultiStreamTester::~MultiStreamTester() {}
MultiStreamTester::~MultiStreamTester() = default;
void MultiStreamTester::RunTest() {
webrtc::RtcEventLogNull event_log;
auto task_queue_factory = CreateDefaultTaskQueueFactory();
auto task_queue = task_queue_factory->CreateTaskQueue(
"TaskQueue", TaskQueueFactory::Priority::NORMAL);
Call::Config config(&event_log);
config.task_queue_factory = task_queue_factory.get();
std::unique_ptr<Call> sender_call;
@ -64,12 +61,12 @@ void MultiStreamTester::RunTest() {
CreateBuiltinVideoBitrateAllocatorFactory();
InternalDecoderFactory decoder_factory;
SendTask(RTC_FROM_HERE, task_queue_, [&]() {
SendTask(RTC_FROM_HERE, task_queue.get(), [&]() {
sender_call = absl::WrapUnique(Call::Create(config));
receiver_call = absl::WrapUnique(Call::Create(config));
sender_transport = CreateSendTransport(task_queue_, sender_call.get());
sender_transport = CreateSendTransport(task_queue.get(), sender_call.get());
receiver_transport =
CreateReceiveTransport(task_queue_, receiver_call.get());
CreateReceiveTransport(task_queue.get(), receiver_call.get());
sender_transport->SetReceiver(receiver_call->Receiver());
receiver_transport->SetReceiver(sender_call->Receiver());
@ -125,7 +122,7 @@ void MultiStreamTester::RunTest() {
Wait();
SendTask(RTC_FROM_HERE, task_queue_, [&]() {
SendTask(RTC_FROM_HERE, task_queue.get(), [&]() {
for (size_t i = 0; i < kNumStreams; ++i) {
frame_generators[i]->Stop();
sender_call->DestroyVideoSendStream(send_streams[i]);

4
video/end_to_end_tests/multi_stream_tester.h
View File

@ -35,7 +35,7 @@ class MultiStreamTester {
int height;
} codec_settings[kNumStreams];
explicit MultiStreamTester(TaskQueueBase* task_queue);
MultiStreamTester();
virtual ~MultiStreamTester();
@ -58,8 +58,6 @@ class MultiStreamTester {
virtual std::unique_ptr<test::DirectTransport> CreateReceiveTransport(
TaskQueueBase* task_queue,
Call* receiver_call);
TaskQueueBase* const task_queue_;
};
} // namespace webrtc
#endif // VIDEO_END_TO_END_TESTS_MULTI_STREAM_TESTER_H_

21
video/end_to_end_tests/multi_stream_tests.cc
View File

@ -21,20 +21,14 @@
#include "call/video_receive_stream.h"
#include "call/video_send_stream.h"
#include "rtc_base/event.h"
#include "test/call_test.h"
#include "test/frame_generator_capturer.h"
#include "test/gtest.h"
#include "video/end_to_end_tests/multi_stream_tester.h"
namespace webrtc {
class MultiStreamEndToEndTest : public test::CallTest {
public:
MultiStreamEndToEndTest() = default;
};
// Each renderer verifies that it receives the expected resolution, and as soon
// as every renderer has received a frame, the test finishes.
TEST_F(MultiStreamEndToEndTest, SendsAndReceivesMultipleStreams) {
TEST(MultiStreamEndToEndTest, SendsAndReceivesMultipleStreams) {
class VideoOutputObserver : public rtc::VideoSinkInterface<VideoFrame> {
public:
VideoOutputObserver(const MultiStreamTester::CodecSettings& settings,
@ -51,7 +45,7 @@ TEST_F(MultiStreamEndToEndTest, SendsAndReceivesMultipleStreams) {
uint32_t Ssrc() { return ssrc_; }
bool Wait() { return done_.Wait(kDefaultTimeoutMs); }
bool Wait() { return done_.Wait(30 * 1000); }
private:
const MultiStreamTester::CodecSettings& settings_;
@ -62,9 +56,8 @@ TEST_F(MultiStreamEndToEndTest, SendsAndReceivesMultipleStreams) {
class Tester : public MultiStreamTester {
public:
explicit Tester(TaskQueueBase* task_queue)
: MultiStreamTester(task_queue) {}
virtual ~Tester() {}
Tester() = default;
~Tester() override = default;
protected:
void Wait() override {
@ -79,9 +72,9 @@ TEST_F(MultiStreamEndToEndTest, SendsAndReceivesMultipleStreams) {
VideoSendStream::Config* send_config,
VideoEncoderConfig* encoder_config,
test::FrameGeneratorCapturer** frame_generator) override {
observers_[stream_index].reset(new VideoOutputObserver(
observers_[stream_index] = std::make_unique<VideoOutputObserver>(
codec_settings[stream_index], send_config->rtp.ssrcs.front(),
frame_generator));
frame_generator);
}
void UpdateReceiveConfig(
@ -92,7 +85,7 @@ TEST_F(MultiStreamEndToEndTest, SendsAndReceivesMultipleStreams) {
private:
std::unique_ptr<VideoOutputObserver> observers_[kNumStreams];
} tester(task_queue());
} tester;
tester.RunTest();
}

35
video/end_to_end_tests/transport_feedback_tests.cc
View File

@ -29,15 +29,13 @@ enum : int { // The first valid value is 1.
};
} // namespace
class TransportFeedbackEndToEndTest : public test::CallTest {
public:
TransportFeedbackEndToEndTest() {
RegisterRtpExtension(RtpExtension(RtpExtension::kTransportSequenceNumberUri,
kTransportSequenceNumberExtensionId));
}
};
TEST(TransportFeedbackMultiStreamTest, AssignsTransportSequenceNumbers) {
static constexpr int kSendRtxPayloadType = 98;
static constexpr int kDefaultTimeoutMs = 30 * 1000;
static constexpr int kNackRtpHistoryMs = 1000;
static constexpr uint32_t kSendRtxSsrcs[MultiStreamTester::kNumStreams] = {
0xBADCAFD, 0xBADCAFE, 0xBADCAFF};
TEST_F(TransportFeedbackEndToEndTest, AssignsTransportSequenceNumbers) {
class RtpExtensionHeaderObserver : public test::DirectTransport {
public:
RtpExtensionHeaderObserver(
@ -56,7 +54,6 @@ TEST_F(TransportFeedbackEndToEndTest, AssignsTransportSequenceNumbers) {
parser_(RtpHeaderParser::CreateForTest()),
first_media_ssrc_(first_media_ssrc),
rtx_to_media_ssrcs_(ssrc_map),
padding_observed_(false),
rtx_padding_observed_(false),
retransmit_observed_(false),
started_(false) {
@ -149,6 +146,7 @@ TEST_F(TransportFeedbackEndToEndTest, AssignsTransportSequenceNumbers) {
return done_.Wait(kDefaultTimeoutMs);
}
private:
rtc::CriticalSection lock_;
rtc::Event done_;
std::unique_ptr<RtpHeaderParser> parser_;
@ -158,7 +156,6 @@ TEST_F(TransportFeedbackEndToEndTest, AssignsTransportSequenceNumbers) {
std::map<uint32_t, std::set<uint16_t>> dropped_seq_;
const uint32_t& first_media_ssrc_;
const std::map<uint32_t, uint32_t>& rtx_to_media_ssrcs_;
bool padding_observed_;
bool rtx_padding_observed_;
bool retransmit_observed_;
bool started_;
@ -166,11 +163,9 @@ TEST_F(TransportFeedbackEndToEndTest, AssignsTransportSequenceNumbers) {
class TransportSequenceNumberTester : public MultiStreamTester {
public:
explicit TransportSequenceNumberTester(TaskQueueBase* task_queue)
: MultiStreamTester(task_queue),
first_media_ssrc_(0),
observer_(nullptr) {}
virtual ~TransportSequenceNumberTester() {}
TransportSequenceNumberTester()
: first_media_ssrc_(0), observer_(nullptr) {}
~TransportSequenceNumberTester() override = default;
protected:
void Wait() override {
@ -238,11 +233,19 @@ TEST_F(TransportFeedbackEndToEndTest, AssignsTransportSequenceNumbers) {
uint32_t first_media_ssrc_;
std::map<uint32_t, uint32_t> rtx_to_media_ssrcs_;
RtpExtensionHeaderObserver* observer_;
} tester(task_queue());
} tester;
tester.RunTest();
}
class TransportFeedbackEndToEndTest : public test::CallTest {
public:
TransportFeedbackEndToEndTest() {
RegisterRtpExtension(RtpExtension(RtpExtension::kTransportSequenceNumberUri,
kTransportSequenceNumberExtensionId));
}
};
class TransportFeedbackTester : public test::EndToEndTest {
public:
TransportFeedbackTester(bool feedback_enabled,