mirror of
https://github.com/servo/servo.git
synced 2025-07-19 21:33:49 +01:00
180 lines
5.6 KiB
HTML
180 lines
5.6 KiB
HTML
<!doctype html>
|
|
<meta charset=utf-8>
|
|
<title>WebRTC IDL Tests</title>
|
|
<script src="/resources/testharness.js"></script>
|
|
<script src="/resources/testharnessreport.js"></script>
|
|
<script src="/resources/WebIDLParser.js"></script>
|
|
<script src="/resources/idlharness.js"></script>
|
|
<script src="./RTCPeerConnection-helper.js"></script>
|
|
<script>
|
|
'use strict';
|
|
|
|
// The following helper functions are called from RTCPeerConnection-helper.js:
|
|
// generateAnswer()
|
|
// generateMediaStreamTrack()
|
|
|
|
// Put the global IDL test objects under a parent object.
|
|
// This allows easier search for the test cases when
|
|
// viewing the web page
|
|
const idlTestObjects = {};
|
|
|
|
// Helper function to create RTCTrackEvent object
|
|
function initTrackEvent() {
|
|
const pc = new RTCPeerConnection();
|
|
const transceiver = pc.addTransceiver('audio');
|
|
const { sender, receiver } = transceiver;
|
|
const { track } = receiver;
|
|
return new RTCTrackEvent('track', {
|
|
receiver, track, transceiver
|
|
});
|
|
}
|
|
|
|
// List of async test driver functions
|
|
const asyncInitTasks = [
|
|
asyncInitCertificate,
|
|
asyncInitTransports,
|
|
asyncInitMediaStreamTrack,
|
|
];
|
|
|
|
// Asynchronously generate an RTCCertificate
|
|
function asyncInitCertificate() {
|
|
return RTCPeerConnection.generateCertificate({
|
|
name: 'RSASSA-PKCS1-v1_5',
|
|
modulusLength: 2048,
|
|
publicExponent: new Uint8Array([1, 0, 1]),
|
|
hash: 'SHA-256'
|
|
}).then(cert => {
|
|
idlTestObjects.certificate = cert;
|
|
});
|
|
}
|
|
|
|
// Asynchronously generate instances of
|
|
// RTCSctpTransport, RTCDtlsTransport,
|
|
// and RTCIceTransport
|
|
function asyncInitTransports() {
|
|
const pc = new RTCPeerConnection();
|
|
pc.createDataChannel('test');
|
|
|
|
// setting answer description initializes pc.sctp
|
|
return pc.createOffer()
|
|
.then(offer =>
|
|
pc.setLocalDescription(offer)
|
|
.then(() => generateAnswer(offer)))
|
|
.then(answer => pc.setRemoteDescription(answer))
|
|
.then(() => {
|
|
const sctpTransport = pc.sctp;
|
|
assert_true(sctpTransport instanceof RTCSctpTransport,
|
|
'Expect pc.sctp to be instance of RTCSctpTransport');
|
|
idlTestObjects.sctpTransport = sctpTransport;
|
|
|
|
const dtlsTransport = sctpTransport.transport;
|
|
assert_true(dtlsTransport instanceof RTCDtlsTransport,
|
|
'Expect sctpTransport.transport to be instance of RTCDtlsTransport');
|
|
idlTestObjects.dtlsTransport = dtlsTransport;
|
|
|
|
const iceTransport = dtlsTransport.transport;
|
|
idlTestObjects.iceTransport = iceTransport;
|
|
});
|
|
}
|
|
|
|
// Asynchoronously generate MediaStreamTrack from getUserMedia
|
|
function asyncInitMediaStreamTrack() {
|
|
return navigator.mediaDevices.getUserMedia({ audio: true })
|
|
.then(mediaStream => {
|
|
const tracks = mediaStream.getTracks();
|
|
assert_greater_than(tracks.length, 0,
|
|
'Expect media stream to have at least one track');
|
|
|
|
idlTestObjects.mediaStreamTrack = tracks[0];
|
|
});
|
|
}
|
|
|
|
// Run all async test drivers, report and swallow any error
|
|
// thrown/rejected. Proper test for correct initialization
|
|
// of the objects are done in their respective test files.
|
|
function asyncInit() {
|
|
return Promise.all(asyncInitTasks.map(
|
|
task => {
|
|
const t = async_test(`Test driver for ${task.name}`);
|
|
let promise;
|
|
t.step(() => {
|
|
promise = task().then(
|
|
t.step_func_done(),
|
|
t.step_func(err =>
|
|
assert_unreached(`Failed to run ${task.name}: ${err}`)));
|
|
});
|
|
return promise;
|
|
}));
|
|
}
|
|
|
|
// Main function to do the IDL test, using fetched IDL text
|
|
function doIdlTest(idlText) {
|
|
const idlArray = new IdlArray();
|
|
|
|
idlArray.add_untested_idls('interface EventHandler {};');
|
|
idlArray.add_idls('interface MediaStreamTrack : EventTarget {};');
|
|
idlArray.add_idls(idlText);
|
|
|
|
idlArray.add_objects({
|
|
'RTCPeerConnection': [`new RTCPeerConnection()`],
|
|
|
|
'RTCSessionDescription': [`new RTCSessionDescription({ type: 'offer' })`],
|
|
|
|
'RTCIceCandidate': [`new RTCIceCandidate({ sdpMid: 1 })`],
|
|
|
|
'RTCDataChannel': [`new RTCPeerConnection().createDataChannel('')`],
|
|
|
|
'RTCRtpTransceiver': [`new RTCPeerConnection().addTransceiver('audio')`],
|
|
|
|
'RTCRtpSender': [`new RTCPeerConnection().addTransceiver('audio').sender`],
|
|
|
|
'RTCRtpReceiver': [`new RTCPeerConnection().addTransceiver('audio').receiver`],
|
|
|
|
'RTCPeerConnectionIceEvent': [`new RTCPeerConnectionIceEvent('ice')`],
|
|
|
|
'RTCPeerConnectionIceErrorEvent':
|
|
[`new RTCPeerConnectionIceErrorEvent('ice-error', { errorCode: 701 });`],
|
|
|
|
'RTCTrackEvent': [`initTrackEvent()`],
|
|
|
|
'RTCErrorEvent': [`new RTCErrorEvent('error')`],
|
|
|
|
'RTCDataChannelEvent': [`new RTCDataChannelEvent('channel',
|
|
{ channel: new RTCPeerConnection().createDataChannel('') })`],
|
|
|
|
// Async initialized objects below
|
|
|
|
'RTCCertificate': ['idlTestObjects.certificate'],
|
|
|
|
'RTCSctpTransport': ['idlTestObjects.sctpTransport'],
|
|
|
|
'RTCDtlsTransport': ['idlTestObjects.dtlsTransport'],
|
|
|
|
'RTCIceTransport': ['idlTestObjects.iceTransport'],
|
|
|
|
// Test on both MediaStreamTrack from getUserMedia and transceiver
|
|
'MediaStreamTrack': [
|
|
`idlTestObjects.mediaStreamTrack`,
|
|
`generateMediaStreamTrack('audio')`]
|
|
});
|
|
|
|
idlArray.test();
|
|
}
|
|
|
|
promise_test(t => {
|
|
return asyncInit()
|
|
.then(() => fetch('/interfaces/webrtc-pc.idl'))
|
|
.then(response => response.text())
|
|
.then(doIdlTest);
|
|
}, 'Main test driver');
|
|
|
|
/*
|
|
TODO
|
|
RTCRtpContributingSource
|
|
RTCRtpSynchronizationSource
|
|
RTCDTMFSender
|
|
RTCDTMFToneChangeEvent
|
|
RTCIdentityProviderRegistrar
|
|
RTCIdentityAssertion
|
|
*/
|
|
</script>
|