libgo: Update to weekly.2011-12-02.

git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@182295 138bc75d-0d04-0410-961f-82ee72b054a4

1 files changed, 110 insertions, 72 deletions

diff --git a/libgo/go/html/parse_test.go b/libgo/go/html/parse_test.go
index 4f15ae1d554..e0c19cff6da 100644
--- a/libgo/go/html/parse_test.go
+++ b/libgo/go/html/parse_test.go
@@ -10,65 +10,77 @@ import (
 	"errors"
 	"fmt"
 	"io"
-	"io/ioutil"
 	"os"
 	"strings"
 	"testing"
 )
 
-func pipeErr(err error) io.Reader {
-	pr, pw := io.Pipe()
-	pw.CloseWithError(err)
-	return pr
-}
-
-func readDat(filename string, c chan io.Reader) {
-	defer close(c)
-	f, err := os.Open("testdata/webkit/" + filename)
+// readParseTest reads a single test case from r.
+func readParseTest(r *bufio.Reader) (text, want, context string, err error) {
+	line, err := r.ReadSlice('\n')
 	if err != nil {
-		c <- pipeErr(err)
-		return
+		return "", "", "", err
 	}
-	defer f.Close()
+	var b []byte
 
-	// Loop through the lines of the file. Each line beginning with "#" denotes
-	// a new section, which is returned as a separate io.Reader.
-	r := bufio.NewReader(f)
-	var pw *io.PipeWriter
+	// Read the HTML.
+	if string(line) != "#data\n" {
+		return "", "", "", fmt.Errorf(`got %q want "#data\n"`, line)
+	}
 	for {
-		line, err := r.ReadSlice('\n')
+		line, err = r.ReadSlice('\n')
 		if err != nil {
-			if pw != nil {
-				pw.CloseWithError(err)
-				pw = nil
-			} else {
-				c <- pipeErr(err)
-			}
-			return
+			return "", "", "", err
 		}
-		if len(line) == 0 {
-			continue
+		if line[0] == '#' {
+			break
+		}
+		b = append(b, line...)
+	}
+	text = strings.TrimRight(string(b), "\n")
+	b = b[:0]
+
+	// Skip the error list.
+	if string(line) != "#errors\n" {
+		return "", "", "", fmt.Errorf(`got %q want "#errors\n"`, line)
+	}
+	for {
+		line, err = r.ReadSlice('\n')
+		if err != nil {
+			return "", "", "", err
 		}
 		if line[0] == '#' {
-			if pw != nil {
-				pw.Close()
-			}
-			var pr *io.PipeReader
-			pr, pw = io.Pipe()
-			c <- pr
-			continue
+			break
+		}
+	}
+
+	if string(line) == "#document-fragment\n" {
+		line, err = r.ReadSlice('\n')
+		if err != nil {
+			return "", "", "", err
 		}
-		if line[0] != '|' {
-			// Strip the trailing '\n'.
-			line = line[:len(line)-1]
+		context = strings.TrimSpace(string(line))
+		line, err = r.ReadSlice('\n')
+		if err != nil {
+			return "", "", "", err
 		}
-		if pw != nil {
-			if _, err := pw.Write(line); err != nil {
-				pw.CloseWithError(err)
-				pw = nil
-			}
+	}
+
+	// Read the dump of what the parse tree should be.
+	if string(line) != "#document\n" {
+		return "", "", "", fmt.Errorf(`got %q want "#document\n"`, line)
+	}
+	for {
+		line, err = r.ReadSlice('\n')
+		if err != nil && err != io.EOF {
+			return "", "", "", err
+		}
+		if len(line) == 0 || len(line) == 1 && line[0] == '\n' {
+			break
 		}
+		b = append(b, line...)
 	}
+	return text, string(b), context, nil
 }
 
 func dumpIndent(w io.Writer, level int) {
@@ -93,11 +105,27 @@ func dumpLevel(w io.Writer, n *Node, level int) error {
 			fmt.Fprintf(w, `%s="%s"`, a.Key, a.Val)
 		}
 	case TextNode:
-		fmt.Fprintf(w, "%q", n.Data)
+		fmt.Fprintf(w, `"%s"`, n.Data)
 	case CommentNode:
 		fmt.Fprintf(w, "<!-- %s -->", n.Data)
 	case DoctypeNode:
-		fmt.Fprintf(w, "<!DOCTYPE %s>", n.Data)
+		fmt.Fprintf(w, "<!DOCTYPE %s", n.Data)
+		if n.Attr != nil {
+			var p, s string
+			for _, a := range n.Attr {
+				switch a.Key {
+				case "public":
+					p = a.Val
+				case "system":
+					s = a.Val
+				}
+			}
+			if p != "" || s != "" {
+				fmt.Fprintf(w, ` "%s"`, p)
+				fmt.Fprintf(w, ` "%s"`, s)
+			}
+		}
+		io.WriteString(w, ">")
 	case scopeMarkerNode:
 		return errors.New("unexpected scopeMarkerNode")
 	default:
@@ -133,46 +161,62 @@ func TestParser(t *testing.T) {
 		n int
 	}{
 		// TODO(nigeltao): Process all the test cases from all the .dat files.
+		{"doctype01.dat", -1},
 		{"tests1.dat", -1},
-		{"tests2.dat", 43},
-		{"tests3.dat", 0},
+		{"tests2.dat", -1},
+		{"tests3.dat", -1},
+		{"tests4.dat", -1},
+		{"tests5.dat", -1},
 	}
 	for _, tf := range testFiles {
-		rc := make(chan io.Reader)
-		go readDat(tf.filename, rc)
+		f, err := os.Open("testdata/webkit/" + tf.filename)
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer f.Close()
+		r := bufio.NewReader(f)
 		for i := 0; i != tf.n; i++ {
-			// Parse the #data section.
-			dataReader := <-rc
-			if dataReader == nil {
+			text, want, context, err := readParseTest(r)
+			if err == io.EOF && tf.n == -1 {
 				break
 			}
-			b, err := ioutil.ReadAll(dataReader)
 			if err != nil {
 				t.Fatal(err)
 			}
-			text := string(b)
-			doc, err := Parse(strings.NewReader(text))
-			if err != nil {
-				t.Fatal(err)
+
+			var doc *Node
+			if context == "" {
+				doc, err = Parse(strings.NewReader(text))
+				if err != nil {
+					t.Fatal(err)
+				}
+			} else {
+				contextNode := &Node{
+					Type: ElementNode,
+					Data: context,
+				}
+				nodes, err := ParseFragment(strings.NewReader(text), contextNode)
+				if err != nil {
+					t.Fatal(err)
+				}
+				doc = &Node{
+					Type: DocumentNode,
+				}
+				for _, n := range nodes {
+					doc.Add(n)
+				}
 			}
+
 			got, err := dump(doc)
 			if err != nil {
 				t.Fatal(err)
 			}
-			// Skip the #error section.
-			if _, err := io.Copy(ioutil.Discard, <-rc); err != nil {
-				t.Fatal(err)
-			}
 			// Compare the parsed tree to the #document section.
-			b, err = ioutil.ReadAll(<-rc)
-			if err != nil {
-				t.Fatal(err)
-			}
-			if want := string(b); got != want {
+			if got != want {
 				t.Errorf("%s test #%d %q, got vs want:\n----\n%s----\n%s----", tf.filename, i, text, got, want)
 				continue
 			}
-			if renderTestBlacklist[text] {
+			if renderTestBlacklist[text] || context != "" {
 				continue
 			}
 			// Check that rendering and re-parsing results in an identical tree.
@@ -193,12 +237,6 @@ func TestParser(t *testing.T) {
 				continue
 			}
 		}
-		// Drain any untested cases for the test file.
-		for r := range rc {
-			if _, err := ioutil.ReadAll(r); err != nil {
-				t.Fatal(err)
-			}
-		}
 	}
 }