 @@ -358,96 +358,100 @@ func (s *Suite) Test_Pkgsrc_parseDocChan
 	test("\tAdded something [author date]",
 		"WARN: doc/CHANGES-2019:123: Invalid doc/CHANGES line: "+
 			"\tAdded something [author date]")
 	test("\tAdded category/package 1.0 [author 2019-11-17]",
 		"WARN: doc/CHANGES-2019:123: Invalid doc/CHANGES line: "+
 			"\tAdded category/package 1.0 [author 2019-11-17]")
 	test("\t\tToo large indentation",
 		"WARN: doc/CHANGES-2019:123: Package changes should be indented using a single tab, not \"\\t\\t\".")
 	test("\t Too large indentation",
 		"WARN: doc/CHANGES-2019:123: Package changes should be indented using a single tab, not \"\\t \".")
 	test("\t",
 		"WARN: doc/CHANGES-2019:123: Invalid doc/CHANGES line: \t")
 	test("\t1",
 		"WARN: doc/CHANGES-2019:123: Invalid doc/CHANGES line: \t1")
 	test("\t1 2 3 4",
 		"WARN: doc/CHANGES-2019:123: Invalid doc/CHANGES line: \t1 2 3 4")
 	test("\t1 2 3 4 5",
 		"WARN: doc/CHANGES-2019:123: Invalid doc/CHANGES line: \t1 2 3 4 5")
 	test("\t1 2 3 4 5 6",
 		"WARN: doc/CHANGES-2019:123: Invalid doc/CHANGES line: \t1 2 3 4 5 6")
 	test("\t1 2 3 4 5 6 7",
 		"WARN: doc/CHANGES-2019:123: Invalid doc/CHANGES line: \t1 2 3 4 5 6 7")
 	test("\t1 2 [3 4",
 		"WARN: doc/CHANGES-2019:123: Invalid doc/CHANGES line: \t1 2 [3 4")
 	test("\t1 2 [3 4]",
 		"WARN: doc/CHANGES-2019:123: Invalid doc/CHANGES line: \t1 2 [3 4]")
 	test("\tAdded 2 [3 4]",
 		"WARN: doc/CHANGES-2019:123: Invalid doc/CHANGES line: \tAdded 2 [3 4]")
 	test("\tAdded pkgpath version 1.0 [author 2019-01-01]",
 		nil...)
 	// "to" is wrong
-	test("\tAdded pkgpath to 1.0 [author date]",
+	test("\tAdded pkgpath to 1.0 [author 2019-01-01]",
 		"WARN: doc/CHANGES-2019:123: Invalid doc/CHANGES line: "+
-			"\tAdded pkgpath to 1.0 [author date]")
+			"\tAdded pkgpath to 1.0 [author 2019-01-01]")
 	test("\tUpdated pkgpath to 1.0 [author 2019-01-01]",
 		nil...)
 	// "from" is wrong
-	test("\tUpdated pkgpath from 1.0 [author date]",
+	test("\tUpdated pkgpath from 1.0 [author 2019-01-01]",
 		"WARN: doc/CHANGES-2019:123: Invalid doc/CHANGES line: "+
-			"\tUpdated pkgpath from 1.0 [author date]")
+			"\tUpdated pkgpath from 1.0 [author 2019-01-01]")
 	test("\tDowngraded pkgpath to 1.0 [author 2019-01-01]",
 		nil...)
 	// "from" is wrong
-	test("\tDowngraded pkgpath from 1.0 [author date]",
+	test("\tDowngraded pkgpath from 1.0 [author 2019-01-01]",
 		"WARN: doc/CHANGES-2019:123: Invalid doc/CHANGES line: "+
-			"\tDowngraded pkgpath from 1.0 [author date]")
+			"\tDowngraded pkgpath from 1.0 [author 2019-01-01]")
 	test("\tRemoved pkgpath [author 2019-01-01]",
 		nil...)
 	test("\tRemoved pkgpath successor pkgpath [author 2019-01-01]",
 		nil...)
 	// "and" is wrong
-	test("\tRemoved pkgpath and pkgpath [author date]",
+	test("\tRemoved pkgpath and pkgpath [author 2019-01-01]",
 		"WARN: doc/CHANGES-2019:123: Invalid doc/CHANGES line: "+
-			"\tRemoved pkgpath and pkgpath [author date]")
+			"\tRemoved pkgpath and pkgpath [author 2019-01-01]")
 	test("\tRenamed pkgpath to other [author 2019-01-01]",
 		nil...)
 	// "from" is wrong
-	test("\tRenamed pkgpath from previous [author date]",
+	test("\tRenamed pkgpath from previous [author 2019-01-01]",
 		"WARN: doc/CHANGES-2019:123: Invalid doc/CHANGES line: "+
-			"\tRenamed pkgpath from previous [author date]")
+			"\tRenamed pkgpath from previous [author 2019-01-01]")
 	test("\tMoved pkgpath to other [author 2019-01-01]",
 		nil...)
 	// "from" is wrong
-	test("\tMoved pkgpath from previous [author date]",
+	test("\tMoved pkgpath from previous [author 2019-01-01]",
 		"WARN: doc/CHANGES-2019:123: Invalid doc/CHANGES line: "+
-			"\tMoved pkgpath from previous [author date]")
+			"\tMoved pkgpath from previous [author 2019-01-01]")
 	// "Split" is wrong
-	test("\tSplit pkgpath into a and b [author date]",
+	test("\tSplit pkgpath into a and b [author 2019-01-01]",
 		"WARN: doc/CHANGES-2019:123: Invalid doc/CHANGES line: "+
-			"\tSplit pkgpath into a and b [author date]")
+			"\tSplit pkgpath into a and b [author 2019-01-01]")
 	// Entries ending in a colon are used for infrastructure changes.
 	test("\tmk: remove support for USE_CROSSBASE [author 2016-06-19]",
 		nil...)
 	test("\tAdded category/pkgpath version 1.0 [author-dash 2019-01-01]",
 		"WARN: doc/CHANGES-2019:123: Invalid doc/CHANGES line: "+
 			"\tAdded category/pkgpath version 1.0 [author-dash 2019-01-01]")
+}
 func (s *Suite) Test_Pkgsrc_checkRemovedAfterLastFreeze(c *check.C) {
 	t := s.Init(c)

 @@ -1,33 +1,34 @@
 // Package intqa provides quality assurance for the pkglint code.
 package intqa
 import (
 	"fmt"
 	"go/ast"
 	"go/parser"
 	"go/token"
 	"io"
 	"os"
-	"path/filepath"
+	"path"
 	"reflect"
 	"sort"
 	"strings"
 	"unicode"
+)
 type Error int
 const (
-	ENone Error = iota
+	ENone Error = iota + 1
 	EAll
 	// A function or method does not have a corresponding test.
 	EMissingTest
 	// The name of a test function does not correspond to a program
 	// element to be tested.
 	EMissingTestee
 	// The tests are not in the same order as their corresponding
 	// testees in the main code.
 	EOrder
 @@ -35,368 +36,428 @@ const (
 	EName
 	// The file of the test method does not correspond to the
 	// file of the testee.
 	EFile
+)
 // TestNameChecker ensures that all test names follow a common naming scheme:
 //  Test_${Type}_${Method}__${description_using_underscores}
 // Each of the variable parts may be omitted.
 type TestNameChecker struct {
 	errorf func(format string, args ...interface{})
-	ignoredFiles []string
+	filters []filter
-	order        int
+	order   int
 	testees []*testee
 	tests   []*test
-	errorsMask uint64
+	errors []string
-	errors     []string
+	out    io.Writer
 	out        io.Writer
+}
 // NewTestNameChecker creates a new checker.
-// By default, all errors are disabled; call Enable to enable them.
+// By default, all errors are enabled;
 // call Configure to disable them selectively.
 func NewTestNameChecker(errorf func(format string, args ...interface{})) *TestNameChecker {
-	return &TestNameChecker{errorf: errorf, out: os.Stderr}
+	ck := TestNameChecker{errorf: errorf, out: os.Stderr}
-func (ck *TestNameChecker) IgnoreFiles(fileGlob string) {
+	// For test fixtures from https://gopkg.in/check/v1.
-	ck.ignoredFiles = append(ck.ignoredFiles, fileGlob)
+	ck.Configure("*_test.go", "*", "SetUpTest", -EMissingTest)
 	ck.Configure("*_test.go", "*", "TearDownTest", -EMissingTest)
-func (ck *TestNameChecker) Enable(errors ...Error) {
+	// See https://github.com/rillig/gobco.
-	for _, err := range errors {
+	ck.Configure("gobco_*.go", "gobco*", "*", -EMissingTest)
-		if err == ENone {
+	ck.Configure("gobco_*.go", "", "gobco*", -EMissingTest)
 			ck.errorsMask = 0
-		} else if err == EAll {
+	return &ck
 			ck.errorsMask = ^uint64(0)
 		} else if err < 0 {
-			ck.errorsMask &= ^(uint64(1) << -uint(err))
+// Configure sets the errors that are activated for the given code,
-		} else {
+// specified by shell patterns like in path.Match.
-			ck.errorsMask |= uint64(1) << uint(err)
+//
 // All rules are applied in order. Later rules overwrite earlier rules.
 //
 // Individual errors can be enabled by giving their constant and disabled
 // by negating them, such as -EMissingTestee. To reset everything, use
 // either EAll or ENone.
 func (ck *TestNameChecker) Configure(filenames, typeNames, funcNames string, errors ...Error) {
 	ck.filters = append(ck.filters, filter{filenames, typeNames, funcNames, errors})
+}
 func (ck *TestNameChecker) Check() {
-	ck.load()
+	ck.load(".")
 	ck.checkTestees()
 	ck.checkTests()
 	ck.checkOrder()
 	ck.print()
+}
 // load loads all type, function and method names from the current package.
-func (ck *TestNameChecker) load() {
+func (ck *TestNameChecker) load(dir string) {
 	fileSet := token.NewFileSet()
-	pkgs, err := parser.ParseDir(fileSet, ".", nil, 0)
+	pkgs, err := parser.ParseDir(fileSet, dir, nil, 0)
 	if err != nil {
 		panic(err)
+	}
-	var pkgnames []string
+	for _, pkgname := range sortedKeys(pkgs) {
 	for pkgname := range pkgs {
 		pkgnames = append(pkgnames, pkgname)
 	sort.Strings(pkgnames)
 	for _, pkgname := range pkgnames {
 		files := pkgs[pkgname].Files
-		var filenames []string
+		for _, filename := range sortedKeys(files) {
 		for filename := range files {
 			filenames = append(filenames, filename)
 		sort.Strings(filenames)
 		for _, filename := range filenames {
 			file := files[filename]
 			for _, decl := range file.Decls {
 				ck.loadDecl(decl, filename)
+			}
+		}
+	}
 	ck.relate()
+}
 // loadDecl adds a single type or function declaration to the known elements.
 func (ck *TestNameChecker) loadDecl(decl ast.Decl, filename string) {
 	switch decl := decl.(type) {
 	case *ast.GenDecl:
 		for _, spec := range decl.Specs {
 			switch spec := spec.(type) {
 			case *ast.TypeSpec:
 				typeName := spec.Name.Name
-				ck.addCode(code{filename, typeName, "", ck.nextOrder()})
+				ck.addCode(code{filename, typeName, "", 0})
+			}
+		}
 	case *ast.FuncDecl:
 		typeName := ""
 		if decl.Recv != nil {
 			typeExpr := decl.Recv.List[0].Type.(ast.Expr)
 			if star, ok := typeExpr.(*ast.StarExpr); ok {
 				typeName = star.X.(*ast.Ident).Name
 			} else {
 				typeName = typeExpr.(*ast.Ident).Name
+			}
+		}
-		ck.addCode(code{filename, typeName, decl.Name.Name, ck.nextOrder()})
+		funcName := decl.Name.Name
 		ck.addCode(code{filename, typeName, funcName, 0})
+	}
+}
 func (ck *TestNameChecker) addCode(code code) {
-	isTest := strings.HasSuffix(code.file, "_test.go") &&
+	if code.isTestScope() && code.isFunc() && code.Func == "TestMain" {
-		code.Type != "" &&
+		// This is not a test for Main, but a wrapper function of the test.
-		strings.HasPrefix(code.Func, "Test")
+		// Therefore it is completely ignored.
 		// See https://golang.org/pkg/testing/#hdr-Main.
 		//
 		// Among others, this function is created by
 		// https://github.com/rillig/gobco when measuring the branch
 		// coverage of a package.
 		return
+	}
-	if isTest {
+	if !ck.isRelevant(code.file, code.Type, code.Func, EAll) {
 		return
+	}
 	if code.isTest() {
 		ck.addTest(code)
 	} else {
 		ck.addTestee(code)
+	}
+}
 func (ck *TestNameChecker) addTestee(code code) {
 	code.order = ck.nextOrder()
 	ck.testees = append(ck.testees, &testee{code})
+}
 func (ck *TestNameChecker) addTest(code code) {
-	if !strings.HasPrefix(code.Func, "Test_") {
+	if !strings.HasPrefix(code.Func, "Test_") &&
 		code.Func != "Test" &&
 		ck.addError(
 			EName,
 			code,
 			"Test %q must start with %q.",
-			code.fullName(), "Test_")
+			code.fullName(), "Test_") {
 		return
+	}
 	parts := strings.SplitN(code.Func, "__", 2)
 	testeeName := strings.TrimPrefix(strings.TrimPrefix(parts[0], "Test"), "_")
 	descr := ""
 	if len(parts) > 1 {
-		if parts[1] == "" {
+		if parts[1] == "" &&
 			ck.addError(
 				EName,
-				"Test %q must not have a nonempty description.",
+				code,
-				code.fullName())
+				"Test %q must have a nonempty description.",
 				code.fullName()) {
 			return
+		}
 		descr = parts[1]
+	}
 	code.order = ck.nextOrder()
 	ck.tests = append(ck.tests, &test{code, testeeName, descr, nil})
+}
 func (ck *TestNameChecker) nextOrder() int {
 	id := ck.order
 	ck.order++
 	return id
+}
 // relate connects the tests to their testees.
 func (ck *TestNameChecker) relate() {
 	testeesByPrefix := make(map[string]*testee)
 	for _, testee := range ck.testees {
 		prefix := join(testee.Type, "_", testee.Func)
 		testeesByPrefix[prefix] = testee
+	}
 	for _, test := range ck.tests {
 		test.testee = testeesByPrefix[test.testeeName]
+	}
+}
 func (ck *TestNameChecker) checkTests() {
 	for _, test := range ck.tests {
 		ck.checkTestFile(test)
 		ck.checkTestName(test)
 		ck.checkTestTestee(test)
 		ck.checkTestDescr(test)
+	}
+}
 func (ck *TestNameChecker) checkTestFile(test *test) {
 	testee := test.testee
 	if testee == nil || testee.file == test.file {
 		return
+	}
 	correctTestFile := strings.TrimSuffix(testee.file, ".go") + "_test.go"
-	if correctTestFile != test.file {
+	if correctTestFile == test.file {
-		ck.addError(
+		return
 			EFile,
 			"Test %q for %q must be in %s instead of %s.",
 			test.fullName(), testee.fullName(), correctTestFile, test.file)
+	}
 	ck.addError(
 		EFile,
 		test.code,
 		"Test %q for %q must be in %s instead of %s.",
 		test.fullName(), testee.fullName(), correctTestFile, test.file)
+}
 func (ck *TestNameChecker) checkTestTestee(test *test) {
 	testee := test.testee
 	if testee != nil || test.testeeName == "" {
 		return
+	}
 	testeeName := strings.Replace(test.testeeName, "_", ".", -1)
 	ck.addError(
 		EMissingTestee,
 		test.code,
 		"Missing testee %q for test %q.",
 		testeeName, test.fullName())
+}
-// checkTestName ensures that the method name does not accidentally
+// checkTestDescr ensures that the type or function name of the testee
-// end up in the description of the test. This could happen if there is a
+// does not accidentally end up in the description of the test. This could
-// double underscore instead of a single underscore.
+// happen if there is a double underscore instead of a single underscore.
-func (ck *TestNameChecker) checkTestName(test *test) {
+func (ck *TestNameChecker) checkTestDescr(test *test) {
 	testee := test.testee
-	if testee == nil {
+	if testee == nil || testee.isMethod() || !isCamelCase(test.descr) {
 		return
 	if testee.Type != "" && testee.Func != "" {
 		return
 	if !isCamelCase(test.descr) {
 		return
+	}
 	ck.addError(
 		EName,
 		testee.code,
 		"%s: Test description %q must not use CamelCase in the first word.",
 		test.fullName(), test.descr)
+}
 func (ck *TestNameChecker) checkTestees() {
 	tested := make(map[*testee]bool)
 	for _, test := range ck.tests {
 		tested[test.testee] = true
+	}
 	for _, testee := range ck.testees {
-		if tested[testee] || testee.Func == "" {
+		ck.checkTesteeTest(testee, tested)
 			continue
+}
-		testName := "Test_" + join(testee.Type, "_", testee.Func)
+func (ck *TestNameChecker) checkTesteeTest(testee *testee, tested map[*testee]bool) {
-		ck.addError(
+	if tested[testee] || testee.isType() {
-			EMissingTest,
+		return
 			"Missing unit test %q for %q.",
 			testName, testee.fullName())
+	}
 	testName := "Test_" + join(testee.Type, "_", testee.Func)
 	ck.addError(
 		EMissingTest,
 		testee.code,
 		"Missing unit test %q for %q.",
 		testName, testee.fullName())
+}
-func (ck *TestNameChecker) isIgnored(filename string) bool {
+// isRelevant checks whether the given error is enabled.
-	for _, mask := range ck.ignoredFiles {
+func (ck *TestNameChecker) isRelevant(filename, typeName, funcName string, e Error) bool {
-		ok, err := filepath.Match(mask, filename)
+	mask := ^uint64(0)
-		if err != nil {
+	for _, filter := range ck.filters {
-			panic(err)
+		if matches(filename, filter.filenames) &&
 			matches(typeName, filter.typeNames) &&
 			matches(funcName, filter.funcNames) {
 			mask = ck.errorsMask(mask, filter.errors...)
+		}
 		if ok {
-			return true
+	return mask&ck.errorsMask(0, e) != 0
+}
 func (ck *TestNameChecker) errorsMask(mask uint64, errors ...Error) uint64 {
 	for _, err := range errors {
 		if err == ENone {
 			mask = 0
 		} else if err == EAll {
 			mask = ^uint64(0)
 		} else if err < 0 {
 			mask &= ^(uint64(1) << -uint(err))
 		} else {
 			mask |= uint64(1) << uint(err)
+		}
+	}
-	return false
+	return mask
+}
 // checkOrder ensures that the tests appear in the same order as their
 // counterparts in the main code.
 func (ck *TestNameChecker) checkOrder() {
 	maxOrderByFile := make(map[string]*test)
 	for _, test := range ck.tests {
 		testee := test.testee
 		if testee == nil {
 			continue
+		}
 		maxOrder := maxOrderByFile[testee.file]
 		if maxOrder == nil || testee.order > maxOrder.testee.order {
 			maxOrderByFile[testee.file] = test
+		}
 		if maxOrder != nil && testee.order < maxOrder.testee.order {
 			insertBefore := maxOrder
 			for _, before := range ck.tests {
 				if before.file == test.file && before.testee != nil && before.testee.order > testee.order {
 					insertBefore = before
 					break
+				}
+			}
 			ck.addError(
 				EOrder,
-				"Test %q should be ordered before %q.",
+				test.code,
 				"Test %q must be ordered before %q.",
 				test.fullName(), insertBefore.fullName())
+		}
+	}
+}
-func (ck *TestNameChecker) addError(e Error, format string, args ...interface{}) {
+func (ck *TestNameChecker) addError(e Error, c code, format string, args ...interface{}) bool {
-	if ck.errorsMask&(uint64(1)<<uint(e)) != 0 {
+	relevant := ck.isRelevant(c.file, c.Type, c.Func, e)
 	if relevant {
 		ck.errors = append(ck.errors, fmt.Sprintf(format, args...))
+	}
 	return relevant
+}
 func (ck *TestNameChecker) print() {
 	for _, msg := range ck.errors {
 		_, _ = fmt.Fprintln(ck.out, msg)
+	}
-	errors := plural(len(ck.errors), "error", "errors")
+	n := len(ck.errors)
-	if len(ck.errors) > 0 {
+	if n > 1 {
-		ck.errorf("%s.", errors)
+		ck.errorf("%d errors.", n)
 	} else if n == 1 {
 		ck.errorf("%d error.", n)
+	}
+}
-type code struct {
+type filter struct {
-	file  string // The file containing the code
+	filenames string
-	Type  string // The type, e.g. MkLine
+	typeNames string
-	Func  string // The function or method name, e.g. Warnf
+	funcNames string
-	order int    // The relative order in the file
+	errors    []Error
+}
 func (c *code) fullName() string { return join(c.Type, ".", c.Func) }
 // testee is an element of the source code that can be tested.
 // It is either a type, a function or a method.
 type testee struct {
 	code
+}
 type test struct {
 	code
 	testeeName string // The method name without the "Test_" prefix and description
 	descr      string // The part after the "__" in the method name
 	testee     *testee
+}
-func plural(n int, sg, pl string) string {
+// code is either a type, a function or a method.
-	if n == 0 {
+type code struct {
-		return ""
+	file  string // the file containing the code
 	Type  string // the type, e.g. MkLine
-	form := pl
+	Func  string // the function or method name, e.g. Warnf
-	if n == 1 {
+	order int    // the relative order in the file
 		form = sg
-	return fmt.Sprintf("%d %s", n, form)
+func (c *code) fullName() string { return join(c.Type, ".", c.Func) }
 func (c *code) isFunc() bool     { return c.Type == "" }
 func (c *code) isType() bool     { return c.Func == "" }
 func (c *code) isMethod() bool   { return c.Type != "" && c.Func != "" }
 func (c *code) isTest() bool {
 	return c.isTestScope() && strings.HasPrefix(c.Func, "Test")
+}
 func (c *code) isTestScope() bool {
 	return strings.HasSuffix(c.file, "_test.go")
+}
 func isCamelCase(str string) bool {
 	for i := 0; i+1 < len(str); i++ {
 		if str[i] == '_' {
 			return false
+		}
 		if unicode.IsLower(rune(str[i])) && unicode.IsUpper(rune(str[i+1])) {
 			return true
+		}
+	}
 	return false
+}
 func join(a, sep, b string) string {
 	if a == "" || b == "" {
 		sep = ""
+	}
 	return a + sep + b
+}
 func matches(subj string, pattern string) bool {
 	ok, err := path.Match(pattern, subj)
 	if err != nil {
 		panic(err)
+	}
 	return ok
+}
 // sortedKeys returns the sorted keys from an arbitrary map.
 func sortedKeys(m interface{}) []string {
 	var keys []string
 	for _, key := range reflect.ValueOf(m).MapKeys() {
 		keys = append(keys, key.Interface().(string))
+	}
 	sort.Strings(keys)
 	return keys
+}

 @@ -1,125 +1,310 @@
 package intqa
 import (
 	"bytes"
 	"fmt"
 	"go/ast"
 	"gopkg.in/check.v1"
 	"io/ioutil"
 	"path"
 	"testing"
+)
 type Suite struct {
 	c       *check.C
 	ck      *TestNameChecker
 	summary string
+}
 func Test(t *testing.T) {
 	check.Suite(&Suite{})
 	check.TestingT(t)
+}
 func (s *Suite) Init(c *check.C) *TestNameChecker {
 	errorf := func(format string, args ...interface{}) {
 		s.summary = fmt.Sprintf(format, args...)
+	}
 	s.c = c
 	s.ck = NewTestNameChecker(errorf)
 	s.ck.Enable(EAll)
 	s.ck.out = ioutil.Discard
 	return s.ck
+}
 func (s *Suite) TearDownTest(c *check.C) {
 	s.c = c
 	s.CheckErrors(nil...)
 	s.CheckSummary("")
+}
 func (s *Suite) CheckTestees(testees ...*testee) {
 	s.c.Check(s.ck.testees, check.DeepEquals, testees)
 	s.ck.testees = nil
+}
 func (*Suite) newTestee(filename, typeName, funcName string, order int) *testee {
 	return &testee{code{filename, typeName, funcName, order}}
+}
 func (s *Suite) CheckTests(tests ...*test) {
 	s.c.Check(s.ck.tests, check.DeepEquals, tests)
 	s.ck.tests = nil
+}
 func (*Suite) newTest(filename, typeName, funcName string, order int, testeeName, descr string, testee *testee) *test {
 	c := code{filename, typeName, funcName, order}
 	return &test{c, testeeName, descr, testee}
+}
 func (s *Suite) CheckErrors(errors ...string) {
 	s.c.Check(s.ck.errors, check.DeepEquals, errors)
 	s.ck.errors = nil
+}
 func (s *Suite) CheckSummary(summary string) {
 	s.c.Check(s.summary, check.Equals, summary)
 	s.summary = ""
+}
-func (s *Suite) Test_TestNameChecker_Enable(c *check.C) {
+func (s *Suite) Test_NewTestNameChecker(c *check.C) {
 	ck := s.Init(c)
 	c.Check(ck.isRelevant("*_test.go", "Suite", "SetUpTest", EAll), check.Equals, true)
 	c.Check(ck.isRelevant("*_test.go", "Suite", "SetUpTest", EMissingTest), check.Equals, false)
 	c.Check(ck.isRelevant("*_test.go", "Suite", "TearDownTest", EAll), check.Equals, true)
 	c.Check(ck.isRelevant("*_test.go", "Suite", "TearDownTest", EMissingTest), check.Equals, false)
+}
 func (s *Suite) Test_TestNameChecker_Configure(c *check.C) {
 	ck := s.Init(c)
-	ck.Enable(ENone) // overwrite initialization from Suite.Init
+	ck.Configure("*", "*", "*", ENone) // overwrite initialization from Suite.Init
 	c.Check(ck.isRelevant("", "", "", EAll), check.Equals, false)
 	c.Check(ck.isRelevant("", "", "", EMissingTestee), check.Equals, false)
 	c.Check(ck.isRelevant("", "", "", EMissingTest), check.Equals, false)
 	ck.Configure("*", "*", "*", EAll)
-	c.Check(ck.errorsMask, check.Equals, uint64(0))
+	c.Check(ck.isRelevant("", "", "", EAll), check.Equals, true)
 	c.Check(ck.isRelevant("", "", "", EMissingTestee), check.Equals, true)
 	c.Check(ck.isRelevant("", "", "", EMissingTest), check.Equals, true)
-	ck.Enable(EAll)
+	ck.Configure("*", "*", "*", -EMissingTestee)
-	c.Check(ck.errorsMask, check.Equals, ^uint64(0))
+	c.Check(ck.isRelevant("", "", "", EAll), check.Equals, true)
 	c.Check(ck.isRelevant("", "", "", EMissingTestee), check.Equals, false)
 	c.Check(ck.isRelevant("", "", "", EMissingTest), check.Equals, true)
 	ck.Configure("*", "*", "*", ENone, EMissingTest)
 	c.Check(ck.isRelevant("", "", "", EAll), check.Equals, true)
 	c.Check(ck.isRelevant("", "", "", EMissingTestee), check.Equals, false)
 	c.Check(ck.isRelevant("", "", "", EMissingTest), check.Equals, true)
 	ck.Configure("*", "*", "*", EAll, -EMissingTest)
 	c.Check(ck.isRelevant("", "", "", EAll), check.Equals, true)
 	c.Check(ck.isRelevant("", "", "", EMissingTestee), check.Equals, true)
 	c.Check(ck.isRelevant("", "", "", EMissingTest), check.Equals, false)
+}
-	ck.Enable(ENone, EMissingTest)
+func (s *Suite) Test_TestNameChecker_Configure__ignore_single_function(c *check.C) {
 	ck := s.Init(c)
-	c.Check(ck.errorsMask, check.Equals, uint64(4))
+	ck.Configure("*", "*", "*", EAll)
-	ck.Enable(EAll, -EMissingTest)
+	// The intention of this rule is that this particular function is ignored.
 	// Everything else from that file is still processed.
 	ck.Configure("*_test.go", "", "TestMain", ENone)
-	c.Check(ck.errorsMask, check.Equals, ^uint64(0)^4)
+	c.Check(ck.isRelevant("file_test.go", "", "", EAll), check.Equals, true)
 	c.Check(ck.isRelevant("file_test.go", "*", "*", EAll), check.Equals, true)
 	c.Check(ck.isRelevant("file_test.go", "*", "Other", EAll), check.Equals, true)
 	c.Check(ck.isRelevant("file_test.go", "", "TestMain", EAll), check.Equals, false)
 	c.Check(ck.isRelevant("file_test.go", "*", "TestMain", EAll), check.Equals, true)
+}
 func (s *Suite) Test_TestNameChecker_Check(c *check.C) {
 	ck := s.Init(c)
 	ck.Configure("*", "Suite", "*", -EMissingTest)
 	ck.Check()
 	s.CheckErrors(
 		"Missing unit test \"Test_NewTestNameChecker\" for \"NewTestNameChecker\".",
 		"Missing unit test \"Test_TestNameChecker_IgnoreFiles\" for \"TestNameChecker.IgnoreFiles\".",
 		"Missing unit test \"Test_TestNameChecker_load\" for \"TestNameChecker.load\".",
 		"Missing unit test \"Test_TestNameChecker_loadDecl\" for \"TestNameChecker.loadDecl\".",
 		"Missing unit test \"Test_TestNameChecker_addCode\" for \"TestNameChecker.addCode\".",
 		"Missing unit test \"Test_TestNameChecker_addTestee\" for \"TestNameChecker.addTestee\".",
 		"Missing unit test \"Test_TestNameChecker_nextOrder\" for \"TestNameChecker.nextOrder\".",
 		"Missing unit test \"Test_TestNameChecker_relate\" for \"TestNameChecker.relate\".",
-		"Missing unit test \"Test_TestNameChecker_checkTests\" for \"TestNameChecker.checkTests\".",
+		"Missing unit test \"Test_TestNameChecker_isRelevant\" for \"TestNameChecker.isRelevant\".")
-		"Missing unit test \"Test_TestNameChecker_checkTestees\" for \"TestNameChecker.checkTestees\".",
+	s.CheckSummary("3 errors.")
 		"Missing unit test \"Test_TestNameChecker_isIgnored\" for \"TestNameChecker.isIgnored\".",
 		"Missing unit test \"Test_TestNameChecker_addError\" for \"TestNameChecker.addError\".",
-		"Missing unit test \"Test_Test\" for \"Test\".",
+func (s *Suite) Test_TestNameChecker_load__filtered_nothing(c *check.C) {
-		"Missing unit test \"Test_Suite_Init\" for \"Suite.Init\".",
+	ck := s.Init(c)
 		"Missing unit test \"Test_Suite_TearDownTest\" for \"Suite.TearDownTest\".",
-		"Missing unit test \"Test_Suite_CheckErrors\" for \"Suite.CheckErrors\".",
+	ck.Configure("*", "*", "*", ENone)
 		"Missing unit test \"Test_Suite_CheckSummary\" for \"Suite.CheckSummary\".",
-		"Missing unit test \"Test_Value_Method\" for \"Value.Method\".")
+	ck.load(".")
 	s.CheckSummary("18 errors.")
 	c.Check(ck.testees, check.IsNil)
 	c.Check(ck.tests, check.IsNil)
+}
 func (s *Suite) Test_TestNameChecker_load__filtered_only_Value(c *check.C) {
 	ck := s.Init(c)
 	ck.Configure("*", "*", "*", ENone)
 	ck.Configure("*", "Value", "*", EAll)
 	ck.load(".")
 	c.Check(ck.testees, check.DeepEquals, []*testee{
 		{code{"testnames_test.go", "Value", "", 0}},
 		{code{"testnames_test.go", "Value", "Method", 1}}})
 	c.Check(ck.tests, check.IsNil)
+}
 func (s *Suite) Test_TestNameChecker_load__panic(c *check.C) {
 	ck := s.Init(c)
 	c.Check(
 		func() { ck.load("does-not-exist") },
 		check.PanicMatches,
 		`^open does-not-exist\b.*`)
+}
 func (s *Suite) Test_TestNameChecker_loadDecl(c *check.C) {
 	ck := s.Init(c)
 	typeDecl := func(name string) *ast.GenDecl {
 		return &ast.GenDecl{Specs: []ast.Spec{&ast.TypeSpec{Name: &ast.Ident{Name: name}}}}
+	}
 	funcDecl := func(name string) *ast.FuncDecl {
 		return &ast.FuncDecl{Name: &ast.Ident{Name: name}}
+	}
 	methodDecl := func(typeName, methodName string) *ast.FuncDecl {
 		return &ast.FuncDecl{
 			Name: &ast.Ident{Name: methodName},
 			Recv: &ast.FieldList{List: []*ast.Field{{Type: &ast.Ident{Name: typeName}}}}}
+	}
 	ck.loadDecl(typeDecl("TypeName"), "file_test.go")
 	s.CheckTestees(
 		s.newTestee("file_test.go", "TypeName", "", 0))
 	// The freestanding TestMain function is ignored by a hardcoded rule,
 	// independently of the configuration.
 	ck.loadDecl(funcDecl("TestMain"), "file_test.go")
 	// The TestMain method on a type is relevant, but violates the naming rule.
 	// Therefore it is ignored.
 	ck.loadDecl(methodDecl("Suite", "TestMain"), "file_test.go")
 	s.CheckTests(
 		nil...)
 	s.CheckErrors(
 		"Test \"Suite.TestMain\" must start with \"Test_\".")
 	// The above error can be disabled, and then the method is handled
 	// like any other test method.
 	ck.Configure("*", "Suite", "*", -EName)
 	ck.loadDecl(methodDecl("Suite", "TestMain"), "file_test.go")
 	s.CheckTests(
 		s.newTest("file_test.go", "Suite", "TestMain", 1, "Main", "", nil))
 	// There is no special handling for TestMain method with a description.
 	ck.loadDecl(methodDecl("Suite", "TestMain__descr"), "file_test.go")
 	s.CheckTests(
 		s.newTest("file_test.go", "Suite", "TestMain__descr", 2, "Main", "descr", nil))
+}
 func (s *Suite) Test_TestNameChecker_addTestee(c *check.C) {
 	ck := s.Init(c)
 	code := code{"filename.go", "Type", "Method", 0}
 	ck.addTestee(code)
 	c.Check(ck.testees, check.DeepEquals, []*testee{{code}})
+}
 func (s *Suite) Test_TestNameChecker_addTest(c *check.C) {
 	ck := s.Init(c)
 	ck.addTest(code{"filename.go", "Type", "Method", 0})
 	c.Check(ck.tests, check.IsNil)
 	s.CheckErrors(
 		"Test \"Type.Method\" must start with \"Test_\".")
+}
 func (s *Suite) Test_TestNameChecker_addTest__empty_description(c *check.C) {
 	ck := s.Init(c)
-	ck.addTest(code{"filename.go", "Suite", "Test_Method__", 0})
+	ck.addTest(code{"f_test.go", "Suite", "Test_Method__", 0})
 	s.CheckErrors(
 		"Test \"Suite.Test_Method__\" must have a nonempty description.")
 	// The test is not registered and thus cannot complain about its missing
 	// testee.
 	ck.checkTests()
 	s.CheckErrors(
 		nil...)
+}
 func (s *Suite) Test_TestNameChecker_addTest__suppressed_empty_description(c *check.C) {
 	ck := s.Init(c)
 	ck.Configure("*", "*", "*", -EName)
 	ck.addTest(code{"f_test.go", "Suite", "Test_Method__", 0})
 	s.CheckErrors(
 		nil...)
 	// Since there was no error above, the test is added normally
 	// and can complain about its missing testee.
 	ck.checkTests()
 	s.CheckErrors(
 		"Missing testee \"Method\" for test \"Suite.Test_Method__\".")
+}
 func (s *Suite) Test_TestNameChecker_nextOrder(c *check.C) {
 	ck := s.Init(c)
 	c.Check(ck.nextOrder(), check.Equals, 0)
 	c.Check(ck.nextOrder(), check.Equals, 1)
 	c.Check(ck.nextOrder(), check.Equals, 2)
+}
 func (s *Suite) Test_TestNameChecker_checkTests(c *check.C) {
 	ck := s.Init(c)
 	ck.tests = append(ck.tests,
 		s.newTest("wrong_test.go", "", "Test_Func", 0, "Func", "",
 			s.newTestee("source.go", "", "Func", 1)))
 	ck.checkTests()
 	s.CheckErrors(
-		"Test \"Suite.Test_Method__\" must not have a nonempty description.")
+		"Test \"Test_Func\" for \"Func\" " +
 			"must be in source_test.go instead of wrong_test.go.")
+}
 func (s *Suite) Test_TestNameChecker_checkTestFile__global(c *check.C) {
 	ck := s.Init(c)
 	ck.checkTestFile(&test{
 		code{"demo_test.go", "Suite", "Test__Global", 0},
 		"",
 		"",
 		&testee{code{"other.go", "", "Global", 0}}})
 	s.CheckErrors(
 		"Test \"Suite.Test__Global\" for \"Global\" " +
 @@ -155,126 +340,289 @@ func (s *Suite) Test_TestNameChecker_che
 func (s *Suite) Test_TestNameChecker_checkTestTestee__testee_exists(c *check.C) {
 	ck := s.Init(c)
 	ck.checkTestTestee(&test{
 		code{"demo_test.go", "Suite", "Test_Missing", 0},
 		"Missing",
 		"",
 		&testee{}})
 	s.CheckErrors(
 		nil...)
+}
-func (s *Suite) Test_TestNameChecker_checkTestName__camel_case(c *check.C) {
+func (s *Suite) Test_TestNameChecker_checkTestDescr__camel_case(c *check.C) {
 	ck := s.Init(c)
-	ck.checkTestName(&test{
+	ck.checkTestDescr(&test{
 		code{"demo_test.go", "Suite", "Test_Missing__CamelCase", 0},
 		"Missing",
 		"CamelCase",
 		&testee{}})
 	s.CheckErrors(
 		"Suite.Test_Missing__CamelCase: Test description \"CamelCase\" " +
 			"must not use CamelCase in the first word.")
+}
 func (s *Suite) Test_TestNameChecker_checkTestees(c *check.C) {
 	ck := s.Init(c)
 	ck.testees = []*testee{s.newTestee("s.go", "", "Func", 0)}
 	ck.tests = nil // force an error
 	ck.checkTestees()
 	s.CheckErrors(
 		"Missing unit test \"Test_Func\" for \"Func\".")
+}
 func (s *Suite) Test_TestNameChecker_checkTesteeTest(c *check.C) {
 	ck := s.Init(c)
 	ck.checkTesteeTest(
 		&testee{code{"demo.go", "Type", "", 0}},
 		nil)
 	ck.checkTesteeTest(
 		&testee{code{"demo.go", "", "Func", 0}},
 		nil)
 	ck.checkTesteeTest(
 		&testee{code{"demo.go", "Type", "Method", 0}},
 		nil)
 	s.CheckErrors(
 		"Missing unit test \"Test_Func\" for \"Func\".",
 		"Missing unit test \"Test_Type_Method\" for \"Type.Method\".")
+}
 func (s *Suite) Test_TestNameChecker_errorsMask(c *check.C) {
 	ck := s.Init(c)
 	c.Check(ck.errorsMask(0, EAll), check.Equals, ^uint64(0))
 	c.Check(ck.errorsMask(12345, ENone), check.Equals, uint64(0))
 	c.Check(ck.errorsMask(12345, ENone, EMissingTest), check.Equals, uint64(8))
 	c.Check(ck.errorsMask(2, EMissingTest), check.Equals, uint64(10))
+}
 func (s *Suite) Test_TestNameChecker_checkOrder(c *check.C) {
 	ck := s.Init(c)
 	ck.addTestee(code{"f.go", "T", "", 10})
 	ck.addTestee(code{"f.go", "T", "M1", 11})
 	ck.addTestee(code{"f.go", "T", "M2", 12})
 	ck.addTestee(code{"f.go", "T", "M3", 13})
 	ck.addTest(code{"a_test.go", "S", "Test_A", 98})        // different file, is skipped
 	ck.addTest(code{"f_test.go", "S", "Test_Missing", 99})  // missing testee, is skipped
 	ck.addTest(code{"f_test.go", "S", "Test_T_M1", 100})    // maxTestee = 11
 	ck.addTest(code{"f_test.go", "S", "Test_T_M2", 101})    // maxTestee = 12
 	ck.addTest(code{"f_test.go", "S", "Test_T", 102})       // testee 10 < maxTestee 12: insert before first [.testee > testee 10] == T_M1
 	ck.addTest(code{"f_test.go", "S", "Test_T_M3", 103})    // maxTestee = 13
 	ck.addTest(code{"f_test.go", "S", "Test_T__1", 104})    // testee < maxTestee: insert before first [testee > 10]
 	ck.addTest(code{"f_test.go", "S", "Test_T__2", 105})    // testee < maxTestee: insert before first [testee > 10]
 	ck.addTest(code{"f_test.go", "S", "Test_T_M2__1", 106}) // testee < maxTestee: insert before first [testee > 12] == T_M3
 	ck.relate()
 	ck.checkOrder()
 	s.CheckErrors(
-		"Test \"S.Test_T\" should be ordered before \"S.Test_T_M1\".",
+		"Test \"S.Test_T\" must be ordered before \"S.Test_T_M1\".",
-		"Test \"S.Test_T__1\" should be ordered before \"S.Test_T_M1\".",
+		"Test \"S.Test_T__1\" must be ordered before \"S.Test_T_M1\".",
-		"Test \"S.Test_T__2\" should be ordered before \"S.Test_T_M1\".",
+		"Test \"S.Test_T__2\" must be ordered before \"S.Test_T_M1\".",
-		"Test \"S.Test_T_M2__1\" should be ordered before \"S.Test_T_M3\".")
+		"Test \"S.Test_T_M2__1\" must be ordered before \"S.Test_T_M3\".")
+}
 func (s *Suite) Test_TestNameChecker_addError(c *check.C) {
 	ck := s.Init(c)
 	ck.Configure("ignored*", "*", "*", -EName)
 	ok1 := ck.addError(EName, code{"ignored.go", "", "Func", 0}, "E1")
 	ok2 := ck.addError(EName, code{"reported.go", "", "Func", 0}, "E2")
 	c.Check(ok1, check.Equals, false)
 	c.Check(ok2, check.Equals, true)
 	s.CheckErrors(
 		"E2")
+}
 func (s *Suite) Test_TestNameChecker_print__empty(c *check.C) {
 	var out bytes.Buffer
 	ck := s.Init(c)
 	ck.out = &out
 	ck.print()
 	c.Check(out.String(), check.Equals, "")
+}
-func (s *Suite) Test_TestNameChecker_print__errors(c *check.C) {
+func (s *Suite) Test_TestNameChecker_print__1_error(c *check.C) {
 	var out bytes.Buffer
 	ck := s.Init(c)
 	ck.out = &out
 	ck.addError(EName, code{}, "1")
 	ck.addError(EName, "1")
 	ck.print()
 	c.Check(out.String(), check.Equals, "1\n")
 	s.CheckErrors("1")
 	s.CheckSummary("1 error.")
+}
 func (s *Suite) Test_TestNameChecker_print__2_errors(c *check.C) {
 	var out bytes.Buffer
 	ck := s.Init(c)
 	ck.out = &out
 	ck.addError(EName, code{}, "1")
 	ck.addError(EName, code{}, "2")
 	ck.print()
 	c.Check(out.String(), check.Equals, "1\n2\n")
 	s.CheckErrors("1", "2")
 	s.CheckSummary("2 errors.")
+}
 func (s *Suite) Test_code_fullName(c *check.C) {
 	_ = s.Init(c)
 	test := func(typeName, funcName, fullName string) {
 		code := code{"filename", typeName, funcName, 0}
 		c.Check(code.fullName(), check.Equals, fullName)
+	}
 	test("Type", "", "Type")
 	test("", "Func", "Func")
 	test("Type", "Method", "Type.Method")
+}
-func (s *Suite) Test_plural(c *check.C) {
+func (s *Suite) Test_code_isFunc(c *check.C) {
 	_ = s.Init(c)
-	c.Check(plural(0, "singular", "plural"), check.Equals, "")
+	test := func(typeName, funcName string, isFunc bool) {
-	c.Check(plural(1, "singular", "plural"), check.Equals, "1 singular")
+		code := code{"filename", typeName, funcName, 0}
-	c.Check(plural(2, "singular", "plural"), check.Equals, "2 plural")
+		c.Check(code.isFunc(), check.Equals, isFunc)
 	c.Check(plural(1000, "singular", "plural"), check.Equals, "1000 plural")
 	test("Type", "", false)
 	test("", "Func", true)
 	test("Type", "Method", false)
+}
 func (s *Suite) Test_code_isType(c *check.C) {
 	_ = s.Init(c)
 	test := func(typeName, funcName string, isType bool) {
 		code := code{"filename", typeName, funcName, 0}
 		c.Check(code.isType(), check.Equals, isType)
+	}
 	test("Type", "", true)
 	test("", "Func", false)
 	test("Type", "Method", false)
+}
 func (s *Suite) Test_code_isMethod(c *check.C) {
 	_ = s.Init(c)
 	test := func(typeName, funcName string, isMethod bool) {
 		code := code{"filename", typeName, funcName, 0}
 		c.Check(code.isMethod(), check.Equals, isMethod)
+	}
 	test("Type", "", false)
 	test("", "Func", false)
 	test("Type", "Method", true)
+}
 func (s *Suite) Test_code_isTest(c *check.C) {
 	_ = s.Init(c)
 	test := func(filename, typeName, funcName string, isTest bool) {
 		code := code{filename, typeName, funcName, 0}
 		c.Check(code.isTest(), check.Equals, isTest)
+	}
 	test("f.go", "Type", "", false)
 	test("f.go", "", "Func", false)
 	test("f.go", "Type", "Method", false)
 	test("f.go", "Type", "Test", false)
 	test("f.go", "Type", "Test_Type_Method", false)
 	test("f.go", "", "Test_Type_Method", false)
 	test("f_test.go", "Type", "Test", true)
 	test("f_test.go", "Type", "Test_Type_Method", true)
 	test("f_test.go", "", "Test_Type_Method", true)
+}
 func (s *Suite) Test_code_isTestScope(c *check.C) {
 	_ = s.Init(c)
 	test := func(filename string, isTestScope bool) {
 		code := code{filename, "", "", 0}
 		c.Check(code.isTestScope(), check.Equals, isTestScope)
+	}
 	test("f.go", false)
 	test("test.go", false)
 	test("_test.go", true)
 	test("file_test.go", true)
 	test("file_linux_test.go", true)
+}
 func (s *Suite) Test_isCamelCase(c *check.C) {
 	_ = s.Init(c)
 	c.Check(isCamelCase(""), check.Equals, false)
 	c.Check(isCamelCase("Word"), check.Equals, false)
 	c.Check(isCamelCase("Ada_Case"), check.Equals, false)
 	c.Check(isCamelCase("snake_case"), check.Equals, false)
 	c.Check(isCamelCase("CamelCase"), check.Equals, true)
 	// After the first underscore of the description, any CamelCase
 	// is ignored because there is no danger of confusing the method
 	// name with the description.
 	c.Check(isCamelCase("Word_CamelCase"), check.Equals, false)
+}
 func (s *Suite) Test_join(c *check.C) {
 	_ = s.Init(c)
 	c.Check(join("", " and ", ""), check.Equals, "")
 	c.Check(join("one", " and ", ""), check.Equals, "one")
 	c.Check(join("", " and ", "two"), check.Equals, "two")
 	c.Check(join("one", " and ", "two"), check.Equals, "one and two")
+}
 func (s *Suite) Test_matches(c *check.C) {
 	_ = s.Init(c)
 	c.Check(matches("*", "*"), check.Equals, true)
 	c.Check(matches("anything", "*"), check.Equals, true)
 	c.Check(matches("*", "anything"), check.Equals, false)
 	c.Check(func() { matches("any", "[") }, check.Panics, path.ErrBadPattern)
+}
 func (s *Suite) Test_sortedKeys(c *check.C) {
 	_ = s.Init(c)
 	m := make(map[string]uint8)
 	m["first"] = 1
 	m["second"] = 2
 	m["third"] = 3
 	m["fourth"] = 4
 	c.Check(
 		sortedKeys(m),
 		check.DeepEquals,
 		[]string{"first", "fourth", "second", "third"})
+}
 func (s *Suite) Test_Value_Method(c *check.C) {
 	_ = s.Init(c)
 	// Just for code coverage of checkTestFile, to have a piece of code
 	// that lives in the same file as its test.
+}
 type Value struct{}
 // Method has no star on the receiver,
 // for code coverage of TestNameChecker.loadDecl.
 func (Value) Method() {}

 @@ -1,16 +1,16 @@
-# $NetBSD: Makefile,v 1.608 2019/11/17 02:06:01 rillig Exp $
+# $NetBSD: Makefile,v 1.609 2019/11/19 06:51:38 rillig Exp $
-PKGNAME=	pkglint-19.3.8
+PKGNAME=	pkglint-19.3.9
 CATEGORIES=	pkgtools
 DISTNAME=	tools
 MASTER_SITES=	${MASTER_SITE_GITHUB:=golang/}
 GITHUB_PROJECT=	tools
 GITHUB_TAG=	92d8274bd7b8a4c65f24bafe401a029e58392704
 MAINTAINER=	rillig@NetBSD.org
 HOMEPAGE=	https://github.com/rillig/pkglint
 COMMENT=	Verifier for NetBSD packages
 LICENSE=	2-clause-bsd
 CONFLICTS+=	pkglint4-[0-9]*
 USE_TOOLS+=		pax

 @@ -18,26 +18,29 @@ func CheckFileAlternatives(filename stri
 	checkPlistWrapper := func(line *Line, wrapper string) {
 		if plist.Files[wrapper] != nil {
 			line.Errorf("Alternative wrapper %q must not appear in the PLIST.", wrapper)
+		}
+	}
 	checkPlistAlternative := func(line *Line, alternative string) {
 		relImplementation := strings.Replace(alternative, "@PREFIX@/", "", 1)
 		plistName := replaceAll(relImplementation, `@(\w+)@`, "${$1}")
 		if plist.Files[plistName] != nil || G.Pkg.vars.IsDefined("ALTERNATIVES_SRC") {
 			return
+		}
 		if plist.Files[strings.Replace(plistName, "${PKGMANDIR}", "man", 1)] != nil {
 			return
+		}
 		switch {
 		case hasPrefix(alternative, "/"):
 			// It's possible but unusual to refer to a fixed absolute path.
 			// These cannot be mentioned in the PLIST since they are not part of the package.
 			break
 		case plistName == alternative:
 			line.Errorf("Alternative implementation %q must appear in the PLIST.", alternative)
 		default:
 			line.Errorf("Alternative implementation %q must appear in the PLIST as %q.", alternative, plistName)

 @@ -96,13 +96,35 @@ func (s *Suite) Test_CheckFileAlternativ
 	// really had this case in mind when I initially wrote the code in
 	// CheckFileAlternatives.
 	t.SetUpPackage("category/package",
 		"ALTERNATIVES_SRC=\talts")
 	t.CreateFileLines("category/package/ALTERNATIVES",
 		"bin/pgm @PREFIX@/bin/gnu-program",
 		"bin/pgm @PREFIX@/bin/nb-program")
 	t.FinishSetUp()
 	G.Check(t.File("category/package"))
 	t.CheckOutputEmpty()
+}
 // When a man page is mentioned in the ALTERNATIVES file, it must use the
 // PKGMANDIR variable. In the PLIST files though, there is some magic
 // in the pkgsrc infrastructure that maps man/ to ${PKGMANDIR}, which
 // leads to a bit less typing.
 //
 // Seen in graphics/py-blockdiag.
 func (s *Suite) Test_CheckFileAlternatives__PLIST_man(c *check.C) {
 	t := s.Init(c)
 	t.SetUpPackage("category/package")
 	t.CreateFileLines("category/package/ALTERNATIVES",
 		"@PKGMANDIR@/man1/blockdiag @PREFIX@/@PKGMANDIR@/man1/blockdiag-@PYVERSSUFFIX@.1")
 	t.CreateFileLines("category/package/PLIST",
 		PlistCvsID,
 		"man/man1/blockdiag-${PYVERSSUFFIX}.1")
 	t.FinishSetUp()
 	G.Check(t.File("category/package"))
 	t.CheckOutputEmpty()
+}

 @@ -100,27 +100,27 @@ func (m MkVarUseModifier) MatchMatch() (
 		exact := !strings.ContainsAny(m.Text[1:], "*?[\\$")
 		return true, m.Text[0] == 'M', m.Text[1:], exact
+	}
 	return false, false, "", false
+}
 func (m MkVarUseModifier) IsToLower() bool { return m.Text == "tl" }
 // ChangesWords returns true if applying this modifier to a list variable
 // may change the number of words in the list, or their boundaries.
 func (m MkVarUseModifier) ChangesWords() bool {
 	text := m.Text
-	// See MkParser.VarUseModifiers for the meaning of these modifiers.
+	// See MkParser.varUseModifier for the meaning of these modifiers.
 	switch text[0] {
 	case 'E', 'H', 'M', 'N', 'O', 'R', 'T':
 		return false
 	case 'C', 'Q', 'S':
 		// For the :C and :S modifiers, a more detailed analysis could reveal
 		// cases that don't change the structure, such as :S,a,b,g or
 		// :C,[0-9A-Za-z_],.,g, but not :C,x,,g.
 		return true
+	}
 	switch text {

 @@ -209,27 +209,27 @@ func (src *Pkgsrc) loadDocChangesFromFil
+		}
 		change := src.parseDocChange(line, warn)
 		if change == nil {
 			continue
+		}
 		changes = append(changes, change)
 		if !warn {
 			continue
+		}
-		if year != "" && len(change.Date) >= 4 && change.Date[0:4] != year {
+		if year != "" && change.Date[0:4] != year {
 			line.Warnf("Year %q for %s does not match the filename %s.",
 				change.Date[0:4], change.Pkgpath, filename)
+		}
 		if len(changes) >= 2 && year != "" {
 			if prev := changes[len(changes)-2]; change.Date < prev.Date {
 				line.Warnf("Date %q for %s is earlier than %q in %s.",
 					change.Date, change.Pkgpath, prev.Date, line.RefToLocation(prev.Location))
 				line.Explain(
 					"The entries in doc/CHANGES should be in chronological order, and",
 					"all dates are assumed to be in the UTC timezone, to prevent time",
 					"warps.",
 					"",

 @@ -1,16 +1,16 @@
 package pkglint
 import (
 	"gopkg.in/check.v1"
 	"netbsd.org/pkglint/intqa"
+)
 // Ensures that all test names follow a common naming scheme:
 //
 //  Test_${Type}_${Method}__${description_using_underscores}
 func (s *Suite) Test__test_names(c *check.C) {
 	ck := intqa.NewTestNameChecker(c.Errorf)
-	ck.IgnoreFiles("*yacc.go")
+	ck.Configure("*", "*", "*", -intqa.EMissingTest)
-	ck.Enable(intqa.EAll, -intqa.EMissingTest)
+	ck.Configure("*yacc.go", "*", "*", intqa.ENone)
 	ck.Check()
+}

 @@ -401,16 +401,16 @@ func (s *Suite) Test_Options_Help__with_
 		"  -W, --warnings=warning,...   Print selected warnings\n"+
 		"\n"+
 		"  Flags for -W, --warnings:\n"+
 		"    all     all of the following\n"+
 		"    none    none of the following\n"+
 		"    basic   Print basic warnings (enabled)\n"+
 		"    extra   Print extra warnings (disabled)\n"+
 		"\n"+
 		"  (Prefix a flag with \"no-\" to disable it.)\n")
+}
 func (s *Suite) Test__test_names(c *check.C) {
 	ck := intqa.NewTestNameChecker(c.Errorf)
-	ck.Enable(intqa.EAll, -intqa.EMissingTest)
+	ck.Configure("*", "*", "*", -intqa.EMissingTest)
 	ck.Check()
+}

 @@ -20,16 +20,16 @@ func (s *Suite) Test_Histogram(c *check.
 	hgr.Add("two", 2)
 	hgr.Add("three", 3)
 	var out strings.Builder
 	hgr.PrintStats(&out, "caption", 2)
 	c.Check(out.String(), check.Equals, ""+
 		"caption      3 three\n"+
 		"caption      2 two\n")
+}
 func (s *Suite) Test__test_names(c *check.C) {
 	ck := intqa.NewTestNameChecker(c.Errorf)
-	ck.Enable(intqa.EAll, -intqa.EMissingTest)
+	ck.Configure("*", "*", "*", -intqa.EMissingTest)
 	ck.Check()
+}

	@@ -123,16 +123,16 @@ func NewOr(parts ...Condition) Conditi		@@ -123,16 +123,16 @@ func NewOr(parts ...Condition) Conditi
123		123
124	func toJSON(cond *Condition) string {	124	func toJSON(cond *Condition) string {
125	jsonStr, _ := json.Marshal(cond)	125	jsonStr, _ := json.Marshal(cond)
126	return strings.Replace(string(jsonStr), "\"", "", -1)	126	return strings.Replace(string(jsonStr), "\"", "", -1)
127	}	127	}
128		128
129	func Test(t *testing.T) {	129	func Test(t *testing.T) {
130	check.Suite(new(Suite))	130	check.Suite(new(Suite))
131	check.TestingT(t)	131	check.TestingT(t)
132	}	132	}
133		133
134	func (s Suite) Test__test_names(c check.C) {	134	func (s Suite) Test__test_names(c check.C) {
135	ck := intqa.NewTestNameChecker(c.Errorf)	135	ck := intqa.NewTestNameChecker(c.Errorf)
136	ck.Enable(intqa.EAll, -intqa.EMissingTest)	136	ck.Configure("", "", "*", -intqa.EMissingTest)
137	ck.Check()	137	ck.Check()
138	}	138	}

 @@ -85,16 +85,16 @@ func (s *Suite) Test_newVersion(c *check
 		&version{nil, 1})
 	c.Check(newVersion("1.0.1a"), check.DeepEquals,
 		&version{[]int{1, 0, 0, 0, 1, 1}, 0})
 	c.Check(newVersion("1.0.1z"), check.DeepEquals,
 		&version{[]int{1, 0, 0, 0, 1, 26}, 0})
 	c.Check(newVersion("0pre20160620"), check.DeepEquals,
 		&version{[]int{0, -1, 20160620}, 0})
 	c.Check(newVersion("3.5.DEV1710"), check.DeepEquals,
 		&version{[]int{3, 0, 5, 0, 4, 5, 22, 1710}, 0})
+}
 func (s *Suite) Test__test_names(c *check.C) {
 	ck := intqa.NewTestNameChecker(c.Errorf)
-	ck.Enable(intqa.EAll, -intqa.EMissingTest)
+	ck.Configure("*", "*", "*", -intqa.EMissingTest)
 	ck.Check()
+}

 @@ -405,16 +405,16 @@ func (s *Suite) Test__Alpha(c *check.C)
 	set := Alpha
 	c.Check(set.Contains(0x00), equals, false)
 	c.Check(set.Contains('@'), equals, false)
 	c.Check(set.Contains('A'), equals, true)
 	c.Check(set.Contains('Z'), equals, true)
 	c.Check(set.Contains('`'), equals, false)
 	c.Check(set.Contains('a'), equals, true)
 	c.Check(set.Contains('z'), equals, true)
+}
 func (s *Suite) Test__test_names(c *check.C) {
 	ck := intqa.NewTestNameChecker(c.Errorf)
-	ck.Enable(intqa.EAll, -intqa.EMissingTest)
+	ck.Configure("*", "*", "*", -intqa.EMissingTest)
 	ck.Check()
+}

	@@ -135,16 +135,16 @@ func (s *Suite) captureTracingOutput(act		@@ -135,16 +135,16 @@ func (s *Suite) captureTracingOutput(act
135	tracer.Tracing = false	135	tracer.Tracing = false
136	tracer.Out = nil	136	tracer.Out = nil
137	return out.String()	137	return out.String()
138	}	138	}
139		139
140	type str struct{}	140	type str struct{}
141		141
142	func (str) String() string {	142	func (str) String() string {
143	return "It's a string"	143	return "It's a string"
144	}	144	}
145		145
146	func (s Suite) Test__test_names(c check.C) {	146	func (s Suite) Test__test_names(c check.C) {
147	ck := intqa.NewTestNameChecker(c.Errorf)	147	ck := intqa.NewTestNameChecker(c.Errorf)
148	ck.Enable(intqa.EAll, -intqa.EMissingTest)	148	ck.Configure("", "", "*", -intqa.EMissingTest)
149	ck.Check()	149	ck.Check()
150	}	150	}