golang.org/x/net v0.61.0: html.RawNode

Clean-room public code sample — generation instructions

Write a brand-new, minimal, self-contained code sample in this clean-room directory.
Do not copy, paraphrase, or reference any existing project source. Work only from this spec.

A csx.json manifest scaffold already exists. Do not recreate it from memory. Preserve its case.goal, packages and symbols; fill its empty case.contract with exact assertions and correct its environment, commands and verifierAdapter for the files you generate.

Goal: verify golang.org/x/net/html.RawNode in pkg:golang/golang.org/x/net@v0.61.0
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:golang/golang.org/x/net@v0.61.0
Demonstrate these symbols/APIs:
  - golang.org/x/net/html.RawNode

Rules:
  - One focused purpose; the smallest project that proves the goal.
  - Include a contract test (test/contract.*) that runs OFFLINE and exits 0 exactly when the goal behavior works.
  - Pin every dependency with a lockfile so resolution is reproducible.
  - No secrets, credentials, or tokens. No real URLs (only example.com or localhost). No absolute paths.
  - No personal names, emails, company names, or project identifiers of any kind.
  - No binaries and no generated output (node_modules, dist, target, venv, .git, .env).
  - Keep it under 200 files and 256KB packed.

{"case":{"caseId":"case:sha256:b8bd22a32e5e98d0a9c2f4a0ec114eb2120369128730bf6e62a0ee22c9352b8f","contract":["html.RawNode is a NodeType enum constant representing unescaped raw markup","html.Render writes html.RawNode Data directly to output without HTML escaping","html.Render distinguishes html.RawNode from html.TextNode where TextNode escapes characters like \u003c, \u003e, and \u0026","html.RawNode can be inserted into an HTML DOM element and serialized correctly as a child node","html.RawNode with empty Data serializes as an empty string without error","html.Parse parses HTML documents without producing any html.RawNode nodes","html.RawNode can be placed alongside sibling TextNode children within a parent ElementNode"],"goal":"verify golang.org/x/net/html.RawNode in pkg:golang/golang.org/x/net@v0.61.0","kind":"HOW","packages":["pkg:golang/golang.org/x/net@v0.61.0"],"schemaVersion":1,"symbols":["golang.org/x/net/html.RawNode"]},"contractCommand":["go","run","./test"],"environment":{"arch":"x64","distro":"ubuntu","ecosystem":"golang","libc":"glibc","libcVersion":"2.39","os":"linux","osVersionBucket":"24","packageManager":"go","schemaVersion":1},"license":"MIT-0","packages":["pkg:golang/golang.org/x/net@v0.61.0"],"schemaVersion":1,"subject":"pkg:golang/golang.org/x/net@v0.61.0","symbols":["golang.org/x/net/html.RawNode"],"verifierAdapter":"golang@1"}

module example.com/sample

go 1.26.0

require golang.org/x/net v0.61.0

golang.org/x/net v0.61.0 h1:RR+6j/BTBCrggOLugxa+66R8FvoN6MHlzDlZIbN9YFw=
golang.org/x/net v0.61.0/go.mod h1:WgDCOTH8iwtB66T4/GfI94AHo/hhdb7Hah9NDseQfiI=

package main

import (
	"bytes"
	"fmt"

	"golang.org/x/net/html"
)

func main() {
	// Demonstrate using html.RawNode to embed unescaped HTML content in a node tree
	container := &html.Node{
		Type: html.ElementNode,
		Data: "div",
	}

	rawContent := &html.Node{
		Type: html.RawNode,
		Data: `<p class="notice">Hello <strong>World</strong> & Welcome!</p>`,
	}
	container.AppendChild(rawContent)

	var buf bytes.Buffer
	if err := html.Render(&buf, container); err != nil {
		panic(err)
	}

	fmt.Println("Rendered HTML with RawNode:")
	fmt.Println(buf.String())
}

{
  "schemaVersion": 1,
  "goal": "verify golang.org/x/net/html.RawNode in pkg:golang/golang.org/x/net@v0.61.0",
  "kind": "HOW",
  "packages": [
    "pkg:golang/golang.org/x/net@v0.61.0"
  ],
  "symbols": [
    "golang.org/x/net/html.RawNode"
  ]
}

package main

import (
	"bytes"
	"fmt"
	"os"
	"strings"

	"golang.org/x/net/html"
)

func main() {
	// Assertion 1: html.RawNode is a NodeType enum constant representing unescaped raw markup
	{
		var nodeType html.NodeType = html.RawNode
		if uint32(nodeType) != 6 {
			fmt.Fprintf(os.Stderr, "Assertion 1 failed: expected uint32(html.RawNode) == 6, got %d\n", uint32(nodeType))
			os.Exit(1)
		}
		if html.RawNode == html.TextNode || html.RawNode == html.ElementNode || html.RawNode == html.CommentNode || html.RawNode == html.DoctypeNode {
			fmt.Fprintf(os.Stderr, "Assertion 1 failed: html.RawNode must be distinct from other NodeType constants\n")
			os.Exit(1)
		}
	}

	// Assertion 2: html.Render writes html.RawNode Data directly to output without HTML escaping
	{
		rawHTML := `<div id="raw-test"><span class="highlight">Unescaped & "special" 'chars' > <</span></div>`
		rawNode := &html.Node{
			Type: html.RawNode,
			Data: rawHTML,
		}
		var buf bytes.Buffer
		if err := html.Render(&buf, rawNode); err != nil {
			fmt.Fprintf(os.Stderr, "Assertion 2 failed: html.Render returned error: %v\n", err)
			os.Exit(1)
		}
		if buf.String() != rawHTML {
			fmt.Fprintf(os.Stderr, "Assertion 2 failed: expected %q, got %q\n", rawHTML, buf.String())
			os.Exit(1)
		}
	}

	// Assertion 3: html.Render distinguishes html.RawNode from html.TextNode where TextNode escapes characters like <, >, and &
	{
		sampleContent := `<b>Alert & "Notice"</b>`
		rawNode := &html.Node{
			Type: html.RawNode,
			Data: sampleContent,
		}
		textNode := &html.Node{
			Type: html.TextNode,
			Data: sampleContent,
		}

		var rawBuf bytes.Buffer
		if err := html.Render(&rawBuf, rawNode); err != nil {
			fmt.Fprintf(os.Stderr, "Assertion 3 failed: html.Render rawNode error: %v\n", err)
			os.Exit(1)
		}

		var textBuf bytes.Buffer
		if err := html.Render(&textBuf, textNode); err != nil {
			fmt.Fprintf(os.Stderr, "Assertion 3 failed: html.Render textNode error: %v\n", err)
			os.Exit(1)
		}

		expectedRaw := `<b>Alert & "Notice"</b>`
		expectedText := `&lt;b&gt;Alert &amp; &#34;Notice&#34;&lt;/b&gt;`

		if rawBuf.String() != expectedRaw {
			fmt.Fprintf(os.Stderr, "Assertion 3 failed: raw expected %q, got %q\n", expectedRaw, rawBuf.String())
			os.Exit(1)
		}
		if textBuf.String() != expectedText {
			fmt.Fprintf(os.Stderr, "Assertion 3 failed: text expected %q, got %q\n", expectedText, textBuf.String())
			os.Exit(1)
		}
	}

	// Assertion 4: html.RawNode can be inserted into an HTML DOM element and serialized correctly as a child node
	{
		container := &html.Node{
			Type: html.ElementNode,
			Data: "section",
		}
		childRaw := &html.Node{
			Type: html.RawNode,
			Data: `<p>Inline <em>markup</em></p>`,
		}
		container.AppendChild(childRaw)

		var buf bytes.Buffer
		if err := html.Render(&buf, container); err != nil {
			fmt.Fprintf(os.Stderr, "Assertion 4 failed: html.Render element error: %v\n", err)
			os.Exit(1)
		}

		expected := `<section><p>Inline <em>markup</em></p></section>`
		if buf.String() != expected {
			fmt.Fprintf(os.Stderr, "Assertion 4 failed: expected %q, got %q\n", expected, buf.String())
			os.Exit(1)
		}
	}

	// Assertion 5: html.RawNode with empty Data serializes as an empty string without error
	{
		emptyNode := &html.Node{
			Type: html.RawNode,
			Data: "",
		}
		var buf bytes.Buffer
		if err := html.Render(&buf, emptyNode); err != nil {
			fmt.Fprintf(os.Stderr, "Assertion 5 failed: html.Render empty RawNode error: %v\n", err)
			os.Exit(1)
		}
		if buf.String() != "" {
			fmt.Fprintf(os.Stderr, "Assertion 5 failed: expected empty string, got %q\n", buf.String())
			os.Exit(1)
		}
	}

	// Assertion 6: html.Parse parses HTML documents without producing any html.RawNode nodes
	{
		htmlDoc := `<!DOCTYPE html><html><head><title>RawNode Test</title></head><body><!-- comment --><div class="content"><p>Paragraph with <code>inline code &amp; entities</code></p><script>var x = 1 < 2;</script></div></body></html>`
		doc, err := html.Parse(strings.NewReader(htmlDoc))
		if err != nil {
			fmt.Fprintf(os.Stderr, "Assertion 6 failed: html.Parse error: %v\n", err)
			os.Exit(1)
		}

		foundRawNode := false
		var walk func(*html.Node)
		walk = func(n *html.Node) {
			if n.Type == html.RawNode {
				foundRawNode = true
			}
			for c := n.FirstChild; c != nil; c = c.NextSibling {
				walk(c)
			}
		}
		walk(doc)

		if foundRawNode {
			fmt.Fprintf(os.Stderr, "Assertion 6 failed: html.Parse unexpectedly produced an html.RawNode\n")
			os.Exit(1)
		}
	}

	// Assertion 7: html.RawNode can be placed alongside sibling TextNode children within a parent ElementNode
	{
		parent := &html.Node{
			Type: html.ElementNode,
			Data: "div",
		}
		parent.AppendChild(&html.Node{
			Type: html.TextNode,
			Data: "Prefix: ",
		})
		parent.AppendChild(&html.Node{
			Type: html.RawNode,
			Data: `<span>Raw & Unescaped</span>`,
		})
		parent.AppendChild(&html.Node{
			Type: html.TextNode,
			Data: " :Suffix",
		})

		var buf bytes.Buffer
		if err := html.Render(&buf, parent); err != nil {
			fmt.Fprintf(os.Stderr, "Assertion 7 failed: html.Render sibling error: %v\n", err)
			os.Exit(1)
		}

		expected := `<div>Prefix: <span>Raw & Unescaped</span> :Suffix</div>`
		if buf.String() != expected {
			fmt.Fprintf(os.Stderr, "Assertion 7 failed: expected %q, got %q\n", expected, buf.String())
			os.Exit(1)
		}
	}

	fmt.Println("All html.RawNode contract assertions passed.")
}