pkgtools/pkglint: update to 19.3.9

Changes since 19.3.8:

Match man pages in ALTERNATIVES with their counterparts in PLIST. In
PLIST files, ${PKGMANDIR} may be abbreviated as a simple "man", but not
in ALTERNATIVES.

15 files changed, 614 insertions, 176 deletions

diff --git a/pkgtools/pkglint/Makefile b/pkgtools/pkglint/Makefile
index 2af5934e322..b459c2f70bf 100644
--- a/pkgtools/pkglint/Makefile
+++ b/pkgtools/pkglint/Makefile
@@ -1,6 +1,6 @@
-# $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/}
diff --git a/pkgtools/pkglint/files/alternatives.go b/pkgtools/pkglint/files/alternatives.go
index 2a39394c5cc..13e01958d1b 100644
--- a/pkgtools/pkglint/files/alternatives.go
+++ b/pkgtools/pkglint/files/alternatives.go
@@ -28,6 +28,9 @@ func CheckFileAlternatives(filename string) {
 		if plist.Files[plistName] != nil || G.Pkg.vars.IsDefined("ALTERNATIVES_SRC") {
 			return
 		}
+		if plist.Files[strings.Replace(plistName, "${PKGMANDIR}", "man", 1)] != nil {
+			return
+		}
 
 		switch {
 
diff --git a/pkgtools/pkglint/files/alternatives_test.go b/pkgtools/pkglint/files/alternatives_test.go
index 16df64ac89e..5c1eda9c0c9 100644
--- a/pkgtools/pkglint/files/alternatives_test.go
+++ b/pkgtools/pkglint/files/alternatives_test.go
@@ -106,3 +106,25 @@ func (s *Suite) Test_CheckFileAlternatives__ALTERNATIVES_SRC(c *check.C) {
 
 	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()
+}
diff --git a/pkgtools/pkglint/files/getopt/getopt_test.go b/pkgtools/pkglint/files/getopt/getopt_test.go
index b8d0550e5d6..acae20fb367 100644
--- a/pkgtools/pkglint/files/getopt/getopt_test.go
+++ b/pkgtools/pkglint/files/getopt/getopt_test.go
@@ -411,6 +411,6 @@ func (s *Suite) Test_Options_Help__with_flag_group(c *check.C) {
 
 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()
 }
diff --git a/pkgtools/pkglint/files/histogram/histogram_test.go b/pkgtools/pkglint/files/histogram/histogram_test.go
index 31bdacac473..da1d7fa934e 100644
--- a/pkgtools/pkglint/files/histogram/histogram_test.go
+++ b/pkgtools/pkglint/files/histogram/histogram_test.go
@@ -30,6 +30,6 @@ func (s *Suite) Test_Histogram(c *check.C) {
 
 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()
 }
diff --git a/pkgtools/pkglint/files/intqa/testnames.go b/pkgtools/pkglint/files/intqa/testnames.go
index 3e3a71b40b6..3c35c228935 100644
--- a/pkgtools/pkglint/files/intqa/testnames.go
+++ b/pkgtools/pkglint/files/intqa/testnames.go
@@ -8,7 +8,8 @@ import (
 	"go/token"
 	"io"
 	"os"
-	"path/filepath"
+	"path"
+	"reflect"
 	"sort"
 	"strings"
 	"unicode"
@@ -17,7 +18,7 @@ import (
 type Error int
 
 const (
-	ENone Error = iota
+	ENone Error = iota + 1
 	EAll
 
 	// A function or method does not have a corresponding test.
@@ -45,43 +46,47 @@ const (
 type TestNameChecker struct {
 	errorf func(format string, args ...interface{})
 
-	ignoredFiles []string
-	order        int
+	filters []filter
+	order   int
 
 	testees []*testee
 	tests   []*test
 
-	errorsMask uint64
-	errors     []string
-	out        io.Writer
+	errors []string
+	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}
+
+	// For test fixtures from https://gopkg.in/check/v1.
+	ck.Configure("*_test.go", "*", "SetUpTest", -EMissingTest)
+	ck.Configure("*_test.go", "*", "TearDownTest", -EMissingTest)
+
+	// See https://github.com/rillig/gobco.
+	ck.Configure("gobco_*.go", "gobco*", "*", -EMissingTest)
+	ck.Configure("gobco_*.go", "", "gobco*", -EMissingTest)
 
-func (ck *TestNameChecker) IgnoreFiles(fileGlob string) {
-	ck.ignoredFiles = append(ck.ignoredFiles, fileGlob)
+	return &ck
 }
 
-func (ck *TestNameChecker) Enable(errors ...Error) {
-	for _, err := range errors {
-		if err == ENone {
-			ck.errorsMask = 0
-		} else if err == EAll {
-			ck.errorsMask = ^uint64(0)
-		} else if err < 0 {
-			ck.errorsMask &= ^(uint64(1) << -uint(err))
-		} else {
-			ck.errorsMask |= uint64(1) << uint(err)
-		}
-	}
+// Configure sets the errors that are activated for the given code,
+// specified by shell patterns like in path.Match.
+//
+// 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()
@@ -89,29 +94,18 @@ func (ck *TestNameChecker) Check() {
 }
 
 // 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 pkgs {
-		pkgnames = append(pkgnames, pkgname)
-	}
-	sort.Strings(pkgnames)
-
-	for _, pkgname := range pkgnames {
+	for _, pkgname := range sortedKeys(pkgs) {
 		files := pkgs[pkgname].Files
 
-		var filenames []string
-		for filename := range files {
-			filenames = append(filenames, filename)
-		}
-		sort.Strings(filenames)
-
-		for _, filename := range filenames {
+		for _, filename := range sortedKeys(files) {
 			file := files[filename]
 			for _, decl := range file.Decls {
 				ck.loadDecl(decl, filename)
@@ -131,7 +125,7 @@ func (ck *TestNameChecker) loadDecl(decl ast.Decl, filename string) {
 			switch spec := spec.(type) {
 			case *ast.TypeSpec:
 				typeName := spec.Name.Name
-				ck.addCode(code{filename, typeName, "", ck.nextOrder()})
+				ck.addCode(code{filename, typeName, "", 0})
 			}
 		}
 
@@ -145,16 +139,28 @@ func (ck *TestNameChecker) loadDecl(decl ast.Decl, filename string) {
 				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") &&
-		code.Type != "" &&
-		strings.HasPrefix(code.Func, "Test")
+	if code.isTestScope() && code.isFunc() && code.Func == "TestMain" {
+		// This is not a test for Main, but a wrapper function of the 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)
@@ -162,15 +168,19 @@ func (ck *TestNameChecker) addCode(code 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
 	}
 
@@ -178,16 +188,18 @@ func (ck *TestNameChecker) addTest(code code) {
 	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.fullName())
+				code,
+				"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})
 }
 
@@ -213,8 +225,8 @@ func (ck *TestNameChecker) relate() {
 func (ck *TestNameChecker) checkTests() {
 	for _, test := range ck.tests {
 		ck.checkTestFile(test)
-		ck.checkTestName(test)
 		ck.checkTestTestee(test)
+		ck.checkTestDescr(test)
 	}
 }
 
@@ -225,12 +237,15 @@ func (ck *TestNameChecker) checkTestFile(test *test) {
 	}
 
 	correctTestFile := strings.TrimSuffix(testee.file, ".go") + "_test.go"
-	if correctTestFile != test.file {
-		ck.addError(
-			EFile,
-			"Test %q for %q must be in %s instead of %s.",
-			test.fullName(), testee.fullName(), correctTestFile, test.file)
+	if correctTestFile == test.file {
+		return
 	}
+
+	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) {
@@ -242,27 +257,23 @@ func (ck *TestNameChecker) checkTestTestee(test *test) {
 	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
-// end up in the description of the test. This could happen if there is a
-// double underscore instead of a single underscore.
-func (ck *TestNameChecker) checkTestName(test *test) {
+// checkTestDescr ensures that the type or function name of the testee
+// does not accidentally end up in the description of the test. This could
+// happen if there is a double underscore instead of a single underscore.
+func (ck *TestNameChecker) checkTestDescr(test *test) {
 	testee := test.testee
-	if testee == nil {
-		return
-	}
-	if testee.Type != "" && testee.Func != "" {
-		return
-	}
-	if !isCamelCase(test.descr) {
+	if testee == nil || testee.isMethod() || !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)
 }
@@ -274,29 +285,49 @@ func (ck *TestNameChecker) checkTestees() {
 	}
 
 	for _, testee := range ck.testees {
-		if tested[testee] || testee.Func == "" {
-			continue
-		}
+		ck.checkTesteeTest(testee, tested)
+	}
+}
 
-		testName := "Test_" + join(testee.Type, "_", testee.Func)
-		ck.addError(
-			EMissingTest,
-			"Missing unit test %q for %q.",
-			testName, testee.fullName())
+func (ck *TestNameChecker) checkTesteeTest(testee *testee, tested map[*testee]bool) {
+	if tested[testee] || testee.isType() {
+		return
 	}
+
+	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 {
-	for _, mask := range ck.ignoredFiles {
-		ok, err := filepath.Match(mask, filename)
-		if err != nil {
-			panic(err)
+// isRelevant checks whether the given error is enabled.
+func (ck *TestNameChecker) isRelevant(filename, typeName, funcName string, e Error) bool {
+	mask := ^uint64(0)
+	for _, filter := range ck.filters {
+		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
@@ -323,18 +354,22 @@ func (ck *TestNameChecker) checkOrder() {
 					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{}) {
-	if ck.errorsMask&(uint64(1)<<uint(e)) != 0 {
+func (ck *TestNameChecker) addError(e Error, c code, format string, args ...interface{}) bool {
+	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() {
@@ -342,23 +377,22 @@ func (ck *TestNameChecker) print() {
 		_, _ = fmt.Fprintln(ck.out, msg)
 	}
 
-	errors := plural(len(ck.errors), "error", "errors")
-	if len(ck.errors) > 0 {
-		ck.errorf("%s.", errors)
+	n := len(ck.errors)
+	if n > 1 {
+		ck.errorf("%d errors.", n)
+	} else if n == 1 {
+		ck.errorf("%d error.", n)
 	}
 }
 
-type code struct {
-	file  string // The file containing the code
-	Type  string // The type, e.g. MkLine
-	Func  string // The function or method name, e.g. Warnf
-	order int    // The relative order in the file
+type filter struct {
+	filenames string
+	typeNames string
+	funcNames string
+	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
 }
@@ -371,15 +405,24 @@ type test struct {
 	testee     *testee
 }
 
-func plural(n int, sg, pl string) string {
-	if n == 0 {
-		return ""
-	}
-	form := pl
-	if n == 1 {
-		form = sg
-	}
-	return fmt.Sprintf("%d %s", n, form)
+// code is either a type, a function or a method.
+type code struct {
+	file  string // the file containing the code
+	Type  string // the type, e.g. MkLine
+	Func  string // the function or method name, e.g. Warnf
+	order int    // the relative order in the file
+}
+
+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 {
@@ -400,3 +443,21 @@ func join(a, sep, b string) string {
 	}
 	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
+}
diff --git a/pkgtools/pkglint/files/intqa/testnames_test.go b/pkgtools/pkglint/files/intqa/testnames_test.go
index cb9a353e443..0a53fae70fc 100644
--- a/pkgtools/pkglint/files/intqa/testnames_test.go
+++ b/pkgtools/pkglint/files/intqa/testnames_test.go
@@ -3,8 +3,10 @@ package intqa
 import (
 	"bytes"
 	"fmt"
+	"go/ast"
 	"gopkg.in/check.v1"
 	"io/ioutil"
+	"path"
 	"testing"
 )
 
@@ -26,7 +28,6 @@ func (s *Suite) Init(c *check.C) *TestNameChecker {
 
 	s.c = c
 	s.ck = NewTestNameChecker(errorf)
-	s.ck.Enable(EAll)
 	s.ck.out = ioutil.Discard
 	return s.ck
 }
@@ -37,6 +38,25 @@ func (s *Suite) TearDownTest(c *check.C) {
 	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
@@ -47,51 +67,169 @@ func (s *Suite) CheckSummary(summary string) {
 	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_checkTestees\" for \"TestNameChecker.checkTestees\".",
-		"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\".",
-		"Missing unit test \"Test_Suite_Init\" for \"Suite.Init\".",
-		"Missing unit test \"Test_Suite_TearDownTest\" for \"Suite.TearDownTest\".",
-		"Missing unit test \"Test_Suite_CheckErrors\" for \"Suite.CheckErrors\".",
-		"Missing unit test \"Test_Suite_CheckSummary\" for \"Suite.CheckSummary\".",
-		"Missing unit test \"Test_Value_Method\" for \"Value.Method\".")
-	s.CheckSummary("18 errors.")
+		"Missing unit test \"Test_TestNameChecker_isRelevant\" for \"TestNameChecker.isRelevant\".")
+	s.CheckSummary("3 errors.")
+}
+
+func (s *Suite) Test_TestNameChecker_load__filtered_nothing(c *check.C) {
+	ck := s.Init(c)
+
+	ck.Configure("*", "*", "*", ENone)
+
+	ck.load(".")
+
+	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) {
@@ -99,6 +237,7 @@ func (s *Suite) Test_TestNameChecker_addTest(c *check.C) {
 
 	ck.addTest(code{"filename.go", "Type", "Method", 0})
 
+	c.Check(ck.tests, check.IsNil)
 	s.CheckErrors(
 		"Test \"Type.Method\" must start with \"Test_\".")
 }
@@ -106,10 +245,56 @@ func (s *Suite) Test_TestNameChecker_addTest(c *check.C) {
 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(
-		"Test \"Suite.Test_Method__\" must not have a nonempty description.")
+		"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 \"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) {
@@ -165,10 +350,10 @@ func (s *Suite) Test_TestNameChecker_checkTestTestee__testee_exists(c *check.C)
 		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",
@@ -179,6 +364,45 @@ func (s *Suite) Test_TestNameChecker_checkTestName__camel_case(c *check.C) {
 			"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)
 
@@ -186,6 +410,8 @@ func (s *Suite) Test_TestNameChecker_checkOrder(c *check.C) {
 	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
@@ -198,10 +424,23 @@ func (s *Suite) Test_TestNameChecker_checkOrder(c *check.C) {
 	ck.checkOrder()
 
 	s.CheckErrors(
-		"Test \"S.Test_T\" should be ordered before \"S.Test_T_M1\".",
-		"Test \"S.Test_T__1\" should be ordered before \"S.Test_T_M1\".",
-		"Test \"S.Test_T__2\" should 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\" must 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\" must be ordered before \"S.Test_T_M1\".",
+		"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) {
@@ -214,12 +453,12 @@ func (s *Suite) Test_TestNameChecker_print__empty(c *check.C) {
 	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")
@@ -227,6 +466,20 @@ func (s *Suite) Test_TestNameChecker_print__errors(c *check.C) {
 	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)
 
@@ -240,13 +493,77 @@ func (s *Suite) Test_code_fullName(c *check.C) {
 	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, "")
-	c.Check(plural(1, "singular", "plural"), check.Equals, "1 singular")
-	c.Check(plural(2, "singular", "plural"), check.Equals, "2 plural")
-	c.Check(plural(1000, "singular", "plural"), check.Equals, "1000 plural")
+	test := func(typeName, funcName string, isFunc bool) {
+		code := code{"filename", typeName, funcName, 0}
+		c.Check(code.isFunc(), check.Equals, isFunc)
+	}
+
+	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) {
@@ -273,6 +590,37 @@ func (s *Suite) Test_join(c *check.C) {
 	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,
diff --git a/pkgtools/pkglint/files/licenses/licenses_test.go b/pkgtools/pkglint/files/licenses/licenses_test.go
index 9d23592b368..469e44cf1d0 100644
--- a/pkgtools/pkglint/files/licenses/licenses_test.go
+++ b/pkgtools/pkglint/files/licenses/licenses_test.go
@@ -133,6 +133,6 @@ func Test(t *testing.T) {
 
 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()
 }
diff --git a/pkgtools/pkglint/files/mktypes.go b/pkgtools/pkglint/files/mktypes.go
index e1bb9d30b8a..db6c452d1df 100644
--- a/pkgtools/pkglint/files/mktypes.go
+++ b/pkgtools/pkglint/files/mktypes.go
@@ -110,7 +110,7 @@ func (m MkVarUseModifier) IsToLower() bool { return m.Text == "tl" }
 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':
diff --git a/pkgtools/pkglint/files/pkgsrc.go b/pkgtools/pkglint/files/pkgsrc.go
index a15e08c2259..750ca1d917e 100644
--- a/pkgtools/pkglint/files/pkgsrc.go
+++ b/pkgtools/pkglint/files/pkgsrc.go
@@ -219,7 +219,7 @@ func (src *Pkgsrc) loadDocChangesFromFile(filename string) []*Change {
 			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)
 		}
diff --git a/pkgtools/pkglint/files/pkgsrc_test.go b/pkgtools/pkglint/files/pkgsrc_test.go
index 01c27b20e84..7487cdbebee 100644
--- a/pkgtools/pkglint/files/pkgsrc_test.go
+++ b/pkgtools/pkglint/files/pkgsrc_test.go
@@ -368,6 +368,10 @@ func (s *Suite) Test_Pkgsrc_parseDocChange(c *check.C) {
 	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",
@@ -387,25 +391,25 @@ func (s *Suite) Test_Pkgsrc_parseDocChange(c *check.C) {
 		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...)
@@ -414,30 +418,30 @@ func (s *Suite) Test_Pkgsrc_parseDocChange(c *check.C) {
 		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]",
diff --git a/pkgtools/pkglint/files/pkgver/vercmp_test.go b/pkgtools/pkglint/files/pkgver/vercmp_test.go
index e69eb546871..2717d69a22b 100644
--- a/pkgtools/pkglint/files/pkgver/vercmp_test.go
+++ b/pkgtools/pkglint/files/pkgver/vercmp_test.go
@@ -95,6 +95,6 @@ func (s *Suite) Test_newVersion(c *check.C) {
 
 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()
 }
diff --git a/pkgtools/pkglint/files/testnames_test.go b/pkgtools/pkglint/files/testnames_test.go
index 3a49e1661cd..aafc0a6154f 100644
--- a/pkgtools/pkglint/files/testnames_test.go
+++ b/pkgtools/pkglint/files/testnames_test.go
@@ -10,7 +10,7 @@ import (
 //  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.Enable(intqa.EAll, -intqa.EMissingTest)
+	ck.Configure("*", "*", "*", -intqa.EMissingTest)
+	ck.Configure("*yacc.go", "*", "*", intqa.ENone)
 	ck.Check()
 }
diff --git a/pkgtools/pkglint/files/textproc/lexer_test.go b/pkgtools/pkglint/files/textproc/lexer_test.go
index f37e6f514b0..039225b0da2 100644
--- a/pkgtools/pkglint/files/textproc/lexer_test.go
+++ b/pkgtools/pkglint/files/textproc/lexer_test.go
@@ -415,6 +415,6 @@ func (s *Suite) Test__Alpha(c *check.C) {
 
 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()
 }
diff --git a/pkgtools/pkglint/files/trace/tracing_test.go b/pkgtools/pkglint/files/trace/tracing_test.go
index e21b332ed84..2a122f39867 100755
--- a/pkgtools/pkglint/files/trace/tracing_test.go
+++ b/pkgtools/pkglint/files/trace/tracing_test.go
@@ -145,6 +145,6 @@ func (str) String() string {
 
 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()
 }