errorcodes_test.go

Documentation: go/types

		 1  // Copyright 2020 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 types_test
		 6  
		 7  import (
		 8  	"fmt"
		 9  	"go/ast"
		10  	"go/constant"
		11  	"go/importer"
		12  	"go/parser"
		13  	"go/token"
		14  	"reflect"
		15  	"strings"
		16  	"testing"
		17  
		18  	. "go/types"
		19  )
		20  
		21  func TestErrorCodeExamples(t *testing.T) {
		22  	walkCodes(t, func(name string, value int, spec *ast.ValueSpec) {
		23  		t.Run(name, func(t *testing.T) {
		24  			doc := spec.Doc.Text()
		25  			examples := strings.Split(doc, "Example:")
		26  			for i := 1; i < len(examples); i++ {
		27  				example := examples[i]
		28  				err := checkExample(t, example)
		29  				if err == nil {
		30  					t.Fatalf("no error in example #%d", i)
		31  				}
		32  				typerr, ok := err.(Error)
		33  				if !ok {
		34  					t.Fatalf("not a types.Error: %v", err)
		35  				}
		36  				if got := readCode(typerr); got != value {
		37  					t.Errorf("%s: example #%d returned code %d (%s), want %d", name, i, got, err, value)
		38  				}
		39  			}
		40  		})
		41  	})
		42  }
		43  
		44  func walkCodes(t *testing.T, f func(string, int, *ast.ValueSpec)) {
		45  	t.Helper()
		46  	fset := token.NewFileSet()
		47  	files, err := pkgFiles(fset, ".", parser.ParseComments) // from self_test.go
		48  	if err != nil {
		49  		t.Fatal(err)
		50  	}
		51  	conf := Config{Importer: importer.Default()}
		52  	info := &Info{
		53  		Types: make(map[ast.Expr]TypeAndValue),
		54  		Defs:	make(map[*ast.Ident]Object),
		55  		Uses:	make(map[*ast.Ident]Object),
		56  	}
		57  	_, err = conf.Check("types", fset, files, info)
		58  	if err != nil {
		59  		t.Fatal(err)
		60  	}
		61  	for _, file := range files {
		62  		for _, decl := range file.Decls {
		63  			decl, ok := decl.(*ast.GenDecl)
		64  			if !ok || decl.Tok != token.CONST {
		65  				continue
		66  			}
		67  			for _, spec := range decl.Specs {
		68  				spec, ok := spec.(*ast.ValueSpec)
		69  				if !ok || len(spec.Names) == 0 {
		70  					continue
		71  				}
		72  				obj := info.ObjectOf(spec.Names[0])
		73  				if named, ok := obj.Type().(*Named); ok && named.Obj().Name() == "errorCode" {
		74  					if len(spec.Names) != 1 {
		75  						t.Fatalf("bad Code declaration for %q: got %d names, want exactly 1", spec.Names[0].Name, len(spec.Names))
		76  					}
		77  					codename := spec.Names[0].Name
		78  					value := int(constant.Val(obj.(*Const).Val()).(int64))
		79  					f(codename, value, spec)
		80  				}
		81  			}
		82  		}
		83  	}
		84  }
		85  
		86  func readCode(err Error) int {
		87  	v := reflect.ValueOf(err)
		88  	return int(v.FieldByName("go116code").Int())
		89  }
		90  
		91  func checkExample(t *testing.T, example string) error {
		92  	t.Helper()
		93  	fset := token.NewFileSet()
		94  	src := fmt.Sprintf("package p\n\n%s", example)
		95  	file, err := parser.ParseFile(fset, "example.go", src, 0)
		96  	if err != nil {
		97  		t.Fatal(err)
		98  	}
		99  	conf := Config{
	 100  		FakeImportC: true,
	 101  		Importer:		importer.Default(),
	 102  	}
	 103  	_, err = conf.Check("example", fset, []*ast.File{file}, nil)
	 104  	return err
	 105  }
	 106  
	 107  func TestErrorCodeStyle(t *testing.T) {
	 108  	// The set of error codes is large and intended to be self-documenting, so
	 109  	// this test enforces some style conventions.
	 110  	forbiddenInIdent := []string{
	 111  		// use invalid instead
	 112  		"illegal",
	 113  		// words with a common short-form
	 114  		"argument",
	 115  		"assertion",
	 116  		"assignment",
	 117  		"boolean",
	 118  		"channel",
	 119  		"condition",
	 120  		"declaration",
	 121  		"expression",
	 122  		"function",
	 123  		"initial", // use init for initializer, initialization, etc.
	 124  		"integer",
	 125  		"interface",
	 126  		"iterat", // use iter for iterator, iteration, etc.
	 127  		"literal",
	 128  		"operation",
	 129  		"package",
	 130  		"pointer",
	 131  		"receiver",
	 132  		"signature",
	 133  		"statement",
	 134  		"variable",
	 135  	}
	 136  	forbiddenInComment := []string{
	 137  		// lhs and rhs should be spelled-out.
	 138  		"lhs", "rhs",
	 139  		// builtin should be hyphenated.
	 140  		"builtin",
	 141  		// Use dot-dot-dot.
	 142  		"ellipsis",
	 143  	}
	 144  	nameHist := make(map[int]int)
	 145  	longestName := ""
	 146  	maxValue := 0
	 147  
	 148  	walkCodes(t, func(name string, value int, spec *ast.ValueSpec) {
	 149  		if name == "_" {
	 150  			return
	 151  		}
	 152  		nameHist[len(name)]++
	 153  		if value > maxValue {
	 154  			maxValue = value
	 155  		}
	 156  		if len(name) > len(longestName) {
	 157  			longestName = name
	 158  		}
	 159  		if token.IsExported(name) {
	 160  			// This is an experimental API, and errorCode values should not be
	 161  			// exported.
	 162  			t.Errorf("%q is exported", name)
	 163  		}
	 164  		if name[0] != '_' || !token.IsExported(name[1:]) {
	 165  			t.Errorf("%q should start with _, followed by an exported identifier", name)
	 166  		}
	 167  		lower := strings.ToLower(name)
	 168  		for _, bad := range forbiddenInIdent {
	 169  			if strings.Contains(lower, bad) {
	 170  				t.Errorf("%q contains forbidden word %q", name, bad)
	 171  			}
	 172  		}
	 173  		doc := spec.Doc.Text()
	 174  		if !strings.HasPrefix(doc, name) {
	 175  			t.Errorf("doc for %q does not start with identifier", name)
	 176  		}
	 177  		lowerComment := strings.ToLower(strings.TrimPrefix(doc, name))
	 178  		for _, bad := range forbiddenInComment {
	 179  			if strings.Contains(lowerComment, bad) {
	 180  				t.Errorf("doc for %q contains forbidden word %q", name, bad)
	 181  			}
	 182  		}
	 183  	})
	 184  
	 185  	if testing.Verbose() {
	 186  		var totChars, totCount int
	 187  		for chars, count := range nameHist {
	 188  			totChars += chars * count
	 189  			totCount += count
	 190  		}
	 191  		avg := float64(totChars) / float64(totCount)
	 192  		fmt.Println()
	 193  		fmt.Printf("%d error codes\n", totCount)
	 194  		fmt.Printf("average length: %.2f chars\n", avg)
	 195  		fmt.Printf("max length: %d (%s)\n", len(longestName), longestName)
	 196  	}
	 197  }
	 198
View as plain text