linters/internal/analyzers/no-literal/linter_test.go

package noliteral

import (
	"go/ast"
	"go/parser"
	"go/token"
	"path/filepath"
	"runtime"
	"testing"

	"golang.org/x/tools/go/analysis"
)

func TestAnalyzerA_n(t *testing.T) {

	_, filename, _, _ := runtime.Caller(0)
	dir := filepath.Dir(filename)

	fset := token.NewFileSet()
	f, err := parser.ParseFile(fset, filepath.Join(dir, "test-case/src/a_negative._go"), nil, parser.AllErrors)
	if err != nil {
		t.Fatal(err)
	}

	Flag := false
	pass := &analysis.Pass{
		Fset:  fset,
		Files: []*ast.File{f},
		Report: func(diag analysis.Diagnostic) {
			t.Log(diag.Message)
			Flag = true
		},
	}

	_, err = run(pass)

	if !Flag {
		t.Fail()
	}
	if err != nil {
		t.Fatal(err)
	}
}

func TestAnalyzerA_p(t *testing.T) {

	_, filename, _, _ := runtime.Caller(0)
	dir := filepath.Dir(filename)

	fset := token.NewFileSet()
	f, err := parser.ParseFile(fset, filepath.Join(dir, "test-case/src/a_positive._go"), nil, parser.AllErrors)
	if err != nil {
		t.Fatal(err)
	}

	flag := false
	pass := &analysis.Pass{
		Fset:  fset,
		Files: []*ast.File{f},
		Report: func(diag analysis.Diagnostic) {
			t.Log(diag.Message)
			flag = true
		},
	}

	_, err = run(pass)

	if flag {
		t.Fail()
	}

	if err != nil {
		t.Fatal(err)
	}
}

func TestAnalyzerB_n(t *testing.T) {

	_, filename, _, _ := runtime.Caller(0)
	dir := filepath.Dir(filename)

	fset := token.NewFileSet()
	f, err := parser.ParseFile(fset, filepath.Join(dir, "test-case/src/b_negative._go"), nil, parser.AllErrors)
	if err != nil {
		t.Fatal(err)
	}

	Flag := false
	pass := &analysis.Pass{
		Fset:  fset,
		Files: []*ast.File{f},
		Report: func(diag analysis.Diagnostic) {
			t.Log(diag.Message)
			Flag = true
		},
	}

	_, err = run(pass)

	if !Flag {
		t.Fail()
	}
	if err != nil {
		t.Fatal(err)
	}
}

func TestAnalyzerB_p(t *testing.T) {

	_, filename, _, _ := runtime.Caller(0)
	dir := filepath.Dir(filename)

	fset := token.NewFileSet()
	f, err := parser.ParseFile(fset, filepath.Join(dir, "test-case/src/b_positive._go"), nil, parser.AllErrors)
	if err != nil {
		t.Fatal(err)
	}

	flag := false
	pass := &analysis.Pass{
		Fset:  fset,
		Files: []*ast.File{f},
		Report: func(diag analysis.Diagnostic) {
			t.Log(diag.Message)
			flag = true
		},
	}

	_, err = run(pass)

	if flag {
		t.Fail()
	}

	if err != nil {
		t.Fatal(err)
	}
}

func TestAnalyzerC_n(t *testing.T) {

	_, filename, _, _ := runtime.Caller(0)
	dir := filepath.Dir(filename)

	fset := token.NewFileSet()
	f, err := parser.ParseFile(fset, filepath.Join(dir, "test-case/src/c_negative._go"), nil, parser.AllErrors)
	if err != nil {
		t.Fatal(err)
	}

	Flag := false
	pass := &analysis.Pass{
		Fset:  fset,
		Files: []*ast.File{f},
		Report: func(diag analysis.Diagnostic) {
			t.Log(diag.Message)
			Flag = true
		},
	}

	_, err = run(pass)

	if !Flag {
		t.Fail()
	}
	if err != nil {
		t.Fatal(err)
	}
}

func TestAnalyzerC_p(t *testing.T) {

	_, filename, _, _ := runtime.Caller(0)
	dir := filepath.Dir(filename)

	fset := token.NewFileSet()
	f, err := parser.ParseFile(fset, filepath.Join(dir, "test-case/src/c_positive._go"), nil, parser.AllErrors)
	if err != nil {
		t.Fatal(err)
	}

	flag := false
	pass := &analysis.Pass{
		Fset:  fset,
		Files: []*ast.File{f},
		Report: func(diag analysis.Diagnostic) {
			t.Log(diag.Message)
			flag = true
		},
	}

	_, err = run(pass)

	if flag {
		t.Fail()
	}

	if err != nil {
		t.Fatal(err)
	}
}

func TestAnalyzerD_n(t *testing.T) {

	_, filename, _, _ := runtime.Caller(0)
	dir := filepath.Dir(filename)

	fset := token.NewFileSet()
	f, err := parser.ParseFile(fset, filepath.Join(dir, "test-case/src/d_negative._go"), nil, parser.AllErrors)
	if err != nil {
		t.Fatal(err)
	}

	Flag := false
	pass := &analysis.Pass{
		Fset:  fset,
		Files: []*ast.File{f},
		Report: func(diag analysis.Diagnostic) {
			t.Log(diag.Message)
			Flag = true
		},
	}

	_, err = run(pass)

	if Flag {
		t.Fail()
	}
	if err != nil {
		t.Fatal(err)
	}
}

func TestAnalyzerD_p(t *testing.T) {

	_, filename, _, _ := runtime.Caller(0)
	dir := filepath.Dir(filename)

	fset := token.NewFileSet()
	f, err := parser.ParseFile(fset, filepath.Join(dir, "test-case/src/d_positive._go"), nil, parser.AllErrors)
	if err != nil {
		t.Fatal(err)
	}

	flag := false
	pass := &analysis.Pass{
		Fset:  fset,
		Files: []*ast.File{f},
		Report: func(diag analysis.Diagnostic) {
			t.Log(diag.Message)
			flag = true
		},
	}

	_, err = run(pass)

	if flag {
		t.Fail()
	}

	if err != nil {
		t.Fatal(err)
	}
}