github.com/Andyfoo/golang/x/net@v0.0.0-20190901054642-57c1bf301704/html/render_test.go (about)

     1  // Copyright 2010 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package html
     6  
     7  import (
     8  	"bytes"
     9  	"testing"
    10  )
    11  
    12  func TestRenderer(t *testing.T) {
    13  	nodes := [...]*Node{
    14  		0: {
    15  			Type: ElementNode,
    16  			Data: "html",
    17  		},
    18  		1: {
    19  			Type: ElementNode,
    20  			Data: "head",
    21  		},
    22  		2: {
    23  			Type: ElementNode,
    24  			Data: "body",
    25  		},
    26  		3: {
    27  			Type: TextNode,
    28  			Data: "0<1",
    29  		},
    30  		4: {
    31  			Type: ElementNode,
    32  			Data: "p",
    33  			Attr: []Attribute{
    34  				{
    35  					Key: "id",
    36  					Val: "A",
    37  				},
    38  				{
    39  					Key: "foo",
    40  					Val: `abc"def`,
    41  				},
    42  			},
    43  		},
    44  		5: {
    45  			Type: TextNode,
    46  			Data: "2",
    47  		},
    48  		6: {
    49  			Type: ElementNode,
    50  			Data: "b",
    51  			Attr: []Attribute{
    52  				{
    53  					Key: "empty",
    54  					Val: "",
    55  				},
    56  			},
    57  		},
    58  		7: {
    59  			Type: TextNode,
    60  			Data: "3",
    61  		},
    62  		8: {
    63  			Type: ElementNode,
    64  			Data: "i",
    65  			Attr: []Attribute{
    66  				{
    67  					Key: "backslash",
    68  					Val: `\`,
    69  				},
    70  			},
    71  		},
    72  		9: {
    73  			Type: TextNode,
    74  			Data: "&4",
    75  		},
    76  		10: {
    77  			Type: TextNode,
    78  			Data: "5",
    79  		},
    80  		11: {
    81  			Type: ElementNode,
    82  			Data: "blockquote",
    83  		},
    84  		12: {
    85  			Type: ElementNode,
    86  			Data: "br",
    87  		},
    88  		13: {
    89  			Type: TextNode,
    90  			Data: "6",
    91  		},
    92  	}
    93  
    94  	// Build a tree out of those nodes, based on a textual representation.
    95  	// Only the ".\t"s are significant. The trailing HTML-like text is
    96  	// just commentary. The "0:" prefixes are for easy cross-reference with
    97  	// the nodes array.
    98  	treeAsText := [...]string{
    99  		0: `<html>`,
   100  		1: `.	<head>`,
   101  		2: `.	<body>`,
   102  		3: `.	.	"0&lt;1"`,
   103  		4: `.	.	<p id="A" foo="abc&#34;def">`,
   104  		5: `.	.	.	"2"`,
   105  		6: `.	.	.	<b empty="">`,
   106  		7: `.	.	.	.	"3"`,
   107  		8: `.	.	.	<i backslash="\">`,
   108  		9: `.	.	.	.	"&amp;4"`,
   109  		10: `.	.	"5"`,
   110  		11: `.	.	<blockquote>`,
   111  		12: `.	.	<br>`,
   112  		13: `.	.	"6"`,
   113  	}
   114  	if len(nodes) != len(treeAsText) {
   115  		t.Fatal("len(nodes) != len(treeAsText)")
   116  	}
   117  	var stack [8]*Node
   118  	for i, line := range treeAsText {
   119  		level := 0
   120  		for line[0] == '.' {
   121  			// Strip a leading ".\t".
   122  			line = line[2:]
   123  			level++
   124  		}
   125  		n := nodes[i]
   126  		if level == 0 {
   127  			if stack[0] != nil {
   128  				t.Fatal("multiple root nodes")
   129  			}
   130  			stack[0] = n
   131  		} else {
   132  			stack[level-1].AppendChild(n)
   133  			stack[level] = n
   134  			for i := level + 1; i < len(stack); i++ {
   135  				stack[i] = nil
   136  			}
   137  		}
   138  		// At each stage of tree construction, we check all nodes for consistency.
   139  		for j, m := range nodes {
   140  			if err := checkNodeConsistency(m); err != nil {
   141  				t.Fatalf("i=%d, j=%d: %v", i, j, err)
   142  			}
   143  		}
   144  	}
   145  
   146  	want := `<html><head></head><body>0&lt;1<p id="A" foo="abc&#34;def">` +
   147  		`2<b empty="">3</b><i backslash="\">&amp;4</i></p>` +
   148  		`5<blockquote></blockquote><br/>6</body></html>`
   149  	b := new(bytes.Buffer)
   150  	if err := Render(b, nodes[0]); err != nil {
   151  		t.Fatal(err)
   152  	}
   153  	if got := b.String(); got != want {
   154  		t.Errorf("got vs want:\n%s\n%s\n", got, want)
   155  	}
   156  }