golang.org/x/net v0.0.0-20180724234803-3673e40ba225: atom.Atom

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/atom.Atom in pkg:golang/golang.org/x/net@v0.0.0-20180724234803-3673e40ba225
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:golang/golang.org/x/net@v0.0.0-20180724234803-3673e40ba225
Demonstrate these symbols/APIs:
  - golang.org/x/net/html/atom.Atom

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.

package atomverify

import (
	"strings"

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

// IsValidAtom returns true when the atom.Atom value is non-zero.
func IsValidAtom(a atom.Atom) bool {
	return a != 0
}

// FormatAtom returns the canonical lowercase string for an atom.Atom.
func FormatAtom(a atom.Atom) string {
	return a.String()
}

// LookupTagAtom converts a lowercase HTML tag byte slice to an atom.Atom.
func LookupTagAtom(raw []byte) atom.Atom {
	return atom.Lookup(raw)
}

// HasAtom checks whether an html.Node is an ElementNode with the specified atom.Atom.
func HasAtom(n *html.Node, want atom.Atom) bool {
	if n == nil || n.Type != html.ElementNode {
		return false
	}
	return n.DataAtom == want
}

// FindElementByAtom traverses an HTML node tree and returns the first ElementNode with DataAtom == target.
func FindElementByAtom(root *html.Node, target atom.Atom) *html.Node {
	if root == nil {
		return nil
	}
	if HasAtom(root, target) {
		return root
	}
	for child := root.FirstChild; child != nil; child = child.NextSibling {
		if match := FindElementByAtom(child, target); match != nil {
			return match
		}
	}
	return nil
}

// ParseDocument parses an HTML string into a document tree.
func ParseDocument(markup string) (*html.Node, error) {
	return html.Parse(strings.NewReader(markup))
}

{"case":{"caseId":"case:sha256:da9406e289cc930e23e19cfc5118b713f8161729c4b637a70b223490ef2a3ec8","contract":["atom.Atom zero value atom.Atom(0) maps to empty string \"\"","atom.Atom constants have non-zero integer codes whose String() returns their lowercase tag or attribute name","atom.Lookup resolves valid HTML tag byte slices to non-zero atom.Atom and returns atom.Atom(0) for unknown or uppercase tags","html.Parse assigns atom.Atom to html.Node.DataAtom for known HTML tags and zero for custom tags","atom.Atom supports direct integer equality comparison between element DataAtom and atom constants"],"goal":"verify golang.org/x/net/html/atom.Atom in pkg:golang/golang.org/x/net@v0.0.0-20180724234803-3673e40ba225","kind":"HOW","packages":["pkg:golang/golang.org/x/net@v0.0.0-20180724234803-3673e40ba225"],"schemaVersion":1,"symbols":["golang.org/x/net/html/atom.Atom"]},"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.0.0-20180724234803-3673e40ba225"],"schemaVersion":1,"subject":"pkg:golang/golang.org/x/net@v0.0.0-20180724234803-3673e40ba225","symbols":["golang.org/x/net/html/atom.Atom"],"verifierAdapter":"golang@1"}

module example.com/atomverify

go 1.21

require golang.org/x/net v0.0.0-20180724234803-3673e40ba225

golang.org/x/net v0.0.0-20180724234803-3673e40ba225 h1:kNX+jCowfMYzvlSvJu5pQWEmyWFrBXJ3PBy10xKMXK8=
golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=

{
  "schemaVersion": 1,
  "goal": "verify golang.org/x/net/html/atom.Atom in pkg:golang/golang.org/x/net@v0.0.0-20180724234803-3673e40ba225",
  "kind": "HOW",
  "packages": [
    "pkg:golang/golang.org/x/net@v0.0.0-20180724234803-3673e40ba225"
  ],
  "symbols": [
    "golang.org/x/net/html/atom.Atom"
  ]
}

package main

import (
	"fmt"
	"os"

	"example.com/atomverify"
	"golang.org/x/net/html"
	"golang.org/x/net/html/atom"
)

func main() {
	// 1. Zero-value atom.Atom(0) converts to empty string "".
	var zero atom.Atom
	if zero != 0 || atomverify.FormatAtom(zero) != "" || atomverify.IsValidAtom(zero) {
		fmt.Fprintf(os.Stderr, "FAIL: zero atom behavior invalid: %v (%q)\n", zero, zero.String())
		os.Exit(1)
	}

	// 2. Known atom.Atom constants are non-zero and String() returns their lowercase name.
	known := []struct {
		code atom.Atom
		text string
	}{
		{atom.Div, "div"},
		{atom.Span, "span"},
		{atom.A, "a"},
		{atom.P, "p"},
		{atom.Section, "section"},
		{atom.Button, "button"},
	}
	for _, item := range known {
		if !atomverify.IsValidAtom(item.code) {
			fmt.Fprintf(os.Stderr, "FAIL: expected non-zero atom for %s\n", item.text)
			os.Exit(1)
		}
		if got := atomverify.FormatAtom(item.code); got != item.text {
			fmt.Fprintf(os.Stderr, "FAIL: expected %q, got %q\n", item.text, got)
			os.Exit(1)
		}
	}

	// 3. atom.Lookup resolves lowercase tag bytes to matching atom.Atom and returns 0 for unknown or uppercase inputs.
	if got := atomverify.LookupTagAtom([]byte("div")); got != atom.Div {
		fmt.Fprintf(os.Stderr, "FAIL: LookupTagAtom(\"div\") = %v, want %v\n", got, atom.Div)
		os.Exit(1)
	}
	if got := atomverify.LookupTagAtom([]byte("DIV")); got != 0 {
		fmt.Fprintf(os.Stderr, "FAIL: LookupTagAtom(\"DIV\") = %v, want 0\n", got)
		os.Exit(1)
	}
	if got := atomverify.LookupTagAtom([]byte("unknown-custom-tag")); got != 0 {
		fmt.Fprintf(os.Stderr, "FAIL: LookupTagAtom(\"unknown-custom-tag\") = %v, want 0\n", got)
		os.Exit(1)
	}

	// 4. html.Parse populates DataAtom with the corresponding atom.Atom for standard tags and 0 for custom tags.
	doc, err := atomverify.ParseDocument(`<!DOCTYPE html><html><body><section><div id="main"><span class="label">ok</span><x-widget>custom</x-widget></div></section></body></html>`)
	if err != nil {
		fmt.Fprintf(os.Stderr, "FAIL: ParseDocument error: %v\n", err)
		os.Exit(1)
	}

	divNode := atomverify.FindElementByAtom(doc, atom.Div)
	if divNode == nil || divNode.DataAtom != atom.Div || divNode.Data != "div" {
		fmt.Fprintf(os.Stderr, "FAIL: failed to find div element by atom.Div\n")
		os.Exit(1)
	}

	spanNode := atomverify.FindElementByAtom(divNode, atom.Span)
	if spanNode == nil || !atomverify.HasAtom(spanNode, atom.Span) || atomverify.HasAtom(spanNode, atom.Div) {
		fmt.Fprintf(os.Stderr, "FAIL: span element atom comparison failed\n")
		os.Exit(1)
	}

	var customFound *html.Node
	var findCustom func(*html.Node)
	findCustom = func(n *html.Node) {
		if n.Type == html.ElementNode && n.Data == "x-widget" {
			customFound = n
			return
		}
		for c := n.FirstChild; c != nil; c = c.NextSibling {
			findCustom(c)
		}
	}
	findCustom(doc)
	if customFound == nil || customFound.DataAtom != 0 {
		fmt.Fprintf(os.Stderr, "FAIL: expected custom element x-widget to have DataAtom 0\n")
		os.Exit(1)
	}

	fmt.Println("PASS")
}