henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1 | /* |
kjellander | b24317b | 2016-02-10 07:54:43 -0800 | [diff] [blame] | 2 | * Copyright 2012 The WebRTC project authors. All Rights Reserved. |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 3 | * |
kjellander | b24317b | 2016-02-10 07:54:43 -0800 | [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 +0000 | [diff] [blame] | 9 | */ |
| 10 | |
Steve Anton | 10542f2 | 2019-01-11 09:11:00 -0800 | [diff] [blame] | 11 | #include "pc/dtmf_sender.h" |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 12 | |
Yves Gerey | 3e70781 | 2018-11-28 16:47:49 +0100 | [diff] [blame] | 13 | #include <stddef.h> |
Jonas Olsson | a4d8737 | 2019-07-05 19:08:33 +0200 | [diff] [blame] | 14 | |
kwiberg | d1fe281 | 2016-04-27 06:47:29 -0700 | [diff] [blame] | 15 | #include <memory> |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 16 | #include <string> |
| 17 | #include <vector> |
| 18 | |
Steve Anton | 10542f2 | 2019-01-11 09:11:00 -0800 | [diff] [blame] | 19 | #include "rtc_base/fake_clock.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 20 | #include "rtc_base/gunit.h" |
Steve Anton | 10542f2 | 2019-01-11 09:11:00 -0800 | [diff] [blame] | 21 | #include "rtc_base/ref_counted_object.h" |
| 22 | #include "rtc_base/time_utils.h" |
Yves Gerey | 3e70781 | 2018-11-28 16:47:49 +0100 | [diff] [blame] | 23 | #include "test/gtest.h" |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 24 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 25 | using webrtc::DtmfProviderInterface; |
| 26 | using webrtc::DtmfSender; |
| 27 | using webrtc::DtmfSenderObserverInterface; |
| 28 | |
deadbeef | e7fc7d5 | 2016-10-28 13:53:08 -0700 | [diff] [blame] | 29 | // TODO(deadbeef): Even though this test now uses a fake clock, it has a |
| 30 | // generous 3-second timeout for every test case. The timeout could be tuned |
| 31 | // to each test based on the tones sent, instead. |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 32 | static const int kMaxWaitMs = 3000; |
| 33 | |
Magnus Jedvert | fc95084 | 2015-10-12 16:10:43 +0200 | [diff] [blame] | 34 | class FakeDtmfObserver : public DtmfSenderObserverInterface { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 35 | public: |
| 36 | FakeDtmfObserver() : completed_(false) {} |
| 37 | |
| 38 | // Implements DtmfSenderObserverInterface. |
kjellander@webrtc.org | 14665ff | 2015-03-04 12:58:35 +0000 | [diff] [blame] | 39 | void OnToneChange(const std::string& tone) override { |
Harald Alvestrand | d7b79af | 2018-09-06 09:33:56 +0200 | [diff] [blame] | 40 | tones_from_single_argument_callback_.push_back(tone); |
| 41 | if (tone.empty()) { |
| 42 | completed_ = true; |
| 43 | } |
| 44 | } |
| 45 | void OnToneChange(const std::string& tone, |
| 46 | const std::string& tone_buffer) override { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 47 | tones_.push_back(tone); |
Harald Alvestrand | d7b79af | 2018-09-06 09:33:56 +0200 | [diff] [blame] | 48 | tones_remaining_ = tone_buffer; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 49 | if (tone.empty()) { |
| 50 | completed_ = true; |
| 51 | } |
| 52 | } |
| 53 | |
| 54 | // getters |
Yves Gerey | 665174f | 2018-06-19 15:03:05 +0200 | [diff] [blame] | 55 | const std::vector<std::string>& tones() const { return tones_; } |
Harald Alvestrand | d7b79af | 2018-09-06 09:33:56 +0200 | [diff] [blame] | 56 | const std::vector<std::string>& tones_from_single_argument_callback() const { |
| 57 | return tones_from_single_argument_callback_; |
| 58 | } |
| 59 | const std::string tones_remaining() { return tones_remaining_; } |
Yves Gerey | 665174f | 2018-06-19 15:03:05 +0200 | [diff] [blame] | 60 | bool completed() const { return completed_; } |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 61 | |
| 62 | private: |
| 63 | std::vector<std::string> tones_; |
Harald Alvestrand | d7b79af | 2018-09-06 09:33:56 +0200 | [diff] [blame] | 64 | std::vector<std::string> tones_from_single_argument_callback_; |
| 65 | std::string tones_remaining_; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 66 | bool completed_; |
| 67 | }; |
| 68 | |
| 69 | class FakeDtmfProvider : public DtmfProviderInterface { |
| 70 | public: |
| 71 | struct DtmfInfo { |
| 72 | DtmfInfo(int code, int duration, int gap) |
Yves Gerey | 665174f | 2018-06-19 15:03:05 +0200 | [diff] [blame] | 73 | : code(code), duration(duration), gap(gap) {} |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 74 | int code; |
| 75 | int duration; |
| 76 | int gap; |
| 77 | }; |
| 78 | |
| 79 | FakeDtmfProvider() : last_insert_dtmf_call_(0) {} |
| 80 | |
Yves Gerey | 665174f | 2018-06-19 15:03:05 +0200 | [diff] [blame] | 81 | ~FakeDtmfProvider() { SignalDestroyed(); } |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 82 | |
| 83 | // Implements DtmfProviderInterface. |
deadbeef | 20cb0c1 | 2017-02-01 20:27:00 -0800 | [diff] [blame] | 84 | bool CanInsertDtmf() override { return can_insert_; } |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 85 | |
deadbeef | 20cb0c1 | 2017-02-01 20:27:00 -0800 | [diff] [blame] | 86 | bool InsertDtmf(int code, int duration) override { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 87 | int gap = 0; |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 88 | // TODO(ronghuawu): Make the timer (basically the rtc::TimeNanos) |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 89 | // mockable and use a fake timer in the unit tests. |
| 90 | if (last_insert_dtmf_call_ > 0) { |
Honghai Zhang | 82d7862 | 2016-05-06 11:29:15 -0700 | [diff] [blame] | 91 | gap = static_cast<int>(rtc::TimeMillis() - last_insert_dtmf_call_); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 92 | } |
Honghai Zhang | 82d7862 | 2016-05-06 11:29:15 -0700 | [diff] [blame] | 93 | last_insert_dtmf_call_ = rtc::TimeMillis(); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 94 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 95 | dtmf_info_queue_.push_back(DtmfInfo(code, duration, gap)); |
| 96 | return true; |
| 97 | } |
| 98 | |
nisse | ef8b61e | 2016-04-29 06:09:15 -0700 | [diff] [blame] | 99 | sigslot::signal0<>* GetOnDestroyedSignal() override { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 100 | return &SignalDestroyed; |
| 101 | } |
| 102 | |
| 103 | // getter and setter |
| 104 | const std::vector<DtmfInfo>& dtmf_info_queue() const { |
| 105 | return dtmf_info_queue_; |
| 106 | } |
| 107 | |
| 108 | // helper functions |
deadbeef | 20cb0c1 | 2017-02-01 20:27:00 -0800 | [diff] [blame] | 109 | void SetCanInsertDtmf(bool can_insert) { can_insert_ = can_insert; } |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 110 | |
| 111 | private: |
deadbeef | 20cb0c1 | 2017-02-01 20:27:00 -0800 | [diff] [blame] | 112 | bool can_insert_ = false; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 113 | std::vector<DtmfInfo> dtmf_info_queue_; |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 114 | int64_t last_insert_dtmf_call_; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 115 | sigslot::signal0<> SignalDestroyed; |
| 116 | }; |
| 117 | |
Mirko Bonadei | 6a489f2 | 2019-04-09 15:11:12 +0200 | [diff] [blame] | 118 | class DtmfSenderTest : public ::testing::Test { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 119 | protected: |
| 120 | DtmfSenderTest() |
Steve Anton | b983bae | 2018-06-20 11:16:53 -0700 | [diff] [blame] | 121 | : observer_(new rtc::RefCountedObject<FakeDtmfObserver>()), |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 122 | provider_(new FakeDtmfProvider()) { |
deadbeef | 20cb0c1 | 2017-02-01 20:27:00 -0800 | [diff] [blame] | 123 | provider_->SetCanInsertDtmf(true); |
Steve Anton | b983bae | 2018-06-20 11:16:53 -0700 | [diff] [blame] | 124 | dtmf_ = DtmfSender::Create(rtc::Thread::Current(), provider_.get()); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 125 | dtmf_->RegisterObserver(observer_.get()); |
| 126 | } |
| 127 | |
| 128 | ~DtmfSenderTest() { |
| 129 | if (dtmf_.get()) { |
| 130 | dtmf_->UnregisterObserver(); |
| 131 | } |
| 132 | } |
| 133 | |
| 134 | // Constructs a list of DtmfInfo from |tones|, |duration| and |
| 135 | // |inter_tone_gap|. |
Yves Gerey | 665174f | 2018-06-19 15:03:05 +0200 | [diff] [blame] | 136 | void GetDtmfInfoFromString(const std::string& tones, |
| 137 | int duration, |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 138 | int inter_tone_gap, |
| 139 | std::vector<FakeDtmfProvider::DtmfInfo>* dtmfs) { |
| 140 | // Init extra_delay as -inter_tone_gap - duration to ensure the first |
| 141 | // DtmfInfo's gap field will be 0. |
| 142 | int extra_delay = -1 * (inter_tone_gap + duration); |
| 143 | |
| 144 | std::string::const_iterator it = tones.begin(); |
| 145 | for (; it != tones.end(); ++it) { |
| 146 | char tone = *it; |
| 147 | int code = 0; |
| 148 | webrtc::GetDtmfCode(tone, &code); |
| 149 | if (tone == ',') { |
| 150 | extra_delay = 2000; // 2 seconds |
| 151 | } else { |
Yves Gerey | 665174f | 2018-06-19 15:03:05 +0200 | [diff] [blame] | 152 | dtmfs->push_back(FakeDtmfProvider::DtmfInfo( |
| 153 | code, duration, duration + inter_tone_gap + extra_delay)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 154 | extra_delay = 0; |
| 155 | } |
| 156 | } |
| 157 | } |
| 158 | |
Steve Anton | b983bae | 2018-06-20 11:16:53 -0700 | [diff] [blame] | 159 | void VerifyExpectedState(const std::string& tones, |
Yves Gerey | 665174f | 2018-06-19 15:03:05 +0200 | [diff] [blame] | 160 | int duration, |
| 161 | int inter_tone_gap) { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 162 | EXPECT_EQ(tones, dtmf_->tones()); |
| 163 | EXPECT_EQ(duration, dtmf_->duration()); |
| 164 | EXPECT_EQ(inter_tone_gap, dtmf_->inter_tone_gap()); |
| 165 | } |
| 166 | |
| 167 | // Verify the provider got all the expected calls. |
Yves Gerey | 665174f | 2018-06-19 15:03:05 +0200 | [diff] [blame] | 168 | void VerifyOnProvider(const std::string& tones, |
| 169 | int duration, |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 170 | int inter_tone_gap) { |
| 171 | std::vector<FakeDtmfProvider::DtmfInfo> dtmf_queue_ref; |
| 172 | GetDtmfInfoFromString(tones, duration, inter_tone_gap, &dtmf_queue_ref); |
| 173 | VerifyOnProvider(dtmf_queue_ref); |
| 174 | } |
| 175 | |
| 176 | void VerifyOnProvider( |
| 177 | const std::vector<FakeDtmfProvider::DtmfInfo>& dtmf_queue_ref) { |
| 178 | const std::vector<FakeDtmfProvider::DtmfInfo>& dtmf_queue = |
| 179 | provider_->dtmf_info_queue(); |
| 180 | ASSERT_EQ(dtmf_queue_ref.size(), dtmf_queue.size()); |
| 181 | std::vector<FakeDtmfProvider::DtmfInfo>::const_iterator it_ref = |
| 182 | dtmf_queue_ref.begin(); |
| 183 | std::vector<FakeDtmfProvider::DtmfInfo>::const_iterator it = |
| 184 | dtmf_queue.begin(); |
| 185 | while (it_ref != dtmf_queue_ref.end() && it != dtmf_queue.end()) { |
| 186 | EXPECT_EQ(it_ref->code, it->code); |
| 187 | EXPECT_EQ(it_ref->duration, it->duration); |
deadbeef | e7fc7d5 | 2016-10-28 13:53:08 -0700 | [diff] [blame] | 188 | // Allow ~10ms error (can be small since we're using a fake clock). |
| 189 | EXPECT_GE(it_ref->gap, it->gap - 10); |
| 190 | EXPECT_LE(it_ref->gap, it->gap + 10); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 191 | ++it_ref; |
| 192 | ++it; |
| 193 | } |
| 194 | } |
| 195 | |
| 196 | // Verify the observer got all the expected callbacks. |
| 197 | void VerifyOnObserver(const std::string& tones_ref) { |
| 198 | const std::vector<std::string>& tones = observer_->tones(); |
| 199 | // The observer will get an empty string at the end. |
| 200 | EXPECT_EQ(tones_ref.size() + 1, tones.size()); |
Harald Alvestrand | d7b79af | 2018-09-06 09:33:56 +0200 | [diff] [blame] | 201 | EXPECT_EQ(observer_->tones(), |
| 202 | observer_->tones_from_single_argument_callback()); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 203 | EXPECT_TRUE(tones.back().empty()); |
Harald Alvestrand | d7b79af | 2018-09-06 09:33:56 +0200 | [diff] [blame] | 204 | EXPECT_TRUE(observer_->tones_remaining().empty()); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 205 | std::string::const_iterator it_ref = tones_ref.begin(); |
| 206 | std::vector<std::string>::const_iterator it = tones.begin(); |
| 207 | while (it_ref != tones_ref.end() && it != tones.end()) { |
| 208 | EXPECT_EQ(*it_ref, it->at(0)); |
| 209 | ++it_ref; |
| 210 | ++it; |
| 211 | } |
| 212 | } |
| 213 | |
kwiberg | d1fe281 | 2016-04-27 06:47:29 -0700 | [diff] [blame] | 214 | std::unique_ptr<FakeDtmfObserver> observer_; |
| 215 | std::unique_ptr<FakeDtmfProvider> provider_; |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 216 | rtc::scoped_refptr<DtmfSender> dtmf_; |
deadbeef | e7fc7d5 | 2016-10-28 13:53:08 -0700 | [diff] [blame] | 217 | rtc::ScopedFakeClock fake_clock_; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 218 | }; |
| 219 | |
| 220 | TEST_F(DtmfSenderTest, CanInsertDtmf) { |
| 221 | EXPECT_TRUE(dtmf_->CanInsertDtmf()); |
deadbeef | 20cb0c1 | 2017-02-01 20:27:00 -0800 | [diff] [blame] | 222 | provider_->SetCanInsertDtmf(false); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 223 | EXPECT_FALSE(dtmf_->CanInsertDtmf()); |
| 224 | } |
| 225 | |
| 226 | TEST_F(DtmfSenderTest, InsertDtmf) { |
| 227 | std::string tones = "@1%a&*$"; |
| 228 | int duration = 100; |
| 229 | int inter_tone_gap = 50; |
| 230 | EXPECT_TRUE(dtmf_->InsertDtmf(tones, duration, inter_tone_gap)); |
deadbeef | e7fc7d5 | 2016-10-28 13:53:08 -0700 | [diff] [blame] | 231 | EXPECT_TRUE_SIMULATED_WAIT(observer_->completed(), kMaxWaitMs, fake_clock_); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 232 | |
| 233 | // The unrecognized characters should be ignored. |
| 234 | std::string known_tones = "1a*"; |
| 235 | VerifyOnProvider(known_tones, duration, inter_tone_gap); |
| 236 | VerifyOnObserver(known_tones); |
| 237 | } |
| 238 | |
| 239 | TEST_F(DtmfSenderTest, InsertDtmfTwice) { |
| 240 | std::string tones1 = "12"; |
| 241 | std::string tones2 = "ab"; |
| 242 | int duration = 100; |
| 243 | int inter_tone_gap = 50; |
| 244 | EXPECT_TRUE(dtmf_->InsertDtmf(tones1, duration, inter_tone_gap)); |
Steve Anton | b983bae | 2018-06-20 11:16:53 -0700 | [diff] [blame] | 245 | VerifyExpectedState(tones1, duration, inter_tone_gap); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 246 | // Wait until the first tone got sent. |
deadbeef | e7fc7d5 | 2016-10-28 13:53:08 -0700 | [diff] [blame] | 247 | EXPECT_TRUE_SIMULATED_WAIT(observer_->tones().size() == 1, kMaxWaitMs, |
| 248 | fake_clock_); |
Steve Anton | b983bae | 2018-06-20 11:16:53 -0700 | [diff] [blame] | 249 | VerifyExpectedState("2", duration, inter_tone_gap); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 250 | // Insert with another tone buffer. |
| 251 | EXPECT_TRUE(dtmf_->InsertDtmf(tones2, duration, inter_tone_gap)); |
Steve Anton | b983bae | 2018-06-20 11:16:53 -0700 | [diff] [blame] | 252 | VerifyExpectedState(tones2, duration, inter_tone_gap); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 253 | // Wait until it's completed. |
deadbeef | e7fc7d5 | 2016-10-28 13:53:08 -0700 | [diff] [blame] | 254 | EXPECT_TRUE_SIMULATED_WAIT(observer_->completed(), kMaxWaitMs, fake_clock_); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 255 | |
| 256 | std::vector<FakeDtmfProvider::DtmfInfo> dtmf_queue_ref; |
| 257 | GetDtmfInfoFromString("1", duration, inter_tone_gap, &dtmf_queue_ref); |
| 258 | GetDtmfInfoFromString("ab", duration, inter_tone_gap, &dtmf_queue_ref); |
| 259 | VerifyOnProvider(dtmf_queue_ref); |
| 260 | VerifyOnObserver("1ab"); |
| 261 | } |
| 262 | |
| 263 | TEST_F(DtmfSenderTest, InsertDtmfWhileProviderIsDeleted) { |
| 264 | std::string tones = "@1%a&*$"; |
| 265 | int duration = 100; |
| 266 | int inter_tone_gap = 50; |
| 267 | EXPECT_TRUE(dtmf_->InsertDtmf(tones, duration, inter_tone_gap)); |
| 268 | // Wait until the first tone got sent. |
deadbeef | e7fc7d5 | 2016-10-28 13:53:08 -0700 | [diff] [blame] | 269 | EXPECT_TRUE_SIMULATED_WAIT(observer_->tones().size() == 1, kMaxWaitMs, |
| 270 | fake_clock_); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 271 | // Delete provider. |
| 272 | provider_.reset(); |
| 273 | // The queue should be discontinued so no more tone callbacks. |
deadbeef | e7fc7d5 | 2016-10-28 13:53:08 -0700 | [diff] [blame] | 274 | SIMULATED_WAIT(false, 200, fake_clock_); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 275 | EXPECT_EQ(1U, observer_->tones().size()); |
| 276 | } |
| 277 | |
| 278 | TEST_F(DtmfSenderTest, InsertDtmfWhileSenderIsDeleted) { |
| 279 | std::string tones = "@1%a&*$"; |
| 280 | int duration = 100; |
| 281 | int inter_tone_gap = 50; |
| 282 | EXPECT_TRUE(dtmf_->InsertDtmf(tones, duration, inter_tone_gap)); |
| 283 | // Wait until the first tone got sent. |
deadbeef | e7fc7d5 | 2016-10-28 13:53:08 -0700 | [diff] [blame] | 284 | EXPECT_TRUE_SIMULATED_WAIT(observer_->tones().size() == 1, kMaxWaitMs, |
| 285 | fake_clock_); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 286 | // Delete the sender. |
| 287 | dtmf_ = NULL; |
| 288 | // The queue should be discontinued so no more tone callbacks. |
deadbeef | e7fc7d5 | 2016-10-28 13:53:08 -0700 | [diff] [blame] | 289 | SIMULATED_WAIT(false, 200, fake_clock_); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 290 | EXPECT_EQ(1U, observer_->tones().size()); |
| 291 | } |
| 292 | |
| 293 | TEST_F(DtmfSenderTest, InsertEmptyTonesToCancelPreviousTask) { |
| 294 | std::string tones1 = "12"; |
| 295 | std::string tones2 = ""; |
| 296 | int duration = 100; |
| 297 | int inter_tone_gap = 50; |
| 298 | EXPECT_TRUE(dtmf_->InsertDtmf(tones1, duration, inter_tone_gap)); |
| 299 | // Wait until the first tone got sent. |
deadbeef | e7fc7d5 | 2016-10-28 13:53:08 -0700 | [diff] [blame] | 300 | EXPECT_TRUE_SIMULATED_WAIT(observer_->tones().size() == 1, kMaxWaitMs, |
| 301 | fake_clock_); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 302 | // Insert with another tone buffer. |
| 303 | EXPECT_TRUE(dtmf_->InsertDtmf(tones2, duration, inter_tone_gap)); |
| 304 | // Wait until it's completed. |
deadbeef | e7fc7d5 | 2016-10-28 13:53:08 -0700 | [diff] [blame] | 305 | EXPECT_TRUE_SIMULATED_WAIT(observer_->completed(), kMaxWaitMs, fake_clock_); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 306 | |
| 307 | std::vector<FakeDtmfProvider::DtmfInfo> dtmf_queue_ref; |
| 308 | GetDtmfInfoFromString("1", duration, inter_tone_gap, &dtmf_queue_ref); |
| 309 | VerifyOnProvider(dtmf_queue_ref); |
| 310 | VerifyOnObserver("1"); |
| 311 | } |
| 312 | |
deadbeef | e7fc7d5 | 2016-10-28 13:53:08 -0700 | [diff] [blame] | 313 | TEST_F(DtmfSenderTest, InsertDtmfWithCommaAsDelay) { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 314 | std::string tones = "3,4"; |
| 315 | int duration = 100; |
| 316 | int inter_tone_gap = 50; |
| 317 | EXPECT_TRUE(dtmf_->InsertDtmf(tones, duration, inter_tone_gap)); |
deadbeef | e7fc7d5 | 2016-10-28 13:53:08 -0700 | [diff] [blame] | 318 | EXPECT_TRUE_SIMULATED_WAIT(observer_->completed(), kMaxWaitMs, fake_clock_); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 319 | |
| 320 | VerifyOnProvider(tones, duration, inter_tone_gap); |
| 321 | VerifyOnObserver(tones); |
| 322 | } |
| 323 | |
| 324 | TEST_F(DtmfSenderTest, TryInsertDtmfWhenItDoesNotWork) { |
| 325 | std::string tones = "3,4"; |
| 326 | int duration = 100; |
| 327 | int inter_tone_gap = 50; |
deadbeef | 20cb0c1 | 2017-02-01 20:27:00 -0800 | [diff] [blame] | 328 | provider_->SetCanInsertDtmf(false); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 329 | EXPECT_FALSE(dtmf_->InsertDtmf(tones, duration, inter_tone_gap)); |
| 330 | } |
| 331 | |
| 332 | TEST_F(DtmfSenderTest, InsertDtmfWithInvalidDurationOrGap) { |
| 333 | std::string tones = "3,4"; |
dminor | 588101c | 2017-03-28 11:18:32 -0700 | [diff] [blame] | 334 | int duration = 40; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 335 | int inter_tone_gap = 50; |
| 336 | |
| 337 | EXPECT_FALSE(dtmf_->InsertDtmf(tones, 6001, inter_tone_gap)); |
dminor | 588101c | 2017-03-28 11:18:32 -0700 | [diff] [blame] | 338 | EXPECT_FALSE(dtmf_->InsertDtmf(tones, 39, inter_tone_gap)); |
Harald Alvestrand | 52e5852 | 2018-02-20 08:15:36 +0100 | [diff] [blame] | 339 | EXPECT_FALSE(dtmf_->InsertDtmf(tones, duration, 29)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 340 | |
| 341 | EXPECT_TRUE(dtmf_->InsertDtmf(tones, duration, inter_tone_gap)); |
| 342 | } |
Harald Alvestrand | 1e0c804 | 2018-03-06 10:51:27 +0100 | [diff] [blame] | 343 | |
| 344 | TEST_F(DtmfSenderTest, InsertDtmfSendsAfterWait) { |
| 345 | std::string tones = "ABC"; |
| 346 | int duration = 100; |
| 347 | int inter_tone_gap = 50; |
| 348 | EXPECT_TRUE(dtmf_->InsertDtmf(tones, duration, inter_tone_gap)); |
Steve Anton | b983bae | 2018-06-20 11:16:53 -0700 | [diff] [blame] | 349 | VerifyExpectedState("ABC", duration, inter_tone_gap); |
Harald Alvestrand | 1e0c804 | 2018-03-06 10:51:27 +0100 | [diff] [blame] | 350 | // Wait until the first tone got sent. |
| 351 | EXPECT_TRUE_SIMULATED_WAIT(observer_->tones().size() == 1, kMaxWaitMs, |
| 352 | fake_clock_); |
Steve Anton | b983bae | 2018-06-20 11:16:53 -0700 | [diff] [blame] | 353 | VerifyExpectedState("BC", duration, inter_tone_gap); |
Harald Alvestrand | 1e0c804 | 2018-03-06 10:51:27 +0100 | [diff] [blame] | 354 | } |