Replace voe_auto_test

webrtc/audio/audio_send_stream_tests.cc

+/*
+ *  Copyright (c) 2017 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.
+ */
+
+#include "webrtc/test/call_test.h"
+#include "webrtc/test/gtest.h"
+#include "webrtc/test/rtcp_packet_parser.h"
+
+namespace webrtc {
+namespace test {
+namespace {
+
+class AudioSendTest : public SendTest {
+ public:
+  AudioSendTest() : SendTest(CallTest::kDefaultTimeoutMs) {}
+
+  size_t GetNumVideoStreams() const override {
+    return 0;
+  }
+  size_t GetNumAudioStreams() const override {
+    return 1;
+  }
+  size_t GetNumFlexfecStreams() const override {
+    return 0;
+  }
+};
+}  // namespace
+
+using AudioSendStreamCallTest = CallTest;
+
+TEST_F(AudioSendStreamCallTest, SupportsCName) {
+  static std::string kCName = "PjqatC14dGfbVwGPUOA9IH7RlsFDbWl4AhXEiDsBizo=";
+  class CNameObserver : public AudioSendTest {
+   public:
+    CNameObserver() : AudioSendTest() {}

[ossu, 2017/09/14 11:51:58]

Will CNameObserver() = default; do?

[the sun, 2017/09/14 12:36:39]

Done.

+
+   private:
+    Action OnSendRtcp(const uint8_t* packet, size_t length) override {
+      RtcpPacketParser parser;
+      EXPECT_TRUE(parser.Parse(packet, length));
+      if (parser.sdes()->num_packets() > 0) {
+        EXPECT_EQ(1u, parser.sdes()->chunks().size());
+        EXPECT_EQ(kCName, parser.sdes()->chunks()[0].cname);
+
+        observation_complete_.Set();
+      }
+
+      return SEND_PACKET;
+    }
+
+    void ModifyAudioConfigs(
+        AudioSendStream::Config* send_config,
+        std::vector<AudioReceiveStream::Config>* receive_configs) override {
+      send_config->rtp.c_name = kCName;
+    }
+
+    void PerformTest() override {
+      EXPECT_TRUE(Wait()) << "Timed out while waiting for RTCP with CNAME.";
+    }
+  } test;
+
+  RunBaseTest(&test);
+}
+
+TEST_F(AudioSendStreamCallTest, SupportsAudioLevel) {
+  class AudioLevelObserver : public AudioSendTest {
+   public:
+    AudioLevelObserver() : AudioSendTest() {
+      EXPECT_TRUE(parser_->RegisterRtpHeaderExtension(
+          kRtpExtensionAudioLevel, test::kAudioLevelExtensionId));
+    }
+
+    Action OnSendRtp(const uint8_t* packet, size_t length) override {
+      RTPHeader header;
+      EXPECT_TRUE(parser_->Parse(packet, length, &header));
+
+      EXPECT_TRUE(header.extension.hasAudioLevel);

[ossu, 2017/09/14 11:51:58]

The old tests included one that checked that no audio level extension was
present if it hadn't been enabled. Is it worth adding that test here as well, or
is that implementation to straightforward to warrant it?

[the sun, 2017/09/14 12:36:40]

Done.

+      if (header.extension.audioLevel != 0) {
+        // Wait for at least one packet with a non-zero level.
+        observation_complete_.Set();
+      } else {
+        LOG(LS_WARNING) << "Got a packet with zero audioLevel - waiting"

[ossu, 2017/09/14 11:51:58]

When can this happen? Where does the audio come from?

[the sun, 2017/09/14 12:36:39]

The test signal is a periodic noise burst.

[ossu, 2017/09/14 12:51:32]

Alright. I was thinking if this would often get logged, then maybe it's benign
enough to not log at all and if it wouldn't, then it should maybe be more than
just a log message. I'm not going to insist either way.

[the sun, 2017/09/14 20:05:05]

It is benign as long as the test eventually completes. If it times out, that
means we got no packages with >0 level, and then the log lines will be helpful.

+                           " for another packet...";
+      }
+
+      return SEND_PACKET;
+    }
+
+    void ModifyAudioConfigs(
+        AudioSendStream::Config* send_config,
+        std::vector<AudioReceiveStream::Config>* receive_configs) override {
+      send_config->rtp.extensions.clear();
+      send_config->rtp.extensions.push_back(RtpExtension(
+          RtpExtension::kAudioLevelUri, test::kAudioLevelExtensionId));
+    }
+
+    void PerformTest() override {
+      EXPECT_TRUE(Wait()) << "Timed out while waiting for single RTP packet.";
+    }
+  } test;
+
+  RunBaseTest(&test);
+}
+
+TEST_F(AudioSendStreamCallTest, SupportsTransportWideSequenceNumbers) {

[ossu, 2017/09/14 11:51:58]

Is this test new? It looks like there are some seeds for testing hasAbsoluteSend
time in the old code, but nothing more. (and this one tests the opposite)

[the sun, 2017/09/14 12:36:39]

AbsoluteSendTime is no longer used. There was a leftover in the old test, but
the test only looked at audioLevel. TransportSequenceNumbers is used though, and
we were lacking a test for it.

[ossu, 2017/09/14 12:51:32]

Acknowledged.

+  static const uint8_t kExtensionId = test::kTransportSequenceNumberExtensionId;
+  class TransportWideSequenceNumberObserver : public AudioSendTest {
+   public:
+    TransportWideSequenceNumberObserver() : AudioSendTest() {
+      EXPECT_TRUE(parser_->RegisterRtpHeaderExtension(
+          kRtpExtensionTransportSequenceNumber, kExtensionId));
+    }
+
+   private:
+    Action OnSendRtp(const uint8_t* packet, size_t length) override {
+      RTPHeader header;
+      EXPECT_TRUE(parser_->Parse(packet, length, &header));
+
+      EXPECT_TRUE(header.extension.hasTransportSequenceNumber);
+      EXPECT_FALSE(header.extension.hasTransmissionTimeOffset);
+      EXPECT_FALSE(header.extension.hasAbsoluteSendTime);
+
+      observation_complete_.Set();
+
+      return SEND_PACKET;
+    }
+
+    void ModifyAudioConfigs(
+        AudioSendStream::Config* send_config,
+        std::vector<AudioReceiveStream::Config>* receive_configs) override {
+      send_config->rtp.extensions.clear();
+      send_config->rtp.extensions.push_back(RtpExtension(
+          RtpExtension::kTransportSequenceNumberUri, kExtensionId));
+    }
+
+    void PerformTest() override {
+      EXPECT_TRUE(Wait()) << "Timed out while waiting for a single RTP packet.";
+    }
+  } test;
+
+  RunBaseTest(&test);
+}
+
+TEST_F(AudioSendStreamCallTest, SendDtmf) {
+  static const uint8_t kDtmfPayloadType = 120;
+  static const int kDtmfPayloadFrequency = 8000;
+  static const int kDtmfEventFirst = 12;

[ossu, 2017/09/14 11:51:58]

It looks like this differs from the ranges tested before. Does that matter? Or
are the input ranges to the functions different?

[the sun, 2017/09/14 12:36:39]

It doesn't matter. The point is to test that events are queued up and then sent
out.

[ossu, 2017/09/14 12:51:32]

Acknowledged.

+  static const int kDtmfEventLast = 25;
+  static const int kDtmfDuration = 10;
+  class DtmfObserver : public AudioSendTest {
+   public:
+    DtmfObserver() : AudioSendTest() {}

[ossu, 2017/09/14 11:51:57]

= default here as well?

[the sun, 2017/09/14 12:36:40]

Done.

+
+   private:
+    Action OnSendRtp(const uint8_t* packet, size_t length) override {
+      RTPHeader header;
+      EXPECT_TRUE(parser_->Parse(packet, length, &header));
+
+      if (header.payloadType == kDtmfPayloadType) {
+        EXPECT_EQ(12u, header.headerLength);
+        const uint8_t event = packet[12];
+        if (expected_dtmf_event_ == event) {

[ossu, 2017/09/14 11:51:58]

Will you want to ensure no other DTMF events are being sent as well? To ensure
they're not mistakenly sent twice, for example. 

[the sun, 2017/09/14 12:36:40]

In part, we're already testing this since for each packet we expect a different
event. I've increased the event length to slightly increase the likelihood that
there could be such a problem.

[ossu, 2017/09/14 12:51:32]

Why not EXPECT_EQ(expected_dtmf_event_, event)? Right now it'll silently ignore
any "extra" events that may be generated, but perhaps that's intended?

[the sun, 2017/09/14 20:05:06]

Well, AFAIU (RFC 4733) extra events are perfectly fine for the sender to
generate - the event duration is relative to the RTP timestamp of the packet and
may even increase for ongoing events (it is still regarded as a single event if
the start timestamp is the same). The RtpSenderAudio implementation periodically
sends events for the given duration of 50ms, presumably as a measure against
packet loss.

I've changed the test to better reflect these expectations.

+          if (expected_dtmf_event_ == kDtmfEventLast) {
+            observation_complete_.Set();
+          } else {
+            ++expected_dtmf_event_;
+          }
+        }
+      }
+
+      return SEND_PACKET;
+    }
+
+    void OnAudioStreamsCreated(
+        AudioSendStream* send_stream,
+        const std::vector<AudioReceiveStream*>& receive_streams) override {
+      // Need to start stream here, else DTMF events are dropped.
+      send_stream->Start();
+      for (int event = kDtmfEventFirst; event <= kDtmfEventLast; ++event) {
+        send_stream->SendTelephoneEvent(kDtmfPayloadType, kDtmfPayloadFrequency,
+                                        event, kDtmfDuration);
+      }
+    }
+
+    void PerformTest() override {
+      EXPECT_TRUE(Wait()) << "Timed out while waiting for DTMF stream.";
+    }
+
+    int expected_dtmf_event_ = kDtmfEventFirst;
+  } test;
+
+  RunBaseTest(&test);
+}
+
+}  // namespace test
+}  // namespace webrtc