mod support; use moli_v8_test_util::ensure_v8; use moli_v8_util::v8_string; use moli_webapi::{ css_values, dom_exception, dom_string_list, geolocation, interfaces, queuing_strategy, rtc, }; use std::pin::pin; use support::{eval, finish_template, illegal_constructor, install_errors, publish}; fn install_values(scope: &mut v8::PinScope<'_, '_>) { install_errors(scope); let target = v8::FunctionTemplate::new(scope, illegal_constructor); finish_template(scope, interfaces::EventTarget::DESCRIPTOR, target); for (interface, template) in [ ( interfaces::RTCPeerConnection::DESCRIPTOR, v8::FunctionTemplate::new(scope, rtc::rtc_peer_connection_constructor_callback), ), ( interfaces::RTCDataChannel::DESCRIPTOR, v8::FunctionTemplate::new(scope, illegal_constructor), ), ( interfaces::RTCRtpReceiver::DESCRIPTOR, v8::FunctionTemplate::new(scope, illegal_constructor), ), ] { if interface.name() != "RTCRtpReceiver" { template.inherit(target); } rtc::install_template_bindings(scope, template, interface.name()); finish_template(scope, interface, template); } let description = v8::FunctionTemplate::new( scope, rtc::session_description::rtc_session_description_constructor_callback, ); let candidate = v8::FunctionTemplate::new( scope, rtc::ice_candidate::rtc_ice_candidate_constructor_callback, ); let audio = v8::FunctionTemplate::new(scope, rtc::encoded_frames::audio_constructor); let video = v8::FunctionTemplate::new(scope, rtc::encoded_frames::video_constructor); let style = v8::FunctionTemplate::new(scope, illegal_constructor); let numeric = v8::FunctionTemplate::new(scope, illegal_constructor); numeric.inherit(style); let keyword = v8::FunctionTemplate::new(scope, css_values::css_keyword_value_constructor_callback); keyword.inherit(style); let unit = v8::FunctionTemplate::new(scope, css_values::css_unit_value_constructor_callback); unit.inherit(numeric); let count = v8::FunctionTemplate::new( scope, queuing_strategy::count_queuing_strategy_constructor_callback, ); let bytes = v8::FunctionTemplate::new( scope, queuing_strategy::byte_length_queuing_strategy_constructor_callback, ); let names = v8::FunctionTemplate::new(scope, illegal_constructor); let coordinates = v8::FunctionTemplate::new(scope, illegal_constructor); let position = v8::FunctionTemplate::new(scope, illegal_constructor); let geo_error = v8::FunctionTemplate::new(scope, illegal_constructor); for (interface, template) in [ (interfaces::RTCSessionDescription::DESCRIPTOR, description), (interfaces::RTCIceCandidate::DESCRIPTOR, candidate), (interfaces::RTCEncodedAudioFrame::DESCRIPTOR, audio), (interfaces::RTCEncodedVideoFrame::DESCRIPTOR, video), (interfaces::CSSStyleValue::DESCRIPTOR, style), (interfaces::CSSNumericValue::DESCRIPTOR, numeric), (interfaces::CSSKeywordValue::DESCRIPTOR, keyword), (interfaces::CSSUnitValue::DESCRIPTOR, unit), (interfaces::CountQueuingStrategy::DESCRIPTOR, count), (interfaces::ByteLengthQueuingStrategy::DESCRIPTOR, bytes), (interfaces::DOMStringList::DESCRIPTOR, names), (interfaces::GeolocationCoordinates::DESCRIPTOR, coordinates), (interfaces::GeolocationPosition::DESCRIPTOR, position), (interfaces::GeolocationPositionError::DESCRIPTOR, geo_error), ] { let prototype = template.prototype_template(scope); match interface.name() { "RTCSessionDescription" => { rtc::session_description::install_session_description_template_bindings( scope, template, ) } "RTCIceCandidate" => { rtc::ice_candidate::install_ice_candidate_template_bindings(scope, template) } "RTCEncodedAudioFrame" | "RTCEncodedVideoFrame" => { rtc::encoded_frames::install(scope, prototype, interface.name()) } _ => {} } css_values::install_typed_value_template_bindings(scope, template, interface.name()); queuing_strategy::install_queuing_strategy_template_bindings( scope, prototype, interface.name(), ); dom_string_list::install_dom_string_list_template_bindings( scope, prototype, interface.name(), ); geolocation::install(scope, template, interface.name()); finish_template(scope, interface, template); } eval( scope, "function check(value, message) { if (!value) throw new Error(message || 'check failed'); }", ); } fn with_values(test: impl for<'s, 'i> FnOnce(&mut v8::PinScope<'s, 'i>)) { ensure_v8(); let mut isolate = v8::Isolate::new(Default::default()); let scope = pin!(v8::HandleScope::new(&mut isolate)); let scope = &mut scope.init(); let context = v8::Context::new(scope, Default::default()); let scope = &mut v8::ContextScope::new(scope, context); install_values(scope); test(scope); } #[test] fn native_error_values_keep_utf16_inheritance_constants_and_dictionary_conversions() { with_values(|scope| { let socket = dom_exception::new_websocket_error_value(scope, "closed", Some(1001), "away") .to_object(scope) .unwrap(); publish(scope, "socketError", socket); let error = dom_exception::new_dom_error_value(scope, "ReadError", "failed") .to_object(scope) .unwrap(); publish(scope, "legacyError", error); eval( scope, r#"(() => { const error = new DOMException('\ud800', 'SyntaxError'); check(error instanceof Error && error instanceof DOMException); check(error.message.charCodeAt(0) === 0xd800 && error.code === 12); check(DOMException.SYNTAX_ERR === 12 && DOMException.prototype.SYNTAX_ERR === 12); check(!Object.getOwnPropertyDescriptor(DOMException, 'SYNTAX_ERR').writable); check(legacyError.name === 'ReadError' && legacyError.message === 'failed'); check(socketError instanceof DOMException && socketError instanceof WebSocketError); check(socketError.name === 'WebSocketError' && socketError.closeCode === 1001 && socketError.reason === 'away'); const reads = []; const quota = new QuotaExceededError('full', { get requested() { reads.push('requested'); return 20; }, get quota() { reads.push('quota'); return 10; } }); check(reads.join(',') === 'quota,requested'); check(quota instanceof DOMException && quota.quota === 10 && quota.requested === 20 && quota.code === 22); const rtc = new RTCError({errorDetail:'sdp-syntax-error', sdpLineNumber:7}, 'bad SDP'); check(rtc instanceof DOMException && rtc.name === 'OperationError' && rtc.code === 0); check(rtc.sdpLineNumber === 7 && rtc.errorDetail === 'sdp-syntax-error' && rtc.sentAlert === null); const transport = new WebTransportError('bad transport', {source:'session', streamErrorCode:12.5}); check(transport instanceof DOMException && transport.source === 'session' && transport.streamErrorCode === 12); try { new RTCError({errorDetail:'not-an-error'}); throw new Error('invalid enum accepted'); } catch (error) { check(error instanceof TypeError); } try { Object.getOwnPropertyDescriptor(DOMException.prototype,'name').get.call(Object.create(DOMException.prototype)); throw new Error('forged exception accepted'); } catch (error) { check(error instanceof TypeError); } })()"#, ); }); } #[test] fn rtc_descriptions_and_candidates_preserve_dictionary_order_and_utf16() { with_values(|scope| { eval( scope, r#"(() => { const reads = []; const description = new RTCSessionDescription({ get type() { reads.push('type'); return 'offer'; }, get sdp() { reads.push('sdp'); return '\ud800'; } }); check(reads.join(',') === 'sdp,type'); check(description.type === 'offer' && description.sdp.charCodeAt(0) === 0xd800); check(description.toJSON().sdp === '\ud800' && new RTCSessionDescription().type === null); const candidate = new RTCIceCandidate({ candidate:'candidate:abc 1 UDP 2122260223 192.0.2.1 5000 typ host', sdpMid:'\ud800', sdpMLineIndex:1 }); check(candidate.foundation === 'abc' && candidate.component === 'rtp' && candidate.protocol === 'udp'); check(candidate.address === '192.0.2.1' && candidate.port === 5000 && candidate.type === 'host'); check(candidate.sdpMid.charCodeAt(0) === 0xd800 && candidate.toJSON().sdpMid === '\ud800'); let converted = false; try { RTCIceCandidate.prototype.toJSON.call({toString(){converted=true;}}); throw new Error('forged candidate accepted'); } catch (error) { check(error instanceof TypeError && !converted); } })()"#, ); }); } #[test] fn rtc_encoded_frame_copies_keep_bytes_metadata_and_native_brands() { with_values(|scope| { let metadata = eval(scope, "({rtpTimestamp:123, contributingSources:[1,2], payloadType:96, width:2, height:3, spatialIndex:0, temporalIndex:0})").to_object(scope).unwrap(); let frame_type = Some(moli_v8_util::v8str(scope, "key")); let audio = rtc::encoded_frames::build_native_frame( scope, rtc::encoded_frames::FrameKind::Audio, &[1, 2, 3], metadata, None, ) .unwrap(); let video = rtc::encoded_frames::build_native_frame( scope, rtc::encoded_frames::FrameKind::Video, &[4, 5], metadata, frame_type, ) .unwrap(); publish(scope, "audioFrame", audio); publish(scope, "videoFrame", video); eval( scope, r#"(() => { const copy = new RTCEncodedAudioFrame(audioFrame); check(copy instanceof RTCEncodedAudioFrame && copy.getMetadata().rtpTimestamp === 123); check(new Uint8Array(copy.data).join() === '1,2,3' && copy.data !== audioFrame.data); const metadata = copy.getMetadata(); metadata.contributingSources.push(7); check(copy.getMetadata().contributingSources.join() === '1,2'); new Uint8Array(copy.data)[0] = 9; check(new Uint8Array(audioFrame.data)[0] === 1); const video = new RTCEncodedVideoFrame(videoFrame); check(video.type === 'key' && video.getMetadata().rtpTimestamp === 123 && video.getMetadata().width === 2); video.data = new Uint8Array([8,9,10]).buffer; check(new Uint8Array(video.data).join() === '8,9,10' && videoFrame.data.byteLength === 2); try { new RTCEncodedAudioFrame(Object.create(RTCEncodedAudioFrame.prototype)); throw new Error('forged frame accepted'); } catch (error) { check(error instanceof TypeError); } })()"#, ); }); } #[test] fn css_values_parse_and_mutate_without_a_document_or_style_host() { with_values(|scope| { let numeric = css_values::style_value_from_text(scope, "25px", true); let keyword = css_values::style_value_from_text(scope, "block", true); let fallback = css_values::style_value_from_text(scope, "rgb(1, 2, 3)", false); publish(scope, "parsedNumeric", numeric); publish(scope, "parsedKeyword", keyword); publish(scope, "parsedFallback", fallback); eval( scope, r#"(() => { check(parsedNumeric instanceof CSSUnitValue && parsedNumeric instanceof CSSStyleValue); check(parsedNumeric.value === 25 && parsedNumeric.unit === 'px' && String(parsedNumeric) === '25px'); check(parsedKeyword instanceof CSSKeywordValue && parsedKeyword.value === 'block'); check(parsedFallback instanceof CSSStyleValue && String(parsedFallback) === 'rgb(1, 2, 3)'); const unit = new CSSUnitValue(2, 'PX'); unit.value = 7; check(unit.unit === 'px' && String(unit) === '7px'); const keyword = new CSSKeywordValue('auto'); keyword.value = 'none'; check(String(keyword) === 'none'); try { new CSSKeywordValue(''); throw new Error('empty keyword accepted'); } catch (error) { check(error instanceof TypeError); } try { new CSSUnitValue(1, 'no-such-unit'); throw new Error('invalid unit accepted'); } catch (error) { check(error instanceof TypeError); } let converted = false; try { Object.getOwnPropertyDescriptor(CSSUnitValue.prototype,'value').set.call({}, {valueOf(){converted=true; return 1;}}); throw new Error('forged unit accepted'); } catch (error) { check(error instanceof TypeError); } check(!converted, 'receiver must be checked before conversion'); })()"#, ); }); } #[test] fn dom_string_list_keeps_utf16_indexed_descriptors_and_iteration() { with_values(|scope| { let values = v8::Local::::try_from(eval(scope, "['a', '\\ud800', 'z']")).unwrap(); let list = dom_string_list::new_dom_string_list(scope, values); publish(scope, "names", list); eval( scope, r#"(() => { check(names instanceof DOMStringList && names.length === 3); check(names.contains('\ud800') && !names.contains('\ufffd')); check(names.item(1).charCodeAt(0) === 0xd800 && names.item(9) === null && names[9] === undefined); check([...names].join('|') === 'a|\ud800|z'); const desc = Object.getOwnPropertyDescriptor(names, '0'); check(!desc.writable && desc.enumerable && desc.value === 'a'); check(Reflect.set(names, '0', 'changed') === false && names[0] === 'a'); check(Reflect.deleteProperty(names, '1') === false && names.length === 3); let converted = false; try { DOMStringList.prototype.contains.call(Object.create(DOMStringList.prototype), {toString(){converted=true; return 'a';}}); throw new Error('forged list accepted'); } catch (error) { check(error instanceof TypeError); } check(!converted, 'forged list converted an argument'); })()"#, ); }); } #[test] fn geolocation_values_keep_realm_prototypes_nulls_and_json_snapshots() { with_values(|scope| { let position = geolocation::build_position( scope, &geolocation::Coordinates { latitude: 10., longitude: 20., altitude: None, accuracy: 3., altitude_accuracy: None, heading: Some(90.), speed: Some(2.), }, 1234., ); let error = geolocation::build_error(scope, 2, "unavailable").unwrap(); publish(scope, "position", position); publish(scope, "positionError", error); eval( scope, r#"(() => { check(position instanceof GeolocationPosition && position.coords instanceof GeolocationCoordinates); check(position.coords === position.coords && position.timestamp === 1234 && position.coords.latitude === 10); check(position.coords.altitude === null && position.coords.altitudeAccuracy === null && position.coords.heading === 90); const json = position.toJSON(); check(Object.getPrototypeOf(json) === Object.prototype && json.coords !== position.coords && json.coords.longitude === 20); check(Object.keys(json.coords).join() === 'accuracy,latitude,longitude,altitude,altitudeAccuracy,heading,speed'); check(positionError instanceof GeolocationPositionError && positionError.code === 2 && positionError.message === 'unavailable'); check(GeolocationPositionError.POSITION_UNAVAILABLE === 2 && positionError.TIMEOUT === 3); check(!Object.getOwnPropertyDescriptor(GeolocationPositionError, 'TIMEOUT').writable); try { Object.getOwnPropertyDescriptor(GeolocationCoordinates.prototype,'latitude').get.call({}); throw new Error('forged coordinates accepted'); } catch (error) { check(error instanceof TypeError); } })()"#, ); }); } #[test] fn queuing_strategies_cache_size_per_realm_and_preserve_getter_effects() { with_values(|scope| { eval( scope, r#"(() => { const reads = []; const count = new CountQueuingStrategy({get highWaterMark(){ reads.push('hwm'); return 2; }}); check(reads.join() === 'hwm' && count.highWaterMark === 2 && count.size() === 1); check(count.size === new CountQueuingStrategy({highWaterMark:9}).size); const bytes = new ByteLengthQueuingStrategy({highWaterMark:3}); check(bytes.size === new ByteLengthQueuingStrategy({highWaterMark:4}).size && bytes.size !== count.size); check(count.size.length === 0 && bytes.size.length === 1); check(bytes.size({get byteLength(){ reads.push('bytes'); return 17; }}) === 17 && reads.join() === 'hwm,bytes'); check(new CountQueuingStrategy({highWaterMark:NaN}).highWaterMark.toString() === 'NaN'); try { new CountQueuingStrategy({}); throw new Error('missing hwm accepted'); } catch (error) { check(error instanceof TypeError); } try { Object.getOwnPropertyDescriptor(CountQueuingStrategy.prototype,'size').get.call({}); throw new Error('forged strategy accepted'); } catch (error) { check(error instanceof TypeError); } })()"#, ); }); } #[test] fn shared_new_target_fallback_uses_the_target_realm_without_repeating_proxy_getters() { ensure_v8(); let mut isolate = v8::Isolate::new(Default::default()); let scope = pin!(v8::HandleScope::new(&mut isolate)); let scope = &mut scope.init(); let source = v8::Context::new(scope, Default::default()); let destination = v8::Context::new(scope, Default::default()); let (target, prototype, size) = { let scope = &mut v8::ContextScope::new(scope, destination); install_values(scope); let target = eval(scope, "(function Target() {}).bind(null)") .to_object(scope) .unwrap(); let prototype = eval(scope, "RTCSessionDescription.prototype") .to_object(scope) .unwrap(); let size = eval(scope, "new CountQueuingStrategy({highWaterMark:1}).size") .to_object(scope) .unwrap(); ( v8::Global::new(scope, target), v8::Global::new(scope, prototype), v8::Global::new(scope, size), ) }; let scope = &mut v8::ContextScope::new(scope, source); install_values(scope); let target = v8::Local::new(scope, &target); let prototype = v8::Local::new(scope, &prototype); let size = v8::Local::new(scope, &size); publish(scope, "foreignTarget", target); publish(scope, "foreignPrototype", prototype); publish(scope, "foreignSize", size); eval( scope, r#"(() => { let reads = 0; const target = new Proxy(foreignTarget, {get(object, key, receiver) { if(key === 'prototype') { reads++; return null; } return Reflect.get(object,key,receiver); }}); const description = Reflect.construct(RTCSessionDescription, [{type:'answer',sdp:'ok'}], target); check(reads === 1, 'NewTarget.prototype was read more than once'); check(Object.getPrototypeOf(description) === foreignPrototype && description.sdp === 'ok'); check(new CountQueuingStrategy({highWaterMark:1}).size !== foreignSize, 'size cache leaked across realms'); })()"#, ); } #[test] fn native_error_and_transport_clone_builders_use_destination_intrinsics_after_global_replacement() { ensure_v8(); let mut isolate = v8::Isolate::new(Default::default()); let scope = pin!(v8::HandleScope::new(&mut isolate)); let scope = &mut scope.init(); let source = v8::Context::new(scope, Default::default()); let destination = v8::Context::new(scope, Default::default()); let payload = { let scope = &mut v8::ContextScope::new(scope, source); install_values(scope); let object = eval( scope, "new WebTransportError('\\ud800', {source:'session',streamErrorCode:42})", ) .to_object(scope) .unwrap(); dom_exception::web_transport_error_clone_payload_from_object(scope, object).unwrap() }; let scope = &mut v8::ContextScope::new(scope, destination); install_values(scope); eval( scope, "globalThis.nativeException = DOMException; globalThis.nativeTransport = WebTransportError; globalThis.DOMException = globalThis.WebTransportError = function(){throw new Error('public constructor called');};", ); let object = dom_exception::build_web_transport_error_from_clone_payload(scope, &payload).unwrap(); let native = dom_exception::new_dom_exception_value(scope, "native", "SyntaxError") .to_object(scope) .unwrap(); publish(scope, "transportClone", object); publish(scope, "nativeError", native); eval( scope, r#"check(transportClone instanceof nativeTransport && transportClone instanceof nativeException); check(transportClone.message.charCodeAt(0) === 0xd800 && transportClone.source === 'session' && transportClone.streamErrorCode === 42); check(nativeError instanceof nativeException && nativeError.name === 'SyntaxError' && nativeError.code === 12);"#, ); // Shared builders must not instantiate an author-provided constructor. assert!(dom_exception::dom_exception_clone_fields(scope, native).is_some()); let not_an_error = v8_string(scope, "not a native error").unwrap(); assert!(dom_exception::websocket_error_close_info(scope, not_an_error.into()).is_none()); assert!(eval(scope, "Object.hasOwn(transportClone, 'stack')").is_true()); } #[test] fn peer_configuration_snapshots_and_channels_work_without_a_renderer() { with_values(|scope| { assert!(eval(scope, r#"(() => { const input = {iceServers: [{urls: ['stun:example.test:3478']}], iceCandidatePoolSize: 2}; class Peer extends RTCPeerConnection {} const peer = new Peer(input); check(peer instanceof Peer && peer instanceof EventTarget); input.iceServers[0].urls[0] = 'stun:changed.test'; const config = peer.getConfiguration(); check(config.iceServers[0].urls[0] === 'stun:example.test:3478'); config.iceServers[0].urls.push('stun:other.test'); check(peer.getConfiguration().iceServers[0].urls.length === 1); peer.setConfiguration({iceServers: [{urls: 'stun:new.test'}], iceCandidatePoolSize: 2}); check(peer.getConfiguration().iceServers[0].urls[0] === 'stun:new.test'); const channel = peer.createDataChannel('label\ud800', {ordered: false, maxRetransmits: 3, protocol: 'test'}); check(channel instanceof RTCDataChannel && channel instanceof EventTarget); check(channel.label === 'label\ufffd' && channel.ordered === false && channel.maxRetransmits === 3); check(channel.protocol === 'test' && channel.maxPacketLifeTime === null && channel.id === null); check(channel.binaryType === 'arraybuffer' && channel.readyState === 'connecting' && channel.bufferedAmount === 0); channel.close(); check(channel.readyState === 'closed'); peer.close(); check(peer.signalingState === 'closed' && peer.iceConnectionState === 'closed' && peer.connectionState === 'closed'); return true; })()"#).is_true()); }); } #[test] fn peer_and_channel_conversions_validate_before_state_and_preserve_exceptions() { with_values(|scope| { assert!(eval(scope, r#"(() => { function fails(name, body) { let caught; try {body();} catch (error) {caught = error;} check(caught && caught.name === name, 'expected ' + name + ', got ' + caught); } for (const url of ['https://example.test', 'stun:example.test/path', 'stun:example.test#x', 'stun:example.test?transport=udp']) { fails('SyntaxError', () => new RTCPeerConnection({iceServers: [{urls: url}]})); } fails('InvalidAccessError', () => new RTCPeerConnection({iceServers: [{urls: 'turn:example.test'}]})); fails('TypeError', () => new RTCPeerConnection({iceCandidatePoolSize: 256})); const peer = new RTCPeerConnection(); fails('TypeError', () => peer.createDataChannel('c', {maxRetransmits: 1, maxPacketLifeTime: 1})); fails('TypeError', () => peer.createDataChannel('c', {negotiated: true})); fails('TypeError', () => peer.createDataChannel('c', {id: 65535})); fails('TypeError', () => RTCPeerConnection.prototype.close.call(Object.create(RTCPeerConnection.prototype))); fails('TypeError', () => RTCDataChannel.prototype.close.call(Object.create(RTCDataChannel.prototype))); const sentinel = {}, order = []; peer.close(); let caught; try {peer.createDataChannel({toString() {order.push('label'); return 'c';}}, { get id() {order.push('id'); throw sentinel;} });} catch (error) {caught = error;} check(caught === sentinel && order.join(',') === 'label,id'); fails('InvalidStateError', () => peer.createDataChannel('c')); return true; })()"#).is_true()); }); } #[test] fn signaling_promises_keep_descriptions_and_report_closed_errors() { with_values(|scope| { eval( scope, r#" globalThis.peerDone = false; globalThis.peerFailure = null; (async () => { const peer = new RTCPeerConnection(); peer.createDataChannel('data'); const offer = await peer.createOffer({offerToReceiveAudio: 1}); check(offer.type === 'offer' && offer.sdp.includes('m=audio') && offer.sdp.includes('m=application')); await peer.setLocalDescription(offer); check(peer.localDescription instanceof RTCSessionDescription); check(peer.localDescription.type === 'offer' && peer.localDescription.sdp === offer.sdp); check(peer.pendingLocalDescription === peer.localDescription && peer.currentLocalDescription === null); check(peer.signalingState === 'have-local-offer' && peer.iceGatheringState === 'new'); peer.close(); const failed = peer.createOffer(); check(failed instanceof Promise); let caught; try {await failed;} catch (error) {caught = error;} check(caught && caught.name === 'InvalidStateError'); peerDone = true; })().catch(error => peerFailure = String(error)); "#, ); scope.perform_microtask_checkpoint(); assert!(eval(scope, "peerFailure === null && peerDone").is_true()); }); } #[test] fn rtc_native_values_use_canonical_intrinsics_and_fresh_capability_objects() { with_values(|scope| { assert!(eval(scope, r#"(() => { const OriginalChannel = RTCDataChannel; const peer = new RTCPeerConnection(); Object.defineProperty(globalThis, 'RTCDataChannel', {configurable: true, get() {throw new Error('public constructor');}}); const channel = peer.createDataChannel('canonical'); check(channel instanceof OriginalChannel && Object.getPrototypeOf(channel) === OriginalChannel.prototype); const caps = RTCRtpReceiver.getCapabilities('audio'); check(Array.isArray(caps.codecs) && caps.codecs.length > 0 && Array.isArray(caps.headerExtensions)); caps.codecs.length = 0; check(RTCRtpReceiver.getCapabilities('audio').codecs.length > 0); check(RTCRtpReceiver.getCapabilities('unknown') === null); check(RTCRtpReceiver.getCapabilities('video').codecs.length > 0); peer.close(); return true; })()"#).is_true()); }); }