From 43a97878ce14b72f0981164f87f2e35e14151312 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 11:22:09 +0200 Subject: Adding upstream version 110.0.1. Signed-off-by: Daniel Baumann --- .../tests/webrtc/RTCDTMFSender-helper.js | 149 +++++++++++++++++++++ 1 file changed, 149 insertions(+) create mode 100644 testing/web-platform/tests/webrtc/RTCDTMFSender-helper.js (limited to 'testing/web-platform/tests/webrtc/RTCDTMFSender-helper.js') diff --git a/testing/web-platform/tests/webrtc/RTCDTMFSender-helper.js b/testing/web-platform/tests/webrtc/RTCDTMFSender-helper.js new file mode 100644 index 0000000000..4316c3804a --- /dev/null +++ b/testing/web-platform/tests/webrtc/RTCDTMFSender-helper.js @@ -0,0 +1,149 @@ +'use strict'; + +// Test is based on the following editor draft: +// https://w3c.github.io/webrtc-pc/archives/20170605/webrtc.html + +// Code using this helper should also include RTCPeerConnection-helper.js +// in the main HTML file + +// The following helper functions are called from RTCPeerConnection-helper.js: +// getTrackFromUserMedia +// exchangeOfferAnswer + +// Create a RTCDTMFSender using getUserMedia() +// Connect the PeerConnection to another PC and wait until it is +// properly connected, so that DTMF can be sent. +function createDtmfSender(pc = new RTCPeerConnection()) { + let dtmfSender; + return getTrackFromUserMedia('audio') + .then(([track, mediaStream]) => { + const sender = pc.addTrack(track, mediaStream); + dtmfSender = sender.dtmf; + assert_true(dtmfSender instanceof RTCDTMFSender, + 'Expect audio sender.dtmf to be set to a RTCDTMFSender'); + // Note: spec bug open - https://github.com/w3c/webrtc-pc/issues/1774 + // on whether sending should be possible before negotiation. + const pc2 = new RTCPeerConnection(); + Object.defineProperty(pc, 'otherPc', { value: pc2 }); + exchangeIceCandidates(pc, pc2); + return exchangeOfferAnswer(pc, pc2); + }).then(() => { + if (!('canInsertDTMF' in dtmfSender)) { + return Promise.resolve(); + } + // Wait until dtmfSender.canInsertDTMF becomes true. + // Up to 150 ms has been observed in test. Wait 1 second + // in steps of 10 ms. + // Note: Using a short timeout and rejected promise in order to + // make test return a clear error message on failure. + return new Promise((resolve, reject) => { + let counter = 0; + step_timeout(function checkCanInsertDTMF() { + if (dtmfSender.canInsertDTMF) { + resolve(); + } else { + if (counter >= 100) { + reject('Waited too long for canInsertDTMF'); + return; + } + ++counter; + step_timeout(checkCanInsertDTMF, 10); + } + }, 0); + }); + }).then(() => { + return dtmfSender; + }); +} + +/* + Create an RTCDTMFSender and test tonechange events on it. + testFunc + Test function that is going to manipulate the DTMFSender. + It will be called with: + t - the test object + sender - the created RTCDTMFSender + pc - the associated RTCPeerConnection as second argument. + toneChanges + Array of expected tonechange events fired. The elements + are array of 3 items: + expectedTone + The expected character in event.tone + expectedToneBuffer + The expected new value of dtmfSender.toneBuffer + expectedDuration + The rough time since beginning or last tonechange event + was fired. + desc + Test description. + */ +function test_tone_change_events(testFunc, toneChanges, desc) { + // Convert to cumulative time + let cumulativeTime = 0; + const cumulativeToneChanges = toneChanges.map(c => { + cumulativeTime += c[2]; + return [c[0], c[1], cumulativeTime]; + }); + + // Wait for same duration as last expected duration + 100ms + // before passing test in case there are new tone events fired, + // in which case the test should fail. + const lastWait = toneChanges.pop()[2] + 100; + + promise_test(async t => { + const pc = new RTCPeerConnection(); + const dtmfSender = await createDtmfSender(pc); + const start = Date.now(); + + const allEventsReceived = new Promise(resolve => { + const onToneChange = t.step_func(ev => { + assert_true(ev instanceof RTCDTMFToneChangeEvent, + 'Expect tone change event object to be an RTCDTMFToneChangeEvent'); + + const { tone } = ev; + assert_equals(typeof tone, 'string', + 'Expect event.tone to be the tone string'); + + assert_greater_than(cumulativeToneChanges.length, 0, + 'More tonechange event is fired than expected'); + + const [ + expectedTone, expectedToneBuffer, expectedTime + ] = cumulativeToneChanges.shift(); + + assert_equals(tone, expectedTone, + `Expect current event.tone to be ${expectedTone}`); + + assert_equals(dtmfSender.toneBuffer, expectedToneBuffer, + `Expect dtmfSender.toneBuffer to be updated to ${expectedToneBuffer}`); + + // We check that the cumulative delay is at least the expected one, but + // system load may cause random delays, so we do not put any + // realistic upper bound on the timing of the events. + assert_between_inclusive(Date.now() - start, expectedTime, + expectedTime + 4000, + `Expect tonechange event for "${tone}" to be fired approximately after ${expectedTime} milliseconds`); + if (cumulativeToneChanges.length === 0) { + resolve(); + } + }); + + dtmfSender.addEventListener('tonechange', onToneChange); + }); + + testFunc(t, dtmfSender, pc); + await allEventsReceived; + const wait = ms => new Promise(resolve => t.step_timeout(resolve, ms)); + await wait(lastWait); + }, desc); +} + +// Get the one and only tranceiver from pc.getTransceivers(). +// Assumes that there is only one tranceiver in pc. +function getTransceiver(pc) { + const transceivers = pc.getTransceivers(); + assert_equals(transceivers.length, 1, + 'Expect there to be only one tranceiver in pc'); + + return transceivers[0]; +} -- cgit v1.2.3