Files
moli/moli-webapi/tests/platform_values.rs
T

570 lines
28 KiB
Rust

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::<v8::Array>::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());
});
}