Something went wrong. Try again.
we (web engine): Experimental web browser project to understand the limits of Claude
Something went wrong. Try again.
Rust
at url-parser
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305//! Test262 test harness.//!//! Walks the Test262 test suite and runs each test case against our JavaScript//! engine. Reports pass/fail/skip counts.//!//! Run with: `cargo test -p we-js --test test262`
/// Workspace root relative to the crate directory.const WORKSPACE_ROOT: &str = concat!(env!("CARGO_MANIFEST_DIR"), "/../../");
/// Metadata extracted from a Test262 test file's YAML frontmatter.struct TestMeta { /// If true, the test expects a parse/early error. negative_phase_parse: bool, /// If true, the test expects a runtime error. negative_phase_runtime: bool, /// The expected error type for negative tests (e.g. "SyntaxError"). negative_type: Option<String>, /// If true, this is an async test. is_async: bool, /// If true, this test should be run as a module. is_module: bool, /// If true, skip the harness preamble. is_raw: bool, /// Required features. features: Vec<String>, /// Required harness includes. includes: Vec<String>,}
impl TestMeta { fn should_skip(&self) -> bool { // Skip async tests and module tests for now. self.is_async || self.is_module }}
/// Parse the YAML-ish frontmatter from a Test262 test file.////// The frontmatter is between `/*---` and `---*/`.fn parse_frontmatter(source: &str) -> TestMeta { let mut meta = TestMeta { negative_phase_parse: false, negative_phase_runtime: false, negative_type: None, is_async: false, is_module: false, is_raw: false, features: Vec::new(), includes: Vec::new(), };
let start = match source.find("/*---") { Some(i) => i + 5, None => return meta, }; let end = match source[start..].find("---*/") { Some(i) => start + i, None => return meta, }; let yaml = &source[start..end];
// Very simple line-by-line YAML extraction. let mut in_negative = false; let mut in_features = false; let mut in_includes = false; let mut in_flags = false;
for line in yaml.lines() { let trimmed = line.trim();
// Detect top-level keys (not indented or with specific indent). if !trimmed.is_empty() && !trimmed.starts_with('-') && !line.starts_with(' ') { in_negative = false; in_features = false; in_includes = false; in_flags = false; }
if trimmed.starts_with("negative:") { in_negative = true; continue; } if trimmed.starts_with("features:") { in_features = true; // Check for inline list: features: [a, b] if let Some(rest) = trimmed.strip_prefix("features:") { let rest = rest.trim(); if rest.starts_with('[') && rest.ends_with(']') { let inner = &rest[1..rest.len() - 1]; for item in inner.split(',') { let item = item.trim(); if !item.is_empty() { meta.features.push(item.to_string()); } } in_features = false; } } continue; } if trimmed.starts_with("includes:") { in_includes = true; if let Some(rest) = trimmed.strip_prefix("includes:") { let rest = rest.trim(); if rest.starts_with('[') && rest.ends_with(']') { let inner = &rest[1..rest.len() - 1]; for item in inner.split(',') { let item = item.trim(); if !item.is_empty() { meta.includes.push(item.to_string()); } } in_includes = false; } } continue; } if trimmed.starts_with("flags:") { in_flags = true; if let Some(rest) = trimmed.strip_prefix("flags:") { let rest = rest.trim(); if rest.starts_with('[') && rest.ends_with(']') { let inner = &rest[1..rest.len() - 1]; for item in inner.split(',') { let flag = item.trim(); match flag { "async" => meta.is_async = true, "module" => meta.is_module = true, "raw" => meta.is_raw = true, _ => {} } } in_flags = false; } } continue; }
// Handle list items under current key. if let Some(item) = trimmed.strip_prefix("- ") { if in_features { meta.features.push(item.to_string()); } else if in_includes { meta.includes.push(item.to_string()); } else if in_flags { match item { "async" => meta.is_async = true, "module" => meta.is_module = true, "raw" => meta.is_raw = true, _ => {} } } continue; }
// Handle sub-keys under negative. if in_negative { if let Some(rest) = trimmed.strip_prefix("phase:") { let phase = rest.trim(); match phase { "parse" | "early" => meta.negative_phase_parse = true, "runtime" | "resolution" => meta.negative_phase_runtime = true, _ => {} } } if let Some(rest) = trimmed.strip_prefix("type:") { meta.negative_type = Some(rest.trim().to_string()); } } }
meta}
/// Recursively collect all `.js` test files under a directory.fn collect_test_files(dir: &std::path::Path, files: &mut Vec<std::path::PathBuf>) { let entries = match std::fs::read_dir(dir) { Ok(e) => e, Err(_) => return, }; let mut entries: Vec<_> = entries.filter_map(|e| e.ok()).collect(); entries.sort_by_key(|e| e.file_name());
for entry in entries { let path = entry.path(); if path.is_dir() { collect_test_files(&path, files); } else if path.extension().map_or(false, |e| e == "js") { // Skip _FIXTURE files (test helpers, not tests themselves). let name = path.file_name().unwrap().to_string_lossy(); if !name.contains("_FIXTURE") { files.push(path); } } }}
/// Run a single Test262 test file. Returns (pass, fail, skip).fn run_test(path: &std::path::Path) -> (usize, usize, usize) { let source = match std::fs::read_to_string(path) { Ok(s) => s, Err(_) => return (0, 0, 1), };
let meta = parse_frontmatter(&source);
if meta.should_skip() { return (0, 0, 1); }
// For negative parse tests, if our evaluate returns an error, that's a pass. // For positive tests, evaluate should succeed (return Ok). let result = we_js::evaluate(&source);
if meta.negative_phase_parse { // We expect a parse error. If our engine returns any error, count as pass. match result { Err(_) => (1, 0, 0), Ok(()) => (0, 1, 0), } } else { // We expect success. match result { Ok(()) => (1, 0, 0), Err(_) => (0, 1, 0), } }}
#[test]fn test262_language_tests() { let test_dir = std::path::PathBuf::from(WORKSPACE_ROOT).join("tests/test262/test/language");
if !test_dir.exists() { eprintln!( "test262 submodule not checked out at {}", test_dir.display() ); eprintln!("Run: git submodule update --init tests/test262"); return; }
let mut files = Vec::new(); collect_test_files(&test_dir, &mut files);
let mut total_pass = 0; let mut total_fail = 0; let mut total_skip = 0;
// Group results by top-level subdirectory for reporting. let mut current_group = String::new(); let mut group_pass = 0; let mut group_fail = 0; let mut group_skip = 0;
for path in &files { // Determine the top-level group (e.g. "expressions", "literals"). let rel = path.strip_prefix(&test_dir).unwrap_or(path); let group = rel .components() .next() .map(|c| c.as_os_str().to_string_lossy().to_string()) .unwrap_or_default();
if group != current_group { if !current_group.is_empty() { eprintln!( " {}: {} pass, {} fail, {} skip", current_group, group_pass, group_fail, group_skip ); } current_group = group; group_pass = 0; group_fail = 0; group_skip = 0; }
let (p, f, s) = run_test(path); group_pass += p; group_fail += f; group_skip += s; total_pass += p; total_fail += f; total_skip += s; }
// Print last group. if !current_group.is_empty() { eprintln!( " {}: {} pass, {} fail, {} skip", current_group, group_pass, group_fail, group_skip ); }
eprintln!(); eprintln!( "Test262 language totals: {} pass, {} fail, {} skip ({} total)", total_pass, total_fail, total_skip, total_pass + total_fail + total_skip );}