157 lines
2.8 KiB
Go
157 lines
2.8 KiB
Go
// Copyright 2010 The Go Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
package html
|
|
|
|
import (
|
|
"bytes"
|
|
"testing"
|
|
)
|
|
|
|
func TestRenderer(t *testing.T) {
|
|
nodes := [...]*Node{
|
|
0: {
|
|
Type: ElementNode,
|
|
Data: "html",
|
|
},
|
|
1: {
|
|
Type: ElementNode,
|
|
Data: "head",
|
|
},
|
|
2: {
|
|
Type: ElementNode,
|
|
Data: "body",
|
|
},
|
|
3: {
|
|
Type: TextNode,
|
|
Data: "0<1",
|
|
},
|
|
4: {
|
|
Type: ElementNode,
|
|
Data: "p",
|
|
Attr: []Attribute{
|
|
{
|
|
Key: "id",
|
|
Val: "A",
|
|
},
|
|
{
|
|
Key: "foo",
|
|
Val: `abc"def`,
|
|
},
|
|
},
|
|
},
|
|
5: {
|
|
Type: TextNode,
|
|
Data: "2",
|
|
},
|
|
6: {
|
|
Type: ElementNode,
|
|
Data: "b",
|
|
Attr: []Attribute{
|
|
{
|
|
Key: "empty",
|
|
Val: "",
|
|
},
|
|
},
|
|
},
|
|
7: {
|
|
Type: TextNode,
|
|
Data: "3",
|
|
},
|
|
8: {
|
|
Type: ElementNode,
|
|
Data: "i",
|
|
Attr: []Attribute{
|
|
{
|
|
Key: "backslash",
|
|
Val: `\`,
|
|
},
|
|
},
|
|
},
|
|
9: {
|
|
Type: TextNode,
|
|
Data: "&4",
|
|
},
|
|
10: {
|
|
Type: TextNode,
|
|
Data: "5",
|
|
},
|
|
11: {
|
|
Type: ElementNode,
|
|
Data: "blockquote",
|
|
},
|
|
12: {
|
|
Type: ElementNode,
|
|
Data: "br",
|
|
},
|
|
13: {
|
|
Type: TextNode,
|
|
Data: "6",
|
|
},
|
|
}
|
|
|
|
// Build a tree out of those nodes, based on a textual representation.
|
|
// Only the ".\t"s are significant. The trailing HTML-like text is
|
|
// just commentary. The "0:" prefixes are for easy cross-reference with
|
|
// the nodes array.
|
|
treeAsText := [...]string{
|
|
0: `<html>`,
|
|
1: `. <head>`,
|
|
2: `. <body>`,
|
|
3: `. . "0<1"`,
|
|
4: `. . <p id="A" foo="abc"def">`,
|
|
5: `. . . "2"`,
|
|
6: `. . . <b empty="">`,
|
|
7: `. . . . "3"`,
|
|
8: `. . . <i backslash="\">`,
|
|
9: `. . . . "&4"`,
|
|
10: `. . "5"`,
|
|
11: `. . <blockquote>`,
|
|
12: `. . <br>`,
|
|
13: `. . "6"`,
|
|
}
|
|
if len(nodes) != len(treeAsText) {
|
|
t.Fatal("len(nodes) != len(treeAsText)")
|
|
}
|
|
var stack [8]*Node
|
|
for i, line := range treeAsText {
|
|
level := 0
|
|
for line[0] == '.' {
|
|
// Strip a leading ".\t".
|
|
line = line[2:]
|
|
level++
|
|
}
|
|
n := nodes[i]
|
|
if level == 0 {
|
|
if stack[0] != nil {
|
|
t.Fatal("multiple root nodes")
|
|
}
|
|
stack[0] = n
|
|
} else {
|
|
stack[level-1].AppendChild(n)
|
|
stack[level] = n
|
|
for i := level + 1; i < len(stack); i++ {
|
|
stack[i] = nil
|
|
}
|
|
}
|
|
// At each stage of tree construction, we check all nodes for consistency.
|
|
for j, m := range nodes {
|
|
if err := checkNodeConsistency(m); err != nil {
|
|
t.Fatalf("i=%d, j=%d: %v", i, j, err)
|
|
}
|
|
}
|
|
}
|
|
|
|
want := `<html><head></head><body>0<1<p id="A" foo="abc"def">` +
|
|
`2<b empty="">3</b><i backslash="\">&4</i></p>` +
|
|
`5<blockquote></blockquote><br/>6</body></html>`
|
|
b := new(bytes.Buffer)
|
|
if err := Render(b, nodes[0]); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if got := b.String(); got != want {
|
|
t.Errorf("got vs want:\n%s\n%s\n", got, want)
|
|
}
|
|
}
|