Imported Upstream version 1.4upstream/1.4

1 files changed, 0 insertions, 431 deletions

diff --git a/src/pkg/go/parser/parser_test.go b/src/pkg/go/parser/parser_test.go
deleted file mode 100644
index 2797ea518..000000000
--- a/src/pkg/go/parser/parser_test.go
+++ /dev/null
@@ -1,431 +0,0 @@
-// Copyright 2009 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 parser
-
-import (
-	"bytes"
-	"fmt"
-	"go/ast"
-	"go/token"
-	"os"
-	"strings"
-	"testing"
-)
-
-var fset = token.NewFileSet()
-
-var validFiles = []string{
-	"parser.go",
-	"parser_test.go",
-	"error_test.go",
-	"short_test.go",
-}
-
-func TestParse(t *testing.T) {
-	for _, filename := range validFiles {
-		_, err := ParseFile(fset, filename, nil, DeclarationErrors)
-		if err != nil {
-			t.Fatalf("ParseFile(%s): %v", filename, err)
-		}
-	}
-}
-
-func nameFilter(filename string) bool {
-	switch filename {
-	case "parser.go", "interface.go", "parser_test.go":
-		return true
-	case "parser.go.orig":
-		return true // permit but should be ignored by ParseDir
-	}
-	return false
-}
-
-func dirFilter(f os.FileInfo) bool { return nameFilter(f.Name()) }
-
-func TestParseDir(t *testing.T) {
-	path := "."
-	pkgs, err := ParseDir(fset, path, dirFilter, 0)
-	if err != nil {
-		t.Fatalf("ParseDir(%s): %v", path, err)
-	}
-	if n := len(pkgs); n != 1 {
-		t.Errorf("got %d packages; want 1", n)
-	}
-	pkg := pkgs["parser"]
-	if pkg == nil {
-		t.Errorf(`package "parser" not found`)
-		return
-	}
-	if n := len(pkg.Files); n != 3 {
-		t.Errorf("got %d package files; want 3", n)
-	}
-	for filename := range pkg.Files {
-		if !nameFilter(filename) {
-			t.Errorf("unexpected package file: %s", filename)
-		}
-	}
-}
-
-func TestParseExpr(t *testing.T) {
-	// just kicking the tires:
-	// a valid arithmetic expression
-	src := "a + b"
-	x, err := ParseExpr(src)
-	if err != nil {
-		t.Fatalf("ParseExpr(%s): %v", src, err)
-	}
-	// sanity check
-	if _, ok := x.(*ast.BinaryExpr); !ok {
-		t.Errorf("ParseExpr(%s): got %T, want *ast.BinaryExpr", src, x)
-	}
-
-	// a valid type expression
-	src = "struct{x *int}"
-	x, err = ParseExpr(src)
-	if err != nil {
-		t.Fatalf("ParseExpr(%s): %v", src, err)
-	}
-	// sanity check
-	if _, ok := x.(*ast.StructType); !ok {
-		t.Errorf("ParseExpr(%s): got %T, want *ast.StructType", src, x)
-	}
-
-	// an invalid expression
-	src = "a + *"
-	_, err = ParseExpr(src)
-	if err == nil {
-		t.Fatalf("ParseExpr(%s): got no error", src)
-	}
-
-	// a valid expression followed by extra tokens is invalid
-	src = "a[i] := x"
-	_, err = ParseExpr(src)
-	if err == nil {
-		t.Fatalf("ParseExpr(%s): got no error", src)
-	}
-
-	// ParseExpr must not crash
-	for _, src := range valids {
-		ParseExpr(src)
-	}
-}
-
-func TestColonEqualsScope(t *testing.T) {
-	f, err := ParseFile(fset, "", `package p; func f() { x, y, z := x, y, z }`, 0)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	// RHS refers to undefined globals; LHS does not.
-	as := f.Decls[0].(*ast.FuncDecl).Body.List[0].(*ast.AssignStmt)
-	for _, v := range as.Rhs {
-		id := v.(*ast.Ident)
-		if id.Obj != nil {
-			t.Errorf("rhs %s has Obj, should not", id.Name)
-		}
-	}
-	for _, v := range as.Lhs {
-		id := v.(*ast.Ident)
-		if id.Obj == nil {
-			t.Errorf("lhs %s does not have Obj, should", id.Name)
-		}
-	}
-}
-
-func TestVarScope(t *testing.T) {
-	f, err := ParseFile(fset, "", `package p; func f() { var x, y, z = x, y, z }`, 0)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	// RHS refers to undefined globals; LHS does not.
-	as := f.Decls[0].(*ast.FuncDecl).Body.List[0].(*ast.DeclStmt).Decl.(*ast.GenDecl).Specs[0].(*ast.ValueSpec)
-	for _, v := range as.Values {
-		id := v.(*ast.Ident)
-		if id.Obj != nil {
-			t.Errorf("rhs %s has Obj, should not", id.Name)
-		}
-	}
-	for _, id := range as.Names {
-		if id.Obj == nil {
-			t.Errorf("lhs %s does not have Obj, should", id.Name)
-		}
-	}
-}
-
-func TestObjects(t *testing.T) {
-	const src = `
-package p
-import fmt "fmt"
-const pi = 3.14
-type T struct{}
-var x int
-func f() { L: }
-`
-
-	f, err := ParseFile(fset, "", src, 0)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	objects := map[string]ast.ObjKind{
-		"p":   ast.Bad, // not in a scope
-		"fmt": ast.Bad, // not resolved yet
-		"pi":  ast.Con,
-		"T":   ast.Typ,
-		"x":   ast.Var,
-		"int": ast.Bad, // not resolved yet
-		"f":   ast.Fun,
-		"L":   ast.Lbl,
-	}
-
-	ast.Inspect(f, func(n ast.Node) bool {
-		if ident, ok := n.(*ast.Ident); ok {
-			obj := ident.Obj
-			if obj == nil {
-				if objects[ident.Name] != ast.Bad {
-					t.Errorf("no object for %s", ident.Name)
-				}
-				return true
-			}
-			if obj.Name != ident.Name {
-				t.Errorf("names don't match: obj.Name = %s, ident.Name = %s", obj.Name, ident.Name)
-			}
-			kind := objects[ident.Name]
-			if obj.Kind != kind {
-				t.Errorf("%s: obj.Kind = %s; want %s", ident.Name, obj.Kind, kind)
-			}
-		}
-		return true
-	})
-}
-
-func TestUnresolved(t *testing.T) {
-	f, err := ParseFile(fset, "", `
-package p
-//
-func f1a(int)
-func f2a(byte, int, float)
-func f3a(a, b int, c float)
-func f4a(...complex)
-func f5a(a s1a, b ...complex)
-//
-func f1b(*int)
-func f2b([]byte, (int), *float)
-func f3b(a, b *int, c []float)
-func f4b(...*complex)
-func f5b(a s1a, b ...[]complex)
-//
-type s1a struct { int }
-type s2a struct { byte; int; s1a }
-type s3a struct { a, b int; c float }
-//
-type s1b struct { *int }
-type s2b struct { byte; int; *float }
-type s3b struct { a, b *s3b; c []float }
-`, 0)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	want := "int " + // f1a
-		"byte int float " + // f2a
-		"int float " + // f3a
-		"complex " + // f4a
-		"complex " + // f5a
-		//
-		"int " + // f1b
-		"byte int float " + // f2b
-		"int float " + // f3b
-		"complex " + // f4b
-		"complex " + // f5b
-		//
-		"int " + // s1a
-		"byte int " + // s2a
-		"int float " + // s3a
-		//
-		"int " + // s1a
-		"byte int float " + // s2a
-		"float " // s3a
-
-	// collect unresolved identifiers
-	var buf bytes.Buffer
-	for _, u := range f.Unresolved {
-		buf.WriteString(u.Name)
-		buf.WriteByte(' ')
-	}
-	got := buf.String()
-
-	if got != want {
-		t.Errorf("\ngot:  %s\nwant: %s", got, want)
-	}
-}
-
-var imports = map[string]bool{
-	`"a"`:        true,
-	"`a`":        true,
-	`"a/b"`:      true,
-	`"a.b"`:      true,
-	`"m\x61th"`:  true,
-	`"greek/αβ"`: true,
-	`""`:         false,
-
-	// Each of these pairs tests both `` vs "" strings
-	// and also use of invalid characters spelled out as
-	// escape sequences and written directly.
-	// For example `"\x00"` tests import "\x00"
-	// while "`\x00`" tests import `<actual-NUL-byte>`.
-	`"\x00"`:     false,
-	"`\x00`":     false,
-	`"\x7f"`:     false,
-	"`\x7f`":     false,
-	`"a!"`:       false,
-	"`a!`":       false,
-	`"a b"`:      false,
-	"`a b`":      false,
-	`"a\\b"`:     false,
-	"`a\\b`":     false,
-	"\"`a`\"":    false,
-	"`\"a\"`":    false,
-	`"\x80\x80"`: false,
-	"`\x80\x80`": false,
-	`"\xFFFD"`:   false,
-	"`\xFFFD`":   false,
-}
-
-func TestImports(t *testing.T) {
-	for path, isValid := range imports {
-		src := fmt.Sprintf("package p; import %s", path)
-		_, err := ParseFile(fset, "", src, 0)
-		switch {
-		case err != nil && isValid:
-			t.Errorf("ParseFile(%s): got %v; expected no error", src, err)
-		case err == nil && !isValid:
-			t.Errorf("ParseFile(%s): got no error; expected one", src)
-		}
-	}
-}
-
-func TestCommentGroups(t *testing.T) {
-	f, err := ParseFile(fset, "", `
-package p /* 1a */ /* 1b */      /* 1c */ // 1d
-/* 2a
-*/
-// 2b
-const pi = 3.1415
-/* 3a */ // 3b
-/* 3c */ const e = 2.7182
-
-// Example from issue 3139
-func ExampleCount() {
-	fmt.Println(strings.Count("cheese", "e"))
-	fmt.Println(strings.Count("five", "")) // before & after each rune
-	// Output:
-	// 3
-	// 5
-}
-`, ParseComments)
-	if err != nil {
-		t.Fatal(err)
-	}
-	expected := [][]string{
-		{"/* 1a */", "/* 1b */", "/* 1c */", "// 1d"},
-		{"/* 2a\n*/", "// 2b"},
-		{"/* 3a */", "// 3b", "/* 3c */"},
-		{"// Example from issue 3139"},
-		{"// before & after each rune"},
-		{"// Output:", "// 3", "// 5"},
-	}
-	if len(f.Comments) != len(expected) {
-		t.Fatalf("got %d comment groups; expected %d", len(f.Comments), len(expected))
-	}
-	for i, exp := range expected {
-		got := f.Comments[i].List
-		if len(got) != len(exp) {
-			t.Errorf("got %d comments in group %d; expected %d", len(got), i, len(exp))
-			continue
-		}
-		for j, exp := range exp {
-			got := got[j].Text
-			if got != exp {
-				t.Errorf("got %q in group %d; expected %q", got, i, exp)
-			}
-		}
-	}
-}
-
-func getField(file *ast.File, fieldname string) *ast.Field {
-	parts := strings.Split(fieldname, ".")
-	for _, d := range file.Decls {
-		if d, ok := d.(*ast.GenDecl); ok && d.Tok == token.TYPE {
-			for _, s := range d.Specs {
-				if s, ok := s.(*ast.TypeSpec); ok && s.Name.Name == parts[0] {
-					if s, ok := s.Type.(*ast.StructType); ok {
-						for _, f := range s.Fields.List {
-							for _, name := range f.Names {
-								if name.Name == parts[1] {
-									return f
-								}
-							}
-						}
-					}
-				}
-			}
-		}
-	}
-	return nil
-}
-
-// Don't use ast.CommentGroup.Text() - we want to see exact comment text.
-func commentText(c *ast.CommentGroup) string {
-	var buf bytes.Buffer
-	if c != nil {
-		for _, c := range c.List {
-			buf.WriteString(c.Text)
-		}
-	}
-	return buf.String()
-}
-
-func checkFieldComments(t *testing.T, file *ast.File, fieldname, lead, line string) {
-	f := getField(file, fieldname)
-	if f == nil {
-		t.Fatalf("field not found: %s", fieldname)
-	}
-	if got := commentText(f.Doc); got != lead {
-		t.Errorf("got lead comment %q; expected %q", got, lead)
-	}
-	if got := commentText(f.Comment); got != line {
-		t.Errorf("got line comment %q; expected %q", got, line)
-	}
-}
-
-func TestLeadAndLineComments(t *testing.T) {
-	f, err := ParseFile(fset, "", `
-package p
-type T struct {
-	/* F1 lead comment */
-	//
-	F1 int  /* F1 */ // line comment
-	// F2 lead
-	// comment
-	F2 int  // F2 line comment
-	// f3 lead comment
-	f3 int  // f3 line comment
-}
-`, ParseComments)
-	if err != nil {
-		t.Fatal(err)
-	}
-	checkFieldComments(t, f, "T.F1", "/* F1 lead comment *///", "/* F1 */// line comment")
-	checkFieldComments(t, f, "T.F2", "// F2 lead// comment", "// F2 line comment")
-	checkFieldComments(t, f, "T.f3", "// f3 lead comment", "// f3 line comment")
-	ast.FileExports(f)
-	checkFieldComments(t, f, "T.F1", "/* F1 lead comment *///", "/* F1 */// line comment")
-	checkFieldComments(t, f, "T.F2", "// F2 lead// comment", "// F2 line comment")
-	if getField(f, "T.f3") != nil {
-		t.Error("not expected to find T.f3")
-	}
-}