html tests

.gitignore

···
 
 # Opam local switch
 _opam/
+*.html

test/dune

···
+(library
+ (name test_report)
+ (modules test_report))
+
+(executable
+ (name test_all)
+ (modules test_all)
+ (libraries bytesrw html5rw.parser html5rw.dom html5rw.tokenizer html5rw.encoding jsont jsont.bytesrw test_report))
+
 (executable
  (name test_html5lib)
- (libraries bytesrw html5rw.parser html5rw.dom))
+ (modules test_html5lib)
+ (libraries bytesrw html5rw.parser html5rw.dom test_report))
 
 (rule
  (alias runtest)
···
 
 (executable
  (name test_tokenizer)
- (libraries bytesrw html5rw.tokenizer jsont jsont.bytesrw))
+ (modules test_tokenizer)
+ (libraries bytesrw html5rw.tokenizer jsont jsont.bytesrw test_report))
 
 (rule
  (alias runtest)
···
 
 (executable
  (name test_encoding)
- (libraries html5rw.encoding))
+ (modules test_encoding)
+ (libraries html5rw.encoding test_report))
 
 (rule
  (alias runtest)
···
 
 (executable
  (name test_serializer)
- (libraries html5rw.dom jsont jsont.bytesrw))
+ (modules test_serializer)
+ (libraries html5rw.dom jsont jsont.bytesrw test_report))
 
 (rule
  (alias runtest)

test/test_all.ml

···
+(* Combined test runner for all html5lib-tests *)
+(* Generates a single standalone HTML report *)
+
+open Bytesrw
+
+module Report = Test_report
+
+(* ============================================================ *)
+(* Tree Construction Tests *)
+(* ============================================================ *)
+
+module TreeConstruction = struct
+  module Parser = Html5rw_parser
+  module Dom = Html5rw_dom
+
+  type test_case = {
+    input : string;
+    expected_tree : string;
+    expected_errors : string list;
+    script_on : bool;
+    fragment_context : string option;
+    raw_lines : string;
+  }
+
+  let parse_test_case lines =
+    let raw_lines = String.concat "\n" lines in
+    let rec parse acc = function
+      | [] -> acc
+      | line :: rest when String.length line > 0 && line.[0] = '#' ->
+        let section = String.trim line in
+        let content, remaining = collect_section rest in
+        parse ((section, content) :: acc) remaining
+      | _ :: rest -> parse acc rest
+    and collect_section lines =
+      let rec loop acc = function
+        | [] -> (List.rev acc, [])
+        | line :: rest when String.length line > 0 && line.[0] = '#' ->
+          (List.rev acc, line :: rest)
+        | line :: rest -> loop (line :: acc) rest
+      in
+      loop [] lines
+    in
+    let sections = parse [] lines in
+    let get_section name =
+      match List.assoc_opt name sections with
+      | Some lines -> String.concat "\n" lines
+      | None -> ""
+    in
+    let data = get_section "#data" in
+    let document = get_section "#document" in
+    let errors_text = get_section "#errors" in
+    let errors =
+      String.split_on_char '\n' errors_text
+      |> List.filter (fun s -> String.trim s <> "")
+    in
+    let script_on = List.mem_assoc "#script-on" sections in
+    let fragment =
+      if List.mem_assoc "#document-fragment" sections then
+        Some (get_section "#document-fragment" |> String.trim)
+      else None
+    in
+    { input = data; expected_tree = document; expected_errors = errors;
+      script_on; fragment_context = fragment; raw_lines }
+
+  let parse_dat_file content =
+    let lines = String.split_on_char '\n' content in
+    let rec split_tests current acc = function
+      | [] ->
+        if current = [] then List.rev acc
+        else List.rev (List.rev current :: acc)
+      | "" :: "#data" :: rest ->
+        let new_acc = if current = [] then acc else (List.rev current :: acc) in
+        split_tests ["#data"] new_acc rest
+      | line :: rest ->
+        split_tests (line :: current) acc rest
+    in
+    let test_groups = split_tests [] [] lines in
+    List.filter_map (fun lines ->
+      if List.exists (fun l -> l = "#data") lines then
+        Some (parse_test_case lines)
+      else None
+    ) test_groups
+
+  let strip_tree_prefix s =
+    let lines = String.split_on_char '\n' s in
+    let stripped = List.filter_map (fun line ->
+      if String.length line >= 2 && String.sub line 0 2 = "| " then
+        Some (String.sub line 2 (String.length line - 2))
+      else if String.trim line = "" then None
+      else Some line
+    ) lines in
+    String.concat "\n" stripped
+
+  let normalize_tree s =
+    let lines = String.split_on_char '\n' s in
+    let non_empty = List.filter (fun l -> String.trim l <> "") lines in
+    String.concat "\n" non_empty
+
+  let run_test test =
+    try
+      let result =
+        match test.fragment_context with
+        | Some ctx_str ->
+          let (namespace, tag_name) =
+            match String.split_on_char ' ' ctx_str with
+            | [ns; tag] when ns = "svg" -> (Some "svg", tag)
+            | [ns; tag] when ns = "math" -> (Some "mathml", tag)
+            | [tag] -> (None, tag)
+            | _ -> (None, ctx_str)
+          in
+          let context = Parser.make_fragment_context ~tag_name ~namespace () in
+          let reader = Bytes.Reader.of_string test.input in
+          Parser.parse ~collect_errors:true ~fragment_context:context reader
+        | None ->
+          let reader = Bytes.Reader.of_string test.input in
+          Parser.parse ~collect_errors:true reader
+      in
+      let actual_tree = Dom.to_test_format (Parser.root result) in
+      let expected = normalize_tree (strip_tree_prefix test.expected_tree) in
+      let actual = normalize_tree (strip_tree_prefix actual_tree) in
+      let error_count = List.length (Parser.errors result) in
+      let expected_error_count = List.length test.expected_errors in
+      (expected = actual, expected, actual, error_count, expected_error_count)
+    with e ->
+      let expected = normalize_tree (strip_tree_prefix test.expected_tree) in
+      (false, expected, Printf.sprintf "EXCEPTION: %s" (Printexc.to_string e), 0, 0)
+
+  let run_file path =
+    let ic = open_in path in
+    let content = really_input_string ic (in_channel_length ic) in
+    close_in ic;
+    let tests = parse_dat_file content in
+    let filename = Filename.basename path in
+    let passed = ref 0 in
+    let failed = ref 0 in
+    let results = ref [] in
+    List.iteri (fun i test ->
+      if test.script_on then ()
+      else begin
+        let (success, expected, actual, actual_error_count, expected_error_count) = run_test test in
+        let description =
+          let input_preview = String.sub test.input 0 (min 60 (String.length test.input)) in
+          if test.fragment_context <> None then
+            Printf.sprintf "Fragment (%s): %s" (Option.get test.fragment_context) input_preview
+          else input_preview
+        in
+        let result : Report.test_result = {
+          test_num = i + 1; description; input = test.input; expected; actual; success;
+          details = [
+            ("Fragment Context", Option.value test.fragment_context ~default:"(none)");
+            ("Expected Errors", string_of_int expected_error_count);
+            ("Actual Errors", string_of_int actual_error_count);
+          ];
+          raw_test_data = Some test.raw_lines;
+        } in
+        results := result :: !results;
+        if success then incr passed else incr failed
+      end
+    ) tests;
+    let file_result : Report.file_result = {
+      filename; test_type = "Tree Construction";
+      passed_count = !passed; failed_count = !failed;
+      tests = List.rev !results;
+    } in
+    (file_result, !passed, !failed)
+
+  let run_dir test_dir =
+    let files = Sys.readdir test_dir |> Array.to_list in
+    let dat_files = List.filter (fun f ->
+      Filename.check_suffix f ".dat" && not (String.contains f '/')
+    ) files in
+    let total_passed = ref 0 in
+    let total_failed = ref 0 in
+    let file_results = ref [] in
+    List.iter (fun file ->
+      let path = Filename.concat test_dir file in
+      if Sys.is_directory path then () else begin
+        let (file_result, passed, failed) = run_file path in
+        total_passed := !total_passed + passed;
+        total_failed := !total_failed + failed;
+        file_results := file_result :: !file_results;
+        Printf.printf "  %s: %d passed, %d failed\n" file passed failed
+      end
+    ) (List.sort String.compare dat_files);
+    (List.rev !file_results, !total_passed, !total_failed)
+end
+
+(* ============================================================ *)
+(* Tokenizer Tests *)
+(* ============================================================ *)
+
+module Tokenizer_tests = struct
+  module Tokenizer = Html5rw_tokenizer
+
+  module TokenCollector = struct
+    type t = { mutable tokens : Tokenizer.Token.t list }
+    let create () = { tokens = [] }
+    let process t token = t.tokens <- token :: t.tokens; `Continue
+    let adjusted_current_node_in_html_namespace _ = true
+    let get_tokens t = List.rev t.tokens
+  end
+
+  type test_case = {
+    description : string;
+    input : string;
+    output : Jsont.json list;
+    expected_error_count : int;
+    initial_states : string list;
+    last_start_tag : string option;
+    double_escaped : bool;
+    xml_mode : bool;
+    raw_json : string;
+  }
+
+  let unescape_double s =
+    let b = Buffer.create (String.length s) in
+    let i = ref 0 in
+    while !i < String.length s do
+      if !i + 1 < String.length s && s.[!i] = '\\' then begin
+        match s.[!i + 1] with
+        | 'u' when !i + 5 < String.length s ->
+          let hex = String.sub s (!i + 2) 4 in
+          (try
+            let code = int_of_string ("0x" ^ hex) in
+            if code < 128 then Buffer.add_char b (Char.chr code)
+            else begin
+              if code < 0x800 then begin
+                Buffer.add_char b (Char.chr (0xC0 lor (code lsr 6)));
+                Buffer.add_char b (Char.chr (0x80 lor (code land 0x3F)))
+              end else begin
+                Buffer.add_char b (Char.chr (0xE0 lor (code lsr 12)));
+                Buffer.add_char b (Char.chr (0x80 lor ((code lsr 6) land 0x3F)));
+                Buffer.add_char b (Char.chr (0x80 lor (code land 0x3F)))
+              end
+            end;
+            i := !i + 6
+          with _ -> Buffer.add_char b s.[!i]; incr i)
+        | 'n' -> Buffer.add_char b '\n'; i := !i + 2
+        | 'r' -> Buffer.add_char b '\r'; i := !i + 2
+        | 't' -> Buffer.add_char b '\t'; i := !i + 2
+        | '\\' -> Buffer.add_char b '\\'; i := !i + 2
+        | _ -> Buffer.add_char b s.[!i]; incr i
+      end else begin
+        Buffer.add_char b s.[!i]; incr i
+      end
+    done;
+    Buffer.contents b
+
+  let json_string = function Jsont.String (s, _) -> s | _ -> failwith "Expected string"
+  let json_bool = function Jsont.Bool (b, _) -> b | _ -> failwith "Expected bool"
+  let json_array = function Jsont.Array (arr, _) -> arr | _ -> failwith "Expected array"
+  let json_object = function Jsont.Object (obj, _) -> obj | _ -> failwith "Expected object"
+
+  let json_mem name obj =
+    match List.find_opt (fun ((n, _), _) -> n = name) obj with
+    | Some (_, v) -> Some v | None -> None
+
+  let json_mem_exn name obj =
+    match json_mem name obj with Some v -> v | None -> failwith ("Missing member: " ^ name)
+
+  let rec json_to_string = function
+    | Jsont.Null _ -> "null"
+    | Jsont.Bool (b, _) -> string_of_bool b
+    | Jsont.Number (n, _) -> Printf.sprintf "%g" n
+    | Jsont.String (s, _) -> Printf.sprintf "%S" s
+    | Jsont.Array (arr, _) -> "[" ^ String.concat ", " (List.map json_to_string arr) ^ "]"
+    | Jsont.Object (obj, _) ->
+      "{" ^ String.concat ", " (List.map (fun ((n, _), v) -> Printf.sprintf "%S: %s" n (json_to_string v)) obj) ^ "}"
+
+  let parse_test_case ~xml_mode json =
+    let raw_json = json_to_string json in
+    let obj = json_object json in
+    let description = json_string (json_mem_exn "description" obj) in
+    let input = json_string (json_mem_exn "input" obj) in
+    let output = json_array (json_mem_exn "output" obj) in
+    let expected_error_count = match json_mem "errors" obj with
+      | Some e -> List.length (json_array e) | None -> 0
+    in
+    let initial_states = match json_mem "initialStates" obj with
+      | Some s -> List.map json_string (json_array s) | None -> ["Data state"]
+    in
+    let last_start_tag = match json_mem "lastStartTag" obj with
+      | Some s -> Some (json_string s) | None -> None
+    in
+    let double_escaped = match json_mem "doubleEscaped" obj with
+      | Some b -> json_bool b | None -> false
+    in
+    { description; input; output; expected_error_count; initial_states;
+      last_start_tag; double_escaped; xml_mode; raw_json }
+
+  let state_of_string = function
+    | "Data state" -> Tokenizer.State.Data
+    | "PLAINTEXT state" -> Tokenizer.State.Plaintext
+    | "RCDATA state" -> Tokenizer.State.Rcdata
+    | "RAWTEXT state" -> Tokenizer.State.Rawtext
+    | "Script data state" -> Tokenizer.State.Script_data
+    | "CDATA section state" -> Tokenizer.State.Cdata_section
+    | s -> failwith ("Unknown state: " ^ s)
+
+  let token_to_test_json (tok : Tokenizer.Token.t) : Jsont.json list =
+    let str s = Jsont.String (s, Jsont.Meta.none) in
+    let arr l = Jsont.Array (l, Jsont.Meta.none) in
+    match tok with
+    | Tokenizer.Token.Doctype { name; public_id; system_id; force_quirks } ->
+      let name_json = match name with Some n -> str n | None -> Jsont.Null ((), Jsont.Meta.none) in
+      let public_json = match public_id with Some p -> str p | None -> Jsont.Null ((), Jsont.Meta.none) in
+      let system_json = match system_id with Some s -> str s | None -> Jsont.Null ((), Jsont.Meta.none) in
+      let correctness = Jsont.Bool (not force_quirks, Jsont.Meta.none) in
+      [arr [str "DOCTYPE"; name_json; public_json; system_json; correctness]]
+    | Tokenizer.Token.Tag { kind = Start; name; attrs; self_closing } ->
+      let attrs_obj = Jsont.Object (
+        List.map (fun (n, v) -> ((n, Jsont.Meta.none), str v)) (List.rev attrs),
+        Jsont.Meta.none
+      ) in
+      if self_closing then [arr [str "StartTag"; str name; attrs_obj; Jsont.Bool (true, Jsont.Meta.none)]]
+      else [arr [str "StartTag"; str name; attrs_obj]]
+    | Tokenizer.Token.Tag { kind = End; name; _ } -> [arr [str "EndTag"; str name]]
+    | Tokenizer.Token.Comment data -> [arr [str "Comment"; str data]]
+    | Tokenizer.Token.Character data -> [arr [str "Character"; str data]]
+    | Tokenizer.Token.EOF -> []
+
+  let rec json_equal a b =
+    match a, b with
+    | Jsont.Null _, Jsont.Null _ -> true
+    | Jsont.Bool (a, _), Jsont.Bool (b, _) -> a = b
+    | Jsont.Number (a, _), Jsont.Number (b, _) -> a = b
+    | Jsont.String (a, _), Jsont.String (b, _) -> a = b
+    | Jsont.Array (a, _), Jsont.Array (b, _) ->
+      List.length a = List.length b && List.for_all2 json_equal a b
+    | Jsont.Object (a, _), Jsont.Object (b, _) ->
+      let a_sorted = List.sort (fun ((n1, _), _) ((n2, _), _) -> String.compare n1 n2) a in
+      let b_sorted = List.sort (fun ((n1, _), _) ((n2, _), _) -> String.compare n1 n2) b in
+      List.length a_sorted = List.length b_sorted &&
+      List.for_all2 (fun ((n1, _), v1) ((n2, _), v2) -> n1 = n2 && json_equal v1 v2) a_sorted b_sorted
+    | _ -> false
+
+  let merge_character_tokens tokens =
+    let rec loop acc = function
+      | [] -> List.rev acc
+      | Tokenizer.Token.Character s1 :: Tokenizer.Token.Character s2 :: rest ->
+        loop acc (Tokenizer.Token.Character (s1 ^ s2) :: rest)
+      | tok :: rest -> loop (tok :: acc) rest
+    in loop [] tokens
+
+  let run_test test initial_state =
+    let input = if test.double_escaped then unescape_double test.input else test.input in
+    let collector = TokenCollector.create () in
+    let tokenizer = Tokenizer.create (module TokenCollector) collector ~collect_errors:true ~xml_mode:test.xml_mode () in
+    Tokenizer.set_state tokenizer initial_state;
+    (match test.last_start_tag with Some tag -> Tokenizer.set_last_start_tag tokenizer tag | None -> ());
+    let reader = Bytes.Reader.of_string input in
+    Tokenizer.run tokenizer (module TokenCollector) reader;
+    let tokens = merge_character_tokens (TokenCollector.get_tokens collector) in
+    let actual_tokens = List.concat_map token_to_test_json tokens in
+    let expected_output = if test.double_escaped then
+      let rec unescape_json = function
+        | Jsont.String (s, m) -> Jsont.String (unescape_double s, m)
+        | Jsont.Array (arr, m) -> Jsont.Array (List.map unescape_json arr, m)
+        | Jsont.Object (obj, m) -> Jsont.Object (List.map (fun (n, v) -> (n, unescape_json v)) obj, m)
+        | other -> other
+      in List.map unescape_json test.output
+    else test.output in
+    let rec merge_expected = function
+      | [] -> []
+      | [x] -> [x]
+      | Jsont.Array ([Jsont.String ("Character", _); Jsont.String (s1, m1)], am1) ::
+        Jsont.Array ([Jsont.String ("Character", _); Jsont.String (s2, _)], _) :: rest ->
+        merge_expected (Jsont.Array ([Jsont.String ("Character", Jsont.Meta.none); Jsont.String (s1 ^ s2, m1)], am1) :: rest)
+      | x :: rest -> x :: merge_expected rest
+    in
+    let expected = merge_expected expected_output in
+    let tokens_match =
+      List.length actual_tokens = List.length expected &&
+      List.for_all2 json_equal actual_tokens expected
+    in
+    let actual_error_count = List.length (Tokenizer.get_errors tokenizer) in
+    let errors_count_match = actual_error_count = test.expected_error_count in
+    (tokens_match && errors_count_match, actual_tokens, expected, actual_error_count, test.expected_error_count)
+
+  let run_file path =
+    let content =
+      let ic = open_in path in
+      let n = in_channel_length ic in
+      let s = really_input_string ic n in
+      close_in ic; s
+    in
+    let json = match Jsont_bytesrw.decode_string Jsont.json content with
+      | Ok j -> j
+      | Error e -> failwith (Printf.sprintf "JSON parse error in %s: %s" path e)
+    in
+    let obj = json_object json in
+    let regular_tests = match json_mem "tests" obj with
+      | Some t -> List.map (parse_test_case ~xml_mode:false) (json_array t) | None -> []
+    in
+    let xml_tests = match json_mem "xmlViolationTests" obj with
+      | Some t -> List.map (parse_test_case ~xml_mode:true) (json_array t) | None -> []
+    in
+    let all_tests = regular_tests @ xml_tests in
+    let filename = Filename.basename path in
+    let passed = ref 0 in
+    let failed = ref 0 in
+    let results = ref [] in
+    List.iteri (fun i test ->
+      List.iter (fun state_name ->
+        try
+          let state = state_of_string state_name in
+          let (success, actual, expected, actual_err_count, expected_err_count) = run_test test state in
+          let description = Printf.sprintf "[%s] %s" state_name test.description in
+          let result : Report.test_result = {
+            test_num = i + 1; description; input = test.input;
+            expected = String.concat "\n" (List.map json_to_string expected);
+            actual = String.concat "\n" (List.map json_to_string actual);
+            success;
+            details = [
+              ("Initial State", state_name);
+              ("Last Start Tag", Option.value test.last_start_tag ~default:"(none)");
+              ("Double Escaped", string_of_bool test.double_escaped);
+              ("XML Mode", string_of_bool test.xml_mode);
+              ("Expected Errors", string_of_int expected_err_count);
+              ("Actual Errors", string_of_int actual_err_count);
+            ];
+            raw_test_data = Some test.raw_json;
+          } in
+          results := result :: !results;
+          if success then incr passed else incr failed
+        with e ->
+          incr failed;
+          let result : Report.test_result = {
+            test_num = i + 1;
+            description = Printf.sprintf "[%s] %s" state_name test.description;
+            input = test.input; expected = "";
+            actual = Printf.sprintf "EXCEPTION: %s" (Printexc.to_string e);
+            success = false; details = [];
+            raw_test_data = Some test.raw_json;
+          } in
+          results := result :: !results
+      ) test.initial_states
+    ) all_tests;
+    let file_result : Report.file_result = {
+      filename; test_type = "Tokenizer";
+      passed_count = !passed; failed_count = !failed;
+      tests = List.rev !results;
+    } in
+    (file_result, !passed, !failed)
+
+  let run_dir test_dir =
+    let files = Sys.readdir test_dir |> Array.to_list in
+    let test_files = List.filter (fun f -> Filename.check_suffix f ".test") files in
+    let total_passed = ref 0 in
+    let total_failed = ref 0 in
+    let file_results = ref [] in
+    List.iter (fun file ->
+      let path = Filename.concat test_dir file in
+      let (file_result, passed, failed) = run_file path in
+      total_passed := !total_passed + passed;
+      total_failed := !total_failed + failed;
+      file_results := file_result :: !file_results;
+      Printf.printf "  %s: %d passed, %d failed\n" file passed failed
+    ) (List.sort String.compare test_files);
+    (List.rev !file_results, !total_passed, !total_failed)
+end
+
+(* ============================================================ *)
+(* Encoding Tests *)
+(* ============================================================ *)
+
+module Encoding_tests = struct
+  module Encoding = Html5rw_encoding
+
+  type test_case = {
+    input : string;
+    expected_encoding : string;
+    raw_lines : string;
+  }
+
+  let normalize_encoding_name s = String.lowercase_ascii (String.trim s)
+
+  let encoding_to_test_name = function
+    | Encoding.Utf8 -> "utf-8"
+    | Encoding.Utf16le -> "utf-16le"
+    | Encoding.Utf16be -> "utf-16be"
+    | Encoding.Windows_1252 -> "windows-1252"
+    | Encoding.Iso_8859_2 -> "iso-8859-2"
+    | Encoding.Euc_jp -> "euc-jp"
+
+  let parse_test_case lines =
+    let raw_lines = String.concat "\n" lines in
+    let rec parse acc = function
+      | [] -> acc
+      | line :: rest when String.length line > 0 && line.[0] = '#' ->
+        let section = String.trim line in
+        let content, remaining = collect_section rest in
+        parse ((section, content) :: acc) remaining
+      | _ :: rest -> parse acc rest
+    and collect_section lines =
+      let rec loop acc = function
+        | [] -> (List.rev acc, [])
+        | line :: rest when String.length line > 0 && line.[0] = '#' ->
+          (List.rev acc, line :: rest)
+        | line :: rest -> loop (line :: acc) rest
+      in loop [] lines
+    in
+    let sections = parse [] lines in
+    let get_section name =
+      match List.assoc_opt name sections with
+      | Some lines -> String.concat "\n" lines | None -> ""
+    in
+    let data = get_section "#data" in
+    let encoding = get_section "#encoding" in
+    { input = data; expected_encoding = String.trim encoding; raw_lines }
+
+  let parse_dat_file content =
+    let lines = String.split_on_char '\n' content in
+    let rec split_tests current acc = function
+      | [] -> if current = [] then List.rev acc else List.rev (List.rev current :: acc)
+      | "" :: "#data" :: rest ->
+        let new_acc = if current = [] then acc else (List.rev current :: acc) in
+        split_tests ["#data"] new_acc rest
+      | line :: rest -> split_tests (line :: current) acc rest
+    in
+    let test_groups = split_tests [] [] lines in
+    List.filter_map (fun lines ->
+      if List.exists (fun l -> l = "#data") lines then Some (parse_test_case lines)
+      else None
+    ) test_groups
+
+  let run_test test =
+    try
+      let (_, detected_encoding) = Encoding.decode (Bytes.of_string test.input) () in
+      let detected_name = encoding_to_test_name detected_encoding in
+      let expected_name = normalize_encoding_name test.expected_encoding in
+      let match_encoding det exp =
+        det = exp ||
+        (det = "windows-1252" && (exp = "windows-1252" || exp = "cp1252" || exp = "iso-8859-1")) ||
+        (det = "iso-8859-2" && (exp = "iso-8859-2" || exp = "iso8859-2" || exp = "latin2")) ||
+        (det = "utf-8" && (exp = "utf-8" || exp = "utf8")) ||
+        (det = "euc-jp" && (exp = "euc-jp" || exp = "eucjp"))
+      in
+      (match_encoding detected_name expected_name, detected_name, expected_name)
+    with e ->
+      (false, Printf.sprintf "EXCEPTION: %s" (Printexc.to_string e), test.expected_encoding)
+
+  let run_file path =
+    let ic = open_in path in
+    let content = really_input_string ic (in_channel_length ic) in
+    close_in ic;
+    let tests = parse_dat_file content in
+    let filename = Filename.basename path in
+    let passed = ref 0 in
+    let failed = ref 0 in
+    let results = ref [] in
+    List.iteri (fun i test ->
+      if String.trim test.expected_encoding = "" then ()
+      else begin
+        let (success, detected, expected) = run_test test in
+        let result : Report.test_result = {
+          test_num = i + 1;
+          description = Printf.sprintf "Detect %s encoding" expected;
+          input = String.escaped test.input;
+          expected; actual = detected; success;
+          details = [
+            ("Input Length", string_of_int (String.length test.input));
+            ("Has BOM", string_of_bool (String.length test.input >= 3 &&
+              (String.sub test.input 0 3 = "\xEF\xBB\xBF" ||
+               String.sub test.input 0 2 = "\xFF\xFE" ||
+               String.sub test.input 0 2 = "\xFE\xFF")));
+          ];
+          raw_test_data = Some test.raw_lines;
+        } in
+        results := result :: !results;
+        if success then incr passed else incr failed
+      end
+    ) tests;
+    let file_result : Report.file_result = {
+      filename; test_type = "Encoding Detection";
+      passed_count = !passed; failed_count = !failed;
+      tests = List.rev !results;
+    } in
+    (file_result, !passed, !failed)
+
+  let run_dir test_dir =
+    let files = Sys.readdir test_dir |> Array.to_list in
+    let dat_files = List.filter (fun f ->
+      Filename.check_suffix f ".dat" && not (String.contains f '/')
+    ) files in
+    let total_passed = ref 0 in
+    let total_failed = ref 0 in
+    let file_results = ref [] in
+    List.iter (fun file ->
+      let path = Filename.concat test_dir file in
+      if Sys.is_directory path then () else begin
+        let (file_result, passed, failed) = run_file path in
+        total_passed := !total_passed + passed;
+        total_failed := !total_failed + failed;
+        file_results := file_result :: !file_results;
+        Printf.printf "  %s: %d passed, %d failed\n" file passed failed
+      end
+    ) (List.sort String.compare dat_files);
+    (List.rev !file_results, !total_passed, !total_failed)
+end
+
+(* ============================================================ *)
+(* Main Entry Point *)
+(* ============================================================ *)
+
+let () =
+  let base_dir = if Array.length Sys.argv > 1 then Sys.argv.(1) else "html5lib-tests" in
+
+  let all_files = ref [] in
+  let total_passed = ref 0 in
+  let total_failed = ref 0 in
+
+  (* Run Tree Construction Tests *)
+  Printf.printf "\n=== Tree Construction Tests ===\n";
+  let tree_dir = Filename.concat base_dir "tree-construction" in
+  if Sys.file_exists tree_dir then begin
+    let (files, passed, failed) = TreeConstruction.run_dir tree_dir in
+    all_files := !all_files @ files;
+    total_passed := !total_passed + passed;
+    total_failed := !total_failed + failed;
+    Printf.printf "  Subtotal: %d passed, %d failed\n" passed failed
+  end else
+    Printf.printf "  (directory not found: %s)\n" tree_dir;
+
+  (* Run Tokenizer Tests *)
+  Printf.printf "\n=== Tokenizer Tests ===\n";
+  let tok_dir = Filename.concat base_dir "tokenizer" in
+  if Sys.file_exists tok_dir then begin
+    let (files, passed, failed) = Tokenizer_tests.run_dir tok_dir in
+    all_files := !all_files @ files;
+    total_passed := !total_passed + passed;
+    total_failed := !total_failed + failed;
+    Printf.printf "  Subtotal: %d passed, %d failed\n" passed failed
+  end else
+    Printf.printf "  (directory not found: %s)\n" tok_dir;
+
+  (* Run Encoding Tests *)
+  Printf.printf "\n=== Encoding Detection Tests ===\n";
+  let enc_dir = Filename.concat base_dir "encoding" in
+  if Sys.file_exists enc_dir then begin
+    let (files, passed, failed) = Encoding_tests.run_dir enc_dir in
+    all_files := !all_files @ files;
+    total_passed := !total_passed + passed;
+    total_failed := !total_failed + failed;
+    Printf.printf "  Subtotal: %d passed, %d failed\n" passed failed
+  end else
+    Printf.printf "  (directory not found: %s)\n" enc_dir;
+
+  (* Note: Serializer tests use the standalone test_serializer.exe for full implementation *)
+
+  Printf.printf "\n=== Overall Summary ===\n";
+  Printf.printf "Total: %d passed, %d failed\n" !total_passed !total_failed;
+
+  (* Generate combined HTML report *)
+  let report : Report.report = {
+    title = "HTML5 Parser Test Suite";
+    test_type = "combined";
+    description = "This is a comprehensive test report for the html5rw OCaml HTML5 parser library, \
+                   validating conformance against the official html5lib-tests test suite. \
+                   Tests cover: (1) Tree Construction - validating the DOM tree building algorithm; \
+                   (2) Tokenization - validating the HTML tokenizer state machine; \
+                   (3) Encoding Detection - validating character encoding sniffing. \
+                   Each test shows the input, expected output, actual output, and original test data.";
+    files = !all_files;
+    total_passed = !total_passed;
+    total_failed = !total_failed;
+  } in
+  Report.generate_report report "html5lib_test_report.html";
+
+  exit (if !total_failed > 0 then 1 else 0)

test/test_encoding.ml

···
 (* Test runner for html5lib-tests encoding tests *)
 
 module Encoding = Html5rw_encoding
+module Report = Test_report
 
 type test_case = {
   input : string;
   expected_encoding : string;
+  raw_lines : string;  (* Original test data from .dat file *)
 }
 
 (* Normalize encoding name for comparison *)
···
 
 (* Parse a single test case from lines *)
 let parse_test_case lines =
+  let raw_lines = String.concat "\n" lines in
   let rec parse acc = function
     | [] -> acc
     | line :: rest when String.length line > 0 && line.[0] = '#' ->
···
   let data = get_section "#data" in
   let encoding = get_section "#encoding" in
 
-  { input = data; expected_encoding = String.trim encoding }
+  { input = data; expected_encoding = String.trim encoding; raw_lines }
 
 (* Parse a .dat file into test cases *)
 let parse_dat_file content =
···
 
   let passed = ref 0 in
   let failed = ref 0 in
-  let errors = ref [] in
+  let results = ref [] in
 
   List.iteri (fun i test ->
     if String.trim test.expected_encoding = "" then
···
       ()
     else begin
       let (success, detected, expected) = run_test test in
-      if success then
-        incr passed
-      else begin
-        incr failed;
-        if List.length !errors < 5 then
-          errors := (i + 1, test.input, detected, expected) :: !errors
-      end
+      let result : Report.test_result = {
+        test_num = i + 1;
+        description = Printf.sprintf "Detect %s encoding" expected;
+        input = String.escaped test.input;  (* Show escaped version of full input *)
+        expected;
+        actual = detected;
+        success;
+        details = [
+          ("Input Length", string_of_int (String.length test.input));
+          ("Has BOM", string_of_bool (String.length test.input >= 3 &&
+            (String.sub test.input 0 3 = "\xEF\xBB\xBF" ||  (* UTF-8 BOM *)
+             String.sub test.input 0 2 = "\xFF\xFE" ||      (* UTF-16 LE BOM *)
+             String.sub test.input 0 2 = "\xFE\xFF")));     (* UTF-16 BE BOM *)
+        ];
+        raw_test_data = Some test.raw_lines;
+      } in
+      results := result :: !results;
+      if success then incr passed else incr failed
     end
   ) tests;
 
-  (!passed, !failed, List.rev !errors, filename)
+  let file_result : Report.file_result = {
+    filename;
+    test_type = "Encoding Detection";
+    passed_count = !passed;
+    failed_count = !failed;
+    tests = List.rev !results;
+  } in
+  (file_result, !passed, !failed)
 
 let () =
   let test_dir = Sys.argv.(1) in
···
 
   let total_passed = ref 0 in
   let total_failed = ref 0 in
-  let all_errors = ref [] in
+  let file_results = ref [] in
 
   List.iter (fun file ->
     let path = Filename.concat test_dir file in
     if Sys.is_directory path then () else begin
-      let (passed, failed, errors, filename) = run_file path in
+      let (file_result, passed, failed) = run_file path in
       total_passed := !total_passed + passed;
       total_failed := !total_failed + failed;
-      if errors <> [] then
-        all_errors := (filename, errors) :: !all_errors;
-      Printf.printf "%s: %d passed, %d failed\n" filename passed failed
+      file_results := file_result :: !file_results;
+      Printf.printf "%s: %d passed, %d failed\n" file passed failed
     end
   ) (List.sort String.compare dat_files);
 
   Printf.printf "\n=== Summary ===\n";
   Printf.printf "Total: %d passed, %d failed\n" !total_passed !total_failed;
 
-  if !all_errors <> [] then begin
-    Printf.printf "\n=== First failures ===\n";
-    List.iter (fun (filename, errors) ->
-      List.iter (fun (test_num, input, detected, expected) ->
-        Printf.printf "\n--- %s test %d ---\n" filename test_num;
-        Printf.printf "Input (first 200 chars): %s\n"
-          (String.escaped (String.sub input 0 (min 200 (String.length input))));
-        Printf.printf "Expected encoding: %s\n" expected;
-        Printf.printf "Detected encoding: %s\n" detected
-      ) errors
-    ) (List.rev !all_errors)
-  end;
+  (* Generate HTML report *)
+  let report : Report.report = {
+    title = "HTML5 Encoding Detection Tests";
+    test_type = "encoding";
+    description = "These tests validate the character encoding detection algorithm as specified in the WHATWG \
+                   Encoding Standard. The parser must determine the document's character encoding from byte order \
+                   marks (BOM), meta charset declarations, or content sniffing. Tests cover UTF-8, UTF-16 \
+                   (big/little endian), Windows-1252, ISO-8859-2, EUC-JP, and other encodings. The algorithm \
+                   examines initial bytes for BOM signatures and scans the first 1024 bytes for meta elements \
+                   declaring charset or http-equiv content-type.";
+    files = List.rev !file_results;
+    total_passed = !total_passed;
+    total_failed = !total_failed;
+  } in
+  Report.generate_report report "test_encoding_report.html";
 
   exit (if !total_failed > 0 then 1 else 0)

test/test_html5lib.ml

···
 
 module Parser = Html5rw_parser
 module Dom = Html5rw_dom
+module Report = Test_report
 
 type test_case = {
   input : string;
···
   expected_errors : string list;
   script_on : bool;
   fragment_context : string option;
+  raw_lines : string;  (* Original test data from .dat file *)
 }
 
 let _is_blank s = String.trim s = ""
 
 (* Parse a single test case from lines *)
 let parse_test_case lines =
+  let raw_lines = String.concat "\n" lines in
   let rec parse acc = function
     | [] -> acc
     | line :: rest when String.length line > 0 && line.[0] = '#' ->
···
     expected_errors = errors;
     script_on;
     fragment_context = fragment;
+    raw_lines;
   }
 
 (* Parse a .dat file into test cases *)
···
     let actual_tree = Dom.to_test_format (Parser.root result) in
     let expected = normalize_tree (strip_tree_prefix test.expected_tree) in
     let actual = normalize_tree (strip_tree_prefix actual_tree) in
-    (expected = actual, expected, actual, List.length (Parser.errors result), List.length test.expected_errors)
+    let error_count = List.length (Parser.errors result) in
+    let expected_error_count = List.length test.expected_errors in
+    (expected = actual, expected, actual, error_count, expected_error_count)
   with e ->
     let expected = normalize_tree (strip_tree_prefix test.expected_tree) in
     (false, expected, Printf.sprintf "EXCEPTION: %s" (Printexc.to_string e), 0, 0)
···
 
   let passed = ref 0 in
   let failed = ref 0 in
-  let errors = ref [] in
+  let results = ref [] in
 
   List.iteri (fun i test ->
     (* Skip script-on tests since we don't support scripting *)
     if test.script_on then
       ()  (* Skip this test *)
     else begin
-      let (success, expected, actual, _actual_error_count, _expected_error_count) = run_test test in
-      if success then
-        incr passed
-      else begin
-        incr failed;
-        errors := (i + 1, test.input, expected, actual) :: !errors
-      end
+      let (success, expected, actual, actual_error_count, expected_error_count) = run_test test in
+      let description =
+        let input_preview = String.sub test.input 0 (min 60 (String.length test.input)) in
+        if test.fragment_context <> None then
+          Printf.sprintf "Fragment (%s): %s" (Option.get test.fragment_context) input_preview
+        else
+          input_preview
+      in
+      let details = [
+        ("Fragment Context", Option.value test.fragment_context ~default:"(none)");
+        ("Expected Errors", string_of_int expected_error_count);
+        ("Actual Errors", string_of_int actual_error_count);
+      ] in
+      let result : Report.test_result = {
+        test_num = i + 1;
+        description;
+        input = test.input;
+        expected;
+        actual;
+        success;
+        details;
+        raw_test_data = Some test.raw_lines;
+      } in
+      results := result :: !results;
+      if success then incr passed else incr failed
     end
   ) tests;
 
-  (!passed, !failed, List.rev !errors, filename)
+  let file_result : Report.file_result = {
+    filename;
+    test_type = "Tree Construction";
+    passed_count = !passed;
+    failed_count = !failed;
+    tests = List.rev !results;
+  } in
+  (file_result, !passed, !failed)
 
 let () =
   let test_dir = Sys.argv.(1) in
···
 
   let total_passed = ref 0 in
   let total_failed = ref 0 in
-  let all_errors = ref [] in
+  let file_results = ref [] in
 
   List.iter (fun file ->
     let path = Filename.concat test_dir file in
     if Sys.is_directory path then () else begin
-      let (passed, failed, errors, filename) = run_file path in
+      let (file_result, passed, failed) = run_file path in
       total_passed := !total_passed + passed;
       total_failed := !total_failed + failed;
-      if errors <> [] then
-        all_errors := (filename, errors) :: !all_errors;
-      Printf.printf "%s: %d passed, %d failed\n" filename passed failed
+      file_results := file_result :: !file_results;
+      Printf.printf "%s: %d passed, %d failed\n" file passed failed
     end
   ) (List.sort String.compare dat_files);
 
   Printf.printf "\n=== Summary ===\n";
   Printf.printf "Total: %d passed, %d failed\n" !total_passed !total_failed;
 
-  if !all_errors <> [] then begin
-    Printf.printf "\n=== First failures ===\n";
-    List.iter (fun (filename, errors) ->
-      List.iter (fun (test_num, input, expected, actual) ->
-        Printf.printf "\n--- %s test %d ---\n" filename test_num;
-        Printf.printf "Input: %s\n" (String.escaped input);
-        Printf.printf "Expected:\n%s\n" expected;
-        Printf.printf "Actual:\n%s\n" actual
-      ) (List.filteri (fun i _ -> i < 3) errors)
-    ) (List.filteri (fun i _ -> i < 10) !all_errors)
-  end;
+  (* Generate HTML report *)
+  let report : Report.report = {
+    title = "HTML5 Tree Construction Tests";
+    test_type = "tree-construction";
+    description = "These tests validate the HTML5 tree construction algorithm as specified in the WHATWG HTML Standard. \
+                   Each test provides HTML input and the expected DOM tree structure. The parser processes the HTML and \
+                   builds a document tree, which is then serialized and compared against the expected output. \
+                   Tests cover various edge cases including malformed HTML, implicit element creation, foster parenting, \
+                   adoption agency algorithm, and foreign content (SVG/MathML). Fragment parsing tests verify parsing \
+                   in the context of specific elements.";
+    files = List.rev !file_results;
+    total_passed = !total_passed;
+    total_failed = !total_failed;
+  } in
+  Report.generate_report report "test_html5lib_report.html";
 
   exit (if !total_failed > 0 then 1 else 0)

test/test_report.ml

···
+(* HTML Test Report Generator *)
+
+type test_result = {
+  test_num : int;
+  description : string;
+  input : string;
+  expected : string;
+  actual : string;
+  success : bool;
+  details : (string * string) list;  (* Additional key-value pairs *)
+  raw_test_data : string option;  (* Original test file content for context *)
+}
+
+type file_result = {
+  filename : string;
+  test_type : string;
+  passed_count : int;
+  failed_count : int;
+  tests : test_result list;
+}
+
+type report = {
+  title : string;
+  test_type : string;
+  description : string;  (* Explanation of what this test suite validates *)
+  files : file_result list;
+  total_passed : int;
+  total_failed : int;
+}
+
+let html_escape s =
+  let buf = Buffer.create (String.length s * 2) in
+  String.iter (fun c ->
+    match c with
+    | '&' -> Buffer.add_string buf "&"
+    | '<' -> Buffer.add_string buf "&lt;"
+    | '>' -> Buffer.add_string buf "&gt;"
+    | '"' -> Buffer.add_string buf "&quot;"
+    | '\'' -> Buffer.add_string buf "&#x27;"
+    | c -> Buffer.add_char buf c
+  ) s;
+  Buffer.contents buf
+
+(* No truncation - show full content for standalone reports *)
+let truncate_string ?(max_len=10000) s =
+  if String.length s <= max_len then s
+  else String.sub s 0 max_len ^ "\n... (truncated at " ^ string_of_int max_len ^ " chars)"
+
+let css = {|
+:root {
+  --bg-primary: #1a1a2e;
+  --bg-secondary: #16213e;
+  --bg-tertiary: #0f3460;
+  --text-primary: #eee;
+  --text-secondary: #aaa;
+  --accent: #e94560;
+  --success: #4ade80;
+  --failure: #f87171;
+  --border: #333;
+}
+
+* { box-sizing: border-box; margin: 0; padding: 0; }
+
+body {
+  font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+  background: var(--bg-primary);
+  color: var(--text-primary);
+  line-height: 1.6;
+}
+
+.container {
+  max-width: 1400px;
+  margin: 0 auto;
+  padding: 20px;
+}
+
+header {
+  background: var(--bg-secondary);
+  padding: 20px;
+  border-radius: 8px;
+  margin-bottom: 20px;
+}
+
+header h1 {
+  font-size: 1.5rem;
+  margin-bottom: 10px;
+  color: var(--accent);
+}
+
+.summary {
+  display: flex;
+  gap: 20px;
+  flex-wrap: wrap;
+  align-items: center;
+}
+
+.stat {
+  padding: 8px 16px;
+  border-radius: 6px;
+  font-weight: 600;
+}
+
+.stat.total { background: var(--bg-tertiary); }
+.stat.passed { background: rgba(74, 222, 128, 0.2); color: var(--success); }
+.stat.failed { background: rgba(248, 113, 113, 0.2); color: var(--failure); }
+
+.controls {
+  display: flex;
+  gap: 10px;
+  margin-top: 10px;
+  flex-wrap: wrap;
+}
+
+input[type="search"], select {
+  padding: 8px 12px;
+  border: 1px solid var(--border);
+  border-radius: 6px;
+  background: var(--bg-primary);
+  color: var(--text-primary);
+  font-size: 14px;
+}
+
+input[type="search"] { width: 300px; }
+
+button {
+  padding: 8px 16px;
+  border: none;
+  border-radius: 6px;
+  background: var(--accent);
+  color: white;
+  cursor: pointer;
+  font-size: 14px;
+}
+
+button:hover { opacity: 0.9; }
+
+.sidebar {
+  position: fixed;
+  left: 0;
+  top: 0;
+  bottom: 0;
+  width: 280px;
+  background: var(--bg-secondary);
+  border-right: 1px solid var(--border);
+  overflow-y: auto;
+  padding: 10px;
+  padding-top: 20px;
+}
+
+.sidebar-item {
+  padding: 8px 12px;
+  border-radius: 6px;
+  cursor: pointer;
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  margin-bottom: 4px;
+  font-size: 14px;
+}
+
+.sidebar-item:hover { background: var(--bg-tertiary); }
+.sidebar-item.active { background: var(--accent); }
+
+.sidebar-item .count {
+  font-size: 12px;
+  padding: 2px 8px;
+  border-radius: 10px;
+  background: var(--bg-primary);
+}
+
+.sidebar-item .count.all-passed { color: var(--success); }
+.sidebar-item .count.has-failed { color: var(--failure); }
+
+main {
+  margin-left: 300px;
+  padding: 20px;
+  padding-top: 30px;
+}
+
+.intro {
+  background: var(--bg-secondary);
+  padding: 20px;
+  border-radius: 8px;
+  margin-bottom: 20px;
+}
+
+.file-section {
+  margin-bottom: 30px;
+  background: var(--bg-secondary);
+  border-radius: 8px;
+  overflow: hidden;
+}
+
+.file-header {
+  padding: 15px 20px;
+  background: var(--bg-tertiary);
+  cursor: pointer;
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+}
+
+.file-header h2 {
+  font-size: 1.1rem;
+  display: flex;
+  align-items: center;
+  gap: 10px;
+}
+
+.file-header .toggle {
+  font-size: 1.2rem;
+  transition: transform 0.2s;
+}
+
+.file-header.collapsed .toggle { transform: rotate(-90deg); }
+
+.file-stats {
+  display: flex;
+  gap: 15px;
+  font-size: 14px;
+}
+
+.file-stats .passed { color: var(--success); }
+.file-stats .failed { color: var(--failure); }
+
+.tests-container {
+  padding: 10px;
+}
+
+.tests-container.hidden { display: none; }
+
+.test-item {
+  margin: 8px 0;
+  border: 1px solid var(--border);
+  border-radius: 6px;
+  overflow: hidden;
+}
+
+.test-header {
+  padding: 10px 15px;
+  cursor: pointer;
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  background: var(--bg-primary);
+}
+
+.test-header:hover { background: var(--bg-tertiary); }
+
+.test-header .status {
+  width: 10px;
+  height: 10px;
+  border-radius: 50%;
+  margin-right: 10px;
+}
+
+.test-header .status.passed { background: var(--success); }
+.test-header .status.failed { background: var(--failure); }
+
+.test-header .test-info {
+  flex: 1;
+  display: flex;
+  align-items: center;
+}
+
+.test-header .test-num {
+  font-weight: 600;
+  margin-right: 10px;
+  color: var(--text-secondary);
+}
+
+.test-header .test-desc {
+  font-size: 14px;
+  color: var(--text-primary);
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  max-width: 600px;
+}
+
+.test-details {
+  padding: 15px;
+  background: var(--bg-primary);
+  border-top: 1px solid var(--border);
+  display: none;
+}
+
+.test-details.visible { display: block; }
+
+.detail-section {
+  margin-bottom: 15px;
+}
+
+.detail-section h4 {
+  font-size: 12px;
+  text-transform: uppercase;
+  color: var(--text-secondary);
+  margin-bottom: 8px;
+  letter-spacing: 0.5px;
+}
+
+.detail-section pre {
+  background: var(--bg-secondary);
+  padding: 12px;
+  border-radius: 6px;
+  overflow-x: auto;
+  font-family: 'Monaco', 'Menlo', monospace;
+  font-size: 13px;
+  white-space: pre-wrap;
+  word-break: break-all;
+  max-height: 300px;
+  overflow-y: auto;
+}
+
+.detail-row {
+  display: grid;
+  grid-template-columns: 1fr 1fr;
+  gap: 15px;
+}
+
+.detail-row.single { grid-template-columns: 1fr; }
+
+.meta-info {
+  display: flex;
+  gap: 20px;
+  flex-wrap: wrap;
+  font-size: 13px;
+  color: var(--text-secondary);
+  margin-bottom: 15px;
+}
+
+.meta-info span {
+  background: var(--bg-secondary);
+  padding: 4px 10px;
+  border-radius: 4px;
+}
+
+.diff-indicator {
+  color: var(--failure);
+  font-weight: bold;
+  margin-left: 5px;
+}
+
+@media (max-width: 900px) {
+  .sidebar { display: none; }
+  main { margin-left: 0; }
+  .detail-row { grid-template-columns: 1fr; }
+}
+|}
+
+let js = {|
+document.addEventListener('DOMContentLoaded', function() {
+  // File section toggling
+  document.querySelectorAll('.file-header').forEach(header => {
+    header.addEventListener('click', function() {
+      this.classList.toggle('collapsed');
+      const container = this.nextElementSibling;
+      container.classList.toggle('hidden');
+    });
+  });
+
+  // Test details toggling
+  document.querySelectorAll('.test-header').forEach(header => {
+    header.addEventListener('click', function(e) {
+      e.stopPropagation();
+      const details = this.nextElementSibling;
+      details.classList.toggle('visible');
+    });
+  });
+
+  // Sidebar navigation
+  document.querySelectorAll('.sidebar-item').forEach(item => {
+    item.addEventListener('click', function() {
+      const fileId = this.dataset.file;
+      const section = document.getElementById(fileId);
+      if (section) {
+        section.scrollIntoView({ behavior: 'smooth' });
+        // Expand if collapsed
+        const header = section.querySelector('.file-header');
+        if (header.classList.contains('collapsed')) {
+          header.click();
+        }
+      }
+      // Update active state
+      document.querySelectorAll('.sidebar-item').forEach(i => i.classList.remove('active'));
+      this.classList.add('active');
+    });
+  });
+
+  // Search functionality
+  const searchInput = document.getElementById('search');
+  if (searchInput) {
+    searchInput.addEventListener('input', function() {
+      const query = this.value.toLowerCase();
+      document.querySelectorAll('.test-item').forEach(item => {
+        const text = item.textContent.toLowerCase();
+        item.style.display = text.includes(query) ? '' : 'none';
+      });
+    });
+  }
+
+  // Filter functionality
+  const filterSelect = document.getElementById('filter');
+  if (filterSelect) {
+    filterSelect.addEventListener('change', function() {
+      const filter = this.value;
+      document.querySelectorAll('.test-item').forEach(item => {
+        const passed = item.querySelector('.status.passed') !== null;
+        if (filter === 'all') {
+          item.style.display = '';
+        } else if (filter === 'passed') {
+          item.style.display = passed ? '' : 'none';
+        } else if (filter === 'failed') {
+          item.style.display = passed ? 'none' : '';
+        }
+      });
+    });
+  }
+
+  // Expand/Collapse all
+  document.getElementById('expand-all')?.addEventListener('click', function() {
+    document.querySelectorAll('.file-header.collapsed').forEach(h => h.click());
+  });
+
+  document.getElementById('collapse-all')?.addEventListener('click', function() {
+    document.querySelectorAll('.file-header:not(.collapsed)').forEach(h => h.click());
+  });
+});
+|}
+
+let generate_test_html test =
+  let status_class = if test.success then "passed" else "failed" in
+  let desc_escaped = html_escape test.description in
+  let input_escaped = html_escape (truncate_string test.input) in
+  let expected_escaped = html_escape (truncate_string test.expected) in
+  let actual_escaped = html_escape (truncate_string test.actual) in
+
+  let details_html = String.concat "" (List.map (fun (key, value) ->
+    Printf.sprintf {|
+      <div class="detail-section">
+        <h4>%s</h4>
+        <pre>%s</pre>
+      </div>
+    |} (html_escape key) (html_escape value)
+  ) test.details) in
+
+  let raw_data_html = match test.raw_test_data with
+    | Some data ->
+      Printf.sprintf {|
+        <div class="detail-section">
+          <h4>Original Test Data (from .dat/.test file)</h4>
+          <pre>%s</pre>
+        </div>
+      |} (html_escape (truncate_string data))
+    | None -> ""
+  in
+
+  let diff_indicator = if test.success then "" else {|<span class="diff-indicator">✗</span>|} in
+
+  Printf.sprintf {|
+    <div class="test-item" data-passed="%b">
+      <div class="test-header">
+        <div class="test-info">
+          <span class="status %s"></span>
+          <span class="test-num">#%d</span>
+          <span class="test-desc">%s</span>
+        </div>
+        <span>▼</span>
+      </div>
+      <div class="test-details">
+        %s
+        <div class="detail-section">
+          <h4>Input (HTML to parse)</h4>
+          <pre>%s</pre>
+        </div>
+        <div class="detail-row">
+          <div class="detail-section">
+            <h4>Expected Output%s</h4>
+            <pre>%s</pre>
+          </div>
+          <div class="detail-section">
+            <h4>Actual Output%s</h4>
+            <pre>%s</pre>
+          </div>
+        </div>
+        %s
+      </div>
+    </div>
+  |} test.success status_class test.test_num desc_escaped
+     raw_data_html input_escaped diff_indicator expected_escaped diff_indicator actual_escaped details_html
+
+let generate_file_html file =
+  let file_id = String.map (fun c -> if c = '.' then '-' else c) file.filename in
+  let tests_html = String.concat "\n" (List.map generate_test_html file.tests) in
+  let collapsed = if file.failed_count = 0 then "collapsed" else "" in
+  let hidden = if file.failed_count = 0 then "hidden" else "" in
+
+  Printf.sprintf {|
+    <div class="file-section" id="file-%s">
+      <div class="file-header %s">
+        <h2>
+          <span class="toggle">▼</span>
+          %s
+          <span style="font-weight: normal; font-size: 0.9em; color: var(--text-secondary)">(%s)</span>
+        </h2>
+        <div class="file-stats">
+          <span class="passed">✓ %d passed</span>
+          <span class="failed">✗ %d failed</span>
+        </div>
+      </div>
+      <div class="tests-container %s">
+        %s
+      </div>
+    </div>
+  |} file_id collapsed file.filename file.test_type file.passed_count file.failed_count hidden tests_html
+
+let generate_sidebar_html files =
+  String.concat "\n" (List.map (fun file ->
+    let file_id = String.map (fun c -> if c = '.' then '-' else c) file.filename in
+    let count_class = if file.failed_count = 0 then "all-passed" else "has-failed" in
+    Printf.sprintf {|
+      <div class="sidebar-item" data-file="file-%s">
+        <span>%s</span>
+        <span class="count %s">%d/%d</span>
+      </div>
+    |} file_id file.filename count_class file.passed_count (file.passed_count + file.failed_count)
+  ) files)
+
+let generate_report report output_path =
+  let files_html = String.concat "\n" (List.map generate_file_html report.files) in
+  let sidebar_html = generate_sidebar_html report.files in
+
+  let html = Printf.sprintf {|<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>%s - Test Report</title>
+  <style>%s</style>
+</head>
+<body>
+  <div class="sidebar">
+    <h3 style="padding: 10px; color: var(--text-secondary); font-size: 12px; text-transform: uppercase;">Files</h3>
+    %s
+  </div>
+
+  <main>
+    <header>
+      <h1>%s</h1>
+      <p style="color: var(--text-secondary); margin: 10px 0; max-width: 900px;">%s</p>
+      <div class="summary">
+        <span class="stat total">%d tests</span>
+        <span class="stat passed">✓ %d passed</span>
+        <span class="stat failed">✗ %d failed</span>
+        <span class="stat total">%.1f%% pass rate</span>
+      </div>
+      <div class="controls">
+        <input type="search" id="search" placeholder="Search tests...">
+        <select id="filter">
+          <option value="all">All tests</option>
+          <option value="passed">Passed only</option>
+          <option value="failed">Failed only</option>
+        </select>
+        <button id="expand-all">Expand All</button>
+        <button id="collapse-all">Collapse All</button>
+      </div>
+    </header>
+    %s
+  </main>
+
+  <script>%s</script>
+</body>
+</html>
+|} report.title css
+   sidebar_html
+   report.title (html_escape report.description)
+   (report.total_passed + report.total_failed)
+   report.total_passed
+   report.total_failed
+   (100.0 *. float_of_int report.total_passed /. float_of_int (max 1 (report.total_passed + report.total_failed)))
+   files_html js
+  in
+
+  let oc = open_out output_path in
+  output_string oc html;
+  close_out oc;
+  Printf.printf "HTML report written to: %s\n" output_path

test/test_serializer.ml

···
 (* Test runner for html5lib-tests serializer tests *)
 
 module Dom = Html5rw_dom
+module Report = Test_report
 
 (* Extract values from JSON *)
 let json_string = function
···
   match json_mem name obj with
   | Some v -> v
   | None -> failwith ("Missing member: " ^ name)
+
+let rec json_to_string = function
+  | Jsont.Null _ -> "null"
+  | Jsont.Bool (b, _) -> string_of_bool b
+  | Jsont.Number (n, _) -> Printf.sprintf "%g" n
+  | Jsont.String (s, _) -> Printf.sprintf "%S" s
+  | Jsont.Array (arr, _) ->
+    "[" ^ String.concat ", " (List.map json_to_string arr) ^ "]"
+  | Jsont.Object (obj, _) ->
+    "{" ^ String.concat ", " (List.map (fun ((n, _), v) -> Printf.sprintf "%S: %s" n (json_to_string v)) obj) ^ "}"
 
 (* Serialization options *)
 type serialize_options = {
···
   input : Jsont.json list;
   expected : string list;
   options : serialize_options;
+  raw_json : string;  (* Original JSON representation of this test *)
 }
 
 let parse_test_case json =
+  let raw_json = json_to_string json in
   let obj = json_object json in
   let description = json_string (json_mem_exn "description" obj) in
   let input = json_array (json_mem_exn "input" obj) in
   let expected = List.map json_string (json_array (json_mem_exn "expected" obj)) in
   let options = parse_options (json_mem "options" obj) in
-  { description; input; expected; options }
+  { description; input; expected; options; raw_json }
 
 (* Parse attrs that can be either array [{name, value}] or object {name: value} or empty {} *)
 let parse_attrs attrs_json =
···
     (false, Printf.sprintf "EXCEPTION: %s" (Printexc.to_string e), test.expected)
 
 (* Run all tests in a file *)
+let format_options opts =
+  let parts = [] in
+  let parts = if opts.quote_char_explicit then
+    Printf.sprintf "quote_char='%c'" opts.quote_char :: parts else parts in
+  let parts = if not opts.minimize_boolean_attributes then
+    "minimize_bool=false" :: parts else parts in
+  let parts = if opts.use_trailing_solidus then
+    "trailing_solidus=true" :: parts else parts in
+  let parts = if opts.escape_lt_in_attrs then
+    "escape_lt=true" :: parts else parts in
+  let parts = if opts.escape_rcdata then
+    "escape_rcdata=true" :: parts else parts in
+  let parts = if opts.strip_whitespace then
+    "strip_ws=true" :: parts else parts in
+  let parts = if opts.inject_meta_charset then
+    "inject_charset=true" :: parts else parts in
+  let parts = if not opts.omit_optional_tags then
+    "omit_tags=false" :: parts else parts in
+  if parts = [] then "(defaults)" else String.concat ", " (List.rev parts)
+
 let run_file path =
   let content =
     let ic = open_in path in
···
   let filename = Filename.basename path in
   let passed = ref 0 in
   let failed = ref 0 in
-  let first_failures = ref [] in
+  let results = ref [] in
 
   List.iteri (fun i test_json ->
     try
       let test = parse_test_case test_json in
       let (success, actual, expected) = run_test test in
 
-      if success then
-        incr passed
-      else begin
-        incr failed;
-        if List.length !first_failures < 3 then
-          first_failures := (i + 1, test.description, actual, expected) :: !first_failures
-      end
+      let result : Report.test_result = {
+        test_num = i + 1;
+        description = test.description;
+        input = String.concat "\n" (List.map (fun tok ->
+          (* Simplified token representation *)
+          match tok with
+          | Jsont.Array (arr, _) ->
+            (match arr with
+             | Jsont.String (ty, _) :: rest ->
+               Printf.sprintf "%s: %s" ty (String.concat ", " (List.map (function
+                 | Jsont.String (s, _) -> Printf.sprintf "%S" s
+                 | Jsont.Object _ -> "{...}"
+                 | Jsont.Null _ -> "null"
+                 | _ -> "?"
+               ) rest))
+             | _ -> "?")
+          | _ -> "?"
+        ) test.input);
+        expected = String.concat " | " expected;
+        actual;
+        success;
+        details = [
+          ("Options", format_options test.options);
+          ("Expected Variants", string_of_int (List.length expected));
+        ];
+        raw_test_data = Some test.raw_json;
+      } in
+      results := result :: !results;
+
+      if success then incr passed else incr failed
     with e ->
       incr failed;
+      let result : Report.test_result = {
+        test_num = i + 1;
+        description = Printf.sprintf "Test %d" (i + 1);
+        input = "";
+        expected = "";
+        actual = Printf.sprintf "EXCEPTION: %s" (Printexc.to_string e);
+        success = false;
+        details = [];
+        raw_test_data = Some (json_to_string test_json);
+      } in
+      results := result :: !results;
       Printf.eprintf "Exception parsing test %d: %s\n" (i + 1) (Printexc.to_string e)
   ) tests_json;
 
-  (!passed, !failed, List.rev !first_failures, filename)
+  let file_result : Report.file_result = {
+    filename;
+    test_type = "Serializer";
+    passed_count = !passed;
+    failed_count = !failed;
+    tests = List.rev !results;
+  } in
+  (file_result, !passed, !failed)
 
 let () =
   let test_dir = Sys.argv.(1) in
···
 
   let total_passed = ref 0 in
   let total_failed = ref 0 in
-  let all_failures = ref [] in
+  let file_results = ref [] in
 
   List.iter (fun file ->
     let path = Filename.concat test_dir file in
-    let (passed, failed, failures, filename) = run_file path in
+    let (file_result, passed, failed) = run_file path in
     total_passed := !total_passed + passed;
     total_failed := !total_failed + failed;
-    if failures <> [] then
-      all_failures := (filename, failures) :: !all_failures;
-    Printf.printf "%s: %d passed, %d failed\n" filename passed failed
+    file_results := file_result :: !file_results;
+    Printf.printf "%s: %d passed, %d failed\n" file passed failed
   ) (List.sort String.compare test_files);
 
   Printf.printf "\n=== Summary ===\n";
   Printf.printf "Total: %d passed, %d failed\n" !total_passed !total_failed;
 
-  if !all_failures <> [] then begin
-    Printf.printf "\n=== First failures ===\n";
-    List.iter (fun (filename, failures) ->
-      List.iter (fun (test_num, desc, actual, expected) ->
-        Printf.printf "\n--- %s test %d ---\n" filename test_num;
-        Printf.printf "Description: %s\n" desc;
-        Printf.printf "Expected: %s\n" (String.concat " | " expected);
-        Printf.printf "Actual:   %s\n" actual
-      ) failures
-    ) (List.rev !all_failures)
-  end;
+  (* Generate HTML report *)
+  let report : Report.report = {
+    title = "HTML5 Serializer Tests";
+    test_type = "serializer";
+    description = "These tests validate the HTML serialization algorithm for converting DOM trees back to HTML text. \
+                   Each test provides a sequence of tokens (start tags, end tags, text, comments, doctypes) and one \
+                   or more valid serialized outputs. Tests cover attribute quoting, boolean attribute minimization, \
+                   self-closing tag syntax (trailing solidus), entity escaping, whitespace handling, meta charset \
+                   injection, and optional tag omission rules as specified in the HTML Standard. Multiple expected \
+                   outputs allow for valid variations in serialization style.";
+    files = List.rev !file_results;
+    total_passed = !total_passed;
+    total_failed = !total_failed;
+  } in
+  Report.generate_report report "test_serializer_report.html";
 
   exit (if !total_failed > 0 then 1 else 0)

test/test_tokenizer.ml

···
 open Bytesrw
 
 module Tokenizer = Html5rw_tokenizer
+module Report = Test_report
 
 (* Token collector sink - collects all tokens into a list *)
 module TokenCollector = struct
···
   last_start_tag : string option;
   double_escaped : bool;
   xml_mode : bool;
+  raw_json : string;  (* Original JSON representation of this test *)
 }
 
 (* Unescape double-escaped strings from tests *)
···
   | Some v -> v
   | None -> failwith ("Missing member: " ^ name)
 
+(* Format JSON for display *)
+let rec json_to_string = function
+  | Jsont.Null _ -> "null"
+  | Jsont.Bool (b, _) -> string_of_bool b
+  | Jsont.Number (n, _) -> Printf.sprintf "%g" n
+  | Jsont.String (s, _) -> Printf.sprintf "%S" s
+  | Jsont.Array (arr, _) ->
+    "[" ^ String.concat ", " (List.map json_to_string arr) ^ "]"
+  | Jsont.Object (obj, _) ->
+    "{" ^ String.concat ", " (List.map (fun ((n, _), v) -> Printf.sprintf "%S: %s" n (json_to_string v)) obj) ^ "}"
+
 (* Parse a single test case from JSON *)
 let parse_test_case ~xml_mode json =
+  let raw_json = json_to_string json in
   let obj = json_object json in
   let description = json_string (json_mem_exn "description" obj) in
   let input = json_string (json_mem_exn "input" obj) in
···
     | Some b -> json_bool b
     | None -> false
   in
-  { description; input; output; expected_error_count; initial_states; last_start_tag; double_escaped; xml_mode }
+  { description; input; output; expected_error_count; initial_states; last_start_tag; double_escaped; xml_mode; raw_json }
 
 (* Convert state name to State.t *)
 let state_of_string = function
···
 
   (tokens_match && errors_count_match, actual_tokens, expected, actual_error_count, test.expected_error_count)
 
-(* Format JSON for display *)
-let rec json_to_string = function
-  | Jsont.Null _ -> "null"
-  | Jsont.Bool (b, _) -> string_of_bool b
-  | Jsont.Number (n, _) -> Printf.sprintf "%g" n
-  | Jsont.String (s, _) -> Printf.sprintf "%S" s
-  | Jsont.Array (arr, _) ->
-    "[" ^ String.concat ", " (List.map json_to_string arr) ^ "]"
-  | Jsont.Object (obj, _) ->
-    "{" ^ String.concat ", " (List.map (fun ((n, _), v) -> Printf.sprintf "%S: %s" n (json_to_string v)) obj) ^ "}"
-
 (* Run all tests in a file *)
 let run_file path =
   let content =
···
   let filename = Filename.basename path in
   let passed = ref 0 in
   let failed = ref 0 in
-  let first_failures = ref [] in
+  let results = ref [] in
 
   List.iteri (fun i test ->
-    (* test is already parsed *)
-
     (* Run for each initial state *)
     List.iter (fun state_name ->
       try
         let state = state_of_string state_name in
         let (success, actual, expected, actual_err_count, expected_err_count) = run_test test state in
 
-        if success then
-          incr passed
-        else begin
-          incr failed;
-          if List.length !first_failures < 3 then
-            first_failures := (i + 1, test.description, state_name, actual, expected, actual_err_count, expected_err_count) :: !first_failures
-        end
+        let description = Printf.sprintf "[%s] %s" state_name test.description in
+        let result : Report.test_result = {
+          test_num = i + 1;
+          description;
+          input = test.input;
+          expected = String.concat "\n" (List.map json_to_string expected);
+          actual = String.concat "\n" (List.map json_to_string actual);
+          success;
+          details = [
+            ("Initial State", state_name);
+            ("Last Start Tag", Option.value test.last_start_tag ~default:"(none)");
+            ("Double Escaped", string_of_bool test.double_escaped);
+            ("XML Mode", string_of_bool test.xml_mode);
+            ("Expected Errors", string_of_int expected_err_count);
+            ("Actual Errors", string_of_int actual_err_count);
+          ];
+          raw_test_data = Some test.raw_json;
+        } in
+        results := result :: !results;
+
+        if success then incr passed else incr failed
       with e ->
         incr failed;
-        if List.length !first_failures < 3 then
-          first_failures := (i + 1, test.description, state_name, [], [], 0, 0) :: !first_failures;
+        let result : Report.test_result = {
+          test_num = i + 1;
+          description = Printf.sprintf "[%s] %s" state_name test.description;
+          input = test.input;
+          expected = "";
+          actual = Printf.sprintf "EXCEPTION: %s" (Printexc.to_string e);
+          success = false;
+          details = [];
+          raw_test_data = Some test.raw_json;
+        } in
+        results := result :: !results;
         Printf.eprintf "Exception in test %d (%s): %s\n" (i + 1) test.description (Printexc.to_string e)
     ) test.initial_states
   ) all_tests;
 
-  (!passed, !failed, List.rev !first_failures, filename)
+  let file_result : Report.file_result = {
+    filename;
+    test_type = "Tokenizer";
+    passed_count = !passed;
+    failed_count = !failed;
+    tests = List.rev !results;
+  } in
+  (file_result, !passed, !failed)
 
 let () =
   let test_dir = Sys.argv.(1) in
···
 
   let total_passed = ref 0 in
   let total_failed = ref 0 in
-  let all_failures = ref [] in
+  let file_results = ref [] in
 
   List.iter (fun file ->
     let path = Filename.concat test_dir file in
-    let (passed, failed, failures, filename) = run_file path in
+    let (file_result, passed, failed) = run_file path in
     total_passed := !total_passed + passed;
     total_failed := !total_failed + failed;
-    if failures <> [] then
-      all_failures := (filename, failures) :: !all_failures;
-    Printf.printf "%s: %d passed, %d failed\n" filename passed failed
+    file_results := file_result :: !file_results;
+    Printf.printf "%s: %d passed, %d failed\n" file passed failed
   ) (List.sort String.compare test_files);
 
   Printf.printf "\n=== Summary ===\n";
   Printf.printf "Total: %d passed, %d failed\n" !total_passed !total_failed;
 
-  if !all_failures <> [] then begin
-    Printf.printf "\n=== First failures ===\n";
-    List.iter (fun (filename, failures) ->
-      List.iter (fun (test_num, desc, state, actual, expected, actual_err_count, expected_err_count) ->
-        Printf.printf "\n--- %s test %d (%s) in %s ---\n" filename test_num state desc;
-        Printf.printf "Expected tokens: [%s]\n" (String.concat "; " (List.map json_to_string expected));
-        Printf.printf "Actual tokens:   [%s]\n" (String.concat "; " (List.map json_to_string actual));
-        Printf.printf "Expected %d errors, got %d\n" expected_err_count actual_err_count
-      ) failures
-    ) (List.rev !all_failures)
-  end;
+  (* Generate HTML report *)
+  let report : Report.report = {
+    title = "HTML5 Tokenizer Tests";
+    test_type = "tokenizer";
+    description = "These tests validate the HTML5 tokenization algorithm as specified in the WHATWG HTML Standard. \
+                   The tokenizer converts HTML input into a stream of tokens (DOCTYPE, start tags, end tags, comments, \
+                   character data, and EOF). Each test specifies input HTML, expected tokens in JSON array format, \
+                   and the initial tokenizer state. Tests cover normal parsing, RCDATA/RAWTEXT/PLAINTEXT states, \
+                   script data parsing, CDATA sections, and various error conditions. Some tests are double-escaped \
+                   to represent special characters. XML violation tests check behavior differences from XML mode.";
+    files = List.rev !file_results;
+    total_passed = !total_passed;
+    total_failed = !total_failed;
+  } in
+  Report.generate_report report "test_tokenizer_report.html";
 
   exit (if !total_failed > 0 then 1 else 0)