dev: follow standard by using 'want' instead of 'ERROR'

Author: ldez

test/analysis.go

@@ -0,0 +1,197 @@
+package test
+
+import (
+	"encoding/json"
+	"fmt"
+	"go/parser"
+	"go/token"
+	"os"
+	"path/filepath"
+	"regexp"
+	"sort"
+	"strconv"
+	"strings"
+	"testing"
+	"text/scanner"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/golangci/golangci-lint/pkg/result"
+)
+
+const keyword = "want"
+
+type jsonResult struct {
+	Issues []*result.Issue
+}
+
+type expectation struct {
+	kind string // either "fact" or "diagnostic"
+	name string // name of object to which fact belongs, or "package" ("fact" only)
+	rx   *regexp.Regexp
+}
+
+type key struct {
+	file string
+	line int
+}
+
+// inspired by https://github.com/golang/tools/blob/b3b5c13b291f9653da6f31b95db100a2e26bd186/go/analysis/analysistest/analysistest.go
+func analyze(t *testing.T, sourcePath string, rawData []byte) {
+	fileData, err := os.ReadFile(sourcePath)
+	require.NoError(t, err)
+
+	want, err := parseComments(sourcePath, fileData)
+	require.NoError(t, err)
+
+	var reportData jsonResult
+	err = json.Unmarshal(rawData, &reportData)
+	require.NoError(t, err)
+
+	for _, issue := range reportData.Issues {
+		if !strings.HasPrefix(issue.Pos.Filename, testdataDir) {
+			issue.Pos.Filename = filepath.Join(testdataDir, issue.Pos.Filename)
+		}
+		checkMessage(t, want, issue.Pos, "diagnostic", issue.FromLinter, issue.Text)
+	}
+
+	var surplus []string
+	for key, expects := range want {
+		for _, exp := range expects {
+			err := fmt.Sprintf("%s:%d: no %s was reported matching %#q", key.file, key.line, exp.kind, exp.rx)
+			surplus = append(surplus, err)
+		}
+	}
+
+	sort.Strings(surplus)
+
+	for _, err := range surplus {
+		t.Errorf("%s", err)
+	}
+}
+
+// inspired by https://github.com/golang/tools/blob/b3b5c13b291f9653da6f31b95db100a2e26bd186/go/analysis/analysistest/analysistest.go
+func parseComments(sourcePath string, fileData []byte) (map[key][]expectation, error) {
+	fset := token.NewFileSet()
+
+	// the error is ignored to let 'typecheck' handle compilation error
+	f, _ := parser.ParseFile(fset, sourcePath, fileData, parser.ParseComments)
+
+	want := make(map[key][]expectation)
+
+	for _, comment := range f.Comments {
+		for _, c := range comment.List {
+			text := strings.TrimPrefix(c.Text, "//")
+			if text == c.Text { // not a //-comment.
+				text = strings.TrimPrefix(text, "/*")
+				text = strings.TrimSuffix(text, "*/")
+			}
+
+			if i := strings.Index(text, "// "+keyword); i >= 0 {
+				text = text[i+len("// "):]
+			}
+
+			posn := fset.Position(c.Pos())
+
+			text = strings.TrimSpace(text)
+
+			if rest := strings.TrimPrefix(text, keyword); rest != text {
+				delta, expects, err := parseExpectations(rest)
+				if err != nil {
+					return nil, err
+				}
+
+				want[key{sourcePath, posn.Line + delta}] = expects
+			}
+		}
+	}
+
+	return want, nil
+}
+
+// inspired by https://github.com/golang/tools/blob/b3b5c13b291f9653da6f31b95db100a2e26bd186/go/analysis/analysistest/analysistest.go
+func parseExpectations(text string) (lineDelta int, expects []expectation, err error) {
+	var scanErr string
+	sc := new(scanner.Scanner).Init(strings.NewReader(text))
+	sc.Error = func(s *scanner.Scanner, msg string) {
+		scanErr = msg // e.g. bad string escape
+	}
+	sc.Mode = scanner.ScanIdents | scanner.ScanStrings | scanner.ScanRawStrings | scanner.ScanInts
+
+	scanRegexp := func(tok rune) (*regexp.Regexp, error) {
+		if tok != scanner.String && tok != scanner.RawString {
+			return nil, fmt.Errorf("got %s, want regular expression",
+				scanner.TokenString(tok))
+		}
+		pattern, _ := strconv.Unquote(sc.TokenText()) // can't fail
+		return regexp.Compile(pattern)
+	}
+
+	for {
+		tok := sc.Scan()
+		switch tok {
+		case '+':
+			tok = sc.Scan()
+			if tok != scanner.Int {
+				return 0, nil, fmt.Errorf("got +%s, want +Int", scanner.TokenString(tok))
+			}
+			lineDelta, _ = strconv.Atoi(sc.TokenText())
+		case scanner.String, scanner.RawString:
+			rx, err := scanRegexp(tok)
+			if err != nil {
+				return 0, nil, err
+			}
+			expects = append(expects, expectation{"diagnostic", "", rx})
+
+		case scanner.Ident:
+			name := sc.TokenText()
+			tok = sc.Scan()
+			if tok != ':' {
+				return 0, nil, fmt.Errorf("got %s after %s, want ':'",
+					scanner.TokenString(tok), name)
+			}
+			tok = sc.Scan()
+			rx, err := scanRegexp(tok)
+			if err != nil {
+				return 0, nil, err
+			}
+			expects = append(expects, expectation{"diagnostic", name, rx})
+
+		case scanner.EOF:
+			if scanErr != "" {
+				return 0, nil, fmt.Errorf("%s", scanErr)
+			}
+			return lineDelta, expects, nil
+
+		default:
+			return 0, nil, fmt.Errorf("unexpected %s", scanner.TokenString(tok))
+		}
+	}
+}
+
+// inspired by https://github.com/golang/tools/blob/b3b5c13b291f9653da6f31b95db100a2e26bd186/go/analysis/analysistest/analysistest.go
+func checkMessage(t *testing.T, want map[key][]expectation, posn token.Position, kind, name, message string) {
+	k := key{posn.Filename, posn.Line}
+	expects := want[k]
+	var unmatched []string
+
+	for i, exp := range expects {
+		if exp.kind == kind && (exp.name == "" || exp.name == name) {
+			if exp.rx.MatchString(message) {
+				// matched: remove the expectation.
+				expects[i] = expects[len(expects)-1]
+				expects = expects[:len(expects)-1]
+				want[k] = expects
+				return
+			}
+			unmatched = append(unmatched, fmt.Sprintf("%#q", exp.rx))
+		}
+	}
+
+	if unmatched == nil {
+		t.Errorf("%v: unexpected %s: %v", posn, kind, message)
+	} else {
+		t.Errorf("%v: %s %q does not match pattern %s",
+			posn, kind, message, strings.Join(unmatched, " or "))
+	}
+}

test/analysis_test.go

@@ -0,0 +1,138 @@
+package test
+
+import (
+	"regexp"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+//nolint:funlen
+func Test_parseComments(t *testing.T) {
+	testCases := []struct {
+		filename string
+		data     string
+		expected map[key][]expectation
+	}{
+		{
+			filename: "a/b.go",
+			data: `package main // want package:"found"
+
+`,
+			expected: map[key][]expectation{
+				{file: "a/b.go", line: 1}: {
+					{kind: "diagnostic", name: "package", rx: regexp.MustCompile(`found`)},
+				},
+			},
+		},
+		{
+			filename: "a/c.go",
+			data: `package main
+
+func main() {
+	println("hello, world") // want "call of println"
+}
+`,
+			expected: map[key][]expectation{
+				{file: "a/c.go", line: 4}: {
+					{kind: "diagnostic", name: "", rx: regexp.MustCompile(`call of println`)},
+				},
+			},
+		},
+		{
+			filename: "a/d.go",
+			data: `package main
+
+func main() {
+	// OK /* */-form.
+	println("hello") /* want "call of println" */
+}
+`,
+			expected: map[key][]expectation{
+				{file: "a/d.go", line: 5}: {
+					{kind: "diagnostic", name: "", rx: regexp.MustCompile(`call of println`)},
+				},
+			},
+		},
+		{
+			filename: "a/e.go",
+			data: `package main
+
+func main() {
+	// OK  (nested comment)
+	println("hello") // some comment // want "call of println"
+}
+`,
+			expected: map[key][]expectation{
+				{file: "a/e.go", line: 5}: {
+					{kind: "diagnostic", name: "", rx: regexp.MustCompile(`call of println`)},
+				},
+			},
+		},
+		{
+			filename: "a/f.go",
+			data: `package main
+
+func main() {
+	// OK (nested comment in /**/)
+	println("hello") /* some comment // want "call of println" */
+}
+`,
+			expected: map[key][]expectation{
+				{file: "a/f.go", line: 5}: {
+					{kind: "diagnostic", name: "", rx: regexp.MustCompile(`call of println`)},
+				},
+			},
+		},
+		{
+			filename: "a/g.go",
+			data: `package main
+
+func main() {
+	// OK (multiple expectations on same line)
+	println(); println() // want "call of println(...)" "call of println(...)"
+}
+`,
+			expected: map[key][]expectation{
+				{file: "a/g.go", line: 5}: {
+					{kind: "diagnostic", name: "", rx: regexp.MustCompile(`call of println(...)`)},
+					{kind: "diagnostic", name: "", rx: regexp.MustCompile(`call of println(...)`)},
+				},
+			},
+		},
+		{
+			filename: "a/h.go",
+			data: `package main
+
+func println(...interface{}) { println() } // want println:"found" "call of println(...)"
+`,
+			expected: map[key][]expectation{
+				{file: "a/h.go", line: 3}: {
+					{kind: "diagnostic", name: "println", rx: regexp.MustCompile(`found`)},
+					{kind: "diagnostic", name: "", rx: regexp.MustCompile(`call of println(...)`)},
+				},
+			},
+		},
+		{
+			filename: "a/b_test.go",
+			data: `package main
+
+// Test file shouldn't mess with things
+`,
+			expected: map[key][]expectation{},
+		},
+	}
+
+	for _, test := range testCases {
+		test := test
+		t.Run(test.filename, func(t *testing.T) {
+			t.Parallel()
+
+			expectations, err := parseComments(test.filename, []byte(test.data))
+			require.NoError(t, err)
+
+			assert.Equal(t, test.expected, expectations)
+		})
+	}
+}