@tkeron/html-parser 0.1.7 → 1.0.0

package/tests/tree-construction-tests23.test.ts

@@ -0,0 +1,18 @@
+import { readFileSync } from "fs";
+import { parse } from "../src/index.ts";
+
+describe("Tree Construction Tests23 Tests", () => {
+  const data = readFileSync("tests/html5lib-data/tree-construction/tests23.dat", "utf8");
+  const tests = data.split("#data\n").slice(1);
+
+  for (const test of tests) {
+    const [input, expected] = test.split("#document\n");
+    const title = input.trim().split("\n")[0] || "Unnamed test";
+    const html = input.trim();
+
+    it.skip(title, () => {
+      const doc = parse(html);
+      expect(doc).toBeDefined();
+    });
+  }
+});

package/tests/tree-construction-tests24.test.ts

@@ -0,0 +1,18 @@
+import { readFileSync } from "fs";
+import { parse } from "../src/index.ts";
+
+describe("Tree Construction Tests24 Tests", () => {
+  const data = readFileSync("tests/html5lib-data/tree-construction/tests24.dat", "utf8");
+  const tests = data.split("#data\n").slice(1);
+
+  for (const test of tests) {
+    const [input, expected] = test.split("#document\n");
+    const title = input.trim().split("\n")[0] || "Unnamed test";
+    const html = input.trim();
+
+    it.skip(title, () => {
+      const doc = parse(html);
+      expect(doc).toBeDefined();
+    });
+  }
+});

package/tests/tree-construction-tests5.test.ts

@@ -0,0 +1,21 @@
+import { readFileSync } from "fs";
+import { parse } from "../src/index.ts";
+
+describe("Tree Construction Tests5 Tests", () => {
+  const content = readFileSync("tests/html5lib-data/tree-construction/tests5.dat", "utf8");
+  const sections = content.split("#data\n");
+
+  for (let i = 1; i < sections.length; i++) {
+    const section = sections[i];
+    const [dataPart, documentPart] = section.split("#document\n");
+    const data = dataPart.trim();
+    const expectedDocument = documentPart ? documentPart.split("#errors\n")[0].trim() : "";
+    const errors = documentPart && documentPart.includes("#errors\n") ? documentPart.split("#errors\n")[1].trim() : "";
+
+    it(`Tests5 test ${i}`, () => {
+      const doc = parse(data);
+      expect(doc).toBeDefined();
+      // TODO: Implement DOM serialization and comparison
+    });
+  }
+});

package/tests/tree-construction-tests6.test.ts

@@ -0,0 +1,21 @@
+import { readFileSync } from "fs";
+import { parse } from "../src/index.ts";
+
+describe("Tree Construction Tests6 Tests", () => {
+  const content = readFileSync("tests/html5lib-data/tree-construction/tests6.dat", "utf8");
+  const sections = content.split("#data\n");
+
+  for (let i = 1; i < sections.length; i++) {
+    const section = sections[i];
+    const [dataPart, documentPart] = section.split("#document\n");
+    const data = dataPart.trim();
+    const expectedDocument = documentPart ? documentPart.split("#errors\n")[0].trim() : "";
+    const errors = documentPart && documentPart.includes("#errors\n") ? documentPart.split("#errors\n")[1].trim() : "";
+
+    it(`Tests6 test ${i}`, () => {
+      const doc = parse(data);
+      expect(doc).toBeDefined();
+      // TODO: Implement DOM serialization and comparison
+    });
+  }
+});

package/tests/tree-construction-tests_innerHTML_1.test.ts

@@ -0,0 +1,21 @@
+import { readFileSync } from "fs";
+import { parse } from "../src/index.ts";
+
+describe("Tree Construction Tests_innerHTML_1 Tests", () => {
+  const content = readFileSync("tests/html5lib-data/tree-construction/tests_innerHTML_1.dat", "utf8");
+  const sections = content.split("#data\n");
+
+  for (let i = 1; i < sections.length; i++) {
+    const section = sections[i];
+    const [dataPart, documentPart] = section.split("#document\n");
+    const data = dataPart.trim();
+    const expectedDocument = documentPart ? documentPart.split("#errors\n")[0].trim() : "";
+    const errors = documentPart && documentPart.includes("#errors\n") ? documentPart.split("#errors\n")[1].trim() : "";
+
+    it(`Tests_innerHTML_1 test ${i}`, () => {
+      const doc = parse(data);
+      expect(doc).toBeDefined();
+      // TODO: Implement DOM serialization and comparison
+    });
+  }
+});

package/tests/official/README.md

@@ -1,87 +0,0 @@
-# Official HTML Parser Tests
-
-This directory contains implementations of official HTML parsing test suites to ensure compliance with web standards.
-
-## Test Sources
-
-### HTML5lib Tests
-- **Tokenizer Tests**: JSON format tests from `html5lib-tests/tokenizer/`
-- **Tree Construction Tests**: DAT format tests from `html5lib-tests/tree-construction/`
-
-### Web Platform Tests (WPT)
-- **Parsing Tests**: HTML format tests from `wpt/html/syntax/parsing/`
-
-### Benchmark/Compliance Tests
-- **Acid Tests**: Standardized rendering tests (Acid1, Acid2, Acid3)
-- **HTML5 Test Suite**: Comprehensive HTML5 compliance tests
-
-## Test Structure
-
-```
-tests/official/
-├── html5lib/
-│   ├── tokenizer/           # JSON tokenizer tests
-│   ├── tree-construction/   # DAT tree construction tests
-│   └── utils/              # HTML5lib test utilities
-├── wpt/                    # Web Platform Tests
-├── acid/                   # Acid tests
-├── benchmarks/             # Performance benchmarks
-└── compliance/             # Compliance test results
-```
-
-## Test Formats
-
-### HTML5lib Tokenizer Tests (JSON)
-```json
-{
-  "tests": [
-    {
-      "description": "Test description",
-      "input": "input_string",
-      "output": [expected_output_tokens],
-      "initialStates": [initial_states],
-      "lastStartTag": "last_start_tag",
-      "errors": [parse_errors]
-    }
-  ]
-}
-```
-
-### HTML5lib Tree Construction Tests (DAT)
-```
-#data
-<html>
-#errors
-(1,6): expected-doctype-but-got-start-tag
-#document
-| <html>
-|   <head>
-|   <body>
-```
-
-### Web Platform Tests (HTML)
-Standard HTML files with embedded test assertions and expected results.
-
-## Usage
-
-```bash
-# Run all official tests
-bun test tests/official/
-
-# Run specific test suite
-bun test tests/official/html5lib/
-bun test tests/official/wpt/
-bun test tests/official/acid/
-
-# Run with coverage
-bun test --coverage tests/official/
-```
-
-## Test Results
-
-Results are automatically generated and stored in `tests/official/compliance/` with detailed reports on:
-- Tokenizer compliance
-- Tree construction compliance  
-- Error handling accuracy
-- Performance benchmarks
-- Standards compliance scores

package/tests/official/acid/acid-tests.test.ts

@@ -1,309 +0,0 @@
-import { describe, it, expect } from 'bun:test';
-import { tokenize } from '../../../src/tokenizer';
-import { parse } from '../../../src/parser';
-
-describe('Acid Tests Compliance', () => {
-  describe('Acid1 Test', () => {
-    it('should parse basic HTML structure correctly', () => {
-      const acid1Html = `
-        <!DOCTYPE html>
-        <html>
-        <head>
-          <title>Acid1 Test</title>
-        </head>
-        <body>
-          <div>
-            <p>Hello <b>World</b></p>
-            <table>
-              <tr>
-                <td>Cell 1</td>
-                <td>Cell 2</td>
-              </tr>
-            </table>
-          </div>
-        </body>
-        </html>
-      `;
-      
-      const tokens = tokenize(acid1Html);
-      const ast = parse(tokens);
-      
-      expect(ast).toBeDefined();
-      expect((ast as any).type).toBe('DOCUMENT');
-      expect((ast as any).children?.length).toBeGreaterThan(0);
-    });
-    
-    it('should handle nested elements', () => {
-      const nestedHtml = `
-        <div>
-          <p>Text <strong>bold <em>italic</em></strong> more text</p>
-        </div>
-      `;
-      
-      const tokens = tokenize(nestedHtml);
-      const ast = parse(tokens);
-      
-      expect(ast).toBeDefined();
-      expect(ast.children?.length).toBeGreaterThan(0);
-    });
-    
-    it('should handle self-closing tags', () => {
-      const selfClosingHtml = `
-        <div>
-          <img src="test.jpg" alt="test">
-          <br>
-          <hr>
-        </div>
-      `;
-      
-      const tokens = tokenize(selfClosingHtml);
-      const ast = parse(tokens);
-      
-      expect(ast).toBeDefined();
-    });
-  });
-  
-  describe('Acid2 Test', () => {
-    it('should handle CSS and more complex HTML', () => {
-      const acid2Html = `
-        <!DOCTYPE html>
-        <html>
-        <head>
-          <style>
-            body { margin: 0; }
-            .test { color: red; }
-          </style>
-        </head>
-        <body>
-          <div class="test">
-            <span>Styled text</span>
-          </div>
-        </body>
-        </html>
-      `;
-      
-      const tokens = tokenize(acid2Html);
-      const ast = parse(tokens);
-      
-      expect(ast).toBeDefined();
-      expect((ast as any).type).toBe('DOCUMENT');
-    });
-    
-    it('should handle complex table structures', () => {
-      const complexTable = `
-        <table>
-          <thead>
-            <tr>
-              <th colspan="2">Header</th>
-            </tr>
-          </thead>
-          <tbody>
-            <tr>
-              <td rowspan="2">Cell 1</td>
-              <td>Cell 2</td>
-            </tr>
-            <tr>
-              <td>Cell 3</td>
-            </tr>
-          </tbody>
-        </table>
-      `;
-      
-      const tokens = tokenize(complexTable);
-      const ast = parse(tokens);
-      
-      expect(ast).toBeDefined();
-    });
-  });
-  
-  describe('Acid3 Test', () => {
-    it('should handle advanced HTML5 features', () => {
-      const acid3Html = `
-        <!DOCTYPE html>
-        <html>
-        <head>
-          <meta charset="UTF-8">
-          <title>Acid3 Test</title>
-        </head>
-        <body>
-          <article>
-            <header>
-              <h1>Article Title</h1>
-            </header>
-            <section>
-              <p>Article content</p>
-            </section>
-            <footer>
-              <p>Footer content</p>
-            </footer>
-          </article>
-        </body>
-        </html>
-      `;
-      
-      const tokens = tokenize(acid3Html);
-      const ast = parse(tokens);
-      
-      expect(ast).toBeDefined();
-      expect((ast as any).type).toBe('DOCUMENT');
-    });
-    
-    it('should handle HTML5 semantic elements', () => {
-      const semanticHtml = `
-        <main>
-          <nav>
-            <ul>
-              <li><a href="#home">Home</a></li>
-              <li><a href="#about">About</a></li>
-            </ul>
-          </nav>
-          <aside>
-            <p>Sidebar content</p>
-          </aside>
-        </main>
-      `;
-      
-      const tokens = tokenize(semanticHtml);
-      const ast = parse(tokens);
-      
-      expect(ast).toBeDefined();
-    });
-  });
-});
-
-describe('Quirks Mode Tests', () => {
-  it('should handle quirks mode HTML', () => {
-    const quirksHtml = `
-      <html>
-      <body>
-        <div>
-          <p>No DOCTYPE - should trigger quirks mode
-          <p>Unclosed paragraphs
-          <div>Nested without proper closing
-        </div>
-      </body>
-      </html>
-    `;
-    
-    const tokens = tokenize(quirksHtml);
-    const ast = parse(tokens);
-    
-    expect(ast).toBeDefined();
-    expect((ast as any).type).toBe('DOCUMENT');
-  });
-  
-  it('should handle malformed HTML gracefully', () => {
-    const malformedHtml = `
-      <div>
-        <p>Unclosed paragraph
-        <span>Unclosed span
-        <b>Bold text
-        <i>Italic text
-      </div>
-    `;
-    
-    const tokens = tokenize(malformedHtml);
-    const ast = parse(tokens);
-    
-    expect(ast).toBeDefined();
-  });
-  
-  it('should handle mismatched tags', () => {
-    const mismatchedHtml = `
-      <div>
-        <p>Paragraph</div>
-        <span>Span</p>
-      </span>
-    `;
-    
-    const tokens = tokenize(mismatchedHtml);
-    const ast = parse(tokens);
-    
-    expect(ast).toBeDefined();
-  });
-});
-
-describe('Performance Benchmarks', () => {
-  it('should parse small HTML quickly', () => {
-    const smallHtml = '<div><p>Hello World</p></div>';
-    
-    const start = performance.now();
-    const tokens = tokenize(smallHtml);
-    const ast = parse(tokens);
-    const end = performance.now();
-    
-    expect(ast).toBeDefined();
-    expect(end - start).toBeLessThan(10); 
-  });
-  
-  it('should handle medium-sized HTML', () => {
-    const mediumHtml = Array(100).fill('<div><p>Content</p></div>').join('');
-    
-    const start = performance.now();
-    const tokens = tokenize(mediumHtml);
-    const ast = parse(tokens);
-    const end = performance.now();
-    
-    expect(ast).toBeDefined();
-    expect(end - start).toBeLessThan(100); 
-  });
-  
-  it('should handle large HTML documents', () => {
-    const largeHtml = Array(1000).fill('<div><p>Large content</p></div>').join('');
-    
-    const start = performance.now();
-    const tokens = tokenize(largeHtml);
-    const ast = parse(tokens);
-    const end = performance.now();
-    
-    expect(ast).toBeDefined();
-    expect(end - start).toBeLessThan(1000); 
-  });
-  
-  it('should handle deeply nested HTML', () => {
-    let deepHtml = '';
-    for (let i = 0; i < 100; i++) {
-      deepHtml += '<div>';
-    }
-    deepHtml += 'Deep content';
-    for (let i = 0; i < 100; i++) {
-      deepHtml += '</div>';
-    }
-    
-    const start = performance.now();
-    const tokens = tokenize(deepHtml);
-    const ast = parse(tokens);
-    const end = performance.now();
-    
-    expect(ast).toBeDefined();
-    expect(end - start).toBeLessThan(500); 
-  });
-});
-
-describe('Memory Usage Tests', () => {
-  it('should not leak memory on repeated parsing', () => {
-    const testHtml = '<div><p>Memory test</p></div>';
-    
-    
-    for (let i = 0; i < 1000; i++) {
-      const tokens = tokenize(testHtml);
-      const ast = parse(tokens);
-      expect(ast).toBeDefined();
-    }
-    
-    
-    expect(true).toBe(true);
-  });
-  
-  it('should handle multiple large documents', () => {
-    const largeHtml = Array(500).fill('<div><p>Large content</p></div>').join('');
-    
-    for (let i = 0; i < 10; i++) {
-      const tokens = tokenize(largeHtml);
-      const ast = parse(tokens);
-      expect(ast).toBeDefined();
-    }
-    
-    expect(true).toBe(true);
-  });
-});