From 2326a220ffe2b04465147acf7371891ca1103a6a Mon Sep 17 00:00:00 2001
From: Gabriel Silva <gabrielsilvadev.comercial@gmail.com>
Date: Wed, 28 Oct 2026 15:41:09 -0300
Subject: [PATCH 1/2] fix(parser): stop the lexers from hanging on a NUL
 character

---
 .../src/parser/expression/lexer.rs            |  7 +++---
 .../src/parser/html/lexer.rs                  |  4 ++++
 .../tests/expression_lexer_test.rs            | 10 ++++++++
 .../tests/html_lexer_test.rs                  | 24 +++++++++++++++++++
 4 files changed, 42 insertions(+), 3 deletions(-)

diff --git a/crates/oxc_angular_compiler/src/parser/expression/lexer.rs b/crates/oxc_angular_compiler/src/parser/expression/lexer.rs
index f0680c00e..187e0dfc4 100644
--- a/crates/oxc_angular_compiler/src/parser/expression/lexer.rs
+++ b/crates/oxc_angular_compiler/src/parser/expression/lexer.rs
@@ -454,7 +454,8 @@ impl<'a> Lexer<'a> {
     /// Advances the index by the current character's byte length and returns the character.
     fn advance(&mut self) -> char {
         let ch = self.peek();
-        if ch != chars::EOF {
+        // By the index, not the character: a NUL in the input reads as `EOF` too.
+        if !self.is_eof() {
             self.index += ch.len_utf8() as u32;
         }
         ch
@@ -476,8 +477,8 @@ impl<'a> Lexer<'a> {
     fn scan_token(&mut self, start: u32) {
         let ch = self.advance();
 
-        // Whitespace
-        if chars::is_whitespace(ch) {
+        // Whitespace. Angular's `scanToken` skips every character up to the space, NUL among them.
+        if ch <= chars::SPACE || chars::is_whitespace(ch) {
             return;
         }
 
diff --git a/crates/oxc_angular_compiler/src/parser/html/lexer.rs b/crates/oxc_angular_compiler/src/parser/html/lexer.rs
index ea9e69c8d..1a0027bb9 100644
--- a/crates/oxc_angular_compiler/src/parser/html/lexer.rs
+++ b/crates/oxc_angular_compiler/src/parser/html/lexer.rs
@@ -706,6 +706,10 @@ impl<'a> HtmlLexer<'a> {
 
     /// Tokenizes the input.
     pub fn tokenize(mut self) -> HtmlTokenizeResult {
+        // Angular's cursor reads NUL as `$EOF` (0), so the input ends at the first one.
+        if let Some(nul) = self.input[self.index as usize..self.length as usize].find('\0') {
+            self.length = self.index + nul as u32;
+        }
         while self.index < self.length {
             self.scan_token();
         }
diff --git a/crates/oxc_angular_compiler/tests/expression_lexer_test.rs b/crates/oxc_angular_compiler/tests/expression_lexer_test.rs
index 8fcdbd6b2..e3c02ba92 100644
--- a/crates/oxc_angular_compiler/tests/expression_lexer_test.rs
+++ b/crates/oxc_angular_compiler/tests/expression_lexer_test.rs
@@ -1176,6 +1176,16 @@ mod regular_expressions {
 mod errors {
     use super::*;
 
+    #[test]
+    fn should_skip_a_nul_character_like_whitespace() {
+        // Angular's `scanToken` skips every character up to the space.
+        let tokens = lex("a\0b");
+        assert_eq!(tokens.len(), 2);
+        expect_identifier_token(&tokens[0], 0, 1, "a");
+        expect_identifier_token(&tokens[1], 2, 3, "b");
+        assert!(lex("'a\0b'").iter().any(super::TokenInfo::is_error));
+    }
+
     #[test]
     fn should_report_unterminated_string() {
         let tokens = lex(r#""hello"#);
diff --git a/crates/oxc_angular_compiler/tests/html_lexer_test.rs b/crates/oxc_angular_compiler/tests/html_lexer_test.rs
index b950f3ce6..a278f1f55 100644
--- a/crates/oxc_angular_compiler/tests/html_lexer_test.rs
+++ b/crates/oxc_angular_compiler/tests/html_lexer_test.rs
@@ -1900,6 +1900,30 @@ mod positions {
 mod edge_cases {
     use super::*;
 
+    #[test]
+    fn should_end_the_input_at_a_nul_character() {
+        // Angular's cursor reads NUL as `$EOF`, so nothing after it is read.
+        assert_eq!(
+            tokenize_and_humanize_parts("<b>a</b>\0<i>{{ b }}</i>"),
+            vec![
+                (HtmlTokenType::TagOpenStart, vec![String::new(), "b".to_string()]),
+                (HtmlTokenType::TagOpenEnd, vec![]),
+                (HtmlTokenType::Text, vec!["a".to_string()]),
+                (HtmlTokenType::TagClose, vec![String::new(), "b".to_string()]),
+                (HtmlTokenType::Eof, vec![]),
+            ]
+        );
+        assert_eq!(
+            tokenize_and_humanize_parts("{{ a\0 }}"),
+            vec![
+                (HtmlTokenType::Text, vec![String::new()]),
+                (HtmlTokenType::Interpolation, vec!["{{".to_string(), " a".to_string()]),
+                (HtmlTokenType::Text, vec![String::new()]),
+                (HtmlTokenType::Eof, vec![]),
+            ]
+        );
+    }
+
     #[test]
     fn should_handle_empty_input() {
         let result = tokenize("");

From ecb086085bec83d1162ee91b266dd55e3c7c81c7 Mon Sep 17 00:00:00 2001
From: LongYinan <lynweklm@gmail.com>
Date: Fri, 30 Oct 2026 14:30:21 +0800
Subject: [PATCH 2/2] fix(parser): stop at a NUL only where Angular's lexers do

Angular's cursor peeks a NUL as `$EOF`, but `advance()` still moves past it.
So only the loops that check `peek() === $EOF` stop there: the main loop,
text, interpolation, tag and attribute names, unquoted values, and block
parameters outside quotes. Comments, CDATA, DOCTYPE, raw text (`<style>`,
`<textarea>`, `<title>`, `<script>`), quoted attribute values, `[...]`
attribute names and ICU values read a NUL as text.

Cutting the input at the first NUL broke the second group. For example,
`<!--a\0b--><p>{{x}}</p>` gave an error, and `<textarea>a\0b</textarea>`
silently dropped the rest of the template, while ngtsc compiles both.

- HTML lexer: stop the main loop and interpolations at a NUL. The scanners
  that read to a closing marker now check the index, not the character.
- Interpolation: read the character after `//` before checking again, as
  Angular does (`{{ a //}}b` is one interpolation).
- Expression lexer: skip whitespace the same way in `${...}` as in
  `scanToken` (every character up to the space, and NBSP), so `${a\0}`
  compiles like it does in Angular.
- Tests: check the tokens and that there are no errors for each case.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../src/parser/expression/lexer.rs            |  12 +-
 .../src/parser/html/lexer.rs                  |  45 ++++--
 .../tests/expression_lexer_test.rs            |  36 ++++-
 .../tests/html_lexer_test.rs                  | 140 +++++++++++++++++-
 4 files changed, 203 insertions(+), 30 deletions(-)

diff --git a/crates/oxc_angular_compiler/src/parser/expression/lexer.rs b/crates/oxc_angular_compiler/src/parser/expression/lexer.rs
index 187e0dfc4..958f0ace3 100644
--- a/crates/oxc_angular_compiler/src/parser/expression/lexer.rs
+++ b/crates/oxc_angular_compiler/src/parser/expression/lexer.rs
@@ -466,9 +466,15 @@ impl<'a> Lexer<'a> {
         self.index >= self.length
     }
 
+    /// Whitespace as Angular's `scanToken` skips it: every character up to the space (NUL and the
+    /// other control characters too), and NBSP.
+    fn is_skipped_whitespace(ch: char) -> bool {
+        ch <= chars::SPACE || ch == chars::NBSP
+    }
+
     /// Skips whitespace characters.
     fn skip_whitespace(&mut self) {
-        while !self.is_eof() && chars::is_whitespace(self.peek()) {
+        while !self.is_eof() && Self::is_skipped_whitespace(self.peek()) {
             self.advance();
         }
     }
@@ -477,8 +483,8 @@ impl<'a> Lexer<'a> {
     fn scan_token(&mut self, start: u32) {
         let ch = self.advance();
 
-        // Whitespace. Angular's `scanToken` skips every character up to the space, NUL among them.
-        if ch <= chars::SPACE || chars::is_whitespace(ch) {
+        // Whitespace
+        if Self::is_skipped_whitespace(ch) {
             return;
         }
 
diff --git a/crates/oxc_angular_compiler/src/parser/html/lexer.rs b/crates/oxc_angular_compiler/src/parser/html/lexer.rs
index 1a0027bb9..e42b3afd3 100644
--- a/crates/oxc_angular_compiler/src/parser/html/lexer.rs
+++ b/crates/oxc_angular_compiler/src/parser/html/lexer.rs
@@ -706,11 +706,8 @@ impl<'a> HtmlLexer<'a> {
 
     /// Tokenizes the input.
     pub fn tokenize(mut self) -> HtmlTokenizeResult {
-        // Angular's cursor reads NUL as `$EOF` (0), so the input ends at the first one.
-        if let Some(nul) = self.input[self.index as usize..self.length as usize].find('\0') {
-            self.length = self.index + nul as u32;
-        }
-        while self.index < self.length {
+        // Like Angular's loop, stop at a NUL: its cursor peeks one as `$EOF`.
+        while self.index < self.length && self.peek() != chars::EOF {
             self.scan_token();
         }
 
@@ -1512,6 +1509,11 @@ impl<'a> HtmlLexer<'a> {
                     continue;
                 }
 
+                // A NUL ends the parameter, but not inside a quote, as in Angular.
+                if ch == chars::EOF && in_quote.is_none() {
+                    break;
+                }
+
                 // If in a quote, check for quote end
                 if let Some(quote_char) = in_quote {
                     if ch == quote_char {
@@ -1607,7 +1609,8 @@ impl<'a> HtmlLexer<'a> {
         let mut in_quote: Option<char> = None;
         let mut in_comment = false;
 
-        while self.index < self.length {
+        // A NUL ends the interpolation, even inside a quote, as in Angular.
+        while self.index < self.length && self.peek() != chars::EOF {
             let ch = self.peek();
 
             // Check for tag start - break out of interpolation
@@ -1656,6 +1659,11 @@ impl<'a> HtmlLexer<'a> {
                 in_comment = true;
                 self.advance();
                 self.advance();
+                // Like Angular, also take the character after `//` before checking again.
+                if self.peek() == '\\' {
+                    self.advance();
+                }
+                self.advance();
                 continue;
             }
 
@@ -1949,7 +1957,8 @@ impl<'a> HtmlLexer<'a> {
                 }
             }
 
-            if self.peek() == chars::EOF {
+            // Raw text reads through a NUL, as Angular's `_consumeRawText` does.
+            if self.index >= self.length {
                 // End of input - emit what we have (if non-empty)
                 if consume_entities {
                     if text_start < self.index {
@@ -2153,7 +2162,7 @@ impl<'a> HtmlLexer<'a> {
                 // Not our closing tag - continue scanning
             }
 
-            if self.peek() == chars::EOF {
+            if self.index >= self.length {
                 // EOF reached - emit whatever content we have
                 let content = &self.input[content_start as usize..self.index as usize];
                 let normalized = normalize_line_endings(content);
@@ -2499,7 +2508,7 @@ impl<'a> HtmlLexer<'a> {
             let starts_with_bracket = self.peek() == '[';
             let mut open_brackets: i32 = 0;
 
-            while self.peek() != chars::EOF {
+            while self.index < self.length {
                 let ch = self.peek();
 
                 // Track bracket depth (can go negative for mismatched brackets)
@@ -2515,9 +2524,10 @@ impl<'a> HtmlLexer<'a> {
                     // - When brackets are balanced or mismatched (open_brackets <= 0):
                     //   stop at name-end characters (whitespace, =, >, <, /, ', ", EOF)
                     // - When brackets are unbalanced with more opens (open_brackets > 0):
-                    //   only stop on newline (interrupts matching)
+                    //   only stop on newline (interrupts matching), so a NUL is read
                     if open_brackets <= 0 {
-                        if chars::is_whitespace(ch)
+                        if ch == chars::EOF
+                            || chars::is_whitespace(ch)
                             || ch == '='
                             || ch == '>'
                             || ch == '<'
@@ -2535,7 +2545,8 @@ impl<'a> HtmlLexer<'a> {
                     }
                 } else {
                     // Normal attribute name - stop at standard name-end characters
-                    if chars::is_whitespace(ch)
+                    if ch == chars::EOF
+                        || chars::is_whitespace(ch)
                         || ch == '='
                         || ch == '>'
                         || ch == '<'
@@ -2743,7 +2754,8 @@ impl<'a> HtmlLexer<'a> {
 
         let mut text_start = self.index;
 
-        while self.peek() != quote && self.peek() != chars::EOF {
+        // Only the quote ends the value: like Angular, read a NUL as text (an interpolation still stops there).
+        while self.peek() != quote && self.index < self.length {
             if self.starts_with(self.interpolation_start) {
                 // Emit any accumulated text first (or empty text token if at start of interpolation)
                 let text = &self.input[text_start as usize..self.index as usize];
@@ -3128,9 +3140,10 @@ impl<'a> HtmlLexer<'a> {
     }
 
     /// Reads characters until the given terminator (does not consume the terminator).
+    /// Like Angular's `_readUntil`, a NUL is read as text.
     fn read_until(&mut self, terminator: char) -> String {
         let start = self.index;
-        while self.peek() != terminator && self.peek() != chars::EOF {
+        while self.peek() != terminator && self.index < self.length {
             self.advance();
         }
         self.input[start as usize..self.index as usize].to_string()
@@ -3337,8 +3350,8 @@ impl<'a> HtmlLexer<'a> {
 
             // Numeric entity doesn't end with semicolon - this is an error
             // Advance cursor to include the peeked character in the error message
-            // (unless we're at EOF)
-            if self.peek() == chars::EOF {
+            // (unless we're at the end; a NUL is read like Angular's cursor does)
+            if self.index >= self.length {
                 // EOF - report "Unexpected character EOF"
                 self.errors.push(HtmlTokenError {
                     msg: "Unexpected character \"EOF\"".to_string(),
diff --git a/crates/oxc_angular_compiler/tests/expression_lexer_test.rs b/crates/oxc_angular_compiler/tests/expression_lexer_test.rs
index e3c02ba92..01d2205df 100644
--- a/crates/oxc_angular_compiler/tests/expression_lexer_test.rs
+++ b/crates/oxc_angular_compiler/tests/expression_lexer_test.rs
@@ -355,6 +355,17 @@ mod token {
         expect_identifier_token(&tokens[1], 8, 9, "b");
     }
 
+    #[test]
+    fn should_skip_control_characters_like_whitespace() {
+        // Angular's `scanToken` skips every character up to the space, NUL among them.
+        for input in ["a\0b", "a\x01b"] {
+            let tokens = lex(input);
+            assert_eq!(tokens.len(), 2);
+            expect_identifier_token(&tokens[0], 0, 1, "a");
+            expect_identifier_token(&tokens[1], 2, 3, "b");
+        }
+    }
+
     #[test]
     fn should_tokenize_quoted_string() {
         let tokens = lex(r#"['\'', "\""]"#);
@@ -632,6 +643,17 @@ mod template_literals {
         assert_eq!(tokens[0].str_value, "\u{00A0}");
     }
 
+    #[test]
+    fn should_skip_a_nul_inside_an_interpolation() {
+        let tokens = lex("`${a\0}`");
+        assert_eq!(tokens.len(), 5);
+        expect_string_token(&tokens[0], 0, 1, "", StringTokenKind::TemplateLiteralPart);
+        expect_operator_token(&tokens[1], 1, 3, "${");
+        expect_identifier_token(&tokens[2], 3, 4, "a");
+        expect_character_token(&tokens[3], 5, 6, "}");
+        expect_string_token(&tokens[4], 6, 7, "", StringTokenKind::TemplateLiteralEnd);
+    }
+
     #[test]
     fn should_tokenize_template_literal_with_interpolation_at_end() {
         let tokens = lex("`hello ${name}`");
@@ -1177,13 +1199,13 @@ mod errors {
     use super::*;
 
     #[test]
-    fn should_skip_a_nul_character_like_whitespace() {
-        // Angular's `scanToken` skips every character up to the space.
-        let tokens = lex("a\0b");
-        assert_eq!(tokens.len(), 2);
-        expect_identifier_token(&tokens[0], 0, 1, "a");
-        expect_identifier_token(&tokens[1], 2, 3, "b");
-        assert!(lex("'a\0b'").iter().any(super::TokenInfo::is_error));
+    fn should_report_a_nul_in_a_string_as_unterminated() {
+        // As in Angular: the string ends at the NUL, `b` is read on its own, and the last quote opens another string.
+        let tokens = lex("'a\0b'");
+        assert_eq!(tokens.len(), 3);
+        assert!(tokens[0].is_error());
+        expect_identifier_token(&tokens[1], 3, 4, "b");
+        assert!(tokens[2].is_error());
     }
 
     #[test]
diff --git a/crates/oxc_angular_compiler/tests/html_lexer_test.rs b/crates/oxc_angular_compiler/tests/html_lexer_test.rs
index a278f1f55..acf01a450 100644
--- a/crates/oxc_angular_compiler/tests/html_lexer_test.rs
+++ b/crates/oxc_angular_compiler/tests/html_lexer_test.rs
@@ -1900,11 +1900,18 @@ mod positions {
 mod edge_cases {
     use super::*;
 
+    /// Tokenizes and returns humanized parts, checking that there are no errors.
+    fn humanize_parts_without_errors(input: &str, icu: bool) -> Vec<(HtmlTokenType, Vec<String>)> {
+        let result = HtmlLexer::new(input).with_expansion_forms(icu).tokenize();
+        assert!(result.errors.is_empty(), "{input:?}: {:?}", result.errors);
+        result.tokens.into_iter().map(|t| (t.token_type, t.parts)).collect()
+    }
+
     #[test]
-    fn should_end_the_input_at_a_nul_character() {
-        // Angular's cursor reads NUL as `$EOF`, so nothing after it is read.
+    fn should_stop_at_a_nul_in_text_and_interpolation() {
+        // Angular's cursor peeks a NUL as `$EOF`, which ends text and interpolations.
         assert_eq!(
-            tokenize_and_humanize_parts("<b>a</b>\0<i>{{ b }}</i>"),
+            humanize_parts_without_errors("<b>a</b>\0<i>{{ b }}</i>", false),
             vec![
                 (HtmlTokenType::TagOpenStart, vec![String::new(), "b".to_string()]),
                 (HtmlTokenType::TagOpenEnd, vec![]),
@@ -1914,7 +1921,7 @@ mod edge_cases {
             ]
         );
         assert_eq!(
-            tokenize_and_humanize_parts("{{ a\0 }}"),
+            humanize_parts_without_errors("{{ a\0 }}", false),
             vec![
                 (HtmlTokenType::Text, vec![String::new()]),
                 (HtmlTokenType::Interpolation, vec!["{{".to_string(), " a".to_string()]),
@@ -1924,6 +1931,131 @@ mod edge_cases {
         );
     }
 
+    #[test]
+    fn should_read_a_nul_in_comments_and_cdata() {
+        // These read to their closing marker, so a NUL is just text in them.
+        assert_eq!(
+            humanize_parts_without_errors("<!--a\0b-->c", false),
+            vec![
+                (HtmlTokenType::CommentStart, vec![]),
+                (HtmlTokenType::RawText, vec!["a\0b".to_string()]),
+                (HtmlTokenType::CommentEnd, vec![]),
+                (HtmlTokenType::Text, vec!["c".to_string()]),
+                (HtmlTokenType::Eof, vec![]),
+            ]
+        );
+        assert_eq!(
+            humanize_parts_without_errors("<![CDATA[a\0b]]>c", false),
+            vec![
+                (HtmlTokenType::CdataStart, vec![]),
+                (HtmlTokenType::RawText, vec!["a\0b".to_string()]),
+                (HtmlTokenType::CdataEnd, vec![]),
+                (HtmlTokenType::Text, vec!["c".to_string()]),
+                (HtmlTokenType::Eof, vec![]),
+            ]
+        );
+    }
+
+    #[test]
+    fn should_read_a_nul_in_raw_text() {
+        assert_eq!(
+            humanize_parts_without_errors("<textarea>a\0b</textarea>c", false),
+            vec![
+                (HtmlTokenType::TagOpenStart, vec![String::new(), "textarea".to_string()]),
+                (HtmlTokenType::TagOpenEnd, vec![]),
+                (HtmlTokenType::EscapableRawText, vec!["a\0b".to_string()]),
+                (HtmlTokenType::TagClose, vec![String::new(), "textarea".to_string()]),
+                (HtmlTokenType::Text, vec!["c".to_string()]),
+                (HtmlTokenType::Eof, vec![]),
+            ]
+        );
+    }
+
+    #[test]
+    fn should_read_a_nul_in_a_quoted_attribute_value() {
+        assert_eq!(
+            humanize_parts_without_errors("<div a=\"x\0y\">z</div>", false),
+            vec![
+                (HtmlTokenType::TagOpenStart, vec![String::new(), "div".to_string()]),
+                (HtmlTokenType::AttrName, vec![String::new(), "a".to_string()]),
+                (HtmlTokenType::AttrQuote, vec!["\"".to_string()]),
+                (HtmlTokenType::AttrValueText, vec!["x\0y".to_string()]),
+                (HtmlTokenType::AttrQuote, vec!["\"".to_string()]),
+                (HtmlTokenType::TagOpenEnd, vec![]),
+                (HtmlTokenType::Text, vec!["z".to_string()]),
+                (HtmlTokenType::TagClose, vec![String::new(), "div".to_string()]),
+                (HtmlTokenType::Eof, vec![]),
+            ]
+        );
+    }
+
+    #[test]
+    fn should_stop_a_block_parameter_at_a_nul_outside_quotes() {
+        assert_eq!(
+            humanize_parts_without_errors("@if (a\0) {x}", false),
+            vec![
+                (HtmlTokenType::IncompleteBlockOpen, vec!["if".to_string()]),
+                (HtmlTokenType::BlockParameter, vec!["a".to_string()]),
+                (HtmlTokenType::Eof, vec![]),
+            ]
+        );
+        assert_eq!(
+            humanize_parts_without_errors("@if (\"a\0b\") {x}", false),
+            vec![
+                (HtmlTokenType::BlockOpenStart, vec!["if".to_string()]),
+                (HtmlTokenType::BlockParameter, vec!["\"a\0b\"".to_string()]),
+                (HtmlTokenType::BlockOpenEnd, vec![]),
+                (HtmlTokenType::Text, vec!["x".to_string()]),
+                (HtmlTokenType::BlockClose, vec![]),
+                (HtmlTokenType::Eof, vec![]),
+            ]
+        );
+    }
+
+    #[test]
+    fn should_read_a_nul_in_an_expansion_form_value() {
+        assert_eq!(
+            humanize_parts_without_errors("{a\0, select, x {b}}", true),
+            vec![
+                (HtmlTokenType::ExpansionFormStart, vec![]),
+                (HtmlTokenType::RawText, vec!["a\0".to_string()]),
+                (HtmlTokenType::RawText, vec!["select".to_string()]),
+                (HtmlTokenType::ExpansionCaseValue, vec!["x".to_string()]),
+                (HtmlTokenType::ExpansionCaseExpStart, vec![]),
+                (HtmlTokenType::Text, vec!["b".to_string()]),
+                (HtmlTokenType::ExpansionCaseExpEnd, vec![]),
+                (HtmlTokenType::ExpansionFormEnd, vec![]),
+                (HtmlTokenType::Eof, vec![]),
+            ]
+        );
+    }
+
+    #[test]
+    fn should_read_the_character_after_a_comment_start_in_an_interpolation() {
+        // Angular reads one more character after `//` before it checks for `}}` or a NUL again.
+        assert_eq!(
+            humanize_parts_without_errors("{{ a //}}b", false),
+            vec![
+                (HtmlTokenType::Text, vec![String::new()]),
+                (HtmlTokenType::Interpolation, vec!["{{".to_string(), " a //}}b".to_string()]),
+                (HtmlTokenType::Text, vec![String::new()]),
+                (HtmlTokenType::Eof, vec![]),
+            ]
+        );
+        assert_eq!(
+            humanize_parts_without_errors("{{ a //\0 }}b", false),
+            vec![
+                (HtmlTokenType::Text, vec![String::new()]),
+                (
+                    HtmlTokenType::Interpolation,
+                    vec!["{{".to_string(), " a //\0 ".to_string(), "}}".to_string()]
+                ),
+                (HtmlTokenType::Text, vec!["b".to_string()]),
+                (HtmlTokenType::Eof, vec![]),
+            ]
+        );
+    }
+
     #[test]
     fn should_handle_empty_input() {
         let result = tokenize("");