Skip to content

armgit / moli

Public Imported from GitHub
0

Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust

91.0 KB
Raw Blame
use super::*;
use moli_webapi_declare::WebApiObject;

#[derive(WebApiObject)]
#[webapi(plain)]
struct LoadingWorkerWrapperProbeDeclaration {}

fn loading_worker_wrapper_probe<'s>(scope: &mut v8::PinScope<'s, '_>) -> v8::Local<'s, v8::Object> {
    LoadingWorkerWrapperProbeDeclaration::new()
        .bind(scope)
        .expect("loading worker wrapper probe declaration should bind")
}

#[test]
fn loading_worker_terminate_blocks_late_script_loaded_transition() {
    let mut vm = new_storage_test_vm("https://example.com/");

    let (finished, post_after_finish) = vm
        .with_default_context_scope_and_checkpoint_for_test(|scope, host_ptr| {
            let host = unsafe { &mut *host_ptr };
            let wrapper = loading_worker_wrapper_probe(scope);
            let creator_storage_key = host
                .active_storage_context(scope, None)
                .storage_key()
                .clone();
            let top_level_site = creator_storage_key.top_level_site().to_owned();
            let owner = host
                .current_runtime_window_execution_context_binding(scope)
                .expect("test Worker should capture the main execution context");
            let outside_settings_load = host
                .register_dedicated_worker_outside_settings_load(owner.dispatch_scope())
                .expect("test Worker should capture its Document script-load authority");
            let worker_id = host.register_loading_worker(
                scope,
                wrapper,
                top_level_site,
                creator_storage_key,
                String::new(),
                moli_fetch::RequestCredentialsMode::SameOrigin,
                None,
                outside_settings_load,
                owner,
            );
            let queued_before_terminate = crate::context_bootstrap::structured_serialize_value(
                scope,
                v8::String::new(scope, "queued-before-terminate")
                    .expect("v8 string allocation")
                    .into(),
            )
            .expect("test worker message should serialize");
            assert!(host.post_worker_message(worker_id, queued_before_terminate));
            assert!(host.terminate_worker(worker_id));
            let finished = host.finish_loading_worker(
                worker_id,
                "https://example.com/worker.js".to_owned(),
                crate::worker::WorkerScriptSource::text(
                    "postMessage('late'); self.close();".to_owned(),
                ),
                crate::worker::WorkerScriptKind::Classic,
                true,
                None,
                None,
                Default::default(),
                Vec::new(),
                Vec::new(),
                crate::content_security_policy::ContentSecurityPolicyReportingEndpoints::default(),
            );
            let queued_after_finish = crate::context_bootstrap::structured_serialize_value(
                scope,
                v8::String::new(scope, "queued-after-finish")
                    .expect("v8 string allocation")
                    .into(),
            )
            .expect("test worker message should serialize");
            let post_after_finish = host.post_worker_message(worker_id, queued_after_finish);
            Ok::<_, anyhow::Error>((finished, post_after_finish))
        })
        .expect("loading worker termination probe should succeed");

    assert!(
        !finished,
        "late ScriptLoaded should not transition a terminated loading worker to running"
    );
    assert!(
        !post_after_finish,
        "terminated loading worker should be removed after the late ScriptLoaded path"
    );
}

#[test]
fn websocket_minimal_surface_is_feature_detectable() {
    let mut vm = new_storage_test_vm("https://websocket-surface.test/");

    let result = vm
        .eval(
            r#"
            (() => {
                const socket = new WebSocket('wss://example.test/socket');
                return [
                    typeof WebSocket,
                    socket instanceof WebSocket,
                    socket instanceof EventTarget,
                    WebSocket.CONNECTING,
                    WebSocket.OPEN,
                    WebSocket.CLOSING,
                    WebSocket.CLOSED,
                    socket.readyState,
                    socket.url,
                    socket.protocol,
                    socket.extensions,
                    socket.binaryType,
                    typeof socket.addEventListener,
                    typeof socket.send,
                    typeof socket.close
                ].join('|');
            })()
            "#,
        )
        .expect("websocket surface should evaluate");

    assert_eq!(
        result,
        "function|true|true|0|1|2|3|0|wss://example.test/socket|||blob|function|function|function"
    );
}

#[test]
fn websocket_document_csp_blocks_connect_src_and_dispatches_event() {
    let mut vm = new_storage_test_vm("https://websocket-connect-csp.test/");
    vm.set_response_content_security_policies(&[String::from("connect-src 'none'")]);
    vm.set_response_content_security_report_only_policies(&[String::from("connect-src 'none'")]);

    let result = vm
        .eval(
            r#"
(() => {
  const events = [];
  self.addEventListener("securitypolicyviolation", event => {
    events.push({
      blockedURI: event.blockedURI,
      effectiveDirective: event.effectiveDirective,
      disposition: event.disposition,
      instance: event instanceof SecurityPolicyViolationEvent
    });
  });
  const socket = new WebSocket("wss://websocket-connect-csp.test/socket");
  globalThis.__websocketCspResult = { readyState: socket.readyState, events };
  return socket.readyState;
})()
"#,
        )
        .expect("WebSocket CSP block probe should evaluate");

    assert_eq!(result, "0");
    assert_eq!(
        drain_pre_domcontentloaded_non_script_page_tasks_for_test(&mut vm),
        2
    );
    assert_eq!(
        vm.eval("JSON.stringify(globalThis.__websocketCspResult)")
            .expect("queued WebSocket CSP violations should be observable"),
        r#"{"readyState":0,"events":[{"blockedURI":"wss://websocket-connect-csp.test/socket","effectiveDirective":"connect-src","disposition":"report","instance":true},{"blockedURI":"wss://websocket-connect-csp.test/socket","effectiveDirective":"connect-src","disposition":"enforce","instance":true}]}"#
    );
}

#[test]
fn websocket_document_csp_block_precedes_mixed_content_rejection() {
    let mut vm = new_storage_test_vm("http://localhost:8000/trusted-types/reporting.html");
    vm.set_response_content_security_policies(&[String::from("connect-src 'none'")]);

    let result = vm
        .eval(
            r#"
(() => {
  const events = [];
  self.addEventListener("securitypolicyviolation", event => {
    events.push({
      blockedURI: event.blockedURI,
      effectiveDirective: event.effectiveDirective,
      disposition: event.disposition
    });
  });
  let outcome;
  try {
    const socket = new WebSocket("ws:/common/blank.html");
    outcome = `socket:${socket.readyState}:${socket.url}`;
  } catch (error) {
    outcome = `throw:${error.name}`;
  }
  globalThis.__websocketMixedContentCspResult = { outcome, events };
  return outcome;
})()
"#,
        )
        .expect("WebSocket CSP and mixed-content ordering probe should evaluate");

    assert_eq!(result, "socket:0:ws://common/blank.html");
    assert_eq!(
        drain_pre_domcontentloaded_non_script_page_tasks_for_test(&mut vm),
        1
    );
    assert_eq!(
        vm.eval("JSON.stringify(globalThis.__websocketMixedContentCspResult)")
            .expect("queued mixed-content WebSocket CSP violation should be observable"),
        r#"{"outcome":"socket:0:ws://common/blank.html","events":[{"blockedURI":"ws://common/blank.html","effectiveDirective":"connect-src","disposition":"enforce"}]}"#
    );
}

#[test]
fn websocket_document_csp_report_only_dispatches_without_blocking() {
    let mut vm = new_storage_test_vm("https://websocket-connect-report-only.test/");
    vm.set_response_content_security_report_only_policies(&[String::from("connect-src 'none'")]);

    let result = vm
        .eval(
            r#"
(() => {
  const events = [];
  self.addEventListener("securitypolicyviolation", event => {
    events.push({
      blockedURI: event.blockedURI,
      effectiveDirective: event.effectiveDirective,
      disposition: event.disposition,
      instance: event instanceof SecurityPolicyViolationEvent
    });
  });
  const socket = new WebSocket("wss://websocket-connect-report-only.test/socket");
  globalThis.__websocketReportOnlyCspResult = { readyState: socket.readyState, events };
  return socket.readyState;
})()
"#,
        )
        .expect("WebSocket CSP report-only probe should evaluate");

    assert_eq!(result, "0");
    assert_eq!(
        drain_pre_domcontentloaded_non_script_page_tasks_for_test(&mut vm),
        1
    );
    assert_eq!(
        vm.eval("JSON.stringify(globalThis.__websocketReportOnlyCspResult)")
            .expect("queued report-only WebSocket CSP violation should be observable"),
        r#"{"readyState":0,"events":[{"blockedURI":"wss://websocket-connect-report-only.test/socket","effectiveDirective":"connect-src","disposition":"report","instance":true}]}"#
    );
}

#[test]
fn websocket_constructor_rejects_invalid_url_and_protocols() {
    let mut vm = new_storage_test_vm("http://127.0.0.1:65535/base/");

    let result = vm
        .eval(
            r#"
            (() => {
                function outcome(callback) {
                    try {
                        callback();
                        return 'ok';
                    } catch (error) {
                        return `${error && error.name}:${String(error && error.message).includes('WebSocket')}`;
                    }
                }
                return [
                    outcome(() => new WebSocket('ftp://example.test/socket')),
                    outcome(() => new WebSocket('ws://example.test/socket#frag')),
                    outcome(() => new WebSocket('ws://example.test/socket', ['chat', 'chat'])),
                    outcome(() => new WebSocket('ws://example.test/socket', ['chat', 'CHAT'])),
                    outcome(() => new WebSocket('ws://example.test/socket', 'bad protocol')),
                    new WebSocket('/relative').url
                ].join('|');
            })()
            "#,
        )
        .expect("websocket validation should evaluate");

    assert_eq!(
        result,
        "SyntaxError:true|SyntaxError:true|SyntaxError:true|SyntaxError:true|SyntaxError:true|ws://127.0.0.1:65535/relative"
    );
}

#[test]
fn websocket_constructor_normalizes_http_urls_and_ignores_extra_arguments() {
    let mut vm = new_storage_test_vm("http://websocket-constructor.test/base/page.html");

    let result = vm
        .eval(
            r#"
            (() => {
                return [
                    new WebSocket('http://example.test/socket', 'chat', 'ignored').url,
                    new WebSocket('https://example.test/socket').url,
                    new WebSocket('/relative', undefined, 'ignored').url
                ].join('|');
            })()
            "#,
        )
        .expect("websocket http/https URL normalization should evaluate");

    assert_eq!(
        result,
        "ws://example.test/socket|wss://example.test/socket|ws://websocket-constructor.test/relative"
    );
}

#[test]
fn websocket_constructor_requires_new_and_url_argument() {
    let mut vm = new_storage_test_vm("https://websocket-constructor.test/");

    let result = vm
        .eval(
            r#"
            (() => {
                function outcome(callback) {
                    try {
                        callback();
                        return 'ok';
                    } catch (error) {
                        return `${error && error.name}:${String(error && error.message).includes('WebSocket')}`;
                    }
                }
                return [
                    outcome(() => WebSocket('wss://example.test/socket')),
                    outcome(() => new WebSocket())
                ].join('|');
            })()
            "#,
        )
        .expect("websocket constructor argument validation should evaluate");

    assert_eq!(result, "TypeError:true|TypeError:true");
}

// Chromium/WPT target tests below are intentionally ignored. They encode the
// WebSocket compatibility surface we still need to converge on, using local
// snippets derived from Chromium's `external/wpt/websockets` coverage.

#[test]
fn websocket_wpt_target_idl_attributes_are_prototype_accessors() {
    let mut vm = new_storage_test_vm("https://websocket-wpt-target.test/");

    vm.eval(
        r#"
        (() => {
            const socket = new WebSocket('wss://example.test/socket');
            const ownInternalSlots = Object.getOwnPropertyNames(socket)
                .filter(name => name.startsWith('__moliWebSocket'));
            if (ownInternalSlots.length !== 0) {
                throw new Error(`WebSocket internal slots should not be reflected: ${ownInternalSlots.join(',')}`);
            }
            Object.assign(WebSocket.prototype, {
                __moliWebSocketUrl: 'wss://poison.example/socket',
                __moliWebSocketReadyState: 99,
                __moliWebSocketBufferedAmount: 99,
                __moliWebSocketExtensions: 'poison-ext',
                __moliWebSocketProtocol: 'poison-proto',
                __moliWebSocketBinaryType: 'arraybuffer'
            });
            Object.assign(socket, {
                __moliWebSocketUrl: 'wss://own-poison.example/socket',
                __moliWebSocketReadyState: 88,
                __moliWebSocketBufferedAmount: 88,
                __moliWebSocketExtensions: 'own-poison-ext',
                __moliWebSocketProtocol: 'own-poison-proto',
                __moliWebSocketBinaryType: 'arraybuffer'
            });
            if (
                socket.url !== 'wss://example.test/socket' ||
                socket.readyState !== 0 ||
                socket.bufferedAmount !== 0 ||
                socket.extensions !== '' ||
                socket.protocol !== '' ||
                socket.binaryType !== 'blob'
            ) {
                throw new Error('WebSocket accessors should ignore string-named internal slot spoofing');
            }
            const readonly = ['url', 'readyState', 'bufferedAmount', 'extensions', 'protocol'];
            for (const name of readonly) {
                if (Object.prototype.hasOwnProperty.call(socket, name)) {
                    throw new Error(`${name} should not be an own data property`);
                }
                const descriptor = Object.getOwnPropertyDescriptor(WebSocket.prototype, name);
                if (!descriptor || typeof descriptor.get !== 'function' || descriptor.set !== undefined) {
                    throw new Error(`${name} should be a readonly prototype accessor`);
                }
                if (descriptor.get.name !== `get ${name}` || descriptor.get.length !== 0) {
                    throw new Error(`${name} getter metadata should match Web IDL`);
                }
                if (descriptor.enumerable !== true || descriptor.configurable !== true) {
                    throw new Error(`${name} descriptor shape should match Web IDL`);
                }
            }
            const binaryType = Object.getOwnPropertyDescriptor(WebSocket.prototype, 'binaryType');
            if (!binaryType || typeof binaryType.get !== 'function' || typeof binaryType.set !== 'function') {
                throw new Error('binaryType should be a prototype accessor pair');
            }
            if (binaryType.get.name !== 'get binaryType' || binaryType.get.length !== 0 ||
                binaryType.set.name !== 'set binaryType' || binaryType.set.length !== 1 ||
                binaryType.enumerable !== true || binaryType.configurable !== true) {
                throw new Error('binaryType descriptor metadata should match Web IDL');
            }
            socket.bufferedAmount = 5;
            if (socket.bufferedAmount !== 0) {
                throw new Error('bufferedAmount should be readonly');
            }
            return 'ok';
        })()
        "#,
    )
    .expect("target WebSocket IDL descriptor test should pass once implemented");
}

#[test]
fn websocket_wpt_target_event_handler_attributes_treat_non_callable_as_null() {
    let mut vm = new_storage_test_vm("https://websocket-wpt-target.test/");

    vm.eval(
        r#"
        (() => {
            const socket = new WebSocket('wss://example.test/socket');
            for (const key of ['onopen', 'onmessage', 'onerror', 'onclose']) {
                const descriptor = Object.getOwnPropertyDescriptor(WebSocket.prototype, key);
                if (!descriptor || typeof descriptor.get !== 'function' || typeof descriptor.set !== 'function') {
                    throw new Error(`${key} should be a prototype accessor pair`);
                }
                if (descriptor.get.name !== `get ${key}` || descriptor.get.length !== 0 ||
                    descriptor.set.name !== `set ${key}` || descriptor.set.length !== 1) {
                    throw new Error(`${key} getter/setter metadata should match Web IDL`);
                }
                if (descriptor.enumerable !== true || descriptor.configurable !== true) {
                    throw new Error(`${key} descriptor shape should match Web IDL`);
                }
                if (Object.prototype.hasOwnProperty.call(socket, key)) {
                    throw new Error(`${key} should not be installed per instance`);
                }
                if (socket[key] !== null) {
                    throw new Error(`${key} should start as null`);
                }
                socket[key] = function () {};
                if (typeof socket[key] !== 'function') {
                    throw new Error(`${key} should accept callable values`);
                }
                if (Object.prototype.hasOwnProperty.call(socket, key)) {
                    throw new Error(`${key} should continue to resolve through the prototype accessor`);
                }
                socket[key] = 2;
                if (socket[key] !== null) {
                    throw new Error(`${key} should coerce non-callable values to null`);
                }
            }
            return 'ok';
        })()
        "#,
    )
    .expect("target WebSocket event handler attribute test should pass once implemented");
}

#[test]
fn websocket_wpt_target_constants_have_webidl_descriptors() {
    let mut vm = new_storage_test_vm("https://websocket-wpt-target.test/");

    vm.eval(
        r#"
        (() => {
            for (const [name, value] of [['CONNECTING', 0], ['OPEN', 1], ['CLOSING', 2], ['CLOSED', 3]]) {
                for (const owner of [WebSocket, WebSocket.prototype]) {
                    const descriptor = Object.getOwnPropertyDescriptor(owner, name);
                    if (!descriptor) {
                        throw new Error(`${name} missing on ${owner === WebSocket ? 'constructor' : 'prototype'}`);
                    }
                    if (descriptor.value !== value || descriptor.writable !== false ||
                        descriptor.enumerable !== true || descriptor.configurable !== false) {
                        throw new Error(`${name} descriptor does not match Web IDL constants`);
                    }
                }
            }
            return 'ok';
        })()
        "#,
    )
    .expect("target WebSocket constant descriptor test should pass once implemented");
}

#[test]
fn websocket_wpt_target_event_target_listener_options_and_objects() {
    let mut vm = new_storage_test_vm("https://websocket-wpt-target.test/");

    vm.eval(
        r#"
        (() => {
            const socket = new WebSocket('wss://example.test/socket');
            const simpleOwn = Object.getOwnPropertyNames(socket)
                .filter(name =>
                    name === '__moliEventTargetSlot' ||
                    name === '__moliSimpleEventTargetOrderedHandlers'
                );
            if (simpleOwn.length !== 0) {
                throw new Error(`WebSocket simple EventTarget internals should not be reflected: ${simpleOwn.join(',')}`);
            }
            const expected = {
                addEventListener: 'true:true:true:true:function:2:addEventListener',
                removeEventListener: 'true:true:true:true:function:2:removeEventListener',
                dispatchEvent: 'true:true:true:true:function:1:dispatchEvent'
            };
            for (const [name, shape] of Object.entries(expected)) {
                if (Object.hasOwn(socket, name) || socket[name] !== EventTarget.prototype[name])
                    throw new Error(`inherited EventTarget method ${name}`);
                const descriptor = Object.getOwnPropertyDescriptor(EventTarget.prototype, name);
                const actual = [
                    !!descriptor,
                    descriptor && descriptor.enumerable,
                    descriptor && descriptor.configurable,
                    descriptor && descriptor.writable,
                    descriptor && typeof descriptor.value,
                    descriptor && descriptor.value.length,
                    descriptor && descriptor.value.name
                ].join(':');
                if (actual !== shape) {
                    throw new Error(`${name} descriptor mismatch: ${actual}`);
                }
            }
            socket.__moliEventTargetSlot = '__wrongSlot';
            socket.__moliSimpleEventTargetOrderedHandlers = false;
            const events = [];
            socket.addEventListener('open', { handleEvent(event) { events.push(`object:${event.type}:${this === socket}`); } });
            socket.addEventListener('open', function once(event) {
                events.push(`once:${event.target === socket}:${event.currentTarget === socket}`);
            }, { once: true });
            socket.dispatchEvent(new Event('open'));
            socket.dispatchEvent(new Event('open'));
            if (events.join('|') !== 'object:open:false|once:true:true|object:open:false') {
                throw new Error(events.join('|'));
            }
            return 'ok';
        })()
        "#,
    )
    .expect("target WebSocket EventTarget listener options test should pass once implemented");
}

#[test]
fn websocket_wpt_target_event_handler_synthetic_ui_event_surface() {
    let mut vm = new_storage_test_vm("https://websocket-wpt-target.test/");

    let result = vm
        .eval(
            r#"
            (() => {
                const socket = new WebSocket('wss://example.test/socket');
                const events = [];
                for (const type of ['open', 'message', 'error', 'close']) {
                    const key = `on${type}`;
                    if (!(key in socket)) {
                        throw new Error(`${key} should be present on WebSocket`);
                    }
                    socket[key] = event => events.push(`${type}:${event.detail}:${event.target === socket}:${event.currentTarget === socket}`);
                    const event = document.createEvent('UIEvents');
                    event.initUIEvent(type, false, false, window, 5);
                    socket.dispatchEvent(event);
                }
                return events.join('|');
            })()
            "#,
        )
        .expect("target WebSocket synthetic UIEvent surface test should evaluate");

    assert_eq!(
        result,
        "open:5:true:true|message:5:true:true|error:5:true:true|close:5:true:true"
    );
}

#[test]
fn websocket_wpt_target_event_handler_assignment_matrix() {
    let mut vm = new_storage_test_vm("https://websocket-wpt-target.test/");

    vm.eval(
        r#"
        (() => {
            const socket = new WebSocket('wss://example.test/socket');
            for (const key of ['onopen', 'onmessage', 'onerror', 'onclose']) {
                const callback = function () {};
                socket[key] = callback;
                if (socket[key] !== callback) {
                    throw new Error(`${key} should retain callable values`);
                }
                for (const value of [1, ';', null, undefined]) {
                    socket[key] = callback;
                    socket[key] = value;
                    if (socket[key] !== null) {
                        throw new Error(`${key} should clear ${String(value)} to null`);
                    }
                }
            }
            return 'ok';
        })()
        "#,
    )
    .expect("target WebSocket event handler assignment matrix should pass once implemented");
}

#[test]
fn websocket_wpt_target_remove_event_listener_surface() {
    let mut vm = new_storage_test_vm("https://websocket-wpt-target.test/");

    vm.eval(
        r#"
        (() => {
            const socket = new WebSocket('wss://example.test/socket');
            for (const type of ['open', 'message', 'error', 'close']) {
                let count = 0;
                function listener() { count++; }
                socket.addEventListener(type, listener);
                socket.removeEventListener(type, listener);
                socket.dispatchEvent(new Event(type));
                if (count !== 0) {
                    throw new Error(`${type} listener should have been removed`);
                }
            }
            return 'ok';
        })()
        "#,
    )
    .expect("target WebSocket removeEventListener test should pass once implemented");
}

#[test]
fn websocket_wpt_target_domexception_names_for_send_and_close_validation() {
    let mut vm = new_storage_test_vm("https://websocket-wpt-target.test/");

    vm.eval(
        r#"
        (() => {
            function expectName(expected, callback) {
                try {
                    callback();
                } catch (error) {
                    if (error && error.name === expected) {
                        return;
                    }
                    throw new Error(`expected ${expected}, got ${error && error.name}`);
                }
                throw new Error(`expected ${expected}, got no exception`);
            }
            function outcome(callback) {
                try {
                    return String(callback());
                } catch (error) {
                    return `throw:${error && error.name}`;
                }
            }
            expectName('InvalidStateError', () => new WebSocket('wss://example.test/a').send('x'));
            for (const value of [0, 500, 1004, 1005, 1006, 5000, NaN, 'string', null, 0x10000 + 1000]) {
                expectName('InvalidAccessError', () => new WebSocket('wss://example.test/b').close(value));
            }
            expectName('InvalidAccessError', () => new WebSocket('wss://example.test/c').close('reason only'));
            if (outcome(() => new WebSocket('wss://example.test/d').close(1000.5, undefined)) !== 'undefined') {
                throw new Error('[Clamp] half-even rounding should keep 1000.5 valid as 1000');
            }
            if (outcome(() => new WebSocket('wss://example.test/e').close(2999.5, 'rounded')) !== 'undefined') {
                throw new Error('[Clamp] half-even rounding should make 2999.5 valid as 3000');
            }
            expectName('InvalidAccessError', () => new WebSocket('wss://example.test/f').close(1001.5));
            expectName('TypeError', () => new WebSocket('wss://example.test/g').close(1000, Symbol()));
            expectName('SyntaxError', () => new WebSocket('wss://example.test/h').close(1000, 'x'.repeat(124)));
            return 'ok';
        })()
        "#,
    )
    .expect("target WebSocket DOMException validation test should pass once implemented");
}

#[test]
fn websocket_wpt_target_send_connecting_invalid_state_precedes_text_conversion() {
    let mut vm = new_storage_test_vm("https://websocket-wpt-target.test/");

    vm.eval(
        r#"
        (() => {
            for (const value of ['a', 'a\uDC00x', 'a\uD800x', 'a\uDC00\uD800x']) {
                const socket = new WebSocket('wss://example.test/socket');
                try {
                    socket.send(value);
                } catch (error) {
                    if (error && error.name === 'InvalidStateError') {
                        continue;
                    }
                    throw new Error(`expected InvalidStateError, got ${error && error.name}`);
                }
                throw new Error('expected send while CONNECTING to throw');
            }
            return 'ok';
        })()
        "#,
    )
    .expect("target WebSocket CONNECTING send validation test should pass once implemented");
}

#[test]
fn websocket_wpt_target_constructor_syntaxerror_names_for_url_and_protocol_validation() {
    let mut vm = new_storage_test_vm("https://websocket-wpt-target.test/");

    vm.eval(
        r#"
        (() => {
            function expectSyntaxError(callback) {
                try {
                    callback();
                } catch (error) {
                    if (error && error.name === 'SyntaxError') {
                        return;
                    }
                    throw new Error(`expected SyntaxError, got ${error && error.name}`);
                }
                throw new Error('expected SyntaxError, got no exception');
            }
            expectSyntaxError(() => new WebSocket('ws://web platform.test/socket'));
            expectSyntaxError(() => new WebSocket('wss://example.test/socket#fragment'));
            expectSyntaxError(() => new WebSocket('wss://example.test/socket', 'bad protocol'));
            expectSyntaxError(() => new WebSocket('wss://example.test/socket', ['chat', 'CHAT']));
            return 'ok';
        })()
        "#,
    )
    .expect("target WebSocket constructor SyntaxError test should pass once implemented");
}

#[test]
fn websocket_wpt_target_constructor_ignores_extra_arguments() {
    let mut vm = new_storage_test_vm("https://websocket-wpt-target.test/");

    let result = vm
        .eval(
            r#"
            (() => {
                const socket = new WebSocket('wss://example.test/socket', 'echo', 'stray');
                return [
                    socket instanceof WebSocket,
                    socket.protocol,
                    socket.url
                ].join('|');
            })()
            "#,
        )
        .expect("target WebSocket extra constructor argument test should evaluate");

    assert_eq!(result, "true||wss://example.test/socket");
}

#[test]
fn websocket_wpt_target_protocol_token_validation_matches_wpt() {
    let mut vm = new_storage_test_vm("https://websocket-wpt-target.test/");

    vm.eval(
        r#"
        (() => {
            function expectSyntaxError(protocols) {
                try {
                    new WebSocket('wss://example.test/socket', protocols);
                } catch (error) {
                    if (error && error.name === 'SyntaxError') {
                        return;
                    }
                    throw new Error(`expected SyntaxError, got ${error && error.name}`);
                }
                throw new Error(`expected SyntaxError for ${JSON.stringify(protocols)}`);
            }
            for (const protocol of ['', 'bad protocol', 'bad,protocol', 'bad/protocol',
                                    'bad;protocol', 'bad=protocol', '\u007F', '\u0080echo']) {
                expectSyntaxError(protocol);
            }
            expectSyntaxError(['echo', 'ECHO']);
            const socket = new WebSocket('wss://example.test/socket', [
                'echo',
                "!#$%&'*+-.^_`|~0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
            ]);
            if (socket.protocol !== '') {
                throw new Error('protocol should be empty before the handshake selects one');
            }
            return 'ok';
        })()
        "#,
    )
    .expect("target WebSocket protocol validation test should pass once implemented");
}

#[test]
fn websocket_wpt_target_protocol_iterable_conversion_order() {
    let mut vm = new_storage_test_vm("https://websocket-wpt-target.test/");

    let result = vm
        .eval(
            r#"
            (() => {
                const steps = [];
                const protocols = {
                    [Symbol.iterator]() {
                        steps.push('iterator');
                        let index = 0;
                        return {
                            next() {
                                index++;
                                if (index === 1) {
                                    return {
                                        done: false,
                                        value: { toString() { steps.push('first'); return 'chat'; } }
                                    };
                                }
                                if (index === 2) {
                                    return {
                                        done: false,
                                        value: { toString() { steps.push('second'); return 'superchat'; } }
                                    };
                                }
                                return { done: true };
                            }
                        };
                    }
                };
                const socket = new WebSocket('wss://example.test/socket', protocols);
                return `${steps.join('|')}|${socket.protocol}`;
            })()
            "#,
        )
        .expect("target WebSocket protocol iterable conversion test should evaluate");

    assert_eq!(result, "iterator|first|second|");
}

#[test]
fn websocket_wpt_target_insecure_websocket_is_blocked_from_secure_context() {
    let mut vm = new_storage_test_vm("https://secure-websocket-wpt-target.test/");

    vm.eval(
        r#"
        (() => {
            try {
                new WebSocket('ws://insecure.example.test/socket');
            } catch (error) {
                if (error && error.name === 'SecurityError') {
                    return 'ok';
                }
                throw new Error(`expected SecurityError, got ${error && error.name}`);
            }
            throw new Error('expected insecure WebSocket construction to throw');
        })()
        "#,
    )
    .expect("target WebSocket mixed-content construction test should pass once implemented");
}

#[test]
fn websocket_wpt_target_loopback_websocket_is_allowed_from_secure_context() {
    let mut vm = new_storage_test_vm("https://secure-websocket-wpt-target.test/");

    let result = vm
        .eval(
            r#"
            (() => {
                const socket = new WebSocket('ws://localhost/socket');
                return socket.url;
            })()
            "#,
        )
        .expect("target WebSocket loopback mixed-content exemption test should evaluate");

    assert_eq!(result, "ws://localhost/socket");
}

#[test]
fn websocket_wpt_target_insecure_websocket_is_blocked_from_loopback_secure_context() {
    let mut vm = new_storage_test_vm("http://localhost/");

    vm.eval(
        r#"
        (() => {
            try {
                new WebSocket('ws://insecure.example.test/socket');
            } catch (error) {
                if (error && error.name === 'SecurityError') {
                    return 'ok';
                }
                throw new Error(`expected SecurityError, got ${error && error.name}`);
            }
            throw new Error('expected insecure WebSocket construction to throw');
        })()
        "#,
    )
    .expect("target WebSocket loopback secure-context construction test should pass");
}

#[test]
fn websocket_wpt_target_url_serialization_percent_encodes_spaces() {
    let mut vm = new_storage_test_vm("http://127.0.0.1:65535/base/");

    let result = vm
        .eval(
            r#"
            (() => {
                const socket = new WebSocket('/echo?foo%20bar baz');
                return socket.url;
            })()
            "#,
        )
        .expect("target WebSocket URL serialization test should evaluate");

    assert_eq!(result, "ws://127.0.0.1:65535/echo?foo%20bar%20baz");
}

#[test]
fn websocket_wpt_target_url_bare_authority_and_query_serialization() {
    let mut vm = new_storage_test_vm("http://websocket-wpt-target.test/base/");

    let result = vm
        .eval(
            r#"
            (() => {
                return [
                    new WebSocket('wss://example.test').url,
                    new WebSocket('wss://example.test?foo%20bar baz').url,
                    new WebSocket('wss://example.test:443').url,
                    new WebSocket('ws://example.test:80').url
                ].join('|');
            })()
            "#,
        )
        .expect("target WebSocket bare-authority URL serialization test should evaluate");

    assert_eq!(
        result,
        "wss://example.test/|wss://example.test/?foo%20bar%20baz|wss://example.test/|ws://example.test/"
    );
}

#[test]
fn websocket_wpt_target_constructor_rejects_url_with_space() {
    let mut vm = new_storage_test_vm("https://websocket-wpt-target.test/");

    vm.eval(
        r#"
        (() => {
            try {
                new WebSocket('wss://web platform.test/socket');
            } catch (error) {
                if (error && error.name === 'SyntaxError') {
                    return 'ok';
                }
                throw new Error(`expected SyntaxError, got ${error && error.name}`);
            }
            throw new Error('expected URL with space to throw');
        })()
        "#,
    )
    .expect("target WebSocket URL space test should pass once implemented");
}

#[test]
fn websocket_wpt_target_relative_url_conversion_for_primitive_inputs() {
    let mut vm = new_storage_test_vm("http://127.0.0.1:65535/base/path?query");

    let result = vm
        .eval(
            r#"
            (() => {
                return [
                    new WebSocket('test').url,
                    new WebSocket('?').url,
                    new WebSocket(null).url,
                    new WebSocket(123).url
                ].join('|');
            })()
            "#,
        )
        .expect("target WebSocket primitive URL conversion test should evaluate");

    assert_eq!(
        result,
        "ws://127.0.0.1:65535/base/test|ws://127.0.0.1:65535/base/path?|ws://127.0.0.1:65535/base/null|ws://127.0.0.1:65535/base/123"
    );
}

#[test]
fn websocket_wpt_target_close_event_constructor_surface() {
    let mut vm = new_storage_test_vm("https://websocket-wpt-target.test/");

    let result = vm
        .eval(
            r#"
            (() => {
                const first = new CloseEvent('foo');
                const second = new CloseEvent('bar', {
                    bubbles: true,
                    cancelable: true,
                    wasClean: true,
                    code: 7,
                    reason: 'x'
                });
                return [
                    first instanceof CloseEvent,
                    first.type,
                    first.bubbles,
                    first.cancelable,
                    first.wasClean,
                    first.code,
                    first.reason,
                    second instanceof CloseEvent,
                    second.type,
                    second.bubbles,
                    second.cancelable,
                    second.wasClean,
                    second.code,
                    second.reason,
                    'initCloseEvent' in CloseEvent.prototype,
                    'initCloseEvent' in second
                ].join('|');
            })()
            "#,
        )
        .expect("target CloseEvent constructor test should evaluate");

    assert_eq!(
        result,
        "true|foo|false|false|false|0||true|bar|true|true|true|7|x|false|false"
    );
}

#[test]
fn websocket_wpt_target_message_event_constructor_surface() {
    let mut vm = new_storage_test_vm("https://websocket-wpt-target.test/");

    let result = vm
        .eval(
            r#"
            (() => {
                const first = new MessageEvent('message');
                const second = new MessageEvent('message', {
                    bubbles: true,
                    cancelable: true,
                    data: 'payload',
                    origin: 'ws://example.test',
                    lastEventId: 'event-id'
                });
                return [
                    first instanceof MessageEvent,
                    first.type,
                    first.bubbles,
                    first.cancelable,
                    first.data === null,
                    first.origin,
                    first.lastEventId,
                    second instanceof MessageEvent,
                    second.bubbles,
                    second.cancelable,
                    second.data,
                    second.origin,
                    second.lastEventId,
                    'ports' in second,
                    'source' in second,
                    new MessageEvent('message', { data: undefined }).data === null
                ].join('|');
            })()
            "#,
        )
        .expect("target MessageEvent constructor test should evaluate");

    assert_eq!(
        result,
        "true|message|false|false|true|||true|true|true|payload|ws://example.test|event-id|true|true|true"
    );
}

#[test]
fn websocket_wpt_target_constructor_identity_and_string_tags() {
    let mut vm = new_storage_test_vm("https://websocket-wpt-target.test/");

    let result = vm
        .eval(
            r#"
            (() => {
                const socket = new WebSocket('wss://example.test/socket');
                return [
                    WebSocket.length,
                    WebSocket.name,
                    WebSocket.prototype.constructor === WebSocket,
                    Object.prototype.toString.call(socket),
                    String(socket),
                    Object.prototype.toString.call(WebSocket.prototype)
                ].join('|');
            })()
            "#,
        )
        .expect("target WebSocket constructor identity test should evaluate");

    assert_eq!(
        result,
        "1|WebSocket|true|[object WebSocket]|[object WebSocket]|[object WebSocketPrototype]"
    );
}

#[test]
fn websocket_wpt_target_global_constructor_and_prototype_descriptors() {
    let mut vm = new_storage_test_vm("https://websocket-wpt-target.test/");

    vm.eval(
        r#"
        (() => {
            const globalDescriptor = Object.getOwnPropertyDescriptor(globalThis, 'WebSocket');
            if (!globalDescriptor || globalDescriptor.value !== WebSocket ||
                globalDescriptor.writable !== true ||
                globalDescriptor.enumerable !== false ||
                globalDescriptor.configurable !== true) {
                throw new Error('global WebSocket descriptor should match Web IDL');
            }
            const prototypeDescriptor = Object.getOwnPropertyDescriptor(WebSocket, 'prototype');
            if (!prototypeDescriptor || prototypeDescriptor.value !== WebSocket.prototype ||
                prototypeDescriptor.writable !== false ||
                prototypeDescriptor.enumerable !== false ||
                prototypeDescriptor.configurable !== false) {
                throw new Error('WebSocket.prototype descriptor should match Web IDL');
            }
            const constructorDescriptor = Object.getOwnPropertyDescriptor(WebSocket.prototype, 'constructor');
            if (!constructorDescriptor || constructorDescriptor.value !== WebSocket ||
                constructorDescriptor.writable !== true ||
                constructorDescriptor.enumerable !== false ||
                constructorDescriptor.configurable !== true) {
                throw new Error('WebSocket.prototype.constructor descriptor should match Web IDL');
            }
            return 'ok';
        })()
        "#,
    )
    .expect("target WebSocket constructor descriptor test should pass once implemented");
}

#[test]
fn websocket_wpt_target_close_event_reason_domstring_conversion() {
    let mut vm = new_storage_test_vm("https://websocket-wpt-target.test/");

    let result = vm
        .eval(
            r#"
            (() => {
                const event = new CloseEvent('close', { reason: '\uD800' });
                return [
                    event.reason.length,
                    event.reason.charCodeAt(0).toString(16)
                ].join('|');
            })()
            "#,
        )
        .expect("target CloseEvent DOMString conversion test should evaluate");

    assert_eq!(result, "1|d800");
}

#[test]
fn websocket_wpt_target_close_event_attribute_descriptors() {
    let mut vm = new_storage_test_vm("https://websocket-wpt-target.test/");

    vm.eval(
        r#"
        (() => {
            for (const name of ['wasClean', 'code', 'reason']) {
                const descriptor = Object.getOwnPropertyDescriptor(CloseEvent.prototype, name);
                if (!descriptor || typeof descriptor.get !== 'function' || descriptor.set !== undefined) {
                    throw new Error(`${name} should be a readonly prototype accessor`);
                }
                if (descriptor.enumerable !== true || descriptor.configurable !== true) {
                    throw new Error(`${name} descriptor should match Web IDL`);
                }
            }
            const event = new CloseEvent('close', { wasClean: true, code: 1000, reason: 'ok' });
            event.code = 3000;
            event.reason = 'changed';
            if (event.code !== 1000 || event.reason !== 'ok') {
                throw new Error('CloseEvent readonly attributes should ignore assignment');
            }
            return 'ok';
        })()
        "#,
    )
    .expect("target CloseEvent attribute descriptor test should pass once implemented");
}

#[test]
fn websocket_wpt_target_interface_property_mutation_surface() {
    let mut vm = new_storage_test_vm("https://websocket-wpt-target.test/");

    vm.eval(
        r#"
        (() => {
            const socket = new WebSocket('wss://example.test/socket');
            if (delete socket.url !== true || socket.url !== 'wss://example.test/socket') {
                throw new Error('readonly url accessor should survive instance delete');
            }
            if (delete socket.bufferedAmount !== true || socket.bufferedAmount !== 0) {
                throw new Error('readonly bufferedAmount accessor should survive instance delete');
            }
            Object.defineProperty(socket, 'readyState', { value: 99 });
            if (socket.readyState !== 99 || !Object.prototype.hasOwnProperty.call(socket, 'readyState')) {
                throw new Error('readyState own data property should shadow the prototype accessor like Chromium');
            }
            Object.defineProperty(socket, 'binaryType', { value: 'arraybuffer' });
            if (socket.binaryType !== 'arraybuffer' || !Object.prototype.hasOwnProperty.call(socket, 'binaryType')) {
                throw new Error('binaryType own data property should shadow the prototype accessor like Chromium');
            }
            return 'ok';
        })()
        "#,
    )
    .expect("target WebSocket interface mutation test should pass once implemented");
}

#[test]
fn websocket_wpt_target_buffered_amount_prototype_mutation_surface() {
    let mut vm = new_storage_test_vm("https://websocket-wpt-target.test/");

    vm.eval(
        r#"
        (() => {
            const socket = new WebSocket('wss://example.test/socket');
            if (socket.bufferedAmount !== 0) {
                throw new Error('bufferedAmount should start at 0');
            }
            socket.bufferedAmount = 5;
            if (socket.bufferedAmount !== 0) {
                throw new Error('bufferedAmount should be readonly through the default accessor');
            }
            delete socket.bufferedAmount;
            if (socket.bufferedAmount !== 0) {
                throw new Error('deleting instance bufferedAmount should preserve prototype getter');
            }
            Object.defineProperty(WebSocket.prototype, 'bufferedAmount', {
                configurable: true,
                get() { return 'getter-ran'; }
            });
            if (socket.bufferedAmount !== 'getter-ran') {
                throw new Error('bufferedAmount getter override should run');
            }
            Object.defineProperty(WebSocket.prototype, 'bufferedAmount', {
                configurable: true,
                set(value) { globalThis[value] = true; }
            });
            socket.bufferedAmount = 'setter_ran';
            if (globalThis.setter_ran !== true) {
                throw new Error('bufferedAmount setter override should run');
            }
            delete WebSocket.prototype.bufferedAmount;
            if (new WebSocket('wss://example.test/socket').bufferedAmount !== undefined) {
                throw new Error('deleted prototype bufferedAmount should expose undefined');
            }
            return 'ok';
        })()
        "#,
    )
    .expect("target WebSocket bufferedAmount prototype mutation test should pass once implemented");
}

#[test]
fn websocket_wpt_target_url_accessor_mutation_and_uppercase_absence() {
    let mut vm = new_storage_test_vm("https://websocket-wpt-target.test/base/page.html");

    vm.eval(
        r#"
        (() => {
            const socket = new WebSocket('/echo');
            if (socket.url !== 'wss://websocket-wpt-target.test/echo') {
                throw new Error(`unexpected url ${socket.url}`);
            }
            socket.url = 'wss://example.test/other';
            if (socket.url !== 'wss://websocket-wpt-target.test/echo') {
                throw new Error('url should be readonly through the default accessor');
            }
            if (socket.URL !== undefined || ('URL' in socket) ||
                WebSocket.prototype.URL !== undefined || ('URL' in WebSocket.prototype)) {
                throw new Error('legacy uppercase URL should not be present');
            }
            delete socket.url;
            if (socket.url !== 'wss://websocket-wpt-target.test/echo') {
                throw new Error('deleting instance url should preserve prototype getter');
            }
            Object.defineProperty(WebSocket.prototype, 'url', {
                configurable: true,
                get() { return 'getter-ran'; }
            });
            if (socket.url !== 'getter-ran') {
                throw new Error('url getter override should run');
            }
            Object.defineProperty(WebSocket.prototype, 'url', {
                configurable: true,
                set(value) { globalThis[value] = true; }
            });
            socket.url = 'setter_ran';
            if (globalThis.setter_ran !== true) {
                throw new Error('url setter override should run');
            }
            delete WebSocket.prototype.url;
            if (new WebSocket('/echo').url !== undefined) {
                throw new Error('deleted prototype url should expose undefined');
            }
            return 'ok';
        })()
        "#,
    )
    .expect("target WebSocket url accessor mutation test should pass once implemented");
}

#[test]
fn websocket_wpt_target_interface_prototype_accessor_override_surface() {
    let mut vm = new_storage_test_vm("https://websocket-wpt-target.test/");

    vm.eval(
        r#"
        (() => {
            Object.defineProperty(WebSocket.prototype, 'readyState', {
                configurable: true,
                get() { return 'ready-override'; },
                set(value) { globalThis.__readySetterValue = value; }
            });
            const first = new WebSocket('wss://example.test/socket');
            if (first.readyState !== 'ready-override') {
                throw new Error('readyState getter override should be observed');
            }
            first.readyState = 'setter-ran';
            if (globalThis.__readySetterValue !== 'setter-ran') {
                throw new Error('readyState setter override should run');
            }
            delete WebSocket.prototype.readyState;
            const second = new WebSocket('wss://example.test/socket');
            if (second.readyState !== undefined) {
                throw new Error('deleted readyState prototype accessor should expose undefined');
            }
            return 'ok';
        })()
        "#,
    )
    .expect("target WebSocket prototype accessor override test should pass once implemented");
}

#[test]
fn websocket_wpt_target_readonly_accessor_override_surface() {
    let mut vm = new_storage_test_vm("https://websocket-wpt-target.test/");

    vm.eval(
        r#"
        (() => {
            for (const [name, value] of [
                ['url', 'url-override'],
                ['bufferedAmount', 'buffered-override'],
                ['extensions', 'extensions-override'],
                ['protocol', 'protocol-override']
            ]) {
                Object.defineProperty(WebSocket.prototype, name, {
                    configurable: true,
                    get() { return value; }
                });
                const socket = new WebSocket('wss://example.test/socket');
                if (socket[name] !== value) {
                    throw new Error(`${name} prototype getter override should be observed`);
                }
                delete WebSocket.prototype[name];
                if (new WebSocket('wss://example.test/socket')[name] !== undefined) {
                    throw new Error(`${name} delete should remove prototype accessor`);
                }
            }
            return 'ok';
        })()
        "#,
    )
    .expect("target WebSocket readonly accessor override test should pass once implemented");
}

#[test]
fn websocket_wpt_target_protocol_extensions_accessor_mutation_surface() {
    let mut vm = new_storage_test_vm("https://websocket-wpt-target.test/");

    vm.eval(
        r#"
        (() => {
            for (const [name, value] of [
                ['protocol', 'protocol-override'],
                ['extensions', 'extensions-override']
            ]) {
                const socket = new WebSocket('wss://example.test/socket');
                if (socket[name] !== '') {
                    throw new Error(`${name} should initially be empty`);
                }
                socket[name] = 'attempted-write';
                if (socket[name] !== '') {
                    throw new Error(`${name} should be readonly through the default accessor`);
                }
                delete socket[name];
                if (socket[name] !== '') {
                    throw new Error(`deleting instance ${name} should preserve prototype getter`);
                }
                Object.defineProperty(WebSocket.prototype, name, {
                    configurable: true,
                    get() { return value; }
                });
                if (socket[name] !== value) {
                    throw new Error(`${name} getter override should run`);
                }
                Object.defineProperty(WebSocket.prototype, name, {
                    configurable: true,
                    set(input) { globalThis[`${name}_${input}`] = true; }
                });
                socket[name] = 'setter';
                if (globalThis[`${name}_setter`] !== true) {
                    throw new Error(`${name} setter override should run`);
                }
                delete WebSocket.prototype[name];
                if (new WebSocket('wss://example.test/socket')[name] !== undefined) {
                    throw new Error(`deleted prototype ${name} should expose undefined`);
                }
            }
            return 'ok';
        })()
        "#,
    )
    .expect("target WebSocket protocol/extensions mutation test should pass once implemented");
}

#[test]
fn websocket_wpt_target_url_and_protocol_initial_surface() {
    let mut vm = new_storage_test_vm("https://websocket-wpt-target.test/base/page.html");

    let result = vm
        .eval(
            r#"
            (() => {
                const absolute = new WebSocket('wss://example.test/socket');
                const relative = new WebSocket('/relative');
                const requestedProtocol = new WebSocket('wss://example.test/socket', 'chat');
                return [
                    absolute.url,
                    relative.url,
                    absolute.protocol,
                    requestedProtocol.protocol
                ].join('|');
            })()
            "#,
        )
        .expect("target WebSocket url/protocol initial surface test should evaluate");

    assert_eq!(
        result,
        "wss://example.test/socket|wss://websocket-wpt-target.test/relative||"
    );
}

#[test]
fn websocket_wpt_target_binary_type_accessor_surface() {
    let mut vm = new_storage_test_vm("https://websocket-wpt-target.test/");

    vm.eval(
        r#"
        (() => {
            const descriptor = Object.getOwnPropertyDescriptor(WebSocket.prototype, 'binaryType');
            if (!descriptor || typeof descriptor.get !== 'function' || typeof descriptor.set !== 'function') {
                throw new Error('binaryType should be a prototype accessor pair');
            }
            if (descriptor.enumerable !== true || descriptor.configurable !== true) {
                throw new Error('binaryType descriptor shape should match Web IDL');
            }
            const socket = new WebSocket('wss://example.test/socket');
            if (socket.binaryType !== 'blob') {
                throw new Error('binaryType should initially be blob');
            }
            socket.binaryType = 'arraybuffer';
            if (socket.binaryType !== 'arraybuffer') {
                throw new Error('binaryType should accept arraybuffer');
            }
            let invalidDidThrow = (() => {
                try {
                    socket.binaryType = 'notBlobOrArrayBuffer';
                    return false;
                } catch (error) {
                    if (error?.name !== 'SyntaxError') {
                        throw error;
                    }
                    return true;
                }
            })();
            if (!invalidDidThrow) {
                throw new Error('invalid binaryType assignments should throw SyntaxError');
            }
            if (socket.binaryType !== 'arraybuffer') {
                throw new Error('invalid binaryType assignments should preserve the previous value');
            }
            Object.defineProperty(WebSocket.prototype, 'binaryType', {
                configurable: true,
                get() { return 'binary-override'; },
                set(value) { globalThis.__binaryTypeSetter = value; }
            });
            const overridden = new WebSocket('wss://example.test/socket');
            if (overridden.binaryType !== 'binary-override') {
                throw new Error('binaryType prototype getter override should be observed');
            }
            overridden.binaryType = 'setter-ran';
            if (globalThis.__binaryTypeSetter !== 'setter-ran') {
                throw new Error('binaryType prototype setter override should run');
            }
            delete WebSocket.prototype.binaryType;
            if (new WebSocket('wss://example.test/socket').binaryType !== undefined) {
                throw new Error('deleted binaryType prototype accessor should expose undefined');
            }
            return 'ok';
        })()
        "#,
    )
    .expect("target WebSocket binaryType accessor surface test should pass once implemented");
}

#[test]
fn websocket_wpt_target_constants_readonly_nonconfigurable_surface() {
    let mut vm = new_storage_test_vm("https://websocket-wpt-target.test/");

    vm.eval(
        r#"
        (() => {
            const socket = new WebSocket('wss://example.test/socket');
            const constants = ['CONNECTING', 'OPEN', 'CLOSING', 'CLOSED'];
            for (let i = 0; i < constants.length; i++) {
                const name = constants[i];
                if (WebSocket[name] !== i) {
                    throw new Error(`WebSocket.${name} should be ${i}`);
                }
                if (WebSocket.prototype[name] !== i) {
                    throw new Error(`WebSocket.prototype.${name} should be ${i}`);
                }
                if (socket[name] !== i) {
                    throw new Error(`socket.${name} should inherit ${i}`);
                }
                const ctorDescriptor = Object.getOwnPropertyDescriptor(WebSocket, name);
                const protoDescriptor = Object.getOwnPropertyDescriptor(WebSocket.prototype, name);
                for (const descriptor of [ctorDescriptor, protoDescriptor]) {
                    if (!descriptor || descriptor.value !== i || descriptor.writable !== false ||
                        descriptor.enumerable !== true || descriptor.configurable !== false) {
                        throw new Error(`${name} descriptor should be readonly and non-configurable`);
                    }
                }
                WebSocket[name] = 5;
                WebSocket.prototype[name] = 5;
                socket[name] = 5;
                delete WebSocket[name];
                delete WebSocket.prototype[name];
                delete socket[name];
                if (WebSocket[name] !== i || WebSocket.prototype[name] !== i || socket[name] !== i) {
                    throw new Error(`${name} should survive assignment and delete`);
                }
                try {
                    Object.defineProperty(WebSocket.prototype, name, { get() { return 'override'; } });
                    throw new Error(`${name} defineProperty getter should throw`);
                } catch (error) {
                    if (!(error instanceof TypeError)) throw error;
                }
                try {
                    Object.defineProperty(WebSocket.prototype, name, { set() {} });
                    throw new Error(`${name} defineProperty setter should throw`);
                } catch (error) {
                    if (!(error instanceof TypeError)) throw error;
                }
            }
            return 'ok';
        })()
        "#,
    )
    .expect("target WebSocket constants surface test should pass once implemented");
}

#[test]
fn websocket_wpt_target_method_replacement_surface() {
    let mut vm = new_storage_test_vm("https://websocket-wpt-target.test/");

    vm.eval(
        r#"
        (() => {
            const socket = new WebSocket('wss://example.test/socket');
            for (const name of ['send', 'close']) {
                const descriptor = Object.getOwnPropertyDescriptor(WebSocket.prototype, name);
                if (!descriptor || typeof descriptor.value !== 'function') {
                    throw new Error(`${name} should be a prototype function`);
                }
                if (descriptor.writable !== true || descriptor.enumerable !== true ||
                    descriptor.configurable !== true) {
                    throw new Error(`${name} descriptor should match Web IDL operations`);
                }
                socket[name] = 5;
                if (socket[name] !== 5) {
                    throw new Error(`${name} should be replaceable on the instance`);
                }
                delete socket[name];
                if (typeof socket[name] !== 'function') {
                    throw new Error(`${name} should fall back to prototype after delete`);
                }
            }
            const closeResult = socket.close();
            if (closeResult !== undefined) {
                throw new Error('close() should return undefined');
            }
            return 'ok';
        })()
        "#,
    )
    .expect("target WebSocket method replacement test should pass once implemented");
}

#[test]
fn websocket_wpt_target_event_handler_object_assignment_surface() {
    let mut vm = new_storage_test_vm("https://websocket-wpt-target.test/");

    vm.eval(
        r#"
        (() => {
            const socket = new WebSocket('wss://example.test/socket');
            for (const name of ['onopen', 'onmessage', 'onerror', 'onclose']) {
                let called = false;
                const handler = { handleEvent() { called = true; } };
                socket[name] = handler;
                if (socket[name] !== handler) {
                    throw new Error(`${name} should retain object handler value`);
                }
                socket.dispatchEvent(new Event(name.slice(2)));
                if (called) {
                    throw new Error(`${name} object handler should not call handleEvent`);
                }
                socket[name] = undefined;
                if (socket[name] !== null) {
                    throw new Error(`${name} should clear to null when set to undefined`);
                }
            }
            return 'ok';
        })()
        "#,
    )
    .expect("target WebSocket event handler object assignment test should pass once implemented");
}

#[test]
fn websocket_wpt_target_websocket_stream_surface_is_accounted_for() {
    let mut vm = new_storage_test_vm("https://websocket-wpt-target.test/");

    let result = vm
        .eval("String(typeof WebSocketStream === 'function')")
        .expect("target WebSocketStream inventory test should evaluate");

    assert_eq!(result, "true");
}

#[test]
fn websocket_wpt_target_websocket_stream_constructor_surface() {
    let mut vm = new_storage_test_vm("https://websocket-wpt-target.test/");

    let result = vm
        .eval(
            r#"
            (() => {
                const stream = new WebSocketStream('wss://example.test/socket');
                return [
                    stream instanceof WebSocketStream,
                    typeof stream.url,
                    stream.opened instanceof Promise,
                    stream.closed instanceof Promise,
                    typeof stream.close,
                    String(stream.close())
                ].join('|');
            })()
            "#,
        )
        .expect("target WebSocketStream constructor surface test should evaluate");

    assert_eq!(result, "true|string|true|true|function|undefined");
}

#[test]
fn websocket_stream_backing_slots_ignore_reflection_and_spoofing() {
    let mut vm = new_storage_test_vm("https://websocket-private-slots.test/");

    let result = vm
        .eval(
            r#"
            (() => {
                const stream = new WebSocketStream('wss://example.test/socket');
                const opened = stream.opened;
                const closed = stream.closed;
                const internalNamesBefore = Object.getOwnPropertyNames(stream)
                    .filter(name => name.startsWith('__moliWebSocketStream'))
                    .sort();
                stream.__moliWebSocketStreamUrl = 'wss://spoofed.test/';
                stream.__moliWebSocketStreamOpened = Promise.resolve('fake-opened');
                stream.__moliWebSocketStreamClosed = Promise.resolve('fake-closed');
                stream.__moliWebSocketStreamOpenedResolve = () => {};
                stream.__moliWebSocketStreamOpenedReject = () => {};
                stream.__moliWebSocketStreamClosedResolve = () => {};
                stream.__moliWebSocketStreamClosedReject = () => {};
                const fake = { __moliWebSocketStreamUrl: 'wss://fake.test/' };
                const descriptorReport = name => {
                    const descriptor = Object.getOwnPropertyDescriptor(WebSocketStream.prototype, name);
                    return [
                        name,
                        typeof descriptor?.get,
                        descriptor?.get?.name,
                        descriptor?.get?.length,
                        typeof descriptor?.set,
                        descriptor?.enumerable,
                        descriptor?.configurable
                    ].join(':');
                };
                const urlDescriptor = Object.getOwnPropertyDescriptor(WebSocketStream.prototype, 'url');
                const openedDescriptor = Object.getOwnPropertyDescriptor(WebSocketStream.prototype, 'opened');
                const closedDescriptor = Object.getOwnPropertyDescriptor(WebSocketStream.prototype, 'closed');
                return JSON.stringify({
                    internalNamesBefore,
                    descriptors: [
                        descriptorReport('url'),
                        descriptorReport('opened'),
                        descriptorReport('closed')
                    ],
                    url: stream.url,
                    openedSame: stream.opened === opened,
                    closedSame: stream.closed === closed,
                    fakeUrl: urlDescriptor.get.call(fake),
                    fakeOpened: String(openedDescriptor.get.call(fake)),
                    fakeClosed: String(closedDescriptor.get.call(fake))
                });
            })()
            "#,
        )
        .expect("WebSocketStream private slot spoofing test should evaluate");

    assert_eq!(
        result,
        r#"{"internalNamesBefore":[],"descriptors":["url:function:get url:0:undefined:true:true","opened:function:get opened:0:undefined:true:true","closed:function:get closed:0:undefined:true:true"],"url":"wss://example.test/socket","openedSame":true,"closedSame":true,"fakeUrl":"","fakeOpened":"undefined","fakeClosed":"undefined"}"#
    );
}

#[test]
fn websocket_wpt_target_websocket_stream_loopback_websocket_is_allowed_from_secure_context() {
    let mut vm = new_storage_test_vm("https://websocket-wpt-target.test/");

    let result = vm
        .eval(
            r#"
            (() => {
                const stream = new WebSocketStream('ws://127.0.0.1/socket');
                return stream.url;
            })()
            "#,
        )
        .expect("target WebSocketStream loopback mixed-content exemption test should evaluate");

    assert_eq!(result, "ws://127.0.0.1/socket");
}

#[test]
fn websocket_wpt_target_websocket_error_constructor_surface() {
    let mut vm = new_storage_test_vm("https://websocket-wpt-target.test/");

    let result = vm
        .eval(
            r#"
            (() => {
                function outcome(callback) {
                    try {
                        callback();
                        return 'ok';
                    } catch (error) {
                        return `${error && error.name}:${error instanceof DOMException}`;
                    }
                }
                const defaults = new WebSocketError();
                const full = new WebSocketError('message', { closeCode: 3456, reason: 'reason' });
                const codeOnly = new WebSocketError('', { closeCode: 3333 });
                const reasonOnly = new WebSocketError('', { reason: 'specified' });
                const closeCodeDescriptor =
                    Object.getOwnPropertyDescriptor(WebSocketError.prototype, 'closeCode');
                const reasonDescriptor =
                    Object.getOwnPropertyDescriptor(WebSocketError.prototype, 'reason');
                return [
                    typeof WebSocketError,
                    defaults instanceof DOMException,
                    defaults instanceof WebSocketError,
                    Object.prototype.toString.call(defaults),
                    defaults.name,
                    defaults.message,
                    String(defaults.code),
                    String(defaults.closeCode),
                    defaults.reason,
                    full.message,
                    String(full.closeCode),
                    full.reason,
                    String(codeOnly.closeCode),
                    codeOnly.reason,
                    String(reasonOnly.closeCode),
                    reasonOnly.reason,
                    typeof closeCodeDescriptor.get,
                    closeCodeDescriptor.get.name,
                    String(closeCodeDescriptor.get.length),
                    String(closeCodeDescriptor.set === undefined),
                    String(closeCodeDescriptor.enumerable),
                    String(closeCodeDescriptor.configurable),
                    typeof reasonDescriptor.get,
                    reasonDescriptor.get.name,
                    String(reasonDescriptor.get.length),
                    String(reasonDescriptor.set === undefined),
                    String(reasonDescriptor.enumerable),
                    String(reasonDescriptor.configurable),
                    String(Object.getPrototypeOf(WebSocketError.prototype) === DOMException.prototype),
                    String(Object.prototype.hasOwnProperty.call(defaults, 'message')),
                    String(Object.prototype.hasOwnProperty.call(defaults, 'closeCode')),
                    String(new DOMException('message', 'WebSocketError') instanceof WebSocketError),
                    outcome(() => Reflect.get(WebSocketError.prototype, 'closeCode')),
                    outcome(() => Reflect.get(WebSocketError.prototype, 'reason')),
                    outcome(() => new WebSocketError('', { closeCode: 1005 })),
                    outcome(() => new WebSocketError('', { closeCode: 1000, reason: 'x'.repeat(124) })),
                    outcome(() => new WebSocketError('', { reason: '\u{1f50c}'.repeat(32) })),
                ].join('|');
            })()
            "#,
        )
        .expect("target WebSocketError constructor surface test should evaluate");

    assert_eq!(
        result,
        "function|true|true|[object WebSocketError]|WebSocketError||0|null||message|3456|reason|3333||1000|specified|function|get closeCode|0|true|true|true|function|get reason|0|true|true|true|true|false|false|false|TypeError:false|TypeError:false|InvalidAccessError:true|SyntaxError:true|SyntaxError:true"
    );
}

#[test]
fn websocket_wpt_target_websocket_stream_options_validation_surface() {
    let mut vm = new_storage_test_vm("https://websocket-wpt-target.test/base/page.html");

    let result = vm
        .eval(
            r#"
            (() => {
                function outcome(callback) {
                    try {
                        callback();
                        return 'ok';
                    } catch (error) {
                        return `${error && error.name}:${String(error && error.message).includes('WebSocketStream')}`;
                    }
                }
                const iterable = {
                    *[Symbol.iterator]() {
                        yield 'alpha';
                        yield 'beta';
                    }
                };
                const validArray = new WebSocketStream('/array', { protocols: ['alpha', 'beta'] });
                const validIterable = new WebSocketStream('/iterable', { protocols: iterable });
                const noProtocols = new WebSocketStream('/none', {});
                return [
                    outcome(() => new WebSocketStream()),
                    outcome(() => new WebSocketStream('/ok', true)),
                    outcome(() => new WebSocketStream('/ok', { protocols: 'chat' })),
                    outcome(() => new WebSocketStream('/ok', { protocols: ['bad protocol'] })),
                    outcome(() => new WebSocketStream('/ok', { protocols: ['chat', 'CHAT'] })),
                    validArray.url,
                    validArray.opened instanceof Promise,
                    validIterable.url,
                    noProtocols.url,
                ].join('|');
            })()
            "#,
        )
        .expect("target WebSocketStream options validation surface test should evaluate");

    assert_eq!(
        result,
        "TypeError:true|TypeError:true|TypeError:true|SyntaxError:true|SyntaxError:true|wss://websocket-wpt-target.test/array|true|wss://websocket-wpt-target.test/iterable|wss://websocket-wpt-target.test/none"
    );
}

#[test]
fn websocket_wpt_target_websocket_stream_close_info_validation_surface() {
    let mut vm = new_storage_test_vm("https://websocket-wpt-target.test/");

    let result = vm
        .eval(
            r#"
            (() => {
                const stream = new WebSocketStream('wss://example.test/socket');
                function outcome(callback) {
                    try {
                        callback();
                        return 'ok';
                    } catch (error) {
                        return `${error && error.name}:${error instanceof DOMException}`;
                    }
                }
                return [
                    String(stream.close()),
                    outcome(() => stream.close({})),
                    outcome(() => stream.close({ closeCode: 3456, reason: 'pizza' })),
                    outcome(() => stream.close({ reason: 'non-empty' })),
                    outcome(() => stream.close(true)),
                    outcome(() => stream.close({ reason: '.'.repeat(124) })),
                    outcome(() => stream.close({ closeCode: 999 })),
                    outcome(() => stream.close({ closeCode: 1001 })),
                    outcome(() => stream.close({ closeCode: 2999 })),
                    outcome(() => stream.close({ closeCode: 5000 })),
                ].join('|');
            })()
            "#,
        )
        .expect("target WebSocketStream close info validation surface test should evaluate");

    assert_eq!(
        result,
        "undefined|ok|ok|ok|TypeError:false|SyntaxError:true|InvalidAccessError:true|InvalidAccessError:true|InvalidAccessError:true|InvalidAccessError:true"
    );
}

#[test]
fn readable_stream_pending_read_resolves_on_future_enqueue() {
    let mut vm = new_storage_test_vm("https://stream-runtime.test/");

    let initial = vm
        .eval(
            r#"
            (() => {
                globalThis.__streamEvents = [];
                const stream = new ReadableStream({
                    start(controller) {
                        globalThis.__streamController = controller;
                    }
                });
                const reader = stream.getReader();
                reader.read().then(({ value, done }) => {
                    globalThis.__streamEvents.push(`${value}:${done}`);
                });
                return JSON.stringify(globalThis.__streamEvents);
            })()
            "#,
        )
        .expect("pending stream read setup should evaluate");
    assert_eq!(initial, "[]");

    vm.eval(
        r#"
            (() => {
                globalThis.__streamController.enqueue('future');
                return JSON.stringify(globalThis.__streamEvents);
            })()
            "#,
    )
    .expect("future stream enqueue should evaluate");
    let after_enqueue = vm
        .eval("JSON.stringify(globalThis.__streamEvents)")
        .expect("future stream enqueue microtask should settle");
    assert_eq!(after_enqueue, r#"["future:false"]"#);
}

#[test]
fn readable_stream_pending_read_resolves_done_on_future_close() {
    let mut vm = new_storage_test_vm("https://stream-runtime.test/");

    let initial = vm
        .eval(
            r#"
            (() => {
                globalThis.__streamEvents = [];
                const stream = new ReadableStream({
                    start(controller) {
                        globalThis.__streamController = controller;
                    }
                });
                const reader = stream.getReader();
                reader.read().then(({ value, done }) => {
                    globalThis.__streamEvents.push(`${String(value)}:${done}`);
                });
                return JSON.stringify(globalThis.__streamEvents);
            })()
            "#,
        )
        .expect("pending stream read setup should evaluate");
    assert_eq!(initial, "[]");

    vm.eval(
        r#"
            (() => {
                globalThis.__streamController.close();
                return JSON.stringify(globalThis.__streamEvents);
            })()
            "#,
    )
    .expect("future stream close should evaluate");
    let after_close = vm
        .eval("JSON.stringify(globalThis.__streamEvents)")
        .expect("future stream close microtask should settle");
    assert_eq!(after_close, r#"["undefined:true"]"#);
}

#[test]
fn readable_stream_async_iterator_return_honors_prevent_cancel() {
    let mut vm = new_storage_test_vm("https://stream-runtime.test/");

    let initial = vm
        .eval(
            r#"
            (() => {
                globalThis.__streamEvents = [];
                const defaultStream = new ReadableStream({
                    start(controller) {
                        controller.enqueue('default-queued');
                    },
                    cancel(reason) {
                        globalThis.__streamEvents.push(`default-cancel:${reason}`);
                    }
                });
                const defaultIterator = defaultStream.values();
                defaultIterator.return('stop').then(({ value, done }) => {
                    globalThis.__streamEvents.push(`default-return:${String(value)}:${done}:${defaultStream.locked}`);
                });
                defaultIterator.next().then(({ value, done }) => {
                    globalThis.__streamEvents.push(`default-next-after-return:${String(value)}:${done}`);
                });

                const keptStream = new ReadableStream({
                    start(controller) {
                        controller.enqueue('kept-queued');
                    },
                    cancel(reason) {
                        globalThis.__streamEvents.push(`kept-cancel:${reason}`);
                    }
                });
                const keptIterator = keptStream.values({
                    get preventCancel() {
                        globalThis.__streamEvents.push('prevent-get');
                        return true;
                    }
                });
                keptIterator.return('keep').then(({ value, done }) => {
                    globalThis.__streamEvents.push(`kept-return:${String(value)}:${done}:${keptStream.locked}`);
                });
                keptIterator.next().then(({ value, done }) => {
                    globalThis.__streamEvents.push(`kept-next-after-return:${String(value)}:${done}`);
                });
                globalThis.__keptStream = keptStream;
                return JSON.stringify(globalThis.__streamEvents);
            })()
            "#,
        )
        .expect("readable stream async iterator return setup should evaluate");
    assert_eq!(initial, r#"["default-cancel:stop","prevent-get"]"#);

    let after_return = vm
        .eval("JSON.stringify(globalThis.__streamEvents)")
        .expect("readable stream async iterator return promises should settle");
    assert_eq!(
        after_return,
        r#"["default-cancel:stop","prevent-get","kept-return:keep:true:false","kept-next-after-return:undefined:true","default-return:stop:true:false","default-next-after-return:undefined:true"]"#
    );

    vm.eval(
        r#"
            (() => {
                globalThis.__keptStream.getReader().read().then(({ value, done }) => {
                    globalThis.__streamEvents.push(`kept-read-after-return:${value}:${done}`);
                });
                return JSON.stringify(globalThis.__streamEvents);
            })()
            "#,
    )
    .expect("preventCancel stream read should evaluate");
    let after_read = vm
        .eval("JSON.stringify(globalThis.__streamEvents)")
        .expect("preventCancel stream read promise should settle");
    assert_eq!(
        after_read,
        r#"["default-cancel:stop","prevent-get","kept-return:keep:true:false","kept-next-after-return:undefined:true","default-return:stop:true:false","default-next-after-return:undefined:true","kept-read-after-return:kept-queued:false"]"#
    );

    let non_object = vm
        .eval(
            r#"
            (() => {
                try {
                    new ReadableStream().values(1);
                    return 'ok';
                } catch (error) {
                    return `${error.name}:${error instanceof TypeError}`;
                }
            })()
            "#,
        )
        .expect("readable stream values non-object options should evaluate");
    assert_eq!(non_object, "TypeError:true");
}

#[test]
fn readable_stream_async_iterator_serializes_operations_and_waits_for_cancel() {
    let mut vm = new_storage_test_vm("https://stream-runtime.test/");

    let initial = vm
        .eval(
            r#"
            (() => {
                globalThis.__iteratorOwnerEvents = [];
                globalThis.__iteratorOwnerResult = "pending";
                let resolveCancel;
                const delayed = new ReadableStream({
                    cancel(reason) {
                        globalThis.__iteratorOwnerEvents.push(`cancel:${reason}`);
                        return new Promise(resolve => { resolveCancel = resolve; });
                    }
                });
                const delayedIterator = delayed.values();
                const returned = delayedIterator.return('stop').then(result => {
                    globalThis.__iteratorOwnerEvents.push(`return:${result.value}:${result.done}`);
                    return result;
                });
                const next = delayedIterator.next().then(result => {
                    globalThis.__iteratorOwnerEvents.push(`next:${String(result.value)}:${result.done}`);
                    return result;
                });
                globalThis.__iteratorOwnerEvents.push(`locked:${delayed.locked}`);

                let pulls = 0;
                const error = { name: 'iterator-error' };
                const errored = new ReadableStream({
                    pull(controller) {
                        if (pulls++ === 0) controller.enqueue(0);
                        else controller.error(error);
                    }
                });
                const erroredIterator = errored.values();
                const ordered = Promise.allSettled([
                    erroredIterator.next(),
                    erroredIterator.next(),
                    erroredIterator.next(),
                    erroredIterator.return('after-error')
                ]);

                Promise.all([returned, next, ordered]).then(([, , results]) => {
                    globalThis.__iteratorOwnerResult = JSON.stringify({
                        events: globalThis.__iteratorOwnerEvents,
                        results: results.map(result => result.status === 'rejected'
                            ? `rejected:${result.reason === error}`
                            : `fulfilled:${String(result.value.value)}:${result.value.done}`)
                    });
                });
                globalThis.__resolveIteratorCancel = resolveCancel;
                return JSON.stringify(globalThis.__iteratorOwnerEvents);
            })()
            "#,
        )
        .expect("async iterator owner setup should evaluate");
    assert_eq!(initial, r#"["cancel:stop","locked:false"]"#);

    let pending = vm
        .eval("globalThis.__iteratorOwnerResult")
        .expect("pending async iterator owner result should evaluate");
    assert_eq!(pending, "pending");

    vm.eval("globalThis.__resolveIteratorCancel()")
        .expect("delayed iterator cancel should resolve");
    for _ in 0..8 {
        let result = vm
            .eval("globalThis.__iteratorOwnerResult")
            .expect("async iterator owner promises should drain");
        if result != "pending" {
            break;
        }
    }
    let result = vm
        .eval("globalThis.__iteratorOwnerResult")
        .expect("async iterator owner result should evaluate");
    assert_eq!(
        result,
        r#"{"events":["cancel:stop","locked:false","return:stop:true","next:undefined:true"],"results":["fulfilled:0:false","rejected:true","fulfilled:undefined:true","fulfilled:after-error:true"]}"#
    );
}

#[test]
fn readable_stream_async_iterator_declared_shape_keeps_symbol_and_tag() {
    let mut vm = new_storage_test_vm("https://stream-runtime.test/");

    let result = vm
        .eval(
            r#"
            (() => {
                const internalNames = () => Object.getOwnPropertyNames(globalThis)
                    .filter(name => name === "__moliReadableStreamAsyncIteratorPrototype")
                    .join(",");
                const globalNamesBefore = internalNames();
                const stream = new ReadableStream({
                    start(controller) {
                        controller.enqueue("queued");
                    }
                });
                const iterator = stream.values({ preventCancel: true });
                const prototype = Object.getPrototypeOf(iterator);
                const intrinsicAsyncIteratorPrototype =
                    Object.getPrototypeOf(Object.getPrototypeOf(async function*() {}).prototype);
                const asyncDescriptor = Object.getOwnPropertyDescriptor(
                    intrinsicAsyncIteratorPrototype,
                    Symbol.asyncIterator
                );
                const tagDescriptor = Object.getOwnPropertyDescriptor(prototype, Symbol.toStringTag);
                const ownSymbols = Object.getOwnPropertySymbols(iterator).map(symbol => {
                    if (symbol === Symbol.asyncIterator) return "Symbol.asyncIterator";
                    return String(symbol);
                });
                const globalNamesAfterCache = internalNames();
                Object.defineProperty(globalThis, "__moliReadableStreamAsyncIteratorPrototype", {
                    configurable: true,
                    value: { spoofed: true }
                });
                const globalNamesAfterSpoof = internalNames();
                const iteratorAfterSpoof = new ReadableStream().values();
                return JSON.stringify({
                    toString: Object.prototype.toString.call(iterator),
                    asyncIteratorReturnsSelf: iterator[Symbol.asyncIterator]() === iterator,
                    globalNamesBefore,
                    globalNamesAfterCache,
                    globalNamesAfterSpoof,
                    ownNames: Object.getOwnPropertyNames(iterator),
                    ownSymbols,
                    leaksReader: "__moliReadableStreamIteratorReader" in iterator,
                    leaksClosed: "__moliReadableStreamIteratorClosed" in iterator,
                    leaksPreventCancel: "__moliReadableStreamIteratorPreventCancel" in iterator,
                    asyncDescriptor: [
                        asyncDescriptor.enumerable,
                        asyncDescriptor.writable,
                        asyncDescriptor.configurable,
                        asyncDescriptor.value.length
                    ].join(","),
                    prototypeParentIsIntrinsic:
                        Object.getPrototypeOf(prototype) === intrinsicAsyncIteratorPrototype,
                    prototypeStableAfterSpoof:
                        Object.getPrototypeOf(iteratorAfterSpoof) === prototype,
                    prototypeNames: Object.getOwnPropertyNames(prototype).sort(),
                    prototypeHasConstructor: Object.hasOwn(prototype, "constructor"),
                    tagDescriptor: [
                        tagDescriptor.enumerable,
                        tagDescriptor.writable,
                        tagDescriptor.configurable,
                        tagDescriptor.value
                    ].join(",")
                });
            })()
            "#,
        )
        .expect("readable stream async iterator declared shape should evaluate");

    assert_eq!(
        result,
        r#"{"toString":"[object ReadableStream AsyncIterator]","asyncIteratorReturnsSelf":true,"globalNamesBefore":"","globalNamesAfterCache":"","globalNamesAfterSpoof":"__moliReadableStreamAsyncIteratorPrototype","ownNames":[],"ownSymbols":[],"leaksReader":false,"leaksClosed":false,"leaksPreventCancel":false,"asyncDescriptor":"false,true,true,0","prototypeParentIsIntrinsic":true,"prototypeStableAfterSpoof":true,"prototypeNames":["next","return"],"prototypeHasConstructor":false,"tagDescriptor":"false,false,true,ReadableStream AsyncIterator"}"#
    );
}